MIR (Mid-level Intermediate Representation)

/// The core MIR data structure representing a function body
pub struct Body<'tcx> {
    /// Basic blocks that make up the control flow graph
    pub basic_blocks: BasicBlocks<'tcx>,
    
    /// Local variables (including arguments and return place)
    pub local_decls: IndexVec<Local, LocalDecl<'tcx>>,
    
    /// User type annotations
    pub user_type_annotations: IndexVec<UserTypeAnnotationIndex, UserTypeAnnotation<'tcx>>,
    
    /// Current compilation phase
    pub phase: MirPhase,
    
    // ... and more fields
}

pub enum MirPhase {
    /// Initial MIR constructed from HIR
    Built,
    
    /// Analysis phase (type checking, borrow checking)
    Analysis(AnalysisPhase),
    
    /// Runtime optimization phase
    Runtime(RuntimePhase),
}

pub enum RuntimePhase {
    Initial,
    PostCleanup,
    Optimized,
}

pub struct BasicBlockData<'tcx> {
    /// Sequence of statements in this block
    pub statements: Vec<Statement<'tcx>>,
    
    /// Terminator instruction (how control flow exits this block)
    pub terminator: Option<Terminator<'tcx>>,
    
    /// True if this block is reachable
    pub is_cleanup: bool,
}

pub enum StatementKind<'tcx> {
    /// Assign the rvalue to the lvalue
    Assign(Box<(Place<'tcx>, Rvalue<'tcx>)>),
    
    /// Mark a local as live at this point
    StorageLive(Local),
    
    /// Mark a local as dead at this point
    StorageDead(Local),
    
    /// Set discriminant for an enum
    SetDiscriminant { place: Box<Place<'tcx>>, variant_index: VariantIdx },
    
    /// No-op (used during optimization)
    Nop,
    
    // ... and more
}

pub enum TerminatorKind<'tcx> {
    /// Goto a single successor block
    Goto { target: BasicBlock },
    
    /// Branch based on condition
    SwitchInt { discr: Operand<'tcx>, targets: SwitchTargets },
    
    /// Return from function
    Return,
    
    /// Abort the program
    Unreachable,
    
    /// Drop a value
    Drop { place: Place<'tcx>, target: BasicBlock, unwind: UnwindAction },
    
    /// Call a function
    Call {
        func: Operand<'tcx>,
        args: Vec<Operand<'tcx>>,
        destination: Place<'tcx>,
        target: Option<BasicBlock>,
        unwind: UnwindAction,
        // ... and more fields
    },
    
    /// Assert a condition
    Assert {
        cond: Operand<'tcx>,
        expected: bool,
        msg: Box<AssertMessage<'tcx>>,
        target: BasicBlock,
        unwind: UnwindAction,
    },
    
    // ... and more
}

pub struct Place<'tcx> {
    pub local: Local,
    pub projection: &'tcx [PlaceElem<'tcx>],
}

pub enum PlaceElem<'tcx> {
    /// Dereference a pointer
    Deref,
    
    /// Access a field
    Field(FieldIdx, Ty<'tcx>),
    
    /// Index into an array
    Index(Local),
    
    /// Downcast to a specific enum variant
    Downcast(Option<Symbol>, VariantIdx),
    
    // ... and more
}

pub enum Rvalue<'tcx> {
    /// Read the value from a place
    Use(Operand<'tcx>),
    
    /// Perform a binary operation
    BinaryOp(BinOp, Box<(Operand<'tcx>, Operand<'tcx>)>),
    
    /// Perform a unary operation
    UnaryOp(UnOp, Operand<'tcx>),
    
    /// Cast a value
    Cast(CastKind, Operand<'tcx>, Ty<'tcx>),
    
    /// Create a reference
    Ref(Region<'tcx>, BorrowKind, Place<'tcx>),
    
    /// Create an aggregate (struct, tuple, array)
    Aggregate(Box<AggregateKind<'tcx>>, Vec<Operand<'tcx>>),
    
    // ... and more
}

// From rustc_mir_build/src/lib.rs
// The builder module constructs MIR from HIR

pub fn provide(providers: &mut Providers) {
    providers.queries.check_match = thir::pattern::check_match;
    providers.queries.lit_to_const = thir::constant::lit_to_const;
    providers.hooks.build_mir_inner_impl = builder::build_mir_inner_impl;
}

declare_passes! {
    mod abort_unwinding_calls : AbortUnwindingCalls;
    mod add_call_guards : AddCallGuards { AllCallEdges, CriticalCallEdges };
    mod cleanup_post_borrowck : CleanupPostBorrowck;
    mod copy_prop : CopyProp;
    mod dataflow_const_prop : DataflowConstProp;
    mod dead_store_elimination : DeadStoreElimination { Initial, Final };
    pub mod inline : Inline, ForceInline;
    mod gvn : GVN;
    mod jump_threading : JumpThreading;
    // ... many more passes
}

// Source code:
fn add(x: i32, y: i32) -> i32 {
    x + y
}

// Simplified MIR:
fn add(_1: i32, _2: i32) -> i32 {
    let mut _0: i32;
    
    bb0: {
        _0 = Add(_1, _2);
        return;
    }
}

// Source code:
fn max(x: i32, y: i32) -> i32 {
    if x > y {
        x
    } else {
        y
    }
}

// Simplified MIR:
fn max(_1: i32, _2: i32) -> i32 {
    let mut _0: i32;
    let mut _3: bool;
    
    bb0: {
        _3 = Gt(_1, _2);
        switchInt(move _3) -> [0: bb2, otherwise: bb1];
    }
    
    bb1: {
        _0 = _1;
        goto -> bb3;
    }
    
    bb2: {
        _0 = _2;
        goto -> bb3;
    }
    
    bb3: {
        return;
    }
}

# Emit MIR for all functions
rustc --emit mir main.rs

# Emit MIR in graphviz format
rustc -Z dump-mir-graphviz main.rs