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_cstr_cache: RefCell<FxHashMap<Symbol, &'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 lltypes: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), &'ll Type>>,
    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<'tcx>>,
    pub dbg_cx: Option<CrateDebugContext<'ll, 'tcx>>,
    eh_personality: Cell<Option<&'ll Value>>,
    eh_catch_typeinfo: Cell<Option<&'ll Value>>,
    pub rust_try_fn: Cell<Option<&'ll Value>>,
    intrinsics: RefCell<FxHashMap<&'static str, &'ll Value>>,
    local_gen_sym_counter: Cell<usize>,
}

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_cstr_cache: RefCell<FxHashMap<Symbol, &'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 http://llvm.org/docs/LangRef.html#the-llvm-used-global-variable for details

lltypes: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), &'ll Type>>

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

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

isize_ty: &'ll Type

coverage_cx: Option<CrateCoverageContext<'tcx>>

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

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

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

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

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

local_gen_sym_counter: Cell<usize>

A counter that is used for generating local symbol names

Implementations

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

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(in common) fn const_cstr(
    &self,
    s: Symbol,
    null_terminated: bool
) -> &'ll Value

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

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

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<'a>(&'a self) -> Option<&'a CrateCoverageContext<'tcx>>

impl<'b, 'tcx> CodegenCx<'b, 'tcx>

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

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

pub(in context) fn declare_intrinsic(
    &self,
    key: &str
) -> Option<&'b Value>

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

impl<'b, 'tcx> CodegenCx<'b, 'tcx>

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, '_> CodegenCx<'ll, '_>

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, 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_fn(
    &self,
    name: &str,
    fn_abi: &FnAbi<'tcx, Ty<'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<'ll, 'tcx> CodegenCx<'ll, 'tcx>

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_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_pointee_for_align(&self, align: Align) -> &'ll Type

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

Return a 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

pub(crate) fn type_array(&self, ty: &'ll Type, len: u64) -> &'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<'ll, 'tcx> AsmMethods for CodegenCx<'ll, 'tcx>

pub fn codegen_global_asm(&self, ga: &GlobalAsm)

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

type Value = &'ll Value

type Function = &'ll Value

type BasicBlock = &'ll BasicBlock

type Type = &'ll Type

type Funclet = Funclet<'ll>

type DIScope = &'ll DIScope

type DILocation = &'ll DILocation

type DIVariable = &'ll DIVariable

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn type_ptr_to_ext(
    &self,
    ty: &'ll Type,
    address_space: AddressSpace
) -> &'ll Type

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

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

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

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

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

Retrieves the bit width of the integer type self.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn from_const_alloc(
    &self,
    layout: TyAndLayout<'tcx>,
    alloc: &Allocation,
    offset: Size
) -> PlaceRef<'tcx, &'ll Value>

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

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

pub fn coverageinfo_finalize(&self)

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

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

Creates the function-specific debug context.

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

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

pub fn create_vtable_metadata(&self, ty: Ty<'tcx>, vtable: Self::Value)

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

pub fn debuginfo_finalize(&self)

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

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

pub fn data_layout(&self) -> &TargetDataLayout

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

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

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

pub fn target_spec(&self) -> &Target

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

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

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

type Ty = Ty<'tcx>

type TyAndLayout = TyAndLayout<'tcx>

pub fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyAndLayout

pub fn spanned_layout_of(&self, ty: Ty<'tcx>, span: Span) -> Self::TyAndLayout

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn sess(&self) -> &Session

pub fn check_overflow(&self) -> bool

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

pub fn used_statics(&self) -> &RefCell<Vec<&'ll Value>>

pub fn set_frame_pointer_elimination(&self, llfn: &'ll Value)

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

pub fn create_used_variable(&self)

pub 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, 'll> PreDefineMethods<'tcx> for CodegenCx<'ll, 'tcx>

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

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

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

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

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

pub 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 i8*.