lib/Target/R600/R600Instructions.td

   1 //===-- R600Instructions.td - R600 Instruction defs  -------*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // R600 Tablegen instruction definitions
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 include "R600Intrinsics.td"
  15
  16 class InstR600 <dag outs, dag ins, string asm, list<dag> pattern,
  17                 InstrItinClass itin>
  18     : AMDGPUInst <outs, ins, asm, pattern> {
  19
  20   field bits<64> Inst;
  21   bit TransOnly = 0;
  22   bit Trig = 0;
  23   bit Op3 = 0;
  24   bit isVector = 0;
  25   bits<2> FlagOperandIdx = 0;
  26   bit Op1 = 0;
  27   bit Op2 = 0;
  28   bit HasNativeOperands = 0;
  29   bit VTXInst = 0;
  30   bit TEXInst = 0;
  31
  32   let Namespace = "AMDGPU";
  33   let OutOperandList = outs;
  34   let InOperandList = ins;
  35   let AsmString = asm;
  36   let Pattern = pattern;
  37   let Itinerary = itin;
  38
  39   let TSFlags{0} = TransOnly;
  40   let TSFlags{4} = Trig;
  41   let TSFlags{5} = Op3;
  42
  43   // Vector instructions are instructions that must fill all slots in an
  44   // instruction group
  45   let TSFlags{6} = isVector;
  46   let TSFlags{8-7} = FlagOperandIdx;
  47   let TSFlags{9} = HasNativeOperands;
  48   let TSFlags{10} = Op1;
  49   let TSFlags{11} = Op2;
  50   let TSFlags{12} = VTXInst;
  51   let TSFlags{13} = TEXInst;
  52 }
  53
  54 class InstR600ISA <dag outs, dag ins, string asm, list<dag> pattern> :
  55     InstR600 <outs, ins, asm, pattern, NullALU> {
  56
  57   let Namespace = "AMDGPU";
  58 }
  59
  60 def MEMxi : Operand<iPTR> {
  61   let MIOperandInfo = (ops R600_TReg32_X:$ptr, i32imm:$index);
  62   let PrintMethod = "printMemOperand";
  63 }
  64
  65 def MEMrr : Operand<iPTR> {
  66   let MIOperandInfo = (ops R600_Reg32:$ptr, R600_Reg32:$index);
  67 }
  68
  69 // Operands for non-registers
  70
  71 class InstFlag<string PM = "printOperand", int Default = 0>
  72     : OperandWithDefaultOps <i32, (ops (i32 Default))> {
  73   let PrintMethod = PM;
  74 }
  75
  76 // src_sel for ALU src operands, see also ALU_CONST, ALU_PARAM registers
  77 def SEL : OperandWithDefaultOps <i32, (ops (i32 -1))> {
  78   let PrintMethod = "printSel";
  79 }
  80 def BANK_SWIZZLE : OperandWithDefaultOps <i32, (ops (i32 0))> {
  81   let PrintMethod = "printBankSwizzle";
  82 }
  83
  84 def LITERAL : InstFlag<"printLiteral">;
  85
  86 def WRITE : InstFlag <"printWrite", 1>;
  87 def OMOD : InstFlag <"printOMOD">;
  88 def REL : InstFlag <"printRel">;
  89 def CLAMP : InstFlag <"printClamp">;
  90 def NEG : InstFlag <"printNeg">;
  91 def ABS : InstFlag <"printAbs">;
  92 def UEM : InstFlag <"printUpdateExecMask">;
  93 def UP : InstFlag <"printUpdatePred">;
  94
  95 // XXX: The r600g finalizer in Mesa expects last to be one in most cases.
  96 // Once we start using the packetizer in this backend we should have this
  97 // default to 0.
  98 def LAST : InstFlag<"printLast", 1>;
  99 def RSel : Operand<i32> {
 100   let PrintMethod = "printRSel";
 101 }
 102 def CT: Operand<i32> {
 103   let PrintMethod = "printCT";
 104 }
 105
 106 def FRAMEri : Operand<iPTR> {
 107   let MIOperandInfo = (ops R600_Reg32:$ptr, i32imm:$index);
 108 }
 109
 110 def ADDRParam : ComplexPattern<i32, 2, "SelectADDRParam", [], []>;
 111 def ADDRDWord : ComplexPattern<i32, 1, "SelectADDRDWord", [], []>;
 112 def ADDRVTX_READ : ComplexPattern<i32, 2, "SelectADDRVTX_READ", [], []>;
 113 def ADDRGA_CONST_OFFSET : ComplexPattern<i32, 1, "SelectGlobalValueConstantOffset", [], []>;
 114 def ADDRGA_VAR_OFFSET : ComplexPattern<i32, 2, "SelectGlobalValueVariableOffset", [], []>;
 115 def ADDRIndirect : ComplexPattern<iPTR, 2, "SelectADDRIndirect", [], []>;
 116
 117 class R600ALU_Word0 {
 118   field bits<32> Word0;
 119
 120   bits<11> src0;
 121   bits<1>  src0_neg;
 122   bits<1>  src0_rel;
 123   bits<11> src1;
 124   bits<1>  src1_rel;
 125   bits<1>  src1_neg;
 126   bits<3>  index_mode = 0;
 127   bits<2>  pred_sel;
 128   bits<1>  last;
 129
 130   bits<9>  src0_sel  = src0{8-0};
 131   bits<2>  src0_chan = src0{10-9};
 132   bits<9>  src1_sel  = src1{8-0};
 133   bits<2>  src1_chan = src1{10-9};
 134
 135   let Word0{8-0}   = src0_sel;
 136   let Word0{9}     = src0_rel;
 137   let Word0{11-10} = src0_chan;
 138   let Word0{12}    = src0_neg;
 139   let Word0{21-13} = src1_sel;
 140   let Word0{22}    = src1_rel;
 141   let Word0{24-23} = src1_chan;
 142   let Word0{25}    = src1_neg;
 143   let Word0{28-26} = index_mode;
 144   let Word0{30-29} = pred_sel;
 145   let Word0{31}    = last;
 146 }
 147
 148 class R600ALU_Word1 {
 149   field bits<32> Word1;
 150
 151   bits<11> dst;
 152   bits<3>  bank_swizzle;
 153   bits<1>  dst_rel;
 154   bits<1>  clamp;
 155
 156   bits<7>  dst_sel  = dst{6-0};
 157   bits<2>  dst_chan = dst{10-9};
 158
 159   let Word1{20-18} = bank_swizzle;
 160   let Word1{27-21} = dst_sel;
 161   let Word1{28}    = dst_rel;
 162   let Word1{30-29} = dst_chan;
 163   let Word1{31}    = clamp;
 164 }
 165
 166 class R600ALU_Word1_OP2 <bits<11> alu_inst> : R600ALU_Word1{
 167
 168   bits<1>  src0_abs;
 169   bits<1>  src1_abs;
 170   bits<1>  update_exec_mask;
 171   bits<1>  update_pred;
 172   bits<1>  write;
 173   bits<2>  omod;
 174
 175   let Word1{0}     = src0_abs;
 176   let Word1{1}     = src1_abs;
 177   let Word1{2}     = update_exec_mask;
 178   let Word1{3}     = update_pred;
 179   let Word1{4}     = write;
 180   let Word1{6-5}   = omod;
 181   let Word1{17-7}  = alu_inst;
 182 }
 183
 184 class R600ALU_Word1_OP3 <bits<5> alu_inst> : R600ALU_Word1{
 185
 186   bits<11> src2;
 187   bits<1>  src2_rel;
 188   bits<1>  src2_neg;
 189
 190   bits<9>  src2_sel = src2{8-0};
 191   bits<2>  src2_chan = src2{10-9};
 192
 193   let Word1{8-0}   = src2_sel;
 194   let Word1{9}     = src2_rel;
 195   let Word1{11-10} = src2_chan;
 196   let Word1{12}    = src2_neg;
 197   let Word1{17-13} = alu_inst;
 198 }
 199
 200 class VTX_WORD0 {
 201   field bits<32> Word0;
 202   bits<7> SRC_GPR;
 203   bits<5> VC_INST;
 204   bits<2> FETCH_TYPE;
 205   bits<1> FETCH_WHOLE_QUAD;
 206   bits<8> BUFFER_ID;
 207   bits<1> SRC_REL;
 208   bits<2> SRC_SEL_X;
 209   bits<6> MEGA_FETCH_COUNT;
 210
 211   let Word0{4-0}   = VC_INST;
 212   let Word0{6-5}   = FETCH_TYPE;
 213   let Word0{7}     = FETCH_WHOLE_QUAD;
 214   let Word0{15-8}  = BUFFER_ID;
 215   let Word0{22-16} = SRC_GPR;
 216   let Word0{23}    = SRC_REL;
 217   let Word0{25-24} = SRC_SEL_X;
 218   let Word0{31-26} = MEGA_FETCH_COUNT;
 219 }
 220
 221 class VTX_WORD1_GPR {
 222   field bits<32> Word1;
 223   bits<7> DST_GPR;
 224   bits<1> DST_REL;
 225   bits<3> DST_SEL_X;
 226   bits<3> DST_SEL_Y;
 227   bits<3> DST_SEL_Z;
 228   bits<3> DST_SEL_W;
 229   bits<1> USE_CONST_FIELDS;
 230   bits<6> DATA_FORMAT;
 231   bits<2> NUM_FORMAT_ALL;
 232   bits<1> FORMAT_COMP_ALL;
 233   bits<1> SRF_MODE_ALL;
 234
 235   let Word1{6-0} = DST_GPR;
 236   let Word1{7}    = DST_REL;
 237   let Word1{8}    = 0; // Reserved
 238   let Word1{11-9} = DST_SEL_X;
 239   let Word1{14-12} = DST_SEL_Y;
 240   let Word1{17-15} = DST_SEL_Z;
 241   let Word1{20-18} = DST_SEL_W;
 242   let Word1{21}    = USE_CONST_FIELDS;
 243   let Word1{27-22} = DATA_FORMAT;
 244   let Word1{29-28} = NUM_FORMAT_ALL;
 245   let Word1{30}    = FORMAT_COMP_ALL;
 246   let Word1{31}    = SRF_MODE_ALL;
 247 }
 248
 249 class TEX_WORD0 {
 250   field bits<32> Word0;
 251
 252   bits<5> TEX_INST;
 253   bits<2> INST_MOD;
 254   bits<1> FETCH_WHOLE_QUAD;
 255   bits<8> RESOURCE_ID;
 256   bits<7> SRC_GPR;
 257   bits<1> SRC_REL;
 258   bits<1> ALT_CONST;
 259   bits<2> RESOURCE_INDEX_MODE;
 260   bits<2> SAMPLER_INDEX_MODE;
 261
 262   let Word0{4-0} = TEX_INST;
 263   let Word0{6-5} = INST_MOD;
 264   let Word0{7} = FETCH_WHOLE_QUAD;
 265   let Word0{15-8} = RESOURCE_ID;
 266   let Word0{22-16} = SRC_GPR;
 267   let Word0{23} = SRC_REL;
 268   let Word0{24} = ALT_CONST;
 269   let Word0{26-25} = RESOURCE_INDEX_MODE;
 270   let Word0{28-27} = SAMPLER_INDEX_MODE;
 271 }
 272
 273 class TEX_WORD1 {
 274   field bits<32> Word1;
 275
 276   bits<7> DST_GPR;
 277   bits<1> DST_REL;
 278   bits<3> DST_SEL_X;
 279   bits<3> DST_SEL_Y;
 280   bits<3> DST_SEL_Z;
 281   bits<3> DST_SEL_W;
 282   bits<7> LOD_BIAS;
 283   bits<1> COORD_TYPE_X;
 284   bits<1> COORD_TYPE_Y;
 285   bits<1> COORD_TYPE_Z;
 286   bits<1> COORD_TYPE_W;
 287
 288   let Word1{6-0} = DST_GPR;
 289   let Word1{7} = DST_REL;
 290   let Word1{11-9} = DST_SEL_X;
 291   let Word1{14-12} = DST_SEL_Y;
 292   let Word1{17-15} = DST_SEL_Z;
 293   let Word1{20-18} = DST_SEL_W;
 294   let Word1{27-21} = LOD_BIAS;
 295   let Word1{28} = COORD_TYPE_X;
 296   let Word1{29} = COORD_TYPE_Y;
 297   let Word1{30} = COORD_TYPE_Z;
 298   let Word1{31} = COORD_TYPE_W;
 299 }
 300
 301 class TEX_WORD2 {
 302   field bits<32> Word2;
 303
 304   bits<5> OFFSET_X;
 305   bits<5> OFFSET_Y;
 306   bits<5> OFFSET_Z;
 307   bits<5> SAMPLER_ID;
 308   bits<3> SRC_SEL_X;
 309   bits<3> SRC_SEL_Y;
 310   bits<3> SRC_SEL_Z;
 311   bits<3> SRC_SEL_W;
 312
 313   let Word2{4-0} = OFFSET_X;
 314   let Word2{9-5} = OFFSET_Y;
 315   let Word2{14-10} = OFFSET_Z;
 316   let Word2{19-15} = SAMPLER_ID;
 317   let Word2{22-20} = SRC_SEL_X;
 318   let Word2{25-23} = SRC_SEL_Y;
 319   let Word2{28-26} = SRC_SEL_Z;
 320   let Word2{31-29} = SRC_SEL_W;
 321 }
 322
 323 /*
 324 XXX: R600 subtarget uses a slightly different encoding than the other
 325 subtargets.  We currently handle this in R600MCCodeEmitter, but we may
 326 want to use these instruction classes in the future.
 327
 328 class R600ALU_Word1_OP2_r600 : R600ALU_Word1_OP2 {
 329
 330   bits<1>  fog_merge;
 331   bits<10> alu_inst;
 332
 333   let Inst{37}    = fog_merge;
 334   let Inst{39-38} = omod;
 335   let Inst{49-40} = alu_inst;
 336 }
 337
 338 class R600ALU_Word1_OP2_r700 : R600ALU_Word1_OP2 {
 339
 340   bits<11> alu_inst;
 341
 342   let Inst{38-37} = omod;
 343   let Inst{49-39} = alu_inst;
 344 }
 345 */
 346
 347 def R600_Pred : PredicateOperand<i32, (ops R600_Predicate),
 348                                      (ops PRED_SEL_OFF)>;
 349
 350
 351 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
 352
 353 // Class for instructions with only one source register.
 354 // If you add new ins to this instruction, make sure they are listed before
 355 // $literal, because the backend currently assumes that the last operand is
 356 // a literal.  Also be sure to update the enum R600Op1OperandIndex::ROI in
 357 // R600Defines.h, R600InstrInfo::buildDefaultInstruction(),
 358 // and R600InstrInfo::getOperandIdx().
 359 class R600_1OP <bits<11> inst, string opName, list<dag> pattern,
 360                 InstrItinClass itin = AnyALU> :
 361     InstR600 <(outs R600_Reg32:$dst),
 362               (ins WRITE:$write, OMOD:$omod, REL:$dst_rel, CLAMP:$clamp,
 363                    R600_Reg32:$src0, NEG:$src0_neg, REL:$src0_rel, ABS:$src0_abs, SEL:$src0_sel,
 364                    LAST:$last, R600_Pred:$pred_sel, LITERAL:$literal,
 365                    BANK_SWIZZLE:$bank_swizzle),
 366               !strconcat("  ", opName,
 367                    "$clamp $last $dst$write$dst_rel$omod, "
 368                    "$src0_neg$src0_abs$src0$src0_abs$src0_rel, "
 369                    "$pred_sel $bank_swizzle"),
 370               pattern,
 371               itin>,
 372     R600ALU_Word0,
 373     R600ALU_Word1_OP2 <inst> {
 374
 375   let src1 = 0;
 376   let src1_rel = 0;
 377   let src1_neg = 0;
 378   let src1_abs = 0;
 379   let update_exec_mask = 0;
 380   let update_pred = 0;
 381   let HasNativeOperands = 1;
 382   let Op1 = 1;
 383   let DisableEncoding = "$literal";
 384
 385   let Inst{31-0}  = Word0;
 386   let Inst{63-32} = Word1;
 387 }
 388
 389 class R600_1OP_Helper <bits<11> inst, string opName, SDPatternOperator node,
 390                     InstrItinClass itin = AnyALU> :
 391     R600_1OP <inst, opName,
 392               [(set R600_Reg32:$dst, (node R600_Reg32:$src0))]
 393 >;
 394
 395 // If you add our change the operands for R600_2OP instructions, you must
 396 // also update the R600Op2OperandIndex::ROI enum in R600Defines.h,
 397 // R600InstrInfo::buildDefaultInstruction(), and R600InstrInfo::getOperandIdx().
 398 class R600_2OP <bits<11> inst, string opName, list<dag> pattern,
 399                 InstrItinClass itin = AnyALU> :
 400   InstR600 <(outs R600_Reg32:$dst),
 401           (ins UEM:$update_exec_mask, UP:$update_pred, WRITE:$write,
 402                OMOD:$omod, REL:$dst_rel, CLAMP:$clamp,
 403                R600_Reg32:$src0, NEG:$src0_neg, REL:$src0_rel, ABS:$src0_abs, SEL:$src0_sel,
 404                R600_Reg32:$src1, NEG:$src1_neg, REL:$src1_rel, ABS:$src1_abs, SEL:$src1_sel,
 405                LAST:$last, R600_Pred:$pred_sel, LITERAL:$literal,
 406                BANK_SWIZZLE:$bank_swizzle),
 407           !strconcat("  ", opName,
 408                 "$clamp $last $update_exec_mask$update_pred$dst$write$dst_rel$omod, "
 409                 "$src0_neg$src0_abs$src0$src0_abs$src0_rel, "
 410                 "$src1_neg$src1_abs$src1$src1_abs$src1_rel, "
 411                 "$pred_sel $bank_swizzle"),
 412           pattern,
 413           itin>,
 414     R600ALU_Word0,
 415     R600ALU_Word1_OP2 <inst> {
 416
 417   let HasNativeOperands = 1;
 418   let Op2 = 1;
 419   let DisableEncoding = "$literal";
 420
 421   let Inst{31-0}  = Word0;
 422   let Inst{63-32} = Word1;
 423 }
 424
 425 class R600_2OP_Helper <bits<11> inst, string opName, SDPatternOperator node,
 426                        InstrItinClass itim = AnyALU> :
 427     R600_2OP <inst, opName,
 428               [(set R600_Reg32:$dst, (node R600_Reg32:$src0,
 429                                            R600_Reg32:$src1))]
 430 >;
 431
 432 // If you add our change the operands for R600_3OP instructions, you must
 433 // also update the R600Op3OperandIndex::ROI enum in R600Defines.h,
 434 // R600InstrInfo::buildDefaultInstruction(), and
 435 // R600InstrInfo::getOperandIdx().
 436 class R600_3OP <bits<5> inst, string opName, list<dag> pattern,
 437                 InstrItinClass itin = AnyALU> :
 438   InstR600 <(outs R600_Reg32:$dst),
 439           (ins REL:$dst_rel, CLAMP:$clamp,
 440                R600_Reg32:$src0, NEG:$src0_neg, REL:$src0_rel, SEL:$src0_sel,
 441                R600_Reg32:$src1, NEG:$src1_neg, REL:$src1_rel, SEL:$src1_sel,
 442                R600_Reg32:$src2, NEG:$src2_neg, REL:$src2_rel, SEL:$src2_sel,
 443                LAST:$last, R600_Pred:$pred_sel, LITERAL:$literal,
 444                BANK_SWIZZLE:$bank_swizzle),
 445           !strconcat("  ", opName, "$clamp $last $dst$dst_rel, "
 446                              "$src0_neg$src0$src0_rel, "
 447                              "$src1_neg$src1$src1_rel, "
 448                              "$src2_neg$src2$src2_rel, "
 449                              "$pred_sel"
 450                              "$bank_swizzle"),
 451           pattern,
 452           itin>,
 453     R600ALU_Word0,
 454     R600ALU_Word1_OP3<inst>{
 455
 456   let HasNativeOperands = 1;
 457   let DisableEncoding = "$literal";
 458   let Op3 = 1;
 459
 460   let Inst{31-0}  = Word0;
 461   let Inst{63-32} = Word1;
 462 }
 463
 464 class R600_REDUCTION <bits<11> inst, dag ins, string asm, list<dag> pattern,
 465                       InstrItinClass itin = VecALU> :
 466   InstR600 <(outs R600_Reg32:$dst),
 467           ins,
 468           asm,
 469           pattern,
 470           itin>;
 471
 472
 473
 474 } // End mayLoad = 1, mayStore = 0, hasSideEffects = 0
 475
 476 def TEX_SHADOW : PatLeaf<
 477   (imm),
 478   [{uint32_t TType = (uint32_t)N->getZExtValue();
 479     return (TType >= 6 && TType <= 8) || (TType >= 11 && TType <= 13);
 480   }]
 481 >;
 482
 483 def TEX_RECT : PatLeaf<
 484   (imm),
 485   [{uint32_t TType = (uint32_t)N->getZExtValue();
 486     return TType == 5;
 487   }]
 488 >;
 489
 490 def TEX_ARRAY : PatLeaf<
 491   (imm),
 492   [{uint32_t TType = (uint32_t)N->getZExtValue();
 493     return TType == 9 || TType == 10 || TType == 15 || TType == 16;
 494   }]
 495 >;
 496
 497 def TEX_SHADOW_ARRAY : PatLeaf<
 498   (imm),
 499   [{uint32_t TType = (uint32_t)N->getZExtValue();
 500     return TType == 11 || TType == 12 || TType == 17;
 501   }]
 502 >;
 503
 504 class EG_CF_RAT <bits <8> cf_inst, bits <6> rat_inst, bits<4> rat_id, dag outs,
 505                  dag ins, string asm, list<dag> pattern> :
 506     InstR600ISA <outs, ins, asm, pattern> {
 507   bits<7>  RW_GPR;
 508   bits<7>  INDEX_GPR;
 509
 510   bits<2>  RIM;
 511   bits<2>  TYPE;
 512   bits<1>  RW_REL;
 513   bits<2>  ELEM_SIZE;
 514
 515   bits<12> ARRAY_SIZE;
 516   bits<4>  COMP_MASK;
 517   bits<4>  BURST_COUNT;
 518   bits<1>  VPM;
 519   bits<1>  eop;
 520   bits<1>  MARK;
 521   bits<1>  BARRIER;
 522
 523   // CF_ALLOC_EXPORT_WORD0_RAT
 524   let Inst{3-0}   = rat_id;
 525   let Inst{9-4}   = rat_inst;
 526   let Inst{10}    = 0; // Reserved
 527   let Inst{12-11} = RIM;
 528   let Inst{14-13} = TYPE;
 529   let Inst{21-15} = RW_GPR;
 530   let Inst{22}    = RW_REL;
 531   let Inst{29-23} = INDEX_GPR;
 532   let Inst{31-30} = ELEM_SIZE;
 533
 534   // CF_ALLOC_EXPORT_WORD1_BUF
 535   let Inst{43-32} = ARRAY_SIZE;
 536   let Inst{47-44} = COMP_MASK;
 537   let Inst{51-48} = BURST_COUNT;
 538   let Inst{52}    = VPM;
 539   let Inst{53}    = eop;
 540   let Inst{61-54} = cf_inst;
 541   let Inst{62}    = MARK;
 542   let Inst{63}    = BARRIER;
 543 }
 544
 545 class LoadParamFrag <PatFrag load_type> : PatFrag <
 546   (ops node:$ptr), (load_type node:$ptr),
 547   [{ return isParamLoad(dyn_cast<LoadSDNode>(N)); }]
 548 >;
 549
 550 def load_param : LoadParamFrag<load>;
 551 def load_param_zexti8 : LoadParamFrag<zextloadi8>;
 552 def load_param_zexti16 : LoadParamFrag<zextloadi16>;
 553
 554 def isR600 : Predicate<"Subtarget.getGeneration() <= AMDGPUSubtarget::R700">;
 555 def isR700 : Predicate<"Subtarget.getGeneration() == AMDGPUSubtarget::R700">;
 556 def isEG : Predicate<
 557   "Subtarget.getGeneration() >= AMDGPUSubtarget::EVERGREEN && "
 558   "Subtarget.getGeneration() < AMDGPUSubtarget::SOUTHERN_ISLANDS && "
 559   "!Subtarget.hasCaymanISA()">;
 560
 561 def isCayman : Predicate<"Subtarget.hasCaymanISA()">;
 562 def isEGorCayman : Predicate<"Subtarget.getGeneration() == "
 563                              "AMDGPUSubtarget::EVERGREEN"
 564                             "|| Subtarget.getGeneration() =="
 565                             "AMDGPUSubtarget::NORTHERN_ISLANDS">;
 566
 567 def isR600toCayman : Predicate<
 568                      "Subtarget.getGeneration() <= AMDGPUSubtarget::NORTHERN_ISLANDS">;
 569
 570 //===----------------------------------------------------------------------===//
 571 // R600 SDNodes
 572 //===----------------------------------------------------------------------===//
 573
 574 def INTERP_PAIR_XY :  AMDGPUShaderInst <
 575   (outs R600_TReg32_X:$dst0, R600_TReg32_Y:$dst1),
 576   (ins i32imm:$src0, R600_TReg32_Y:$src1, R600_TReg32_X:$src2),
 577   "INTERP_PAIR_XY $src0 $src1 $src2 : $dst0 dst1",
 578   []>;
 579
 580 def INTERP_PAIR_ZW :  AMDGPUShaderInst <
 581   (outs R600_TReg32_Z:$dst0, R600_TReg32_W:$dst1),
 582   (ins i32imm:$src0, R600_TReg32_Y:$src1, R600_TReg32_X:$src2),
 583   "INTERP_PAIR_ZW $src0 $src1 $src2 : $dst0 dst1",
 584   []>;
 585
 586 def CONST_ADDRESS: SDNode<"AMDGPUISD::CONST_ADDRESS",
 587   SDTypeProfile<1, -1, [SDTCisInt<0>, SDTCisPtrTy<1>]>,
 588   [SDNPVariadic]
 589 >;
 590
 591 def DOT4 : SDNode<"AMDGPUISD::DOT4",
 592   SDTypeProfile<1, 8, [SDTCisFP<0>, SDTCisVT<1, f32>, SDTCisVT<2, f32>,
 593       SDTCisVT<3, f32>, SDTCisVT<4, f32>, SDTCisVT<5, f32>,
 594       SDTCisVT<6, f32>, SDTCisVT<7, f32>, SDTCisVT<8, f32>]>,
 595   []
 596 >;
 597
 598 def TEXTURE_FETCH_Type : SDTypeProfile<1, 19, [SDTCisFP<0>]>;
 599
 600 def TEXTURE_FETCH: SDNode<"AMDGPUISD::TEXTURE_FETCH", TEXTURE_FETCH_Type, []>;
 601
 602 multiclass TexPattern<bits<32> TextureOp, Instruction inst, ValueType vt = v4f32> {
 603 def : Pat<(TEXTURE_FETCH (i32 TextureOp), vt:$SRC_GPR,
 604           (i32 imm:$srcx), (i32 imm:$srcy), (i32 imm:$srcz), (i32 imm:$srcw),
 605           (i32 imm:$offsetx), (i32 imm:$offsety), (i32 imm:$offsetz),
 606           (i32 imm:$DST_SEL_X), (i32 imm:$DST_SEL_Y), (i32 imm:$DST_SEL_Z),
 607           (i32 imm:$DST_SEL_W),
 608           (i32 imm:$RESOURCE_ID), (i32 imm:$SAMPLER_ID),
 609           (i32 imm:$COORD_TYPE_X), (i32 imm:$COORD_TYPE_Y), (i32 imm:$COORD_TYPE_Z),
 610           (i32 imm:$COORD_TYPE_W)),
 611           (inst R600_Reg128:$SRC_GPR,
 612           imm:$srcx, imm:$srcy, imm:$srcz, imm:$srcw,
 613           imm:$offsetx, imm:$offsety, imm:$offsetz,
 614           imm:$DST_SEL_X, imm:$DST_SEL_Y, imm:$DST_SEL_Z,
 615           imm:$DST_SEL_W,
 616           imm:$RESOURCE_ID, imm:$SAMPLER_ID,
 617           imm:$COORD_TYPE_X, imm:$COORD_TYPE_Y, imm:$COORD_TYPE_Z,
 618           imm:$COORD_TYPE_W)>;
 619 }
 620
 621 //===----------------------------------------------------------------------===//
 622 // Interpolation Instructions
 623 //===----------------------------------------------------------------------===//
 624
 625 def INTERP_VEC_LOAD :  AMDGPUShaderInst <
 626   (outs R600_Reg128:$dst),
 627   (ins i32imm:$src0),
 628   "INTERP_LOAD $src0 : $dst",
 629   []>;
 630
 631 def INTERP_XY : R600_2OP <0xD6, "INTERP_XY", []> {
 632   let bank_swizzle = 5;
 633 }
 634
 635 def INTERP_ZW : R600_2OP <0xD7, "INTERP_ZW", []> {
 636   let bank_swizzle = 5;
 637 }
 638
 639 def INTERP_LOAD_P0 : R600_1OP <0xE0, "INTERP_LOAD_P0", []>;
 640
 641 //===----------------------------------------------------------------------===//
 642 // Export Instructions
 643 //===----------------------------------------------------------------------===//
 644
 645 def ExportType : SDTypeProfile<0, 7, [SDTCisFP<0>, SDTCisInt<1>]>;
 646
 647 def EXPORT: SDNode<"AMDGPUISD::EXPORT", ExportType,
 648   [SDNPHasChain, SDNPSideEffect]>;
 649
 650 class ExportWord0 {
 651   field bits<32> Word0;
 652
 653   bits<13> arraybase;
 654   bits<2> type;
 655   bits<7> gpr;
 656   bits<2> elem_size;
 657
 658   let Word0{12-0} = arraybase;
 659   let Word0{14-13} = type;
 660   let Word0{21-15} = gpr;
 661   let Word0{22} = 0; // RW_REL
 662   let Word0{29-23} = 0; // INDEX_GPR
 663   let Word0{31-30} = elem_size;
 664 }
 665
 666 class ExportSwzWord1 {
 667   field bits<32> Word1;
 668
 669   bits<3> sw_x;
 670   bits<3> sw_y;
 671   bits<3> sw_z;
 672   bits<3> sw_w;
 673   bits<1> eop;
 674   bits<8> inst;
 675
 676   let Word1{2-0} = sw_x;
 677   let Word1{5-3} = sw_y;
 678   let Word1{8-6} = sw_z;
 679   let Word1{11-9} = sw_w;
 680 }
 681
 682 class ExportBufWord1 {
 683   field bits<32> Word1;
 684
 685   bits<12> arraySize;
 686   bits<4> compMask;
 687   bits<1> eop;
 688   bits<8> inst;
 689
 690   let Word1{11-0} = arraySize;
 691   let Word1{15-12} = compMask;
 692 }
 693
 694 multiclass ExportPattern<Instruction ExportInst, bits<8> cf_inst> {
 695   def : Pat<(int_R600_store_pixel_depth R600_Reg32:$reg),
 696     (ExportInst
 697         (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), R600_Reg32:$reg, sub0),
 698         0, 61, 0, 7, 7, 7, cf_inst, 0)
 699   >;
 700
 701   def : Pat<(int_R600_store_pixel_stencil R600_Reg32:$reg),
 702     (ExportInst
 703         (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), R600_Reg32:$reg, sub0),
 704         0, 61, 7, 0, 7, 7, cf_inst, 0)
 705   >;
 706
 707   def : Pat<(int_R600_store_dummy (i32 imm:$type)),
 708     (ExportInst
 709         (v4f32 (IMPLICIT_DEF)), imm:$type, 0, 7, 7, 7, 7, cf_inst, 0)
 710   >;
 711
 712   def : Pat<(int_R600_store_dummy 1),
 713     (ExportInst
 714         (v4f32 (IMPLICIT_DEF)), 1, 60, 7, 7, 7, 7, cf_inst, 0)
 715   >;
 716
 717   def : Pat<(EXPORT (v4f32 R600_Reg128:$src), (i32 imm:$base), (i32 imm:$type),
 718     (i32 imm:$swz_x), (i32 imm:$swz_y), (i32 imm:$swz_z), (i32 imm:$swz_w)),
 719         (ExportInst R600_Reg128:$src, imm:$type, imm:$base,
 720         imm:$swz_x, imm:$swz_y, imm:$swz_z, imm:$swz_w, cf_inst, 0)
 721   >;
 722
 723 }
 724
 725 multiclass SteamOutputExportPattern<Instruction ExportInst,
 726     bits<8> buf0inst, bits<8> buf1inst, bits<8> buf2inst, bits<8> buf3inst> {
 727 // Stream0
 728   def : Pat<(int_R600_store_stream_output (v4f32 R600_Reg128:$src),
 729       (i32 imm:$arraybase), (i32 0), (i32 imm:$mask)),
 730       (ExportInst R600_Reg128:$src, 0, imm:$arraybase,
 731       4095, imm:$mask, buf0inst, 0)>;
 732 // Stream1
 733   def : Pat<(int_R600_store_stream_output (v4f32 R600_Reg128:$src),
 734       (i32 imm:$arraybase), (i32 1), (i32 imm:$mask)),
 735       (ExportInst R600_Reg128:$src, 0, imm:$arraybase,
 736       4095, imm:$mask, buf1inst, 0)>;
 737 // Stream2
 738   def : Pat<(int_R600_store_stream_output (v4f32 R600_Reg128:$src),
 739       (i32 imm:$arraybase), (i32 2), (i32 imm:$mask)),
 740       (ExportInst R600_Reg128:$src, 0, imm:$arraybase,
 741       4095, imm:$mask, buf2inst, 0)>;
 742 // Stream3
 743   def : Pat<(int_R600_store_stream_output (v4f32 R600_Reg128:$src),
 744       (i32 imm:$arraybase), (i32 3), (i32 imm:$mask)),
 745       (ExportInst R600_Reg128:$src, 0, imm:$arraybase,
 746       4095, imm:$mask, buf3inst, 0)>;
 747 }
 748
 749 // Export Instructions should not be duplicated by TailDuplication pass
 750 // (which assumes that duplicable instruction are affected by exec mask)
 751 let usesCustomInserter = 1, isNotDuplicable = 1 in {
 752
 753 class ExportSwzInst : InstR600ISA<(
 754     outs),
 755     (ins R600_Reg128:$gpr, i32imm:$type, i32imm:$arraybase,
 756     i32imm:$sw_x, i32imm:$sw_y, i32imm:$sw_z, i32imm:$sw_w, i32imm:$inst,
 757     i32imm:$eop),
 758     !strconcat("EXPORT", " $gpr"),
 759     []>, ExportWord0, ExportSwzWord1 {
 760   let elem_size = 3;
 761   let Inst{31-0} = Word0;
 762   let Inst{63-32} = Word1;
 763 }
 764
 765 } // End usesCustomInserter = 1
 766
 767 class ExportBufInst : InstR600ISA<(
 768     outs),
 769     (ins R600_Reg128:$gpr, i32imm:$type, i32imm:$arraybase,
 770     i32imm:$arraySize, i32imm:$compMask, i32imm:$inst, i32imm:$eop),
 771     !strconcat("EXPORT", " $gpr"),
 772     []>, ExportWord0, ExportBufWord1 {
 773   let elem_size = 0;
 774   let Inst{31-0} = Word0;
 775   let Inst{63-32} = Word1;
 776 }
 777
 778 //===----------------------------------------------------------------------===//
 779 // Control Flow Instructions
 780 //===----------------------------------------------------------------------===//
 781
 782 class CF_ALU_WORD0 {
 783   field bits<32> Word0;
 784
 785   bits<22> ADDR;
 786   bits<4> KCACHE_BANK0;
 787   bits<4> KCACHE_BANK1;
 788   bits<2> KCACHE_MODE0;
 789
 790   let Word0{21-0} = ADDR;
 791   let Word0{25-22} = KCACHE_BANK0;
 792   let Word0{29-26} = KCACHE_BANK1;
 793   let Word0{31-30} = KCACHE_MODE0;
 794 }
 795
 796 class CF_ALU_WORD1 {
 797   field bits<32> Word1;
 798
 799   bits<2> KCACHE_MODE1;
 800   bits<8> KCACHE_ADDR0;
 801   bits<8> KCACHE_ADDR1;
 802   bits<7> COUNT;
 803   bits<1> ALT_CONST;
 804   bits<4> CF_INST;
 805   bits<1> WHOLE_QUAD_MODE;
 806   bits<1> BARRIER;
 807
 808   let Word1{1-0} = KCACHE_MODE1;
 809   let Word1{9-2} = KCACHE_ADDR0;
 810   let Word1{17-10} = KCACHE_ADDR1;
 811   let Word1{24-18} = COUNT;
 812   let Word1{25} = ALT_CONST;
 813   let Word1{29-26} = CF_INST;
 814   let Word1{30} = WHOLE_QUAD_MODE;
 815   let Word1{31} = BARRIER;
 816 }
 817
 818 def KCACHE : InstFlag<"printKCache">;
 819
 820 class ALU_CLAUSE<bits<4> inst, string OpName> : AMDGPUInst <(outs),
 821 (ins i32imm:$ADDR, i32imm:$KCACHE_BANK0, i32imm:$KCACHE_BANK1,
 822 KCACHE:$KCACHE_MODE0, KCACHE:$KCACHE_MODE1,
 823 i32imm:$KCACHE_ADDR0, i32imm:$KCACHE_ADDR1,
 824 i32imm:$COUNT),
 825 !strconcat(OpName, " $COUNT, @$ADDR, "
 826 "KC0[$KCACHE_MODE0], KC1[$KCACHE_MODE1]"),
 827 [] >, CF_ALU_WORD0, CF_ALU_WORD1 {
 828   field bits<64> Inst;
 829
 830   let CF_INST = inst;
 831   let ALT_CONST = 0;
 832   let WHOLE_QUAD_MODE = 0;
 833   let BARRIER = 1;
 834
 835   let Inst{31-0} = Word0;
 836   let Inst{63-32} = Word1;
 837 }
 838
 839 class CF_WORD0_R600 {
 840   field bits<32> Word0;
 841
 842   bits<32> ADDR;
 843
 844   let Word0 = ADDR;
 845 }
 846
 847 class CF_WORD1_R600 {
 848   field bits<32> Word1;
 849
 850   bits<3> POP_COUNT;
 851   bits<5> CF_CONST;
 852   bits<2> COND;
 853   bits<3> COUNT;
 854   bits<6> CALL_COUNT;
 855   bits<1> COUNT_3;
 856   bits<1> END_OF_PROGRAM;
 857   bits<1> VALID_PIXEL_MODE;
 858   bits<7> CF_INST;
 859   bits<1> WHOLE_QUAD_MODE;
 860   bits<1> BARRIER;
 861
 862   let Word1{2-0} = POP_COUNT;
 863   let Word1{7-3} = CF_CONST;
 864   let Word1{9-8} = COND;
 865   let Word1{12-10} = COUNT;
 866   let Word1{18-13} = CALL_COUNT;
 867   let Word1{19} = COUNT_3;
 868   let Word1{21} = END_OF_PROGRAM;
 869   let Word1{22} = VALID_PIXEL_MODE;
 870   let Word1{29-23} = CF_INST;
 871   let Word1{30} = WHOLE_QUAD_MODE;
 872   let Word1{31} = BARRIER;
 873 }
 874
 875 class CF_CLAUSE_R600 <bits<7> inst, dag ins, string AsmPrint> : AMDGPUInst <(outs),
 876 ins, AsmPrint, [] >, CF_WORD0_R600, CF_WORD1_R600 {
 877   field bits<64> Inst;
 878
 879   let CF_INST = inst;
 880   let BARRIER = 1;
 881   let CF_CONST = 0;
 882   let VALID_PIXEL_MODE = 0;
 883   let COND = 0;
 884   let CALL_COUNT = 0;
 885   let COUNT_3 = 0;
 886   let END_OF_PROGRAM = 0;
 887   let WHOLE_QUAD_MODE = 0;
 888
 889   let Inst{31-0} = Word0;
 890   let Inst{63-32} = Word1;
 891 }
 892
 893 class CF_WORD0_EG {
 894   field bits<32> Word0;
 895
 896   bits<24> ADDR;
 897   bits<3> JUMPTABLE_SEL;
 898
 899   let Word0{23-0} = ADDR;
 900   let Word0{26-24} = JUMPTABLE_SEL;
 901 }
 902
 903 class CF_WORD1_EG {
 904   field bits<32> Word1;
 905
 906   bits<3> POP_COUNT;
 907   bits<5> CF_CONST;
 908   bits<2> COND;
 909   bits<6> COUNT;
 910   bits<1> VALID_PIXEL_MODE;
 911   bits<1> END_OF_PROGRAM;
 912   bits<8> CF_INST;
 913   bits<1> BARRIER;
 914
 915   let Word1{2-0} = POP_COUNT;
 916   let Word1{7-3} = CF_CONST;
 917   let Word1{9-8} = COND;
 918   let Word1{15-10} = COUNT;
 919   let Word1{20} = VALID_PIXEL_MODE;
 920   let Word1{21} = END_OF_PROGRAM;
 921   let Word1{29-22} = CF_INST;
 922   let Word1{31} = BARRIER;
 923 }
 924
 925 class CF_CLAUSE_EG <bits<8> inst, dag ins, string AsmPrint> : AMDGPUInst <(outs),
 926 ins, AsmPrint, [] >, CF_WORD0_EG, CF_WORD1_EG {
 927   field bits<64> Inst;
 928
 929   let CF_INST = inst;
 930   let BARRIER = 1;
 931   let JUMPTABLE_SEL = 0;
 932   let CF_CONST = 0;
 933   let VALID_PIXEL_MODE = 0;
 934   let COND = 0;
 935   let END_OF_PROGRAM = 0;
 936
 937   let Inst{31-0} = Word0;
 938   let Inst{63-32} = Word1;
 939 }
 940
 941 def CF_ALU : ALU_CLAUSE<8, "ALU">;
 942 def CF_ALU_PUSH_BEFORE : ALU_CLAUSE<9, "ALU_PUSH_BEFORE">;
 943
 944 def FETCH_CLAUSE : AMDGPUInst <(outs),
 945 (ins i32imm:$addr), "Fetch clause starting at $addr:", [] > {
 946   field bits<8> Inst;
 947   bits<8> num;
 948   let Inst = num;
 949 }
 950
 951 def ALU_CLAUSE : AMDGPUInst <(outs),
 952 (ins i32imm:$addr), "ALU clause starting at $addr:", [] > {
 953   field bits<8> Inst;
 954   bits<8> num;
 955   let Inst = num;
 956 }
 957
 958 def LITERALS : AMDGPUInst <(outs),
 959 (ins LITERAL:$literal1, LITERAL:$literal2), "$literal1, $literal2", [] > {
 960   field bits<64> Inst;
 961   bits<32> literal1;
 962   bits<32> literal2;
 963
 964   let Inst{31-0} = literal1;
 965   let Inst{63-32} = literal2;
 966 }
 967
 968 def PAD : AMDGPUInst <(outs), (ins), "PAD", [] > {
 969   field bits<64> Inst;
 970 }
 971
 972 let Predicates = [isR600toCayman] in {
 973
 974 //===----------------------------------------------------------------------===//
 975 // Common Instructions R600, R700, Evergreen, Cayman
 976 //===----------------------------------------------------------------------===//
 977
 978 def ADD : R600_2OP_Helper <0x0, "ADD", fadd>;
 979 // Non-IEEE MUL: 0 * anything = 0
 980 def MUL : R600_2OP_Helper <0x1, "MUL NON-IEEE", int_AMDGPU_mul>;
 981 def MUL_IEEE : R600_2OP_Helper <0x2, "MUL_IEEE", fmul>;
 982 def MAX : R600_2OP_Helper <0x3, "MAX", AMDGPUfmax>;
 983 def MIN : R600_2OP_Helper <0x4, "MIN", AMDGPUfmin>;
 984
 985 // For the SET* instructions there is a naming conflict in TargetSelectionDAG.td,
 986 // so some of the instruction names don't match the asm string.
 987 // XXX: Use the defs in TargetSelectionDAG.td instead of intrinsics.
 988 def SETE : R600_2OP <
 989   0x08, "SETE",
 990   [(set f32:$dst, (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, COND_EQ))]
 991 >;
 992
 993 def SGT : R600_2OP <
 994   0x09, "SETGT",
 995   [(set f32:$dst, (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, COND_GT))]
 996 >;
 997
 998 def SGE : R600_2OP <
 999   0xA, "SETGE",
1000   [(set f32:$dst, (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, COND_GE))]
1001 >;
1002
1003 def SNE : R600_2OP <
1004   0xB, "SETNE",
1005   [(set f32:$dst, (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, COND_NE))]
1006 >;
1007
1008 def SETE_DX10 : R600_2OP <
1009   0xC, "SETE_DX10",
1010   [(set i32:$dst, (selectcc f32:$src0, f32:$src1, -1, 0, COND_EQ))]
1011 >;
1012
1013 def SETGT_DX10 : R600_2OP <
1014   0xD, "SETGT_DX10",
1015   [(set i32:$dst, (selectcc f32:$src0, f32:$src1, -1, 0, COND_GT))]
1016 >;
1017
1018 def SETGE_DX10 : R600_2OP <
1019   0xE, "SETGE_DX10",
1020   [(set i32:$dst, (selectcc f32:$src0, f32:$src1, -1, 0, COND_GE))]
1021 >;
1022
1023 def SETNE_DX10 : R600_2OP <
1024   0xF, "SETNE_DX10",
1025   [(set i32:$dst, (selectcc f32:$src0, f32:$src1, -1, 0, COND_NE))]
1026 >;
1027
1028 def FRACT : R600_1OP_Helper <0x10, "FRACT", AMDGPUfract>;
1029 def TRUNC : R600_1OP_Helper <0x11, "TRUNC", int_AMDGPU_trunc>;
1030 def CEIL : R600_1OP_Helper <0x12, "CEIL", fceil>;
1031 def RNDNE : R600_1OP_Helper <0x13, "RNDNE", frint>;
1032 def FLOOR : R600_1OP_Helper <0x14, "FLOOR", ffloor>;
1033
1034 def MOV : R600_1OP <0x19, "MOV", []>;
1035
1036 let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1 in {
1037
1038 class MOV_IMM <ValueType vt, Operand immType> : AMDGPUInst <
1039   (outs R600_Reg32:$dst),
1040   (ins immType:$imm),
1041   "",
1042   []
1043 >;
1044
1045 } // end let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1
1046
1047 def MOV_IMM_I32 : MOV_IMM<i32, i32imm>;
1048 def : Pat <
1049   (imm:$val),
1050   (MOV_IMM_I32 imm:$val)
1051 >;
1052
1053 def MOV_IMM_F32 : MOV_IMM<f32, f32imm>;
1054 def : Pat <
1055   (fpimm:$val),
1056   (MOV_IMM_F32  fpimm:$val)
1057 >;
1058
1059 def PRED_SETE : R600_2OP <0x20, "PRED_SETE", []>;
1060 def PRED_SETGT : R600_2OP <0x21, "PRED_SETGT", []>;
1061 def PRED_SETGE : R600_2OP <0x22, "PRED_SETGE", []>;
1062 def PRED_SETNE : R600_2OP <0x23, "PRED_SETNE", []>;
1063
1064 let hasSideEffects = 1 in {
1065
1066 def KILLGT : R600_2OP <0x2D, "KILLGT", []>;
1067
1068 } // end hasSideEffects
1069
1070 def AND_INT : R600_2OP_Helper <0x30, "AND_INT", and>;
1071 def OR_INT : R600_2OP_Helper <0x31, "OR_INT", or>;
1072 def XOR_INT : R600_2OP_Helper <0x32, "XOR_INT", xor>;
1073 def NOT_INT : R600_1OP_Helper <0x33, "NOT_INT", not>;
1074 def ADD_INT : R600_2OP_Helper <0x34, "ADD_INT", add>;
1075 def SUB_INT : R600_2OP_Helper <0x35, "SUB_INT", sub>;
1076 def MAX_INT : R600_2OP_Helper <0x36, "MAX_INT", AMDGPUsmax>;
1077 def MIN_INT : R600_2OP_Helper <0x37, "MIN_INT", AMDGPUsmin>;
1078 def MAX_UINT : R600_2OP_Helper <0x38, "MAX_UINT", AMDGPUumax>;
1079 def MIN_UINT : R600_2OP_Helper <0x39, "MIN_UINT", AMDGPUumin>;
1080
1081 def SETE_INT : R600_2OP <
1082   0x3A, "SETE_INT",
1083   [(set i32:$dst, (selectcc i32:$src0, i32:$src1, -1, 0, SETEQ))]
1084 >;
1085
1086 def SETGT_INT : R600_2OP <
1087   0x3B, "SETGT_INT",
1088   [(set i32:$dst, (selectcc i32:$src0, i32:$src1, -1, 0, SETGT))]
1089 >;
1090
1091 def SETGE_INT : R600_2OP <
1092   0x3C, "SETGE_INT",
1093   [(set i32:$dst, (selectcc i32:$src0, i32:$src1, -1, 0, SETGE))]
1094 >;
1095
1096 def SETNE_INT : R600_2OP <
1097   0x3D, "SETNE_INT",
1098   [(set i32:$dst, (selectcc i32:$src0, i32:$src1, -1, 0, SETNE))]
1099 >;
1100
1101 def SETGT_UINT : R600_2OP <
1102   0x3E, "SETGT_UINT",
1103   [(set i32:$dst, (selectcc i32:$src0, i32:$src1, -1, 0, SETUGT))]
1104 >;
1105
1106 def SETGE_UINT : R600_2OP <
1107   0x3F, "SETGE_UINT",
1108   [(set i32:$dst, (selectcc i32:$src0, i32:$src1, -1, 0, SETUGE))]
1109 >;
1110
1111 def PRED_SETE_INT : R600_2OP <0x42, "PRED_SETE_INT", []>;
1112 def PRED_SETGT_INT : R600_2OP <0x43, "PRED_SETGE_INT", []>;
1113 def PRED_SETGE_INT : R600_2OP <0x44, "PRED_SETGE_INT", []>;
1114 def PRED_SETNE_INT : R600_2OP <0x45, "PRED_SETNE_INT", []>;
1115
1116 def CNDE_INT : R600_3OP <
1117   0x1C, "CNDE_INT",
1118   [(set i32:$dst, (selectcc i32:$src0, 0, i32:$src1, i32:$src2, COND_EQ))]
1119 >;
1120
1121 def CNDGE_INT : R600_3OP <
1122   0x1E, "CNDGE_INT",
1123   [(set i32:$dst, (selectcc i32:$src0, 0, i32:$src1, i32:$src2, COND_GE))]
1124 >;
1125
1126 def CNDGT_INT : R600_3OP <
1127   0x1D, "CNDGT_INT",
1128   [(set i32:$dst, (selectcc i32:$src0, 0, i32:$src1, i32:$src2, COND_GT))]
1129 >;
1130
1131 //===----------------------------------------------------------------------===//
1132 // Texture instructions
1133 //===----------------------------------------------------------------------===//
1134
1135 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
1136
1137 class R600_TEX <bits<11> inst, string opName> :
1138   InstR600 <(outs R600_Reg128:$DST_GPR),
1139           (ins R600_Reg128:$SRC_GPR,
1140           RSel:$srcx, RSel:$srcy, RSel:$srcz, RSel:$srcw,
1141           i32imm:$offsetx, i32imm:$offsety, i32imm:$offsetz,
1142           RSel:$DST_SEL_X, RSel:$DST_SEL_Y, RSel:$DST_SEL_Z, RSel:$DST_SEL_W,
1143           i32imm:$RESOURCE_ID, i32imm:$SAMPLER_ID,
1144           CT:$COORD_TYPE_X, CT:$COORD_TYPE_Y, CT:$COORD_TYPE_Z,
1145           CT:$COORD_TYPE_W),
1146           !strconcat(opName,
1147           " $DST_GPR.$DST_SEL_X$DST_SEL_Y$DST_SEL_Z$DST_SEL_W, "
1148           "$SRC_GPR.$srcx$srcy$srcz$srcw "
1149           "RID:$RESOURCE_ID SID:$SAMPLER_ID "
1150           "CT:$COORD_TYPE_X$COORD_TYPE_Y$COORD_TYPE_Z$COORD_TYPE_W"),
1151           [],
1152           NullALU>, TEX_WORD0, TEX_WORD1, TEX_WORD2 {
1153   let Inst{31-0} = Word0;
1154   let Inst{63-32} = Word1;
1155
1156   let TEX_INST = inst{4-0};
1157   let SRC_REL = 0;
1158   let DST_REL = 0;
1159   let LOD_BIAS = 0;
1160
1161   let INST_MOD = 0;
1162   let FETCH_WHOLE_QUAD = 0;
1163   let ALT_CONST = 0;
1164   let SAMPLER_INDEX_MODE = 0;
1165   let RESOURCE_INDEX_MODE = 0;
1166
1167   let TEXInst = 1;
1168 }
1169
1170 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 0
1171
1172
1173
1174 def TEX_SAMPLE : R600_TEX <0x10, "TEX_SAMPLE">;
1175 def TEX_SAMPLE_C : R600_TEX <0x18, "TEX_SAMPLE_C">;
1176 def TEX_SAMPLE_L : R600_TEX <0x11, "TEX_SAMPLE_L">;
1177 def TEX_SAMPLE_C_L : R600_TEX <0x19, "TEX_SAMPLE_C_L">;
1178 def TEX_SAMPLE_LB : R600_TEX <0x12, "TEX_SAMPLE_LB">;
1179 def TEX_SAMPLE_C_LB : R600_TEX <0x1A, "TEX_SAMPLE_C_LB">;
1180 def TEX_LD : R600_TEX <0x03, "TEX_LD">;
1181 def TEX_GET_TEXTURE_RESINFO : R600_TEX <0x04, "TEX_GET_TEXTURE_RESINFO">;
1182 def TEX_GET_GRADIENTS_H : R600_TEX <0x07, "TEX_GET_GRADIENTS_H">;
1183 def TEX_GET_GRADIENTS_V : R600_TEX <0x08, "TEX_GET_GRADIENTS_V">;
1184 def TEX_SET_GRADIENTS_H : R600_TEX <0x0B, "TEX_SET_GRADIENTS_H">;
1185 def TEX_SET_GRADIENTS_V : R600_TEX <0x0C, "TEX_SET_GRADIENTS_V">;
1186 def TEX_SAMPLE_G : R600_TEX <0x14, "TEX_SAMPLE_G">;
1187 def TEX_SAMPLE_C_G : R600_TEX <0x1C, "TEX_SAMPLE_C_G">;
1188
1189 defm : TexPattern<0, TEX_SAMPLE>;
1190 defm : TexPattern<1, TEX_SAMPLE_C>;
1191 defm : TexPattern<2, TEX_SAMPLE_L>;
1192 defm : TexPattern<3, TEX_SAMPLE_C_L>;
1193 defm : TexPattern<4, TEX_SAMPLE_LB>;
1194 defm : TexPattern<5, TEX_SAMPLE_C_LB>;
1195 defm : TexPattern<6, TEX_LD, v4i32>;
1196 defm : TexPattern<7, TEX_GET_TEXTURE_RESINFO, v4i32>;
1197 defm : TexPattern<8, TEX_GET_GRADIENTS_H>;
1198 defm : TexPattern<9, TEX_GET_GRADIENTS_V>;
1199
1200 //===----------------------------------------------------------------------===//
1201 // Helper classes for common instructions
1202 //===----------------------------------------------------------------------===//
1203
1204 class MUL_LIT_Common <bits<5> inst> : R600_3OP <
1205   inst, "MUL_LIT",
1206   []
1207 >;
1208
1209 class MULADD_Common <bits<5> inst> : R600_3OP <
1210   inst, "MULADD",
1211   []
1212 >;
1213
1214 class MULADD_IEEE_Common <bits<5> inst> : R600_3OP <
1215   inst, "MULADD_IEEE",
1216   [(set f32:$dst, (fadd (fmul f32:$src0, f32:$src1), f32:$src2))]
1217 >;
1218
1219 class CNDE_Common <bits<5> inst> : R600_3OP <
1220   inst, "CNDE",
1221   [(set f32:$dst, (selectcc f32:$src0, FP_ZERO, f32:$src1, f32:$src2, COND_EQ))]
1222 >;
1223
1224 class CNDGT_Common <bits<5> inst> : R600_3OP <
1225   inst, "CNDGT",
1226   [(set f32:$dst, (selectcc f32:$src0, FP_ZERO, f32:$src1, f32:$src2, COND_GT))]
1227 >;
1228
1229 class CNDGE_Common <bits<5> inst> : R600_3OP <
1230   inst, "CNDGE",
1231   [(set f32:$dst, (selectcc f32:$src0, FP_ZERO, f32:$src1, f32:$src2, COND_GE))]
1232 >;
1233
1234
1235 let isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"  in {
1236 class R600_VEC2OP<list<dag> pattern> : InstR600 <(outs R600_Reg32:$dst), (ins
1237 // Slot X
1238    UEM:$update_exec_mask_X, UP:$update_pred_X, WRITE:$write_X,
1239    OMOD:$omod_X, REL:$dst_rel_X, CLAMP:$clamp_X,
1240    R600_TReg32_X:$src0_X, NEG:$src0_neg_X, REL:$src0_rel_X, ABS:$src0_abs_X, SEL:$src0_sel_X,
1241    R600_TReg32_X:$src1_X, NEG:$src1_neg_X, REL:$src1_rel_X, ABS:$src1_abs_X, SEL:$src1_sel_X,
1242    R600_Pred:$pred_sel_X,
1243 // Slot Y
1244    UEM:$update_exec_mask_Y, UP:$update_pred_Y, WRITE:$write_Y,
1245    OMOD:$omod_Y, REL:$dst_rel_Y, CLAMP:$clamp_Y,
1246    R600_TReg32_Y:$src0_Y, NEG:$src0_neg_Y, REL:$src0_rel_Y, ABS:$src0_abs_Y, SEL:$src0_sel_Y,
1247    R600_TReg32_Y:$src1_Y, NEG:$src1_neg_Y, REL:$src1_rel_Y, ABS:$src1_abs_Y, SEL:$src1_sel_Y,
1248    R600_Pred:$pred_sel_Y,
1249 // Slot Z
1250    UEM:$update_exec_mask_Z, UP:$update_pred_Z, WRITE:$write_Z,
1251    OMOD:$omod_Z, REL:$dst_rel_Z, CLAMP:$clamp_Z,
1252    R600_TReg32_Z:$src0_Z, NEG:$src0_neg_Z, REL:$src0_rel_Z, ABS:$src0_abs_Z, SEL:$src0_sel_Z,
1253    R600_TReg32_Z:$src1_Z, NEG:$src1_neg_Z, REL:$src1_rel_Z, ABS:$src1_abs_Z, SEL:$src1_sel_Z,
1254    R600_Pred:$pred_sel_Z,
1255 // Slot W
1256    UEM:$update_exec_mask_W, UP:$update_pred_W, WRITE:$write_W,
1257    OMOD:$omod_W, REL:$dst_rel_W, CLAMP:$clamp_W,
1258    R600_TReg32_W:$src0_W, NEG:$src0_neg_W, REL:$src0_rel_W, ABS:$src0_abs_W, SEL:$src0_sel_W,
1259    R600_TReg32_W:$src1_W, NEG:$src1_neg_W, REL:$src1_rel_W, ABS:$src1_abs_W, SEL:$src1_sel_W,
1260    R600_Pred:$pred_sel_W,
1261    LITERAL:$literal0, LITERAL:$literal1),
1262   "",
1263   pattern,
1264   AnyALU> {}
1265 }
1266
1267 def DOT_4 : R600_VEC2OP<[(set R600_Reg32:$dst, (DOT4
1268   R600_TReg32_X:$src0_X, R600_TReg32_X:$src1_X,
1269   R600_TReg32_Y:$src0_Y, R600_TReg32_Y:$src1_Y,
1270   R600_TReg32_Z:$src0_Z, R600_TReg32_Z:$src1_Z,
1271   R600_TReg32_W:$src0_W, R600_TReg32_W:$src1_W))]>;
1272
1273
1274 class DOT4_Common <bits<11> inst> : R600_2OP <inst, "DOT4", []>;
1275
1276
1277 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
1278 multiclass CUBE_Common <bits<11> inst> {
1279
1280   def _pseudo : InstR600 <
1281     (outs R600_Reg128:$dst),
1282     (ins R600_Reg128:$src),
1283     "CUBE $dst $src",
1284     [(set v4f32:$dst, (int_AMDGPU_cube v4f32:$src))],
1285     VecALU
1286   > {
1287     let isPseudo = 1;
1288   }
1289
1290   def _real : R600_2OP <inst, "CUBE", []>;
1291 }
1292 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 0
1293
1294 class EXP_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
1295   inst, "EXP_IEEE", fexp2
1296 > {
1297   let TransOnly = 1;
1298   let Itinerary = TransALU;
1299 }
1300
1301 class FLT_TO_INT_Common <bits<11> inst> : R600_1OP_Helper <
1302   inst, "FLT_TO_INT", fp_to_sint
1303 > {
1304   let TransOnly = 1;
1305   let Itinerary = TransALU;
1306 }
1307
1308 class INT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
1309   inst, "INT_TO_FLT", sint_to_fp
1310 > {
1311   let TransOnly = 1;
1312   let Itinerary = TransALU;
1313 }
1314
1315 class FLT_TO_UINT_Common <bits<11> inst> : R600_1OP_Helper <
1316   inst, "FLT_TO_UINT", fp_to_uint
1317 > {
1318   let TransOnly = 1;
1319   let Itinerary = TransALU;
1320 }
1321
1322 class UINT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
1323   inst, "UINT_TO_FLT", uint_to_fp
1324 > {
1325   let TransOnly = 1;
1326   let Itinerary = TransALU;
1327 }
1328
1329 class LOG_CLAMPED_Common <bits<11> inst> : R600_1OP <
1330   inst, "LOG_CLAMPED", []
1331 >;
1332
1333 class LOG_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
1334   inst, "LOG_IEEE", flog2
1335 > {
1336   let TransOnly = 1;
1337   let Itinerary = TransALU;
1338 }
1339
1340 class LSHL_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHL", shl>;
1341 class LSHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHR", srl>;
1342 class ASHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "ASHR", sra>;
1343 class MULHI_INT_Common <bits<11> inst> : R600_2OP_Helper <
1344   inst, "MULHI_INT", mulhs
1345 > {
1346   let TransOnly = 1;
1347   let Itinerary = TransALU;
1348 }
1349 class MULHI_UINT_Common <bits<11> inst> : R600_2OP_Helper <
1350   inst, "MULHI", mulhu
1351 > {
1352   let TransOnly = 1;
1353   let Itinerary = TransALU;
1354 }
1355 class MULLO_INT_Common <bits<11> inst> : R600_2OP_Helper <
1356   inst, "MULLO_INT", mul
1357 > {
1358   let TransOnly = 1;
1359   let Itinerary = TransALU;
1360 }
1361 class MULLO_UINT_Common <bits<11> inst> : R600_2OP <inst, "MULLO_UINT", []> {
1362   let TransOnly = 1;
1363   let Itinerary = TransALU;
1364 }
1365
1366 class RECIP_CLAMPED_Common <bits<11> inst> : R600_1OP <
1367   inst, "RECIP_CLAMPED", []
1368 > {
1369   let TransOnly = 1;
1370   let Itinerary = TransALU;
1371 }
1372
1373 class RECIP_IEEE_Common <bits<11> inst> : R600_1OP <
1374   inst, "RECIP_IEEE", [(set f32:$dst, (fdiv FP_ONE, f32:$src0))]
1375 > {
1376   let TransOnly = 1;
1377   let Itinerary = TransALU;
1378 }
1379
1380 class RECIP_UINT_Common <bits<11> inst> : R600_1OP_Helper <
1381   inst, "RECIP_UINT", AMDGPUurecip
1382 > {
1383   let TransOnly = 1;
1384   let Itinerary = TransALU;
1385 }
1386
1387 class RECIPSQRT_CLAMPED_Common <bits<11> inst> : R600_1OP_Helper <
1388   inst, "RECIPSQRT_CLAMPED", int_AMDGPU_rsq
1389 > {
1390   let TransOnly = 1;
1391   let Itinerary = TransALU;
1392 }
1393
1394 class RECIPSQRT_IEEE_Common <bits<11> inst> : R600_1OP <
1395   inst, "RECIPSQRT_IEEE", []
1396 > {
1397   let TransOnly = 1;
1398   let Itinerary = TransALU;
1399 }
1400
1401 class SIN_Common <bits<11> inst> : R600_1OP <
1402   inst, "SIN", []>{
1403   let Trig = 1;
1404   let TransOnly = 1;
1405   let Itinerary = TransALU;
1406 }
1407
1408 class COS_Common <bits<11> inst> : R600_1OP <
1409   inst, "COS", []> {
1410   let Trig = 1;
1411   let TransOnly = 1;
1412   let Itinerary = TransALU;
1413 }
1414
1415 //===----------------------------------------------------------------------===//
1416 // Helper patterns for complex intrinsics
1417 //===----------------------------------------------------------------------===//
1418
1419 multiclass DIV_Common <InstR600 recip_ieee> {
1420 def : Pat<
1421   (int_AMDGPU_div f32:$src0, f32:$src1),
1422   (MUL_IEEE $src0, (recip_ieee $src1))
1423 >;
1424
1425 def : Pat<
1426   (fdiv f32:$src0, f32:$src1),
1427   (MUL_IEEE $src0, (recip_ieee $src1))
1428 >;
1429 }
1430
1431 class TGSI_LIT_Z_Common <InstR600 mul_lit, InstR600 log_clamped, InstR600 exp_ieee>
1432   : Pat <
1433   (int_TGSI_lit_z f32:$src_x, f32:$src_y, f32:$src_w),
1434   (exp_ieee (mul_lit (log_clamped (MAX $src_y, (f32 ZERO))), $src_w, $src_x))
1435 >;
1436
1437 //===----------------------------------------------------------------------===//
1438 // R600 / R700 Instructions
1439 //===----------------------------------------------------------------------===//
1440
1441 let Predicates = [isR600] in {
1442
1443   def MUL_LIT_r600 : MUL_LIT_Common<0x0C>;
1444   def MULADD_r600 : MULADD_Common<0x10>;
1445   def MULADD_IEEE_r600 : MULADD_IEEE_Common<0x14>;
1446   def CNDE_r600 : CNDE_Common<0x18>;
1447   def CNDGT_r600 : CNDGT_Common<0x19>;
1448   def CNDGE_r600 : CNDGE_Common<0x1A>;
1449   def DOT4_r600 : DOT4_Common<0x50>;
1450   defm CUBE_r600 : CUBE_Common<0x52>;
1451   def EXP_IEEE_r600 : EXP_IEEE_Common<0x61>;
1452   def LOG_CLAMPED_r600 : LOG_CLAMPED_Common<0x62>;
1453   def LOG_IEEE_r600 : LOG_IEEE_Common<0x63>;
1454   def RECIP_CLAMPED_r600 : RECIP_CLAMPED_Common<0x64>;
1455   def RECIP_IEEE_r600 : RECIP_IEEE_Common<0x66>;
1456   def RECIPSQRT_CLAMPED_r600 : RECIPSQRT_CLAMPED_Common<0x67>;
1457   def RECIPSQRT_IEEE_r600 : RECIPSQRT_IEEE_Common<0x69>;
1458   def FLT_TO_INT_r600 : FLT_TO_INT_Common<0x6b>;
1459   def INT_TO_FLT_r600 : INT_TO_FLT_Common<0x6c>;
1460   def FLT_TO_UINT_r600 : FLT_TO_UINT_Common<0x79>;
1461   def UINT_TO_FLT_r600 : UINT_TO_FLT_Common<0x6d>;
1462   def SIN_r600 : SIN_Common<0x6E>;
1463   def COS_r600 : COS_Common<0x6F>;
1464   def ASHR_r600 : ASHR_Common<0x70>;
1465   def LSHR_r600 : LSHR_Common<0x71>;
1466   def LSHL_r600 : LSHL_Common<0x72>;
1467   def MULLO_INT_r600 : MULLO_INT_Common<0x73>;
1468   def MULHI_INT_r600 : MULHI_INT_Common<0x74>;
1469   def MULLO_UINT_r600 : MULLO_UINT_Common<0x75>;
1470   def MULHI_UINT_r600 : MULHI_UINT_Common<0x76>;
1471   def RECIP_UINT_r600 : RECIP_UINT_Common <0x78>;
1472
1473   defm DIV_r600 : DIV_Common<RECIP_IEEE_r600>;
1474   def : POW_Common <LOG_IEEE_r600, EXP_IEEE_r600, MUL>;
1475   def TGSI_LIT_Z_r600 : TGSI_LIT_Z_Common<MUL_LIT_r600, LOG_CLAMPED_r600, EXP_IEEE_r600>;
1476
1477   def : Pat<(fsqrt f32:$src), (MUL $src, (RECIPSQRT_CLAMPED_r600 $src))>;
1478
1479   def R600_ExportSwz : ExportSwzInst {
1480     let Word1{20-17} = 0; // BURST_COUNT
1481     let Word1{21} = eop;
1482     let Word1{22} = 1; // VALID_PIXEL_MODE
1483     let Word1{30-23} = inst;
1484     let Word1{31} = 1; // BARRIER
1485   }
1486   defm : ExportPattern<R600_ExportSwz, 39>;
1487
1488   def R600_ExportBuf : ExportBufInst {
1489     let Word1{20-17} = 0; // BURST_COUNT
1490     let Word1{21} = eop;
1491     let Word1{22} = 1; // VALID_PIXEL_MODE
1492     let Word1{30-23} = inst;
1493     let Word1{31} = 1; // BARRIER
1494   }
1495   defm : SteamOutputExportPattern<R600_ExportBuf, 0x20, 0x21, 0x22, 0x23>;
1496
1497   def CF_TC_R600 : CF_CLAUSE_R600<1, (ins i32imm:$ADDR, i32imm:$COUNT),
1498   "TEX $COUNT @$ADDR"> {
1499     let POP_COUNT = 0;
1500   }
1501   def CF_VC_R600 : CF_CLAUSE_R600<2, (ins i32imm:$ADDR, i32imm:$COUNT),
1502   "VTX $COUNT @$ADDR"> {
1503     let POP_COUNT = 0;
1504   }
1505   def WHILE_LOOP_R600 : CF_CLAUSE_R600<6, (ins i32imm:$ADDR),
1506   "LOOP_START_DX10 @$ADDR"> {
1507     let POP_COUNT = 0;
1508     let COUNT = 0;
1509   }
1510   def END_LOOP_R600 : CF_CLAUSE_R600<5, (ins i32imm:$ADDR), "END_LOOP @$ADDR"> {
1511     let POP_COUNT = 0;
1512     let COUNT = 0;
1513   }
1514   def LOOP_BREAK_R600 : CF_CLAUSE_R600<9, (ins i32imm:$ADDR),
1515   "LOOP_BREAK @$ADDR"> {
1516     let POP_COUNT = 0;
1517     let COUNT = 0;
1518   }
1519   def CF_CONTINUE_R600 : CF_CLAUSE_R600<8, (ins i32imm:$ADDR),
1520   "CONTINUE @$ADDR"> {
1521     let POP_COUNT = 0;
1522     let COUNT = 0;
1523   }
1524   def CF_JUMP_R600 : CF_CLAUSE_R600<10, (ins i32imm:$ADDR, i32imm:$POP_COUNT),
1525   "JUMP @$ADDR POP:$POP_COUNT"> {
1526     let COUNT = 0;
1527   }
1528   def CF_ELSE_R600 : CF_CLAUSE_R600<13, (ins i32imm:$ADDR, i32imm:$POP_COUNT),
1529   "ELSE @$ADDR POP:$POP_COUNT"> {
1530     let COUNT = 0;
1531   }
1532   def CF_CALL_FS_R600 : CF_CLAUSE_R600<19, (ins), "CALL_FS"> {
1533     let ADDR = 0;
1534     let COUNT = 0;
1535     let POP_COUNT = 0;
1536   }
1537   def POP_R600 : CF_CLAUSE_R600<14, (ins i32imm:$ADDR, i32imm:$POP_COUNT),
1538   "POP @$ADDR POP:$POP_COUNT"> {
1539     let COUNT = 0;
1540   }
1541   def CF_END_R600 : CF_CLAUSE_R600<0, (ins), "CF_END"> {
1542     let COUNT = 0;
1543     let POP_COUNT = 0;
1544     let ADDR = 0;
1545     let END_OF_PROGRAM = 1;
1546   }
1547
1548 }
1549
1550 // Helper pattern for normalizing inputs to triginomic instructions for R700+
1551 // cards.
1552 class COS_PAT <InstR600 trig> : Pat<
1553   (fcos f32:$src),
1554   (trig (MUL_IEEE (MOV_IMM_I32 CONST.TWO_PI_INV), $src))
1555 >;
1556
1557 class SIN_PAT <InstR600 trig> : Pat<
1558   (fsin f32:$src),
1559   (trig (MUL_IEEE (MOV_IMM_I32 CONST.TWO_PI_INV), $src))
1560 >;
1561
1562 //===----------------------------------------------------------------------===//
1563 // R700 Only instructions
1564 //===----------------------------------------------------------------------===//
1565
1566 let Predicates = [isR700] in {
1567   def SIN_r700 : SIN_Common<0x6E>;
1568   def COS_r700 : COS_Common<0x6F>;
1569
1570   // R700 normalizes inputs to SIN/COS the same as EG
1571   def : SIN_PAT <SIN_r700>;
1572   def : COS_PAT <COS_r700>;
1573 }
1574
1575 //===----------------------------------------------------------------------===//
1576 // Evergreen Only instructions
1577 //===----------------------------------------------------------------------===//
1578
1579 let Predicates = [isEG] in {
1580
1581 def RECIP_IEEE_eg : RECIP_IEEE_Common<0x86>;
1582 defm DIV_eg : DIV_Common<RECIP_IEEE_eg>;
1583
1584 def MULLO_INT_eg : MULLO_INT_Common<0x8F>;
1585 def MULHI_INT_eg : MULHI_INT_Common<0x90>;
1586 def MULLO_UINT_eg : MULLO_UINT_Common<0x91>;
1587 def MULHI_UINT_eg : MULHI_UINT_Common<0x92>;
1588 def RECIP_UINT_eg : RECIP_UINT_Common<0x94>;
1589 def RECIPSQRT_CLAMPED_eg : RECIPSQRT_CLAMPED_Common<0x87>;
1590 def EXP_IEEE_eg : EXP_IEEE_Common<0x81>;
1591 def LOG_IEEE_eg : LOG_IEEE_Common<0x83>;
1592 def RECIP_CLAMPED_eg : RECIP_CLAMPED_Common<0x84>;
1593 def RECIPSQRT_IEEE_eg : RECIPSQRT_IEEE_Common<0x89>;
1594 def SIN_eg : SIN_Common<0x8D>;
1595 def COS_eg : COS_Common<0x8E>;
1596
1597 def : POW_Common <LOG_IEEE_eg, EXP_IEEE_eg, MUL>;
1598 def : SIN_PAT <SIN_eg>;
1599 def : COS_PAT <COS_eg>;
1600 def : Pat<(fsqrt f32:$src), (MUL $src, (RECIPSQRT_CLAMPED_eg $src))>;
1601 } // End Predicates = [isEG]
1602
1603 //===----------------------------------------------------------------------===//
1604 // Evergreen / Cayman Instructions
1605 //===----------------------------------------------------------------------===//
1606
1607 let Predicates = [isEGorCayman] in {
1608
1609   // BFE_UINT - bit_extract, an optimization for mask and shift
1610   // Src0 = Input
1611   // Src1 = Offset
1612   // Src2 = Width
1613   //
1614   // bit_extract = (Input << (32 - Offset - Width)) >> (32 - Width)
1615   //
1616   // Example Usage:
1617   // (Offset, Width)
1618   //
1619   // (0, 8)           = (Input << 24) >> 24  = (Input &  0xff)       >> 0
1620   // (8, 8)           = (Input << 16) >> 24  = (Input &  0xffff)     >> 8
1621   // (16,8)           = (Input <<  8) >> 24  = (Input &  0xffffff)   >> 16
1622   // (24,8)           = (Input <<  0) >> 24  = (Input &  0xffffffff) >> 24
1623   def BFE_UINT_eg : R600_3OP <0x4, "BFE_UINT",
1624     [(set i32:$dst, (int_AMDIL_bit_extract_u32 i32:$src0, i32:$src1,
1625                                                i32:$src2))],
1626     VecALU
1627   >;
1628   def : BFEPattern <BFE_UINT_eg>;
1629
1630   def BFI_INT_eg : R600_3OP <0x06, "BFI_INT", [], VecALU>;
1631   defm : BFIPatterns <BFI_INT_eg>;
1632
1633   def BIT_ALIGN_INT_eg : R600_3OP <0xC, "BIT_ALIGN_INT", [], VecALU>;
1634   def : ROTRPattern <BIT_ALIGN_INT_eg>;
1635
1636   def MULADD_eg : MULADD_Common<0x14>;
1637   def MULADD_IEEE_eg : MULADD_IEEE_Common<0x18>;
1638   def ASHR_eg : ASHR_Common<0x15>;
1639   def LSHR_eg : LSHR_Common<0x16>;
1640   def LSHL_eg : LSHL_Common<0x17>;
1641   def CNDE_eg : CNDE_Common<0x19>;
1642   def CNDGT_eg : CNDGT_Common<0x1A>;
1643   def CNDGE_eg : CNDGE_Common<0x1B>;
1644   def MUL_LIT_eg : MUL_LIT_Common<0x1F>;
1645   def LOG_CLAMPED_eg : LOG_CLAMPED_Common<0x82>;
1646   def DOT4_eg : DOT4_Common<0xBE>;
1647   defm CUBE_eg : CUBE_Common<0xC0>;
1648
1649 let hasSideEffects = 1 in {
1650   def MOVA_INT_eg : R600_1OP <0xCC, "MOVA_INT", []>;
1651 }
1652
1653   def TGSI_LIT_Z_eg : TGSI_LIT_Z_Common<MUL_LIT_eg, LOG_CLAMPED_eg, EXP_IEEE_eg>;
1654
1655   def FLT_TO_INT_eg : FLT_TO_INT_Common<0x50> {
1656     let Pattern = [];
1657   }
1658
1659   def INT_TO_FLT_eg : INT_TO_FLT_Common<0x9B>;
1660
1661   def FLT_TO_UINT_eg : FLT_TO_UINT_Common<0x9A> {
1662     let Pattern = [];
1663   }
1664
1665   def UINT_TO_FLT_eg : UINT_TO_FLT_Common<0x9C>;
1666
1667   // TRUNC is used for the FLT_TO_INT instructions to work around a
1668   // perceived problem where the rounding modes are applied differently
1669   // depending on the instruction and the slot they are in.
1670   // See:
1671   // https://bugs.freedesktop.org/show_bug.cgi?id=50232
1672   // Mesa commit: a1a0974401c467cb86ef818f22df67c21774a38c
1673   //
1674   // XXX: Lowering SELECT_CC will sometimes generate fp_to_[su]int nodes,
1675   // which do not need to be truncated since the fp values are 0.0f or 1.0f.
1676   // We should look into handling these cases separately.
1677   def : Pat<(fp_to_sint f32:$src0), (FLT_TO_INT_eg (TRUNC $src0))>;
1678
1679   def : Pat<(fp_to_uint f32:$src0), (FLT_TO_UINT_eg (TRUNC $src0))>;
1680
1681   // SHA-256 Patterns
1682   def : SHA256MaPattern <BFI_INT_eg, XOR_INT>;
1683
1684   def EG_ExportSwz : ExportSwzInst {
1685     let Word1{19-16} = 0; // BURST_COUNT
1686     let Word1{20} = 1; // VALID_PIXEL_MODE
1687     let Word1{21} = eop;
1688     let Word1{29-22} = inst;
1689     let Word1{30} = 0; // MARK
1690     let Word1{31} = 1; // BARRIER
1691   }
1692   defm : ExportPattern<EG_ExportSwz, 83>;
1693
1694   def EG_ExportBuf : ExportBufInst {
1695     let Word1{19-16} = 0; // BURST_COUNT
1696     let Word1{20} = 1; // VALID_PIXEL_MODE
1697     let Word1{21} = eop;
1698     let Word1{29-22} = inst;
1699     let Word1{30} = 0; // MARK
1700     let Word1{31} = 1; // BARRIER
1701   }
1702   defm : SteamOutputExportPattern<EG_ExportBuf, 0x40, 0x41, 0x42, 0x43>;
1703
1704   def CF_TC_EG : CF_CLAUSE_EG<1, (ins i32imm:$ADDR, i32imm:$COUNT),
1705   "TEX $COUNT @$ADDR"> {
1706     let POP_COUNT = 0;
1707   }
1708   def CF_VC_EG : CF_CLAUSE_EG<2, (ins i32imm:$ADDR, i32imm:$COUNT),
1709   "VTX $COUNT @$ADDR"> {
1710     let POP_COUNT = 0;
1711   }
1712   def WHILE_LOOP_EG : CF_CLAUSE_EG<6, (ins i32imm:$ADDR),
1713   "LOOP_START_DX10 @$ADDR"> {
1714     let POP_COUNT = 0;
1715     let COUNT = 0;
1716   }
1717   def END_LOOP_EG : CF_CLAUSE_EG<5, (ins i32imm:$ADDR), "END_LOOP @$ADDR"> {
1718     let POP_COUNT = 0;
1719     let COUNT = 0;
1720   }
1721   def LOOP_BREAK_EG : CF_CLAUSE_EG<9, (ins i32imm:$ADDR),
1722   "LOOP_BREAK @$ADDR"> {
1723     let POP_COUNT = 0;
1724     let COUNT = 0;
1725   }
1726   def CF_CONTINUE_EG : CF_CLAUSE_EG<8, (ins i32imm:$ADDR),
1727   "CONTINUE @$ADDR"> {
1728     let POP_COUNT = 0;
1729     let COUNT = 0;
1730   }
1731   def CF_JUMP_EG : CF_CLAUSE_EG<10, (ins i32imm:$ADDR, i32imm:$POP_COUNT),
1732   "JUMP @$ADDR POP:$POP_COUNT"> {
1733     let COUNT = 0;
1734   }
1735   def CF_ELSE_EG : CF_CLAUSE_EG<13, (ins i32imm:$ADDR, i32imm:$POP_COUNT),
1736   "ELSE @$ADDR POP:$POP_COUNT"> {
1737     let COUNT = 0;
1738   }
1739   def CF_CALL_FS_EG : CF_CLAUSE_EG<19, (ins), "CALL_FS"> {
1740     let ADDR = 0;
1741     let COUNT = 0;
1742     let POP_COUNT = 0;
1743   }
1744   def POP_EG : CF_CLAUSE_EG<14, (ins i32imm:$ADDR, i32imm:$POP_COUNT),
1745   "POP @$ADDR POP:$POP_COUNT"> {
1746     let COUNT = 0;
1747   }
1748   def CF_END_EG :  CF_CLAUSE_EG<0, (ins), "CF_END"> {
1749     let COUNT = 0;
1750     let POP_COUNT = 0;
1751     let ADDR = 0;
1752     let END_OF_PROGRAM = 1;
1753   }
1754
1755 //===----------------------------------------------------------------------===//
1756 // Memory read/write instructions
1757 //===----------------------------------------------------------------------===//
1758 let usesCustomInserter = 1 in {
1759
1760 class RAT_WRITE_CACHELESS_eg <dag ins, bits<4> comp_mask, string name,
1761                               list<dag> pattern>
1762     : EG_CF_RAT <0x57, 0x2, 0, (outs), ins, name, pattern> {
1763   let RIM         = 0;
1764   // XXX: Have a separate instruction for non-indexed writes.
1765   let TYPE        = 1;
1766   let RW_REL      = 0;
1767   let ELEM_SIZE   = 0;
1768
1769   let ARRAY_SIZE  = 0;
1770   let COMP_MASK   = comp_mask;
1771   let BURST_COUNT = 0;
1772   let VPM         = 0;
1773   let MARK        = 0;
1774   let BARRIER     = 1;
1775 }
1776
1777 } // End usesCustomInserter = 1
1778
1779 // 32-bit store
1780 def RAT_WRITE_CACHELESS_32_eg : RAT_WRITE_CACHELESS_eg <
1781   (ins R600_TReg32_X:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1782   0x1, "RAT_WRITE_CACHELESS_32_eg $rw_gpr, $index_gpr, $eop",
1783   [(global_store i32:$rw_gpr, i32:$index_gpr)]
1784 >;
1785
1786 //128-bit store
1787 def RAT_WRITE_CACHELESS_128_eg : RAT_WRITE_CACHELESS_eg <
1788   (ins R600_Reg128:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1789   0xf, "RAT_WRITE_CACHELESS_128 $rw_gpr.XYZW, $index_gpr, $eop",
1790   [(global_store v4i32:$rw_gpr, i32:$index_gpr)]
1791 >;
1792
1793 class VTX_READ_eg <string name, bits<8> buffer_id, dag outs, list<dag> pattern>
1794     : InstR600ISA <outs, (ins MEMxi:$ptr), name, pattern>,
1795       VTX_WORD1_GPR, VTX_WORD0 {
1796
1797   // Static fields
1798   let VC_INST = 0;
1799   let FETCH_TYPE = 2;
1800   let FETCH_WHOLE_QUAD = 0;
1801   let BUFFER_ID = buffer_id;
1802   let SRC_REL = 0;
1803   // XXX: We can infer this field based on the SRC_GPR.  This would allow us
1804   // to store vertex addresses in any channel, not just X.
1805   let SRC_SEL_X = 0;
1806   let DST_REL = 0;
1807   // The docs say that if this bit is set, then DATA_FORMAT, NUM_FORMAT_ALL,
1808   // FORMAT_COMP_ALL, SRF_MODE_ALL, and ENDIAN_SWAP fields will be ignored,
1809   // however, based on my testing if USE_CONST_FIELDS is set, then all
1810   // these fields need to be set to 0.
1811   let USE_CONST_FIELDS = 0;
1812   let NUM_FORMAT_ALL = 1;
1813   let FORMAT_COMP_ALL = 0;
1814   let SRF_MODE_ALL = 0;
1815
1816   let Inst{31-0} = Word0;
1817   let Inst{63-32} = Word1;
1818   // LLVM can only encode 64-bit instructions, so these fields are manually
1819   // encoded in R600CodeEmitter
1820   //
1821   // bits<16> OFFSET;
1822   // bits<2>  ENDIAN_SWAP = 0;
1823   // bits<1>  CONST_BUF_NO_STRIDE = 0;
1824   // bits<1>  MEGA_FETCH = 0;
1825   // bits<1>  ALT_CONST = 0;
1826   // bits<2>  BUFFER_INDEX_MODE = 0;
1827
1828
1829
1830   // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1831   // is done in R600CodeEmitter
1832   //
1833   // Inst{79-64} = OFFSET;
1834   // Inst{81-80} = ENDIAN_SWAP;
1835   // Inst{82}    = CONST_BUF_NO_STRIDE;
1836   // Inst{83}    = MEGA_FETCH;
1837   // Inst{84}    = ALT_CONST;
1838   // Inst{86-85} = BUFFER_INDEX_MODE;
1839   // Inst{95-86} = 0; Reserved
1840
1841   // VTX_WORD3 (Padding)
1842   //
1843   // Inst{127-96} = 0;
1844
1845   let VTXInst = 1;
1846 }
1847
1848 class VTX_READ_8_eg <bits<8> buffer_id, list<dag> pattern>
1849     : VTX_READ_eg <"VTX_READ_8 $dst, $ptr", buffer_id, (outs R600_TReg32_X:$dst),
1850                    pattern> {
1851
1852   let MEGA_FETCH_COUNT = 1;
1853   let DST_SEL_X = 0;
1854   let DST_SEL_Y = 7;   // Masked
1855   let DST_SEL_Z = 7;   // Masked
1856   let DST_SEL_W = 7;   // Masked
1857   let DATA_FORMAT = 1; // FMT_8
1858 }
1859
1860 class VTX_READ_16_eg <bits<8> buffer_id, list<dag> pattern>
1861     : VTX_READ_eg <"VTX_READ_16 $dst, $ptr", buffer_id, (outs R600_TReg32_X:$dst),
1862                     pattern> {
1863   let MEGA_FETCH_COUNT = 2;
1864   let DST_SEL_X = 0;
1865   let DST_SEL_Y = 7;   // Masked
1866   let DST_SEL_Z = 7;   // Masked
1867   let DST_SEL_W = 7;   // Masked
1868   let DATA_FORMAT = 5; // FMT_16
1869
1870 }
1871
1872 class VTX_READ_32_eg <bits<8> buffer_id, list<dag> pattern>
1873     : VTX_READ_eg <"VTX_READ_32 $dst, $ptr", buffer_id, (outs R600_TReg32_X:$dst),
1874                    pattern> {
1875
1876   let MEGA_FETCH_COUNT = 4;
1877   let DST_SEL_X        = 0;
1878   let DST_SEL_Y        = 7;   // Masked
1879   let DST_SEL_Z        = 7;   // Masked
1880   let DST_SEL_W        = 7;   // Masked
1881   let DATA_FORMAT      = 0xD; // COLOR_32
1882
1883   // This is not really necessary, but there were some GPU hangs that appeared
1884   // to be caused by ALU instructions in the next instruction group that wrote
1885   // to the $ptr registers of the VTX_READ.
1886   // e.g.
1887   // %T3_X<def> = VTX_READ_PARAM_32_eg %T2_X<kill>, 24
1888   // %T2_X<def> = MOV %ZERO
1889   //Adding this constraint prevents this from happening.
1890   let Constraints = "$ptr.ptr = $dst";
1891 }
1892
1893 class VTX_READ_128_eg <bits<8> buffer_id, list<dag> pattern>
1894     : VTX_READ_eg <"VTX_READ_128 $dst.XYZW, $ptr", buffer_id, (outs R600_Reg128:$dst),
1895                    pattern> {
1896
1897   let MEGA_FETCH_COUNT = 16;
1898   let DST_SEL_X        =  0;
1899   let DST_SEL_Y        =  1;
1900   let DST_SEL_Z        =  2;
1901   let DST_SEL_W        =  3;
1902   let DATA_FORMAT      =  0x22; // COLOR_32_32_32_32
1903
1904   // XXX: Need to force VTX_READ_128 instructions to write to the same register
1905   // that holds its buffer address to avoid potential hangs.  We can't use
1906   // the same constraint as VTX_READ_32_eg, because the $ptr.ptr and $dst
1907   // registers are different sizes.
1908 }
1909
1910 //===----------------------------------------------------------------------===//
1911 // VTX Read from parameter memory space
1912 //===----------------------------------------------------------------------===//
1913
1914 def VTX_READ_PARAM_8_eg : VTX_READ_8_eg <0,
1915   [(set i32:$dst, (load_param_zexti8 ADDRVTX_READ:$ptr))]
1916 >;
1917
1918 def VTX_READ_PARAM_16_eg : VTX_READ_16_eg <0,
1919   [(set i32:$dst, (load_param_zexti16 ADDRVTX_READ:$ptr))]
1920 >;
1921
1922 def VTX_READ_PARAM_32_eg : VTX_READ_32_eg <0,
1923   [(set i32:$dst, (load_param ADDRVTX_READ:$ptr))]
1924 >;
1925
1926 def VTX_READ_PARAM_128_eg : VTX_READ_128_eg <0,
1927   [(set v4i32:$dst, (load_param ADDRVTX_READ:$ptr))]
1928 >;
1929
1930 //===----------------------------------------------------------------------===//
1931 // VTX Read from global memory space
1932 //===----------------------------------------------------------------------===//
1933
1934 // 8-bit reads
1935 def VTX_READ_GLOBAL_8_eg : VTX_READ_8_eg <1,
1936   [(set i32:$dst, (zextloadi8_global ADDRVTX_READ:$ptr))]
1937 >;
1938
1939 // 32-bit reads
1940 def VTX_READ_GLOBAL_32_eg : VTX_READ_32_eg <1,
1941   [(set i32:$dst, (global_load ADDRVTX_READ:$ptr))]
1942 >;
1943
1944 // 128-bit reads
1945 def VTX_READ_GLOBAL_128_eg : VTX_READ_128_eg <1,
1946   [(set v4i32:$dst, (global_load ADDRVTX_READ:$ptr))]
1947 >;
1948
1949 //===----------------------------------------------------------------------===//
1950 // Constant Loads
1951 // XXX: We are currently storing all constants in the global address space.
1952 //===----------------------------------------------------------------------===//
1953
1954 def CONSTANT_LOAD_eg : VTX_READ_32_eg <1,
1955   [(set i32:$dst, (constant_load ADDRVTX_READ:$ptr))]
1956 >;
1957
1958 }
1959
1960 //===----------------------------------------------------------------------===//
1961 // Regist loads and stores - for indirect addressing
1962 //===----------------------------------------------------------------------===//
1963
1964 defm R600_ : RegisterLoadStore <R600_Reg32, FRAMEri, ADDRIndirect>;
1965
1966 let Predicates = [isCayman] in {
1967
1968 let isVector = 1 in {
1969
1970 def RECIP_IEEE_cm : RECIP_IEEE_Common<0x86>;
1971
1972 def MULLO_INT_cm : MULLO_INT_Common<0x8F>;
1973 def MULHI_INT_cm : MULHI_INT_Common<0x90>;
1974 def MULLO_UINT_cm : MULLO_UINT_Common<0x91>;
1975 def MULHI_UINT_cm : MULHI_UINT_Common<0x92>;
1976 def RECIPSQRT_CLAMPED_cm : RECIPSQRT_CLAMPED_Common<0x87>;
1977 def EXP_IEEE_cm : EXP_IEEE_Common<0x81>;
1978 def LOG_IEEE_cm : LOG_IEEE_Common<0x83>;
1979 def RECIP_CLAMPED_cm : RECIP_CLAMPED_Common<0x84>;
1980 def RECIPSQRT_IEEE_cm : RECIPSQRT_IEEE_Common<0x89>;
1981 def SIN_cm : SIN_Common<0x8D>;
1982 def COS_cm : COS_Common<0x8E>;
1983 } // End isVector = 1
1984
1985 def : POW_Common <LOG_IEEE_cm, EXP_IEEE_cm, MUL>;
1986 def : SIN_PAT <SIN_cm>;
1987 def : COS_PAT <COS_cm>;
1988
1989 defm DIV_cm : DIV_Common<RECIP_IEEE_cm>;
1990
1991 // RECIP_UINT emulation for Cayman
1992 // The multiplication scales from [0,1] to the unsigned integer range
1993 def : Pat <
1994   (AMDGPUurecip i32:$src0),
1995   (FLT_TO_UINT_eg (MUL_IEEE (RECIP_IEEE_cm (UINT_TO_FLT_eg $src0)),
1996                             (MOV_IMM_I32 CONST.FP_UINT_MAX_PLUS_1)))
1997 >;
1998
1999   def CF_END_CM : CF_CLAUSE_EG<32, (ins), "CF_END"> {
2000     let ADDR = 0;
2001     let POP_COUNT = 0;
2002     let COUNT = 0;
2003   }
2004
2005 def : Pat<(fsqrt f32:$src), (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_cm $src))>;
2006
2007 } // End isCayman
2008
2009 //===----------------------------------------------------------------------===//
2010 // Branch Instructions
2011 //===----------------------------------------------------------------------===//
2012
2013
2014 def IF_PREDICATE_SET  : ILFormat<(outs), (ins GPRI32:$src),
2015   "IF_PREDICATE_SET $src", []>;
2016
2017 def PREDICATED_BREAK : ILFormat<(outs), (ins GPRI32:$src),
2018   "PREDICATED_BREAK $src", []>;
2019
2020 //===----------------------------------------------------------------------===//
2021 // Pseudo instructions
2022 //===----------------------------------------------------------------------===//
2023
2024 let isPseudo = 1 in {
2025
2026 def PRED_X : InstR600 <
2027   (outs R600_Predicate_Bit:$dst),
2028   (ins R600_Reg32:$src0, i32imm:$src1, i32imm:$flags),
2029   "", [], NullALU> {
2030   let FlagOperandIdx = 3;
2031 }
2032
2033 let isTerminator = 1, isBranch = 1 in {
2034 def JUMP_COND : InstR600 <
2035           (outs),
2036           (ins brtarget:$target, R600_Predicate_Bit:$p),
2037           "JUMP $target ($p)",
2038           [], AnyALU
2039   >;
2040
2041 def JUMP : InstR600 <
2042           (outs),
2043           (ins brtarget:$target),
2044           "JUMP $target",
2045           [], AnyALU
2046   >
2047 {
2048   let isPredicable = 1;
2049   let isBarrier = 1;
2050 }
2051
2052 }  // End isTerminator = 1, isBranch = 1
2053
2054 let usesCustomInserter = 1 in {
2055
2056 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in {
2057
2058 def MASK_WRITE : AMDGPUShaderInst <
2059     (outs),
2060     (ins R600_Reg32:$src),
2061     "MASK_WRITE $src",
2062     []
2063 >;
2064
2065 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 1
2066
2067
2068 def TXD: InstR600 <
2069   (outs R600_Reg128:$dst),
2070   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2,
2071        i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
2072   "TXD $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
2073   [(set v4f32:$dst, (int_AMDGPU_txd v4f32:$src0, v4f32:$src1, v4f32:$src2,
2074                      imm:$resourceId, imm:$samplerId, imm:$textureTarget))],
2075   NullALU > {
2076   let TEXInst = 1;
2077 }
2078
2079 def TXD_SHADOW: InstR600 <
2080   (outs R600_Reg128:$dst),
2081   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2,
2082        i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
2083   "TXD_SHADOW $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
2084   [(set v4f32:$dst, (int_AMDGPU_txd v4f32:$src0, v4f32:$src1, v4f32:$src2,
2085         imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))],
2086    NullALU
2087 > {
2088   let TEXInst = 1;
2089 }
2090 } // End isPseudo = 1
2091 } // End usesCustomInserter = 1
2092
2093 def CLAMP_R600 :  CLAMP <R600_Reg32>;
2094 def FABS_R600 : FABS<R600_Reg32>;
2095 def FNEG_R600 : FNEG<R600_Reg32>;
2096
2097 //===---------------------------------------------------------------------===//
2098 // Return instruction
2099 //===---------------------------------------------------------------------===//
2100 let isTerminator = 1, isReturn = 1, hasCtrlDep = 1,
2101     usesCustomInserter = 1 in {
2102   def RETURN          : ILFormat<(outs), (ins variable_ops),
2103       "RETURN", [(IL_retflag)]>;
2104 }
2105
2106
2107 //===----------------------------------------------------------------------===//
2108 // Constant Buffer Addressing Support
2109 //===----------------------------------------------------------------------===//
2110
2111 let usesCustomInserter = 1, isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"  in {
2112 def CONST_COPY : Instruction {
2113   let OutOperandList = (outs R600_Reg32:$dst);
2114   let InOperandList = (ins i32imm:$src);
2115   let Pattern =
2116       [(set R600_Reg32:$dst, (CONST_ADDRESS ADDRGA_CONST_OFFSET:$src))];
2117   let AsmString = "CONST_COPY";
2118   let neverHasSideEffects = 1;
2119   let isAsCheapAsAMove = 1;
2120   let Itinerary = NullALU;
2121 }
2122 } // end usesCustomInserter = 1, isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"
2123
2124 def TEX_VTX_CONSTBUF :
2125   InstR600ISA <(outs R600_Reg128:$dst), (ins MEMxi:$ptr, i32imm:$BUFFER_ID), "VTX_READ_eg $dst, $ptr",
2126       [(set v4i32:$dst, (CONST_ADDRESS ADDRGA_VAR_OFFSET:$ptr, (i32 imm:$BUFFER_ID)))]>,
2127   VTX_WORD1_GPR, VTX_WORD0 {
2128
2129   let VC_INST = 0;
2130   let FETCH_TYPE = 2;
2131   let FETCH_WHOLE_QUAD = 0;
2132   let SRC_REL = 0;
2133   let SRC_SEL_X = 0;
2134   let DST_REL = 0;
2135   let USE_CONST_FIELDS = 0;
2136   let NUM_FORMAT_ALL = 2;
2137   let FORMAT_COMP_ALL = 1;
2138   let SRF_MODE_ALL = 1;
2139   let MEGA_FETCH_COUNT = 16;
2140   let DST_SEL_X        = 0;
2141   let DST_SEL_Y        = 1;
2142   let DST_SEL_Z        = 2;
2143   let DST_SEL_W        = 3;
2144   let DATA_FORMAT      = 35;
2145
2146   let Inst{31-0} = Word0;
2147   let Inst{63-32} = Word1;
2148
2149 // LLVM can only encode 64-bit instructions, so these fields are manually
2150 // encoded in R600CodeEmitter
2151 //
2152 // bits<16> OFFSET;
2153 // bits<2>  ENDIAN_SWAP = 0;
2154 // bits<1>  CONST_BUF_NO_STRIDE = 0;
2155 // bits<1>  MEGA_FETCH = 0;
2156 // bits<1>  ALT_CONST = 0;
2157 // bits<2>  BUFFER_INDEX_MODE = 0;
2158
2159
2160
2161 // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
2162 // is done in R600CodeEmitter
2163 //
2164 // Inst{79-64} = OFFSET;
2165 // Inst{81-80} = ENDIAN_SWAP;
2166 // Inst{82}    = CONST_BUF_NO_STRIDE;
2167 // Inst{83}    = MEGA_FETCH;
2168 // Inst{84}    = ALT_CONST;
2169 // Inst{86-85} = BUFFER_INDEX_MODE;
2170 // Inst{95-86} = 0; Reserved
2171
2172 // VTX_WORD3 (Padding)
2173 //
2174 // Inst{127-96} = 0;
2175   let VTXInst = 1;
2176 }
2177
2178 def TEX_VTX_TEXBUF:
2179   InstR600ISA <(outs R600_Reg128:$dst), (ins MEMxi:$ptr, i32imm:$BUFFER_ID), "TEX_VTX_EXPLICIT_READ $dst, $ptr",
2180       [(set v4f32:$dst, (int_R600_load_texbuf ADDRGA_VAR_OFFSET:$ptr, imm:$BUFFER_ID))]>,
2181 VTX_WORD1_GPR, VTX_WORD0 {
2182
2183 let VC_INST = 0;
2184 let FETCH_TYPE = 2;
2185 let FETCH_WHOLE_QUAD = 0;
2186 let SRC_REL = 0;
2187 let SRC_SEL_X = 0;
2188 let DST_REL = 0;
2189 let USE_CONST_FIELDS = 1;
2190 let NUM_FORMAT_ALL = 0;
2191 let FORMAT_COMP_ALL = 0;
2192 let SRF_MODE_ALL = 1;
2193 let MEGA_FETCH_COUNT = 16;
2194 let DST_SEL_X        = 0;
2195 let DST_SEL_Y        = 1;
2196 let DST_SEL_Z        = 2;
2197 let DST_SEL_W        = 3;
2198 let DATA_FORMAT      = 0;
2199
2200 let Inst{31-0} = Word0;
2201 let Inst{63-32} = Word1;
2202
2203 // LLVM can only encode 64-bit instructions, so these fields are manually
2204 // encoded in R600CodeEmitter
2205 //
2206 // bits<16> OFFSET;
2207 // bits<2>  ENDIAN_SWAP = 0;
2208 // bits<1>  CONST_BUF_NO_STRIDE = 0;
2209 // bits<1>  MEGA_FETCH = 0;
2210 // bits<1>  ALT_CONST = 0;
2211 // bits<2>  BUFFER_INDEX_MODE = 0;
2212
2213
2214
2215 // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
2216 // is done in R600CodeEmitter
2217 //
2218 // Inst{79-64} = OFFSET;
2219 // Inst{81-80} = ENDIAN_SWAP;
2220 // Inst{82}    = CONST_BUF_NO_STRIDE;
2221 // Inst{83}    = MEGA_FETCH;
2222 // Inst{84}    = ALT_CONST;
2223 // Inst{86-85} = BUFFER_INDEX_MODE;
2224 // Inst{95-86} = 0; Reserved
2225
2226 // VTX_WORD3 (Padding)
2227 //
2228 // Inst{127-96} = 0;
2229   let VTXInst = 1;
2230 }
2231
2232
2233
2234 //===--------------------------------------------------------------------===//
2235 // Instructions support
2236 //===--------------------------------------------------------------------===//
2237 //===---------------------------------------------------------------------===//
2238 // Custom Inserter for Branches and returns, this eventually will be a
2239 // seperate pass
2240 //===---------------------------------------------------------------------===//
2241 let isTerminator = 1, usesCustomInserter = 1, isBranch = 1, isBarrier = 1 in {
2242   def BRANCH : ILFormat<(outs), (ins brtarget:$target),
2243       "; Pseudo unconditional branch instruction",
2244       [(br bb:$target)]>;
2245   defm BRANCH_COND : BranchConditional<IL_brcond>;
2246 }
2247
2248 //===---------------------------------------------------------------------===//
2249 // Flow and Program control Instructions
2250 //===---------------------------------------------------------------------===//
2251 let isTerminator=1 in {
2252   def SWITCH      : ILFormat< (outs), (ins GPRI32:$src),
2253   !strconcat("SWITCH", " $src"), []>;
2254   def CASE        : ILFormat< (outs), (ins GPRI32:$src),
2255       !strconcat("CASE", " $src"), []>;
2256   def BREAK       : ILFormat< (outs), (ins),
2257       "BREAK", []>;
2258   def CONTINUE    : ILFormat< (outs), (ins),
2259       "CONTINUE", []>;
2260   def DEFAULT     : ILFormat< (outs), (ins),
2261       "DEFAULT", []>;
2262   def ELSE        : ILFormat< (outs), (ins),
2263       "ELSE", []>;
2264   def ENDSWITCH   : ILFormat< (outs), (ins),
2265       "ENDSWITCH", []>;
2266   def ENDMAIN     : ILFormat< (outs), (ins),
2267       "ENDMAIN", []>;
2268   def END         : ILFormat< (outs), (ins),
2269       "END", []>;
2270   def ENDFUNC     : ILFormat< (outs), (ins),
2271       "ENDFUNC", []>;
2272   def ENDIF       : ILFormat< (outs), (ins),
2273       "ENDIF", []>;
2274   def WHILELOOP   : ILFormat< (outs), (ins),
2275       "WHILE", []>;
2276   def ENDLOOP     : ILFormat< (outs), (ins),
2277       "ENDLOOP", []>;
2278   def FUNC        : ILFormat< (outs), (ins),
2279       "FUNC", []>;
2280   def RETDYN      : ILFormat< (outs), (ins),
2281       "RET_DYN", []>;
2282   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2283   defm IF_LOGICALNZ  : BranchInstr<"IF_LOGICALNZ">;
2284   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2285   defm IF_LOGICALZ   : BranchInstr<"IF_LOGICALZ">;
2286   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2287   defm BREAK_LOGICALNZ : BranchInstr<"BREAK_LOGICALNZ">;
2288   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2289   defm BREAK_LOGICALZ : BranchInstr<"BREAK_LOGICALZ">;
2290   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2291   defm CONTINUE_LOGICALNZ : BranchInstr<"CONTINUE_LOGICALNZ">;
2292   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2293   defm CONTINUE_LOGICALZ : BranchInstr<"CONTINUE_LOGICALZ">;
2294   defm IFC         : BranchInstr2<"IFC">;
2295   defm BREAKC      : BranchInstr2<"BREAKC">;
2296   defm CONTINUEC   : BranchInstr2<"CONTINUEC">;
2297 }
2298
2299 //===----------------------------------------------------------------------===//
2300 // ISel Patterns
2301 //===----------------------------------------------------------------------===//
2302
2303 // CND*_INT Pattterns for f32 True / False values
2304
2305 class CND_INT_f32 <InstR600 cnd, CondCode cc> : Pat <
2306   (selectcc i32:$src0, 0, f32:$src1, f32:$src2, cc),
2307   (cnd $src0, $src1, $src2)
2308 >;
2309
2310 def : CND_INT_f32 <CNDE_INT,  SETEQ>;
2311 def : CND_INT_f32 <CNDGT_INT, SETGT>;
2312 def : CND_INT_f32 <CNDGE_INT, SETGE>;
2313
2314 //CNDGE_INT extra pattern
2315 def : Pat <
2316   (selectcc i32:$src0, -1, i32:$src1, i32:$src2, COND_GT),
2317   (CNDGE_INT $src0, $src1, $src2)
2318 >;
2319
2320 // KIL Patterns
2321 def KILP : Pat <
2322   (int_AMDGPU_kilp),
2323   (MASK_WRITE (KILLGT (f32 ONE), (f32 ZERO)))
2324 >;
2325
2326 def KIL : Pat <
2327   (int_AMDGPU_kill f32:$src0),
2328   (MASK_WRITE (KILLGT (f32 ZERO), $src0))
2329 >;
2330
2331 // SGT Reverse args
2332 def : Pat <
2333   (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, COND_LT),
2334   (SGT $src1, $src0)
2335 >;
2336
2337 // SGE Reverse args
2338 def : Pat <
2339   (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, COND_LE),
2340   (SGE $src1, $src0)
2341 >;
2342
2343 // SETGT_DX10 reverse args
2344 def : Pat <
2345   (selectcc f32:$src0, f32:$src1, -1, 0, COND_LT),
2346   (SETGT_DX10 $src1, $src0)
2347 >;
2348
2349 // SETGE_DX10 reverse args
2350 def : Pat <
2351   (selectcc f32:$src0, f32:$src1, -1, 0, COND_LE),
2352   (SETGE_DX10 $src1, $src0)
2353 >;
2354
2355 // SETGT_INT reverse args
2356 def : Pat <
2357   (selectcc i32:$src0, i32:$src1, -1, 0, SETLT),
2358   (SETGT_INT $src1, $src0)
2359 >;
2360
2361 // SETGE_INT reverse args
2362 def : Pat <
2363   (selectcc i32:$src0, i32:$src1, -1, 0, SETLE),
2364   (SETGE_INT $src1, $src0)
2365 >;
2366
2367 // SETGT_UINT reverse args
2368 def : Pat <
2369   (selectcc i32:$src0, i32:$src1, -1, 0, SETULT),
2370   (SETGT_UINT $src1, $src0)
2371 >;
2372
2373 // SETGE_UINT reverse args
2374 def : Pat <
2375   (selectcc i32:$src0, i32:$src1, -1, 0, SETULE),
2376   (SETGE_UINT $src1, $src0)
2377 >;
2378
2379 // The next two patterns are special cases for handling 'true if ordered' and
2380 // 'true if unordered' conditionals.  The assumption here is that the behavior of
2381 // SETE and SNE conforms to the Direct3D 10 rules for floating point values
2382 // described here:
2383 // http://msdn.microsoft.com/en-us/library/windows/desktop/cc308050.aspx#alpha_32_bit
2384 // We assume that  SETE returns false when one of the operands is NAN and
2385 // SNE returns true when on of the operands is NAN
2386
2387 //SETE - 'true if ordered'
2388 def : Pat <
2389   (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, SETO),
2390   (SETE $src0, $src1)
2391 >;
2392
2393 //SETE_DX10 - 'true if ordered'
2394 def : Pat <
2395   (selectcc f32:$src0, f32:$src1, -1, 0, SETO),
2396   (SETE_DX10 $src0, $src1)
2397 >;
2398
2399 //SNE - 'true if unordered'
2400 def : Pat <
2401   (selectcc f32:$src0, f32:$src1, FP_ONE, FP_ZERO, SETUO),
2402   (SNE $src0, $src1)
2403 >;
2404
2405 //SETNE_DX10 - 'true if ordered'
2406 def : Pat <
2407   (selectcc f32:$src0, f32:$src1, -1, 0, SETUO),
2408   (SETNE_DX10 $src0, $src1)
2409 >;
2410
2411 def : Extract_Element <f32, v4f32, 0, sub0>;
2412 def : Extract_Element <f32, v4f32, 1, sub1>;
2413 def : Extract_Element <f32, v4f32, 2, sub2>;
2414 def : Extract_Element <f32, v4f32, 3, sub3>;
2415
2416 def : Insert_Element <f32, v4f32, 0, sub0>;
2417 def : Insert_Element <f32, v4f32, 1, sub1>;
2418 def : Insert_Element <f32, v4f32, 2, sub2>;
2419 def : Insert_Element <f32, v4f32, 3, sub3>;
2420
2421 def : Extract_Element <i32, v4i32, 0, sub0>;
2422 def : Extract_Element <i32, v4i32, 1, sub1>;
2423 def : Extract_Element <i32, v4i32, 2, sub2>;
2424 def : Extract_Element <i32, v4i32, 3, sub3>;
2425
2426 def : Insert_Element <i32, v4i32, 0, sub0>;
2427 def : Insert_Element <i32, v4i32, 1, sub1>;
2428 def : Insert_Element <i32, v4i32, 2, sub2>;
2429 def : Insert_Element <i32, v4i32, 3, sub3>;
2430
2431 def : Vector4_Build <v4f32, f32>;
2432 def : Vector4_Build <v4i32, i32>;
2433
2434 // bitconvert patterns
2435
2436 def : BitConvert <i32, f32, R600_Reg32>;
2437 def : BitConvert <f32, i32, R600_Reg32>;
2438 def : BitConvert <v4f32, v4i32, R600_Reg128>;
2439 def : BitConvert <v4i32, v4f32, R600_Reg128>;
2440
2441 // DWORDADDR pattern
2442 def : DwordAddrPat  <i32, R600_Reg32>;
2443
2444 } // End isR600toCayman Predicate