Struct llhd::ir::InstBuilder

pub struct InstBuilder<B> { /* fields omitted */ }

A temporary object used to construct a single instruction.

Methods

impl<B> InstBuilder<B>

pub fn new(builder: B) -> Self

Create a new instruction builder that inserts into builder.

impl<'_, B: UnitBuilder> InstBuilder<&'_ mut B>

pub fn const_int(
    &mut self,
    width: usize,
    sig: bool,
    value: impl Into<BigInt>
) -> Value

a = const iN[$]? imm

pub fn const_time(&mut self, value: impl Into<ConstTime>) -> Value

a = const time imm

pub fn alias(&mut self, x: Value) -> Value

a = x

pub fn array_uniform(&mut self, imm: usize, x: Value) -> Value

a = array imm, type x

pub fn array(&mut self, args: Vec<Value>) -> Value

a = array args

pub fn strukt(&mut self, args: Vec<Value>) -> Value

a = struct args

pub fn not(&mut self, x: Value) -> Value

a = not type x, y

pub fn neg(&mut self, x: Value) -> Value

a = neg type x, y

pub fn add(&mut self, x: Value, y: Value) -> Value

a = add type x, y

pub fn sub(&mut self, x: Value, y: Value) -> Value

a = sub type x, y

pub fn and(&mut self, x: Value, y: Value) -> Value

a = and type x, y

pub fn or(&mut self, x: Value, y: Value) -> Value

a = or type x, y

pub fn xor(&mut self, x: Value, y: Value) -> Value

a = xor type x, y

pub fn smul(&mut self, x: Value, y: Value) -> Value

a = smul type x, y

pub fn sdiv(&mut self, x: Value, y: Value) -> Value

a = sdiv type x, y

pub fn smod(&mut self, x: Value, y: Value) -> Value

a = smod type x, y

pub fn srem(&mut self, x: Value, y: Value) -> Value

a = srem type x, y

pub fn umul(&mut self, x: Value, y: Value) -> Value

a = umul type x, y

pub fn udiv(&mut self, x: Value, y: Value) -> Value

a = udiv type x, y

pub fn umod(&mut self, x: Value, y: Value) -> Value

a = umod type x, y

pub fn urem(&mut self, x: Value, y: Value) -> Value

a = urem type x, y

pub fn eq(&mut self, x: Value, y: Value) -> Value

a = eq type x, y

pub fn neq(&mut self, x: Value, y: Value) -> Value

a = neq type x, y

pub fn slt(&mut self, x: Value, y: Value) -> Value

a = slt type x, y

pub fn sgt(&mut self, x: Value, y: Value) -> Value

a = sgt type x, y

pub fn sle(&mut self, x: Value, y: Value) -> Value

a = sle type x, y

pub fn sge(&mut self, x: Value, y: Value) -> Value

a = sge type x, y

pub fn ult(&mut self, x: Value, y: Value) -> Value

a = ult type x, y

pub fn ugt(&mut self, x: Value, y: Value) -> Value

a = ugt type x, y

pub fn ule(&mut self, x: Value, y: Value) -> Value

a = ule type x, y

pub fn uge(&mut self, x: Value, y: Value) -> Value

a = uge type x, y

pub fn shl(&mut self, x: Value, y: Value, z: Value) -> Value

a = shl type x, y, z

pub fn shr(&mut self, x: Value, y: Value, z: Value) -> Value

a = shr type x, y, z

pub fn mux(&mut self, x: Value, y: Value) -> Value

a = mux type x, y

pub fn reg(&mut self, x: Value, data: Vec<(Value, RegMode, Value)>) -> Value

a = reg type init (, data mode trigger)*

pub fn ins_field(&mut self, x: Value, y: Value, imm: usize) -> Value

a = insf type x, y, imm

pub fn ins_slice(
    &mut self,
    x: Value,
    y: Value,
    imm0: usize,
    imm1: usize
) -> Value

a = inss type x, y, imm0, imm1

pub fn ext_field(&mut self, x: Value, imm: usize) -> Value

a = extf type x, imm

pub fn ext_slice(&mut self, x: Value, imm0: usize, imm1: usize) -> Value

a = exts type x, imm0, imm1

pub fn con(&mut self, x: Value, y: Value) -> Inst

con type x, y

pub fn del(&mut self, x: Value, y: Value) -> Inst

a = del type x, y

pub fn call(&mut self, unit: ExtUnit, args: Vec<Value>) -> Inst

a = call type unit (args...)

pub fn inst(
    &mut self,
    unit: ExtUnit,
    inputs: Vec<Value>,
    outputs: Vec<Value>
) -> Inst

inst unit (inputs...) -> (outputs...)

pub fn sig(&mut self, x: Value) -> Value

a = sig type x

pub fn prb(&mut self, x: Value) -> Value

a = prb type x

pub fn drv(&mut self, x: Value, y: Value, z: Value) -> Inst

drv type x, y, z

pub fn var(&mut self, x: Value) -> Value

a = var type x

pub fn ld(&mut self, x: Value) -> Value

a = ld type x

pub fn st(&mut self, x: Value, y: Value) -> Inst

st type x, y

pub fn halt(&mut self) -> Inst

halt

pub fn ret(&mut self) -> Inst

ret

pub fn ret_value(&mut self, x: Value) -> Inst

ret type x

pub fn br(&mut self, bb: Block) -> Inst

br bb

pub fn br_cond(&mut self, x: Value, bb0: Block, bb1: Block) -> Inst

br x, bb0, bb1

pub fn wait(&mut self, bb: Block, args: Vec<Value>) -> Inst

wait bb, args

pub fn wait_time(&mut self, bb: Block, time: Value, args: Vec<Value>) -> Inst

wait bb, time, args