Allow similar TargetOpcodes to use inheritance to factor out commonality. NFC.

[dsanders]

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)

[dsanders]

ping

[qcolombet]

LGTM

include/llvm/Target/GenericOpcodes.td

 // After instruction selection, these opcodes should not appear.
 //
 //===----------------------------------------------------------------------===//
 
 //------------------------------------------------------------------------------
 // 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;
 }
 
 // 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;
 }
 
 // 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;
 }
 
 
 // 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;
   let mayLoad = 1;
   let mayStore = 1;
 }
 
-def G_BSWAP : Instruction {
+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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
 }
 
 //------------------------------------------------------------------------------
 // Overflow ops
 //------------------------------------------------------------------------------
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 //------------------------------------------------------------------------------
 // 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;
 }
 
 //------------------------------------------------------------------------------
 // Floating Point Binary ops.
 //------------------------------------------------------------------------------
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
   let isCommutable = 1;
 }
 
 // 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;
   let isCommutable = 0;
 }
 
 // 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;
 }
 
 //------------------------------------------------------------------------------
 // Memory ops
 //------------------------------------------------------------------------------
 
 // 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 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 hasSideEffects = 0;
   let mayStore = 1;
 }
 
 //------------------------------------------------------------------------------
 // Variadic ops
 //------------------------------------------------------------------------------
 
 // 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;
 }
 
 // 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);
   let InOperandList = (ins variable_ops);
   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;
 }
 
 /// Concatenante 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 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;
   let mayLoad = 1;
   let mayStore = 1;
 }
 
 //------------------------------------------------------------------------------
 // Branches.
 //------------------------------------------------------------------------------
 
 // Generic unconditional branch.
-def G_BR : Instruction {
+def G_BR : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins unknown:$src1);
   let hasSideEffects = 0;
   let isBranch = 1;
   let isTerminator = 1;
   let isBarrier = 1;
 }
 
 // Generic conditional branch.
-def G_BRCOND : Instruction {
+def G_BRCOND : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins type0:$tst, unknown:$truebb);
   let hasSideEffects = 0;
   let isBranch = 1;
   let isTerminator = 1;
 }
 
 // Generic indirect branch.
-def G_BRINDIRECT : Instruction {
+def G_BRINDIRECT : GenericInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins type0:$src1);
   let hasSideEffects = 0;
   let isBranch = 1;
   let isTerminator = 1;
 }
 
 //------------------------------------------------------------------------------
 // Vector ops
 //------------------------------------------------------------------------------
 
 // 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;
 }
 
 // TODO: Add the other generic opcodes.

include/llvm/Target/Target.td

 }
 
 // Standard Pseudo Instructions.
 // This list must match TargetOpcodes.h and CodeGenTarget.cpp.
 // Only these instructions are allowed in the TargetOpcode namespace.
 // 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 = "";
   let hasCtrlDep = 1;
   let hasSideEffects = 0;
   let isNotDuplicable = 1;
 }
-def EH_LABEL : Instruction {
+def EH_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
   let hasCtrlDep = 1;
   let hasSideEffects = 0;
   let isNotDuplicable = 1;
 }
-def GC_LABEL : Instruction {
+def GC_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
   let hasCtrlDep = 1;
   let hasSideEffects = 0;
   let isNotDuplicable = 1;
 }
-def ANNOTATION_LABEL : Instruction {
+def ANNOTATION_LABEL : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins i32imm:$id);
   let AsmString = "";
   let hasCtrlDep = 1;
   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 = "";
   let hasSideEffects = 0;
   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 = "";
   let hasSideEffects = 0;
   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;
   let isCall = 1;
   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);
   let hasSideEffects = 1;
   let isCall = 1;
   let mayLoad = 1;
   let usesCustomInserter = 1;
 }
-def STATEPOINT : Instruction {
+def STATEPOINT : StandardPseudoInstruction {
   let OutOperandList = (outs);
   let InOperandList = (ins variable_ops);
   let usesCustomInserter = 1;
   let mayLoad = 1;
   let mayStore = 1;
   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;
   bit isReMaterializable = 1;
   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.
   let OutOperandList = (outs);
   let InOperandList = (ins ptr_rc:$symbol, i32imm:$id);
   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;
   let hasSideEffects = 1;
   let mayLoad = 1;
   let mayStore = 1;
   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;
   let mayLoad = 1;
   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.";
   let usesCustomInserter = 1;
   let hasSideEffects = 1;
   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.";
   let usesCustomInserter = 1;
   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.";
   let usesCustomInserter = 1;
   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.";
   let usesCustomInserter = 1;
   let isCall = 1;
   let mayLoad = 1;
   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";
   let usesCustomInserter = 1;
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 1;
 }
 
 // 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.
 //
 // Subtargets can have multiple different assembly parsers (e.g. AT&T vs Intel
 // syntax on X86 for example).
 //
 class AsmParser {