Enum cranelift_codegen::ir::GlobalValueData

pub enum GlobalValueData {
    VMContext,
    Load {
        base: GlobalValue,
        offset: Offset32,
        global_type: Type,
        flags: MemFlags,
    },
    IAddImm {
        base: GlobalValue,
        offset: Imm64,
        global_type: Type,
    },
    Symbol {
        name: ExternalName,
        offset: Imm64,
        colocated: bool,
        tls: bool,
    },
    DynScaleTargetConst {
        vector_type: Type,
    },
}

Information about a global value declaration.

Variants

VMContext

Value is the address of the VM context struct.

Load

Value is pointed to by another global value.

The base global value is assumed to contain a pointer. This global value is computed by loading from memory at that pointer value. The memory must be accessible, and naturally aligned to hold a value of the type. The data at this address is assumed to never change while the current function is executing.

Fields

base: GlobalValue

The base pointer global value.

offset: Offset32

Offset added to the base pointer before doing the load.

global_type: Type

Type of the loaded value.

flags: MemFlags

Specifies the memory flags to be used by the load. Guaranteed to be notrap and aligned.

IAddImm

Value is an offset from another global value.

Fields

base: GlobalValue

The base pointer global value.

offset: Imm64

Byte offset to be added to the value.

global_type: Type

Type of the iadd.

Symbol

Value is symbolic, meaning it’s a name which will be resolved to an actual value later (eg. by linking). Cranelift itself does not interpret this name; it’s used by embedders to link with other data structures.

For now, symbolic values always have pointer type, and represent addresses, however in the future they could be used to represent other things as well.

Fields

name: ExternalName

The symbolic name.

offset: Imm64

Offset from the symbol. This can be used instead of IAddImm to represent folding an offset into a symbol.

colocated: bool

Will this symbol be defined nearby, such that it will always be a certain distance away, after linking? If so, references to it can avoid going through a GOT. Note that symbols meant to be preemptible cannot be colocated.

If true, some backends may use relocation forms that have limited range: for example, a +/- 2^27-byte range on AArch64. See the documentation for RelocDistance for more details.

tls: bool

Does this symbol refer to a thread local storage value?

DynScaleTargetConst

Value is a multiple of how many instances of vector_type will fit in a target vector register.

Fields

vector_type: Type

Base vector type.

Implementations

impl GlobalValueData

pub fn symbol_name(&self) -> &ExternalName

Assume that self is an GlobalValueData::Symbol and return its name.

pub fn global_type(&self, isa: &dyn TargetIsa) -> Type

Return the type of this global.

Trait Implementations

impl Clone for GlobalValueData

fn clone(&self) -> GlobalValueData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Display for GlobalValueData

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

Formats the value using the given formatter.

impl Hash for GlobalValueData

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 PartialEq for GlobalValueData

fn eq(&self, other: &GlobalValueData) -> bool

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

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

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

impl StructuralPartialEq for GlobalValueData