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 let usesCustomInserter = 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 def CF_ALU : ALU_CLAUSE<8, "ALU">;
 827 def CF_ALU_PUSH_BEFORE : ALU_CLAUSE<9, "ALU_PUSH_BEFORE">;
 828
 829 let Predicates = [isR600toCayman] in {
 830
 831 //===----------------------------------------------------------------------===//
 832 // Common Instructions R600, R700, Evergreen, Cayman
 833 //===----------------------------------------------------------------------===//
 834
 835 def ADD : R600_2OP_Helper <0x0, "ADD", fadd>;
 836 // Non-IEEE MUL: 0 * anything = 0
 837 def MUL : R600_2OP_Helper <0x1, "MUL NON-IEEE", int_AMDGPU_mul>;
 838 def MUL_IEEE : R600_2OP_Helper <0x2, "MUL_IEEE", fmul>;
 839 def MAX : R600_2OP_Helper <0x3, "MAX", AMDGPUfmax>;
 840 def MIN : R600_2OP_Helper <0x4, "MIN", AMDGPUfmin>;
 841
 842 // For the SET* instructions there is a naming conflict in TargetSelectionDAG.td,
 843 // so some of the instruction names don't match the asm string.
 844 // XXX: Use the defs in TargetSelectionDAG.td instead of intrinsics.
 845 def SETE : R600_2OP <
 846   0x08, "SETE",
 847   [(set R600_Reg32:$dst,
 848    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 849              COND_EQ))]
 850 >;
 851
 852 def SGT : R600_2OP <
 853   0x09, "SETGT",
 854   [(set R600_Reg32:$dst,
 855    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 856               COND_GT))]
 857 >;
 858
 859 def SGE : R600_2OP <
 860   0xA, "SETGE",
 861   [(set R600_Reg32:$dst,
 862    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 863               COND_GE))]
 864 >;
 865
 866 def SNE : R600_2OP <
 867   0xB, "SETNE",
 868   [(set R600_Reg32:$dst,
 869    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 870     COND_NE))]
 871 >;
 872
 873 def SETE_DX10 : R600_2OP <
 874   0xC, "SETE_DX10",
 875   [(set R600_Reg32:$dst,
 876    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, (i32 -1), (i32 0),
 877     COND_EQ))]
 878 >;
 879
 880 def SETGT_DX10 : R600_2OP <
 881   0xD, "SETGT_DX10",
 882   [(set R600_Reg32:$dst,
 883    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, (i32 -1), (i32 0),
 884     COND_GT))]
 885 >;
 886
 887 def SETGE_DX10 : R600_2OP <
 888   0xE, "SETGE_DX10",
 889   [(set R600_Reg32:$dst,
 890    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, (i32 -1), (i32 0),
 891     COND_GE))]
 892 >;
 893
 894 def SETNE_DX10 : R600_2OP <
 895   0xF, "SETNE_DX10",
 896   [(set R600_Reg32:$dst,
 897     (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, (i32 -1), (i32 0),
 898      COND_NE))]
 899 >;
 900
 901 def FRACT : R600_1OP_Helper <0x10, "FRACT", AMDGPUfract>;
 902 def TRUNC : R600_1OP_Helper <0x11, "TRUNC", int_AMDGPU_trunc>;
 903 def CEIL : R600_1OP_Helper <0x12, "CEIL", fceil>;
 904 def RNDNE : R600_1OP_Helper <0x13, "RNDNE", frint>;
 905 def FLOOR : R600_1OP_Helper <0x14, "FLOOR", ffloor>;
 906
 907 def MOV : R600_1OP <0x19, "MOV", []>;
 908
 909 let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1 in {
 910
 911 class MOV_IMM <ValueType vt, Operand immType> : AMDGPUInst <
 912   (outs R600_Reg32:$dst),
 913   (ins immType:$imm),
 914   "",
 915   []
 916 >;
 917
 918 } // end let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1
 919
 920 def MOV_IMM_I32 : MOV_IMM<i32, i32imm>;
 921 def : Pat <
 922   (imm:$val),
 923   (MOV_IMM_I32 imm:$val)
 924 >;
 925
 926 def MOV_IMM_F32 : MOV_IMM<f32, f32imm>;
 927 def : Pat <
 928   (fpimm:$val),
 929   (MOV_IMM_F32  fpimm:$val)
 930 >;
 931
 932 def PRED_SETE : R600_2OP <0x20, "PRED_SETE", []>;
 933 def PRED_SETGT : R600_2OP <0x21, "PRED_SETGT", []>;
 934 def PRED_SETGE : R600_2OP <0x22, "PRED_SETGE", []>;
 935 def PRED_SETNE : R600_2OP <0x23, "PRED_SETNE", []>;
 936
 937 let hasSideEffects = 1 in {
 938
 939 def KILLGT : R600_2OP <0x2D, "KILLGT", []>;
 940
 941 } // end hasSideEffects
 942
 943 def AND_INT : R600_2OP_Helper <0x30, "AND_INT", and>;
 944 def OR_INT : R600_2OP_Helper <0x31, "OR_INT", or>;
 945 def XOR_INT : R600_2OP_Helper <0x32, "XOR_INT", xor>;
 946 def NOT_INT : R600_1OP_Helper <0x33, "NOT_INT", not>;
 947 def ADD_INT : R600_2OP_Helper <0x34, "ADD_INT", add>;
 948 def SUB_INT : R600_2OP_Helper <0x35, "SUB_INT", sub>;
 949 def MAX_INT : R600_2OP_Helper <0x36, "MAX_INT", AMDGPUsmax>;
 950 def MIN_INT : R600_2OP_Helper <0x37, "MIN_INT", AMDGPUsmin>;
 951 def MAX_UINT : R600_2OP_Helper <0x38, "MAX_UINT", AMDGPUumax>;
 952 def MIN_UINT : R600_2OP_Helper <0x39, "MIN_UINT", AMDGPUumin>;
 953
 954 def SETE_INT : R600_2OP <
 955   0x3A, "SETE_INT",
 956   [(set (i32 R600_Reg32:$dst),
 957    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETEQ))]
 958 >;
 959
 960 def SETGT_INT : R600_2OP <
 961   0x3B, "SETGT_INT",
 962   [(set (i32 R600_Reg32:$dst),
 963    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETGT))]
 964 >;
 965
 966 def SETGE_INT : R600_2OP <
 967   0x3C, "SETGE_INT",
 968   [(set (i32 R600_Reg32:$dst),
 969    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETGE))]
 970 >;
 971
 972 def SETNE_INT : R600_2OP <
 973   0x3D, "SETNE_INT",
 974   [(set (i32 R600_Reg32:$dst),
 975    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETNE))]
 976 >;
 977
 978 def SETGT_UINT : R600_2OP <
 979   0x3E, "SETGT_UINT",
 980   [(set (i32 R600_Reg32:$dst),
 981    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUGT))]
 982 >;
 983
 984 def SETGE_UINT : R600_2OP <
 985   0x3F, "SETGE_UINT",
 986   [(set (i32 R600_Reg32:$dst),
 987     (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUGE))]
 988 >;
 989
 990 def PRED_SETE_INT : R600_2OP <0x42, "PRED_SETE_INT", []>;
 991 def PRED_SETGT_INT : R600_2OP <0x43, "PRED_SETGE_INT", []>;
 992 def PRED_SETGE_INT : R600_2OP <0x44, "PRED_SETGE_INT", []>;
 993 def PRED_SETNE_INT : R600_2OP <0x45, "PRED_SETNE_INT", []>;
 994
 995 def CNDE_INT : R600_3OP <
 996   0x1C, "CNDE_INT",
 997   [(set (i32 R600_Reg32:$dst),
 998    (selectcc (i32 R600_Reg32:$src0), 0,
 999        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
1000        COND_EQ))]
1001 >;
1002
1003 def CNDGE_INT : R600_3OP <
1004   0x1E, "CNDGE_INT",
1005   [(set (i32 R600_Reg32:$dst),
1006    (selectcc (i32 R600_Reg32:$src0), 0,
1007        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
1008        COND_GE))]
1009 >;
1010
1011 def CNDGT_INT : R600_3OP <
1012   0x1D, "CNDGT_INT",
1013   [(set (i32 R600_Reg32:$dst),
1014    (selectcc (i32 R600_Reg32:$src0), 0,
1015        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
1016        COND_GT))]
1017 >;
1018
1019 //===----------------------------------------------------------------------===//
1020 // Texture instructions
1021 //===----------------------------------------------------------------------===//
1022
1023 def TEX_LD : R600_TEX <
1024   0x03, "TEX_LD",
1025   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_txf R600_Reg128:$SRC_GPR,
1026       imm:$OFFSET_X, imm:$OFFSET_Y, imm:$OFFSET_Z, imm:$RESOURCE_ID,
1027       imm:$SAMPLER_ID, imm:$textureTarget))]
1028 > {
1029 let AsmString = "TEX_LD $DST_GPR, $SRC_GPR, $OFFSET_X, $OFFSET_Y, $OFFSET_Z,"
1030     "$RESOURCE_ID, $SAMPLER_ID, $textureTarget";
1031 let InOperandList = (ins R600_Reg128:$SRC_GPR, i32imm:$OFFSET_X,
1032     i32imm:$OFFSET_Y, i32imm:$OFFSET_Z, i32imm:$RESOURCE_ID, i32imm:$SAMPLER_ID,
1033     i32imm:$textureTarget);
1034 }
1035
1036 def TEX_GET_TEXTURE_RESINFO : R600_TEX <
1037   0x04, "TEX_GET_TEXTURE_RESINFO",
1038   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_txq R600_Reg128:$SRC_GPR,
1039       imm:$RESOURCE_ID, imm:$SAMPLER_ID, imm:$textureTarget))]
1040 >;
1041
1042 def TEX_GET_GRADIENTS_H : R600_TEX <
1043   0x07, "TEX_GET_GRADIENTS_H",
1044   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_ddx R600_Reg128:$SRC_GPR,
1045       imm:$RESOURCE_ID, imm:$SAMPLER_ID, imm:$textureTarget))]
1046 >;
1047
1048 def TEX_GET_GRADIENTS_V : R600_TEX <
1049   0x08, "TEX_GET_GRADIENTS_V",
1050   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_ddy R600_Reg128:$SRC_GPR,
1051       imm:$RESOURCE_ID, imm:$SAMPLER_ID, imm:$textureTarget))]
1052 >;
1053
1054 def TEX_SET_GRADIENTS_H : R600_TEX <
1055   0x0B, "TEX_SET_GRADIENTS_H",
1056   []
1057 >;
1058
1059 def TEX_SET_GRADIENTS_V : R600_TEX <
1060   0x0C, "TEX_SET_GRADIENTS_V",
1061   []
1062 >;
1063
1064 def TEX_SAMPLE : R600_TEX <
1065   0x10, "TEX_SAMPLE",
1066   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_tex R600_Reg128:$SRC_GPR,
1067       imm:$RESOURCE_ID, imm:$SAMPLER_ID, imm:$textureTarget))]
1068 >;
1069
1070 def TEX_SAMPLE_C : R600_TEX <
1071   0x18, "TEX_SAMPLE_C",
1072   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_tex R600_Reg128:$SRC_GPR,
1073       imm:$RESOURCE_ID, imm:$SAMPLER_ID, TEX_SHADOW:$textureTarget))]
1074 >;
1075
1076 def TEX_SAMPLE_L : R600_TEX <
1077   0x11, "TEX_SAMPLE_L",
1078   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_txl R600_Reg128:$SRC_GPR,
1079       imm:$RESOURCE_ID, imm:$SAMPLER_ID, imm:$textureTarget))]
1080 >;
1081
1082 def TEX_SAMPLE_C_L : R600_TEX <
1083   0x19, "TEX_SAMPLE_C_L",
1084   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_txl R600_Reg128:$SRC_GPR,
1085       imm:$RESOURCE_ID, imm:$SAMPLER_ID, TEX_SHADOW:$textureTarget))]
1086 >;
1087
1088 def TEX_SAMPLE_LB : R600_TEX <
1089   0x12, "TEX_SAMPLE_LB",
1090   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_txb R600_Reg128:$SRC_GPR,
1091       imm:$RESOURCE_ID, imm:$SAMPLER_ID, imm:$textureTarget))]
1092 >;
1093
1094 def TEX_SAMPLE_C_LB : R600_TEX <
1095   0x1A, "TEX_SAMPLE_C_LB",
1096   [(set R600_Reg128:$DST_GPR, (int_AMDGPU_txb R600_Reg128:$SRC_GPR,
1097       imm:$RESOURCE_ID, imm:$SAMPLER_ID, TEX_SHADOW:$textureTarget))]
1098 >;
1099
1100 def TEX_SAMPLE_G : R600_TEX <
1101   0x14, "TEX_SAMPLE_G",
1102   []
1103 >;
1104
1105 def TEX_SAMPLE_C_G : R600_TEX <
1106   0x1C, "TEX_SAMPLE_C_G",
1107   []
1108 >;
1109
1110 //===----------------------------------------------------------------------===//
1111 // Helper classes for common instructions
1112 //===----------------------------------------------------------------------===//
1113
1114 class MUL_LIT_Common <bits<5> inst> : R600_3OP <
1115   inst, "MUL_LIT",
1116   []
1117 >;
1118
1119 class MULADD_Common <bits<5> inst> : R600_3OP <
1120   inst, "MULADD",
1121   []
1122 >;
1123
1124 class MULADD_IEEE_Common <bits<5> inst> : R600_3OP <
1125   inst, "MULADD_IEEE",
1126   [(set (f32 R600_Reg32:$dst),
1127    (fadd (fmul R600_Reg32:$src0, R600_Reg32:$src1), R600_Reg32:$src2))]
1128 >;
1129
1130 class CNDE_Common <bits<5> inst> : R600_3OP <
1131   inst, "CNDE",
1132   [(set R600_Reg32:$dst,
1133    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
1134        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
1135        COND_EQ))]
1136 >;
1137
1138 class CNDGT_Common <bits<5> inst> : R600_3OP <
1139   inst, "CNDGT",
1140   [(set R600_Reg32:$dst,
1141    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
1142        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
1143        COND_GT))]
1144 >;
1145
1146 class CNDGE_Common <bits<5> inst> : R600_3OP <
1147   inst, "CNDGE",
1148   [(set R600_Reg32:$dst,
1149    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
1150        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
1151        COND_GE))]
1152 >;
1153
1154 multiclass DOT4_Common <bits<11> inst> {
1155
1156   def _pseudo : R600_REDUCTION <inst,
1157     (ins R600_Reg128:$src0, R600_Reg128:$src1),
1158     "DOT4 $dst $src0, $src1",
1159     [(set R600_Reg32:$dst, (int_AMDGPU_dp4 R600_Reg128:$src0, R600_Reg128:$src1))]
1160   >;
1161
1162   def _real : R600_2OP <inst, "DOT4", []>;
1163 }
1164
1165 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
1166 multiclass CUBE_Common <bits<11> inst> {
1167
1168   def _pseudo : InstR600 <
1169     inst,
1170     (outs R600_Reg128:$dst),
1171     (ins R600_Reg128:$src),
1172     "CUBE $dst $src",
1173     [(set R600_Reg128:$dst, (int_AMDGPU_cube R600_Reg128:$src))],
1174     VecALU
1175   > {
1176     let isPseudo = 1;
1177   }
1178
1179   def _real : R600_2OP <inst, "CUBE", []>;
1180 }
1181 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 0
1182
1183 class EXP_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
1184   inst, "EXP_IEEE", fexp2
1185 >;
1186
1187 class FLT_TO_INT_Common <bits<11> inst> : R600_1OP_Helper <
1188   inst, "FLT_TO_INT", fp_to_sint
1189 >;
1190
1191 class INT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
1192   inst, "INT_TO_FLT", sint_to_fp
1193 >;
1194
1195 class FLT_TO_UINT_Common <bits<11> inst> : R600_1OP_Helper <
1196   inst, "FLT_TO_UINT", fp_to_uint
1197 >;
1198
1199 class UINT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
1200   inst, "UINT_TO_FLT", uint_to_fp
1201 >;
1202
1203 class LOG_CLAMPED_Common <bits<11> inst> : R600_1OP <
1204   inst, "LOG_CLAMPED", []
1205 >;
1206
1207 class LOG_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
1208   inst, "LOG_IEEE", flog2
1209 >;
1210
1211 class LSHL_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHL", shl>;
1212 class LSHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHR", srl>;
1213 class ASHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "ASHR", sra>;
1214 class MULHI_INT_Common <bits<11> inst> : R600_2OP_Helper <
1215   inst, "MULHI_INT", mulhs
1216 >;
1217 class MULHI_UINT_Common <bits<11> inst> : R600_2OP_Helper <
1218   inst, "MULHI", mulhu
1219 >;
1220 class MULLO_INT_Common <bits<11> inst> : R600_2OP_Helper <
1221   inst, "MULLO_INT", mul
1222 >;
1223 class MULLO_UINT_Common <bits<11> inst> : R600_2OP <inst, "MULLO_UINT", []>;
1224
1225 class RECIP_CLAMPED_Common <bits<11> inst> : R600_1OP <
1226   inst, "RECIP_CLAMPED", []
1227 >;
1228
1229 class RECIP_IEEE_Common <bits<11> inst> : R600_1OP <
1230   inst, "RECIP_IEEE", [(set R600_Reg32:$dst, (fdiv FP_ONE, R600_Reg32:$src0))]
1231 >;
1232
1233 class RECIP_UINT_Common <bits<11> inst> : R600_1OP_Helper <
1234   inst, "RECIP_UINT", AMDGPUurecip
1235 >;
1236
1237 class RECIPSQRT_CLAMPED_Common <bits<11> inst> : R600_1OP_Helper <
1238   inst, "RECIPSQRT_CLAMPED", int_AMDGPU_rsq
1239 >;
1240
1241 class RECIPSQRT_IEEE_Common <bits<11> inst> : R600_1OP <
1242   inst, "RECIPSQRT_IEEE", []
1243 >;
1244
1245 class SIN_Common <bits<11> inst> : R600_1OP <
1246   inst, "SIN", []>{
1247   let Trig = 1;
1248 }
1249
1250 class COS_Common <bits<11> inst> : R600_1OP <
1251   inst, "COS", []> {
1252   let Trig = 1;
1253 }
1254
1255 //===----------------------------------------------------------------------===//
1256 // Helper patterns for complex intrinsics
1257 //===----------------------------------------------------------------------===//
1258
1259 multiclass DIV_Common <InstR600 recip_ieee> {
1260 def : Pat<
1261   (int_AMDGPU_div R600_Reg32:$src0, R600_Reg32:$src1),
1262   (MUL_IEEE R600_Reg32:$src0, (recip_ieee R600_Reg32:$src1))
1263 >;
1264
1265 def : Pat<
1266   (fdiv R600_Reg32:$src0, R600_Reg32:$src1),
1267   (MUL_IEEE R600_Reg32:$src0, (recip_ieee R600_Reg32:$src1))
1268 >;
1269 }
1270
1271 class TGSI_LIT_Z_Common <InstR600 mul_lit, InstR600 log_clamped, InstR600 exp_ieee> : Pat <
1272   (int_TGSI_lit_z R600_Reg32:$src_x, R600_Reg32:$src_y, R600_Reg32:$src_w),
1273   (exp_ieee (mul_lit (log_clamped (MAX R600_Reg32:$src_y, (f32 ZERO))), R600_Reg32:$src_w, R600_Reg32:$src_x))
1274 >;
1275
1276 //===----------------------------------------------------------------------===//
1277 // R600 / R700 Instructions
1278 //===----------------------------------------------------------------------===//
1279
1280 let Predicates = [isR600] in {
1281
1282   def MUL_LIT_r600 : MUL_LIT_Common<0x0C>;
1283   def MULADD_r600 : MULADD_Common<0x10>;
1284   def MULADD_IEEE_r600 : MULADD_IEEE_Common<0x14>;
1285   def CNDE_r600 : CNDE_Common<0x18>;
1286   def CNDGT_r600 : CNDGT_Common<0x19>;
1287   def CNDGE_r600 : CNDGE_Common<0x1A>;
1288   defm DOT4_r600 : DOT4_Common<0x50>;
1289   defm CUBE_r600 : CUBE_Common<0x52>;
1290   def EXP_IEEE_r600 : EXP_IEEE_Common<0x61>;
1291   def LOG_CLAMPED_r600 : LOG_CLAMPED_Common<0x62>;
1292   def LOG_IEEE_r600 : LOG_IEEE_Common<0x63>;
1293   def RECIP_CLAMPED_r600 : RECIP_CLAMPED_Common<0x64>;
1294   def RECIP_IEEE_r600 : RECIP_IEEE_Common<0x66>;
1295   def RECIPSQRT_CLAMPED_r600 : RECIPSQRT_CLAMPED_Common<0x67>;
1296   def RECIPSQRT_IEEE_r600 : RECIPSQRT_IEEE_Common<0x69>;
1297   def FLT_TO_INT_r600 : FLT_TO_INT_Common<0x6b>;
1298   def INT_TO_FLT_r600 : INT_TO_FLT_Common<0x6c>;
1299   def FLT_TO_UINT_r600 : FLT_TO_UINT_Common<0x79>;
1300   def UINT_TO_FLT_r600 : UINT_TO_FLT_Common<0x6d>;
1301   def SIN_r600 : SIN_Common<0x6E>;
1302   def COS_r600 : COS_Common<0x6F>;
1303   def ASHR_r600 : ASHR_Common<0x70>;
1304   def LSHR_r600 : LSHR_Common<0x71>;
1305   def LSHL_r600 : LSHL_Common<0x72>;
1306   def MULLO_INT_r600 : MULLO_INT_Common<0x73>;
1307   def MULHI_INT_r600 : MULHI_INT_Common<0x74>;
1308   def MULLO_UINT_r600 : MULLO_UINT_Common<0x75>;
1309   def MULHI_UINT_r600 : MULHI_UINT_Common<0x76>;
1310   def RECIP_UINT_r600 : RECIP_UINT_Common <0x78>;
1311
1312   defm DIV_r600 : DIV_Common<RECIP_IEEE_r600>;
1313   def : POW_Common <LOG_IEEE_r600, EXP_IEEE_r600, MUL, R600_Reg32>;
1314   def TGSI_LIT_Z_r600 : TGSI_LIT_Z_Common<MUL_LIT_r600, LOG_CLAMPED_r600, EXP_IEEE_r600>;
1315
1316   def : Pat<(fsqrt R600_Reg32:$src),
1317     (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_r600 R600_Reg32:$src))>;
1318
1319   def R600_ExportSwz : ExportSwzInst {
1320     let Word1{20-17} = 1; // BURST_COUNT
1321     let Word1{21} = eop;
1322     let Word1{22} = 1; // VALID_PIXEL_MODE
1323     let Word1{30-23} = inst;
1324     let Word1{31} = 1; // BARRIER
1325   }
1326   defm : ExportPattern<R600_ExportSwz, 39>;
1327
1328   def R600_ExportBuf : ExportBufInst {
1329     let Word1{20-17} = 1; // BURST_COUNT
1330     let Word1{21} = eop;
1331     let Word1{22} = 1; // VALID_PIXEL_MODE
1332     let Word1{30-23} = inst;
1333     let Word1{31} = 1; // BARRIER
1334   }
1335   defm : SteamOutputExportPattern<R600_ExportBuf, 0x20, 0x21, 0x22, 0x23>;
1336 }
1337
1338 // Helper pattern for normalizing inputs to triginomic instructions for R700+
1339 // cards.
1340 class COS_PAT <InstR600 trig> : Pat<
1341   (fcos R600_Reg32:$src),
1342   (trig (MUL_IEEE (MOV_IMM_I32 CONST.TWO_PI_INV), R600_Reg32:$src))
1343 >;
1344
1345 class SIN_PAT <InstR600 trig> : Pat<
1346   (fsin R600_Reg32:$src),
1347   (trig (MUL_IEEE (MOV_IMM_I32 CONST.TWO_PI_INV), R600_Reg32:$src))
1348 >;
1349
1350 //===----------------------------------------------------------------------===//
1351 // R700 Only instructions
1352 //===----------------------------------------------------------------------===//
1353
1354 let Predicates = [isR700] in {
1355   def SIN_r700 : SIN_Common<0x6E>;
1356   def COS_r700 : COS_Common<0x6F>;
1357
1358   // R700 normalizes inputs to SIN/COS the same as EG
1359   def : SIN_PAT <SIN_r700>;
1360   def : COS_PAT <COS_r700>;
1361 }
1362
1363 //===----------------------------------------------------------------------===//
1364 // Evergreen Only instructions
1365 //===----------------------------------------------------------------------===//
1366
1367 let Predicates = [isEG] in {
1368
1369 def RECIP_IEEE_eg : RECIP_IEEE_Common<0x86>;
1370 defm DIV_eg : DIV_Common<RECIP_IEEE_eg>;
1371
1372 def MULLO_INT_eg : MULLO_INT_Common<0x8F>;
1373 def MULHI_INT_eg : MULHI_INT_Common<0x90>;
1374 def MULLO_UINT_eg : MULLO_UINT_Common<0x91>;
1375 def MULHI_UINT_eg : MULHI_UINT_Common<0x92>;
1376 def RECIP_UINT_eg : RECIP_UINT_Common<0x94>;
1377 def RECIPSQRT_CLAMPED_eg : RECIPSQRT_CLAMPED_Common<0x87>;
1378 def EXP_IEEE_eg : EXP_IEEE_Common<0x81>;
1379 def LOG_IEEE_eg : LOG_IEEE_Common<0x83>;
1380 def RECIP_CLAMPED_eg : RECIP_CLAMPED_Common<0x84>;
1381 def RECIPSQRT_IEEE_eg : RECIPSQRT_IEEE_Common<0x89>;
1382 def SIN_eg : SIN_Common<0x8D>;
1383 def COS_eg : COS_Common<0x8E>;
1384
1385 def : POW_Common <LOG_IEEE_eg, EXP_IEEE_eg, MUL, R600_Reg32>;
1386 def : SIN_PAT <SIN_eg>;
1387 def : COS_PAT <COS_eg>;
1388 def : Pat<(fsqrt R600_Reg32:$src),
1389   (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_eg R600_Reg32:$src))>;
1390 } // End Predicates = [isEG]
1391
1392 //===----------------------------------------------------------------------===//
1393 // Evergreen / Cayman Instructions
1394 //===----------------------------------------------------------------------===//
1395
1396 let Predicates = [isEGorCayman] in {
1397
1398   // BFE_UINT - bit_extract, an optimization for mask and shift
1399   // Src0 = Input
1400   // Src1 = Offset
1401   // Src2 = Width
1402   //
1403   // bit_extract = (Input << (32 - Offset - Width)) >> (32 - Width)
1404   //
1405   // Example Usage:
1406   // (Offset, Width)
1407   //
1408   // (0, 8)           = (Input << 24) >> 24  = (Input &  0xff)       >> 0
1409   // (8, 8)           = (Input << 16) >> 24  = (Input &  0xffff)     >> 8
1410   // (16,8)           = (Input <<  8) >> 24  = (Input &  0xffffff)   >> 16
1411   // (24,8)           = (Input <<  0) >> 24  = (Input &  0xffffffff) >> 24
1412   def BFE_UINT_eg : R600_3OP <0x4, "BFE_UINT",
1413     [(set R600_Reg32:$dst, (int_AMDIL_bit_extract_u32 R600_Reg32:$src0,
1414                                                       R600_Reg32:$src1,
1415                                                       R600_Reg32:$src2))],
1416     VecALU
1417   >;
1418
1419   def BIT_ALIGN_INT_eg : R600_3OP <0xC, "BIT_ALIGN_INT",
1420     [(set R600_Reg32:$dst, (AMDGPUbitalign R600_Reg32:$src0, R600_Reg32:$src1,
1421                                           R600_Reg32:$src2))],
1422     VecALU
1423   >;
1424
1425   def MULADD_eg : MULADD_Common<0x14>;
1426   def MULADD_IEEE_eg : MULADD_IEEE_Common<0x18>;
1427   def ASHR_eg : ASHR_Common<0x15>;
1428   def LSHR_eg : LSHR_Common<0x16>;
1429   def LSHL_eg : LSHL_Common<0x17>;
1430   def CNDE_eg : CNDE_Common<0x19>;
1431   def CNDGT_eg : CNDGT_Common<0x1A>;
1432   def CNDGE_eg : CNDGE_Common<0x1B>;
1433   def MUL_LIT_eg : MUL_LIT_Common<0x1F>;
1434   def LOG_CLAMPED_eg : LOG_CLAMPED_Common<0x82>;
1435   defm DOT4_eg : DOT4_Common<0xBE>;
1436   defm CUBE_eg : CUBE_Common<0xC0>;
1437
1438 let hasSideEffects = 1 in {
1439   def MOVA_INT_eg : R600_1OP <0xCC, "MOVA_INT", []>;
1440 }
1441
1442   def TGSI_LIT_Z_eg : TGSI_LIT_Z_Common<MUL_LIT_eg, LOG_CLAMPED_eg, EXP_IEEE_eg>;
1443
1444   def FLT_TO_INT_eg : FLT_TO_INT_Common<0x50> {
1445     let Pattern = [];
1446   }
1447
1448   def INT_TO_FLT_eg : INT_TO_FLT_Common<0x9B>;
1449
1450   def FLT_TO_UINT_eg : FLT_TO_UINT_Common<0x9A> {
1451     let Pattern = [];
1452   }
1453
1454   def UINT_TO_FLT_eg : UINT_TO_FLT_Common<0x9C>;
1455
1456   // TRUNC is used for the FLT_TO_INT instructions to work around a
1457   // perceived problem where the rounding modes are applied differently
1458   // depending on the instruction and the slot they are in.
1459   // See:
1460   // https://bugs.freedesktop.org/show_bug.cgi?id=50232
1461   // Mesa commit: a1a0974401c467cb86ef818f22df67c21774a38c
1462   //
1463   // XXX: Lowering SELECT_CC will sometimes generate fp_to_[su]int nodes,
1464   // which do not need to be truncated since the fp values are 0.0f or 1.0f.
1465   // We should look into handling these cases separately.
1466   def : Pat<(fp_to_sint R600_Reg32:$src0),
1467     (FLT_TO_INT_eg (TRUNC R600_Reg32:$src0))>;
1468
1469   def : Pat<(fp_to_uint R600_Reg32:$src0),
1470     (FLT_TO_UINT_eg (TRUNC R600_Reg32:$src0))>;
1471
1472   def EG_ExportSwz : ExportSwzInst {
1473     let Word1{19-16} = 1; // BURST_COUNT
1474     let Word1{20} = 1; // VALID_PIXEL_MODE
1475     let Word1{21} = eop;
1476     let Word1{29-22} = inst;
1477     let Word1{30} = 0; // MARK
1478     let Word1{31} = 1; // BARRIER
1479   }
1480   defm : ExportPattern<EG_ExportSwz, 83>;
1481
1482   def EG_ExportBuf : ExportBufInst {
1483     let Word1{19-16} = 1; // BURST_COUNT
1484     let Word1{20} = 1; // VALID_PIXEL_MODE
1485     let Word1{21} = eop;
1486     let Word1{29-22} = inst;
1487     let Word1{30} = 0; // MARK
1488     let Word1{31} = 1; // BARRIER
1489   }
1490   defm : SteamOutputExportPattern<EG_ExportBuf, 0x40, 0x41, 0x42, 0x43>;
1491
1492 //===----------------------------------------------------------------------===//
1493 // Memory read/write instructions
1494 //===----------------------------------------------------------------------===//
1495 let usesCustomInserter = 1 in {
1496
1497 class RAT_WRITE_CACHELESS_eg <dag ins, bits<4> comp_mask, string name,
1498                               list<dag> pattern>
1499     : EG_CF_RAT <0x57, 0x2, 0, (outs), ins,
1500                  !strconcat(name, " $rw_gpr, $index_gpr, $eop"), pattern> {
1501   let RIM         = 0;
1502   // XXX: Have a separate instruction for non-indexed writes.
1503   let TYPE        = 1;
1504   let RW_REL      = 0;
1505   let ELEM_SIZE   = 0;
1506
1507   let ARRAY_SIZE  = 0;
1508   let COMP_MASK   = comp_mask;
1509   let BURST_COUNT = 0;
1510   let VPM         = 0;
1511   let MARK        = 0;
1512   let BARRIER     = 1;
1513 }
1514
1515 } // End usesCustomInserter = 1
1516
1517 // 32-bit store
1518 def RAT_WRITE_CACHELESS_32_eg : RAT_WRITE_CACHELESS_eg <
1519   (ins R600_TReg32_X:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1520   0x1, "RAT_WRITE_CACHELESS_32_eg",
1521   [(global_store (i32 R600_TReg32_X:$rw_gpr), R600_TReg32_X:$index_gpr)]
1522 >;
1523
1524 //128-bit store
1525 def RAT_WRITE_CACHELESS_128_eg : RAT_WRITE_CACHELESS_eg <
1526   (ins R600_Reg128:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1527   0xf, "RAT_WRITE_CACHELESS_128",
1528   [(global_store (v4i32 R600_Reg128:$rw_gpr), R600_TReg32_X:$index_gpr)]
1529 >;
1530
1531 class VTX_READ_eg <string name, bits<8> buffer_id, dag outs, list<dag> pattern>
1532     : InstR600ISA <outs, (ins MEMxi:$ptr), name#" $dst, $ptr", pattern>,
1533       VTX_WORD1_GPR, VTX_WORD0 {
1534
1535   // Static fields
1536   let VC_INST = 0;
1537   let FETCH_TYPE = 2;
1538   let FETCH_WHOLE_QUAD = 0;
1539   let BUFFER_ID = buffer_id;
1540   let SRC_REL = 0;
1541   // XXX: We can infer this field based on the SRC_GPR.  This would allow us
1542   // to store vertex addresses in any channel, not just X.
1543   let SRC_SEL_X = 0;
1544   let DST_REL = 0;
1545   // The docs say that if this bit is set, then DATA_FORMAT, NUM_FORMAT_ALL,
1546   // FORMAT_COMP_ALL, SRF_MODE_ALL, and ENDIAN_SWAP fields will be ignored,
1547   // however, based on my testing if USE_CONST_FIELDS is set, then all
1548   // these fields need to be set to 0.
1549   let USE_CONST_FIELDS = 0;
1550   let NUM_FORMAT_ALL = 1;
1551   let FORMAT_COMP_ALL = 0;
1552   let SRF_MODE_ALL = 0;
1553
1554   let Inst{31-0} = Word0;
1555   let Inst{63-32} = Word1;
1556   // LLVM can only encode 64-bit instructions, so these fields are manually
1557   // encoded in R600CodeEmitter
1558   //
1559   // bits<16> OFFSET;
1560   // bits<2>  ENDIAN_SWAP = 0;
1561   // bits<1>  CONST_BUF_NO_STRIDE = 0;
1562   // bits<1>  MEGA_FETCH = 0;
1563   // bits<1>  ALT_CONST = 0;
1564   // bits<2>  BUFFER_INDEX_MODE = 0;
1565
1566
1567
1568   // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1569   // is done in R600CodeEmitter
1570   //
1571   // Inst{79-64} = OFFSET;
1572   // Inst{81-80} = ENDIAN_SWAP;
1573   // Inst{82}    = CONST_BUF_NO_STRIDE;
1574   // Inst{83}    = MEGA_FETCH;
1575   // Inst{84}    = ALT_CONST;
1576   // Inst{86-85} = BUFFER_INDEX_MODE;
1577   // Inst{95-86} = 0; Reserved
1578
1579   // VTX_WORD3 (Padding)
1580   //
1581   // Inst{127-96} = 0;
1582 }
1583
1584 class VTX_READ_8_eg <bits<8> buffer_id, list<dag> pattern>
1585     : VTX_READ_eg <"VTX_READ_8", buffer_id, (outs R600_TReg32_X:$dst),
1586                    pattern> {
1587
1588   let MEGA_FETCH_COUNT = 1;
1589   let DST_SEL_X = 0;
1590   let DST_SEL_Y = 7;   // Masked
1591   let DST_SEL_Z = 7;   // Masked
1592   let DST_SEL_W = 7;   // Masked
1593   let DATA_FORMAT = 1; // FMT_8
1594 }
1595
1596 class VTX_READ_16_eg <bits<8> buffer_id, list<dag> pattern>
1597     : VTX_READ_eg <"VTX_READ_16", buffer_id, (outs R600_TReg32_X:$dst),
1598                     pattern> {
1599   let MEGA_FETCH_COUNT = 2;
1600   let DST_SEL_X = 0;
1601   let DST_SEL_Y = 7;   // Masked
1602   let DST_SEL_Z = 7;   // Masked
1603   let DST_SEL_W = 7;   // Masked
1604   let DATA_FORMAT = 5; // FMT_16
1605
1606 }
1607
1608 class VTX_READ_32_eg <bits<8> buffer_id, list<dag> pattern>
1609     : VTX_READ_eg <"VTX_READ_32", buffer_id, (outs R600_TReg32_X:$dst),
1610                    pattern> {
1611
1612   let MEGA_FETCH_COUNT = 4;
1613   let DST_SEL_X        = 0;
1614   let DST_SEL_Y        = 7;   // Masked
1615   let DST_SEL_Z        = 7;   // Masked
1616   let DST_SEL_W        = 7;   // Masked
1617   let DATA_FORMAT      = 0xD; // COLOR_32
1618
1619   // This is not really necessary, but there were some GPU hangs that appeared
1620   // to be caused by ALU instructions in the next instruction group that wrote
1621   // to the $ptr registers of the VTX_READ.
1622   // e.g.
1623   // %T3_X<def> = VTX_READ_PARAM_32_eg %T2_X<kill>, 24
1624   // %T2_X<def> = MOV %ZERO
1625   //Adding this constraint prevents this from happening.
1626   let Constraints = "$ptr.ptr = $dst";
1627 }
1628
1629 class VTX_READ_128_eg <bits<8> buffer_id, list<dag> pattern>
1630     : VTX_READ_eg <"VTX_READ_128", buffer_id, (outs R600_Reg128:$dst),
1631                    pattern> {
1632
1633   let MEGA_FETCH_COUNT = 16;
1634   let DST_SEL_X        =  0;
1635   let DST_SEL_Y        =  1;
1636   let DST_SEL_Z        =  2;
1637   let DST_SEL_W        =  3;
1638   let DATA_FORMAT      =  0x22; // COLOR_32_32_32_32
1639
1640   // XXX: Need to force VTX_READ_128 instructions to write to the same register
1641   // that holds its buffer address to avoid potential hangs.  We can't use
1642   // the same constraint as VTX_READ_32_eg, because the $ptr.ptr and $dst
1643   // registers are different sizes.
1644 }
1645
1646 //===----------------------------------------------------------------------===//
1647 // VTX Read from parameter memory space
1648 //===----------------------------------------------------------------------===//
1649
1650 def VTX_READ_PARAM_8_eg : VTX_READ_8_eg <0,
1651   [(set (i32 R600_TReg32_X:$dst), (load_param_zexti8 ADDRVTX_READ:$ptr))]
1652 >;
1653
1654 def VTX_READ_PARAM_16_eg : VTX_READ_16_eg <0,
1655   [(set (i32 R600_TReg32_X:$dst), (load_param_zexti16 ADDRVTX_READ:$ptr))]
1656 >;
1657
1658 def VTX_READ_PARAM_32_eg : VTX_READ_32_eg <0,
1659   [(set (i32 R600_TReg32_X:$dst), (load_param ADDRVTX_READ:$ptr))]
1660 >;
1661
1662 def VTX_READ_PARAM_128_eg : VTX_READ_128_eg <0,
1663   [(set (v4i32 R600_Reg128:$dst), (load_param ADDRVTX_READ:$ptr))]
1664 >;
1665
1666 //===----------------------------------------------------------------------===//
1667 // VTX Read from global memory space
1668 //===----------------------------------------------------------------------===//
1669
1670 // 8-bit reads
1671 def VTX_READ_GLOBAL_8_eg : VTX_READ_8_eg <1,
1672   [(set (i32 R600_TReg32_X:$dst), (zextloadi8_global ADDRVTX_READ:$ptr))]
1673 >;
1674
1675 // 32-bit reads
1676 def VTX_READ_GLOBAL_32_eg : VTX_READ_32_eg <1,
1677   [(set (i32 R600_TReg32_X:$dst), (global_load ADDRVTX_READ:$ptr))]
1678 >;
1679
1680 // 128-bit reads
1681 def VTX_READ_GLOBAL_128_eg : VTX_READ_128_eg <1,
1682   [(set (v4i32 R600_Reg128:$dst), (global_load ADDRVTX_READ:$ptr))]
1683 >;
1684
1685 //===----------------------------------------------------------------------===//
1686 // Constant Loads
1687 // XXX: We are currently storing all constants in the global address space.
1688 //===----------------------------------------------------------------------===//
1689
1690 def CONSTANT_LOAD_eg : VTX_READ_32_eg <1,
1691   [(set (i32 R600_TReg32_X:$dst), (constant_load ADDRVTX_READ:$ptr))]
1692 >;
1693
1694 }
1695
1696 //===----------------------------------------------------------------------===//
1697 // Regist loads and stores - for indirect addressing
1698 //===----------------------------------------------------------------------===//
1699
1700 defm R600_ : RegisterLoadStore <R600_Reg32, FRAMEri, ADDRIndirect>;
1701
1702 let Predicates = [isCayman] in {
1703
1704 let isVector = 1 in {
1705
1706 def RECIP_IEEE_cm : RECIP_IEEE_Common<0x86>;
1707
1708 def MULLO_INT_cm : MULLO_INT_Common<0x8F>;
1709 def MULHI_INT_cm : MULHI_INT_Common<0x90>;
1710 def MULLO_UINT_cm : MULLO_UINT_Common<0x91>;
1711 def MULHI_UINT_cm : MULHI_UINT_Common<0x92>;
1712 def RECIPSQRT_CLAMPED_cm : RECIPSQRT_CLAMPED_Common<0x87>;
1713 def EXP_IEEE_cm : EXP_IEEE_Common<0x81>;
1714 def LOG_IEEE_cm : LOG_IEEE_Common<0x83>;
1715 def RECIP_CLAMPED_cm : RECIP_CLAMPED_Common<0x84>;
1716 def RECIPSQRT_IEEE_cm : RECIPSQRT_IEEE_Common<0x89>;
1717 def SIN_cm : SIN_Common<0x8D>;
1718 def COS_cm : COS_Common<0x8E>;
1719 } // End isVector = 1
1720
1721 def : POW_Common <LOG_IEEE_cm, EXP_IEEE_cm, MUL, R600_Reg32>;
1722 def : SIN_PAT <SIN_cm>;
1723 def : COS_PAT <COS_cm>;
1724
1725 defm DIV_cm : DIV_Common<RECIP_IEEE_cm>;
1726
1727 // RECIP_UINT emulation for Cayman
1728 def : Pat <
1729   (AMDGPUurecip R600_Reg32:$src0),
1730   (FLT_TO_UINT_eg (MUL_IEEE (RECIP_IEEE_cm (UINT_TO_FLT_eg R600_Reg32:$src0)),
1731                             (MOV_IMM_I32 0x4f800000)))
1732 >;
1733
1734
1735 def : Pat<(fsqrt R600_Reg32:$src),
1736   (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_cm R600_Reg32:$src))>;
1737
1738 } // End isCayman
1739
1740 //===----------------------------------------------------------------------===//
1741 // Branch Instructions
1742 //===----------------------------------------------------------------------===//
1743
1744
1745 def IF_PREDICATE_SET  : ILFormat<(outs), (ins GPRI32:$src),
1746   "IF_PREDICATE_SET $src", []>;
1747
1748 def PREDICATED_BREAK : ILFormat<(outs), (ins GPRI32:$src),
1749   "PREDICATED_BREAK $src", []>;
1750
1751 //===----------------------------------------------------------------------===//
1752 // Pseudo instructions
1753 //===----------------------------------------------------------------------===//
1754
1755 let isPseudo = 1 in {
1756
1757 def PRED_X : InstR600 <
1758   0, (outs R600_Predicate_Bit:$dst),
1759   (ins R600_Reg32:$src0, i32imm:$src1, i32imm:$flags),
1760   "", [], NullALU> {
1761   let FlagOperandIdx = 3;
1762 }
1763
1764 let isTerminator = 1, isBranch = 1 in {
1765 def JUMP_COND : InstR600 <0x10,
1766           (outs),
1767           (ins brtarget:$target, R600_Predicate_Bit:$p),
1768           "JUMP $target ($p)",
1769           [], AnyALU
1770   >;
1771
1772 def JUMP : InstR600 <0x10,
1773           (outs),
1774           (ins brtarget:$target),
1775           "JUMP $target",
1776           [], AnyALU
1777   >
1778 {
1779   let isPredicable = 1;
1780   let isBarrier = 1;
1781 }
1782
1783 }  // End isTerminator = 1, isBranch = 1
1784
1785 let usesCustomInserter = 1 in {
1786
1787 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in {
1788
1789 def MASK_WRITE : AMDGPUShaderInst <
1790     (outs),
1791     (ins R600_Reg32:$src),
1792     "MASK_WRITE $src",
1793     []
1794 >;
1795
1796 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 1
1797
1798
1799 def TXD: AMDGPUShaderInst <
1800   (outs R600_Reg128:$dst),
1801   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
1802   "TXD $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
1803   [(set R600_Reg128:$dst, (int_AMDGPU_txd R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
1804 >;
1805
1806 def TXD_SHADOW: AMDGPUShaderInst <
1807   (outs R600_Reg128:$dst),
1808   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
1809   "TXD_SHADOW $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
1810   [(set R600_Reg128:$dst, (int_AMDGPU_txd R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
1811 >;
1812
1813 } // End isPseudo = 1
1814 } // End usesCustomInserter = 1
1815
1816 def CLAMP_R600 :  CLAMP <R600_Reg32>;
1817 def FABS_R600 : FABS<R600_Reg32>;
1818 def FNEG_R600 : FNEG<R600_Reg32>;
1819
1820 //===---------------------------------------------------------------------===//
1821 // Return instruction
1822 //===---------------------------------------------------------------------===//
1823 let isTerminator = 1, isReturn = 1, hasCtrlDep = 1,
1824     usesCustomInserter = 1 in {
1825   def RETURN          : ILFormat<(outs), (ins variable_ops),
1826       "RETURN", [(IL_retflag)]>;
1827 }
1828
1829
1830 //===----------------------------------------------------------------------===//
1831 // Constant Buffer Addressing Support
1832 //===----------------------------------------------------------------------===//
1833
1834 let usesCustomInserter = 1, isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"  in {
1835 def CONST_COPY : Instruction {
1836   let OutOperandList = (outs R600_Reg32:$dst);
1837   let InOperandList = (ins i32imm:$src);
1838   let Pattern =
1839       [(set R600_Reg32:$dst, (CONST_ADDRESS ADDRGA_CONST_OFFSET:$src))];
1840   let AsmString = "CONST_COPY";
1841   let neverHasSideEffects = 1;
1842   let isAsCheapAsAMove = 1;
1843   let Itinerary = NullALU;
1844 }
1845 } // end usesCustomInserter = 1, isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"
1846
1847 def TEX_VTX_CONSTBUF :
1848   InstR600ISA <(outs R600_Reg128:$dst), (ins MEMxi:$ptr, i32imm:$BUFFER_ID), "VTX_READ_eg $dst, $ptr",
1849       [(set R600_Reg128:$dst, (CONST_ADDRESS ADDRGA_VAR_OFFSET:$ptr, (i32 imm:$BUFFER_ID)))]>,
1850   VTX_WORD1_GPR, VTX_WORD0 {
1851
1852   let VC_INST = 0;
1853   let FETCH_TYPE = 2;
1854   let FETCH_WHOLE_QUAD = 0;
1855   let SRC_REL = 0;
1856   let SRC_SEL_X = 0;
1857   let DST_REL = 0;
1858   let USE_CONST_FIELDS = 0;
1859   let NUM_FORMAT_ALL = 2;
1860   let FORMAT_COMP_ALL = 1;
1861   let SRF_MODE_ALL = 1;
1862   let MEGA_FETCH_COUNT = 16;
1863   let DST_SEL_X        = 0;
1864   let DST_SEL_Y        = 1;
1865   let DST_SEL_Z        = 2;
1866   let DST_SEL_W        = 3;
1867   let DATA_FORMAT      = 35;
1868
1869   let Inst{31-0} = Word0;
1870   let Inst{63-32} = Word1;
1871
1872 // LLVM can only encode 64-bit instructions, so these fields are manually
1873 // encoded in R600CodeEmitter
1874 //
1875 // bits<16> OFFSET;
1876 // bits<2>  ENDIAN_SWAP = 0;
1877 // bits<1>  CONST_BUF_NO_STRIDE = 0;
1878 // bits<1>  MEGA_FETCH = 0;
1879 // bits<1>  ALT_CONST = 0;
1880 // bits<2>  BUFFER_INDEX_MODE = 0;
1881
1882
1883
1884 // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1885 // is done in R600CodeEmitter
1886 //
1887 // Inst{79-64} = OFFSET;
1888 // Inst{81-80} = ENDIAN_SWAP;
1889 // Inst{82}    = CONST_BUF_NO_STRIDE;
1890 // Inst{83}    = MEGA_FETCH;
1891 // Inst{84}    = ALT_CONST;
1892 // Inst{86-85} = BUFFER_INDEX_MODE;
1893 // Inst{95-86} = 0; Reserved
1894
1895 // VTX_WORD3 (Padding)
1896 //
1897 // Inst{127-96} = 0;
1898 }
1899
1900 def TEX_VTX_TEXBUF:
1901   InstR600ISA <(outs R600_Reg128:$dst), (ins MEMxi:$ptr, i32imm:$BUFFER_ID), "TEX_VTX_EXPLICIT_READ $dst, $ptr",
1902       [(set R600_Reg128:$dst, (int_R600_load_texbuf ADDRGA_VAR_OFFSET:$ptr, imm:$BUFFER_ID))]>,
1903 VTX_WORD1_GPR, VTX_WORD0 {
1904
1905 let VC_INST = 0;
1906 let FETCH_TYPE = 2;
1907 let FETCH_WHOLE_QUAD = 0;
1908 let SRC_REL = 0;
1909 let SRC_SEL_X = 0;
1910 let DST_REL = 0;
1911 let USE_CONST_FIELDS = 1;
1912 let NUM_FORMAT_ALL = 0;
1913 let FORMAT_COMP_ALL = 0;
1914 let SRF_MODE_ALL = 1;
1915 let MEGA_FETCH_COUNT = 16;
1916 let DST_SEL_X        = 0;
1917 let DST_SEL_Y        = 1;
1918 let DST_SEL_Z        = 2;
1919 let DST_SEL_W        = 3;
1920 let DATA_FORMAT      = 0;
1921
1922 let Inst{31-0} = Word0;
1923 let Inst{63-32} = Word1;
1924
1925 // LLVM can only encode 64-bit instructions, so these fields are manually
1926 // encoded in R600CodeEmitter
1927 //
1928 // bits<16> OFFSET;
1929 // bits<2>  ENDIAN_SWAP = 0;
1930 // bits<1>  CONST_BUF_NO_STRIDE = 0;
1931 // bits<1>  MEGA_FETCH = 0;
1932 // bits<1>  ALT_CONST = 0;
1933 // bits<2>  BUFFER_INDEX_MODE = 0;
1934
1935
1936
1937 // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1938 // is done in R600CodeEmitter
1939 //
1940 // Inst{79-64} = OFFSET;
1941 // Inst{81-80} = ENDIAN_SWAP;
1942 // Inst{82}    = CONST_BUF_NO_STRIDE;
1943 // Inst{83}    = MEGA_FETCH;
1944 // Inst{84}    = ALT_CONST;
1945 // Inst{86-85} = BUFFER_INDEX_MODE;
1946 // Inst{95-86} = 0; Reserved
1947
1948 // VTX_WORD3 (Padding)
1949 //
1950 // Inst{127-96} = 0;
1951 }
1952
1953
1954
1955 //===--------------------------------------------------------------------===//
1956 // Instructions support
1957 //===--------------------------------------------------------------------===//
1958 //===---------------------------------------------------------------------===//
1959 // Custom Inserter for Branches and returns, this eventually will be a
1960 // seperate pass
1961 //===---------------------------------------------------------------------===//
1962 let isTerminator = 1, usesCustomInserter = 1, isBranch = 1, isBarrier = 1 in {
1963   def BRANCH : ILFormat<(outs), (ins brtarget:$target),
1964       "; Pseudo unconditional branch instruction",
1965       [(br bb:$target)]>;
1966   defm BRANCH_COND : BranchConditional<IL_brcond>;
1967 }
1968
1969 //===---------------------------------------------------------------------===//
1970 // Flow and Program control Instructions
1971 //===---------------------------------------------------------------------===//
1972 let isTerminator=1 in {
1973   def SWITCH      : ILFormat< (outs), (ins GPRI32:$src),
1974   !strconcat("SWITCH", " $src"), []>;
1975   def CASE        : ILFormat< (outs), (ins GPRI32:$src),
1976       !strconcat("CASE", " $src"), []>;
1977   def BREAK       : ILFormat< (outs), (ins),
1978       "BREAK", []>;
1979   def CONTINUE    : ILFormat< (outs), (ins),
1980       "CONTINUE", []>;
1981   def DEFAULT     : ILFormat< (outs), (ins),
1982       "DEFAULT", []>;
1983   def ELSE        : ILFormat< (outs), (ins),
1984       "ELSE", []>;
1985   def ENDSWITCH   : ILFormat< (outs), (ins),
1986       "ENDSWITCH", []>;
1987   def ENDMAIN     : ILFormat< (outs), (ins),
1988       "ENDMAIN", []>;
1989   def END         : ILFormat< (outs), (ins),
1990       "END", []>;
1991   def ENDFUNC     : ILFormat< (outs), (ins),
1992       "ENDFUNC", []>;
1993   def ENDIF       : ILFormat< (outs), (ins),
1994       "ENDIF", []>;
1995   def WHILELOOP   : ILFormat< (outs), (ins),
1996       "WHILE", []>;
1997   def ENDLOOP     : ILFormat< (outs), (ins),
1998       "ENDLOOP", []>;
1999   def FUNC        : ILFormat< (outs), (ins),
2000       "FUNC", []>;
2001   def RETDYN      : ILFormat< (outs), (ins),
2002       "RET_DYN", []>;
2003   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2004   defm IF_LOGICALNZ  : BranchInstr<"IF_LOGICALNZ">;
2005   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2006   defm IF_LOGICALZ   : BranchInstr<"IF_LOGICALZ">;
2007   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2008   defm BREAK_LOGICALNZ : BranchInstr<"BREAK_LOGICALNZ">;
2009   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2010   defm BREAK_LOGICALZ : BranchInstr<"BREAK_LOGICALZ">;
2011   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2012   defm CONTINUE_LOGICALNZ : BranchInstr<"CONTINUE_LOGICALNZ">;
2013   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
2014   defm CONTINUE_LOGICALZ : BranchInstr<"CONTINUE_LOGICALZ">;
2015   defm IFC         : BranchInstr2<"IFC">;
2016   defm BREAKC      : BranchInstr2<"BREAKC">;
2017   defm CONTINUEC   : BranchInstr2<"CONTINUEC">;
2018 }
2019
2020 //===----------------------------------------------------------------------===//
2021 // ISel Patterns
2022 //===----------------------------------------------------------------------===//
2023
2024 // CND*_INT Pattterns for f32 True / False values
2025
2026 class CND_INT_f32 <InstR600 cnd, CondCode cc> : Pat <
2027   (selectcc (i32 R600_Reg32:$src0), 0, (f32 R600_Reg32:$src1),
2028                                             R600_Reg32:$src2, cc),
2029   (cnd R600_Reg32:$src0, R600_Reg32:$src1, R600_Reg32:$src2)
2030 >;
2031
2032 def : CND_INT_f32 <CNDE_INT,  SETEQ>;
2033 def : CND_INT_f32 <CNDGT_INT, SETGT>;
2034 def : CND_INT_f32 <CNDGE_INT, SETGE>;
2035
2036 //CNDGE_INT extra pattern
2037 def : Pat <
2038   (selectcc (i32 R600_Reg32:$src0), -1, (i32 R600_Reg32:$src1),
2039                                         (i32 R600_Reg32:$src2), COND_GT),
2040   (CNDGE_INT R600_Reg32:$src0, R600_Reg32:$src1, R600_Reg32:$src2)
2041 >;
2042
2043 // KIL Patterns
2044 def KILP : Pat <
2045   (int_AMDGPU_kilp),
2046   (MASK_WRITE (KILLGT (f32 ONE), (f32 ZERO)))
2047 >;
2048
2049 def KIL : Pat <
2050   (int_AMDGPU_kill R600_Reg32:$src0),
2051   (MASK_WRITE (KILLGT (f32 ZERO), (f32 R600_Reg32:$src0)))
2052 >;
2053
2054 // SGT Reverse args
2055 def : Pat <
2056   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, COND_LT),
2057   (SGT R600_Reg32:$src1, R600_Reg32:$src0)
2058 >;
2059
2060 // SGE Reverse args
2061 def : Pat <
2062   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, COND_LE),
2063   (SGE R600_Reg32:$src1, R600_Reg32:$src0)
2064 >;
2065
2066 // SETGT_DX10 reverse args
2067 def : Pat <
2068   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, COND_LT),
2069   (SETGT_DX10 R600_Reg32:$src1, R600_Reg32:$src0)
2070 >;
2071
2072 // SETGE_DX10 reverse args
2073 def : Pat <
2074   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, COND_LE),
2075   (SETGE_DX10 R600_Reg32:$src1, R600_Reg32:$src0)
2076 >;
2077
2078 // SETGT_INT reverse args
2079 def : Pat <
2080   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETLT),
2081   (SETGT_INT R600_Reg32:$src1, R600_Reg32:$src0)
2082 >;
2083
2084 // SETGE_INT reverse args
2085 def : Pat <
2086   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETLE),
2087   (SETGE_INT R600_Reg32:$src1, R600_Reg32:$src0)
2088 >;
2089
2090 // SETGT_UINT reverse args
2091 def : Pat <
2092   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETULT),
2093   (SETGT_UINT R600_Reg32:$src1, R600_Reg32:$src0)
2094 >;
2095
2096 // SETGE_UINT reverse args
2097 def : Pat <
2098   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETULE),
2099   (SETGE_UINT R600_Reg32:$src1, R600_Reg32:$src0)
2100 >;
2101
2102 // The next two patterns are special cases for handling 'true if ordered' and
2103 // 'true if unordered' conditionals.  The assumption here is that the behavior of
2104 // SETE and SNE conforms to the Direct3D 10 rules for floating point values
2105 // described here:
2106 // http://msdn.microsoft.com/en-us/library/windows/desktop/cc308050.aspx#alpha_32_bit
2107 // We assume that  SETE returns false when one of the operands is NAN and
2108 // SNE returns true when on of the operands is NAN
2109
2110 //SETE - 'true if ordered'
2111 def : Pat <
2112   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, SETO),
2113   (SETE R600_Reg32:$src0, R600_Reg32:$src1)
2114 >;
2115
2116 //SETE_DX10 - 'true if ordered'
2117 def : Pat <
2118   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETO),
2119   (SETE_DX10 R600_Reg32:$src0, R600_Reg32:$src1)
2120 >;
2121
2122 //SNE - 'true if unordered'
2123 def : Pat <
2124   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, SETUO),
2125   (SNE R600_Reg32:$src0, R600_Reg32:$src1)
2126 >;
2127
2128 //SETNE_DX10 - 'true if ordered'
2129 def : Pat <
2130   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUO),
2131   (SETNE_DX10 R600_Reg32:$src0, R600_Reg32:$src1)
2132 >;
2133
2134 def : Extract_Element <f32, v4f32, R600_Reg128, 0, sub0>;
2135 def : Extract_Element <f32, v4f32, R600_Reg128, 1, sub1>;
2136 def : Extract_Element <f32, v4f32, R600_Reg128, 2, sub2>;
2137 def : Extract_Element <f32, v4f32, R600_Reg128, 3, sub3>;
2138
2139 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 0, sub0>;
2140 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 1, sub1>;
2141 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 2, sub2>;
2142 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 3, sub3>;
2143
2144 def : Extract_Element <i32, v4i32, R600_Reg128, 0, sub0>;
2145 def : Extract_Element <i32, v4i32, R600_Reg128, 1, sub1>;
2146 def : Extract_Element <i32, v4i32, R600_Reg128, 2, sub2>;
2147 def : Extract_Element <i32, v4i32, R600_Reg128, 3, sub3>;
2148
2149 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 0, sub0>;
2150 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 1, sub1>;
2151 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 2, sub2>;
2152 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 3, sub3>;
2153
2154 def : Vector4_Build <v4f32, R600_Reg128, f32, R600_Reg32>;
2155 def : Vector4_Build <v4i32, R600_Reg128, i32, R600_Reg32>;
2156
2157 // bitconvert patterns
2158
2159 def : BitConvert <i32, f32, R600_Reg32>;
2160 def : BitConvert <f32, i32, R600_Reg32>;
2161 def : BitConvert <v4f32, v4i32, R600_Reg128>;
2162 def : BitConvert <v4i32, v4f32, R600_Reg128>;
2163
2164 // DWORDADDR pattern
2165 def : DwordAddrPat  <i32, R600_Reg32>;
2166
2167 } // End isR600toCayman Predicate