Enum TypeRepr 

pub enum TypeRepr {
    Default,
    Align(NonZero<u16>),
    Packed(NonZero<u16>),
    Transparent,
    BigEndian,
}

This represents metadata about how a structured type will be represented in memory

Variants

Default

This corresponds to the C ABI representation for a given type

Align(NonZero<u16>)

This modifies the default representation, by raising the minimum alignment.

The alignment must be a power of two, e.g. 32, and values from 1 to 2^16 are allowed.

The alignment must be greater than the default minimum alignment of the type or this representation has no effect.

Packed(NonZero<u16>)

This modifies the default representation, by lowering the minimum alignment of a type, and in the case of structs, changes the alignments of the fields to be the smaller of the specified alignment and the default alignment. This has the effect of changing the layout of a struct.

Notably, Packed(1) will result in a struct that has no alignment requirement, and no padding between fields.

The alignment must be a power of two, e.g. 32, and values from 1 to 2^16 are allowed.

The alignment must be smaller than the default alignment, or this representation has no effect.

Transparent

This may only be used on structs with no more than one non-zero sized field, and indicates that the representation of that field should be used for the struct.

BigEndian

This is equivalent to the default representation, except it indicates that if multiple field elements are required to represent the value on Miden’s operand stack (i.e. the value is larger than 4 bytes), then the field elements will be ordered on the operand stack with the highest-addressed bytes at the top.

Normally, types are laid out in natural order (i.e. lowest-addressed bytes on top of the stack), and when lowering word-sized loads/stores, we are required to reverse the order of the elements into big-endian order.

This representation essentially disables this implicit reversal, keeping elements on the operand stack in the order produced by mem_loadw.

NOTE: This is meant to be a temporary work around to permit us to represent some legacy types in the transaction kernel API which use a different representation on the operand stack than in memory - this will be deprecated in the future.

Implementations

impl TypeRepr

pub fn packed(align: u16) -> TypeRepr

Construct a packed representation with the given alignment

pub fn align(align: u16) -> TypeRepr

Construct a representation with the given minimum alignment

pub fn is_transparent(&self) -> bool

Return true if this type representation is transparent

pub fn is_packed(&self) -> bool

Return true if this type representation is packed

pub fn min_alignment(&self) -> Option<usize>

Get the custom alignment given for this type representation, if applicable

Trait Implementations

impl Clone for TypeRepr

fn clone(&self) -> TypeRepr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeRepr

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

Formats the value using the given formatter.

impl Default for TypeRepr

fn default() -> TypeRepr

Returns the “default value” for a type.

impl Display for TypeRepr

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

Formats the value using the given formatter.

impl Hash for TypeRepr

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 TypeRepr

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

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Copy for TypeRepr

impl Eq for TypeRepr

impl StructuralPartialEq for TypeRepr