Struct midenc_codegen_masm::NativePtr

pub struct NativePtr {
    pub waddr: u32,
    pub index: u8,
    pub offset: u8,
    pub addrspace: AddressSpace,
}

This represents a descriptor for a pointer translated from the IR into a form suitable for referencing data in Miden’s linear memory.

Fields

waddr: u32

This is the address of the word containing the first byte of data

index: u8

This is the element index of the word referenced by waddr containing the first byte of data

Each element is assumed to be a 32-bit value/chunk

offset: u8

This is the byte offset into the 32-bit chunk referenced by index

This offset is where the data referenced by the pointer actually starts.

addrspace: AddressSpace

This is the assumed address space of the pointer value.

This address space is unknown by default, but can be specified if known statically. The address space determines whether the pointer is valid in certain contexts. For example, attempting to load a pointer with address space 0 is invalid if not operating in the root context.

Currently this has no effect, but is here as we expand support for multiple memories.

Implementations

impl NativePtr

pub fn new(waddr: u32, index: u8, offset: u8) -> Self

pub fn from_ptr(addr: u32) -> Self

Translates a raw pointer (assumed to be in a byte-addressable address space) to a native pointer value, in the default [hir::AddressSpace].

pub const fn is_word_aligned(&self) -> bool

Returns true if this pointer is aligned to a word boundary

pub const fn is_element_aligned(&self) -> bool

Returns true if this pointer is aligned to a field element boundary

pub const fn is_unaligned(&self) -> bool

Returns true if this pointer is not word or element aligned

pub const fn alignment(&self) -> u32

Returns the byte alignment implied by this pointer value.

For example, a pointer to the first word in linear memory, i.e. address 0, with an element index of 1, and offset of 16, is equivalent to an address in byte-addressable memory of 48, which has an implied alignment of 16 bytes.

pub const fn as_ptr(&self) -> u32

Converts this native pointer back to a byte-addressable pointer value

Trait Implementations

impl Clone for NativePtr

fn clone(&self) -> NativePtr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NativePtr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NativePtr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NativePtr

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for NativePtr

impl Eq for NativePtr

impl StructuralPartialEq for NativePtr