summaryrefslogtreecommitdiff
path: root/include/llvm/Target/GenericOpcodes.td
diff options
context:
space:
mode:
Diffstat (limited to 'include/llvm/Target/GenericOpcodes.td')
-rw-r--r--include/llvm/Target/GenericOpcodes.td215
1 files changed, 136 insertions, 79 deletions
diff --git a/include/llvm/Target/GenericOpcodes.td b/include/llvm/Target/GenericOpcodes.td
index e35bcb015d6a..28c90bf22767 100644
--- a/include/llvm/Target/GenericOpcodes.td
+++ b/include/llvm/Target/GenericOpcodes.td
@@ -16,9 +16,11 @@
// Unary ops.
//------------------------------------------------------------------------------
+class GenericInstruction : StandardPseudoInstruction;
+
// Extend the underlying scalar type of an operation, leaving the high bits
// unspecified.
-def G_ANYEXT : Instruction {
+def G_ANYEXT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
@@ -26,7 +28,7 @@ def G_ANYEXT : Instruction {
// Sign extend the underlying scalar type of an operation, copying the sign bit
// into the newly-created space.
-def G_SEXT : Instruction {
+def G_SEXT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
@@ -34,7 +36,7 @@ def G_SEXT : Instruction {
// Zero extend the underlying scalar type of an operation, putting zero bits
// into the newly-created space.
-def G_ZEXT : Instruction {
+def G_ZEXT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
@@ -43,68 +45,74 @@ def G_ZEXT : Instruction {
// Truncate the underlying scalar type of an operation. This is equivalent to
// G_EXTRACT for scalar types, but acts elementwise on vectors.
-def G_TRUNC : Instruction {
+def G_TRUNC : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_IMPLICIT_DEF : Instruction {
+def G_IMPLICIT_DEF : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins);
let hasSideEffects = 0;
}
-def G_FRAME_INDEX : Instruction {
+def G_PHI : GenericInstruction {
+ let OutOperandList = (outs type0:$dst);
+ let InOperandList = (ins variable_ops);
+ let hasSideEffects = 0;
+}
+
+def G_FRAME_INDEX : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins unknown:$src2);
let hasSideEffects = 0;
}
-def G_GLOBAL_VALUE : Instruction {
+def G_GLOBAL_VALUE : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins unknown:$src);
let hasSideEffects = 0;
}
-def G_INTTOPTR : Instruction {
+def G_INTTOPTR : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_PTRTOINT : Instruction {
+def G_PTRTOINT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_BITCAST : Instruction {
+def G_BITCAST : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_CONSTANT : Instruction {
+def G_CONSTANT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins unknown:$imm);
let hasSideEffects = 0;
}
-def G_FCONSTANT : Instruction {
+def G_FCONSTANT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins unknown:$imm);
let hasSideEffects = 0;
}
-def G_VASTART : Instruction {
+def G_VASTART : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins type0:$list);
let hasSideEffects = 0;
let mayStore = 1;
}
-def G_VAARG : Instruction {
+def G_VAARG : GenericInstruction {
let OutOperandList = (outs type0:$val);
let InOperandList = (ins type1:$list, unknown:$align);
let hasSideEffects = 0;
@@ -112,12 +120,18 @@ def G_VAARG : Instruction {
let mayStore = 1;
}
+def G_BSWAP : GenericInstruction {
+ let OutOperandList = (outs type0:$dst);
+ let InOperandList = (ins type0:$src);
+ let hasSideEffects = 0;
+}
+
//------------------------------------------------------------------------------
// Binary ops.
//------------------------------------------------------------------------------
// Generic addition.
-def G_ADD : Instruction {
+def G_ADD : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -125,7 +139,7 @@ def G_ADD : Instruction {
}
// Generic subtraction.
-def G_SUB : Instruction {
+def G_SUB : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -133,7 +147,7 @@ def G_SUB : Instruction {
}
// Generic multiplication.
-def G_MUL : Instruction {
+def G_MUL : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -141,7 +155,7 @@ def G_MUL : Instruction {
}
// Generic signed division.
-def G_SDIV : Instruction {
+def G_SDIV : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -149,7 +163,7 @@ def G_SDIV : Instruction {
}
// Generic unsigned division.
-def G_UDIV : Instruction {
+def G_UDIV : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -157,7 +171,7 @@ def G_UDIV : Instruction {
}
// Generic signed remainder.
-def G_SREM : Instruction {
+def G_SREM : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -165,7 +179,7 @@ def G_SREM : Instruction {
}
// Generic unsigned remainder.
-def G_UREM : Instruction {
+def G_UREM : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -173,7 +187,7 @@ def G_UREM : Instruction {
}
// Generic bitwise and.
-def G_AND : Instruction {
+def G_AND : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -181,7 +195,7 @@ def G_AND : Instruction {
}
// Generic bitwise or.
-def G_OR : Instruction {
+def G_OR : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -189,7 +203,7 @@ def G_OR : Instruction {
}
// Generic bitwise xor.
-def G_XOR : Instruction {
+def G_XOR : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -197,55 +211,55 @@ def G_XOR : Instruction {
}
// Generic left-shift.
-def G_SHL : Instruction {
+def G_SHL : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Generic logical right-shift.
-def G_LSHR : Instruction {
+def G_LSHR : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Generic arithmetic right-shift.
-def G_ASHR : Instruction {
+def G_ASHR : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Generic integer comparison.
-def G_ICMP : Instruction {
+def G_ICMP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins unknown:$tst, type1:$src1, type1:$src2);
let hasSideEffects = 0;
}
// Generic floating-point comparison.
-def G_FCMP : Instruction {
+def G_FCMP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins unknown:$tst, type1:$src1, type1:$src2);
let hasSideEffects = 0;
}
// Generic select
-def G_SELECT : Instruction {
+def G_SELECT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$tst, type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Generic pointer offset.
-def G_GEP : Instruction {
+def G_GEP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type1:$src2);
let hasSideEffects = 0;
}
-def G_PTR_MASK : Instruction {
+def G_PTR_MASK : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src, unknown:$bits);
let hasSideEffects = 0;
@@ -256,14 +270,14 @@ def G_PTR_MASK : Instruction {
//------------------------------------------------------------------------------
// Generic unsigned addition consuming and producing a carry flag.
-def G_UADDE : Instruction {
+def G_UADDE : GenericInstruction {
let OutOperandList = (outs type0:$dst, type1:$carry_out);
let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
let hasSideEffects = 0;
}
// Generic signed addition producing a carry flag.
-def G_SADDO : Instruction {
+def G_SADDO : GenericInstruction {
let OutOperandList = (outs type0:$dst, type1:$carry_out);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -271,21 +285,21 @@ def G_SADDO : Instruction {
}
// Generic unsigned subtraction consuming and producing a carry flag.
-def G_USUBE : Instruction {
+def G_USUBE : GenericInstruction {
let OutOperandList = (outs type0:$dst, type1:$carry_out);
let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
let hasSideEffects = 0;
}
// Generic unsigned subtraction producing a carry flag.
-def G_SSUBO : Instruction {
+def G_SSUBO : GenericInstruction {
let OutOperandList = (outs type0:$dst, type1:$carry_out);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Generic unsigned multiplication producing a carry flag.
-def G_UMULO : Instruction {
+def G_UMULO : GenericInstruction {
let OutOperandList = (outs type0:$dst, type1:$carry_out);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -293,7 +307,7 @@ def G_UMULO : Instruction {
}
// Generic signed multiplication producing a carry flag.
-def G_SMULO : Instruction {
+def G_SMULO : GenericInstruction {
let OutOperandList = (outs type0:$dst, type1:$carry_out);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -302,7 +316,7 @@ def G_SMULO : Instruction {
// Multiply two numbers at twice the incoming bit width (unsigned) and return
// the high half of the result.
-def G_UMULH : Instruction {
+def G_UMULH : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -311,7 +325,7 @@ def G_UMULH : Instruction {
// Multiply two numbers at twice the incoming bit width (signed) and return
// the high half of the result.
-def G_SMULH : Instruction {
+def G_SMULH : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -322,43 +336,43 @@ def G_SMULH : Instruction {
// Floating Point Unary Ops.
//------------------------------------------------------------------------------
-def G_FNEG : Instruction {
+def G_FNEG : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src);
let hasSideEffects = 0;
}
-def G_FPEXT : Instruction {
+def G_FPEXT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_FPTRUNC : Instruction {
+def G_FPTRUNC : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_FPTOSI : Instruction {
+def G_FPTOSI : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_FPTOUI : Instruction {
+def G_FPTOUI : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_SITOFP : Instruction {
+def G_SITOFP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
-def G_UITOFP : Instruction {
+def G_UITOFP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
@@ -369,7 +383,7 @@ def G_UITOFP : Instruction {
//------------------------------------------------------------------------------
// Generic FP addition.
-def G_FADD : Instruction {
+def G_FADD : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -377,7 +391,7 @@ def G_FADD : Instruction {
}
// Generic FP subtraction.
-def G_FSUB : Instruction {
+def G_FSUB : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -385,7 +399,7 @@ def G_FSUB : Instruction {
}
// Generic FP multiplication.
-def G_FMUL : Instruction {
+def G_FMUL : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
@@ -394,7 +408,7 @@ def G_FMUL : Instruction {
// Generic fused multiply-add instruction.
// Behaves like llvm fma intrinsic ie src1 * src2 + src3
-def G_FMA : Instruction {
+def G_FMA : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2, type0:$src3);
let hasSideEffects = 0;
@@ -402,49 +416,49 @@ def G_FMA : Instruction {
}
// Generic FP division.
-def G_FDIV : Instruction {
+def G_FDIV : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Generic FP remainder.
-def G_FREM : Instruction {
+def G_FREM : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Floating point exponentiation.
-def G_FPOW : Instruction {
+def G_FPOW : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1, type0:$src2);
let hasSideEffects = 0;
}
// Floating point base-e exponential of a value.
-def G_FEXP : Instruction {
+def G_FEXP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1);
let hasSideEffects = 0;
}
// Floating point base-2 exponential of a value.
-def G_FEXP2 : Instruction {
+def G_FEXP2 : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1);
let hasSideEffects = 0;
}
// Floating point base-2 logarithm of a value.
-def G_FLOG : Instruction {
+def G_FLOG : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1);
let hasSideEffects = 0;
}
// Floating point base-2 logarithm of a value.
-def G_FLOG2 : Instruction {
+def G_FLOG2 : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src1);
let hasSideEffects = 0;
@@ -455,29 +469,71 @@ def G_FLOG2 : Instruction {
//------------------------------------------------------------------------------
// Generic load. Expects a MachineMemOperand in addition to explicit operands.
-def G_LOAD : Instruction {
+def G_LOAD : GenericInstruction {
let OutOperandList = (outs type0:$dst);
- let InOperandList = (ins type1:$addr);
+ let InOperandList = (ins ptype1:$addr);
let hasSideEffects = 0;
let mayLoad = 1;
}
// Generic store. Expects a MachineMemOperand in addition to explicit operands.
-def G_STORE : Instruction {
+def G_STORE : GenericInstruction {
let OutOperandList = (outs);
- let InOperandList = (ins type0:$src, type1:$addr);
+ let InOperandList = (ins type0:$src, ptype1:$addr);
+ let hasSideEffects = 0;
+ let mayStore = 1;
+}
+
+// Generic atomic cmpxchg with internal success check. Expects a
+// MachineMemOperand in addition to explicit operands.
+def G_ATOMIC_CMPXCHG_WITH_SUCCESS : GenericInstruction {
+ let OutOperandList = (outs type0:$oldval, type1:$success);
+ let InOperandList = (ins type2:$addr, type0:$cmpval, type0:$newval);
let hasSideEffects = 0;
+ let mayLoad = 1;
let mayStore = 1;
}
+// Generic atomic cmpxchg. Expects a MachineMemOperand in addition to explicit
+// operands.
+def G_ATOMIC_CMPXCHG : GenericInstruction {
+ let OutOperandList = (outs type0:$oldval);
+ let InOperandList = (ins ptype1:$addr, type0:$cmpval, type0:$newval);
+ let hasSideEffects = 0;
+ let mayLoad = 1;
+ let mayStore = 1;
+}
+
+// Generic atomicrmw. Expects a MachineMemOperand in addition to explicit
+// operands.
+class G_ATOMICRMW_OP : GenericInstruction {
+ let OutOperandList = (outs type0:$oldval);
+ let InOperandList = (ins ptype1:$addr, type0:$val);
+ let hasSideEffects = 0;
+ let mayLoad = 1;
+ let mayStore = 1;
+}
+
+def G_ATOMICRMW_XCHG : G_ATOMICRMW_OP;
+def G_ATOMICRMW_ADD : G_ATOMICRMW_OP;
+def G_ATOMICRMW_SUB : G_ATOMICRMW_OP;
+def G_ATOMICRMW_AND : G_ATOMICRMW_OP;
+def G_ATOMICRMW_NAND : G_ATOMICRMW_OP;
+def G_ATOMICRMW_OR : G_ATOMICRMW_OP;
+def G_ATOMICRMW_XOR : G_ATOMICRMW_OP;
+def G_ATOMICRMW_MAX : G_ATOMICRMW_OP;
+def G_ATOMICRMW_MIN : G_ATOMICRMW_OP;
+def G_ATOMICRMW_UMAX : G_ATOMICRMW_OP;
+def G_ATOMICRMW_UMIN : G_ATOMICRMW_OP;
+
//------------------------------------------------------------------------------
// Variadic ops
//------------------------------------------------------------------------------
-// Extract multiple registers specified size, starting from blocks given by
-// indexes. This will almost certainly be mapped to sub-register COPYs after
+// Extract a register of the specified size, starting from the block given by
+// index. This will almost certainly be mapped to sub-register COPYs after
// register banks have been selected.
-def G_EXTRACT : Instruction {
+def G_EXTRACT : GenericInstruction {
let OutOperandList = (outs type0:$res);
let InOperandList = (ins type1:$src, unknown:$offset);
let hasSideEffects = 0;
@@ -486,34 +542,35 @@ def G_EXTRACT : Instruction {
// Extract multiple registers specified size, starting from blocks given by
// indexes. This will almost certainly be mapped to sub-register COPYs after
// register banks have been selected.
-def G_UNMERGE_VALUES : Instruction {
- let OutOperandList = (outs);
- let InOperandList = (ins variable_ops);
+def G_UNMERGE_VALUES : GenericInstruction {
+ let OutOperandList = (outs type0:$dst0, variable_ops);
+ let InOperandList = (ins type1:$src);
let hasSideEffects = 0;
}
// Insert a smaller register into a larger one at the specified bit-index.
-def G_INSERT : Instruction {
+def G_INSERT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src, type1:$op, unknown:$offset);
let hasSideEffects = 0;
}
-def G_MERGE_VALUES : Instruction {
+/// Concatenate multiple registers of the same size into a wider register.
+def G_MERGE_VALUES : GenericInstruction {
let OutOperandList = (outs type0:$dst);
- let InOperandList = (ins variable_ops);
+ let InOperandList = (ins type1:$src0, variable_ops);
let hasSideEffects = 0;
}
// Intrinsic without side effects.
-def G_INTRINSIC : Instruction {
+def G_INTRINSIC : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins unknown:$intrin, variable_ops);
let hasSideEffects = 0;
}
// Intrinsic with side effects.
-def G_INTRINSIC_W_SIDE_EFFECTS : Instruction {
+def G_INTRINSIC_W_SIDE_EFFECTS : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins unknown:$intrin, variable_ops);
let hasSideEffects = 1;
@@ -526,7 +583,7 @@ def G_INTRINSIC_W_SIDE_EFFECTS : Instruction {
//------------------------------------------------------------------------------
// Generic unconditional branch.
-def G_BR : Instruction {
+def G_BR : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins unknown:$src1);
let hasSideEffects = 0;
@@ -536,7 +593,7 @@ def G_BR : Instruction {
}
// Generic conditional branch.
-def G_BRCOND : Instruction {
+def G_BRCOND : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins type0:$tst, unknown:$truebb);
let hasSideEffects = 0;
@@ -545,7 +602,7 @@ def G_BRCOND : Instruction {
}
// Generic indirect branch.
-def G_BRINDIRECT : Instruction {
+def G_BRINDIRECT : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins type0:$src1);
let hasSideEffects = 0;
@@ -558,21 +615,21 @@ def G_BRINDIRECT : Instruction {
//------------------------------------------------------------------------------
// Generic insertelement.
-def G_INSERT_VECTOR_ELT : Instruction {
+def G_INSERT_VECTOR_ELT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src, type1:$elt, type2:$idx);
let hasSideEffects = 0;
}
// Generic extractelement.
-def G_EXTRACT_VECTOR_ELT : Instruction {
+def G_EXTRACT_VECTOR_ELT : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$src, type2:$idx);
let hasSideEffects = 0;
}
// Generic shufflevector.
-def G_SHUFFLE_VECTOR: Instruction {
+def G_SHUFFLE_VECTOR: GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type1:$v1, type1:$v2, type2:$mask);
let hasSideEffects = 0;
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-02 21:15:08 +0000