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