Enum GlobalAlloc

pub enum GlobalAlloc<'tcx> {
    Function {
        instance: Instance<'tcx>,
    },
    VTable(Ty<'tcx>, &'tcx List<PolyExistentialPredicate<'tcx>>),
    Static(DefId),
    Memory(ConstAllocation<'tcx>),
}

An allocation in the global (tcx-managed) memory can be either a function pointer, a static, or a “real” allocation with some data in it.

Variants

Function

The alloc ID is used as a function pointer.

Fields

instance: Instance<'tcx>

VTable(Ty<'tcx>, &'tcx List<PolyExistentialPredicate<'tcx>>)

This alloc ID points to a symbolic (not-reified) vtable. We remember the full dyn type, not just the principal trait, so that const-eval and Miri can detect UB due to invalid transmutes of dyn Trait types.

Static(DefId)

The alloc ID points to a “lazy” static variable that did not get computed (yet). This is also used to break the cycle in recursive statics.

Memory(ConstAllocation<'tcx>)

The alloc ID points to memory.

Implementations

impl<'tcx> GlobalAlloc<'tcx>

pub fn unwrap_memory(&self) -> ConstAllocation<'tcx>

Panics if the GlobalAlloc does not refer to an GlobalAlloc::Memory

pub fn unwrap_fn(&self) -> Instance<'tcx>

Panics if the GlobalAlloc is not GlobalAlloc::Function

pub fn unwrap_vtable(&self) -> (Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>)

Panics if the GlobalAlloc is not GlobalAlloc::VTable

pub fn address_space(&self, cx: &impl HasDataLayout) -> AddressSpace

The address space that this GlobalAlloc should be placed in.

pub fn mutability( &self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> Mutability

pub fn size_and_align( &self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> (Size, Align)

Trait Implementations

impl<'tcx> Clone for GlobalAlloc<'tcx>

fn clone(&self) -> GlobalAlloc<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Debug for GlobalAlloc<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for GlobalAlloc<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for GlobalAlloc<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx> Hash for GlobalAlloc<'tcx>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for GlobalAlloc<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl<'tcx> PartialEq for GlobalAlloc<'tcx>

fn eq(&self, other: &GlobalAlloc<'tcx>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> Eq for GlobalAlloc<'tcx>

impl<'tcx> StructuralPartialEq for GlobalAlloc<'tcx>

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

Size for each variant:

• Function: 32 bytes
• VTable: 24 bytes
• Static: 12 bytes
• Memory: 16 bytes