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: booluse_dll_storage_attrs: booltls_model: ThreadLocalModellmod: &'ll Modulellcx: &'ll Contextcodegen_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 Typecoverage_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
sourceimpl<'ll> CodegenCx<'ll, '_>
impl<'ll> CodegenCx<'ll, '_>
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 fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value
sourceimpl<'ll, 'tcx> CodegenCx<'ll, 'tcx>
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(&self) -> Option<&CrateCoverageContext<'ll, 'tcx>>
fn create_used_variable_impl(&self, name: &'static CStr, values: &[&'ll Value])
sourceimpl<'ll> CodegenCx<'ll, '_>
impl<'ll> CodegenCx<'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
sourceimpl CodegenCx<'_, '_>
impl CodegenCx<'_, '_>
sourcepub fn generate_local_symbol_name(&self, prefix: &str) -> String
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.
sourceimpl CodegenCx<'_, '_>
impl CodegenCx<'_, '_>
sourcepub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc
pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc
Looks up debug source information about a BytePos.
sourceimpl<'ll, 'tcx> CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> CodegenCx<'ll, 'tcx>
sourcepub fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value
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.
sourcepub fn declare_cfn(
&self,
name: &str,
unnamed: UnnamedAddr,
fn_type: &'ll Type
) -> &'ll Value
pub 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.
sourcepub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Value
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.
sourcepub fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value>
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).
sourcepub fn define_private_global(&self, ty: &'ll Type) -> &'ll Value
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.
sourcepub fn get_declared_value(&self, name: &str) -> Option<&'ll Value>
pub fn get_declared_value(&self, name: &str) -> Option<&'ll Value>
Gets declared value by name.
sourcepub fn get_defined_value(&self, name: &str) -> Option<&'ll Value>
pub fn get_defined_value(&self, name: &str) -> Option<&'ll Value>
Gets defined or externally defined (AvailableExternally linkage) value by name.
sourceimpl CodegenCx<'_, '_>
impl CodegenCx<'_, '_>
sourcepub(crate) unsafe fn should_assume_dso_local(
&self,
llval: &Value,
is_declaration: bool
) -> bool
pub(crate) unsafe fn should_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.
sourceimpl<'ll> CodegenCx<'ll, '_>
impl<'ll> CodegenCx<'ll, '_>
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
sourcepub(crate) fn type_ix(&self, num_bits: u64) -> &'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
sourcepub(crate) fn type_padding_filler(&self, size: Size, 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
Trait Implementations
sourceimpl<'tcx> AsmMethods<'tcx> for CodegenCx<'_, 'tcx>
impl<'tcx> AsmMethods<'tcx> for CodegenCx<'_, 'tcx>
fn codegen_global_asm(
&self,
template: &[InlineAsmTemplatePiece],
operands: &[GlobalAsmOperandRef<'tcx>],
options: InlineAsmOptions,
_line_spans: &[Span]
)
sourceimpl<'ll> BackendTypes for CodegenCx<'ll, '_>
impl<'ll> BackendTypes for CodegenCx<'ll, '_>
type Value = &'ll Value
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
sourceimpl<'ll, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'ll, 'tcx>
fn type_i1(&self) -> &'ll Type
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_f32(&self) -> &'ll Type
fn type_f64(&self) -> &'ll Type
fn type_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'ll Type
fn type_struct(&self, els: &[&'ll Type], packed: bool) -> &'ll Type
fn type_kind(&self, ty: &'ll Type) -> TypeKind
fn type_ptr_to(&self, ty: &'ll Type) -> &'ll Type
fn type_ptr_to_ext(&self, ty: &'ll Type, address_space: AddressSpace) -> &'ll Type
fn element_type(&self, ty: &'ll Type) -> &'ll Type
sourcefn vector_length(&self, ty: &'ll Type) -> usize
fn vector_length(&self, ty: &'ll Type) -> usize
self if it is a LLVM vector type.fn float_width(&self, ty: &'ll Type) -> usize
fn val_ty(&self, v: &'ll Value) -> &'ll Type
sourceimpl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx>
fn const_null(&self, t: &'ll Type) -> &'ll Value
fn const_undef(&self, t: &'ll Type) -> &'ll Value
fn const_int(&self, t: &'ll Type, i: i64) -> &'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_bool(&self, val: bool) -> &'ll Value
fn const_i16(&self, i: i16) -> &'ll Value
fn const_i32(&self, i: i32) -> &'ll Value
fn const_u32(&self, i: u32) -> &'ll Value
fn const_u64(&self, i: u64) -> &'ll Value
fn const_usize(&self, i: u64) -> &'ll Value
fn const_u8(&self, i: u8) -> &'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_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<'tcx>) -> Self::Value
fn from_const_alloc(
&self,
layout: TyAndLayout<'tcx>,
alloc: ConstAllocation<'tcx>,
offset: Size
) -> PlaceRef<'tcx, &'ll Value>
fn const_ptrcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value
sourceimpl<'ll, 'tcx> CoverageInfoMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> CoverageInfoMethods<'tcx> for CodegenCx<'ll, 'tcx>
sourcefn define_unused_fn(&self, def_id: DefId)
fn define_unused_fn(&self, def_id: DefId)
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.
fn coverageinfo_finalize(&self)
sourcefn get_pgo_func_name_var(&self, instance: Instance<'tcx>) -> &'ll Value
fn get_pgo_func_name_var(&self, instance: Instance<'tcx>) -> &'ll Value
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 moresourceimpl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx>
sourcefn 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>>
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>>
fn dbg_scope_fn(
&self,
instance: Instance<'tcx>,
fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
maybe_definition_llfn: Option<&'ll Value>
) -> &'ll DIScope
fn dbg_loc(
&self,
scope: &'ll DIScope,
inlined_at: Option<&'ll DILocation>,
span: Span
) -> &'ll DILocation
fn create_vtable_debuginfo(
&self,
ty: Ty<'tcx>,
trait_ref: Option<PolyExistentialTraitRef<'tcx>>,
vtable: Self::Value
)
fn extend_scope_to_file(
&self,
scope_metadata: &'ll DIScope,
file: &SourceFile
) -> &'ll DILexicalBlock
fn debuginfo_finalize(&self)
fn create_dbg_var(
&self,
variable_name: Symbol,
variable_type: Ty<'tcx>,
scope_metadata: &'ll DIScope,
variable_kind: VariableKind,
span: Span
) -> &'ll DIVariable
sourceimpl<'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'_, 'tcx>
impl<'tcx> FnAbiOfHelpers<'tcx> for CodegenCx<'_, 'tcx>
type FnAbiOfResult = &'tcx FnAbi<'tcx, Ty<'tcx>>
type FnAbiOfResult = &'tcx FnAbi<'tcx, Ty<'tcx>>
&FnAbi-wrapping type (or &FnAbi itself), which will be
returned from fn_abi_of_* (see also handle_fn_abi_err). Read moresourcefn handle_fn_abi_err(
&self,
err: FnAbiError<'tcx>,
span: Span,
fn_abi_request: FnAbiRequest<'tcx>
) -> !
fn handle_fn_abi_err(
&self,
err: FnAbiError<'tcx>,
span: Span,
fn_abi_request: FnAbiRequest<'tcx>
) -> !
fn_abi_of_*, to adapt tcx.fn_abi_of_*(...) into a
Self::FnAbiOfResult (which does not need to be a Result<...>). Read moresourceimpl HasDataLayout for CodegenCx<'_, '_>
impl HasDataLayout for CodegenCx<'_, '_>
fn data_layout(&self) -> &TargetDataLayout
sourceimpl<'tcx, 'll> HasParamEnv<'tcx> for CodegenCx<'ll, 'tcx>
impl<'tcx, 'll> HasParamEnv<'tcx> for CodegenCx<'ll, 'tcx>
sourceimpl HasTargetSpec for CodegenCx<'_, '_>
impl HasTargetSpec for CodegenCx<'_, '_>
fn target_spec(&self) -> &Target
sourceimpl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'_, 'tcx>
impl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'_, 'tcx>
type LayoutOfResult = TyAndLayout<'tcx, Ty<'tcx>>
type LayoutOfResult = TyAndLayout<'tcx, Ty<'tcx>>
TyAndLayout-wrapping type (or TyAndLayout itself), which will be
returned from layout_of (see also handle_layout_err). Read moresourcefn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> !
fn handle_layout_err(&self, err: LayoutError<'tcx>, span: Span, ty: Ty<'tcx>) -> !
layout_of, to adapt tcx.layout_of(...) into a
Self::LayoutOfResult (which does not need to be a Result<...>). Read moresourcefn layout_tcx_at_span(&self) -> Span
fn layout_tcx_at_span(&self) -> Span
Span to use for tcx.at(span), from layout_of.sourceimpl<'ll, 'tcx> LayoutTypeMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> LayoutTypeMethods<'tcx> for CodegenCx<'ll, 'tcx>
fn backend_type(&self, layout: TyAndLayout<'tcx>) -> &'ll Type
fn immediate_backend_type(&self, layout: TyAndLayout<'tcx>) -> &'ll Type
fn is_backend_immediate(&self, layout: TyAndLayout<'tcx>) -> bool
fn is_backend_scalar_pair(&self, layout: TyAndLayout<'tcx>) -> bool
fn backend_field_index(&self, layout: TyAndLayout<'tcx>, index: usize) -> u64
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
sourceimpl<'ll, 'tcx> MiscMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> MiscMethods<'tcx> for CodegenCx<'ll, 'tcx>
fn vtables(
&self
) -> &RefCell<FxHashMap<(Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>), &'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 check_overflow(&self) -> bool
fn codegen_unit(&self) -> &'tcx CodegenUnit<'tcx>
fn used_statics(&self) -> &RefCell<Vec<&'ll Value>>
fn compiler_used_statics(&self) -> &RefCell<Vec<&'ll Value>>
fn set_frame_pointer_type(&self, llfn: &'ll Value)
fn apply_target_cpu_attr(&self, llfn: &'ll Value)
fn create_used_variable(&self)
fn create_compiler_used_variable(&self)
sourcefn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function>
fn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function>
sourceimpl<'tcx> PreDefineMethods<'tcx> for CodegenCx<'_, 'tcx>
impl<'tcx> PreDefineMethods<'tcx> for CodegenCx<'_, '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
)
sourceimpl<'ll> StaticMethods for CodegenCx<'ll, '_>
impl<'ll> StaticMethods for CodegenCx<'ll, '_>
sourcefn add_used_global(&self, global: &'ll Value)
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*.
sourcefn add_compiler_used_global(&self, global: &'ll Value)
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 i8*.
fn static_addr_of(
&self,
cv: &'ll Value,
align: Align,
kind: Option<&str>
) -> &'ll Value
fn codegen_static(&self, def_id: DefId, is_mutable: bool)
sourceimpl<'ll, 'tcx> TypeMembershipMethods<'tcx> for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> TypeMembershipMethods<'tcx> for CodegenCx<'ll, 'tcx>
fn set_type_metadata(&self, function: &'ll Value, typeid: String)
fn typeid_metadata(&self, typeid: String) -> &'ll Value
Auto Trait Implementations
impl<'ll, 'tcx> !RefUnwindSafe for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> !Send for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> !Sync for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> Unpin for CodegenCx<'ll, 'tcx>
impl<'ll, 'tcx> !UnwindSafe for CodegenCx<'ll, 'tcx>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<'tcx, T> DerivedTypeMethods<'tcx> for Twhere
T: BaseTypeMethods<'tcx> + MiscMethods<'tcx>,
impl<'tcx, T> DerivedTypeMethods<'tcx> for Twhere
T: BaseTypeMethods<'tcx> + MiscMethods<'tcx>,
fn type_i8p(&self) -> Self::Type
fn type_i8p_ext(&self, address_space: AddressSpace) -> Self::Type
fn type_int(&self) -> Self::Type
fn type_from_integer(&self, i: Integer) -> Self::Type
fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool
fn type_is_sized(&self, ty: Ty<'tcx>) -> bool
fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool
fn type_has_metadata(&self, ty: Ty<'tcx>) -> bool
sourceimpl<'tcx, C> FnAbiOf<'tcx> for Cwhere
C: FnAbiOfHelpers<'tcx>,
impl<'tcx, C> FnAbiOf<'tcx> for Cwhere
C: FnAbiOfHelpers<'tcx>,
sourcefn fn_abi_of_fn_ptr(
&self,
sig: Binder<'tcx, FnSig<'tcx>>,
extra_args: &'tcx List<Ty<'tcx>>
) -> Self::FnAbiOfResult
fn fn_abi_of_fn_ptr(
&self,
sig: Binder<'tcx, FnSig<'tcx>>,
extra_args: &'tcx List<Ty<'tcx>>
) -> Self::FnAbiOfResult
sourcefn fn_abi_of_instance(
&self,
instance: Instance<'tcx>,
extra_args: &'tcx List<Ty<'tcx>>
) -> Self::FnAbiOfResult
fn fn_abi_of_instance(
&self,
instance: Instance<'tcx>,
extra_args: &'tcx List<Ty<'tcx>>
) -> Self::FnAbiOfResult
FnAbi suitable for declaring/defining an fn instance, and for
direct calls to an fn. Read moresourceimpl<'tcx, C> LayoutOf<'tcx> for Cwhere
C: LayoutOfHelpers<'tcx>,
impl<'tcx, C> LayoutOf<'tcx> for Cwhere
C: LayoutOfHelpers<'tcx>,
sourcefn layout_of(&self, ty: Ty<'tcx>) -> Self::LayoutOfResult
fn layout_of(&self, ty: Ty<'tcx>) -> Self::LayoutOfResult
sourcefn spanned_layout_of(&self, ty: Ty<'tcx>, span: Span) -> Self::LayoutOfResult
fn spanned_layout_of(&self, ty: Ty<'tcx>, span: Span) -> Self::LayoutOfResult
span. Note that this implicitly
executes in “reveal all” mode, and will normalize the input type. Read moreLayout
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