Enum NativeInst 

pub enum NativeInst {
    LoadImm {
        dst: Register,
        ty: NativeType,
        value: i64,
    },
    Add {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Sub {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Mul {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Div {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    And {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Or {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Xor {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Shl {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Shr {
        dst: Register,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Cmp {
        dst: Register,
        cc: CondCode,
        ty: NativeType,
        lhs: NativeValue,
        rhs: NativeValue,
    },
    Br {
        target: BlockId,
    },
    CondBr {
        cond: NativeValue,
        then_target: BlockId,
        else_target: BlockId,
    },
    Call {
        dst: Option<Register>,
        func: NativeValue,
        args: Vec<NativeValue>,
        ret_type: NativeType,
    },
    Ret {
        value: Option<NativeValue>,
    },
    Load {
        dst: Register,
        ty: NativeType,
        addr: NativeValue,
    },
    Store {
        ty: NativeType,
        addr: NativeValue,
        value: NativeValue,
    },
    Alloc {
        dst: Register,
        size: usize,
        align: usize,
    },
    Free {
        ptr: NativeValue,
    },
    Phi {
        dst: Register,
        ty: NativeType,
        incoming: Vec<(NativeValue, BlockId)>,
    },
    Select {
        dst: Register,
        ty: NativeType,
        cond: NativeValue,
        true_val: NativeValue,
        false_val: NativeValue,
    },
    Copy {
        dst: Register,
        src: NativeValue,
    },
    Nop,
    Comment(String),
    IntToPtr {
        dst: Register,
        src: NativeValue,
    },
    PtrToInt {
        dst: Register,
        src: NativeValue,
    },
    GetElementPtr {
        dst: Register,
        base: NativeValue,
        offset: NativeValue,
        elem_size: usize,
    },
    Switch {
        value: NativeValue,
        default: BlockId,
        targets: Vec<(u64, BlockId)>,
    },
}

A single instruction in the native IR.

Variants

LoadImm

Load immediate: dst = imm.

Fields

dst: Register

ty: NativeType

value: i64

Add

Add: dst = lhs + rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Sub

Subtract: dst = lhs - rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Mul

Multiply: dst = lhs * rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Div

Divide: dst = lhs / rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

And

Bitwise AND: dst = lhs & rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Or

Bitwise OR: dst = lhs | rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Xor

Bitwise XOR: dst = lhs ^ rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Shl

Shift left: dst = lhs << rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Shr

Shift right (arithmetic): dst = lhs >> rhs.

Fields

dst: Register

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Cmp

Compare: dst = cmp(cc, lhs, rhs).

Fields

dst: Register

cc: CondCode

ty: NativeType

lhs: NativeValue

rhs: NativeValue

Br

Unconditional branch to a block.

Fields

target: BlockId

CondBr

Conditional branch: if cond != 0, goto then_target, else goto else_target.

Fields

cond: NativeValue

then_target: BlockId

else_target: BlockId

Call

Function call: dst = func(args...).

Fields

dst: Option<Register>

func: NativeValue

args: Vec<NativeValue>

ret_type: NativeType

Ret

Return from function.

Fields

value: Option<NativeValue>

Load

Load from memory: dst = *addr.

Fields

dst: Register

ty: NativeType

addr: NativeValue

Store

Store to memory: *addr = value.

Fields

ty: NativeType

addr: NativeValue

value: NativeValue

Alloc

Allocate stack space: dst = alloca(size, align).

Fields

dst: Register

size: usize

align: usize

Free

Free heap memory.

Fields

ptr: NativeValue

Phi

Phi node (SSA): dst = phi([(val, block), ...]).

Fields

dst: Register

ty: NativeType

incoming: Vec<(NativeValue, BlockId)>

Select

Select: dst = cond ? true_val : false_val.

Fields

dst: Register

ty: NativeType

cond: NativeValue

true_val: NativeValue

false_val: NativeValue

Copy

Copy: dst = src.

Fields

dst: Register

src: NativeValue

Nop

No-operation (placeholder).

Comment(String)

Comment (for debugging).

IntToPtr

Integer to pointer cast.

Fields

dst: Register

src: NativeValue

PtrToInt

Pointer to integer cast.

Fields

dst: Register

src: NativeValue

GetElementPtr

Get element pointer (pointer arithmetic).

Fields

dst: Register

base: NativeValue

offset: NativeValue

elem_size: usize

Switch

Switch/table branch.

Fields

value: NativeValue

default: BlockId

targets: Vec<(u64, BlockId)>

Implementations

impl NativeInst

pub fn dst_reg(&self) -> Option<Register>

Get the destination register of this instruction, if any.

pub fn src_regs(&self) -> Vec<Register>

Get all source registers read by this instruction.

pub fn is_terminator(&self) -> bool

Whether this instruction is a terminator (ends a basic block).

Trait Implementations

impl Clone for NativeInst

fn clone(&self) -> NativeInst

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NativeInst

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

Formats the value using the given formatter.

impl PartialEq for NativeInst

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