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

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

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

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

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

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

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

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

pub(crate) fn alloc_to_backend( &self, global_alloc: GlobalAlloc<'tcx>, need_symbol_name: bool, schema: Option<&PointerAuthSchema>, ) -> Result<Value<'ll>, u64>

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

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

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

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

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: Value<'ll>, align: Align, kind: Option<&str>, ) -> Value<'ll>

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) -> Value<'ll>

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

fn codegen_static_item(&mut self, def_id: DefId)

pub(crate) fn add_used_global(&mut self, global: Value<'ll>)

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

pub(crate) fn add_compiler_used_global(&self, global: Value<'ll>)

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

fn define_objc_classname(&self, classname: &str) -> Value<'ll>

fn get_objc_class_t(&self) -> Type<'ll>

fn get_objc_classref(&self, classname: Symbol) -> Value<'ll>

fn get_objc_selref(&self, methname: Symbol) -> Value<'ll>

pub(crate) fn define_objc_module_info(&mut self)

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

pub(crate) fn new( tcx: TyCtxt<'tcx>, codegen_unit: &'tcx CodegenUnit<'tcx>, module_refs: ModuleRefs<'ll>, bitcode_needed: bool, ) -> Self

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

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: &[Value<'ll>], )

pub(crate) fn objc_abi_version(&self) -> u32

The Objective-C ABI that is used.

This corresponds to the -fobjc-abi-version= flag in Clang / GCC.

pub(crate) fn add_ptrauth_elf_got_flag(&self)

pub(crate) fn add_ptrauth_sign_personality_flag(&self)

pub(crate) fn add_ptrauth_pauthabi_version_and_platform_flags( &self, aarch64_elf_pauthabi_version: u32, )

pub(crate) fn add_objc_module_flags(&self)

pub(crate) fn is_sanitizer_type_ignored( &self, sanitizer: &CStr, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, ) -> bool

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

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

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

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

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

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

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

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

pub(crate) fn get_const_i64(&self, n: u64) -> Value<'ll>

pub(crate) fn get_const_i32(&self, n: u64) -> Value<'ll>

pub(crate) fn get_const_i16(&self, n: u64) -> Value<'ll>

pub(crate) fn get_const_i8(&self, n: u64) -> Value<'ll>

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

pub(crate) fn create_metadata(&self, name: &[u8]) -> &'ll Metadata

pub(crate) fn get_functions(&self) -> Vec<Value<'ll>>

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

pub(crate) fn get_intrinsic( &self, base_name: Cow<'static, str>, type_params: &[Type<'ll>], ) -> (Type<'ll>, Value<'ll>)

fn declare_intrinsic( &self, base_name: &str, type_params: &[Type<'ll>], ) -> (Type<'ll>, Value<'ll>)

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.

pub(crate) fn generate_global_symbol_name(&self) -> String

Generates a new global symbol name with the given prefix.

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

pub(crate) fn md_node_in_context( &self, md_list: &[&'ll Metadata], ) -> &'ll Metadata

Wrapper for LLVMMDNodeInContext2, i.e. llvm::MDNode::get.

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

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

pub(crate) fn set_metadata_node( &self, instruction: Value<'ll>, kind_id: MetadataKindId, md_list: &[&'ll Metadata], ) -> &'ll Metadata

Helper method for the sequence of calls:

• LLVMMDNodeInContext2 (to create an llvm::MDNode from a list of metadata)
• LLVMMetadataAsValue (to adapt that node to an llvm::Value)
• LLVMSetMetadata (to set that node as metadata of kind_id for instruction)

pub(crate) fn module_add_named_metadata_node( &self, module: Module<'ll>, kind_name: &CStr, md_list: &[&'ll Metadata], )

Helper method for the sequence of calls:

• LLVMMDNodeInContext2 (to create an llvm::MDNode from a list of metadata)
• LLVMMetadataAsValue (to adapt that node to an llvm::Value)
• LLVMAddNamedMetadataOperand (to set that node as metadata of kind_name for module)

pub(crate) fn global_add_metadata_node( &self, global: Value<'ll>, kind_id: MetadataKindId, md_list: &[&'ll Metadata], )

Helper method for the sequence of calls:

• LLVMMDNodeInContext2 (to create an llvm::MDNode from a list of metadata)
• LLVMGlobalAddMetadata (to set that node as metadata of kind_id for global)

pub(crate) fn global_set_metadata_node( &self, global: Value<'ll>, kind_id: MetadataKindId, md_list: &[&'ll Metadata], )

Helper method for the sequence of calls:

• LLVMMDNodeInContext2 (to create an llvm::MDNode from a list of metadata)
• LLVMGlobalSetMetadata (to set that node as metadata of kind_id for global)

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

pub(crate) fn coverageinfo_finalize(&mut 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 ensure_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Value<'ll>

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.

This has the side-effect of causing coverage codegen to consider this function “used”, making it eligible to emit an associated covfun record.

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

pub(crate) fn debuginfo_finalize(&self)

Creates any deferred debug metadata nodes

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

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

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_global_in_addrspace( &self, name: &str, ty: Type<'ll>, addr_space: AddressSpace, ) -> Value<'ll>

Declare a global value in a specific address space.

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: Type<'ll>, ) -> Value<'ll>

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: Type<'ll>, ) -> Value<'ll>

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

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.

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

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

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

Gets declared value by name.

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

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

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

fn predefine_without_aliases( &self, instance: Instance<'tcx>, attrs: &CodegenFnAttrs, linkage: Linkage, visibility: Visibility, symbol_name: &str, ) -> Value<'ll>

fn add_static_aliases( &self, aliasee: Value<'ll>, aliases: &[(DefId, Linkage, Visibility)], )

LLVM has the concept of an alias. We need this for the “externally implementable items” feature, though it’s generally useful.

On macos, though this might be a more general problem, function symbols have a fixed target architecture. This is necessary, since macos binaries may contain code for both ARM and x86 macs.

LLVM can add attributes for target architecture to function symbols, cannot do so for statics, but importantly, also cannot for aliases even when aliases may refer to a function symbol.

This is not a problem: instead of using LLVM aliases, we can just generate a new function symbol (with target architecture!) which effectively comes down to:

fn alias_name(...args) {
    original_name(...args)
}

That’s also an alias.

This does mean that the alias symbol has a different address than the original symbol (assuming no optimizations by LLVM occur). This is unacceptable for statics. So for statics we do want to use LLVM aliases, which is fine, since for those we don’t care about target architecture anyway.

So, this function is for static aliases. See add_function_aliases for the alternative.

fn add_function_aliases( &self, aliasee_instance: Instance<'tcx>, aliasee: Value<'ll>, attrs: &CodegenFnAttrs, aliases: &[(DefId, Linkage, Visibility)], )

See add_static_aliases for docs.

pub(crate) fn assume_dso_local( &self, llval: Value<'ll>, is_declaration: bool, ) -> bool

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 set_visibility( &self, lldecl: Value<'ll>, linkage: Linkage, visibility: Visibility, )

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

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

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

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

pub(crate) fn set_struct_body_packed(&self, ty: Type<'ll>, els: &[Type<'ll>])

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

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

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

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

pub(crate) fn type_scalable_vector( &self, ty: Type<'ll>, count: u64, ) -> Type<'ll>

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

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

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

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

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

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

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

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

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

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

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) -> Context<'ll>

pub(crate) fn llmod(&self) -> Module<'ll>

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

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

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

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

pub(crate) fn type_packed_struct(&self, els: &[Type<'ll>]) -> Type<'ll>

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

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

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

Prefer more specific methods (e.g. int_width, float_type, vector_element_type) when possible.

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)

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

Trait Implementations

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

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

Codegen a module-level assembly block.

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 Function = Value<'ll>

type BasicBlock = &'ll BasicBlock

type Funclet = Funclet<'ll>

type Value = Value<'ll>

type Type = Type<'ll>

type FunctionSignature = Type<'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) -> Type<'ll>

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

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

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

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

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

fn type_f16(&self) -> Type<'ll>

fn type_f16b(&self) -> Type<'ll>

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

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

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

fn type_ppcf128(&self) -> Type<'ll>

fn type_x87_f80(&self) -> Type<'ll>

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

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

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

fn vector_element_type_and_length( &self, ty: Self::Type, ) -> Option<(Self::Type, u64)>

Returns the tuple (element_type, length) of ty if it is a vector type, otherwise returns None.

fn float_type(&self, ty: Type<'ll>) -> Option<Float>

Retrieves the scalar float type of ty. Returns None is ty is not a float.

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

Retrieves the bit width of the scalar integer type ty. Returns None is ty is not an integer.

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

fn vector_element_type(&self, ty: Self::Type) -> Option<Self::Type>

Returns the element type of ty if it is a vector type, otherwise returns None.

fn vector_length(&self, ty: Self::Type) -> Option<u64>

Returns the number of elements in ty if it is a vector type, otherwise returns None.

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

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

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

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: Type<'ll>) -> Value<'ll>

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) -> Value<'ll>

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

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

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

fn const_i64(&self, i: i64) -> Value<'ll>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn scalar_to_backend_with_pac( &self, cv: Scalar, layout: Scalar, llty: Type<'ll>, schema: Option<&PointerAuthSchema>, ) -> Value<'ll>

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

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

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

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

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

fn deref_mut(&mut self) -> &mut Self::Target

Mutably 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: MaybeResult<&'tcx FnAbi<'tcx, Ty<'tcx>>> = &'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>

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: MaybeResult<TyAndLayout<'tcx, Ty<'tcx>>> = 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>) -> Type<'ll>

The backend type used for a Rust type when it is being loaded from or stored to memory.

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

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

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

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

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

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

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

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

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

fn apply_vcall_visibility_metadata( &self, ty: Ty<'tcx>, poly_trait_ref: Option<ExistentialTraitRef<'tcx>>, vtable: Value<'ll>, )

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

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

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

fn sess(&self) -> &Session

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

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

fn apply_default_optimisation_attrs(&self, llfn: Value<'ll>)

Applies the compilation’s optimization attributes to a function that no item produced, such as the C entry shim.

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.

fn intrinsic_call_expects_place_always(&self, name: Symbol) -> bool

Whether codegen_intrinsic_call expects to always have a place_value when emitting code for the intrinsic name.

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

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

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

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

fn static_addr_of( &self, alloc: ConstAllocation<'_>, kind: Option<&str>, ) -> Value<'ll>

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

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

fn add_type_metadata(&self, function: Value<'ll>, typeid: &[u8])

fn set_type_metadata(&self, function: Value<'ll>, typeid: &[u8])

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

fn set_kcfi_type_metadata(&self, function: Value<'ll>, 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.