Enum CfgInstData 

pub enum CfgInstData {
    Const(u64),
    FloatConst(u64),
    BoolConst(bool),
    StringConst(u32),
    Param {
        index: u32,
    },
    BlockParam {
        index: u32,
    },
    Add(CfgValue, CfgValue),
    Sub(CfgValue, CfgValue),
    Mul(CfgValue, CfgValue),
    Div(CfgValue, CfgValue),
    Mod(CfgValue, CfgValue),
    Eq(CfgValue, CfgValue),
    Ne(CfgValue, CfgValue),
    Lt(CfgValue, CfgValue),
    Gt(CfgValue, CfgValue),
    Le(CfgValue, CfgValue),
    Ge(CfgValue, CfgValue),
    BitAnd(CfgValue, CfgValue),
    BitOr(CfgValue, CfgValue),
    BitXor(CfgValue, CfgValue),
    Shl(CfgValue, CfgValue),
    Shr(CfgValue, CfgValue),
    Neg(CfgValue),
    Not(CfgValue),
    BitNot(CfgValue),
    Alloc {
        slot: u32,
        init: CfgValue,
    },
    Load {
        slot: u32,
    },
    Store {
        slot: u32,
        value: CfgValue,
    },
    ParamStore {
        param_slot: u32,
        value: CfgValue,
    },
    PlaceRead {
        place: Place,
    },
    PlaceWrite {
        place: Place,
        value: CfgValue,
    },
    Call {
        name: Spur,
        args_start: u32,
        args_len: u32,
    },
    Intrinsic {
        name: Spur,
        args_start: u32,
        args_len: u32,
    },
    StructInit {
        struct_id: StructId,
        fields_start: u32,
        fields_len: u32,
    },
    FieldSet {
        slot: u32,
        struct_id: StructId,
        field_index: u32,
        value: CfgValue,
    },
    ParamFieldSet {
        param_slot: u32,
        inner_offset: u32,
        struct_id: StructId,
        field_index: u32,
        value: CfgValue,
    },
    ArrayInit {
        elements_start: u32,
        elements_len: u32,
    },
    IndexSet {
        slot: u32,
        array_type: Type,
        index: CfgValue,
        value: CfgValue,
    },
    ParamIndexSet {
        param_slot: u32,
        array_type: Type,
        index: CfgValue,
        value: CfgValue,
    },
    EnumVariant {
        enum_id: EnumId,
        variant_index: u32,
    },
    EnumCreate {
        enum_id: EnumId,
        variant_index: u32,
        fields_start: u32,
        fields_len: u32,
    },
    EnumPayloadGet {
        base: CfgValue,
        variant_index: u32,
        field_index: u32,
    },
    IntCast {
        value: CfgValue,
        from_ty: Type,
    },
    FloatCast {
        value: CfgValue,
        from_ty: Type,
    },
    IntToFloat {
        value: CfgValue,
        from_ty: Type,
    },
    FloatToInt {
        value: CfgValue,
        from_ty: Type,
    },
    Drop {
        value: CfgValue,
    },
    StorageLive {
        slot: u32,
    },
    StorageDead {
        slot: u32,
    },
}

CFG instruction data.

Unlike AIR, there are NO control flow instructions here. Control flow is handled entirely by terminators.

Variants

Const(u64)

Integer constant (typed)

FloatConst(u64)

Floating-point constant, stored as f64 bits via f64::to_bits().

BoolConst(bool)

Boolean constant

StringConst(u32)

String constant (index into string table)

Param

Reference to a function parameter

Fields

index: u32

BlockParam

Block parameter (like phi, but explicit) Only valid at the start of a block

Fields

index: u32

Add(CfgValue, CfgValue)

Sub(CfgValue, CfgValue)

Mul(CfgValue, CfgValue)

Div(CfgValue, CfgValue)

Mod(CfgValue, CfgValue)

Eq(CfgValue, CfgValue)

Ne(CfgValue, CfgValue)

Lt(CfgValue, CfgValue)

Gt(CfgValue, CfgValue)

Le(CfgValue, CfgValue)

Ge(CfgValue, CfgValue)

BitAnd(CfgValue, CfgValue)

BitOr(CfgValue, CfgValue)

BitXor(CfgValue, CfgValue)

Shl(CfgValue, CfgValue)

Shr(CfgValue, CfgValue)

Neg(CfgValue)

Not(CfgValue)

BitNot(CfgValue)

Alloc

Allocate local variable with initial value

Fields

slot: u32

init: CfgValue

Load

Load value from local variable

Fields

slot: u32

Store

Store value to local variable

Fields

slot: u32

value: CfgValue

ParamStore

Store value to a parameter (for inout params)

