Struct rustc_codegen_ssa::mir::FunctionCx

pub struct FunctionCx<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
    instance: Instance<'tcx>,
    mir: &'tcx Body<'tcx>,
    debug_context: Option<FunctionDebugContext<Bx::DIScope, Bx::DILocation>>,
    llfn: Bx::Function,
    cx: &'a Bx::CodegenCx,
    fn_abi: FnAbi<'tcx, Ty<'tcx>>,
    personality_slot: Option<PlaceRef<'tcx, Bx::Value>>,
    blocks: IndexVec<BasicBlock, Bx::BasicBlock>,
    cleanup_kinds: IndexVec<BasicBlock, CleanupKind>,
    funclets: IndexVec<BasicBlock, Option<Bx::Funclet>>,
    landing_pads: IndexVec<BasicBlock, Option<Bx::BasicBlock>>,
    unreachable_block: Option<Bx::BasicBlock>,
    locals: IndexVec<Local, LocalRef<'tcx, Bx::Value>>,
    per_local_var_debug_info: Option<IndexVec<Local, Vec<PerLocalVarDebugInfo<'tcx, Bx::DIVariable>>>>,
    caller_location: Option<OperandRef<'tcx, Bx::Value>>,
}

Master context for codegenning from MIR.

Fields

instance: Instance<'tcx>

mir: &'tcx Body<'tcx>

debug_context: Option<FunctionDebugContext<Bx::DIScope, Bx::DILocation>>

llfn: Bx::Function

cx: &'a Bx::CodegenCx

fn_abi: FnAbi<'tcx, Ty<'tcx>>

personality_slot: Option<PlaceRef<'tcx, Bx::Value>>

When unwinding is initiated, we have to store this personality value somewhere so that we can load it and re-use it in the resume instruction. The personality is (afaik) some kind of value used for C++ unwinding, which must filter by type: we don't really care about it very much. Anyway, this value contains an alloca into which the personality is stored and then later loaded when generating the DIVERGE_BLOCK.

blocks: IndexVec<BasicBlock, Bx::BasicBlock>

A Block for each MIR BasicBlock

cleanup_kinds: IndexVec<BasicBlock, CleanupKind>

The funclet status of each basic block

funclets: IndexVec<BasicBlock, Option<Bx::Funclet>>

When targeting MSVC, this stores the cleanup info for each funclet BB. This is initialized as we compute the funclets' head block in RPO.

landing_pads: IndexVec<BasicBlock, Option<Bx::BasicBlock>>

This stores the landing-pad block for a given BB, computed lazily on GNU and eagerly on MSVC.

unreachable_block: Option<Bx::BasicBlock>

Cached unreachable block

locals: IndexVec<Local, LocalRef<'tcx, Bx::Value>>

The location where each MIR arg/var/tmp/ret is stored. This is usually an PlaceRef representing an alloca, but not always: sometimes we can skip the alloca and just store the value directly using an OperandRef, which makes for tighter LLVM IR. The conditions for using an OperandRef are as follows:

• the type of the local must be judged "immediate" by is_llvm_immediate
• the operand must never be referenced indirectly
  • we should not take its address using the & operator
  • nor should it appear in a place path like tmp.a
• the operand must be defined by an rvalue that can generate immediate values

Avoiding allocs can also be important for certain intrinsics, notably expect.

per_local_var_debug_info: Option<IndexVec<Local, Vec<PerLocalVarDebugInfo<'tcx, Bx::DIVariable>>>>

All VarDebugInfo from the MIR body, partitioned by Local. This is None if no var#[non_exhaustive]iable debuginfo/names are needed.

caller_location: Option<OperandRef<'tcx, Bx::Value>>

Caller location propagated if this function has #[track_caller].

Implementations

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

Codegen implementations for some terminator variants.

pub(in mir::block) fn codegen_resume_terminator(
    &mut self,
    helper: TerminatorCodegenHelper<'tcx>,
    bx: Bx
)

Generates code for a Resume terminator.

pub(in mir::block) fn codegen_switchint_terminator(
    &mut self,
    helper: TerminatorCodegenHelper<'tcx>,
    bx: Bx,
    discr: &Operand<'tcx>,
    switch_ty: Ty<'tcx>,
    targets: &SwitchTargets
)

pub(in mir::block) fn codegen_return_terminator(
    &mut self,
    bx: Bx
)

pub(in mir::block) fn codegen_drop_terminator(
    &mut self,
    helper: TerminatorCodegenHelper<'tcx>,
    bx: Bx,
    location: Place<'tcx>,
    target: BasicBlock,
    unwind: Option<BasicBlock>
)

pub(in mir::block) fn codegen_assert_terminator(
    &mut self,
    helper: TerminatorCodegenHelper<'tcx>,
    bx: Bx,
    terminator: &Terminator<'tcx>,
    cond: &Operand<'tcx>,
    expected: bool,
    msg: &AssertMessage<'tcx>,
    target: BasicBlock,
    cleanup: Option<BasicBlock>
)

