Enum rustc_middle::mir::interpret::GlobalAlloc

pub enum GlobalAlloc<'tcx> {
    Function(Instance<'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(Instance<'tcx>)

The alloc ID is used as a function pointer.

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

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, 

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<GlobalAlloc<'tcx>> for GlobalAlloc<'tcx>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

impl<'tcx> StructuralEq 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: 40 bytes

Size for each variant:

• Function: 36 bytes
• Static: 8 bytes
• Memory: 12 bytes