[llvm] r319701 - Allow similar TargetOpcodes to use inheritance to factor out commonality. NFC.
Daniel Sanders via llvm-commits
llvm-commits at lists.llvm.org
Mon Dec 4 13:40:57 PST 2017
Author: dsanders
Date: Mon Dec 4 13:40:57 2017
New Revision: 319701
URL: http://llvm.org/viewvc/llvm-project?rev=319701&view=rev
Log:
Allow similar TargetOpcodes to use inheritance to factor out commonality. NFC.
Summary:
While implementing atomicrmw in https://reviews.llvm.org/D40092 I found that
inheritance is unusable for all the Generic Opcodes in GlobalISel. This is
because the whole header is included inside a 'let mayLoad = 0, mayStore = 0 ... in'
block. In TableGen, the order of precedence for field assignments is:
1. Values from classes the record inherits from.
2. Values from 'let Name=Value in { ... }'
3. Values from 'let Name=Value;'
As such the 'let mayLoad = 0, mayStore = 0, ... in' surrounding the
'include "GenericOpcodes.td"' was overriding any values provided via inheritance.
We hadn't noticed this before because we were only using 'let Name=Value;' to
specialize opcodes.
Fix this by moving the default values to the lowest precedence. This is
accomplished by moving the values to a common base class
(StandardPseudoInstruction for most TargetOpcodes, and GenericOpcode for
GlobalISel specific TargetOpcodes)
Reviewers: qcolombet
Reviewed By: qcolombet
Subscribers: llvm-commits, igorb
Differential Revision: https://reviews.llvm.org/D40096
Modified:
llvm/trunk/include/llvm/Target/GenericOpcodes.td
llvm/trunk/include/llvm/Target/Target.td
Modified: llvm/trunk/include/llvm/Target/GenericOpcodes.td
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Target/GenericOpcodes.td?rev=319701&r1=319700&r2=319701&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Target/GenericOpcodes.td (original)
+++ llvm/trunk/include/llvm/Target/GenericOpcodes.td Mon Dec 4 13:40:57 2017
@@ -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,74 +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_PHI : Instruction {
+def G_PHI : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins variable_ops);
let hasSideEffects = 0;
}
-def G_FRAME_INDEX : Instruction {
+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;
@@ -118,7 +120,7 @@ def G_VAARG : Instruction {
let mayStore = 1;
}
-def G_BSWAP : Instruction {
+def G_BSWAP : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins type0:$src);
let hasSideEffects = 0;
@@ -129,7 +131,7 @@ def G_BSWAP : Instruction {
//------------------------------------------------------------------------------
// 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;
@@ -137,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;
@@ -145,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;
@@ -153,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;
@@ -161,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;
@@ -169,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;
@@ -177,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;
@@ -185,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;
@@ -193,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;
@@ -201,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;
@@ -209,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;
@@ -268,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;
@@ -283,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;
@@ -305,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;
@@ -314,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;
@@ -323,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;
@@ -334,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;
@@ -381,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;
@@ -389,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;
@@ -397,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;
@@ -406,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;
@@ -414,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;
@@ -467,7 +469,7 @@ 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 ptype1:$addr);
let hasSideEffects = 0;
@@ -475,7 +477,7 @@ def G_LOAD : Instruction {
}
// 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, ptype1:$addr);
let hasSideEffects = 0;
@@ -486,7 +488,7 @@ def G_STORE : Instruction {
// operands. Technically, we could have handled this as a G_LOAD, however we
// decided to keep it separate on the basis that atomic loads tend to have
// very different handling to non-atomic loads.
-def G_ATOMIC_LOAD : Instruction {
+def G_ATOMIC_LOAD : GenericInstruction {
let OutOperandList = (outs type0:$dst);
let InOperandList = (ins ptype1:$addr);
let hasSideEffects = 0;
@@ -497,7 +499,7 @@ def G_ATOMIC_LOAD : Instruction {
// operands. Technically, we could have handled this as a G_STORE, however we
// decided to keep it separate on the basis that atomic stores tend to have
// very different handling to non-atomic stores.
-def G_ATOMIC_STORE : Instruction {
+def G_ATOMIC_STORE : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins type0:$src, ptype1:$addr);
let hasSideEffects = 0;
@@ -506,7 +508,7 @@ def G_ATOMIC_STORE : Instruction {
// Generic atomic cmpxchg with internal success check. Expects a
// MachineMemOperand in addition to explicit operands.
-def G_ATOMIC_CMPXCHG_WITH_SUCCESS : Instruction {
+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;
@@ -516,7 +518,7 @@ def G_ATOMIC_CMPXCHG_WITH_SUCCESS : Inst
// Generic atomic cmpxchg. Expects a MachineMemOperand in addition to explicit
// operands.
-def G_ATOMIC_CMPXCHG : Instruction {
+def G_ATOMIC_CMPXCHG : GenericInstruction {
let OutOperandList = (outs type0:$oldval);
let InOperandList = (ins ptype1:$addr, type0:$cmpval, type0:$newval);
let hasSideEffects = 0;
@@ -526,7 +528,7 @@ def G_ATOMIC_CMPXCHG : Instruction {
// Generic atomicrmw. Expects a MachineMemOperand in addition to explicit
// operands.
-class G_ATOMICRMW_OP : Instruction {
+class G_ATOMICRMW_OP : GenericInstruction {
let OutOperandList = (outs type0:$oldval);
let InOperandList = (ins ptype1:$addr, type0:$val);
let hasSideEffects = 0;
@@ -534,83 +536,17 @@ class G_ATOMICRMW_OP : Instruction {
let mayStore = 1;
}
-def G_ATOMICRMW_XCHG : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_ADD : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_SUB : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_AND : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_NAND : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_OR : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_XOR : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_MAX : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_MIN : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_UMAX : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- let mayLoad = 1;
- let mayStore = 1;
-}
-def G_ATOMICRMW_UMIN : G_ATOMICRMW_OP {
- // FIXME: This include is surrounded by a 'let mayLoad = 0, mayStore = 0 in {}'
- // block which overrides the value inherited from G_ATOMICRMW_OP. Work
- // around this for now. See http://reviews.llvm.org/D40096
- 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
@@ -619,7 +555,7 @@ def G_ATOMICRMW_UMIN : G_ATOMICRMW_OP {
// 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;
@@ -628,35 +564,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 {
+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;
}
/// Concatenate multiple registers of the same size into a wider register.
-def G_MERGE_VALUES : Instruction {
+def G_MERGE_VALUES : GenericInstruction {
let OutOperandList = (outs type0:$dst);
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;
@@ -669,7 +605,7 @@ def G_INTRINSIC_W_SIDE_EFFECTS : Instruc
//------------------------------------------------------------------------------
// Generic unconditional branch.
-def G_BR : Instruction {
+def G_BR : GenericInstruction {
let OutOperandList = (outs);
let InOperandList = (ins unknown:$src1);
let hasSideEffects = 0;
@@ -679,7 +615,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;
@@ -688,7 +624,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;
@@ -701,21 +637,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;
Modified: llvm/trunk/include/llvm/Target/Target.td
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Target/Target.td?rev=319701&r1=319700&r2=319701&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Target/Target.td (original)
+++ llvm/trunk/include/llvm/Target/Target.td Mon Dec 4 13:40:57 2017
@@ -897,21 +897,27 @@ class InstrInfo {
// Ensure mayLoad and mayStore have a default value, so as not to break
// targets that set guessInstructionProperties=0. Any local definition of
// mayLoad/mayStore takes precedence over these default values.
-let mayLoad = 0, mayStore = 0, isCodeGenOnly = 1, isPseudo = 1,
- hasNoSchedulingInfo = 1, Namespace = "TargetOpcode" in {
-def PHI : Instruction {
+class StandardPseudoInstruction : Instruction {
+ let mayLoad = 0;
+ let mayStore = 0;
+ let isCodeGenOnly = 1;
+ let isPseudo = 1;
+ let hasNoSchedulingInfo = 1;
+ let Namespace = "TargetOpcode";
+}
+def PHI : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins variable_ops);
let AsmString = "PHINODE";
let hasSideEffects = 0;
}
-def INLINEASM : Instruction {
+def INLINEASM : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins variable_ops);
let AsmString = "";
let hasSideEffects = 0; // Note side effect is encoded in an operand.
}
-def CFI_INSTRUCTION : Instruction {
+def CFI_INSTRUCTION : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i32imm:$id);
let AsmString = "";
@@ -919,7 +925,7 @@ def CFI_INSTRUCTION : Instruction {
let hasSideEffects = 0;
let isNotDuplicable = 1;
}
-def EH_LABEL : Instruction {
+def EH_LABEL : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i32imm:$id);
let AsmString = "";
@@ -927,7 +933,7 @@ def EH_LABEL : Instruction {
let hasSideEffects = 0;
let isNotDuplicable = 1;
}
-def GC_LABEL : Instruction {
+def GC_LABEL : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i32imm:$id);
let AsmString = "";
@@ -935,7 +941,7 @@ def GC_LABEL : Instruction {
let hasSideEffects = 0;
let isNotDuplicable = 1;
}
-def ANNOTATION_LABEL : Instruction {
+def ANNOTATION_LABEL : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i32imm:$id);
let AsmString = "";
@@ -943,26 +949,26 @@ def ANNOTATION_LABEL : Instruction {
let hasSideEffects = 0;
let isNotDuplicable = 1;
}
-def KILL : Instruction {
+def KILL : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins variable_ops);
let AsmString = "";
let hasSideEffects = 0;
}
-def EXTRACT_SUBREG : Instruction {
+def EXTRACT_SUBREG : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins unknown:$supersrc, i32imm:$subidx);
let AsmString = "";
let hasSideEffects = 0;
}
-def INSERT_SUBREG : Instruction {
+def INSERT_SUBREG : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins unknown:$supersrc, unknown:$subsrc, i32imm:$subidx);
let AsmString = "";
let hasSideEffects = 0;
let Constraints = "$supersrc = $dst";
}
-def IMPLICIT_DEF : Instruction {
+def IMPLICIT_DEF : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins);
let AsmString = "";
@@ -970,33 +976,33 @@ def IMPLICIT_DEF : Instruction {
let isReMaterializable = 1;
let isAsCheapAsAMove = 1;
}
-def SUBREG_TO_REG : Instruction {
+def SUBREG_TO_REG : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins unknown:$implsrc, unknown:$subsrc, i32imm:$subidx);
let AsmString = "";
let hasSideEffects = 0;
}
-def COPY_TO_REGCLASS : Instruction {
+def COPY_TO_REGCLASS : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins unknown:$src, i32imm:$regclass);
let AsmString = "";
let hasSideEffects = 0;
let isAsCheapAsAMove = 1;
}
-def DBG_VALUE : Instruction {
+def DBG_VALUE : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins variable_ops);
let AsmString = "DBG_VALUE";
let hasSideEffects = 0;
}
-def REG_SEQUENCE : Instruction {
+def REG_SEQUENCE : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins unknown:$supersrc, variable_ops);
let AsmString = "";
let hasSideEffects = 0;
let isAsCheapAsAMove = 1;
}
-def COPY : Instruction {
+def COPY : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins unknown:$src);
let AsmString = "";
@@ -1004,25 +1010,25 @@ def COPY : Instruction {
let isAsCheapAsAMove = 1;
let hasNoSchedulingInfo = 0;
}
-def BUNDLE : Instruction {
+def BUNDLE : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins variable_ops);
let AsmString = "BUNDLE";
let hasSideEffects = 1;
}
-def LIFETIME_START : Instruction {
+def LIFETIME_START : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i32imm:$id);
let AsmString = "LIFETIME_START";
let hasSideEffects = 0;
}
-def LIFETIME_END : Instruction {
+def LIFETIME_END : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i32imm:$id);
let AsmString = "LIFETIME_END";
let hasSideEffects = 0;
}
-def STACKMAP : Instruction {
+def STACKMAP : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins i64imm:$id, i32imm:$nbytes, variable_ops);
let hasSideEffects = 1;
@@ -1030,7 +1036,7 @@ def STACKMAP : Instruction {
let mayLoad = 1;
let usesCustomInserter = 1;
}
-def PATCHPOINT : Instruction {
+def PATCHPOINT : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins i64imm:$id, i32imm:$nbytes, unknown:$callee,
i32imm:$nargs, i32imm:$cc, variable_ops);
@@ -1039,7 +1045,7 @@ def PATCHPOINT : Instruction {
let mayLoad = 1;
let usesCustomInserter = 1;
}
-def STATEPOINT : Instruction {
+def STATEPOINT : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins variable_ops);
let usesCustomInserter = 1;
@@ -1048,7 +1054,7 @@ def STATEPOINT : Instruction {
let hasSideEffects = 1;
let isCall = 1;
}
-def LOAD_STACK_GUARD : Instruction {
+def LOAD_STACK_GUARD : StandardPseudoInstruction {
let OutOperandList = (outs ptr_rc:$dst);
let InOperandList = (ins);
let mayLoad = 1;
@@ -1056,7 +1062,7 @@ def LOAD_STACK_GUARD : Instruction {
let hasSideEffects = 0;
bit isPseudo = 1;
}
-def LOCAL_ESCAPE : Instruction {
+def LOCAL_ESCAPE : StandardPseudoInstruction {
// This instruction is really just a label. It has to be part of the chain so
// that it doesn't get dropped from the DAG, but it produces nothing and has
// no side effects.
@@ -1065,7 +1071,7 @@ def LOCAL_ESCAPE : Instruction {
let hasSideEffects = 0;
let hasCtrlDep = 1;
}
-def FAULTING_OP : Instruction {
+def FAULTING_OP : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins variable_ops);
let usesCustomInserter = 1;
@@ -1075,7 +1081,7 @@ def FAULTING_OP : Instruction {
let isTerminator = 1;
let isBranch = 1;
}
-def PATCHABLE_OP : Instruction {
+def PATCHABLE_OP : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins variable_ops);
let usesCustomInserter = 1;
@@ -1083,14 +1089,14 @@ def PATCHABLE_OP : Instruction {
let mayStore = 1;
let hasSideEffects = 1;
}
-def PATCHABLE_FUNCTION_ENTER : Instruction {
+def PATCHABLE_FUNCTION_ENTER : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins);
let AsmString = "# XRay Function Enter.";
let usesCustomInserter = 1;
let hasSideEffects = 0;
}
-def PATCHABLE_RET : Instruction {
+def PATCHABLE_RET : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins variable_ops);
let AsmString = "# XRay Function Patchable RET.";
@@ -1099,7 +1105,7 @@ def PATCHABLE_RET : Instruction {
let isTerminator = 1;
let isReturn = 1;
}
-def PATCHABLE_FUNCTION_EXIT : Instruction {
+def PATCHABLE_FUNCTION_EXIT : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins);
let AsmString = "# XRay Function Exit.";
@@ -1107,7 +1113,7 @@ def PATCHABLE_FUNCTION_EXIT : Instructio
let hasSideEffects = 0; // FIXME: is this correct?
let isReturn = 0; // Original return instruction will follow
}
-def PATCHABLE_TAIL_CALL : Instruction {
+def PATCHABLE_TAIL_CALL : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins variable_ops);
let AsmString = "# XRay Tail Call Exit.";
@@ -1115,7 +1121,7 @@ def PATCHABLE_TAIL_CALL : Instruction {
let hasSideEffects = 1;
let isReturn = 1;
}
-def PATCHABLE_EVENT_CALL : Instruction {
+def PATCHABLE_EVENT_CALL : StandardPseudoInstruction {
let OutOperandList = (outs);
let InOperandList = (ins ptr_rc:$event, i8imm:$size);
let AsmString = "# XRay Custom Event Log.";
@@ -1125,7 +1131,7 @@ def PATCHABLE_EVENT_CALL : Instruction {
let mayStore = 1;
let hasSideEffects = 1;
}
-def FENTRY_CALL : Instruction {
+def FENTRY_CALL : StandardPseudoInstruction {
let OutOperandList = (outs unknown:$dst);
let InOperandList = (ins variable_ops);
let AsmString = "# FEntry call";
@@ -1138,8 +1144,6 @@ def FENTRY_CALL : Instruction {
// Generic opcodes used in GlobalISel.
include "llvm/Target/GenericOpcodes.td"
-}
-
//===----------------------------------------------------------------------===//
// AsmParser - This class can be implemented by targets that wish to implement
// .s file parsing.
More information about the llvm-commits
mailing list