pub trait InstBuilder<'f>: InstBuilderBase<'f> {
#[allow(non_snake_case)]
fn jump(mut self, EBB: ir::Ebb, args: &[Value]) -> Inst {
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
self.Jump(Opcode::Jump, types::INVALID, EBB, vlist).0
}
#[allow(non_snake_case)]
fn fallthrough(mut self, EBB: ir::Ebb, args: &[Value]) -> Inst {
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
self.Jump(Opcode::Fallthrough, types::INVALID, EBB, vlist).0
}
#[allow(non_snake_case)]
fn brz(mut self, c: ir::Value, EBB: ir::Ebb, args: &[Value]) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(c);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(c, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.Branch(Opcode::Brz, ctrl_typevar, EBB, vlist).0
}
#[allow(non_snake_case)]
fn brnz(mut self, c: ir::Value, EBB: ir::Ebb, args: &[Value]) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(c);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(c, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.Branch(Opcode::Brnz, ctrl_typevar, EBB, vlist).0
}
#[allow(non_snake_case)]
fn br_icmp<T1intcc: Into<ir::condcodes::IntCC>>(mut self, Cond: T1intcc, x: ir::Value, y: ir::Value, EBB: ir::Ebb, args: &[Value]) -> Inst {
let Cond = Cond.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(x, pool);
vlist.push(y, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.BranchIcmp(Opcode::BrIcmp, ctrl_typevar, Cond, EBB, vlist).0
}
#[allow(non_snake_case)]
fn brif<T1intcc: Into<ir::condcodes::IntCC>>(mut self, Cond: T1intcc, f: ir::Value, EBB: ir::Ebb, args: &[Value]) -> Inst {
let Cond = Cond.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(f, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.BranchInt(Opcode::Brif, types::INVALID, Cond, EBB, vlist).0
}
#[allow(non_snake_case)]
fn brff<T1floatcc: Into<ir::condcodes::FloatCC>>(mut self, Cond: T1floatcc, f: ir::Value, EBB: ir::Ebb, args: &[Value]) -> Inst {
let Cond = Cond.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(f, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.BranchFloat(Opcode::Brff, types::INVALID, Cond, EBB, vlist).0
}
#[allow(non_snake_case)]
fn br_table(self, x: ir::Value, EBB: ir::Ebb, JT: ir::JumpTable) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.BranchTable(Opcode::BrTable, ctrl_typevar, EBB, JT, x).0
}
#[allow(non_snake_case)]
fn jump_table_entry<T1uimm8: Into<ir::immediates::Uimm8>>(self, x: ir::Value, addr: ir::Value, Size: T1uimm8, JT: ir::JumpTable) -> Value {
let Size = Size.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BranchTableEntry(Opcode::JumpTableEntry, ctrl_typevar, Size, JT, x, addr);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn jump_table_base(self, iAddr: crate::ir::Type, JT: ir::JumpTable) -> Value {
let (inst, dfg) = self.BranchTableBase(Opcode::JumpTableBase, iAddr, JT);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn indirect_jump_table_br(self, addr: ir::Value, JT: ir::JumpTable) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(addr);
self.IndirectJump(Opcode::IndirectJumpTableBr, ctrl_typevar, JT, addr).0
}
#[allow(non_snake_case)]
fn debugtrap(self) -> Inst {
self.NullAry(Opcode::Debugtrap, types::INVALID).0
}
#[allow(non_snake_case)]
fn trap<T1trapcode: Into<ir::TrapCode>>(self, code: T1trapcode) -> Inst {
let code = code.into();
self.Trap(Opcode::Trap, types::INVALID, code).0
}
#[allow(non_snake_case)]
fn trapz<T1trapcode: Into<ir::TrapCode>>(self, c: ir::Value, code: T1trapcode) -> Inst {
let code = code.into();
let ctrl_typevar = self.data_flow_graph().value_type(c);
self.CondTrap(Opcode::Trapz, ctrl_typevar, code, c).0
}
#[allow(non_snake_case)]
fn resumable_trap<T1trapcode: Into<ir::TrapCode>>(self, code: T1trapcode) -> Inst {
let code = code.into();
self.Trap(Opcode::ResumableTrap, types::INVALID, code).0
}
#[allow(non_snake_case)]
fn trapnz<T1trapcode: Into<ir::TrapCode>>(self, c: ir::Value, code: T1trapcode) -> Inst {
let code = code.into();
let ctrl_typevar = self.data_flow_graph().value_type(c);
self.CondTrap(Opcode::Trapnz, ctrl_typevar, code, c).0
}
#[allow(non_snake_case)]
fn trapif<T1intcc: Into<ir::condcodes::IntCC>, T2trapcode: Into<ir::TrapCode>>(self, Cond: T1intcc, f: ir::Value, code: T2trapcode) -> Inst {
let Cond = Cond.into();
let code = code.into();
self.IntCondTrap(Opcode::Trapif, types::INVALID, Cond, code, f).0
}
#[allow(non_snake_case)]
fn trapff<T1floatcc: Into<ir::condcodes::FloatCC>, T2trapcode: Into<ir::TrapCode>>(self, Cond: T1floatcc, f: ir::Value, code: T2trapcode) -> Inst {
let Cond = Cond.into();
let code = code.into();
self.FloatCondTrap(Opcode::Trapff, types::INVALID, Cond, code, f).0
}
#[allow(non_snake_case)]
fn return_(mut self, rvals: &[Value]) -> Inst {
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(rvals.iter().cloned(), pool);
}
self.MultiAry(Opcode::Return, types::INVALID, vlist).0
}
#[allow(non_snake_case)]
fn fallthrough_return(mut self, rvals: &[Value]) -> Inst {
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(rvals.iter().cloned(), pool);
}
self.MultiAry(Opcode::FallthroughReturn, types::INVALID, vlist).0
}
#[allow(non_snake_case)]
fn call(mut self, FN: ir::FuncRef, args: &[Value]) -> Inst {
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
self.Call(Opcode::Call, types::INVALID, FN, vlist).0
}
#[allow(non_snake_case)]
fn call_indirect(mut self, SIG: ir::SigRef, callee: ir::Value, args: &[Value]) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(callee);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(callee, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.CallIndirect(Opcode::CallIndirect, ctrl_typevar, SIG, vlist).0
}
#[allow(non_snake_case)]
fn func_addr(self, iAddr: crate::ir::Type, FN: ir::FuncRef) -> Value {
let (inst, dfg) = self.FuncAddr(Opcode::FuncAddr, iAddr, FN);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn load<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, Mem: crate::ir::Type, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let (inst, dfg) = self.Load(Opcode::Load, Mem, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn load_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, Mem: crate::ir::Type, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::LoadComplex, Mem, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn store<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, MemFlags: T1memflags, x: ir::Value, p: ir::Value, Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.Store(Opcode::Store, ctrl_typevar, MemFlags, Offset, x, p).0
}
#[allow(non_snake_case)]
fn store_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, MemFlags: T1memflags, x: ir::Value, args: &[Value], Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(x, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.StoreComplex(Opcode::StoreComplex, ctrl_typevar, MemFlags, Offset, vlist).0
}
#[allow(non_snake_case)]
fn uload8<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, iExt8: crate::ir::Type, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let (inst, dfg) = self.Load(Opcode::Uload8, iExt8, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn uload8_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, iExt8: crate::ir::Type, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::Uload8Complex, iExt8, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sload8<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, iExt8: crate::ir::Type, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let (inst, dfg) = self.Load(Opcode::Sload8, iExt8, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sload8_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, iExt8: crate::ir::Type, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::Sload8Complex, iExt8, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn istore8<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, MemFlags: T1memflags, x: ir::Value, p: ir::Value, Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.Store(Opcode::Istore8, ctrl_typevar, MemFlags, Offset, x, p).0
}
#[allow(non_snake_case)]
fn istore8_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, MemFlags: T1memflags, x: ir::Value, args: &[Value], Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(x, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.StoreComplex(Opcode::Istore8Complex, ctrl_typevar, MemFlags, Offset, vlist).0
}
#[allow(non_snake_case)]
fn uload16<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, iExt16: crate::ir::Type, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let (inst, dfg) = self.Load(Opcode::Uload16, iExt16, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn uload16_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, iExt16: crate::ir::Type, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::Uload16Complex, iExt16, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sload16<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, iExt16: crate::ir::Type, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let (inst, dfg) = self.Load(Opcode::Sload16, iExt16, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sload16_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, iExt16: crate::ir::Type, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::Sload16Complex, iExt16, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn istore16<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, MemFlags: T1memflags, x: ir::Value, p: ir::Value, Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.Store(Opcode::Istore16, ctrl_typevar, MemFlags, Offset, x, p).0
}
#[allow(non_snake_case)]
fn istore16_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, MemFlags: T1memflags, x: ir::Value, args: &[Value], Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(x, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.StoreComplex(Opcode::Istore16Complex, ctrl_typevar, MemFlags, Offset, vlist).0
}
#[allow(non_snake_case)]
fn uload32<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(p);
let (inst, dfg) = self.Load(Opcode::Uload32, ctrl_typevar, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn uload32_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::Uload32Complex, types::INVALID, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sload32<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, MemFlags: T1memflags, p: ir::Value, Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(p);
let (inst, dfg) = self.Load(Opcode::Sload32, ctrl_typevar, MemFlags, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sload32_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, MemFlags: T1memflags, args: &[Value], Offset: T2offset32) -> Value {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
let (inst, dfg) = self.LoadComplex(Opcode::Sload32Complex, types::INVALID, MemFlags, Offset, vlist);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn istore32<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(self, MemFlags: T1memflags, x: ir::Value, p: ir::Value, Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.Store(Opcode::Istore32, ctrl_typevar, MemFlags, Offset, x, p).0
}
#[allow(non_snake_case)]
fn istore32_complex<T1memflags: Into<ir::MemFlags>, T2offset32: Into<ir::immediates::Offset32>>(mut self, MemFlags: T1memflags, x: ir::Value, args: &[Value], Offset: T2offset32) -> Inst {
let MemFlags = MemFlags.into();
let Offset = Offset.into();
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.push(x, pool);
vlist.extend(args.iter().cloned(), pool);
}
self.StoreComplex(Opcode::Istore32Complex, types::INVALID, MemFlags, Offset, vlist).0
}
#[allow(non_snake_case)]
fn stack_load<T1offset32: Into<ir::immediates::Offset32>>(self, Mem: crate::ir::Type, SS: ir::StackSlot, Offset: T1offset32) -> Value {
let Offset = Offset.into();
let (inst, dfg) = self.StackLoad(Opcode::StackLoad, Mem, SS, Offset);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn stack_store<T1offset32: Into<ir::immediates::Offset32>>(self, x: ir::Value, SS: ir::StackSlot, Offset: T1offset32) -> Inst {
let Offset = Offset.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.StackStore(Opcode::StackStore, ctrl_typevar, SS, Offset, x).0
}
#[allow(non_snake_case)]
fn stack_addr<T1offset32: Into<ir::immediates::Offset32>>(self, iAddr: crate::ir::Type, SS: ir::StackSlot, Offset: T1offset32) -> Value {
let Offset = Offset.into();
let (inst, dfg) = self.StackLoad(Opcode::StackAddr, iAddr, SS, Offset);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn global_value(self, Mem: crate::ir::Type, GV: ir::GlobalValue) -> Value {
let (inst, dfg) = self.UnaryGlobalValue(Opcode::GlobalValue, Mem, GV);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn symbol_value(self, Mem: crate::ir::Type, GV: ir::GlobalValue) -> Value {
let (inst, dfg) = self.UnaryGlobalValue(Opcode::SymbolValue, Mem, GV);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn heap_addr<T1uimm32: Into<ir::immediates::Uimm32>>(self, iAddr: crate::ir::Type, H: ir::Heap, p: ir::Value, Size: T1uimm32) -> Value {
let Size = Size.into();
let (inst, dfg) = self.HeapAddr(Opcode::HeapAddr, iAddr, H, Size, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn table_addr<T1offset32: Into<ir::immediates::Offset32>>(self, iAddr: crate::ir::Type, T: ir::Table, p: ir::Value, Offset: T1offset32) -> Value {
let Offset = Offset.into();
let (inst, dfg) = self.TableAddr(Opcode::TableAddr, iAddr, T, Offset, p);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn iconst<T1imm64: Into<ir::immediates::Imm64>>(self, Int: crate::ir::Type, N: T1imm64) -> Value {
let N = N.into();
let (inst, dfg) = self.UnaryImm(Opcode::Iconst, Int, N);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn f32const<T1ieee32: Into<ir::immediates::Ieee32>>(self, N: T1ieee32) -> Value {
let N = N.into();
let (inst, dfg) = self.UnaryIeee32(Opcode::F32const, types::INVALID, N);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn f64const<T1ieee64: Into<ir::immediates::Ieee64>>(self, N: T1ieee64) -> Value {
let N = N.into();
let (inst, dfg) = self.UnaryIeee64(Opcode::F64const, types::INVALID, N);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bconst<T1boolean: Into<bool>>(self, Bool: crate::ir::Type, N: T1boolean) -> Value {
let N = N.into();
let (inst, dfg) = self.UnaryBool(Opcode::Bconst, Bool, N);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn vconst<T1uimm128: Into<ir::Constant>>(self, TxN: crate::ir::Type, N: T1uimm128) -> Value {
let N = N.into();
let (inst, dfg) = self.UnaryImm128(Opcode::Vconst, TxN, N);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn null(self, Ref: crate::ir::Type) -> Value {
let (inst, dfg) = self.NullAry(Opcode::Null, Ref);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn nop(self) -> Inst {
self.NullAry(Opcode::Nop, types::INVALID).0
}
#[allow(non_snake_case)]
fn select(self, c: ir::Value, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Ternary(Opcode::Select, ctrl_typevar, c, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn selectif<T1intcc: Into<ir::condcodes::IntCC>>(self, Any: crate::ir::Type, cc: T1intcc, flags: ir::Value, x: ir::Value, y: ir::Value) -> Value {
let cc = cc.into();
let (inst, dfg) = self.IntSelect(Opcode::Selectif, Any, cc, flags, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn copy(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Copy, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn spill(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Spill, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fill(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Fill, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fill_nop(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::FillNop, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn regmove<T1regunit: Into<isa::RegUnit>, T2regunit: Into<isa::RegUnit>>(self, x: ir::Value, src: T1regunit, dst: T2regunit) -> Inst {
let src = src.into();
let dst = dst.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.RegMove(Opcode::Regmove, ctrl_typevar, src, dst, x).0
}
#[allow(non_snake_case)]
fn copy_special<T1regunit: Into<isa::RegUnit>, T2regunit: Into<isa::RegUnit>>(self, src: T1regunit, dst: T2regunit) -> Inst {
let src = src.into();
let dst = dst.into();
self.CopySpecial(Opcode::CopySpecial, types::INVALID, src, dst).0
}
#[allow(non_snake_case)]
fn copy_to_ssa<T1regunit: Into<isa::RegUnit>>(self, Any: crate::ir::Type, src: T1regunit) -> Value {
let src = src.into();
let (inst, dfg) = self.CopyToSsa(Opcode::CopyToSsa, Any, src);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn copy_nop(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::CopyNop, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn adjust_sp_down(self, delta: ir::Value) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(delta);
self.Unary(Opcode::AdjustSpDown, ctrl_typevar, delta).0
}
#[allow(non_snake_case)]
fn adjust_sp_up_imm<T1imm64: Into<ir::immediates::Imm64>>(self, Offset: T1imm64) -> Inst {
let Offset = Offset.into();
self.UnaryImm(Opcode::AdjustSpUpImm, types::INVALID, Offset).0
}
#[allow(non_snake_case)]
fn adjust_sp_down_imm<T1imm64: Into<ir::immediates::Imm64>>(self, Offset: T1imm64) -> Inst {
let Offset = Offset.into();
self.UnaryImm(Opcode::AdjustSpDownImm, types::INVALID, Offset).0
}
#[allow(non_snake_case)]
fn ifcmp_sp(self, addr: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(addr);
let (inst, dfg) = self.Unary(Opcode::IfcmpSp, ctrl_typevar, addr);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn regspill<T1regunit: Into<isa::RegUnit>>(self, x: ir::Value, src: T1regunit, SS: ir::StackSlot) -> Inst {
let src = src.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.RegSpill(Opcode::Regspill, ctrl_typevar, src, SS, x).0
}
#[allow(non_snake_case)]
fn regfill<T1regunit: Into<isa::RegUnit>>(self, x: ir::Value, SS: ir::StackSlot, dst: T1regunit) -> Inst {
let dst = dst.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.RegFill(Opcode::Regfill, ctrl_typevar, SS, dst, x).0
}
#[allow(non_snake_case)]
fn safepoint(mut self, args: &[Value]) -> Inst {
let mut vlist = ir::ValueList::default();
{
let pool = &mut self.data_flow_graph_mut().value_lists;
vlist.extend(args.iter().cloned(), pool);
}
self.MultiAry(Opcode::Safepoint, types::INVALID, vlist).0
}
#[allow(non_snake_case)]
fn vsplit(self, x: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Vsplit, ctrl_typevar, x);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn vconcat(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Vconcat, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn vselect(self, c: ir::Value, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Ternary(Opcode::Vselect, ctrl_typevar, c, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn splat(self, TxN: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Splat, TxN, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn insertlane<T1uimm8: Into<ir::immediates::Uimm8>>(self, x: ir::Value, Idx: T1uimm8, y: ir::Value) -> Value {
let Idx = Idx.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.InsertLane(Opcode::Insertlane, ctrl_typevar, Idx, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn extractlane<T1uimm8: Into<ir::immediates::Uimm8>>(self, x: ir::Value, Idx: T1uimm8) -> Value {
let Idx = Idx.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.ExtractLane(Opcode::Extractlane, ctrl_typevar, Idx, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn icmp<T1intcc: Into<ir::condcodes::IntCC>>(self, Cond: T1intcc, x: ir::Value, y: ir::Value) -> Value {
let Cond = Cond.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.IntCompare(Opcode::Icmp, ctrl_typevar, Cond, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn icmp_imm<T1intcc: Into<ir::condcodes::IntCC>, T2imm64: Into<ir::immediates::Imm64>>(self, Cond: T1intcc, x: ir::Value, Y: T2imm64) -> Value {
let Cond = Cond.into();
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.IntCompareImm(Opcode::IcmpImm, ctrl_typevar, Cond, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ifcmp(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Ifcmp, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ifcmp_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::IfcmpImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn iadd(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Iadd, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn isub(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Isub, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn imul(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Imul, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn umulhi(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Umulhi, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn smulhi(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Smulhi, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn udiv(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Udiv, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sdiv(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Sdiv, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn urem(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Urem, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn srem(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Srem, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn iadd_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::IaddImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn imul_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::ImulImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn udiv_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::UdivImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sdiv_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::SdivImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn urem_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::UremImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn srem_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::SremImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn irsub_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::IrsubImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn iadd_cin(self, x: ir::Value, y: ir::Value, c_in: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(y);
let (inst, dfg) = self.Ternary(Opcode::IaddCin, ctrl_typevar, x, y, c_in);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn iadd_cout(self, x: ir::Value, y: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::IaddCout, ctrl_typevar, x, y);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn iadd_carry(self, x: ir::Value, y: ir::Value, c_in: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(y);
let (inst, dfg) = self.Ternary(Opcode::IaddCarry, ctrl_typevar, x, y, c_in);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn isub_bin(self, x: ir::Value, y: ir::Value, b_in: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(y);
let (inst, dfg) = self.Ternary(Opcode::IsubBin, ctrl_typevar, x, y, b_in);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn isub_bout(self, x: ir::Value, y: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::IsubBout, ctrl_typevar, x, y);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn isub_borrow(self, x: ir::Value, y: ir::Value, b_in: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(y);
let (inst, dfg) = self.Ternary(Opcode::IsubBorrow, ctrl_typevar, x, y, b_in);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn band(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Band, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bor(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Bor, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bxor(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Bxor, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bnot(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Bnot, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn band_not(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::BandNot, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bor_not(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::BorNot, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bxor_not(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::BxorNot, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn band_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::BandImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bor_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::BorImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bxor_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::BxorImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn rotl(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Rotl, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn rotr(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Rotr, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn rotl_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::RotlImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn rotr_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::RotrImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ishl(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Ishl, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ushr(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Ushr, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sshr(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Sshr, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ishl_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::IshlImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ushr_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::UshrImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sshr_imm<T1imm64: Into<ir::immediates::Imm64>>(self, x: ir::Value, Y: T1imm64) -> Value {
let Y = Y.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.BinaryImm(Opcode::SshrImm, ctrl_typevar, Y, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bitrev(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Bitrev, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn clz(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Clz, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn cls(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Cls, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ctz(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Ctz, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn popcnt(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Popcnt, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcmp<T1floatcc: Into<ir::condcodes::FloatCC>>(self, Cond: T1floatcc, x: ir::Value, y: ir::Value) -> Value {
let Cond = Cond.into();
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.FloatCompare(Opcode::Fcmp, ctrl_typevar, Cond, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ffcmp(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Ffcmp, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fadd(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fadd, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fsub(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fsub, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fmul(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fmul, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fdiv(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fdiv, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sqrt(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Sqrt, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fma(self, x: ir::Value, y: ir::Value, z: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(y);
let (inst, dfg) = self.Ternary(Opcode::Fma, ctrl_typevar, x, y, z);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fneg(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Fneg, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fabs(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Fabs, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcopysign(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fcopysign, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fmin(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fmin, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fmax(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::Fmax, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ceil(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Ceil, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn floor(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Floor, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn trunc(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Trunc, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn nearest(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Nearest, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn is_null(self, x: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::IsNull, ctrl_typevar, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn trueif<T1intcc: Into<ir::condcodes::IntCC>>(self, Cond: T1intcc, f: ir::Value) -> Value {
let Cond = Cond.into();
let (inst, dfg) = self.IntCond(Opcode::Trueif, types::INVALID, Cond, f);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn trueff<T1floatcc: Into<ir::condcodes::FloatCC>>(self, Cond: T1floatcc, f: ir::Value) -> Value {
let Cond = Cond.into();
let (inst, dfg) = self.FloatCond(Opcode::Trueff, types::INVALID, Cond, f);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bitcast(self, MemTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Bitcast, MemTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn raw_bitcast(self, AnyTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::RawBitcast, AnyTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn scalar_to_vector(self, TxN: crate::ir::Type, s: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::ScalarToVector, TxN, s);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn breduce(self, BoolTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Breduce, BoolTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bextend(self, BoolTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Bextend, BoolTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bint(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Bint, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn bmask(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Bmask, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn ireduce(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Ireduce, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn uextend(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Uextend, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn sextend(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Sextend, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fpromote(self, FloatTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Fpromote, FloatTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fdemote(self, FloatTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::Fdemote, FloatTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcvt_to_uint(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::FcvtToUint, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcvt_to_uint_sat(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::FcvtToUintSat, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcvt_to_sint(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::FcvtToSint, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcvt_to_sint_sat(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::FcvtToSintSat, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcvt_from_uint(self, FloatTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::FcvtFromUint, FloatTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn fcvt_from_sint(self, FloatTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::FcvtFromSint, FloatTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn isplit(self, x: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::Isplit, ctrl_typevar, x);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn iconcat(self, lo: ir::Value, hi: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(lo);
let (inst, dfg) = self.Binary(Opcode::Iconcat, ctrl_typevar, lo, hi);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn x86_udivmodx(self, nlo: ir::Value, nhi: ir::Value, d: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(nhi);
let (inst, dfg) = self.Ternary(Opcode::X86Udivmodx, ctrl_typevar, nlo, nhi, d);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn x86_sdivmodx(self, nlo: ir::Value, nhi: ir::Value, d: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(nhi);
let (inst, dfg) = self.Ternary(Opcode::X86Sdivmodx, ctrl_typevar, nlo, nhi, d);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn x86_umulx(self, argL: ir::Value, argR: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(argL);
let (inst, dfg) = self.Binary(Opcode::X86Umulx, ctrl_typevar, argL, argR);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn x86_smulx(self, argL: ir::Value, argR: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(argL);
let (inst, dfg) = self.Binary(Opcode::X86Smulx, ctrl_typevar, argL, argR);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn x86_cvtt2si(self, IntTo: crate::ir::Type, x: ir::Value) -> Value {
let (inst, dfg) = self.Unary(Opcode::X86Cvtt2si, IntTo, x);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn x86_fmin(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::X86Fmin, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn x86_fmax(self, x: ir::Value, y: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Binary(Opcode::X86Fmax, ctrl_typevar, x, y);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn x86_push(self, x: ir::Value) -> Inst {
let ctrl_typevar = self.data_flow_graph().value_type(x);
self.Unary(Opcode::X86Push, ctrl_typevar, x).0
}
#[allow(non_snake_case)]
fn x86_pop(self, iWord: crate::ir::Type) -> Value {
let (inst, dfg) = self.NullAry(Opcode::X86Pop, iWord);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn x86_bsr(self, x: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::X86Bsr, ctrl_typevar, x);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn x86_bsf(self, x: ir::Value) -> (Value, Value) {
let ctrl_typevar = self.data_flow_graph().value_type(x);
let (inst, dfg) = self.Unary(Opcode::X86Bsf, ctrl_typevar, x);
let results = &dfg.inst_results(inst)[0..2];
(results[0], results[1])
}
#[allow(non_snake_case)]
fn x86_pshufd<T1uimm8: Into<ir::immediates::Uimm8>>(self, a: ir::Value, i: T1uimm8) -> Value {
let i = i.into();
let ctrl_typevar = self.data_flow_graph().value_type(a);
let (inst, dfg) = self.ExtractLane(Opcode::X86Pshufd, ctrl_typevar, i, a);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn x86_pshufb(self, a: ir::Value, b: ir::Value) -> Value {
let ctrl_typevar = self.data_flow_graph().value_type(a);
let (inst, dfg) = self.Binary(Opcode::X86Pshufb, ctrl_typevar, a, b);
dfg.first_result(inst)
}
#[allow(non_snake_case)]
fn Unary(self, opcode: Opcode, ctrl_typevar: Type, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Unary {
opcode,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn UnaryImm(self, opcode: Opcode, ctrl_typevar: Type, imm: ir::immediates::Imm64) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::UnaryImm {
opcode,
imm,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn UnaryImm128(self, opcode: Opcode, ctrl_typevar: Type, imm: ir::Constant) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::UnaryImm128 {
opcode,
imm,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn UnaryIeee32(self, opcode: Opcode, ctrl_typevar: Type, imm: ir::immediates::Ieee32) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::UnaryIeee32 {
opcode,
imm,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn UnaryIeee64(self, opcode: Opcode, ctrl_typevar: Type, imm: ir::immediates::Ieee64) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::UnaryIeee64 {
opcode,
imm,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn UnaryBool(self, opcode: Opcode, ctrl_typevar: Type, imm: bool) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::UnaryBool {
opcode,
imm,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn UnaryGlobalValue(self, opcode: Opcode, ctrl_typevar: Type, global_value: ir::GlobalValue) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::UnaryGlobalValue {
opcode,
global_value,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Binary(self, opcode: Opcode, ctrl_typevar: Type, arg0: Value, arg1: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Binary {
opcode,
args: [arg0, arg1],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BinaryImm(self, opcode: Opcode, ctrl_typevar: Type, imm: ir::immediates::Imm64, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BinaryImm {
opcode,
imm,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Ternary(self, opcode: Opcode, ctrl_typevar: Type, arg0: Value, arg1: Value, arg2: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Ternary {
opcode,
args: [arg0, arg1, arg2],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn MultiAry(self, opcode: Opcode, ctrl_typevar: Type, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::MultiAry {
opcode,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn NullAry(self, opcode: Opcode, ctrl_typevar: Type) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::NullAry {
opcode,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn InsertLane(self, opcode: Opcode, ctrl_typevar: Type, lane: ir::immediates::Uimm8, arg0: Value, arg1: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::InsertLane {
opcode,
lane,
args: [arg0, arg1],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn ExtractLane(self, opcode: Opcode, ctrl_typevar: Type, lane: ir::immediates::Uimm8, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::ExtractLane {
opcode,
lane,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn IntCompare(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, arg0: Value, arg1: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::IntCompare {
opcode,
cond,
args: [arg0, arg1],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn IntCompareImm(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, imm: ir::immediates::Imm64, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::IntCompareImm {
opcode,
cond,
imm,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn IntCond(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::IntCond {
opcode,
cond,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn FloatCompare(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::FloatCC, arg0: Value, arg1: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::FloatCompare {
opcode,
cond,
args: [arg0, arg1],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn FloatCond(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::FloatCC, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::FloatCond {
opcode,
cond,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn IntSelect(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, arg0: Value, arg1: Value, arg2: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::IntSelect {
opcode,
cond,
args: [arg0, arg1, arg2],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Jump(self, opcode: Opcode, ctrl_typevar: Type, destination: ir::Ebb, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Jump {
opcode,
destination,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Branch(self, opcode: Opcode, ctrl_typevar: Type, destination: ir::Ebb, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Branch {
opcode,
destination,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BranchInt(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, destination: ir::Ebb, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BranchInt {
opcode,
cond,
destination,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BranchFloat(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::FloatCC, destination: ir::Ebb, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BranchFloat {
opcode,
cond,
destination,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BranchIcmp(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, destination: ir::Ebb, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BranchIcmp {
opcode,
cond,
destination,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BranchTable(self, opcode: Opcode, ctrl_typevar: Type, destination: ir::Ebb, table: ir::JumpTable, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BranchTable {
opcode,
destination,
table,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BranchTableEntry(self, opcode: Opcode, ctrl_typevar: Type, imm: ir::immediates::Uimm8, table: ir::JumpTable, arg0: Value, arg1: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BranchTableEntry {
opcode,
imm,
table,
args: [arg0, arg1],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn BranchTableBase(self, opcode: Opcode, ctrl_typevar: Type, table: ir::JumpTable) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::BranchTableBase {
opcode,
table,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn IndirectJump(self, opcode: Opcode, ctrl_typevar: Type, table: ir::JumpTable, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::IndirectJump {
opcode,
table,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Call(self, opcode: Opcode, ctrl_typevar: Type, func_ref: ir::FuncRef, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Call {
opcode,
func_ref,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn CallIndirect(self, opcode: Opcode, ctrl_typevar: Type, sig_ref: ir::SigRef, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::CallIndirect {
opcode,
sig_ref,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn FuncAddr(self, opcode: Opcode, ctrl_typevar: Type, func_ref: ir::FuncRef) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::FuncAddr {
opcode,
func_ref,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Load(self, opcode: Opcode, ctrl_typevar: Type, flags: ir::MemFlags, offset: ir::immediates::Offset32, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Load {
opcode,
flags,
offset,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn LoadComplex(self, opcode: Opcode, ctrl_typevar: Type, flags: ir::MemFlags, offset: ir::immediates::Offset32, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::LoadComplex {
opcode,
flags,
offset,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Store(self, opcode: Opcode, ctrl_typevar: Type, flags: ir::MemFlags, offset: ir::immediates::Offset32, arg0: Value, arg1: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Store {
opcode,
flags,
offset,
args: [arg0, arg1],
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn StoreComplex(self, opcode: Opcode, ctrl_typevar: Type, flags: ir::MemFlags, offset: ir::immediates::Offset32, args: ir::ValueList) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::StoreComplex {
opcode,
flags,
offset,
args,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn StackLoad(self, opcode: Opcode, ctrl_typevar: Type, stack_slot: ir::StackSlot, offset: ir::immediates::Offset32) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::StackLoad {
opcode,
stack_slot,
offset,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn StackStore(self, opcode: Opcode, ctrl_typevar: Type, stack_slot: ir::StackSlot, offset: ir::immediates::Offset32, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::StackStore {
opcode,
stack_slot,
offset,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn HeapAddr(self, opcode: Opcode, ctrl_typevar: Type, heap: ir::Heap, imm: ir::immediates::Uimm32, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::HeapAddr {
opcode,
heap,
imm,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn TableAddr(self, opcode: Opcode, ctrl_typevar: Type, table: ir::Table, offset: ir::immediates::Offset32, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::TableAddr {
opcode,
table,
offset,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn RegMove(self, opcode: Opcode, ctrl_typevar: Type, src: isa::RegUnit, dst: isa::RegUnit, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::RegMove {
opcode,
src,
dst,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn CopySpecial(self, opcode: Opcode, ctrl_typevar: Type, src: isa::RegUnit, dst: isa::RegUnit) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::CopySpecial {
opcode,
src,
dst,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn CopyToSsa(self, opcode: Opcode, ctrl_typevar: Type, src: isa::RegUnit) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::CopyToSsa {
opcode,
src,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn RegSpill(self, opcode: Opcode, ctrl_typevar: Type, src: isa::RegUnit, dst: ir::StackSlot, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::RegSpill {
opcode,
src,
dst,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn RegFill(self, opcode: Opcode, ctrl_typevar: Type, src: ir::StackSlot, dst: isa::RegUnit, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::RegFill {
opcode,
src,
dst,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn Trap(self, opcode: Opcode, ctrl_typevar: Type, code: ir::TrapCode) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::Trap {
opcode,
code,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn CondTrap(self, opcode: Opcode, ctrl_typevar: Type, code: ir::TrapCode, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::CondTrap {
opcode,
code,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn IntCondTrap(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::IntCC, code: ir::TrapCode, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::IntCondTrap {
opcode,
cond,
code,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
#[allow(non_snake_case)]
fn FloatCondTrap(self, opcode: Opcode, ctrl_typevar: Type, cond: ir::condcodes::FloatCC, code: ir::TrapCode, arg0: Value) -> (Inst, &'f mut ir::DataFlowGraph) {
let data = ir::InstructionData::FloatCondTrap {
opcode,
cond,
code,
arg: arg0,
};
self.build(data, ctrl_typevar)
}
}