From 17ce6cb99d6e2c7adede76c588a730a74ba6ce26 Mon Sep 17 00:00:00 2001
From: Daniel Sanders <daniel_l_sanders@apple.com>
Date: Mon, 4 Dec 2017 21:40:57 +0000
Subject: [PATCH] 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

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@319701 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Target/GenericOpcodes.td | 248 ++++++++++----------------
 include/llvm/Target/Target.td         |  74 ++++----
 2 files changed, 131 insertions(+), 191 deletions(-)

diff --git a/include/llvm/Target/GenericOpcodes.td b/include/llvm/Target/GenericOpcodes.td
index 76e672a37af..3b2e8f2d08b 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,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 : Instruction {
 
 // 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 : Instruction {
 //------------------------------------------------------------------------------
 
 // 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;
diff --git a/include/llvm/Target/Target.td b/include/llvm/Target/Target.td
index 86fa3c03fb5..4b95e2065bc 100644
--- a/include/llvm/Target/Target.td
+++ b/include/llvm/Target/Target.td
@@ -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 : Instruction {
   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.
-- 
2.50.1