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