Body in rustc_middle::mir - Rust (original) (raw)

pub struct Body<'tcx> {Show 19 fields
    pub basic_blocks: BasicBlocks<'tcx>,
    pub phase: MirPhase,
    pub pass_count: usize,
    pub source: MirSource<'tcx>,
    pub source_scopes: IndexVec<SourceScope, SourceScopeData<'tcx>>,
    pub coroutine: Option<Box<CoroutineInfo<'tcx>>>,
    pub local_decls: IndexVec<Local, LocalDecl<'tcx>>,
    pub user_type_annotations: CanonicalUserTypeAnnotations<'tcx>,
    pub arg_count: usize,
    pub spread_arg: Option<Local>,
    pub var_debug_info: Vec<VarDebugInfo<'tcx>>,
    pub span: Span,
    pub required_consts: Option<Vec<ConstOperand<'tcx>>>,
    pub mentioned_items: Option<Vec<Spanned<MentionedItem<'tcx>>>>,
    pub is_polymorphic: bool,
    pub injection_phase: Option<MirPhase>,
    pub tainted_by_errors: Option<ErrorGuaranteed>,
    pub coverage_info_hi: Option<Box<CoverageInfoHi>>,
    pub function_coverage_info: Option<Box<FunctionCoverageInfo>>,
}

Expand description

The lowered representation of a single function.

A list of basic blocks. References to basic block use a newtyped index type BasicBlockthat indexes into this vector.

Records how far through the “desugaring and optimization” process this particular MIR has traversed. This is particularly useful when inlining, since in that context we instantiate the promoted constants and add them to our promoted vector – but those promoted items have already been optimized, whereas ours have not. This field allows us to see the difference and forego optimization on the inlined promoted items.

How many passses we have executed since starting the current phase. Used for debug output.

A list of source scopes; these are referenced by statements and used for debuginfo. Indexed by a SourceScope.

Additional information carried by a MIR body when it is lowered from a coroutine.

Note that the coroutine drop shim, any promoted consts, and other synthetic MIR bodies that come from processing a coroutine body are not typically coroutines themselves, and should probably set this to None to avoid carrying redundant information.

Declarations of locals.

The first local is the return value pointer, followed by arg_countlocals for the function arguments, followed by any user-declared variables and temporaries.

User type annotations.

The number of arguments this function takes.

Starting at local 1, arg_count locals will be provided by the caller and can be assumed to be initialized.

If this MIR was built for a constant, this will be 0.

Mark an argument local (which must be a tuple) as getting passed as its individual components at the LLVM level.

This is used for the “rust-call” ABI.

Debug information pertaining to user variables, including captures.

A span representing this MIR, for error reporting.

Constants that are required to evaluate successfully for this MIR to be well-formed. We hold in this field all the constants we are not able to evaluate yet.None indicates that the list has not been computed yet.

This is soundness-critical, we make a guarantee that all consts syntactically mentioned in a function have successfully evaluated if the function ever gets executed at runtime.

Further items that were mentioned in this function and hence may become monomorphized, depending on optimizations. We use this to avoid optimization-dependent compile errors: the collector recursively traverses all “mentioned” items and evaluates all theirrequired_consts.None indicates that the list has not been computed yet.

This is not soundness-critical and the contents of this list are not a stable guarantee. All that’s relevant is that this set is optimization-level-independent, and that it includes everything that the collector would consider “used”. (For example, we currently compute this set after drop elaboration, so some drop calls that can never be reached are not considered “mentioned”.) See the documentation of CollectionMode incompiler/rustc_monomorphize/src/collector.rs for more context.

Does this body use generic parameters. This is used for the ConstEvaluatable check.

Note that this does not actually mean that this body is not computable right now. The repeat count in the following example is polymorphic, but can still be evaluated without knowing anything about the type parameter T.

fn test<T>() {
    let _ = [0; size_of::<*mut T>()];
}

WARNING: Do not change this flags after the MIR was originally created, even if an optimization removed the last mention of all generic params. We do not want to rely on optimizations and potentially allow things like [u8; size_of::<T>() * 0] due to this.

The phase at which this MIR should be “injected” into the compilation process.

Everything that comes before this MirPhase should be skipped.

This is only Some if the function that this body comes from was annotated with rustc_custom_mir.

Coverage information collected from THIR/MIR during MIR building, to be used by the InstrumentCoverage pass.

Only present if coverage is enabled and this function is eligible. Boxed to limit space overhead in non-coverage builds.

Per-function coverage information added by the InstrumentCoveragepass, to be used in conjunction with the coverage statements injected into this body’s blocks.

If -Cinstrument-coverage is not active, or if an individual function is not eligible for coverage, then this should always be None.