Struct GenericCx

pub(crate) struct GenericCx<'ll, T: Borrow<SCx<'ll>>>(T, PhantomData<SCx<'ll>>);

Tuple Fields

0: T

1: PhantomData<SCx<'ll>>

Implementations

impl<'ll> GenericCx<'ll, FullCx<'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

impl<'ll> GenericCx<'ll, FullCx<'ll, '_>>

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)

impl<'ll, 'tcx> GenericCx<'ll, FullCx<'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(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], )

impl<'ll> GenericCx<'ll, SCx<'ll>>

pub(crate) fn new( llmod: &'ll Module, llcx: &'ll Context, pointer_size: Size, ) -> Self

impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX>

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>

impl<'ll> GenericCx<'ll, FullCx<'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 GenericCx<'_, FullCx<'_, '_>>

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.

impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX>

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.

impl<'ll, 'tcx> GenericCx<'ll, FullCx<'ll, 'tcx>>

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.

impl<'ll> GenericCx<'ll, FullCx<'ll, '_>>

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

impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX>

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.

impl<'ll, 'tcx> GenericCx<'ll, FullCx<'ll, 'tcx>>

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.

impl GenericCx<'_, FullCx<'_, '_>>

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

impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX>

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>

impl<'ll, 'tcx> GenericCx<'ll, FullCx<'ll, 'tcx>>

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.

impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX>

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

impl<'a, 'tcx> GenericCx<'a, FullCx<'a, 'tcx>>

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<'tcx> AsmCodegenMethods<'tcx> for GenericCx<'_, FullCx<'_, 'tcx>>

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

fn mangled_name(&self, instance: Instance<'tcx>) -> String

The mangled name of this instance

impl<'ll, CX: Borrow<SCx<'ll>>> BackendTypes for GenericCx<'ll, CX>

type Value = &'ll Value

type Metadata = &'ll Metadata

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, CX: Borrow<SCx<'ll>>> BaseTypeCodegenMethods for GenericCx<'ll, CX>

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_f16(&self) -> &'ll Type

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

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

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

fn type_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'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> ConstCodegenMethods for GenericCx<'ll, FullCx<'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_bool(&self, val: bool) -> &'ll Value

fn const_i8(&self, i: i8) -> &'ll Value

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

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

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

fn const_u8(&self, i: u8) -> &'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_uint(&self, t: &'ll Type, i: u64) -> &'ll Value

fn const_uint_big(&self, t: &'ll Type, u: u128) -> &'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_vector(&self, elts: &[&'ll Value]) -> &'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<'_>) -> Self::Value

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

impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for GenericCx<'ll, FullCx<'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 Metadata, &'ll Metadata>>

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 Metadata

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

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

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

fn debuginfo_finalize(&self)

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

impl<'ll, T: Borrow<SCx<'ll>>> Deref for GenericCx<'ll, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'tcx> FnAbiOfHelpers<'tcx> for GenericCx<'_, FullCx<'_, 'tcx>>

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

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

impl HasDataLayout for GenericCx<'_, FullCx<'_, '_>>

fn data_layout(&self) -> &TargetDataLayout

impl HasTargetSpec for GenericCx<'_, FullCx<'_, '_>>

fn target_spec(&self) -> &Target

impl<'tcx> HasTyCtxt<'tcx> for GenericCx<'_, FullCx<'_, 'tcx>>

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

impl<'tcx, 'll> HasTypingEnv<'tcx> for GenericCx<'ll, FullCx<'ll, 'tcx>>

fn typing_env(&self) -> TypingEnv<'tcx>

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

FIXME(#132279): This method should not be used as in the future everything should take a TypingEnv instead. Remove it as that point.

impl<'tcx> LayoutOfHelpers<'tcx> for GenericCx<'_, FullCx<'_, 'tcx>>

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

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 layout_tcx_at_span(&self) -> Span

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

impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for GenericCx<'ll, FullCx<'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 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 is_backend_ref(&self, layout: TyAndLayout<'tcx, Ty<'tcx>>) -> bool

A type that produces an OperandValue::Ref when loaded.

impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for GenericCx<'ll, FullCx<'ll, 'tcx>>

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

fn apply_vcall_visibility_metadata( &self, ty: Ty<'tcx>, poly_trait_ref: Option<ExistentialTraitRef<'tcx>>, vtable: &'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 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> PreDefineCodegenMethods<'tcx> for GenericCx<'_, FullCx<'_, '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> StaticCodegenMethods for GenericCx<'ll, FullCx<'ll, '_>>

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

Get a pointer to a global variable.

The pointer will always be in the default address space. If global variables default to a different address space, an addrspacecast is inserted.

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 codegen_static(&self, def_id: DefId)

impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for GenericCx<'ll, FullCx<'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 Metadata>

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: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.