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