Enum MemoryTypeData

pub enum MemoryTypeData {
    Struct {
        size: u64,
        fields: Vec<MemoryTypeField>,
    },
    Memory {
        size: u64,
    },
    DynamicMemory {
        size: u64,
        gv: GlobalValue,
    },
    Empty,
}

Data defining a memory type.

A memory type corresponds to a layout of data in memory. It may have a statically-known or dynamically-known size.

Variants

Struct

An aggregate consisting of certain fields at certain offsets.

Fields must be sorted by offset, must be within the struct’s overall size, and must not overlap. These conditions are checked by the CLIF verifier.

Fields

size: u64

Size of this type.

fields: Vec<MemoryTypeField>

Fields in this type. Sorted by offset.

Memory

A statically-sized untyped blob of memory.

Fields

size: u64

Accessible size.

DynamicMemory

A dynamically-sized untyped blob of memory, with bound given by a global value plus some static amount.

Fields

size: u64

Static part of size.

gv: GlobalValue

Dynamic part of size.

Empty

A type with no size.

Implementations

impl MemoryTypeData

pub fn static_size(&self) -> Option<u64>

Provide the static size of this type, if known.

(The size may not be known for dynamically-sized arrays or memories, when those memtype kinds are added.)

Trait Implementations

impl Clone for MemoryTypeData

fn clone(&self) -> MemoryTypeData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for MemoryTypeData

fn default() -> Self

Returns the “default value” for a type.

impl Display for MemoryTypeData

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

Formats the value using the given formatter.

impl Hash for MemoryTypeData

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 MemoryTypeData

fn eq(&self, other: &MemoryTypeData) -> 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 StructuralPartialEq for MemoryTypeData