Struct rustc_codegen_llvm::context::CodegenCx

pub struct CodegenCx<'ll, 'tcx> {

    pub tcx: TyCtxt<'tcx>,
    pub check_overflow: bool,
    pub use_dll_storage_attrs: bool,
    pub tls_model: ThreadLocalMode,
    pub llmod: &'ll Module,
    pub llcx: &'ll Context,
    pub codegen_unit: &'tcx CodegenUnit<'tcx>,
    pub instances: RefCell<FxHashMap<Instance<'tcx>, &'ll Value>>,
    pub vtables: RefCell<FxHashMap<(Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>), &'ll Value>>,
    pub const_str_cache: RefCell<FxHashMap<String, &'ll Value>>,
    pub const_globals: RefCell<FxHashMap<&'ll Value, &'ll Value>>,
    pub statics_to_rauw: RefCell<Vec<(&'ll Value, &'ll Value)>>,
    pub used_statics: RefCell<Vec<&'ll Value>>,
    pub compiler_used_statics: RefCell<Vec<&'ll Value>>,
    pub type_lowering: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), TypeLowering<'ll>>>,
    pub scalar_lltypes: RefCell<FxHashMap<Ty<'tcx>, &'ll Type>>,
    pub pointee_infos: RefCell<FxHashMap<(Ty<'tcx>, Size), Option<PointeeInfo>>>,
    pub isize_ty: &'ll Type,
    pub coverage_cx: Option<CrateCoverageContext<'ll, 'tcx>>,
    pub dbg_cx: Option<CodegenUnitDebugContext<'ll, 'tcx>>,
    eh_personality: Cell<Option<&'ll Value>>,
    eh_catch_typeinfo: Cell<Option<&'ll Value>>,
    pub rust_try_fn: Cell<Option<(&'ll Type, &'ll Value)>>,
    intrinsics: RefCell<FxHashMap<&'static str, (&'ll Type, &'ll Value)>>,
    local_gen_sym_counter: Cell<usize>,
    pub renamed_statics: RefCell<FxHashMap<DefId, &'ll Value>>,
}

There is one CodegenCx per compilation unit. Each one has its own LLVM llvm::Context so that several compilation units may be optimized in parallel. All other LLVM data structures in the CodegenCx are tied to that llvm::Context.

Fields

tcx: TyCtxt<'tcx>

check_overflow: bool

use_dll_storage_attrs: bool

tls_model: ThreadLocalMode

llmod: &'ll Module

llcx: &'ll Context

codegen_unit: &'tcx CodegenUnit<'tcx>

instances: RefCell<FxHashMap<Instance<'tcx>, &'ll Value>>

Cache instances of monomorphic and polymorphic items

vtables: RefCell<FxHashMap<(Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>), &'ll Value>>

Cache generated vtables

const_str_cache: RefCell<FxHashMap<String, &'ll Value>>

Cache of constant strings,

const_globals: RefCell<FxHashMap<&'ll Value, &'ll Value>>

Cache of emitted const globals (value -> global)

statics_to_rauw: RefCell<Vec<(&'ll Value, &'ll Value)>>

List of globals for static variables which need to be passed to the LLVM function ReplaceAllUsesWith (RAUW) when codegen is complete. (We have to make sure we don’t invalidate any Values referring to constants.)

used_statics: RefCell<Vec<&'ll Value>>

Statics that will be placed in the llvm.used variable See https://llvm.org/docs/LangRef.html#the-llvm-used-global-variable for details

compiler_used_statics: RefCell<Vec<&'ll Value>>

Statics that will be placed in the llvm.compiler.used variable See https://llvm.org/docs/LangRef.html#the-llvm-compiler-used-global-variable for details

type_lowering: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), TypeLowering<'ll>>>

Mapping of non-scalar types to llvm types and field remapping if needed.

scalar_lltypes: RefCell<FxHashMap<Ty<'tcx>, &'ll Type>>

Mapping of scalar types to llvm types.

