lib/Target/R600/R600Instructions.td

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