Enum midenc_hir::Type

pub enum Type {
    Unknown,
    Unit,
    Never,
    I1,
    I8,
    U8,
    I16,
    U16,
    I32,
    U32,
    I64,
    U64,
    I128,
    U128,
    U256,
    F64,
    Felt,
    Ptr(Box<Type>),
    NativePtr(Box<Type>, AddressSpace),
    Struct(StructType),
    Array(Box<Type>, usize),
    List(Box<Type>),
}

Represents the type of a value

Variants

Unknown

This indicates a failure to type a value, or a value which is untypable

Unit

This type is used to indicate the absence of a value, such as a function which returns nothing

Never

This type is the bottom type, and represents divergence, akin to Rust’s Never/! type

I1

I8

U8

I16

U16

I32

U32

I64

U64

I128

U128

U256

F64

Felt

Field element

Ptr(Box<Type>)

A pointer to a value in the default byte-addressable address space used by the IR.

Pointers of this type will be translated to an appropriate address space during code generation.

NativePtr(Box<Type>, AddressSpace)

A pointer to a valude in Miden’s native word-addressable address space.

In the type system, we represent the type of the pointee, as well as an address space identifier.

This pointer type is represented on Miden’s operand stack as a u64 value, consisting of two 32-bit elements, the most-significant bits being on top of the stack:

1. Metadata for the pointer (in the upper 32-bit limb):

• The least-significant 2 bits represent a zero-based element index (range is 0-3)
• The next most significant 4 bits represent a zero-based byte index (range is 0-31)
• The remaining 26 bits represent an address space identifier

2. The lower 32-bit limb contains the word-aligned address, which forms the base address of the pointer.

Dereferencing a pointer of this type involves popping the pointer metadata, and determining what type of load to issue based on the size of the value being loaded, and where the start of the data is according to the metadata. Then the word-aligned address is popped and the value is loaded.

If the load is naturally aligned, i.e. the element index and byte offset are zero, and the size is exactly one element or word; then a mem_load or mem_loadw are issued and no further action is required. If the load is not naturally aligned, then either one or two words will be loaded, depending on the type being loaded, unused elements will be dropped, and if the byte offset is non-zero, the data will be shifted bitwise into alignment on an element boundary.

Struct(StructType)

A compound type of fixed shape and size

Array(Box<Type>, usize)

A vector of fixed size

List(Box<Type>)

A dynamically sized list of values of the given type

NOTE: Currently this only exists to support the Wasm Canonical ABI, but it has no defined represenation yet, so in practice cannot be used in most places except during initial translation in the Wasm frontend.

Implementations

impl Type

pub fn to_raw_parts(self) -> Option<SmallVec<[Type; 4]>>

Convert this type into a vector of types corresponding to how this type will be represented in memory.

The largest “part” size is 32 bits, so types that fit in 32 bits remain unchanged. For types larger than 32 bits, they will be broken up into parts that do fit in 32 bits, preserving accurate types to the extent possible. For types smaller than 32 bits, they will be merged into packed structs no larger than 32 bits, to preserve the type information, and make it possible to reason about how to extract parts of the original type.

For an example, a struct of type { *ptr, u8, u8 } will be encoded on the operand stack as [*ptr, {u8, u8}], where the first value is the 32-bit pointer field, and the remaining fields are encoded as a 16-bit struct in the second value.

pub fn split(self, n: usize) -> (Type, Option<Type>)

Split this type into two parts:

• The first part is no more than n bytes in size, and may contain the type itself if it fits
• The second part is None if the first part is smaller than or equal in size to the requested split size
• The second part is Some if there is data left in the original type after the split. This part will be a type that attempts to preserve, to the extent possible, the original type structure, but will fall back to an array of bytes if a larger type must be split down the middle somewhere.

pub fn min_alignment(&self) -> usize

Returns the minimum alignment, in bytes, of this type

pub fn size_in_bits(&self) -> usize

