Struct rustc_codegen_ssa::mir::FunctionCx
source · pub struct FunctionCx<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {Show 16 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: &'tcx FnAbi<'tcx, Ty<'tcx>>,
personality_slot: Option<PlaceRef<'tcx, Bx::Value>>,
cached_llbbs: IndexVec<BasicBlock, Option<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>,
double_unwind_guard: 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>>,
}
Expand description
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: &'tcx 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.
cached_llbbs: IndexVec<BasicBlock, Option<Bx::BasicBlock>>
A backend BasicBlock
for each MIR BasicBlock
, created lazily
as-needed (e.g. RPO reaching it or another block branching to it).
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 at the same time as the landing_pads
entry for the
funclets’ head block, i.e. when needed by an unwind / cleanup_ret
edge.
landing_pads: IndexVec<BasicBlock, Option<Bx::BasicBlock>>
This stores the cached landing/cleanup pad block for a given BB.
unreachable_block: Option<Bx::BasicBlock>
Cached unreachable block
double_unwind_guard: Option<Bx::BasicBlock>
Cached double unwind guarding 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
- we should not take its address using the
- 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
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
Codegen implementations for some terminator variants.
sourcefn codegen_resume_terminator(
&mut self,
helper: TerminatorCodegenHelper<'tcx>,
bx: Bx
)
fn codegen_resume_terminator(
&mut self,
helper: TerminatorCodegenHelper<'tcx>,
bx: Bx
)
Generates code for a Resume
terminator.
fn codegen_switchint_terminator(
&mut self,
helper: TerminatorCodegenHelper<'tcx>,
bx: Bx,
discr: &Operand<'tcx>,
switch_ty: Ty<'tcx>,
targets: &SwitchTargets
)
fn codegen_return_terminator(&mut self, bx: Bx)
fn codegen_drop_terminator(
&mut self,
helper: TerminatorCodegenHelper<'tcx>,
bx: Bx,
location: Place<'tcx>,
target: BasicBlock,
unwind: Option<BasicBlock>
)
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>
)
fn codegen_abort_terminator(
&mut self,
helper: TerminatorCodegenHelper<'tcx>,
bx: Bx,
terminator: &Terminator<'tcx>
)
sourcefn codegen_panic_intrinsic(
&mut self,
helper: &TerminatorCodegenHelper<'tcx>,
bx: &mut Bx,
intrinsic: Option<Symbol>,
instance: Option<Instance<'tcx>>,
source_info: SourceInfo,
target: Option<BasicBlock>,
cleanup: Option<BasicBlock>
) -> bool
fn codegen_panic_intrinsic(
&mut self,
helper: &TerminatorCodegenHelper<'tcx>,
bx: &mut Bx,
intrinsic: Option<Symbol>,
instance: Option<Instance<'tcx>>,
source_info: SourceInfo,
target: Option<BasicBlock>,
cleanup: Option<BasicBlock>
) -> bool
Returns true
if this is indeed a panic intrinsic and codegen is done.
fn codegen_call_terminator(
&mut self,
helper: TerminatorCodegenHelper<'tcx>,
bx: Bx,
terminator: &Terminator<'tcx>,
func: &Operand<'tcx>,
args: &[Operand<'tcx>],
destination: Place<'tcx>,
target: Option<BasicBlock>,
cleanup: Option<BasicBlock>,
fn_span: Span
)
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>,
cleanup: Option<BasicBlock>,
instance: Instance<'_>
)
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn codegen_block(&mut self, bb: BasicBlock)
fn codegen_terminator(
&mut self,
bx: Bx,
bb: BasicBlock,
terminator: &'tcx Terminator<'tcx>
)
fn codegen_argument(
&mut self,
bx: &mut Bx,
op: OperandRef<'tcx, Bx::Value>,
llargs: &mut Vec<Bx::Value>,
arg: &ArgAbi<'tcx, Ty<'tcx>>
)
fn codegen_arguments_untupled(
&mut self,
bx: &mut Bx,
operand: &Operand<'tcx>,
llargs: &mut Vec<Bx::Value>,
args: &[ArgAbi<'tcx, Ty<'tcx>>]
) -> usize
fn get_caller_location(
&mut self,
bx: &mut Bx,
source_info: SourceInfo
) -> OperandRef<'tcx, Bx::Value>
fn get_personality_slot(&mut self, bx: &mut Bx) -> PlaceRef<'tcx, Bx::Value>
sourcefn landing_pad_for(&mut self, bb: BasicBlock) -> Bx::BasicBlock
fn landing_pad_for(&mut self, bb: BasicBlock) -> Bx::BasicBlock
Returns the landing/cleanup pad wrapper around the given basic block.
fn landing_pad_for_uncached(&mut self, bb: BasicBlock) -> Bx::BasicBlock
fn landing_pad_type(&self) -> Bx::Type
fn unreachable_block(&mut self) -> Bx::BasicBlock
fn double_unwind_guard(&mut self) -> Bx::BasicBlock
sourcepub fn llbb(&mut self, bb: BasicBlock) -> Bx::BasicBlock
pub fn llbb(&mut self, bb: BasicBlock) -> Bx::BasicBlock
Get the backend BasicBlock
for a MIR BasicBlock
, either already
cached in self.cached_llbbs
, or created on demand (and cached).
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>
fn codegen_transmute(&mut self, bx: &mut Bx, src: &Operand<'tcx>, dst: Place<'tcx>)
fn codegen_transmute_into(
&mut self,
bx: &mut Bx,
src: &Operand<'tcx>,
dst: PlaceRef<'tcx, Bx::Value>
)
fn store_return(
&mut self,
bx: &mut Bx,
dest: ReturnDest<'tcx, Bx::Value>,
ret_abi: &ArgAbi<'tcx, Ty<'tcx>>,
llval: Bx::Value
)
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn eval_mir_constant_to_operand(
&self,
bx: &mut Bx,
constant: &Constant<'tcx>
) -> Result<OperandRef<'tcx, Bx::Value>, ErrorHandled>
pub fn eval_mir_constant(
&self,
constant: &Constant<'tcx>
) -> Result<ConstValue<'tcx>, ErrorHandled>
sourcepub fn simd_shuffle_indices(
&mut self,
bx: &Bx,
span: Span,
ty: Ty<'tcx>,
constant: Result<ConstValue<'tcx>, ErrorHandled>
) -> (Bx::Value, Ty<'tcx>)
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
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn codegen_coverage(&self, bx: &mut Bx, coverage: Coverage, scope: SourceScope)
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn set_debug_loc(&self, bx: &mut Bx, source_info: SourceInfo)
fn dbg_loc(&self, source_info: SourceInfo) -> Option<Bx::DILocation>
fn adjusted_span_and_dbg_scope(
&self,
source_info: SourceInfo
) -> Option<(Bx::DIScope, Option<Bx::DILocation>, Span)>
sourcefn adjust_span_for_debugging(&self, span: Span) -> Span
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 (when the macro is
annotated with #[collapse_debuginfo]
or when -Zdebug-macros
is provided).
fn spill_operand_to_stack(
operand: &OperandRef<'tcx, Bx::Value>,
name: Option<String>,
bx: &mut Bx
) -> PlaceRef<'tcx, Bx::Value>
sourcepub fn debug_introduce_local(&self, bx: &mut Bx, local: Local)
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)
sourcepub fn compute_per_local_var_debug_info(
&self,
bx: &mut Bx
) -> Option<IndexVec<Local, Vec<PerLocalVarDebugInfo<'tcx, Bx::DIVariable>>>>
pub fn compute_per_local_var_debug_info(
&self,
bx: &mut Bx
) -> Option<IndexVec<Local, Vec<PerLocalVarDebugInfo<'tcx, Bx::DIVariable>>>>
Partition all VarDebugInfo
in self.mir
, by their base Local
.
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
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
)
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
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>
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
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>
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
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>)
fn evaluate_array_len(&mut self, bx: &mut Bx, place: Place<'tcx>) -> Bx::Value
sourcefn 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>)
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>
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn rvalue_creates_operand(&self, rvalue: &Rvalue<'tcx>, span: Span) -> bool
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn codegen_statement(&mut self, bx: Bx, statement: &Statement<'tcx>) -> Bx
sourceimpl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx>
pub fn monomorphize<T>(&self, value: T) -> Twhere
T: Copy + TypeFoldable<'tcx>,
Auto Trait Implementations
impl<'a, 'tcx, Bx> !RefUnwindSafe for FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx> !Send for FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx> !Sync for FunctionCx<'a, 'tcx, Bx>
impl<'a, 'tcx, Bx> Unpin for FunctionCx<'a, 'tcx, Bx>where
<Bx as BackendTypes>::BasicBlock: Unpin,
<Bx as BackendTypes>::DILocation: Unpin,
<Bx as BackendTypes>::DIScope: Unpin,
<Bx as BackendTypes>::DIVariable: Unpin,
<Bx as BackendTypes>::Funclet: Unpin,
<Bx as BackendTypes>::Function: Unpin,
<Bx as BackendTypes>::Value: Unpin,
impl<'a, 'tcx, Bx> !UnwindSafe for FunctionCx<'a, 'tcx, Bx>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Layout
Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.