cranelift-codegen 0.79.0

;; 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)))
)