Returns the size in bits of this type, without alignment padding.

pub fn size_in_bytes(&self) -> usize

Returns the minimum number of bytes required to store a value of this type

pub fn aligned_size_in_bytes(&self) -> usize

Same as size_in_bytes, but with sufficient padding to guarantee alignment of the value.

pub fn size_in_felts(&self) -> usize

Returns the size in field elements of this type

pub fn size_in_words(&self) -> usize

Returns the size in words of this type

pub fn layout(&self) -> Layout

Returns the layout of this type in memory

pub fn is_loadable(&self) -> bool

Returns true if this type can be loaded on to the operand stack

The rule for “loadability” is a bit arbitrary, but the purpose is to force users of the IR to either pass large values by reference, or calculate the addresses of the individual fields needed from a large structure or array, and issue loads/stores against those instead.

In effect, we reject loads of values that are larger than a single word, as that is the largest value which can be worked with on the operand stack of the Miden VM.

impl Type

pub fn is_zst(&self) -> bool

Returns true if this type is a zero-sized type, which includes:

• Types with no size, e.g. Type::Unit
• Zero-sized arrays
• Arrays with a zero-sized element type
• Structs composed of nothing but zero-sized fields

pub fn is_numeric(&self) -> bool

pub fn is_integer(&self) -> bool

pub fn is_signed_integer(&self) -> bool

pub fn is_unsigned_integer(&self) -> bool

pub fn as_unsigned(&self) -> Type

Get this type as its unsigned integral twin, e.g. i32 becomes u32.

This function will panic if the type is not an integer type, or has no unsigned representation

pub fn as_signed(&self) -> Type

Get this type as its signed integral twin, e.g. u32 becomes i32.

This function will panic if the type is not an integer type, or has no signed representation

pub fn is_float(&self) -> bool

pub fn is_felt(&self) -> bool

pub fn is_pointer(&self) -> bool

pub fn is_struct(&self) -> bool

pub fn is_array(&self) -> bool

pub fn is_compatible_operand(&self, other: &Type) -> bool

Returns true if self and other are compatible operand types for a binary operator, e.g. add

In short, the rules are as follows:

• The operand order is assumed to be self <op> other, i.e. op is being applied to self using other. The left-hand operand is used as the “controlling” type for the operator, i.e. it determines what instruction will be used to perform the operation.
• The operand types must be numeric, or support being manipulated numerically
• If the controlling type is unsigned, it is never compatible with signed types, because Miden instructions for unsigned types use a simple unsigned binary encoding, thus they will not handle signed operands using two’s complement correctly.
• If the controlling type is signed, it is compatible with both signed and unsigned types, as long as the values fit in the range of the controlling type, e.g. adding a u16 to an i32 is fine, but adding a u32 to an i32 is not.
• Pointer types are permitted to be the controlling type, and since they are represented using u32, they have the same compatibility set as u32 does. In all other cases, pointer types are treated the same as any other non-numeric type.
• Non-numeric types are always incompatible, since no operators support these types

pub fn pointee(&self) -> Option<&Type>

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl Display for Type

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

Print this type for display using the provided module context

impl From<&Immediate> for Type

fn from(imm: &Immediate) -> Self

Converts to this type from the input type.

impl From<Immediate> for Type

fn from(imm: Immediate) -> Self

Converts to this type from the input type.

impl From<StructType> for Type

fn from(ty: StructType) -> Type

Converts to this type from the input type.

impl Hash for Type

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

where __H: Hasher,

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 Type

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

type Debug = Type

const DEFAULT: Self = Type::Felt

A value of this type which represents the “zero” value for the type

fn debug(&self) -> Self::Debug

Format this stack element for display

impl TryFrom<Type> for StructType

type Error = Type

The type returned in the event of a conversion error.

fn try_from( ty: Type, ) -> Result<StructType, <StructType as TryFrom<Type>>::Error>

Performs the conversion.

impl Eq for Type

impl StructuralPartialEq for Type