Struct rustc_codegen_llvm::context::CodegenCx

source · 
pub struct CodegenCx<'ll, 'tcx> {
Show 27 fields
    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_unsized: RefCell<FxHashMap<&'ll Value, &'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>>,

}
Expand description

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_unsized: RefCell<FxHashMap<&'ll Value, &'ll Value>>

Reverse-direction for const ptrs cast from globals.

Key is a Value holding a *T, Val is a Value holding a *[T].

Needed because LLVM loses pointer->pointee association when we ptrcast, and we have to ptrcast during codegen of a [T] const because we form a slice, a (*T,usize) pair, not a pointer to an LLVM array type. Similar for trait objects.

§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§

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

Looks up debug source information about a BytePos.

Declare a global value.

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

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.

source

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.

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.

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).

Declare a private global

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

Gets declared value by name.

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

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

source

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

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

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

Trait Implementations§

Returns the number of elements in self if it is a LLVM vector type.
Retrieves the bit width of the integer type self.

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. The first CodeRegion is used to add a single counter, with the same counter ID used in the injected instrprof.increment intrinsic call. Since the function is never called, all other CodeRegions can be added as unreachable_regions.

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. Read more
Creates the function-specific debug context. Read more
The &FnAbi-wrapping type (or &FnAbi itself), which will be returned from fn_abi_of_* (see also handle_fn_abi_err). Read more
Helper used for fn_abi_of_*, to adapt tcx.fn_abi_of_*(...) into a Self::FnAbiOfResult (which does not need to be a Result<...>). Read more
The TyAndLayout-wrapping type (or TyAndLayout itself), which will be returned from layout_of (see also handle_layout_err). Read more
Helper used for layout_of, to adapt tcx.layout_of(...) into a Self::LayoutOfResult (which does not need to be a Result<...>). Read more
Span to use for tcx.at(span), from layout_of.
Declares the extern “C” main function for the entry point. Returns None if the symbol already exists.

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

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

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.

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