Fields

param_slot: u32

value: CfgValue

PlaceRead

Read a value from a memory location.

This unifies Load, IndexGet, and FieldGet into a single instruction that can handle arbitrarily nested access patterns like arr[i].field.

Fields

place: Place

PlaceWrite

Write a value to a memory location.

This unifies Store, IndexSet, ParamIndexSet, FieldSet, and ParamFieldSet into a single instruction that can handle nested writes.

Fields

place: Place

value: CfgValue

Call

Function call. Arguments are stored in the Cfg’s call_args array. Use Cfg::get_call_args(args_start, args_len) to retrieve them.

Fields

name: Spur

Function name (interned symbol)

args_start: u32

Start index into Cfg’s call_args array

args_len: u32

Number of arguments

Intrinsic

Intrinsic call (e.g., @dbg). Arguments are stored in the Cfg’s extra array. Use Cfg::get_extra(args_start, args_len) to retrieve them.

Fields

name: Spur

Intrinsic name (interned symbol)

args_start: u32

Start index into Cfg’s extra array

args_len: u32

Number of arguments

StructInit

Struct initialization. Field values are stored in the Cfg’s extra array. Use Cfg::get_extra(fields_start, fields_len) to retrieve them.

Fields

struct_id: StructId

fields_start: u32

Start index into Cfg’s extra array

fields_len: u32

Number of fields

FieldSet

Fields

slot: u32

struct_id: StructId

field_index: u32

value: CfgValue

ParamFieldSet

Store a value to a struct field (for parameters, including inout)

Fields

param_slot: u32

The parameter’s ABI slot (relative to params, not locals)

inner_offset: u32

Offset within the struct for nested field access

struct_id: StructId

field_index: u32

value: CfgValue

ArrayInit

Array initialization. Element values are stored in the Cfg’s extra array. Use Cfg::get_extra(elements_start, elements_len) to retrieve them. The array type is stored in CfgInst.ty.

Fields

elements_start: u32

Start index into Cfg’s extra array

elements_len: u32

Number of elements

IndexSet

Store a value to an array element.

Fields

slot: u32

array_type: Type

The array type (for bounds checking and element size)

index: CfgValue

value: CfgValue

ParamIndexSet

Store a value to an array element of an inout parameter

Fields

param_slot: u32

The parameter’s ABI slot (relative to params, not locals)

array_type: Type

The array type (for bounds checking and element size)

index: CfgValue

Index expression

value: CfgValue

Value to store

EnumVariant

Create an enum variant (discriminant value) for unit-only enums.

Fields

enum_id: EnumId

variant_index: u32

EnumCreate

Create a data enum variant with associated field values. Used when the enum has at least one data variant. Field values are stored in the Cfg’s extra array.

Fields

enum_id: EnumId

variant_index: u32

fields_start: u32

Start index into Cfg’s extra array for field CfgValues

fields_len: u32

Number of field values

EnumPayloadGet

Extract a field value from an enum variant’s payload. Used in data variant match arm bodies to bind pattern variables.

Fields

base: CfgValue

The enum value to extract from

variant_index: u32

The variant index (must match the arm’s pattern)

field_index: u32

The field index within the variant

IntCast

Integer cast: convert between integer types with runtime range check. Panics if the value cannot be represented in the target type. The target type is stored in CfgInst.ty.

Fields

value: CfgValue

The value to cast

from_ty: Type

The source type (for determining signedness and size)

FloatCast

Float cast: convert between floating-point types (fptrunc/fpext). The target type is stored in CfgInst.ty.

Fields

value: CfgValue

The value to cast

from_ty: Type

The source float type

IntToFloat

Integer to float conversion (sitofp/uitofp). The target type is stored in CfgInst.ty.

Fields

value: CfgValue

The integer value to convert

from_ty: Type

The source integer type (for determining signedness)

FloatToInt

Float to integer conversion (fptosi/fptoui) with runtime range check. Panics if the value is NaN or out of range of the target integer type. The target type is stored in CfgInst.ty.

Fields

value: CfgValue

The float value to convert

from_ty: Type

The source float type

Drop

Drop a value, running its destructor if the type has one. For trivially droppable types, this is a no-op that will be elided.

Fields

value: CfgValue

StorageLive

Marks that a local slot becomes live (storage allocated). The slot is now valid to write to.

Fields

slot: u32

StorageDead

Marks that a local slot becomes dead (storage can be deallocated). The slot is now invalid to read from. Drop elaboration inserts Drop before this if the type needs drop.

Fields

slot: u32

Trait Implementations

impl Clone for CfgInstData

fn clone(&self) -> CfgInstData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CfgInstData

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

Formats the value using the given formatter.