test/TableGen/GlobalISelEmitter.td

   1 // RUN: llvm-tblgen -gen-global-isel -I %p/../../include %s | FileCheck %s
   2
   3 include "llvm/Target/Target.td"
   4
   5 //===- Define the necessary boilerplate for our test target. --------------===//
   6
   7 def MyTargetISA : InstrInfo;
   8 def MyTarget : Target { let InstructionSet = MyTargetISA; }
   9
  10 let TargetPrefix = "mytarget" in {
  11 def int_mytarget_nop : Intrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem]>;
  12 }
  13
  14 def R0 : Register<"r0"> { let Namespace = "MyTarget"; }
  15 def GPR32 : RegisterClass<"MyTarget", [i32], 32, (add R0)>;
  16 def GPR32Op : RegisterOperand<GPR32>;
  17 def F0 : Register<"f0"> { let Namespace = "MyTarget"; }
  18 def FPR32 : RegisterClass<"MyTarget", [f32], 32, (add F0)>;
  19
  20 class I<dag OOps, dag IOps, list<dag> Pat>
  21   : Instruction {
  22   let Namespace = "MyTarget";
  23   let OutOperandList = OOps;
  24   let InOperandList = IOps;
  25   let Pattern = Pat;
  26 }
  27
  28 def complex : Operand<i32>, ComplexPattern<i32, 2, "SelectComplexPattern", []> {
  29   let MIOperandInfo = (ops i32imm, i32imm);
  30 }
  31 def gi_complex :
  32     GIComplexOperandMatcher<s32, "selectComplexPattern">,
  33     GIComplexPatternEquiv<complex>;
  34 def complex_rr : Operand<i32>, ComplexPattern<i32, 2, "SelectComplexPatternRR", []> {
  35   let MIOperandInfo = (ops GPR32, GPR32);
  36 }
  37 def gi_complex_rr :
  38     GIComplexOperandMatcher<s32, "selectComplexPatternRR">,
  39     GIComplexPatternEquiv<complex_rr>;
  40
  41 def m1 : OperandWithDefaultOps <i32, (ops (i32 -1))>;
  42 def Z : OperandWithDefaultOps <i32, (ops R0)>;
  43 def m1Z : OperandWithDefaultOps <i32, (ops (i32 -1), R0)>;
  44
  45 def HasA : Predicate<"Subtarget->hasA()">;
  46 def HasB : Predicate<"Subtarget->hasB()">;
  47 def HasC : Predicate<"Subtarget->hasC()"> { let RecomputePerFunction = 1; }
  48
  49 //===- Test the function boilerplate. -------------------------------------===//
  50
  51 // CHECK: const unsigned MAX_SUBTARGET_PREDICATES = 3;
  52 // CHECK: using PredicateBitset = llvm::PredicateBitsetImpl<MAX_SUBTARGET_PREDICATES>;
  53
  54 // CHECK-LABEL: #ifdef GET_GLOBALISEL_TEMPORARIES_DECL
  55 // CHECK-NEXT:    mutable MatcherState State;
  56 // CHECK-NEXT:    typedef ComplexRendererFns(MyTargetInstructionSelector::*ComplexMatcherMemFn)(MachineOperand &) const;
  57 // CHECK-NEXT:    const MatcherInfoTy<PredicateBitset, ComplexMatcherMemFn> MatcherInfo;
  58 // CHECK-NEXT:    static MyTargetInstructionSelector::ComplexMatcherMemFn ComplexPredicateFns[];
  59 // CHECK-NEXT:  #endif // ifdef GET_GLOBALISEL_TEMPORARIES_DECL
  60
  61 // CHECK-LABEL: #ifdef GET_GLOBALISEL_TEMPORARIES_INIT
  62 // CHECK-NEXT:    , State(2),
  63 // CHECK-NEXT:    MatcherInfo({TypeObjects, FeatureBitsets, I64ImmPredicateFns, APIntImmPredicateFns, APFloatImmPredicateFns, ComplexPredicateFns})
  64 // CHECK-NEXT:  #endif // ifdef GET_GLOBALISEL_TEMPORARIES_INIT
  65
  66 // CHECK-LABEL: enum SubtargetFeatureBits : uint8_t {
  67 // CHECK-NEXT:    Feature_HasABit = 0,
  68 // CHECK-NEXT:    Feature_HasBBit = 1,
  69 // CHECK-NEXT:    Feature_HasCBit = 2,
  70 // CHECK-NEXT:  };
  71
  72 // CHECK-LABEL: PredicateBitset MyTargetInstructionSelector::
  73 // CHECK-NEXT:  computeAvailableModuleFeatures(const MyTargetSubtarget *Subtarget) const {
  74 // CHECK-NEXT:    PredicateBitset Features;
  75 // CHECK-NEXT:    if (Subtarget->hasA())
  76 // CHECK-NEXT:      Features[Feature_HasABit] = 1;
  77 // CHECK-NEXT:    if (Subtarget->hasB())
  78 // CHECK-NEXT:      Features[Feature_HasBBit] = 1;
  79 // CHECK-NEXT:    return Features;
  80 // CHECK-NEXT:  }
  81
  82 // CHECK-LABEL: PredicateBitset MyTargetInstructionSelector::
  83 // CHECK-NEXT:  computeAvailableFunctionFeatures(const MyTargetSubtarget *Subtarget, const MachineFunction *MF) const {
  84 // CHECK-NEXT:    PredicateBitset Features;
  85 // CHECK-NEXT:    if (Subtarget->hasC())
  86 // CHECK-NEXT:      Features[Feature_HasCBit] = 1;
  87 // CHECK-NEXT:    return Features;
  88 // CHECK-NEXT:  }
  89
  90 // CHECK-LABEL: // LLT Objects.
  91 // CHECK-NEXT:  enum {
  92 // CHECK-NEXT:    GILLT_s16,
  93 // CHECK-NEXT:    GILLT_s32,
  94 // CHECK-NEXT:  }
  95 // CHECK-NEXT:  const static LLT TypeObjects[] = {
  96 // CHECK-NEXT:    LLT::scalar(16),
  97 // CHECK-NEXT:    LLT::scalar(32),
  98 // CHECK-NEXT:  };
  99
 100 // CHECK-LABEL: // Feature bitsets.
 101 // CHECK-NEXT:  enum {
 102 // CHECK-NEXT:    GIFBS_Invalid,
 103 // CHECK-NEXT:    GIFBS_HasA,
 104 // CHECK-NEXT:    GIFBS_HasA_HasB_HasC,
 105 // CHECK-NEXT:  }
 106 // CHECK-NEXT:  const static PredicateBitset FeatureBitsets[] {
 107 // CHECK-NEXT:    {}, // GIFBS_Invalid
 108 // CHECK-NEXT:    {Feature_HasABit, },
 109 // CHECK-NEXT:    {Feature_HasABit, Feature_HasBBit, Feature_HasCBit, },
 110 // CHECK-NEXT:  };
 111
 112 // CHECK-LABEL: // ComplexPattern predicates.
 113 // CHECK-NEXT:  enum {
 114 // CHECK-NEXT:    GICP_Invalid,
 115 // CHECK-NEXT:    GICP_gi_complex,
 116 // CHECK-NEXT:    GICP_gi_complex_rr,
 117 // CHECK-NEXT:  };
 118
 119 // CHECK-LABEL: // PatFrag predicates.
 120 // CHECK-NEXT:  enum {
 121 // CHECK-NEXT:    GIPFP_I64_Predicate_simm8 = GIPFP_I64_Invalid + 1,
 122 // CHECK-NEXT:  };
 123 // CHECK-NEXT:  static bool Predicate_simm8(int64_t Imm) { return isInt<8>(Imm);   }
 124 // CHECK-NEXT:  static InstructionSelector::I64ImmediatePredicateFn I64ImmPredicateFns[] = {
 125 // CHECK-NEXT:    nullptr,
 126 // CHECK-NEXT:    Predicate_simm8,
 127 // CHECK-NEXT:  };
 128
 129 // CHECK-LABEL: // PatFrag predicates.
 130 // CHECK-NEXT:  enum {
 131 // CHECK-NEXT:    GIPFP_APFloat_Predicate_fpimmz = GIPFP_APFloat_Invalid + 1,
 132 // CHECK-NEXT:  };
 133 // CHECK-NEXT:  static bool Predicate_fpimmz(const APFloat & Imm) { return Imm->isExactlyValue(0.0); }
 134 // CHECK-NEXT:  static InstructionSelector::APFloatImmediatePredicateFn APFloatImmPredicateFns[] = {
 135 // CHECK-NEXT:    nullptr,
 136 // CHECK-NEXT:    Predicate_fpimmz,
 137 // CHECK-NEXT:  };
 138
 139 // CHECK-LABEL: // PatFrag predicates.
 140 // CHECK-NEXT:  enum {
 141 // CHECK-NEXT:    GIPFP_APInt_Predicate_simm9 = GIPFP_APInt_Invalid + 1,
 142 // CHECK-NEXT:  };
 143 // CHECK-NEXT:  static bool Predicate_simm9(const APInt & Imm) { return isInt<9>(Imm->getSExtValue());   }
 144 // CHECK-NEXT:  static InstructionSelector::APIntImmediatePredicateFn APIntImmPredicateFns[] = {
 145 // CHECK-NEXT:    nullptr,
 146 // CHECK-NEXT:    Predicate_simm9,
 147 // CHECK-NEXT:  };
 148
 149 // CHECK-LABEL: MyTargetInstructionSelector::ComplexMatcherMemFn
 150 // CHECK-NEXT:  MyTargetInstructionSelector::ComplexPredicateFns[] = {
 151 // CHECK-NEXT:    nullptr, // GICP_Invalid
 152 // CHECK-NEXT:    &MyTargetInstructionSelector::selectComplexPattern, // gi_complex
 153 // CHECK-NEXT:    &MyTargetInstructionSelector::selectComplexPatternRR, // gi_complex_rr
 154 // CHECK-NEXT:  }
 155
 156 // CHECK: bool MyTargetInstructionSelector::selectImpl(MachineInstr &I) const {
 157 // CHECK-NEXT: MachineFunction &MF = *I.getParent()->getParent();
 158 // CHECK-NEXT: MachineRegisterInfo &MRI = MF.getRegInfo();
 159 // CHECK:      AvailableFunctionFeatures = computeAvailableFunctionFeatures(&STI, &MF);
 160 // CHECK-NEXT: const PredicateBitset AvailableFeatures = getAvailableFeatures();
 161 // CHECK-NEXT: NewMIVector OutMIs;
 162 // CHECK-NEXT: State.MIs.clear();
 163 // CHECK-NEXT: State.MIs.push_back(&I);
 164
 165 //===- Test a pattern with multiple ComplexPatterns in multiple instrs ----===//
 166 //
 167
 168 // CHECK-LABEL: MatchTable0[] = {
 169 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 0*/ [[LABEL:[0-9]+]],
 170 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/4,
 171 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_SELECT,
 172 // CHECK-NEXT:    // MIs[0] dst
 173 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 174 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 175 // CHECK-NEXT:    // MIs[0] src1
 176 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 177 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 178 // CHECK-NEXT:    // MIs[0] src2
 179 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 180 // CHECK-NEXT:    GIM_CheckComplexPattern, /*MI*/0, /*Op*/2, /*Renderer*/0, GICP_gi_complex,
 181 // CHECK-NEXT:    // MIs[0] src3
 182 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/3, /*Type*/GILLT_s32,
 183 // CHECK-NEXT:    GIM_CheckComplexPattern, /*MI*/0, /*Op*/3, /*Renderer*/1, GICP_gi_complex,
 184 // CHECK-NEXT:    // (select:{ *:[i32] } GPR32:{ *:[i32] }:$src1, complex:{ *:[i32] }:$src2, complex:{ *:[i32] }:$src3) => (INSN2:{ *:[i32] } GPR32:{ *:[i32] }:$src1, complex:{ *:[i32] }:$src3, complex:{ *:[i32] }:$src2)
 185 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::INSN2,
 186 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 187 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 188 // CHECK-NEXT:    GIR_ComplexRenderer, /*InsnID*/0, /*RendererID*/1,
 189 // CHECK-NEXT:    GIR_ComplexRenderer, /*InsnID*/0, /*RendererID*/0,
 190 // CHECK-NEXT:    GIR_MergeMemOperands, /*InsnID*/0, /*MergeInsnID's*/0, GIU_MergeMemOperands_EndOfList,
 191 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 192 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 193 // CHECK-NEXT:    GIR_Done,
 194 // CHECK-NEXT:  // Label 0: @[[LABEL]]
 195
 196 def INSN3 : I<(outs GPR32:$dst),
 197               (ins GPR32Op:$src1, GPR32:$src2a, GPR32:$src2b, GPR32:$scr), []>;
 198 def INSN4 : I<(outs GPR32:$scr),
 199               (ins GPR32:$src3, complex:$src4, i32imm:$src5a, i32imm:$src5b), []>;
 200 def : Pat<(select GPR32:$src1, (complex_rr GPR32:$src2a, GPR32:$src2b),
 201                                (select GPR32:$src3,
 202                                        complex:$src4,
 203                                        (complex i32imm:$src5a, i32imm:$src5b))),
 204           (INSN3 GPR32:$src1, GPR32:$src2b, GPR32:$src2a,
 205                  (INSN4 GPR32:$src3, complex:$src4, i32imm:$src5a,
 206                         i32imm:$src5b))>;
 207
 208 //===- Test a pattern with multiple ComplexPattern operands. --------------===//
 209 //
 210
 211 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 1*/ [[LABEL:[0-9]+]],
 212 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/4,
 213 // CHECK-NEXT:    GIM_RecordInsn, /*DefineMI*/1, /*MI*/0, /*OpIdx*/3, // MIs[1]
 214 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/1, /*Expected*/4,
 215 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_SELECT,
 216 // CHECK-NEXT:    // MIs[0] dst
 217 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 218 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 219 // CHECK-NEXT:    // MIs[0] src1
 220 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 221 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 222 // CHECK-NEXT:    // MIs[0] Operand 2
 223 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 224 // CHECK-NEXT:    GIM_CheckComplexPattern, /*MI*/0, /*Op*/2, /*Renderer*/0, GICP_gi_complex_rr,
 225 // CHECK-NEXT:    // MIs[0] Operand 3
 226 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/3, /*Type*/GILLT_s32,
 227 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/1, TargetOpcode::G_SELECT,
 228 // CHECK-NEXT:    // MIs[1] Operand 0
 229 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/0, /*Type*/GILLT_s32,
 230 // CHECK-NEXT:    // MIs[1] src3
 231 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/1, /*Type*/GILLT_s32,
 232 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 233 // CHECK-NEXT:    // MIs[1] src4
 234 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/2, /*Type*/GILLT_s32,
 235 // CHECK-NEXT:    GIM_CheckComplexPattern, /*MI*/1, /*Op*/2, /*Renderer*/1, GICP_gi_complex,
 236 // CHECK-NEXT:    // MIs[1] Operand 3
 237 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/3, /*Type*/GILLT_s32,
 238 // CHECK-NEXT:    GIM_CheckComplexPattern, /*MI*/1, /*Op*/3, /*Renderer*/2, GICP_gi_complex,
 239 // CHECK-NEXT:    GIM_CheckIsSafeToFold, /*InsnID*/1,
 240 // CHECK-NEXT:    // (select:{ *:[i32] } GPR32:{ *:[i32] }:$src1, (complex_rr:{ *:[i32] } GPR32:{ *:[i32] }:$src2a, GPR32:{ *:[i32] }:$src2b), (select:{ *:[i32] } GPR32:{ *:[i32] }:$src3, complex:{ *:[i32] }:$src4, (complex:{ *:[i32] } i32imm:{ *:[i32] }:$src5a, i32imm:{ *:[i32] }:$src5b)))  =>  (INSN3:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2b, GPR32:{ *:[i32] }:$src2a, (INSN4:{ *:[i32] } GPR32:{ *:[i32] }:$src3, complex:{ *:[i32] }:$src4, i32imm:{ *:[i32] }:$src5a, i32imm:{ *:[i32] }:$src5b))
 241 // CHECK-NEXT:    GIR_MakeTempReg, /*TempRegID*/0, /*TypeID*/GILLT_s32,
 242 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/1, /*Opcode*/MyTarget::INSN4,
 243 // CHECK-NEXT:    GIR_AddTempRegister, /*InsnID*/1, /*TempRegID*/0, /*TempRegFlags*/RegState::Define,
 244 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/1, /*OldInsnID*/1, /*OpIdx*/1, // src3
 245 // CHECK-NEXT:    GIR_ComplexRenderer, /*InsnID*/1, /*RendererID*/1,
 246 // CHECK-NEXT:    GIR_ComplexSubOperandRenderer, /*InsnID*/1, /*RendererID*/2, /*SubOperand*/0, // src5a
 247 // CHECK-NEXT:    GIR_ComplexSubOperandRenderer, /*InsnID*/1, /*RendererID*/2, /*SubOperand*/1, // src5b
 248 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::INSN3,
 249 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 250 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 251 // CHECK-NEXT:    GIR_ComplexSubOperandRenderer, /*InsnID*/0, /*RendererID*/0, /*SubOperand*/1, // src2b
 252 // CHECK-NEXT:    GIR_ComplexSubOperandRenderer, /*InsnID*/0, /*RendererID*/0, /*SubOperand*/0, // src2a
 253 // CHECK-NEXT:    GIR_AddTempRegister, /*InsnID*/0, /*TempRegID*/0, /*TempRegFlags*/0,
 254 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 255 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 256 // CHECK-NEXT:    GIR_Done,
 257 // CHECK-NEXT:  // Label 1: @[[LABEL]]
 258
 259 def : GINodeEquiv<G_SELECT, select>;
 260 let mayLoad = 1 in {
 261   def INSN2 : I<(outs GPR32:$dst), (ins GPR32Op:$src1, complex:$src2, complex:$src3), []>;
 262 }
 263 def : Pat<(select GPR32:$src1, complex:$src2, complex:$src3),
 264           (INSN2 GPR32:$src1, complex:$src3, complex:$src2)>;
 265
 266 //===- Test a simple pattern with regclass operands. ----------------------===//
 267
 268 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 2*/ [[LABEL:[0-9]+]],
 269 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 270 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_ADD,
 271 // CHECK-NEXT:    // MIs[0] dst
 272 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 273 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 274 // CHECK-NEXT:    // MIs[0] src1
 275 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 276 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID
 277 // CHECK-NEXT:    // MIs[0] src2
 278 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 279 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 280 // CHECK-NEXT:    // (add:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2) => (ADD:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2)
 281 // CHECK-NEXT:    GIR_MutateOpcode, /*InsnID*/0, /*RecycleInsnID*/0, /*Opcode*/MyTarget::ADD,
 282 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 283 // CHECK-NEXT:    GIR_Done,
 284 // CHECK-NEXT:  // Label 2: @[[LABEL]]
 285
 286 def ADD : I<(outs GPR32:$dst), (ins GPR32:$src1, GPR32:$src2),
 287             [(set GPR32:$dst, (add GPR32:$src1, GPR32:$src2))]>;
 288
 289 //===- Test a pattern with a tied operand in the matcher ------------------===//
 290
 291 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 3*/ [[LABEL:[0-9]+]],
 292 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 293 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_ADD,
 294 // CHECK-NEXT:    // MIs[0] dst
 295 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 296 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 297 // CHECK-NEXT:    // MIs[0] src{{$}}
 298 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 299 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 300 // CHECK-NEXT:    // MIs[0] src{{$}}
 301 // CHECK-NEXT:    GIM_CheckIsSameOperand, /*MI*/0, /*OpIdx*/2, /*OtherMI*/0, /*OtherOpIdx*/1,
 302 // CHECK-NEXT:    // (add:{ *:[i32] } GPR32:{ *:[i32] }:$src, GPR32:{ *:[i32] }:$src) => (DOUBLE:{ *:[i32] } GPR32:{ *:[i32] }:$src)
 303 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::DOUBLE,
 304 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 305 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src
 306 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 307 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 308 // CHECK-NEXT:    GIR_Done,
 309 // CHECK-NEXT:  // Label 3: @[[LABEL]]
 310
 311 def DOUBLE : I<(outs GPR32:$dst), (ins GPR32:$src), [(set GPR32:$dst, (add GPR32:$src, GPR32:$src))]>;
 312
 313 //===- Test a simple pattern with ValueType operands. ----------------------===//
 314
 315 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 4*/ [[LABEL:[0-9]+]],
 316 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 317 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_ADD,
 318 // CHECK-NEXT:    // MIs[0] dst
 319 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 320 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 321 // CHECK-NEXT:    // MIs[0] src1
 322 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 323 // CHECK-NEXT:    // MIs[0] src2
 324 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 325 // CHECK-NEXT:    // (add:{ *:[i32] } i32:{ *:[i32] }:$src1, i32:{ *:[i32] }:$src2) => (ADD:{ *:[i32] } i32:{ *:[i32] }:$src1, i32:{ *:[i32] }:$src2)
 326 // CHECK-NEXT:    GIR_MutateOpcode, /*InsnID*/0, /*RecycleInsnID*/0, /*Opcode*/MyTarget::ADD,
 327 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 328 // CHECK-NEXT:    GIR_Done,
 329 // CHECK-NEXT:  // Label 4: @[[LABEL]]
 330
 331 def : Pat<(add i32:$src1, i32:$src2),
 332           (ADD i32:$src1, i32:$src2)>;
 333
 334 //===- Test a simple pattern with an intrinsic. ---------------------------===//
 335 //
 336
 337 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 5*/ [[LABEL:[0-9]+]],
 338 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 339 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_INTRINSIC,
 340 // CHECK-NEXT:    // MIs[0] dst
 341 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 342 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 343 // CHECK-NEXT:    // MIs[0] Operand 1
 344 // CHECK-NEXT:    GIM_CheckIntrinsicID, /*MI*/0, /*Op*/1, Intrinsic::mytarget_nop,
 345 // CHECK-NEXT:    // MIs[0] src1
 346 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 347 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 348 // CHECK-NEXT:    // (intrinsic_wo_chain:{ *:[i32] } [[ID:[0-9]+]]:{ *:[iPTR] }, GPR32:{ *:[i32] }:$src1) => (MOV:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 349
 350 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MOV,
 351 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 352 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/2, // src1
 353 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 354 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 355 // CHECK-NEXT:    GIR_Done,
 356 // CHECK-NEXT:  // Label 5: @[[LABEL]]
 357
 358 def MOV : I<(outs GPR32:$dst), (ins GPR32:$src1),
 359             [(set GPR32:$dst, (int_mytarget_nop GPR32:$src1))]>;
 360
 361 //===- Test a nested instruction match. -----------------------------------===//
 362
 363 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 6*/ [[LABEL:[0-9]+]],
 364 // CHECK-NEXT:    GIM_CheckFeatures, GIFBS_HasA,
 365 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 366 // CHECK-NEXT:    GIM_RecordInsn, /*DefineMI*/1, /*MI*/0, /*OpIdx*/1, // MIs[1]
 367 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/1, /*Expected*/3,
 368 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_MUL,
 369 // CHECK-NEXT:    // MIs[0] dst
 370 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 371 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 372 // CHECK-NEXT:    // MIs[0] Operand 1
 373 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 374 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/1, TargetOpcode::G_ADD,
 375 // CHECK-NEXT:    // MIs[1] Operand 0
 376 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/0, /*Type*/GILLT_s32,
 377 // CHECK-NEXT:    // MIs[1] src1
 378 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/1, /*Type*/GILLT_s32,
 379 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 380 // CHECK-NEXT:    // MIs[1] src2
 381 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/2, /*Type*/GILLT_s32,
 382 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 383 // CHECK-NEXT:    // MIs[0] src3
 384 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 385 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 386 // CHECK-NEXT:    GIM_CheckIsSafeToFold, /*InsnID*/1,
 387 // CHECK-NEXT:    // (mul:{ *:[i32] } (add:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2), GPR32:{ *:[i32] }:$src3)  =>  (MULADD:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2, GPR32:{ *:[i32] }:$src3)
 388 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MULADD,
 389 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 390 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/1, // src1
 391 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/2, // src2
 392 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/2, // src3
 393 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 394 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 395 // CHECK-NEXT:    GIR_Done,
 396 // CHECK-NEXT:  // Label 6: @[[LABEL]]
 397
 398 // We also get a second rule by commutativity.
 399 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 7*/ [[LABEL:[0-9]+]],
 400 // CHECK-NEXT:    GIM_CheckFeatures, GIFBS_HasA,
 401 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 402 // CHECK-NEXT:    GIM_RecordInsn, /*DefineMI*/1, /*MI*/0, /*OpIdx*/2,
 403 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/1, /*Expected*/3,
 404 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_MUL,
 405 // CHECK-NEXT:    // MIs[0] dst
 406 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 407 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 408 // CHECK-NEXT:    // MIs[0] src3
 409 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 410 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 411 // CHECK-NEXT:    // MIs[0] Operand 2
 412 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 413 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/1, TargetOpcode::G_ADD,
 414 // CHECK-NEXT:    // MIs[1] Operand 0
 415 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/0, /*Type*/GILLT_s32,
 416 // CHECK-NEXT:    // MIs[1] src1
 417 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/1, /*Type*/GILLT_s32,
 418 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 419 // CHECK-NEXT:    // MIs[1] src2
 420 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/2, /*Type*/GILLT_s32,
 421 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 422 // CHECK-NEXT:    GIM_CheckIsSafeToFold, /*InsnID*/1,
 423 // CHECK-NEXT:    // (mul:{ *:[i32] } GPR32:{ *:[i32] }:$src3, (add:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2))  =>  (MULADD:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2, GPR32:{ *:[i32] }:$src3)
 424 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MULADD,
 425 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 426 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/1, // src1
 427 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/2, // src2
 428 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src3
 429 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 430 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 431 // CHECK-NEXT:    GIR_Done,
 432 // CHECK-NEXT:  // Label 7: @[[LABEL]]
 433
 434 def MULADD : I<(outs GPR32:$dst), (ins GPR32:$src1, GPR32:$src2, GPR32:$src3),
 435                [(set GPR32:$dst,
 436                      (mul (add GPR32:$src1, GPR32:$src2), GPR32:$src3))]>,
 437              Requires<[HasA]>;
 438
 439 //===- Test another simple pattern with regclass operands. ----------------===//
 440
 441 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 8*/ [[LABEL:[0-9]+]],
 442 // CHECK-NEXT:    GIM_CheckFeatures, GIFBS_HasA_HasB_HasC,
 443 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 444 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_MUL,
 445 // CHECK-NEXT:    // MIs[0] dst
 446 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 447 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 448 // CHECK-NEXT:    // MIs[0] src1
 449 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 450 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 451 // CHECK-NEXT:    // MIs[0] src2
 452 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 453 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 454 // CHECK-NEXT:    // (mul:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2) => (MUL:{ *:[i32] } GPR32:{ *:[i32] }:$src2, GPR32:{ *:[i32] }:$src1)
 455 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MUL,
 456 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 457 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/2, // src2
 458 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 459 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 460 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 461 // CHECK-NEXT:    GIR_Done,
 462 // CHECK-NEXT:  // Label 8: @[[LABEL]]
 463
 464 def MUL : I<(outs GPR32:$dst), (ins GPR32:$src2, GPR32:$src1),
 465              [(set GPR32:$dst, (mul GPR32:$src1, GPR32:$src2))]>,
 466           Requires<[HasA, HasB, HasC]>;
 467
 468 //===- Test a more complex multi-instruction match. -----------------------===//
 469
 470 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 9*/ [[LABEL:[0-9]+]],
 471 // CHECK-NEXT:    GIM_CheckFeatures, GIFBS_HasA,
 472 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 473 // CHECK-NEXT:    GIM_RecordInsn, /*DefineMI*/1, /*MI*/0, /*OpIdx*/1, // MIs[1]
 474 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/1, /*Expected*/3,
 475 // CHECK-NEXT:    GIM_RecordInsn, /*DefineMI*/2, /*MI*/0, /*OpIdx*/2, // MIs[2]
 476 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/2, /*Expected*/3,
 477 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_SUB,
 478 // CHECK-NEXT:    // MIs[0] dst
 479 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 480 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 481 // CHECK-NEXT:    // MIs[0] Operand 1
 482 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 483 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/1, TargetOpcode::G_SUB,
 484 // CHECK-NEXT:    // MIs[1] Operand 0
 485 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/0, /*Type*/GILLT_s32,
 486 // CHECK-NEXT:    // MIs[1] src1
 487 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/1, /*Type*/GILLT_s32,
 488 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 489 // CHECK-NEXT:    // MIs[1] src2
 490 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/2, /*Type*/GILLT_s32,
 491 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 492 // CHECK-NEXT:    // MIs[0] Operand 2
 493 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 494 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/2, TargetOpcode::G_SUB,
 495 // CHECK-NEXT:    // MIs[2] Operand 0
 496 // CHECK-NEXT:    GIM_CheckType, /*MI*/2, /*Op*/0, /*Type*/GILLT_s32,
 497 // CHECK-NEXT:    // MIs[2] src3
 498 // CHECK-NEXT:    GIM_CheckType, /*MI*/2, /*Op*/1, /*Type*/GILLT_s32,
 499 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/2, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 500 // CHECK-NEXT:    // MIs[2] src4
 501 // CHECK-NEXT:    GIM_CheckType, /*MI*/2, /*Op*/2, /*Type*/GILLT_s32,
 502 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/2, /*Op*/2, /*RC*/MyTarget::GPR32RegClassID,
 503 // CHECK-NEXT:    GIM_CheckIsSafeToFold, /*InsnID*/1,
 504 // CHECK-NEXT:    GIM_CheckIsSafeToFold, /*InsnID*/2,
 505 // CHECK-NEXT:    // (sub:{ *:[i32] } (sub:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2), (sub:{ *:[i32] } GPR32:{ *:[i32] }:$src3, GPR32:{ *:[i32] }:$src4)) => (INSNBOB:{ *:[i32] } GPR32:{ *:[i32] }:$src1, GPR32:{ *:[i32] }:$src2, GPR32:{ *:[i32] }:$src3, GPR32:{ *:[i32] }:$src4)
 506 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::INSNBOB,
 507 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 508 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/1, // src1
 509 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/2, // src2
 510 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/2, /*OpIdx*/1, // src3
 511 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/2, /*OpIdx*/2, // src4
 512 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 513 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 514 // CHECK-NEXT:    GIR_Done,
 515 // CHECK-NEXT:  // Label 9: @[[LABEL]]
 516
 517 def INSNBOB : I<(outs GPR32:$dst), (ins GPR32:$src1, GPR32:$src2, GPR32:$src3, GPR32:$src4),
 518                  [(set GPR32:$dst,
 519                       (sub (sub GPR32:$src1, GPR32:$src2), (sub GPR32:$src3, GPR32:$src4)))]>,
 520                Requires<[HasA]>;
 521
 522 //===- Test a pattern with ComplexPattern operands. -----------------------===//
 523 //
 524
 525 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 10*/ [[LABEL:[0-9]+]],
 526 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 527 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_SUB,
 528 // CHECK-NEXT:    // MIs[0] dst
 529 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 530 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 531 // CHECK-NEXT:    // MIs[0] src1
 532 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 533 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 534 // CHECK-NEXT:    // MIs[0] src2
 535 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 536 // CHECK-NEXT:    GIM_CheckComplexPattern, /*MI*/0, /*Op*/2, /*Renderer*/0, GICP_gi_complex,
 537 // CHECK-NEXT:    // (sub:{ *:[i32] } GPR32:{ *:[i32] }:$src1, complex:{ *:[i32] }:$src2) => (INSN1:{ *:[i32] } GPR32:{ *:[i32] }:$src1, complex:{ *:[i32] }:$src2)
 538 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::INSN1,
 539 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 540 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 541 // CHECK-NEXT:    GIR_ComplexRenderer, /*InsnID*/0, /*RendererID*/0,
 542 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 543 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 544 // CHECK-NEXT:    GIR_Done,
 545 // CHECK-NEXT:  // Label 10: @[[LABEL]]
 546
 547 def INSN1 : I<(outs GPR32:$dst), (ins GPR32:$src1, complex:$src2), []>;
 548 def : Pat<(sub GPR32:$src1, complex:$src2), (INSN1 GPR32:$src1, complex:$src2)>;
 549
 550 //===- Test a simple pattern with a default operand. ----------------------===//
 551 //
 552
 553 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 11*/ [[LABEL:[0-9]+]],
 554 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 555 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_XOR,
 556 // CHECK-NEXT:    // MIs[0] dst
 557 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 558 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 559 // CHECK-NEXT:    // MIs[0] src1
 560 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 561 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 562 // CHECK-NEXT:    // MIs[0] Operand 2
 563 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 564 // CHECK-NEXT:    GIM_CheckConstantInt, /*MI*/0, /*Op*/2, -2
 565 // CHECK-NEXT:    // (xor:{ *:[i32] } GPR32:{ *:[i32] }:$src1, -2:{ *:[i32] }) => (XORI:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 566 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::XORI,
 567 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 568 // CHECK-NEXT:    GIR_AddImm, /*InsnID*/0, /*Imm*/-1,
 569 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 570 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 571 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 572 // CHECK-NEXT:    GIR_Done,
 573 // CHECK-NEXT:  // Label 11: @[[LABEL]]
 574
 575 // The -2 is just to distinguish it from the 'not' case below.
 576 def XORI : I<(outs GPR32:$dst), (ins m1:$src2, GPR32:$src1),
 577              [(set GPR32:$dst, (xor GPR32:$src1, -2))]>;
 578
 579 //===- Test a simple pattern with a default register operand. -------------===//
 580 //
 581
 582 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 12*/ [[LABEL:[0-9]+]],
 583 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 584 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_XOR,
 585 // CHECK-NEXT:    // MIs[0] dst
 586 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 587 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 588 // CHECK-NEXT:    // MIs[0] src1
 589 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 590 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 591 // CHECK-NEXT:    // MIs[0] Operand 2
 592 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 593 // CHECK-NEXT:    GIM_CheckConstantInt, /*MI*/0, /*Op*/2, -3
 594 // CHECK-NEXT:    // (xor:{ *:[i32] } GPR32:{ *:[i32] }:$src1, -3:{ *:[i32] }) => (XOR:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 595 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::XOR,
 596 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 597 // CHECK-NEXT:    GIR_AddRegister, /*InsnID*/0, MyTarget::R0,
 598 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 599 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 600 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 601 // CHECK-NEXT:    GIR_Done,
 602 // CHECK-NEXT:  // Label 12: @[[LABEL]]
 603
 604 // The -3 is just to distinguish it from the 'not' case below and the other default op case above.
 605 def XOR : I<(outs GPR32:$dst), (ins Z:$src2, GPR32:$src1),
 606             [(set GPR32:$dst, (xor GPR32:$src1, -3))]>;
 607
 608 //===- Test a simple pattern with a multiple default operands. ------------===//
 609 //
 610
 611 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 13*/ [[LABEL:[0-9]+]],
 612 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 613 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_XOR,
 614 // CHECK-NEXT:    // MIs[0] dst
 615 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 616 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 617 // CHECK-NEXT:    // MIs[0] src1
 618 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 619 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 620 // CHECK-NEXT:    // MIs[0] Operand 2
 621 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 622 // CHECK-NEXT:    GIM_CheckConstantInt, /*MI*/0, /*Op*/2, -4
 623 // CHECK-NEXT:    // (xor:{ *:[i32] } GPR32:{ *:[i32] }:$src1, -4:{ *:[i32] }) => (XORlike:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 624 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::XORlike,
 625 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 626 // CHECK-NEXT:    GIR_AddImm, /*InsnID*/0, /*Imm*/-1,
 627 // CHECK-NEXT:    GIR_AddRegister, /*InsnID*/0, MyTarget::R0,
 628 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 629 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 630 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 631 // CHECK-NEXT:    GIR_Done,
 632 // CHECK-NEXT:  // Label 13: @[[LABEL]]
 633
 634 // The -4 is just to distinguish it from the other 'not' cases.
 635 def XORlike : I<(outs GPR32:$dst), (ins m1Z:$src2, GPR32:$src1),
 636                 [(set GPR32:$dst, (xor GPR32:$src1, -4))]>;
 637
 638 //===- Test a simple pattern with multiple operands with defaults. --------===//
 639 //
 640
 641 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 14*/ [[LABEL:[0-9]+]],
 642 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 643 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_XOR,
 644 // CHECK-NEXT:    // MIs[0] dst
 645 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 646 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 647 // CHECK-NEXT:    // MIs[0] src1
 648 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 649 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 650 // CHECK-NEXT:    // MIs[0] Operand 2
 651 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 652 // CHECK-NEXT:    GIM_CheckConstantInt, /*MI*/0, /*Op*/2, -5,
 653 // CHECK-NEXT:    // (xor:{ *:[i32] } GPR32:{ *:[i32] }:$src1, -5:{ *:[i32] }) => (XORManyDefaults:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 654 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::XORManyDefaults,
 655 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 656 // CHECK-NEXT:    GIR_AddImm, /*InsnID*/0, /*Imm*/-1,
 657 // CHECK-NEXT:    GIR_AddRegister, /*InsnID*/0, MyTarget::R0,
 658 // CHECK-NEXT:    GIR_AddRegister, /*InsnID*/0, MyTarget::R0,
 659 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // src1
 660 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 661 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 662 // CHECK-NEXT:    GIR_Done,
 663 // CHECK-NEXT:  // Label 14: @[[LABEL]]
 664
 665 // The -5 is just to distinguish it from the other cases.
 666 def XORManyDefaults : I<(outs GPR32:$dst), (ins m1Z:$src3, Z:$src2, GPR32:$src1),
 667                         [(set GPR32:$dst, (xor GPR32:$src1, -5))]>;
 668
 669 //===- Test a simple pattern with constant immediate operands. ------------===//
 670 //
 671 // This must precede the 3-register variants because constant immediates have
 672 // priority over register banks.
 673
 674 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 15*/ [[LABEL:[0-9]+]],
 675 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/3,
 676 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_XOR,
 677 // CHECK-NEXT:    // MIs[0] dst
 678 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 679 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 680 // CHECK-NEXT:    // MIs[0] Wm
 681 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 682 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 683 // CHECK-NEXT:    // MIs[0] Operand 2
 684 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/2, /*Type*/GILLT_s32,
 685 // CHECK-NEXT:    GIM_CheckConstantInt, /*MI*/0, /*Op*/2, -1,
 686 // CHECK-NEXT:    // (xor:{ *:[i32] } GPR32:{ *:[i32] }:$Wm, -1:{ *:[i32] }) => (ORN:{ *:[i32] } R0:{ *:[i32] }, GPR32:{ *:[i32] }:$Wm)
 687 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::ORN,
 688 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 689 // CHECK-NEXT:    GIR_AddRegister, /*InsnID*/0, MyTarget::R0,
 690 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/1, // Wm
 691 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 692 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 693 // CHECK-NEXT:    GIR_Done,
 694 // CHECK-NEXT:  // Label 15: @[[LABEL]]
 695
 696 def ORN : I<(outs GPR32:$dst), (ins GPR32:$src1, GPR32:$src2), []>;
 697 def : Pat<(not GPR32:$Wm), (ORN R0, GPR32:$Wm)>;
 698
 699 //===- Test a COPY_TO_REGCLASS --------------------------------------------===//
 700 //
 701
 702 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 16*/ [[LABEL:[0-9]+]],
 703 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 704 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_BITCAST,
 705 // CHECK-NEXT:    // MIs[0] dst
 706 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 707 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 708 // CHECK-NEXT:    // MIs[0] src1
 709 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s32,
 710 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::FPR32RegClassID,
 711 // CHECK-NEXT:    // (bitconvert:{ *:[i32] } FPR32:{ *:[f32] }:$src1) => (COPY_TO_REGCLASS:{ *:[i32] } FPR32:{ *:[f32] }:$src1, GPR32:{ *:[i32] })
 712 // CHECK-NEXT:    GIR_MutateOpcode, /*InsnID*/0, /*RecycleInsnID*/0, /*Opcode*/TargetOpcode::COPY,
 713 // CHECK-NEXT:    GIR_ConstrainOperandRC, /*InsnID*/0, /*Op*/0, /*RC GPR32*/1,
 714 // CHECK-NEXT:    GIR_Done,
 715 // CHECK-NEXT:  // Label 16: @[[LABEL]]
 716
 717 def : Pat<(i32 (bitconvert FPR32:$src1)),
 718           (COPY_TO_REGCLASS FPR32:$src1, GPR32)>;
 719
 720 //===- Test a simple pattern with just a specific leaf immediate. ---------===//
 721
 722 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 17*/ [[LABEL:[0-9]+]],
 723 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 724 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_CONSTANT,
 725 // CHECK-NEXT:    // MIs[0] dst
 726 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 727 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 728 // CHECK-NEXT:    // MIs[0] Operand 1
 729 // CHECK-NEXT:    GIM_CheckLiteralInt, /*MI*/0, /*Op*/1, 1,
 730 // CHECK-NEXT:    // 1:{ *:[i32] }  =>  (MOV1:{ *:[i32] })
 731 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MOV1,
 732 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 733 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 734 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 735 // CHECK-NEXT:    GIR_Done,
 736 // CHECK-NEXT:  // Label 17: @[[LABEL]]
 737
 738 def MOV1 : I<(outs GPR32:$dst), (ins), [(set GPR32:$dst, 1)]>;
 739
 740 //===- Test a simple pattern with a leaf immediate and a predicate. -------===//
 741
 742 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 18*/ [[LABEL:[0-9]+]],
 743 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 744 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_CONSTANT,
 745 // CHECK-NEXT:    GIM_CheckI64ImmPredicate, /*MI*/0, /*Predicate*/GIPFP_I64_Predicate_simm8,
 746 // CHECK-NEXT:    // MIs[0] dst
 747 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 748 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 749 // CHECK-NEXT:    // MIs[0] Operand 1
 750 // CHECK-NEXT:    // No operand predicates
 751 // CHECK-NEXT:    // (imm:{ *:[i32] })<<P:Predicate_simm8>>:$imm => (MOVimm8:{ *:[i32] } (imm:{ *:[i32] }):$imm)
 752 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MOVimm8,
 753 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 754 // CHECK-NEXT:    GIR_CopyConstantAsSImm, /*NewInsnID*/0, /*OldInsnID*/0, // imm
 755 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 756 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 757 // CHECK-NEXT:    GIR_Done,
 758 // CHECK-NEXT:  // Label 18: @[[LABEL]]
 759
 760 def simm8 : ImmLeaf<i32, [{ return isInt<8>(Imm); }]>;
 761 def MOVimm8 : I<(outs GPR32:$dst), (ins i32imm:$imm), [(set GPR32:$dst, simm8:$imm)]>;
 762
 763 //===- Same again but use an IntImmLeaf. ----------------------------------===//
 764
 765 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 19*/ [[LABEL:[0-9]+]],
 766 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 767 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_CONSTANT,
 768 // CHECK-NEXT:    GIM_CheckAPIntImmPredicate, /*MI*/0, /*Predicate*/GIPFP_APInt_Predicate_simm9,
 769 // CHECK-NEXT:    // MIs[0] dst
 770 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 771 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 772 // CHECK-NEXT:    // MIs[0] Operand 1
 773 // CHECK-NEXT:    // No operand predicates
 774 // CHECK-NEXT:    // (imm:{ *:[i32] })<<P:Predicate_simm9>>:$imm =>  (MOVimm9:{ *:[i32] } (imm:{ *:[i32] }):$imm)
 775 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MOVimm9,
 776 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 777 // CHECK-NEXT:    GIR_CopyConstantAsSImm, /*NewInsnID*/0, /*OldInsnID*/0, // imm
 778 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 779 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 780 // CHECK-NEXT:    GIR_Done,
 781 // CHECK-NEXT:  // Label 19: @[[LABEL]]
 782
 783 def simm9 : IntImmLeaf<i32, [{ return isInt<9>(Imm->getSExtValue()); }]>;
 784 def MOVimm9 : I<(outs GPR32:$dst), (ins i32imm:$imm), [(set GPR32:$dst, simm9:$imm)]>;
 785
 786 //===- Test a simple pattern with just a leaf immediate. ------------------===//
 787
 788 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 20*/ [[LABEL:[0-9]+]],
 789 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 790 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_CONSTANT,
 791 // CHECK-NEXT:    // MIs[0] dst
 792 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 793 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 794 // CHECK-NEXT:    // MIs[0] Operand 1
 795 // CHECK-NEXT:    // No operand predicates
 796 // CHECK-NEXT:    // (imm:{ *:[i32] }):$imm =>  (MOVimm:{ *:[i32] } (imm:{ *:[i32] }):$imm)
 797 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MOVimm,
 798 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 799 // CHECK-NEXT:    GIR_CopyConstantAsSImm, /*NewInsnID*/0, /*OldInsnID*/0, // imm
 800 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 801 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 802 // CHECK-NEXT:    GIR_Done,
 803 // CHECK-NEXT:  // Label 20: @[[LABEL]]
 804
 805 def MOVimm : I<(outs GPR32:$dst), (ins i32imm:$imm), [(set GPR32:$dst, imm:$imm)]>;
 806
 807 //===- Test a simple pattern with a FP immediate and a predicate. ---------===//
 808
 809 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 21*/ [[LABEL:[0-9]+]],
 810 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 811 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_FCONSTANT,
 812 // CHECK-NEXT:    GIM_CheckAPFloatImmPredicate, /*MI*/0, /*Predicate*/GIPFP_APFloat_Predicate_fpimmz,
 813 // CHECK-NEXT:    // MIs[0] dst
 814 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 815 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::FPR32RegClassID,
 816 // CHECK-NEXT:    // MIs[0] Operand 1
 817 // CHECK-NEXT:    // No operand predicates
 818 // CHECK-NEXT:    // (fpimm:{ *:[f32] })<<P:Predicate_fpimmz>>:$imm =>  (MOVfpimmz:{ *:[f32] } (fpimm:{ *:[f32] }):$imm)
 819 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::MOVfpimmz,
 820 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 821 // CHECK-NEXT:    GIR_CopyFConstantAsFPImm, /*NewInsnID*/0, /*OldInsnID*/0, // imm
 822 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 823 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 824 // CHECK-NEXT:    GIR_Done,
 825 // CHECK-NEXT:  // Label 21: @[[LABEL]]
 826
 827 def fpimmz : FPImmLeaf<f32, [{ return Imm->isExactlyValue(0.0); }]>;
 828 def MOVfpimmz : I<(outs FPR32:$dst), (ins f32imm:$imm), [(set FPR32:$dst, fpimmz:$imm)]>;
 829
 830 //===- Test a simple pattern with inferred pointer operands. ---------------===//
 831
 832 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 22*/ [[LABEL:[0-9]+]],
 833 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 834 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_LOAD,
 835 // CHECK-NEXT:    GIM_CheckNonAtomic, /*MI*/0,
 836 // CHECK-NEXT:    // MIs[0] dst
 837 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 838 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 839 // CHECK-NEXT:    // MIs[0] src1
 840 // CHECK-NEXT:    GIM_CheckPointerToAny, /*MI*/0, /*Op*/1, /*SizeInBits*/32,
 841 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 842 // CHECK-NEXT:    // (ld:{ *:[i32] } GPR32:{ *:[i32] }:$src1)<<P:Predicate_unindexedload>><<P:Predicate_load>> => (LOAD:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 843 // CHECK-NEXT:    GIR_MutateOpcode, /*InsnID*/0, /*RecycleInsnID*/0, /*Opcode*/MyTarget::LOAD,
 844 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 845 // CHECK-NEXT:    GIR_Done,
 846 // CHECK-NEXT:  // Label 22: @[[LABEL]]
 847
 848 def LOAD : I<(outs GPR32:$dst), (ins GPR32:$src1),
 849             [(set GPR32:$dst, (load GPR32:$src1))]>;
 850
 851 //===- Test a simple pattern with a sextload -------------------------------===//
 852
 853 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 23*/ [[LABEL:[0-9]+]],
 854 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/2,
 855 // CHECK-NEXT:    GIM_RecordInsn, /*DefineMI*/1, /*MI*/0, /*OpIdx*/1, // MIs[1]
 856 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/1, /*Expected*/2,
 857 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_SEXT,
 858 // CHECK-NEXT:    // MIs[0] dst
 859 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/0, /*Type*/GILLT_s32,
 860 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/0, /*Op*/0, /*RC*/MyTarget::GPR32RegClassID,
 861 // CHECK-NEXT:    // MIs[0] Operand 1
 862 // CHECK-NEXT:    GIM_CheckType, /*MI*/0, /*Op*/1, /*Type*/GILLT_s16,
 863 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/1, TargetOpcode::G_LOAD,
 864 // CHECK-NEXT:    GIM_CheckNonAtomic, /*MI*/1,
 865 // CHECK-NEXT:    // MIs[1] Operand 0
 866 // CHECK-NEXT:    GIM_CheckType, /*MI*/1, /*Op*/0, /*Type*/GILLT_s16,
 867 // CHECK-NEXT:    // MIs[1] src1
 868 // CHECK-NEXT:    GIM_CheckPointerToAny, /*MI*/1, /*Op*/1, /*SizeInBits*/32,
 869 // CHECK-NEXT:    GIM_CheckRegBankForClass, /*MI*/1, /*Op*/1, /*RC*/MyTarget::GPR32RegClassID,
 870 // CHECK-NEXT:    GIM_CheckIsSafeToFold, /*InsnID*/1,
 871 // CHECK-NEXT:    // (sext:{ *:[i32] } (ld:{ *:[i16] } GPR32:{ *:[i32] }:$src1)<<P:Predicate_unindexedload>>)  =>  (SEXTLOAD:{ *:[i32] } GPR32:{ *:[i32] }:$src1)
 872 // CHECK-NEXT:    GIR_BuildMI, /*InsnID*/0, /*Opcode*/MyTarget::SEXTLOAD,
 873 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/0, /*OpIdx*/0, // dst
 874 // CHECK-NEXT:    GIR_Copy, /*NewInsnID*/0, /*OldInsnID*/1, /*OpIdx*/1, // src1
 875 // CHECK-NEXT:    GIR_MergeMemOperands, /*InsnID*/0, /*MergeInsnID's*/0, 1, GIU_MergeMemOperands_EndOfList,
 876 // CHECK-NEXT:    GIR_EraseFromParent, /*InsnID*/0,
 877 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 878 // CHECK-NEXT:    GIR_Done,
 879 // CHECK-NEXT:  // Label 23: @[[LABEL]]
 880
 881 def SEXTLOAD : I<(outs GPR32:$dst), (ins GPR32:$src1),
 882                  [(set GPR32:$dst, (sextloadi16 GPR32:$src1))]>;
 883
 884 //===- Test a pattern with an MBB operand. --------------------------------===//
 885
 886 // CHECK-NEXT:  GIM_Try, /*On fail goto*//*Label 24*/ [[LABEL:[0-9]+]],
 887 // CHECK-NEXT:    GIM_CheckNumOperands, /*MI*/0, /*Expected*/1,
 888 // CHECK-NEXT:    GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_BR,
 889 // CHECK-NEXT:    // MIs[0] target
 890 // CHECK-NEXT:    GIM_CheckIsMBB, /*MI*/0, /*Op*/0,
 891 // CHECK-NEXT:    // (br (bb:{ *:[Other] }):$target) => (BR (bb:{ *:[Other] }):$target)
 892 // CHECK-NEXT:    GIR_MutateOpcode, /*InsnID*/0, /*RecycleInsnID*/0, /*Opcode*/MyTarget::BR,
 893 // CHECK-NEXT:    GIR_ConstrainSelectedInstOperands, /*InsnID*/0,
 894 // CHECK-NEXT:    GIR_Done,
 895 // CHECK-NEXT:  // Label 24: @[[LABEL]]
 896
 897 def BR : I<(outs), (ins unknown:$target),
 898             [(br bb:$target)]>;
 899
 900 // CHECK-NEXT:    GIM_Reject,
 901 // CHECK-NEXT:  };
 902 // CHECK-NEXT:  if (executeMatchTable(*this, OutMIs, State, MatcherInfo, MatchTable0, TII, MRI, TRI, RBI, AvailableFeatures)) {
 903 // CHECK-NEXT:    return true;
 904 // CHECK-NEXT:  }