pub(in mir::block) fn codegen_panic_intrinsic(
    &mut self,
    helper: &TerminatorCodegenHelper<'tcx>,
    bx: &mut Bx,
    intrinsic: Option<Symbol>,
    instance: Option<Instance<'tcx>>,
    source_info: SourceInfo,
    destination: &Option<(Place<'tcx>, BasicBlock)>,
    cleanup: Option<BasicBlock>
) -> bool

Returns true if this is indeed a panic intrinsic and codegen is done.

pub(in mir::block) fn codegen_call_terminator(
    &mut self,
    helper: TerminatorCodegenHelper<'tcx>,
    bx: Bx,
    terminator: &Terminator<'tcx>,
    func: &Operand<'tcx>,
    args: &Vec<Operand<'tcx>>,
    destination: &Option<(Place<'tcx>, BasicBlock)>,
    cleanup: Option<BasicBlock>,
    fn_span: Span
)

pub(in mir::block) fn codegen_asm_terminator(
    &mut self,
    helper: TerminatorCodegenHelper<'tcx>,
    bx: Bx,
    terminator: &Terminator<'tcx>,
    template: &[InlineAsmTemplatePiece],
    operands: &[InlineAsmOperand<'tcx>],
    options: InlineAsmOptions,
    line_spans: &[Span],
    destination: Option<BasicBlock>
)

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn codegen_block(&mut self, bb: BasicBlock)

pub(in mir::block) fn codegen_terminator(
    &mut self,
    bx: Bx,
    bb: BasicBlock,
    terminator: &'tcx Terminator<'tcx>
)

pub(in mir::block) fn codegen_argument(
    &mut self,
    bx: &mut Bx,
    op: OperandRef<'tcx, Bx::Value>,
    llargs: &mut Vec<Bx::Value>,
    arg: &ArgAbi<'tcx, Ty<'tcx>>
)

pub(in mir::block) fn codegen_arguments_untupled(
    &mut self,
    bx: &mut Bx,
    operand: &Operand<'tcx>,
    llargs: &mut Vec<Bx::Value>,
    args: &[ArgAbi<'tcx, Ty<'tcx>>]
)

pub(in mir::block) fn get_caller_location(
    &mut self,
    bx: &mut Bx,
    source_info: SourceInfo
) -> OperandRef<'tcx, Bx::Value>

pub(in mir::block) fn get_personality_slot(
    &mut self,
    bx: &mut Bx
) -> PlaceRef<'tcx, Bx::Value>

pub(in mir::block) fn landing_pad_to(
    &mut self,
    target_bb: BasicBlock
) -> Bx::BasicBlock

Returns the landing-pad wrapper around the given basic block.

No-op in MSVC SEH scheme.

pub(in mir::block) fn landing_pad_uncached(
    &mut self,
    target_bb: Bx::BasicBlock
) -> Bx::BasicBlock

pub(in mir::block) fn landing_pad_type(
    &self
) -> Bx::Type

pub(in mir::block) fn unreachable_block(
    &mut self
) -> Bx::BasicBlock

pub fn new_block(&self, name: &str) -> Bx

pub fn build_block(&self, bb: BasicBlock) -> Bx

pub(in mir::block) fn make_return_dest(
    &mut self,
    bx: &mut Bx,
    dest: Place<'tcx>,
    fn_ret: &ArgAbi<'tcx, Ty<'tcx>>,
    llargs: &mut Vec<Bx::Value>,
    is_intrinsic: bool
) -> ReturnDest<'tcx, Bx::Value>

pub(in mir::block) fn codegen_transmute(
    &mut self,
    bx: &mut Bx,
    src: &Operand<'tcx>,
    dst: Place<'tcx>
)

pub(in mir::block) fn codegen_transmute_into(
    &mut self,
    bx: &mut Bx,
    src: &Operand<'tcx>,
    dst: PlaceRef<'tcx, Bx::Value>
)

pub(in mir::block) fn store_return(
    &mut self,
    bx: &mut Bx,
    dest: ReturnDest<'tcx, Bx::Value>,
    ret_abi: &ArgAbi<'tcx, Ty<'tcx>>,
    llval: Bx::Value
)

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn eval_mir_constant_to_operand(
    &mut self,
    bx: &mut Bx,
    constant: &Constant<'tcx>
) -> Result<OperandRef<'tcx, Bx::Value>, ErrorHandled>

pub fn eval_mir_constant(
    &mut self,
    constant: &Constant<'tcx>
) -> Result<ConstValue<'tcx>, ErrorHandled>

pub fn simd_shuffle_indices(
    &mut self,
    bx: &Bx,
    span: Span,
    ty: Ty<'tcx>,
    constant: Result<ConstValue<'tcx>, ErrorHandled>
) -> (Bx::Value, Ty<'tcx>)

process constant containing SIMD shuffle indices

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn codegen_coverage(&self, bx: &mut Bx, coverage: Coverage)

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn set_debug_loc(&self, bx: &mut Bx, source_info: SourceInfo)

pub(in mir::debuginfo) fn dbg_loc(
    &self,
    source_info: SourceInfo
) -> Option<Bx::DILocation>

pub(in mir::debuginfo) fn adjusted_span_and_dbg_scope(
    &self,
    source_info: SourceInfo
) -> Option<(Bx::DIScope, Option<Bx::DILocation>, Span)>

pub(in mir::debuginfo) fn adjust_span_for_debugging(
    &self,
    span: Span
) -> Span

In order to have a good line stepping behavior in debugger, we overwrite debug locations of macro expansions with that of the outermost expansion site (unless the crate is being compiled with -Z debug-macros).

pub fn debug_introduce_local(&self, bx: &mut Bx, local: Local)

Apply debuginfo and/or name, after creating the alloca for a local, or initializing the local with an operand (whichever applies).

pub fn debug_introduce_locals(&self, bx: &mut Bx)

pub fn compute_per_local_var_debug_info(
    &self
) -> Option<IndexVec<Local, Vec<PerLocalVarDebugInfo<'tcx, Bx::DIVariable>>>>

Partition all VarDebugInfo in self.mir, by their base Local.

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn codegen_intrinsic_call(
    bx: &mut Bx,
    instance: Instance<'tcx>,
    fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
    args: &[OperandRef<'tcx, Bx::Value>],
    llresult: Bx::Value,
    span: Span
)

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub(in mir::operand) fn maybe_codegen_consume_direct(
    &mut self,
    bx: &mut Bx,
    place_ref: PlaceRef<'tcx>
) -> Option<OperandRef<'tcx, Bx::Value>>

pub fn codegen_consume(
    &mut self,
    bx: &mut Bx,
    place_ref: PlaceRef<'tcx>
) -> OperandRef<'tcx, Bx::Value>

pub fn codegen_operand(
    &mut self,
    bx: &mut Bx,
    operand: &Operand<'tcx>
) -> OperandRef<'tcx, Bx::Value>

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn codegen_place(
    &mut self,
    bx: &mut Bx,
    place_ref: PlaceRef<'tcx>
) -> PlaceRef<'tcx, Bx::Value>

pub fn monomorphized_place_ty(&self, place_ref: PlaceRef<'tcx>) -> Ty<'tcx>

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn codegen_rvalue(
    &mut self,
    bx: Bx,
    dest: PlaceRef<'tcx, Bx::Value>,
    rvalue: &Rvalue<'tcx>
) -> Bx

pub fn codegen_rvalue_unsized(
    &mut self,
    bx: Bx,
    indirect_dest: PlaceRef<'tcx, Bx::Value>,
    rvalue: &Rvalue<'tcx>
) -> Bx

pub fn codegen_rvalue_operand(
    &mut self,
    bx: Bx,
    rvalue: &Rvalue<'tcx>
) -> (Bx, OperandRef<'tcx, Bx::Value>)

pub(in mir::rvalue) fn evaluate_array_len(
    &mut self,
    bx: &mut Bx,
    place: Place<'tcx>
) -> Bx::Value

pub(in mir::rvalue) fn codegen_place_to_pointer(
    &mut self,
    bx: Bx,
    place: Place<'tcx>,
    mk_ptr_ty: impl FnOnce(TyCtxt<'tcx>, Ty<'tcx>) -> Ty<'tcx>
) -> (Bx, OperandRef<'tcx, Bx::Value>)

Codegen an Rvalue::AddressOf or Rvalue::Ref

pub fn codegen_scalar_binop(
    &mut self,
    bx: &mut Bx,
    op: BinOp,
    lhs: Bx::Value,
    rhs: Bx::Value,
    input_ty: Ty<'tcx>
) -> Bx::Value

pub fn codegen_fat_ptr_binop(
    &mut self,
    bx: &mut Bx,
    op: BinOp,
    lhs_addr: Bx::Value,
    lhs_extra: Bx::Value,
    rhs_addr: Bx::Value,
    rhs_extra: Bx::Value,
    _input_ty: Ty<'tcx>
) -> Bx::Value

pub fn codegen_scalar_checked_binop(
    &mut self,
    bx: &mut Bx,
    op: BinOp,
    lhs: Bx::Value,
    rhs: Bx::Value,
    input_ty: Ty<'tcx>
) -> OperandValue<Bx::Value>

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn rvalue_creates_operand(&self, rvalue: &Rvalue<'tcx>, span: Span) -> bool

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn codegen_statement(&mut self, bx: Bx, statement: &Statement<'tcx>) -> Bx

impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>

pub fn monomorphize<T>(&self, value: T) -> T where
    T: Copy + TypeFoldable<'tcx>,