Struct FullCx

pub(crate) struct FullCx<'ll, 'tcx> {

    pub tcx: TyCtxt<'tcx>,
    pub scx: GenericCx<'ll, SCx<'ll>>,
    pub use_dll_storage_attrs: bool,
    pub tls_model: ThreadLocalMode,
    pub codegen_unit: &'tcx CodegenUnit<'tcx>,
    pub instances: RefCell<FxHashMap<Instance<'tcx>, &'ll Value>>,
    pub vtables: RefCell<FxHashMap<(Ty<'tcx>, Option<ExistentialTraitRef<'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>), &'ll Type>>,
    pub scalar_lltypes: RefCell<FxHashMap<Ty<'tcx>, &'ll Type>>,
    pub coverage_cx: Option<CguCoverageContext<'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>>,
}

Fields

tcx: TyCtxt<'tcx>

scx: GenericCx<'ll, SCx<'ll>>

use_dll_storage_attrs: bool

tls_model: ThreadLocalMode

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<ExistentialTraitRef<'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>), &'ll Type>>

Mapping of non-scalar types to llvm types.

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

Mapping of scalar types to llvm types.

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

Extra per-CGU codegen state needed when coverage instrumentation is enabled.

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.

Methods from Deref<Target = GenericCx<'ll, SCx<'ll>>>

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

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

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

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

pub(crate) fn const_pointercast( &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

Create a global variable.

The returned global variable is a pointer in the default address space for globals. Fails if a symbol with the given name already exists.

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

Create a global constant.

The returned global variable is a pointer in the default address space for globals.

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

fn get_static_inner(&self, def_id: DefId, llty: &'ll Type) -> &'ll Value

fn codegen_static_item(&self, def_id: DefId)

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

pub(crate) fn coverage_cx(&self) -> &CguCoverageContext<'ll, 'tcx>

Extra state that is only available when coverage instrumentation is enabled.

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

pub(crate) fn get_metadata_value(&self, metadata: &'ll Metadata) -> &'ll Value

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

pub(crate) fn get_md_kind_id(&self, name: &str) -> MetadataKindId

pub(crate) fn create_metadata(&self, name: String) -> Option<&'ll Metadata>

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

pub(crate) 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.

pub(crate) fn set_metadata<'a>( &self, val: &'a Value, kind_id: impl Into<MetadataKindId>, md: &'ll Metadata, )

A wrapper for llvm::LLVMSetMetadata, but it takes Metadata as a parameter instead of Value.

pub(crate) fn coverageinfo_finalize(&self)

fn covfun_section_name(&self) -> &CStr

Returns the section name to use when embedding per-function coverage information in the object file, according to the target’s object file format. LLVM’s coverage tools use information from this section when producing coverage reports.

Typical values are:

• __llvm_covfun on Linux
• __LLVM_COV,__llvm_covfun on macOS (includes __LLVM_COV, segment prefix)
• .lcovfun$M on Windows (includes $M sorting suffix)

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 lookup_debug_loc(&self, pos: BytePos) -> DebugLoc

Looks up debug source information about a BytePos.

fn create_template_type_parameter( &self, name: &str, actual_type_metadata: &'ll DIType, ) -> &'ll DITemplateTypeParameter

pub(crate) 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(crate) 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(crate) 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(crate) 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(crate) 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(crate) 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(crate) fn get_declared_value(&self, name: &str) -> Option<&'ll Value>

Gets declared value by name.

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

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

pub(crate) fn 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. Marks the local as DSO if so.

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

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 llcx(&self) -> &'ll Context

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

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

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

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

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

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

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

Trait Implementations

impl<'ll> Borrow<SCx<'ll>> for FullCx<'ll, '_>

fn borrow(&self) -> &SCx<'ll>

Immutably borrows from an owned value.

impl<'ll, 'tcx> Deref for FullCx<'ll, 'tcx>

type Target = GenericCx<'ll, SCx<'ll>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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: 816 bytes