pointee_infos: RefCell<FxHashMap<(Ty<'tcx>, Size), Option<PointeeInfo>>>

isize_ty: &'ll Type

coverage_cx: Option<CrateCoverageContext<'ll, 'tcx>>

dbg_cx: Option<CodegenUnitDebugContext<'ll, 'tcx>>

eh_personality: Cell<Option<&'ll Value>>

eh_catch_typeinfo: Cell<Option<&'ll Value>>

rust_try_fn: Cell<Option<(&'ll Type, &'ll Value)>>

intrinsics: RefCell<FxHashMap<&'static str, (&'ll Type, &'ll Value)>>

local_gen_sym_counter: Cell<usize>

A counter that is used for generating local symbol names

renamed_statics: RefCell<FxHashMap<DefId, &'ll Value>>

codegen_static will sometimes create a second global variable with a different type and clear the symbol name of the original global. global_asm! needs to be able to find this new global so that it can compute the correct mangled symbol name to insert into the asm.

Implementations

impl<'ll> CodegenCx<'ll, '_>

pub fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value

pub fn const_vector(&self, elts: &[&'ll Value]) -> &'ll Value

pub fn const_bytes(&self, bytes: &[u8]) -> &'ll Value

pub fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value

impl<'ll> CodegenCx<'ll, '_>

pub(crate) fn const_bitcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value

pub(crate) fn static_addr_of_mut( &self, cv: &'ll Value, align: Align, kind: Option<&str> ) -> &'ll Value

pub(crate) fn get_static(&self, def_id: DefId) -> &'ll Value

impl<'ll, 'tcx> CodegenCx<'ll, 'tcx>

pub(crate) fn new( tcx: TyCtxt<'tcx>, codegen_unit: &'tcx CodegenUnit<'tcx>, llvm_module: &'ll ModuleLlvm ) -> Self

pub(crate) fn statics_to_rauw(&self) -> &RefCell<Vec<(&'ll Value, &'ll Value)>>

pub fn coverage_context(&self) -> Option<&CrateCoverageContext<'ll, 'tcx>>

pub(crate) fn create_used_variable_impl( &self, name: &'static CStr, values: &[&'ll Value] )

impl<'ll> CodegenCx<'ll, '_>

pub(crate) fn get_intrinsic(&self, key: &str) -> (&'ll Type, &'ll Value)

fn insert_intrinsic( &self, name: &'static str, args: Option<&[&'ll Type]>, ret: &'ll Type ) -> (&'ll Type, &'ll Value)

fn declare_intrinsic(&self, key: &str) -> Option<(&'ll Type, &'ll Value)>

pub(crate) fn eh_catch_typeinfo(&self) -> &'ll Value

impl CodegenCx<'_, '_>

pub fn generate_local_symbol_name(&self, prefix: &str) -> String

Generates a new symbol name with the given prefix. This symbol name must only be used for definitions with internal or private linkage.

impl<'ll, 'tcx> CodegenCx<'ll, 'tcx>

pub(crate) fn coverageinfo_finalize(&self)

fn get_pgo_func_name_var(&self, instance: Instance<'tcx>) -> &'ll Value

For LLVM codegen, returns a function-specific Value for a global string, to hold the function name passed to LLVM intrinsic instrprof.increment(). The Value is only created once per instance. Multiple invocations with the same instance return the same Value.

fn define_unused_fn(&self, def_id: DefId)

Functions with MIR-based coverage are normally codegenned only if called. LLVM coverage tools typically expect every function to be defined (even if unused), with at least one call to LLVM intrinsic instrprof.increment.

Codegen a small function that will never be called, with one counter that will never be incremented.

For used/called functions, the coverageinfo was already added to the function_coverage_map (keyed by function Instance) during codegen. But in this case, since the unused function was not previously codegenned, collect the coverage CodeRegions from the MIR and add them. Since the function is never called, all of its CodeRegions can be added as unreachable_regions.

impl CodegenCx<'_, '_>

pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc

Looks up debug source information about a BytePos.

impl<'ll, 'tcx> CodegenCx<'ll, 'tcx>

pub fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value

Declare a global value.

If there’s a value with the same name already declared, the function will return its Value instead.

pub fn declare_cfn( &self, name: &str, unnamed: UnnamedAddr, fn_type: &'ll Type ) -> &'ll Value

Declare a C ABI function.

Only use this for foreign function ABIs and glue. For Rust functions use declare_fn instead.

If there’s a value with the same name already declared, the function will update the declaration and return existing Value instead.

pub fn declare_entry_fn( &self, name: &str, callconv: CallConv, unnamed: UnnamedAddr, fn_type: &'ll Type ) -> &'ll Value

Declare an entry Function

The ABI of this function can change depending on the target (although for now the same as declare_cfn)

If there’s a value with the same name already declared, the function will update the declaration and return existing Value instead.

pub fn declare_fn( &self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, instance: Option<Instance<'tcx>> ) -> &'ll Value

Declare a Rust function.

If there’s a value with the same name already declared, the function will update the declaration and return existing Value instead.

pub fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value>

Declare a global with an intention to define it.

Use this function when you intend to define a global. This function will return None if the name already has a definition associated with it. In that case an error should be reported to the user, because it usually happens due to user’s fault (e.g., misuse of #[no_mangle] or #[export_name] attributes).

pub fn define_private_global(&self, ty: &'ll Type) -> &'ll Value

Declare a private global

Use this function when you intend to define a global without a name.

pub fn get_declared_value(&self, name: &str) -> Option<&'ll Value>

Gets declared value by name.

pub fn get_defined_value(&self, name: &str) -> Option<&'ll Value>

Gets defined or externally defined (AvailableExternally linkage) value by name.

impl CodegenCx<'_, '_>

pub(crate) unsafe fn should_assume_dso_local( &self, llval: &Value, is_declaration: bool ) -> bool

Whether a definition or declaration can be assumed to be local to a group of libraries that form a single DSO or executable.

impl<'ll> CodegenCx<'ll, '_>

pub(crate) fn type_named_struct(&self, name: &str) -> &'ll Type

pub(crate) fn set_struct_body( &self, ty: &'ll Type, els: &[&'ll Type], packed: bool )

pub(crate) fn type_void(&self) -> &'ll Type

pub(crate) fn type_token(&self) -> &'ll Type

pub(crate) fn type_metadata(&self) -> &'ll Type

pub(crate) fn type_ix(&self, num_bits: u64) -> &'ll Type

x Creates an integer type with the given number of bits, e.g., i24

pub(crate) fn type_vector(&self, ty: &'ll Type, len: u64) -> &'ll Type

pub(crate) fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type>

pub(crate) fn type_bool(&self) -> &'ll Type

pub(crate) fn type_int_from_ty(&self, t: IntTy) -> &'ll Type

pub(crate) fn type_uint_from_ty(&self, t: UintTy) -> &'ll Type

pub(crate) fn type_float_from_ty(&self, t: FloatTy) -> &'ll Type

pub(crate) fn type_padding_filler(&self, size: Size, align: Align) -> &'ll Type

Return an LLVM type that has at most the required alignment, and exactly the required size, as a best-effort padding array.

pub(crate) fn type_variadic_func( &self, args: &[&'ll Type], ret: &'ll Type ) -> &'ll Type

impl<'a, 'tcx> CodegenCx<'a, 'tcx>

pub fn align_of(&self, ty: Ty<'tcx>) -> Align

pub fn size_of(&self, ty: Ty<'tcx>) -> Size

pub fn size_and_align_of(&self, ty: Ty<'tcx>) -> (Size, Align)

Trait Implementations

impl<'tcx> AsmMethods<'tcx> for CodegenCx<'_, 'tcx>

fn codegen_global_asm( &self, template: &[InlineAsmTemplatePiece], operands: &[GlobalAsmOperandRef<'tcx>], options: InlineAsmOptions, _line_spans: &[Span] )

impl<'ll> BackendTypes for CodegenCx<'ll, '_>

type Value = &'ll Value

type Function = &'ll Value

type BasicBlock = &'ll BasicBlock

type Type = &'ll Type

type Funclet = Funclet<'ll>

type DIScope = &'ll Metadata

type DILocation = &'ll Metadata

type DIVariable = &'ll Metadata

impl<'ll, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'ll, 'tcx>

fn type_i1(&self) -> &'ll Type

fn type_i8(&self) -> &'ll Type

fn type_i16(&self) -> &'ll Type

fn type_i32(&self) -> &'ll Type

fn type_i64(&self) -> &'ll Type

fn type_i128(&self) -> &'ll Type

fn type_isize(&self) -> &'ll Type

fn type_f32(&self) -> &'ll Type

fn type_f64(&self) -> &'ll Type

fn type_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'ll Type

fn type_struct(&self, els: &[&'ll Type], packed: bool) -> &'ll Type

fn type_kind(&self, ty: &'ll Type) -> TypeKind

fn type_ptr(&self) -> &'ll Type

fn type_ptr_ext(&self, address_space: AddressSpace) -> &'ll Type

fn element_type(&self, ty: &'ll Type) -> &'ll Type

fn vector_length(&self, ty: &'ll Type) -> usize

Returns the number of elements in self if it is an LLVM vector type.

fn float_width(&self, ty: &'ll Type) -> usize

fn int_width(&self, ty: &'ll Type) -> u64

Retrieves the bit width of the integer type self.

fn val_ty(&self, v: &'ll Value) -> &'ll Type

fn type_array(&self, ty: &'ll Type, len: u64) -> &'ll Type

impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx>

fn const_null(&self, t: &'ll Type) -> &'ll Value

fn const_undef(&self, t: &'ll Type) -> &'ll Value

Generate an uninitialized value (matching uninitialized memory in MIR). Whether memory is initialized or not is tracked byte-for-byte.

fn const_poison(&self, t: &'ll Type) -> &'ll Value

Generate a fake value. Poison always affects the entire value, even if just a single byte is poison. This can only be used in codepaths that are already UB, i.e., UB-free Rust code (including code that e.g. copies uninit memory with MaybeUninit) can never encounter a poison value.

fn const_int(&self, t: &'ll Type, i: i64) -> &'ll Value

fn const_uint(&self, t: &'ll Type, i: u64) -> &'ll Value

fn const_uint_big(&self, t: &'ll Type, u: u128) -> &'ll Value

fn const_bool(&self, val: bool) -> &'ll Value

fn const_i16(&self, i: i16) -> &'ll Value

fn const_i32(&self, i: i32) -> &'ll Value

fn const_u32(&self, i: u32) -> &'ll Value

fn const_u64(&self, i: u64) -> &'ll Value

fn const_u128(&self, i: u128) -> &'ll Value

fn const_usize(&self, i: u64) -> &'ll Value

fn const_u8(&self, i: u8) -> &'ll Value

fn const_real(&self, t: &'ll Type, val: f64) -> &'ll Value

fn const_str(&self, s: &str) -> (&'ll Value, &'ll Value)

fn const_struct(&self, elts: &[&'ll Value], packed: bool) -> &'ll Value

fn const_to_opt_uint(&self, v: &'ll Value) -> Option<u64>

fn const_to_opt_u128(&self, v: &'ll Value, sign_ext: bool) -> Option<u128>

fn scalar_to_backend( &self, cv: Scalar, layout: Scalar, llty: &'ll Type ) -> &'ll Value

fn const_data_from_alloc(&self, alloc: ConstAllocation<'tcx>) -> Self::Value

fn const_bitcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value

fn const_ptr_byte_offset( &self, base_addr: Self::Value, offset: Size ) -> Self::Value

impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx>

fn create_function_debug_context( &self, instance: Instance<'tcx>, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, llfn: &'ll Value, mir: &Body<'tcx> ) -> Option<FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>>

Creates the function-specific debug context.

fn dbg_scope_fn( &self, instance: Instance<'tcx>, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, maybe_definition_llfn: Option<&'ll Value> ) -> &'ll DIScope

fn dbg_loc( &self, scope: &'ll DIScope, inlined_at: Option<&'ll DILocation>, span: Span ) -> &'ll DILocation

fn create_vtable_debuginfo( &self, ty: Ty<'tcx>, trait_ref: Option<PolyExistentialTraitRef<'tcx>>, vtable: Self::Value )

fn extend_scope_to_file( &self, scope_metadata: &'ll DIScope, file: &SourceFile ) -> &'ll DILexicalBlock

fn debuginfo_finalize(&self)

fn create_dbg_var( &self, variable_name: Symbol, variable_type: Ty<'tcx>, scope_metadata: &'ll DIScope, variable_kind: VariableKind, span: Span ) -> &'ll DIVariable

impl<'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'_, 'tcx>

type FnAbiOfResult = &'tcx FnAbi<'tcx, Ty<'tcx>>

The &FnAbi-wrapping type (or &FnAbi itself), which will be returned from fn_abi_of_* (see also handle_fn_abi_err).

fn handle_fn_abi_err( &self, err: FnAbiError<'tcx>, span: Span, fn_abi_request: FnAbiRequest<'tcx> ) -> !

Helper used for fn_abi_of_*, to adapt tcx.fn_abi_of_*(...) into a Self::FnAbiOfResult (which does not need to be a Result<...>).

impl HasDataLayout for CodegenCx<'_, '_>

fn data_layout(&self) -> &TargetDataLayout

impl<'tcx, 'll> HasParamEnv<'tcx> for CodegenCx<'ll, 'tcx>

fn param_env(&self) -> ParamEnv<'tcx>

impl HasTargetSpec for CodegenCx<'_, '_>

fn target_spec(&self) -> &Target

impl<'tcx> HasTyCtxt<'tcx> for CodegenCx<'_, 'tcx>

fn tcx(&self) -> TyCtxt<'tcx>

impl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'_, 'tcx>

type LayoutOfResult = TyAndLayout<'tcx, Ty<'tcx>>

The TyAndLayout-wrapping type (or TyAndLayout itself), which will be returned from layout_of (see also handle_layout_err).

fn handle_layout_err( &self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx> ) -> !

Helper used for layout_of, to adapt tcx.layout_of(...) into a Self::LayoutOfResult (which does not need to be a Result<...>).

fn layout_tcx_at_span(&self) -> Span

Span to use for tcx.at(span), from layout_of.

impl<'ll, 'tcx> LayoutTypeMethods<'tcx> for CodegenCx<'ll, 'tcx>

fn backend_type(&self, layout: TyAndLayout<'tcx>) -> &'ll Type

The backend type used for a rust type when it’s in memory, such as when it’s stack-allocated or when it’s being loaded or stored.

fn immediate_backend_type(&self, layout: TyAndLayout<'tcx>) -> &'ll Type

The backend type used for a rust type when it’s in an SSA register.

fn is_backend_immediate(&self, layout: TyAndLayout<'tcx>) -> bool

fn is_backend_scalar_pair(&self, layout: TyAndLayout<'tcx>) -> bool

fn backend_field_index(&self, layout: TyAndLayout<'tcx>, index: usize) -> u64

fn scalar_pair_element_backend_type( &self, layout: TyAndLayout<'tcx>, index: usize, immediate: bool ) -> &'ll Type

fn cast_backend_type(&self, ty: &CastTarget) -> &'ll Type

fn fn_decl_backend_type(&self, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Type

fn fn_ptr_backend_type(&self, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Type

fn reg_backend_type(&self, ty: &Reg) -> &'ll Type

fn scalar_copy_backend_type( &self, layout: TyAndLayout<'tcx> ) -> Option<Self::Type>

A type that can be used in a super::BuilderMethods::load + super::BuilderMethods::store pair to implement a typed copy, such as a MIR *_0 = *_1.

impl<'ll, 'tcx> MiscMethods<'tcx> for CodegenCx<'ll, 'tcx>

fn vtables( &self ) -> &RefCell<FxHashMap<(Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>), &'ll Value>>

fn get_fn(&self, instance: Instance<'tcx>) -> &'ll Value

fn get_fn_addr(&self, instance: Instance<'tcx>) -> &'ll Value

fn eh_personality(&self) -> &'ll Value

fn sess(&self) -> &Session

fn check_overflow(&self) -> bool

fn codegen_unit(&self) -> &'tcx CodegenUnit<'tcx>

fn set_frame_pointer_type(&self, llfn: &'ll Value)

fn apply_target_cpu_attr(&self, llfn: &'ll Value)

fn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function>

Declares the extern “C” main function for the entry point. Returns None if the symbol already exists.

impl<'tcx> PreDefineMethods<'tcx> for CodegenCx<'_, 'tcx>

fn predefine_static( &self, def_id: DefId, linkage: Linkage, visibility: Visibility, symbol_name: &str )

fn predefine_fn( &self, instance: Instance<'tcx>, linkage: Linkage, visibility: Visibility, symbol_name: &str )

impl<'ll> StaticMethods for CodegenCx<'ll, '_>

fn add_used_global(&self, global: &'ll Value)

Add a global value to a list to be stored in the llvm.used variable, an array of ptr.

fn add_compiler_used_global(&self, global: &'ll Value)

Add a global value to a list to be stored in the llvm.compiler.used variable, an array of ptr.

fn static_addr_of( &self, cv: &'ll Value, align: Align, kind: Option<&str> ) -> &'ll Value

fn codegen_static(&self, def_id: DefId, is_mutable: bool)

impl<'ll, 'tcx> TypeMembershipMethods<'tcx> for CodegenCx<'ll, 'tcx>

fn add_type_metadata(&self, function: &'ll Value, typeid: String)

fn set_type_metadata(&self, function: &'ll Value, typeid: String)

fn typeid_metadata(&self, typeid: String) -> Option<&'ll Value>

fn add_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32)

fn set_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 784 bytes