86611d3bbc
* x64: expand FloatCC enum in ISLE * isle: regenerate manifests * isle: generate all enum fields in `clif.isle` This expands the `gen_isle` function to write all of the immediate `enum`s out explicitly in `clif.isle`. Non-`enum` immediates are still `extern primitive`. * Only compile `enum_values` with `rebuild-isle` feature * Only compile `gen_enum_isle` with `rebuild-isle` feature
1701 lines
41 KiB
Common Lisp
1701 lines
41 KiB
Common Lisp
;; GENERATED BY `gen_isle`. DO NOT EDIT!!!
|
|
;;
|
|
;; This ISLE file defines all the external type declarations for Cranelift's
|
|
;; data structures that ISLE will process, such as `InstructionData` and
|
|
;; `Opcode`.
|
|
|
|
;;;; Extern type declarations for immediates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type Block (primitive Block))
|
|
(type Constant (primitive Constant))
|
|
(type FuncRef (primitive FuncRef))
|
|
(type GlobalValue (primitive GlobalValue))
|
|
(type Heap (primitive Heap))
|
|
(type Ieee32 (primitive Ieee32))
|
|
(type Ieee64 (primitive Ieee64))
|
|
(type Imm64 (primitive Imm64))
|
|
(type Immediate (primitive Immediate))
|
|
(type JumpTable (primitive JumpTable))
|
|
(type MemFlags (primitive MemFlags))
|
|
(type Offset32 (primitive Offset32))
|
|
(type SigRef (primitive SigRef))
|
|
(type StackSlot (primitive StackSlot))
|
|
(type Table (primitive Table))
|
|
(type Uimm32 (primitive Uimm32))
|
|
(type Uimm8 (primitive Uimm8))
|
|
(type bool (primitive bool))
|
|
|
|
;;;; Enumerated Immediate: AtomicRmwOp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type AtomicRmwOp extern
|
|
(enum
|
|
Add
|
|
And
|
|
Nand
|
|
Or
|
|
Smax
|
|
Smin
|
|
Sub
|
|
Umax
|
|
Umin
|
|
Xchg
|
|
Xor
|
|
)
|
|
)
|
|
|
|
;;;; Enumerated Immediate: FloatCC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type FloatCC extern
|
|
(enum
|
|
Equal
|
|
GreaterThan
|
|
GreaterThanOrEqual
|
|
LessThan
|
|
LessThanOrEqual
|
|
NotEqual
|
|
Ordered
|
|
OrderedNotEqual
|
|
Unordered
|
|
UnorderedOrEqual
|
|
UnorderedOrGreaterThan
|
|
UnorderedOrGreaterThanOrEqual
|
|
UnorderedOrLessThan
|
|
UnorderedOrLessThanOrEqual
|
|
)
|
|
)
|
|
|
|
;;;; Enumerated Immediate: IntCC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type IntCC extern
|
|
(enum
|
|
Equal
|
|
NotEqual
|
|
NotOverflow
|
|
Overflow
|
|
SignedGreaterThan
|
|
SignedGreaterThanOrEqual
|
|
SignedLessThan
|
|
SignedLessThanOrEqual
|
|
UnsignedGreaterThan
|
|
UnsignedGreaterThanOrEqual
|
|
UnsignedLessThan
|
|
UnsignedLessThanOrEqual
|
|
)
|
|
)
|
|
|
|
;;;; Enumerated Immediate: TrapCode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type TrapCode extern
|
|
(enum
|
|
HeapOutOfBounds
|
|
IntegerDivisionByZero
|
|
IntegerOverflow
|
|
StackOverflow
|
|
)
|
|
)
|
|
|
|
;;;; Value Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; ISLE representation of `[Value; 2]`.
|
|
(type ValueArray2 extern (enum))
|
|
|
|
(decl value_array_2 (Value Value) ValueArray2)
|
|
(extern constructor value_array_2 pack_value_array_2)
|
|
(extern extractor infallible value_array_2 unpack_value_array_2)
|
|
|
|
;; ISLE representation of `[Value; 3]`.
|
|
(type ValueArray3 extern (enum))
|
|
|
|
(decl value_array_3 (Value Value Value) ValueArray3)
|
|
(extern constructor value_array_3 pack_value_array_3)
|
|
(extern extractor infallible value_array_3 unpack_value_array_3)
|
|
|
|
;;;; `Opcode` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type Opcode extern
|
|
(enum
|
|
Jump
|
|
Brz
|
|
Brnz
|
|
BrIcmp
|
|
Brif
|
|
Brff
|
|
BrTable
|
|
Debugtrap
|
|
Trap
|
|
Trapz
|
|
ResumableTrap
|
|
Trapnz
|
|
ResumableTrapnz
|
|
Trapif
|
|
Trapff
|
|
Return
|
|
FallthroughReturn
|
|
Call
|
|
CallIndirect
|
|
FuncAddr
|
|
Splat
|
|
Swizzle
|
|
Insertlane
|
|
Extractlane
|
|
Imin
|
|
Umin
|
|
Imax
|
|
Umax
|
|
AvgRound
|
|
UaddSat
|
|
SaddSat
|
|
UsubSat
|
|
SsubSat
|
|
Load
|
|
LoadComplex
|
|
Store
|
|
StoreComplex
|
|
Uload8
|
|
Uload8Complex
|
|
Sload8
|
|
Sload8Complex
|
|
Istore8
|
|
Istore8Complex
|
|
Uload16
|
|
Uload16Complex
|
|
Sload16
|
|
Sload16Complex
|
|
Istore16
|
|
Istore16Complex
|
|
Uload32
|
|
Uload32Complex
|
|
Sload32
|
|
Sload32Complex
|
|
Istore32
|
|
Istore32Complex
|
|
Uload8x8
|
|
Uload8x8Complex
|
|
Sload8x8
|
|
Sload8x8Complex
|
|
Uload16x4
|
|
Uload16x4Complex
|
|
Sload16x4
|
|
Sload16x4Complex
|
|
Uload32x2
|
|
Uload32x2Complex
|
|
Sload32x2
|
|
Sload32x2Complex
|
|
StackLoad
|
|
StackStore
|
|
StackAddr
|
|
GlobalValue
|
|
SymbolValue
|
|
TlsValue
|
|
HeapAddr
|
|
GetPinnedReg
|
|
SetPinnedReg
|
|
TableAddr
|
|
Iconst
|
|
F32const
|
|
F64const
|
|
Bconst
|
|
Vconst
|
|
ConstAddr
|
|
Shuffle
|
|
Null
|
|
Nop
|
|
Select
|
|
Selectif
|
|
SelectifSpectreGuard
|
|
Bitselect
|
|
Copy
|
|
IfcmpSp
|
|
Vsplit
|
|
Vconcat
|
|
Vselect
|
|
VanyTrue
|
|
VallTrue
|
|
VhighBits
|
|
Icmp
|
|
IcmpImm
|
|
Ifcmp
|
|
IfcmpImm
|
|
Iadd
|
|
Isub
|
|
Ineg
|
|
Iabs
|
|
Imul
|
|
Umulhi
|
|
Smulhi
|
|
SqmulRoundSat
|
|
Udiv
|
|
Sdiv
|
|
Urem
|
|
Srem
|
|
IaddImm
|
|
ImulImm
|
|
UdivImm
|
|
SdivImm
|
|
UremImm
|
|
SremImm
|
|
IrsubImm
|
|
IaddCin
|
|
IaddIfcin
|
|
IaddCout
|
|
IaddIfcout
|
|
IaddCarry
|
|
IaddIfcarry
|
|
IsubBin
|
|
IsubIfbin
|
|
IsubBout
|
|
IsubIfbout
|
|
IsubBorrow
|
|
IsubIfborrow
|
|
Band
|
|
Bor
|
|
Bxor
|
|
Bnot
|
|
BandNot
|
|
BorNot
|
|
BxorNot
|
|
BandImm
|
|
BorImm
|
|
BxorImm
|
|
Rotl
|
|
Rotr
|
|
RotlImm
|
|
RotrImm
|
|
Ishl
|
|
Ushr
|
|
Sshr
|
|
IshlImm
|
|
UshrImm
|
|
SshrImm
|
|
Bitrev
|
|
Clz
|
|
Cls
|
|
Ctz
|
|
Popcnt
|
|
Fcmp
|
|
Ffcmp
|
|
Fadd
|
|
Fsub
|
|
Fmul
|
|
Fdiv
|
|
Sqrt
|
|
Fma
|
|
Fneg
|
|
Fabs
|
|
Fcopysign
|
|
Fmin
|
|
FminPseudo
|
|
Fmax
|
|
FmaxPseudo
|
|
Ceil
|
|
Floor
|
|
Trunc
|
|
Nearest
|
|
IsNull
|
|
IsInvalid
|
|
Trueif
|
|
Trueff
|
|
Bitcast
|
|
RawBitcast
|
|
ScalarToVector
|
|
Breduce
|
|
Bextend
|
|
Bint
|
|
Bmask
|
|
Ireduce
|
|
Snarrow
|
|
Unarrow
|
|
Uunarrow
|
|
SwidenLow
|
|
SwidenHigh
|
|
UwidenLow
|
|
UwidenHigh
|
|
IaddPairwise
|
|
WideningPairwiseDotProductS
|
|
Uextend
|
|
Sextend
|
|
Fpromote
|
|
Fdemote
|
|
Fvdemote
|
|
FvpromoteLow
|
|
FcvtToUint
|
|
FcvtToUintSat
|
|
FcvtToSint
|
|
FcvtToSintSat
|
|
FcvtFromUint
|
|
FcvtFromSint
|
|
FcvtLowFromSint
|
|
Isplit
|
|
Iconcat
|
|
AtomicRmw
|
|
AtomicCas
|
|
AtomicLoad
|
|
AtomicStore
|
|
Fence
|
|
)
|
|
)
|
|
|
|
;;;; `InstructionData` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(type InstructionData extern
|
|
(enum
|
|
(AtomicCas (opcode Opcode) (args ValueArray3) (flags MemFlags))
|
|
(AtomicRmw (opcode Opcode) (args ValueArray2) (flags MemFlags) (op AtomicRmwOp))
|
|
(Binary (opcode Opcode) (args ValueArray2))
|
|
(BinaryImm64 (opcode Opcode) (arg Value) (imm Imm64))
|
|
(BinaryImm8 (opcode Opcode) (arg Value) (imm Uimm8))
|
|
(Branch (opcode Opcode) (args ValueList) (destination Block))
|
|
(BranchFloat (opcode Opcode) (args ValueList) (cond FloatCC) (destination Block))
|
|
(BranchIcmp (opcode Opcode) (args ValueList) (cond IntCC) (destination Block))
|
|
(BranchInt (opcode Opcode) (args ValueList) (cond IntCC) (destination Block))
|
|
(BranchTable (opcode Opcode) (arg Value) (destination Block) (table JumpTable))
|
|
(Call (opcode Opcode) (func_ref FuncRef))
|
|
(CallIndirect (opcode Opcode) (args ValueList) (sig_ref SigRef))
|
|
(CondTrap (opcode Opcode) (arg Value) (code TrapCode))
|
|
(FloatCompare (opcode Opcode) (args ValueArray2) (cond FloatCC))
|
|
(FloatCond (opcode Opcode) (arg Value) (cond FloatCC))
|
|
(FloatCondTrap (opcode Opcode) (arg Value) (cond FloatCC) (code TrapCode))
|
|
(FuncAddr (opcode Opcode) (func_ref FuncRef))
|
|
(HeapAddr (opcode Opcode) (arg Value) (heap Heap) (imm Uimm32))
|
|
(IntCompare (opcode Opcode) (args ValueArray2) (cond IntCC))
|
|
(IntCompareImm (opcode Opcode) (arg Value) (cond IntCC) (imm Imm64))
|
|
(IntCond (opcode Opcode) (arg Value) (cond IntCC))
|
|
(IntCondTrap (opcode Opcode) (arg Value) (cond IntCC) (code TrapCode))
|
|
(IntSelect (opcode Opcode) (args ValueArray3) (cond IntCC))
|
|
(Jump (opcode Opcode) (destination Block))
|
|
(Load (opcode Opcode) (arg Value) (flags MemFlags) (offset Offset32))
|
|
(LoadComplex (opcode Opcode) (flags MemFlags) (offset Offset32))
|
|
(LoadNoOffset (opcode Opcode) (arg Value) (flags MemFlags))
|
|
(MultiAry (opcode Opcode))
|
|
(NullAry (opcode Opcode))
|
|
(Shuffle (opcode Opcode) (args ValueArray2) (imm Immediate))
|
|
(StackLoad (opcode Opcode) (stack_slot StackSlot) (offset Offset32))
|
|
(StackStore (opcode Opcode) (arg Value) (stack_slot StackSlot) (offset Offset32))
|
|
(Store (opcode Opcode) (args ValueArray2) (flags MemFlags) (offset Offset32))
|
|
(StoreComplex (opcode Opcode) (args ValueList) (flags MemFlags) (offset Offset32))
|
|
(StoreNoOffset (opcode Opcode) (args ValueArray2) (flags MemFlags))
|
|
(TableAddr (opcode Opcode) (arg Value) (table Table) (offset Offset32))
|
|
(Ternary (opcode Opcode) (args ValueArray3))
|
|
(TernaryImm8 (opcode Opcode) (args ValueArray2) (imm Uimm8))
|
|
(Trap (opcode Opcode) (code TrapCode))
|
|
(Unary (opcode Opcode) (arg Value))
|
|
(UnaryBool (opcode Opcode) (imm bool))
|
|
(UnaryConst (opcode Opcode) (constant_handle Constant))
|
|
(UnaryGlobalValue (opcode Opcode) (global_value GlobalValue))
|
|
(UnaryIeee32 (opcode Opcode) (imm Ieee32))
|
|
(UnaryIeee64 (opcode Opcode) (imm Ieee64))
|
|
(UnaryImm (opcode Opcode) (imm Imm64))
|
|
)
|
|
)
|
|
|
|
;;;; Extracting Opcode, Operands, and Immediates from `InstructionData` ;;;;;;;;
|
|
|
|
(decl jump (Block ValueSlice) Inst)
|
|
(extractor
|
|
(jump block args)
|
|
(inst_data (InstructionData.Jump (Opcode.Jump) block))
|
|
)
|
|
|
|
(decl brz (Value Block ValueSlice) Inst)
|
|
(extractor
|
|
(brz c block args)
|
|
(inst_data (InstructionData.Branch (Opcode.Brz) (unwrap_head_value_list_1 c args) block))
|
|
)
|
|
|
|
(decl brnz (Value Block ValueSlice) Inst)
|
|
(extractor
|
|
(brnz c block args)
|
|
(inst_data (InstructionData.Branch (Opcode.Brnz) (unwrap_head_value_list_1 c args) block))
|
|
)
|
|
|
|
(decl br_icmp (IntCC Value Value Block ValueSlice) Inst)
|
|
(extractor
|
|
(br_icmp Cond x y block args)
|
|
(inst_data (InstructionData.BranchIcmp (Opcode.BrIcmp) (unwrap_head_value_list_2 x y args) Cond block))
|
|
)
|
|
|
|
(decl brif (IntCC Value Block ValueSlice) Inst)
|
|
(extractor
|
|
(brif Cond f block args)
|
|
(inst_data (InstructionData.BranchInt (Opcode.Brif) (unwrap_head_value_list_1 f args) Cond block))
|
|
)
|
|
|
|
(decl brff (FloatCC Value Block ValueSlice) Inst)
|
|
(extractor
|
|
(brff Cond f block args)
|
|
(inst_data (InstructionData.BranchFloat (Opcode.Brff) (unwrap_head_value_list_1 f args) Cond block))
|
|
)
|
|
|
|
(decl br_table (Value Block JumpTable) Inst)
|
|
(extractor
|
|
(br_table x block JT)
|
|
(inst_data (InstructionData.BranchTable (Opcode.BrTable) x block JT))
|
|
)
|
|
|
|
(decl debugtrap () Inst)
|
|
(extractor
|
|
(debugtrap )
|
|
(inst_data (InstructionData.NullAry (Opcode.Debugtrap)))
|
|
)
|
|
|
|
(decl trap (TrapCode) Inst)
|
|
(extractor
|
|
(trap code)
|
|
(inst_data (InstructionData.Trap (Opcode.Trap) code))
|
|
)
|
|
|
|
(decl trapz (Value TrapCode) Inst)
|
|
(extractor
|
|
(trapz c code)
|
|
(inst_data (InstructionData.CondTrap (Opcode.Trapz) c code))
|
|
)
|
|
|
|
(decl resumable_trap (TrapCode) Inst)
|
|
(extractor
|
|
(resumable_trap code)
|
|
(inst_data (InstructionData.Trap (Opcode.ResumableTrap) code))
|
|
)
|
|
|
|
(decl trapnz (Value TrapCode) Inst)
|
|
(extractor
|
|
(trapnz c code)
|
|
(inst_data (InstructionData.CondTrap (Opcode.Trapnz) c code))
|
|
)
|
|
|
|
(decl resumable_trapnz (Value TrapCode) Inst)
|
|
(extractor
|
|
(resumable_trapnz c code)
|
|
(inst_data (InstructionData.CondTrap (Opcode.ResumableTrapnz) c code))
|
|
)
|
|
|
|
(decl trapif (IntCC Value TrapCode) Inst)
|
|
(extractor
|
|
(trapif Cond f code)
|
|
(inst_data (InstructionData.IntCondTrap (Opcode.Trapif) f Cond code))
|
|
)
|
|
|
|
(decl trapff (FloatCC Value TrapCode) Inst)
|
|
(extractor
|
|
(trapff Cond f code)
|
|
(inst_data (InstructionData.FloatCondTrap (Opcode.Trapff) f Cond code))
|
|
)
|
|
|
|
(decl return (ValueSlice) Inst)
|
|
(extractor
|
|
(return rvals)
|
|
(inst_data (InstructionData.MultiAry (Opcode.Return)))
|
|
)
|
|
|
|
(decl fallthrough_return (ValueSlice) Inst)
|
|
(extractor
|
|
(fallthrough_return rvals)
|
|
(inst_data (InstructionData.MultiAry (Opcode.FallthroughReturn)))
|
|
)
|
|
|
|
(decl call (FuncRef ValueSlice) Inst)
|
|
(extractor
|
|
(call FN args)
|
|
(inst_data (InstructionData.Call (Opcode.Call) FN))
|
|
)
|
|
|
|
(decl call_indirect (SigRef Value ValueSlice) Inst)
|
|
(extractor
|
|
(call_indirect SIG callee args)
|
|
(inst_data (InstructionData.CallIndirect (Opcode.CallIndirect) (unwrap_head_value_list_1 callee args) SIG))
|
|
)
|
|
|
|
(decl func_addr (FuncRef) Inst)
|
|
(extractor
|
|
(func_addr FN)
|
|
(inst_data (InstructionData.FuncAddr (Opcode.FuncAddr) FN))
|
|
)
|
|
|
|
(decl splat (Value) Inst)
|
|
(extractor
|
|
(splat x)
|
|
(inst_data (InstructionData.Unary (Opcode.Splat) x))
|
|
)
|
|
|
|
(decl swizzle (Value Value) Inst)
|
|
(extractor
|
|
(swizzle x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Swizzle) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl insertlane (Value Value Uimm8) Inst)
|
|
(extractor
|
|
(insertlane x y Idx)
|
|
(inst_data (InstructionData.TernaryImm8 (Opcode.Insertlane) (value_array_2 x y) Idx))
|
|
)
|
|
|
|
(decl extractlane (Value Uimm8) Inst)
|
|
(extractor
|
|
(extractlane x Idx)
|
|
(inst_data (InstructionData.BinaryImm8 (Opcode.Extractlane) x Idx))
|
|
)
|
|
|
|
(decl imin (Value Value) Inst)
|
|
(extractor
|
|
(imin x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Imin) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl umin (Value Value) Inst)
|
|
(extractor
|
|
(umin x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Umin) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl imax (Value Value) Inst)
|
|
(extractor
|
|
(imax x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Imax) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl umax (Value Value) Inst)
|
|
(extractor
|
|
(umax x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Umax) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl avg_round (Value Value) Inst)
|
|
(extractor
|
|
(avg_round x y)
|
|
(inst_data (InstructionData.Binary (Opcode.AvgRound) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl uadd_sat (Value Value) Inst)
|
|
(extractor
|
|
(uadd_sat x y)
|
|
(inst_data (InstructionData.Binary (Opcode.UaddSat) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl sadd_sat (Value Value) Inst)
|
|
(extractor
|
|
(sadd_sat x y)
|
|
(inst_data (InstructionData.Binary (Opcode.SaddSat) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl usub_sat (Value Value) Inst)
|
|
(extractor
|
|
(usub_sat x y)
|
|
(inst_data (InstructionData.Binary (Opcode.UsubSat) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl ssub_sat (Value Value) Inst)
|
|
(extractor
|
|
(ssub_sat x y)
|
|
(inst_data (InstructionData.Binary (Opcode.SsubSat) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl load (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(load MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Load) p MemFlags Offset))
|
|
)
|
|
|
|
(decl load_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(load_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.LoadComplex) MemFlags Offset))
|
|
)
|
|
|
|
(decl store (MemFlags Value Value Offset32) Inst)
|
|
(extractor
|
|
(store MemFlags x p Offset)
|
|
(inst_data (InstructionData.Store (Opcode.Store) (value_array_2 x p) MemFlags Offset))
|
|
)
|
|
|
|
(decl store_complex (MemFlags Value ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(store_complex MemFlags x args Offset)
|
|
(inst_data (InstructionData.StoreComplex (Opcode.StoreComplex) (unwrap_head_value_list_1 x args) MemFlags Offset))
|
|
)
|
|
|
|
(decl uload8 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(uload8 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Uload8) p MemFlags Offset))
|
|
)
|
|
|
|
(decl uload8_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(uload8_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Uload8Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl sload8 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(sload8 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Sload8) p MemFlags Offset))
|
|
)
|
|
|
|
(decl sload8_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(sload8_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Sload8Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl istore8 (MemFlags Value Value Offset32) Inst)
|
|
(extractor
|
|
(istore8 MemFlags x p Offset)
|
|
(inst_data (InstructionData.Store (Opcode.Istore8) (value_array_2 x p) MemFlags Offset))
|
|
)
|
|
|
|
(decl istore8_complex (MemFlags Value ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(istore8_complex MemFlags x args Offset)
|
|
(inst_data (InstructionData.StoreComplex (Opcode.Istore8Complex) (unwrap_head_value_list_1 x args) MemFlags Offset))
|
|
)
|
|
|
|
(decl uload16 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(uload16 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Uload16) p MemFlags Offset))
|
|
)
|
|
|
|
(decl uload16_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(uload16_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Uload16Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl sload16 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(sload16 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Sload16) p MemFlags Offset))
|
|
)
|
|
|
|
(decl sload16_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(sload16_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Sload16Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl istore16 (MemFlags Value Value Offset32) Inst)
|
|
(extractor
|
|
(istore16 MemFlags x p Offset)
|
|
(inst_data (InstructionData.Store (Opcode.Istore16) (value_array_2 x p) MemFlags Offset))
|
|
)
|
|
|
|
(decl istore16_complex (MemFlags Value ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(istore16_complex MemFlags x args Offset)
|
|
(inst_data (InstructionData.StoreComplex (Opcode.Istore16Complex) (unwrap_head_value_list_1 x args) MemFlags Offset))
|
|
)
|
|
|
|
(decl uload32 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(uload32 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Uload32) p MemFlags Offset))
|
|
)
|
|
|
|
(decl uload32_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(uload32_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Uload32Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl sload32 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(sload32 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Sload32) p MemFlags Offset))
|
|
)
|
|
|
|
(decl sload32_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(sload32_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Sload32Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl istore32 (MemFlags Value Value Offset32) Inst)
|
|
(extractor
|
|
(istore32 MemFlags x p Offset)
|
|
(inst_data (InstructionData.Store (Opcode.Istore32) (value_array_2 x p) MemFlags Offset))
|
|
)
|
|
|
|
(decl istore32_complex (MemFlags Value ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(istore32_complex MemFlags x args Offset)
|
|
(inst_data (InstructionData.StoreComplex (Opcode.Istore32Complex) (unwrap_head_value_list_1 x args) MemFlags Offset))
|
|
)
|
|
|
|
(decl uload8x8 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(uload8x8 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Uload8x8) p MemFlags Offset))
|
|
)
|
|
|
|
(decl uload8x8_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(uload8x8_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Uload8x8Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl sload8x8 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(sload8x8 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Sload8x8) p MemFlags Offset))
|
|
)
|
|
|
|
(decl sload8x8_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(sload8x8_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Sload8x8Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl uload16x4 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(uload16x4 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Uload16x4) p MemFlags Offset))
|
|
)
|
|
|
|
(decl uload16x4_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(uload16x4_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Uload16x4Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl sload16x4 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(sload16x4 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Sload16x4) p MemFlags Offset))
|
|
)
|
|
|
|
(decl sload16x4_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(sload16x4_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Sload16x4Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl uload32x2 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(uload32x2 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Uload32x2) p MemFlags Offset))
|
|
)
|
|
|
|
(decl uload32x2_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(uload32x2_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Uload32x2Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl sload32x2 (MemFlags Value Offset32) Inst)
|
|
(extractor
|
|
(sload32x2 MemFlags p Offset)
|
|
(inst_data (InstructionData.Load (Opcode.Sload32x2) p MemFlags Offset))
|
|
)
|
|
|
|
(decl sload32x2_complex (MemFlags ValueSlice Offset32) Inst)
|
|
(extractor
|
|
(sload32x2_complex MemFlags args Offset)
|
|
(inst_data (InstructionData.LoadComplex (Opcode.Sload32x2Complex) MemFlags Offset))
|
|
)
|
|
|
|
(decl stack_load (StackSlot Offset32) Inst)
|
|
(extractor
|
|
(stack_load SS Offset)
|
|
(inst_data (InstructionData.StackLoad (Opcode.StackLoad) SS Offset))
|
|
)
|
|
|
|
(decl stack_store (Value StackSlot Offset32) Inst)
|
|
(extractor
|
|
(stack_store x SS Offset)
|
|
(inst_data (InstructionData.StackStore (Opcode.StackStore) x SS Offset))
|
|
)
|
|
|
|
(decl stack_addr (StackSlot Offset32) Inst)
|
|
(extractor
|
|
(stack_addr SS Offset)
|
|
(inst_data (InstructionData.StackLoad (Opcode.StackAddr) SS Offset))
|
|
)
|
|
|
|
(decl global_value (GlobalValue) Inst)
|
|
(extractor
|
|
(global_value GV)
|
|
(inst_data (InstructionData.UnaryGlobalValue (Opcode.GlobalValue) GV))
|
|
)
|
|
|
|
(decl symbol_value (GlobalValue) Inst)
|
|
(extractor
|
|
(symbol_value GV)
|
|
(inst_data (InstructionData.UnaryGlobalValue (Opcode.SymbolValue) GV))
|
|
)
|
|
|
|
(decl tls_value (GlobalValue) Inst)
|
|
(extractor
|
|
(tls_value GV)
|
|
(inst_data (InstructionData.UnaryGlobalValue (Opcode.TlsValue) GV))
|
|
)
|
|
|
|
(decl heap_addr (Heap Value Uimm32) Inst)
|
|
(extractor
|
|
(heap_addr H p Size)
|
|
(inst_data (InstructionData.HeapAddr (Opcode.HeapAddr) p H Size))
|
|
)
|
|
|
|
(decl get_pinned_reg () Inst)
|
|
(extractor
|
|
(get_pinned_reg )
|
|
(inst_data (InstructionData.NullAry (Opcode.GetPinnedReg)))
|
|
)
|
|
|
|
(decl set_pinned_reg (Value) Inst)
|
|
(extractor
|
|
(set_pinned_reg addr)
|
|
(inst_data (InstructionData.Unary (Opcode.SetPinnedReg) addr))
|
|
)
|
|
|
|
(decl table_addr (Table Value Offset32) Inst)
|
|
(extractor
|
|
(table_addr T p Offset)
|
|
(inst_data (InstructionData.TableAddr (Opcode.TableAddr) p T Offset))
|
|
)
|
|
|
|
(decl iconst (Imm64) Inst)
|
|
(extractor
|
|
(iconst N)
|
|
(inst_data (InstructionData.UnaryImm (Opcode.Iconst) N))
|
|
)
|
|
|
|
(decl f32const (Ieee32) Inst)
|
|
(extractor
|
|
(f32const N)
|
|
(inst_data (InstructionData.UnaryIeee32 (Opcode.F32const) N))
|
|
)
|
|
|
|
(decl f64const (Ieee64) Inst)
|
|
(extractor
|
|
(f64const N)
|
|
(inst_data (InstructionData.UnaryIeee64 (Opcode.F64const) N))
|
|
)
|
|
|
|
(decl bconst (bool) Inst)
|
|
(extractor
|
|
(bconst N)
|
|
(inst_data (InstructionData.UnaryBool (Opcode.Bconst) N))
|
|
)
|
|
|
|
(decl vconst (Constant) Inst)
|
|
(extractor
|
|
(vconst N)
|
|
(inst_data (InstructionData.UnaryConst (Opcode.Vconst) N))
|
|
)
|
|
|
|
(decl const_addr (Constant) Inst)
|
|
(extractor
|
|
(const_addr constant)
|
|
(inst_data (InstructionData.UnaryConst (Opcode.ConstAddr) constant))
|
|
)
|
|
|
|
(decl shuffle (Value Value Immediate) Inst)
|
|
(extractor
|
|
(shuffle a b mask)
|
|
(inst_data (InstructionData.Shuffle (Opcode.Shuffle) (value_array_2 a b) mask))
|
|
)
|
|
|
|
(decl null () Inst)
|
|
(extractor
|
|
(null )
|
|
(inst_data (InstructionData.NullAry (Opcode.Null)))
|
|
)
|
|
|
|
(decl nop () Inst)
|
|
(extractor
|
|
(nop )
|
|
(inst_data (InstructionData.NullAry (Opcode.Nop)))
|
|
)
|
|
|
|
(decl select (Value Value Value) Inst)
|
|
(extractor
|
|
(select c x y)
|
|
(inst_data (InstructionData.Ternary (Opcode.Select) (value_array_3 c x y)))
|
|
)
|
|
|
|
(decl selectif (IntCC Value Value Value) Inst)
|
|
(extractor
|
|
(selectif cc flags x y)
|
|
(inst_data (InstructionData.IntSelect (Opcode.Selectif) (value_array_3 flags x y) cc))
|
|
)
|
|
|
|
(decl selectif_spectre_guard (IntCC Value Value Value) Inst)
|
|
(extractor
|
|
(selectif_spectre_guard cc flags x y)
|
|
(inst_data (InstructionData.IntSelect (Opcode.SelectifSpectreGuard) (value_array_3 flags x y) cc))
|
|
)
|
|
|
|
(decl bitselect (Value Value Value) Inst)
|
|
(extractor
|
|
(bitselect c x y)
|
|
(inst_data (InstructionData.Ternary (Opcode.Bitselect) (value_array_3 c x y)))
|
|
)
|
|
|
|
(decl copy (Value) Inst)
|
|
(extractor
|
|
(copy x)
|
|
(inst_data (InstructionData.Unary (Opcode.Copy) x))
|
|
)
|
|
|
|
(decl ifcmp_sp (Value) Inst)
|
|
(extractor
|
|
(ifcmp_sp addr)
|
|
(inst_data (InstructionData.Unary (Opcode.IfcmpSp) addr))
|
|
)
|
|
|
|
(decl vsplit (Value) Inst)
|
|
(extractor
|
|
(vsplit x)
|
|
(inst_data (InstructionData.Unary (Opcode.Vsplit) x))
|
|
)
|
|
|
|
(decl vconcat (Value Value) Inst)
|
|
(extractor
|
|
(vconcat x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Vconcat) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl vselect (Value Value Value) Inst)
|
|
(extractor
|
|
(vselect c x y)
|
|
(inst_data (InstructionData.Ternary (Opcode.Vselect) (value_array_3 c x y)))
|
|
)
|
|
|
|
(decl vany_true (Value) Inst)
|
|
(extractor
|
|
(vany_true a)
|
|
(inst_data (InstructionData.Unary (Opcode.VanyTrue) a))
|
|
)
|
|
|
|
(decl vall_true (Value) Inst)
|
|
(extractor
|
|
(vall_true a)
|
|
(inst_data (InstructionData.Unary (Opcode.VallTrue) a))
|
|
)
|
|
|
|
(decl vhigh_bits (Value) Inst)
|
|
(extractor
|
|
(vhigh_bits a)
|
|
(inst_data (InstructionData.Unary (Opcode.VhighBits) a))
|
|
)
|
|
|
|
(decl icmp (IntCC Value Value) Inst)
|
|
(extractor
|
|
(icmp Cond x y)
|
|
(inst_data (InstructionData.IntCompare (Opcode.Icmp) (value_array_2 x y) Cond))
|
|
)
|
|
|
|
(decl icmp_imm (IntCC Value Imm64) Inst)
|
|
(extractor
|
|
(icmp_imm Cond x Y)
|
|
(inst_data (InstructionData.IntCompareImm (Opcode.IcmpImm) x Cond Y))
|
|
)
|
|
|
|
(decl ifcmp (Value Value) Inst)
|
|
(extractor
|
|
(ifcmp x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Ifcmp) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl ifcmp_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(ifcmp_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.IfcmpImm) x Y))
|
|
)
|
|
|
|
(decl iadd (Value Value) Inst)
|
|
(extractor
|
|
(iadd x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Iadd) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl isub (Value Value) Inst)
|
|
(extractor
|
|
(isub x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Isub) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl ineg (Value) Inst)
|
|
(extractor
|
|
(ineg x)
|
|
(inst_data (InstructionData.Unary (Opcode.Ineg) x))
|
|
)
|
|
|
|
(decl iabs (Value) Inst)
|
|
(extractor
|
|
(iabs x)
|
|
(inst_data (InstructionData.Unary (Opcode.Iabs) x))
|
|
)
|
|
|
|
(decl imul (Value Value) Inst)
|
|
(extractor
|
|
(imul x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Imul) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl umulhi (Value Value) Inst)
|
|
(extractor
|
|
(umulhi x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Umulhi) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl smulhi (Value Value) Inst)
|
|
(extractor
|
|
(smulhi x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Smulhi) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl sqmul_round_sat (Value Value) Inst)
|
|
(extractor
|
|
(sqmul_round_sat x y)
|
|
(inst_data (InstructionData.Binary (Opcode.SqmulRoundSat) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl udiv (Value Value) Inst)
|
|
(extractor
|
|
(udiv x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Udiv) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl sdiv (Value Value) Inst)
|
|
(extractor
|
|
(sdiv x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Sdiv) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl urem (Value Value) Inst)
|
|
(extractor
|
|
(urem x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Urem) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl srem (Value Value) Inst)
|
|
(extractor
|
|
(srem x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Srem) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl iadd_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(iadd_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.IaddImm) x Y))
|
|
)
|
|
|
|
(decl imul_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(imul_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.ImulImm) x Y))
|
|
)
|
|
|
|
(decl udiv_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(udiv_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.UdivImm) x Y))
|
|
)
|
|
|
|
(decl sdiv_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(sdiv_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.SdivImm) x Y))
|
|
)
|
|
|
|
(decl urem_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(urem_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.UremImm) x Y))
|
|
)
|
|
|
|
(decl srem_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(srem_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.SremImm) x Y))
|
|
)
|
|
|
|
(decl irsub_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(irsub_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.IrsubImm) x Y))
|
|
)
|
|
|
|
(decl iadd_cin (Value Value Value) Inst)
|
|
(extractor
|
|
(iadd_cin x y c_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IaddCin) (value_array_3 x y c_in)))
|
|
)
|
|
|
|
(decl iadd_ifcin (Value Value Value) Inst)
|
|
(extractor
|
|
(iadd_ifcin x y c_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IaddIfcin) (value_array_3 x y c_in)))
|
|
)
|
|
|
|
(decl iadd_cout (Value Value) Inst)
|
|
(extractor
|
|
(iadd_cout x y)
|
|
(inst_data (InstructionData.Binary (Opcode.IaddCout) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl iadd_ifcout (Value Value) Inst)
|
|
(extractor
|
|
(iadd_ifcout x y)
|
|
(inst_data (InstructionData.Binary (Opcode.IaddIfcout) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl iadd_carry (Value Value Value) Inst)
|
|
(extractor
|
|
(iadd_carry x y c_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IaddCarry) (value_array_3 x y c_in)))
|
|
)
|
|
|
|
(decl iadd_ifcarry (Value Value Value) Inst)
|
|
(extractor
|
|
(iadd_ifcarry x y c_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IaddIfcarry) (value_array_3 x y c_in)))
|
|
)
|
|
|
|
(decl isub_bin (Value Value Value) Inst)
|
|
(extractor
|
|
(isub_bin x y b_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IsubBin) (value_array_3 x y b_in)))
|
|
)
|
|
|
|
(decl isub_ifbin (Value Value Value) Inst)
|
|
(extractor
|
|
(isub_ifbin x y b_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IsubIfbin) (value_array_3 x y b_in)))
|
|
)
|
|
|
|
(decl isub_bout (Value Value) Inst)
|
|
(extractor
|
|
(isub_bout x y)
|
|
(inst_data (InstructionData.Binary (Opcode.IsubBout) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl isub_ifbout (Value Value) Inst)
|
|
(extractor
|
|
(isub_ifbout x y)
|
|
(inst_data (InstructionData.Binary (Opcode.IsubIfbout) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl isub_borrow (Value Value Value) Inst)
|
|
(extractor
|
|
(isub_borrow x y b_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IsubBorrow) (value_array_3 x y b_in)))
|
|
)
|
|
|
|
(decl isub_ifborrow (Value Value Value) Inst)
|
|
(extractor
|
|
(isub_ifborrow x y b_in)
|
|
(inst_data (InstructionData.Ternary (Opcode.IsubIfborrow) (value_array_3 x y b_in)))
|
|
)
|
|
|
|
(decl band (Value Value) Inst)
|
|
(extractor
|
|
(band x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Band) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl bor (Value Value) Inst)
|
|
(extractor
|
|
(bor x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Bor) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl bxor (Value Value) Inst)
|
|
(extractor
|
|
(bxor x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Bxor) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl bnot (Value) Inst)
|
|
(extractor
|
|
(bnot x)
|
|
(inst_data (InstructionData.Unary (Opcode.Bnot) x))
|
|
)
|
|
|
|
(decl band_not (Value Value) Inst)
|
|
(extractor
|
|
(band_not x y)
|
|
(inst_data (InstructionData.Binary (Opcode.BandNot) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl bor_not (Value Value) Inst)
|
|
(extractor
|
|
(bor_not x y)
|
|
(inst_data (InstructionData.Binary (Opcode.BorNot) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl bxor_not (Value Value) Inst)
|
|
(extractor
|
|
(bxor_not x y)
|
|
(inst_data (InstructionData.Binary (Opcode.BxorNot) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl band_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(band_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.BandImm) x Y))
|
|
)
|
|
|
|
(decl bor_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(bor_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.BorImm) x Y))
|
|
)
|
|
|
|
(decl bxor_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(bxor_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.BxorImm) x Y))
|
|
)
|
|
|
|
(decl rotl (Value Value) Inst)
|
|
(extractor
|
|
(rotl x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Rotl) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl rotr (Value Value) Inst)
|
|
(extractor
|
|
(rotr x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Rotr) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl rotl_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(rotl_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.RotlImm) x Y))
|
|
)
|
|
|
|
(decl rotr_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(rotr_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.RotrImm) x Y))
|
|
)
|
|
|
|
(decl ishl (Value Value) Inst)
|
|
(extractor
|
|
(ishl x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Ishl) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl ushr (Value Value) Inst)
|
|
(extractor
|
|
(ushr x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Ushr) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl sshr (Value Value) Inst)
|
|
(extractor
|
|
(sshr x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Sshr) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl ishl_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(ishl_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.IshlImm) x Y))
|
|
)
|
|
|
|
(decl ushr_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(ushr_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.UshrImm) x Y))
|
|
)
|
|
|
|
(decl sshr_imm (Value Imm64) Inst)
|
|
(extractor
|
|
(sshr_imm x Y)
|
|
(inst_data (InstructionData.BinaryImm64 (Opcode.SshrImm) x Y))
|
|
)
|
|
|
|
(decl bitrev (Value) Inst)
|
|
(extractor
|
|
(bitrev x)
|
|
(inst_data (InstructionData.Unary (Opcode.Bitrev) x))
|
|
)
|
|
|
|
(decl clz (Value) Inst)
|
|
(extractor
|
|
(clz x)
|
|
(inst_data (InstructionData.Unary (Opcode.Clz) x))
|
|
)
|
|
|
|
(decl cls (Value) Inst)
|
|
(extractor
|
|
(cls x)
|
|
(inst_data (InstructionData.Unary (Opcode.Cls) x))
|
|
)
|
|
|
|
(decl ctz (Value) Inst)
|
|
(extractor
|
|
(ctz x)
|
|
(inst_data (InstructionData.Unary (Opcode.Ctz) x))
|
|
)
|
|
|
|
(decl popcnt (Value) Inst)
|
|
(extractor
|
|
(popcnt x)
|
|
(inst_data (InstructionData.Unary (Opcode.Popcnt) x))
|
|
)
|
|
|
|
(decl fcmp (FloatCC Value Value) Inst)
|
|
(extractor
|
|
(fcmp Cond x y)
|
|
(inst_data (InstructionData.FloatCompare (Opcode.Fcmp) (value_array_2 x y) Cond))
|
|
)
|
|
|
|
(decl ffcmp (Value Value) Inst)
|
|
(extractor
|
|
(ffcmp x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Ffcmp) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fadd (Value Value) Inst)
|
|
(extractor
|
|
(fadd x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fadd) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fsub (Value Value) Inst)
|
|
(extractor
|
|
(fsub x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fsub) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fmul (Value Value) Inst)
|
|
(extractor
|
|
(fmul x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fmul) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fdiv (Value Value) Inst)
|
|
(extractor
|
|
(fdiv x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fdiv) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl sqrt (Value) Inst)
|
|
(extractor
|
|
(sqrt x)
|
|
(inst_data (InstructionData.Unary (Opcode.Sqrt) x))
|
|
)
|
|
|
|
(decl fma (Value Value Value) Inst)
|
|
(extractor
|
|
(fma x y z)
|
|
(inst_data (InstructionData.Ternary (Opcode.Fma) (value_array_3 x y z)))
|
|
)
|
|
|
|
(decl fneg (Value) Inst)
|
|
(extractor
|
|
(fneg x)
|
|
(inst_data (InstructionData.Unary (Opcode.Fneg) x))
|
|
)
|
|
|
|
(decl fabs (Value) Inst)
|
|
(extractor
|
|
(fabs x)
|
|
(inst_data (InstructionData.Unary (Opcode.Fabs) x))
|
|
)
|
|
|
|
(decl fcopysign (Value Value) Inst)
|
|
(extractor
|
|
(fcopysign x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fcopysign) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fmin (Value Value) Inst)
|
|
(extractor
|
|
(fmin x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fmin) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fmin_pseudo (Value Value) Inst)
|
|
(extractor
|
|
(fmin_pseudo x y)
|
|
(inst_data (InstructionData.Binary (Opcode.FminPseudo) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fmax (Value Value) Inst)
|
|
(extractor
|
|
(fmax x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Fmax) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl fmax_pseudo (Value Value) Inst)
|
|
(extractor
|
|
(fmax_pseudo x y)
|
|
(inst_data (InstructionData.Binary (Opcode.FmaxPseudo) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl ceil (Value) Inst)
|
|
(extractor
|
|
(ceil x)
|
|
(inst_data (InstructionData.Unary (Opcode.Ceil) x))
|
|
)
|
|
|
|
(decl floor (Value) Inst)
|
|
(extractor
|
|
(floor x)
|
|
(inst_data (InstructionData.Unary (Opcode.Floor) x))
|
|
)
|
|
|
|
(decl trunc (Value) Inst)
|
|
(extractor
|
|
(trunc x)
|
|
(inst_data (InstructionData.Unary (Opcode.Trunc) x))
|
|
)
|
|
|
|
(decl nearest (Value) Inst)
|
|
(extractor
|
|
(nearest x)
|
|
(inst_data (InstructionData.Unary (Opcode.Nearest) x))
|
|
)
|
|
|
|
(decl is_null (Value) Inst)
|
|
(extractor
|
|
(is_null x)
|
|
(inst_data (InstructionData.Unary (Opcode.IsNull) x))
|
|
)
|
|
|
|
(decl is_invalid (Value) Inst)
|
|
(extractor
|
|
(is_invalid x)
|
|
(inst_data (InstructionData.Unary (Opcode.IsInvalid) x))
|
|
)
|
|
|
|
(decl trueif (IntCC Value) Inst)
|
|
(extractor
|
|
(trueif Cond f)
|
|
(inst_data (InstructionData.IntCond (Opcode.Trueif) f Cond))
|
|
)
|
|
|
|
(decl trueff (FloatCC Value) Inst)
|
|
(extractor
|
|
(trueff Cond f)
|
|
(inst_data (InstructionData.FloatCond (Opcode.Trueff) f Cond))
|
|
)
|
|
|
|
(decl bitcast (Value) Inst)
|
|
(extractor
|
|
(bitcast x)
|
|
(inst_data (InstructionData.Unary (Opcode.Bitcast) x))
|
|
)
|
|
|
|
(decl raw_bitcast (Value) Inst)
|
|
(extractor
|
|
(raw_bitcast x)
|
|
(inst_data (InstructionData.Unary (Opcode.RawBitcast) x))
|
|
)
|
|
|
|
(decl scalar_to_vector (Value) Inst)
|
|
(extractor
|
|
(scalar_to_vector s)
|
|
(inst_data (InstructionData.Unary (Opcode.ScalarToVector) s))
|
|
)
|
|
|
|
(decl breduce (Value) Inst)
|
|
(extractor
|
|
(breduce x)
|
|
(inst_data (InstructionData.Unary (Opcode.Breduce) x))
|
|
)
|
|
|
|
(decl bextend (Value) Inst)
|
|
(extractor
|
|
(bextend x)
|
|
(inst_data (InstructionData.Unary (Opcode.Bextend) x))
|
|
)
|
|
|
|
(decl bint (Value) Inst)
|
|
(extractor
|
|
(bint x)
|
|
(inst_data (InstructionData.Unary (Opcode.Bint) x))
|
|
)
|
|
|
|
(decl bmask (Value) Inst)
|
|
(extractor
|
|
(bmask x)
|
|
(inst_data (InstructionData.Unary (Opcode.Bmask) x))
|
|
)
|
|
|
|
(decl ireduce (Value) Inst)
|
|
(extractor
|
|
(ireduce x)
|
|
(inst_data (InstructionData.Unary (Opcode.Ireduce) x))
|
|
)
|
|
|
|
(decl snarrow (Value Value) Inst)
|
|
(extractor
|
|
(snarrow x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Snarrow) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl unarrow (Value Value) Inst)
|
|
(extractor
|
|
(unarrow x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Unarrow) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl uunarrow (Value Value) Inst)
|
|
(extractor
|
|
(uunarrow x y)
|
|
(inst_data (InstructionData.Binary (Opcode.Uunarrow) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl swiden_low (Value) Inst)
|
|
(extractor
|
|
(swiden_low x)
|
|
(inst_data (InstructionData.Unary (Opcode.SwidenLow) x))
|
|
)
|
|
|
|
(decl swiden_high (Value) Inst)
|
|
(extractor
|
|
(swiden_high x)
|
|
(inst_data (InstructionData.Unary (Opcode.SwidenHigh) x))
|
|
)
|
|
|
|
(decl uwiden_low (Value) Inst)
|
|
(extractor
|
|
(uwiden_low x)
|
|
(inst_data (InstructionData.Unary (Opcode.UwidenLow) x))
|
|
)
|
|
|
|
(decl uwiden_high (Value) Inst)
|
|
(extractor
|
|
(uwiden_high x)
|
|
(inst_data (InstructionData.Unary (Opcode.UwidenHigh) x))
|
|
)
|
|
|
|
(decl iadd_pairwise (Value Value) Inst)
|
|
(extractor
|
|
(iadd_pairwise x y)
|
|
(inst_data (InstructionData.Binary (Opcode.IaddPairwise) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl widening_pairwise_dot_product_s (Value Value) Inst)
|
|
(extractor
|
|
(widening_pairwise_dot_product_s x y)
|
|
(inst_data (InstructionData.Binary (Opcode.WideningPairwiseDotProductS) (value_array_2 x y)))
|
|
)
|
|
|
|
(decl uextend (Value) Inst)
|
|
(extractor
|
|
(uextend x)
|
|
(inst_data (InstructionData.Unary (Opcode.Uextend) x))
|
|
)
|
|
|
|
(decl sextend (Value) Inst)
|
|
(extractor
|
|
(sextend x)
|
|
(inst_data (InstructionData.Unary (Opcode.Sextend) x))
|
|
)
|
|
|
|
(decl fpromote (Value) Inst)
|
|
(extractor
|
|
(fpromote x)
|
|
(inst_data (InstructionData.Unary (Opcode.Fpromote) x))
|
|
)
|
|
|
|
(decl fdemote (Value) Inst)
|
|
(extractor
|
|
(fdemote x)
|
|
(inst_data (InstructionData.Unary (Opcode.Fdemote) x))
|
|
)
|
|
|
|
(decl fvdemote (Value) Inst)
|
|
(extractor
|
|
(fvdemote x)
|
|
(inst_data (InstructionData.Unary (Opcode.Fvdemote) x))
|
|
)
|
|
|
|
(decl fvpromote_low (Value) Inst)
|
|
(extractor
|
|
(fvpromote_low a)
|
|
(inst_data (InstructionData.Unary (Opcode.FvpromoteLow) a))
|
|
)
|
|
|
|
(decl fcvt_to_uint (Value) Inst)
|
|
(extractor
|
|
(fcvt_to_uint x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtToUint) x))
|
|
)
|
|
|
|
(decl fcvt_to_uint_sat (Value) Inst)
|
|
(extractor
|
|
(fcvt_to_uint_sat x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtToUintSat) x))
|
|
)
|
|
|
|
(decl fcvt_to_sint (Value) Inst)
|
|
(extractor
|
|
(fcvt_to_sint x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtToSint) x))
|
|
)
|
|
|
|
(decl fcvt_to_sint_sat (Value) Inst)
|
|
(extractor
|
|
(fcvt_to_sint_sat x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtToSintSat) x))
|
|
)
|
|
|
|
(decl fcvt_from_uint (Value) Inst)
|
|
(extractor
|
|
(fcvt_from_uint x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtFromUint) x))
|
|
)
|
|
|
|
(decl fcvt_from_sint (Value) Inst)
|
|
(extractor
|
|
(fcvt_from_sint x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtFromSint) x))
|
|
)
|
|
|
|
(decl fcvt_low_from_sint (Value) Inst)
|
|
(extractor
|
|
(fcvt_low_from_sint x)
|
|
(inst_data (InstructionData.Unary (Opcode.FcvtLowFromSint) x))
|
|
)
|
|
|
|
(decl isplit (Value) Inst)
|
|
(extractor
|
|
(isplit x)
|
|
(inst_data (InstructionData.Unary (Opcode.Isplit) x))
|
|
)
|
|
|
|
(decl iconcat (Value Value) Inst)
|
|
(extractor
|
|
(iconcat lo hi)
|
|
(inst_data (InstructionData.Binary (Opcode.Iconcat) (value_array_2 lo hi)))
|
|
)
|
|
|
|
(decl atomic_rmw (MemFlags AtomicRmwOp Value Value) Inst)
|
|
(extractor
|
|
(atomic_rmw MemFlags AtomicRmwOp p x)
|
|
(inst_data (InstructionData.AtomicRmw (Opcode.AtomicRmw) (value_array_2 p x) MemFlags AtomicRmwOp))
|
|
)
|
|
|
|
(decl atomic_cas (MemFlags Value Value Value) Inst)
|
|
(extractor
|
|
(atomic_cas MemFlags p e x)
|
|
(inst_data (InstructionData.AtomicCas (Opcode.AtomicCas) (value_array_3 p e x) MemFlags))
|
|
)
|
|
|
|
(decl atomic_load (MemFlags Value) Inst)
|
|
(extractor
|
|
(atomic_load MemFlags p)
|
|
(inst_data (InstructionData.LoadNoOffset (Opcode.AtomicLoad) p MemFlags))
|
|
)
|
|
|
|
(decl atomic_store (MemFlags Value Value) Inst)
|
|
(extractor
|
|
(atomic_store MemFlags x p)
|
|
(inst_data (InstructionData.StoreNoOffset (Opcode.AtomicStore) (value_array_2 x p) MemFlags))
|
|
)
|
|
|
|
(decl fence () Inst)
|
|
(extractor
|
|
(fence )
|
|
(inst_data (InstructionData.NullAry (Opcode.Fence)))
|
|
)
|
|
|