Enum Aggregate 

#[non_exhaustive]
pub enum Aggregate {
    Struct {
        fields: Vec<MemType>,
        packed: bool,
    },
    Array {
        elem: MemType,
        len: u64,
    },
}

An aggregate memory type: a struct or a fixed-length array.

An aggregate may name only aggregates declared before it, so layouts are computed in declaration order and a recursive aggregate is impossible (recursion goes through ptr, which is opaque).

Examples

use ir_lang::{Aggregate, MemType, Module, Type};

let mut m = Module::new("demo");
let pair = m.declare_aggregate(Aggregate::structure(&[Type::U8.into(), Type::I64.into()]))?;
let layout = m.layout(pair.into()).unwrap();
assert_eq!((layout.size(), layout.align()), (16, 8));
assert_eq!(m.field_offset(pair, 1), Some(8));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Struct

Fields laid out in order. Unless packed, each field is placed at the next multiple of its alignment and the size is rounded up to the struct’s alignment (the C rule); a packed struct has alignment 1 and no padding.

Fields

fields: Vec<MemType>

The field types, in order.

packed: bool

Whether the struct is packed.

Array

len elements of elem, each at a stride of the element’s size.

Fields

elem: MemType

The element type.

len: u64

The element count.

Implementations

impl Aggregate

pub fn structure(fields: &[MemType]) -> Aggregate

A (non-packed) struct with the given fields.

Examples

use ir_lang::{Aggregate, Type};

let s = Aggregate::structure(&[Type::I32.into()]);
assert!(matches!(s, Aggregate::Struct { packed: false, .. }));

pub fn packed(fields: &[MemType]) -> Aggregate

A packed struct (alignment 1, no padding) with the given fields.

Examples

use ir_lang::{Aggregate, Type};

let s = Aggregate::packed(&[Type::U8.into(), Type::U32.into()]);
assert!(matches!(s, Aggregate::Struct { packed: true, .. }));

pub fn array(elem: MemType, len: u64) -> Aggregate

An array of len elements.

Examples

use ir_lang::{Aggregate, Type};

let a = Aggregate::array(Type::F64.into(), 4);
assert!(matches!(a, Aggregate::Array { len: 4, .. }));

Trait Implementations

impl Clone for Aggregate

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Aggregate

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

Formats the value using the given formatter.

impl Eq for Aggregate

impl Hash for Aggregate

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 Aggregate

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Aggregate