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 def LITERAL : InstFlag<"printLiteral">;
  74
  75 def WRITE : InstFlag <"printWrite", 1>;
  76 def OMOD : InstFlag <"printOMOD">;
  77 def REL : InstFlag <"printRel">;
  78 def CLAMP : InstFlag <"printClamp">;
  79 def NEG : InstFlag <"printNeg">;
  80 def ABS : InstFlag <"printAbs">;
  81 def UEM : InstFlag <"printUpdateExecMask">;
  82 def UP : InstFlag <"printUpdatePred">;
  83
  84 // XXX: The r600g finalizer in Mesa expects last to be one in most cases.
  85 // Once we start using the packetizer in this backend we should have this
  86 // default to 0.
  87 def LAST : InstFlag<"printLast", 1>;
  88
  89 def ADDRParam : ComplexPattern<i32, 2, "SelectADDRParam", [], []>;
  90 def ADDRDWord : ComplexPattern<i32, 1, "SelectADDRDWord", [], []>;
  91 def ADDRVTX_READ : ComplexPattern<i32, 2, "SelectADDRVTX_READ", [], []>;
  92
  93 class R600ALU_Word0 {
  94   field bits<32> Word0;
  95
  96   bits<11> src0;
  97   bits<1>  src0_neg;
  98   bits<1>  src0_rel;
  99   bits<11> src1;
 100   bits<1>  src1_rel;
 101   bits<1>  src1_neg;
 102   bits<3>  index_mode = 0;
 103   bits<2>  pred_sel;
 104   bits<1>  last;
 105
 106   bits<9>  src0_sel  = src0{8-0};
 107   bits<2>  src0_chan = src0{10-9};
 108   bits<9>  src1_sel  = src1{8-0};
 109   bits<2>  src1_chan = src1{10-9};
 110
 111   let Word0{8-0}   = src0_sel;
 112   let Word0{9}     = src0_rel;
 113   let Word0{11-10} = src0_chan;
 114   let Word0{12}    = src0_neg;
 115   let Word0{21-13} = src1_sel;
 116   let Word0{22}    = src1_rel;
 117   let Word0{24-23} = src1_chan;
 118   let Word0{25}    = src1_neg;
 119   let Word0{28-26} = index_mode;
 120   let Word0{30-29} = pred_sel;
 121   let Word0{31}    = last;
 122 }
 123
 124 class R600ALU_Word1 {
 125   field bits<32> Word1;
 126
 127   bits<11> dst;
 128   bits<3>  bank_swizzle = 0;
 129   bits<1>  dst_rel;
 130   bits<1>  clamp;
 131
 132   bits<7>  dst_sel  = dst{6-0};
 133   bits<2>  dst_chan = dst{10-9};
 134
 135   let Word1{20-18} = bank_swizzle;
 136   let Word1{27-21} = dst_sel;
 137   let Word1{28}    = dst_rel;
 138   let Word1{30-29} = dst_chan;
 139   let Word1{31}    = clamp;
 140 }
 141
 142 class R600ALU_Word1_OP2 <bits<11> alu_inst> : R600ALU_Word1{
 143
 144   bits<1>  src0_abs;
 145   bits<1>  src1_abs;
 146   bits<1>  update_exec_mask;
 147   bits<1>  update_pred;
 148   bits<1>  write;
 149   bits<2>  omod;
 150
 151   let Word1{0}     = src0_abs;
 152   let Word1{1}     = src1_abs;
 153   let Word1{2}     = update_exec_mask;
 154   let Word1{3}     = update_pred;
 155   let Word1{4}     = write;
 156   let Word1{6-5}   = omod;
 157   let Word1{17-7}  = alu_inst;
 158 }
 159
 160 class R600ALU_Word1_OP3 <bits<5> alu_inst> : R600ALU_Word1{
 161
 162   bits<11> src2;
 163   bits<1>  src2_rel;
 164   bits<1>  src2_neg;
 165
 166   bits<9>  src2_sel = src2{8-0};
 167   bits<2>  src2_chan = src2{10-9};
 168
 169   let Word1{8-0}   = src2_sel;
 170   let Word1{9}     = src2_rel;
 171   let Word1{11-10} = src2_chan;
 172   let Word1{12}    = src2_neg;
 173   let Word1{17-13} = alu_inst;
 174 }
 175
 176 /*
 177 XXX: R600 subtarget uses a slightly different encoding than the other
 178 subtargets.  We currently handle this in R600MCCodeEmitter, but we may
 179 want to use these instruction classes in the future.
 180
 181 class R600ALU_Word1_OP2_r600 : R600ALU_Word1_OP2 {
 182
 183   bits<1>  fog_merge;
 184   bits<10> alu_inst;
 185
 186   let Inst{37}    = fog_merge;
 187   let Inst{39-38} = omod;
 188   let Inst{49-40} = alu_inst;
 189 }
 190
 191 class R600ALU_Word1_OP2_r700 : R600ALU_Word1_OP2 {
 192
 193   bits<11> alu_inst;
 194
 195   let Inst{38-37} = omod;
 196   let Inst{49-39} = alu_inst;
 197 }
 198 */
 199
 200 def R600_Pred : PredicateOperand<i32, (ops R600_Predicate),
 201                                      (ops PRED_SEL_OFF)>;
 202
 203
 204 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
 205
 206 // Class for instructions with only one source register.
 207 // If you add new ins to this instruction, make sure they are listed before
 208 // $literal, because the backend currently assumes that the last operand is
 209 // a literal.  Also be sure to update the enum R600Op1OperandIndex::ROI in
 210 // R600Defines.h, R600InstrInfo::buildDefaultInstruction(),
 211 // and R600InstrInfo::getOperandIdx().
 212 class R600_1OP <bits<11> inst, string opName, list<dag> pattern,
 213                 InstrItinClass itin = AnyALU> :
 214     InstR600 <0,
 215               (outs R600_Reg32:$dst),
 216               (ins WRITE:$write, OMOD:$omod, REL:$dst_rel, CLAMP:$clamp,
 217                    R600_Reg32:$src0, NEG:$src0_neg, REL:$src0_rel, ABS:$src0_abs,
 218                    LAST:$last, R600_Pred:$pred_sel, LITERAL:$literal),
 219               !strconcat(opName,
 220                    "$clamp $dst$write$dst_rel$omod, "
 221                    "$src0_neg$src0_abs$src0$src0_abs$src0_rel, "
 222                    "$literal $pred_sel$last"),
 223               pattern,
 224               itin>,
 225     R600ALU_Word0,
 226     R600ALU_Word1_OP2 <inst> {
 227
 228   let src1 = 0;
 229   let src1_rel = 0;
 230   let src1_neg = 0;
 231   let src1_abs = 0;
 232   let update_exec_mask = 0;
 233   let update_pred = 0;
 234   let HasNativeOperands = 1;
 235   let Op1 = 1;
 236   let DisableEncoding = "$literal";
 237
 238   let Inst{31-0}  = Word0;
 239   let Inst{63-32} = Word1;
 240 }
 241
 242 class R600_1OP_Helper <bits<11> inst, string opName, SDPatternOperator node,
 243                     InstrItinClass itin = AnyALU> :
 244     R600_1OP <inst, opName,
 245               [(set R600_Reg32:$dst, (node R600_Reg32:$src0))]
 246 >;
 247
 248 // If you add our change the operands for R600_2OP instructions, you must
 249 // also update the R600Op2OperandIndex::ROI enum in R600Defines.h,
 250 // R600InstrInfo::buildDefaultInstruction(), and R600InstrInfo::getOperandIdx().
 251 class R600_2OP <bits<11> inst, string opName, list<dag> pattern,
 252                 InstrItinClass itin = AnyALU> :
 253   InstR600 <inst,
 254           (outs R600_Reg32:$dst),
 255           (ins UEM:$update_exec_mask, UP:$update_pred, WRITE:$write,
 256                OMOD:$omod, REL:$dst_rel, CLAMP:$clamp,
 257                R600_Reg32:$src0, NEG:$src0_neg, REL:$src0_rel, ABS:$src0_abs,
 258                R600_Reg32:$src1, NEG:$src1_neg, REL:$src1_rel, ABS:$src1_abs,
 259                LAST:$last, R600_Pred:$pred_sel, LITERAL:$literal),
 260           !strconcat(opName,
 261                 "$clamp $update_exec_mask$update_pred$dst$write$dst_rel$omod, "
 262                 "$src0_neg$src0_abs$src0$src0_abs$src0_rel, "
 263                 "$src1_neg$src1_abs$src1$src1_abs$src1_rel, "
 264                 "$literal $pred_sel$last"),
 265           pattern,
 266           itin>,
 267     R600ALU_Word0,
 268     R600ALU_Word1_OP2 <inst> {
 269
 270   let HasNativeOperands = 1;
 271   let Op2 = 1;
 272   let DisableEncoding = "$literal";
 273
 274   let Inst{31-0}  = Word0;
 275   let Inst{63-32} = Word1;
 276 }
 277
 278 class R600_2OP_Helper <bits<11> inst, string opName, SDPatternOperator node,
 279                        InstrItinClass itim = AnyALU> :
 280     R600_2OP <inst, opName,
 281               [(set R600_Reg32:$dst, (node R600_Reg32:$src0,
 282                                            R600_Reg32:$src1))]
 283 >;
 284
 285 // If you add our change the operands for R600_3OP instructions, you must
 286 // also update the R600Op3OperandIndex::ROI enum in R600Defines.h,
 287 // R600InstrInfo::buildDefaultInstruction(), and
 288 // R600InstrInfo::getOperandIdx().
 289 class R600_3OP <bits<5> inst, string opName, list<dag> pattern,
 290                 InstrItinClass itin = AnyALU> :
 291   InstR600 <0,
 292           (outs R600_Reg32:$dst),
 293           (ins REL:$dst_rel, CLAMP:$clamp,
 294                R600_Reg32:$src0, NEG:$src0_neg, REL:$src0_rel,
 295                R600_Reg32:$src1, NEG:$src1_neg, REL:$src1_rel,
 296                R600_Reg32:$src2, NEG:$src2_neg, REL:$src2_rel,
 297                LAST:$last, R600_Pred:$pred_sel, LITERAL:$literal),
 298           !strconcat(opName, "$clamp $dst$dst_rel, "
 299                              "$src0_neg$src0$src0_rel, "
 300                              "$src1_neg$src1$src1_rel, "
 301                              "$src2_neg$src2$src2_rel, "
 302                              "$literal $pred_sel$last"),
 303           pattern,
 304           itin>,
 305     R600ALU_Word0,
 306     R600ALU_Word1_OP3<inst>{
 307
 308   let HasNativeOperands = 1;
 309   let DisableEncoding = "$literal";
 310   let Op3 = 1;
 311
 312   let Inst{31-0}  = Word0;
 313   let Inst{63-32} = Word1;
 314 }
 315
 316 class R600_REDUCTION <bits<11> inst, dag ins, string asm, list<dag> pattern,
 317                       InstrItinClass itin = VecALU> :
 318   InstR600 <inst,
 319           (outs R600_Reg32:$dst),
 320           ins,
 321           asm,
 322           pattern,
 323           itin>;
 324
 325 class R600_TEX <bits<11> inst, string opName, list<dag> pattern,
 326                 InstrItinClass itin = AnyALU> :
 327   InstR600 <inst,
 328           (outs R600_Reg128:$dst),
 329           (ins R600_Reg128:$src0, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
 330           !strconcat(opName, "$dst, $src0, $resourceId, $samplerId, $textureTarget"),
 331           pattern,
 332           itin>{
 333     let Inst {10-0} = inst;
 334   }
 335
 336 } // End mayLoad = 1, mayStore = 0, hasSideEffects = 0
 337
 338 def TEX_SHADOW : PatLeaf<
 339   (imm),
 340   [{uint32_t TType = (uint32_t)N->getZExtValue();
 341     return (TType >= 6 && TType <= 8) || (TType >= 11 && TType <= 13);
 342   }]
 343 >;
 344
 345 def TEX_RECT : PatLeaf<
 346   (imm),
 347   [{uint32_t TType = (uint32_t)N->getZExtValue();
 348     return TType == 5;
 349   }]
 350 >;
 351
 352 class EG_CF_RAT <bits <8> cf_inst, bits <6> rat_inst, bits<4> rat_id, dag outs,
 353                  dag ins, string asm, list<dag> pattern> :
 354     InstR600ISA <outs, ins, asm, pattern> {
 355   bits<7>  RW_GPR;
 356   bits<7>  INDEX_GPR;
 357
 358   bits<2>  RIM;
 359   bits<2>  TYPE;
 360   bits<1>  RW_REL;
 361   bits<2>  ELEM_SIZE;
 362
 363   bits<12> ARRAY_SIZE;
 364   bits<4>  COMP_MASK;
 365   bits<4>  BURST_COUNT;
 366   bits<1>  VPM;
 367   bits<1>  eop;
 368   bits<1>  MARK;
 369   bits<1>  BARRIER;
 370
 371   // CF_ALLOC_EXPORT_WORD0_RAT
 372   let Inst{3-0}   = rat_id;
 373   let Inst{9-4}   = rat_inst;
 374   let Inst{10}    = 0; // Reserved
 375   let Inst{12-11} = RIM;
 376   let Inst{14-13} = TYPE;
 377   let Inst{21-15} = RW_GPR;
 378   let Inst{22}    = RW_REL;
 379   let Inst{29-23} = INDEX_GPR;
 380   let Inst{31-30} = ELEM_SIZE;
 381
 382   // CF_ALLOC_EXPORT_WORD1_BUF
 383   let Inst{43-32} = ARRAY_SIZE;
 384   let Inst{47-44} = COMP_MASK;
 385   let Inst{51-48} = BURST_COUNT;
 386   let Inst{52}    = VPM;
 387   let Inst{53}    = eop;
 388   let Inst{61-54} = cf_inst;
 389   let Inst{62}    = MARK;
 390   let Inst{63}    = BARRIER;
 391 }
 392
 393 class LoadParamFrag <PatFrag load_type> : PatFrag <
 394   (ops node:$ptr), (load_type node:$ptr),
 395   [{ return isParamLoad(dyn_cast<LoadSDNode>(N)); }]
 396 >;
 397
 398 def load_param : LoadParamFrag<load>;
 399 def load_param_zexti8 : LoadParamFrag<zextloadi8>;
 400 def load_param_zexti16 : LoadParamFrag<zextloadi16>;
 401
 402 def isR600 : Predicate<"Subtarget.device()"
 403                             "->getGeneration() == AMDGPUDeviceInfo::HD4XXX">;
 404 def isR700 : Predicate<"Subtarget.device()"
 405                             "->getGeneration() == AMDGPUDeviceInfo::HD4XXX &&"
 406                             "Subtarget.device()->getDeviceFlag()"
 407                             ">= OCL_DEVICE_RV710">;
 408 def isEG : Predicate<
 409   "Subtarget.device()->getGeneration() >= AMDGPUDeviceInfo::HD5XXX && "
 410   "Subtarget.device()->getGeneration() < AMDGPUDeviceInfo::HD7XXX && "
 411   "Subtarget.device()->getDeviceFlag() != OCL_DEVICE_CAYMAN">;
 412
 413 def isCayman : Predicate<"Subtarget.device()"
 414                             "->getDeviceFlag() == OCL_DEVICE_CAYMAN">;
 415 def isEGorCayman : Predicate<"Subtarget.device()"
 416                             "->getGeneration() == AMDGPUDeviceInfo::HD5XXX"
 417                             "|| Subtarget.device()->getGeneration() =="
 418                             "AMDGPUDeviceInfo::HD6XXX">;
 419
 420 def isR600toCayman : Predicate<
 421                      "Subtarget.device()->getGeneration() <= AMDGPUDeviceInfo::HD6XXX">;
 422
 423 //===----------------------------------------------------------------------===//
 424 // Interpolation Instructions
 425 //===----------------------------------------------------------------------===//
 426
 427 def INTERP: SDNode<"AMDGPUISD::INTERP",
 428   SDTypeProfile<1, 2, [SDTCisFP<0>, SDTCisInt<1>, SDTCisInt<2>]>
 429   >;
 430
 431 def INTERP_P0: SDNode<"AMDGPUISD::INTERP_P0",
 432   SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisInt<1>]>
 433   >;
 434
 435 let usesCustomInserter = 1 in {
 436 def input_perspective :  AMDGPUShaderInst <
 437   (outs R600_Reg128:$dst),
 438   (ins i32imm:$src0, i32imm:$src1),
 439   "input_perspective $src0 $src1 : dst",
 440   [(set R600_Reg128:$dst, (INTERP (i32 imm:$src0), (i32 imm:$src1)))]>;
 441 }  // End usesCustomInserter = 1
 442
 443 def input_constant :  AMDGPUShaderInst <
 444   (outs R600_Reg128:$dst),
 445   (ins i32imm:$src),
 446   "input_perspective $src : dst",
 447   [(set R600_Reg128:$dst, (INTERP_P0 (i32 imm:$src)))]>;
 448
 449
 450
 451 def INTERP_XY : R600_2OP <0xD6, "INTERP_XY", []> {
 452   let bank_swizzle = 5;
 453 }
 454
 455 def INTERP_ZW : R600_2OP <0xD7, "INTERP_ZW", []> {
 456   let bank_swizzle = 5;
 457 }
 458
 459 def INTERP_LOAD_P0 : R600_1OP <0xE0, "INTERP_LOAD_P0", []>;
 460
 461 //===----------------------------------------------------------------------===//
 462 // Export Instructions
 463 //===----------------------------------------------------------------------===//
 464
 465 def ExportType : SDTypeProfile<0, 5, [SDTCisFP<0>, SDTCisInt<1>]>;
 466
 467 def EXPORT: SDNode<"AMDGPUISD::EXPORT", ExportType,
 468   [SDNPHasChain, SDNPSideEffect]>;
 469
 470 class ExportWord0 {
 471   field bits<32> Word0;
 472
 473   bits<13> arraybase;
 474   bits<2> type;
 475   bits<7> gpr;
 476   bits<2> elem_size;
 477
 478   let Word0{12-0} = arraybase;
 479   let Word0{14-13} = type;
 480   let Word0{21-15} = gpr;
 481   let Word0{22} = 0; // RW_REL
 482   let Word0{29-23} = 0; // INDEX_GPR
 483   let Word0{31-30} = elem_size;
 484 }
 485
 486 class ExportSwzWord1 {
 487   field bits<32> Word1;
 488
 489   bits<3> sw_x;
 490   bits<3> sw_y;
 491   bits<3> sw_z;
 492   bits<3> sw_w;
 493   bits<1> eop;
 494   bits<8> inst;
 495
 496   let Word1{2-0} = sw_x;
 497   let Word1{5-3} = sw_y;
 498   let Word1{8-6} = sw_z;
 499   let Word1{11-9} = sw_w;
 500 }
 501
 502 class ExportBufWord1 {
 503   field bits<32> Word1;
 504
 505   bits<12> arraySize;
 506   bits<4> compMask;
 507   bits<1> eop;
 508   bits<8> inst;
 509
 510   let Word1{11-0} = arraySize;
 511   let Word1{15-12} = compMask;
 512 }
 513
 514 multiclass ExportPattern<Instruction ExportInst, bits<8> cf_inst> {
 515   def : Pat<(int_R600_store_pixel_depth R600_Reg32:$reg),
 516     (ExportInst
 517         (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), R600_Reg32:$reg, sel_x),
 518         0, 61, 0, 7, 7, 7, cf_inst, 0)
 519   >;
 520
 521   def : Pat<(int_R600_store_pixel_stencil R600_Reg32:$reg),
 522     (ExportInst
 523         (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), R600_Reg32:$reg, sel_x),
 524         0, 61, 7, 0, 7, 7, cf_inst, 0)
 525   >;
 526
 527   def : Pat<(int_R600_store_pixel_dummy),
 528     (ExportInst
 529         (v4f32 (IMPLICIT_DEF)), 0, 0, 7, 7, 7, 7, cf_inst, 0)
 530   >;
 531
 532   def : Pat<(EXPORT (v4f32 R600_Reg128:$src), (i32 0),
 533     (i32 imm:$type), (i32 imm:$arraybase), (i32 imm)),
 534         (ExportInst R600_Reg128:$src, imm:$type, imm:$arraybase,
 535         0, 1, 2, 3, cf_inst, 0)
 536   >;
 537 }
 538
 539 multiclass SteamOutputExportPattern<Instruction ExportInst,
 540     bits<8> buf0inst, bits<8> buf1inst, bits<8> buf2inst, bits<8> buf3inst> {
 541 // Stream0
 542   def : Pat<(EXPORT (v4f32 R600_Reg128:$src), (i32 1),
 543       (i32 imm:$type), (i32 imm:$arraybase), (i32 imm:$mask)),
 544       (ExportInst R600_Reg128:$src, imm:$type, imm:$arraybase,
 545       4095, imm:$mask, buf0inst, 0)>;
 546 // Stream1
 547   def : Pat<(EXPORT (v4f32 R600_Reg128:$src), (i32 2),
 548       (i32 imm:$type), (i32 imm:$arraybase), (i32 imm:$mask)),
 549       (ExportInst R600_Reg128:$src, imm:$type, imm:$arraybase,
 550       4095, imm:$mask, buf1inst, 0)>;
 551 // Stream2
 552   def : Pat<(EXPORT (v4f32 R600_Reg128:$src), (i32 3),
 553       (i32 imm:$type), (i32 imm:$arraybase), (i32 imm:$mask)),
 554       (ExportInst R600_Reg128:$src, imm:$type, imm:$arraybase,
 555       4095, imm:$mask, buf2inst, 0)>;
 556 // Stream3
 557   def : Pat<(EXPORT (v4f32 R600_Reg128:$src), (i32 4),
 558       (i32 imm:$type), (i32 imm:$arraybase), (i32 imm:$mask)),
 559       (ExportInst R600_Reg128:$src, imm:$type, imm:$arraybase,
 560       4095, imm:$mask, buf3inst, 0)>;
 561 }
 562
 563 let isTerminator = 1, usesCustomInserter = 1 in {
 564
 565 class ExportSwzInst : InstR600ISA<(
 566     outs),
 567     (ins R600_Reg128:$gpr, i32imm:$type, i32imm:$arraybase,
 568     i32imm:$sw_x, i32imm:$sw_y, i32imm:$sw_z, i32imm:$sw_w, i32imm:$inst,
 569     i32imm:$eop),
 570     !strconcat("EXPORT", " $gpr"),
 571     []>, ExportWord0, ExportSwzWord1 {
 572   let elem_size = 3;
 573   let Inst{31-0} = Word0;
 574   let Inst{63-32} = Word1;
 575 }
 576
 577 } // End isTerminator = 1, usesCustomInserter = 1
 578
 579 class ExportBufInst : InstR600ISA<(
 580     outs),
 581     (ins R600_Reg128:$gpr, i32imm:$type, i32imm:$arraybase,
 582     i32imm:$arraySize, i32imm:$compMask, i32imm:$inst, i32imm:$eop),
 583     !strconcat("EXPORT", " $gpr"),
 584     []>, ExportWord0, ExportBufWord1 {
 585   let elem_size = 0;
 586   let Inst{31-0} = Word0;
 587   let Inst{63-32} = Word1;
 588 }
 589
 590 let Predicates = [isR600toCayman] in {
 591
 592 //===----------------------------------------------------------------------===//
 593 // Common Instructions R600, R700, Evergreen, Cayman
 594 //===----------------------------------------------------------------------===//
 595
 596 def ADD : R600_2OP_Helper <0x0, "ADD", fadd>;
 597 // Non-IEEE MUL: 0 * anything = 0
 598 def MUL : R600_2OP_Helper <0x1, "MUL NON-IEEE", int_AMDGPU_mul>;
 599 def MUL_IEEE : R600_2OP_Helper <0x2, "MUL_IEEE", fmul>;
 600 def MAX : R600_2OP_Helper <0x3, "MAX", AMDGPUfmax>;
 601 def MIN : R600_2OP_Helper <0x4, "MIN", AMDGPUfmin>;
 602
 603 // For the SET* instructions there is a naming conflict in TargetSelectionDAG.td,
 604 // so some of the instruction names don't match the asm string.
 605 // XXX: Use the defs in TargetSelectionDAG.td instead of intrinsics.
 606 def SETE : R600_2OP <
 607   0x08, "SETE",
 608   [(set R600_Reg32:$dst,
 609    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 610              COND_EQ))]
 611 >;
 612
 613 def SGT : R600_2OP <
 614   0x09, "SETGT",
 615   [(set R600_Reg32:$dst,
 616    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 617               COND_GT))]
 618 >;
 619
 620 def SGE : R600_2OP <
 621   0xA, "SETGE",
 622   [(set R600_Reg32:$dst,
 623    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 624               COND_GE))]
 625 >;
 626
 627 def SNE : R600_2OP <
 628   0xB, "SETNE",
 629   [(set R600_Reg32:$dst,
 630    (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO,
 631     COND_NE))]
 632 >;
 633
 634 def FRACT : R600_1OP_Helper <0x10, "FRACT", AMDGPUfract>;
 635 def TRUNC : R600_1OP_Helper <0x11, "TRUNC", int_AMDGPU_trunc>;
 636 def CEIL : R600_1OP_Helper <0x12, "CEIL", fceil>;
 637 def RNDNE : R600_1OP_Helper <0x13, "RNDNE", frint>;
 638 def FLOOR : R600_1OP_Helper <0x14, "FLOOR", ffloor>;
 639
 640 def MOV : R600_1OP <0x19, "MOV", []>;
 641
 642 let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1 in {
 643
 644 class MOV_IMM <ValueType vt, Operand immType> : AMDGPUInst <
 645   (outs R600_Reg32:$dst),
 646   (ins immType:$imm),
 647   "",
 648   []
 649 >;
 650
 651 } // end let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1
 652
 653 def MOV_IMM_I32 : MOV_IMM<i32, i32imm>;
 654 def : Pat <
 655   (imm:$val),
 656   (MOV_IMM_I32 imm:$val)
 657 >;
 658
 659 def MOV_IMM_F32 : MOV_IMM<f32, f32imm>;
 660 def : Pat <
 661   (fpimm:$val),
 662   (MOV_IMM_F32  fpimm:$val)
 663 >;
 664
 665 def PRED_SETE : R600_2OP <0x20, "PRED_SETE", []>;
 666 def PRED_SETGT : R600_2OP <0x21, "PRED_SETGT", []>;
 667 def PRED_SETGE : R600_2OP <0x22, "PRED_SETGE", []>;
 668 def PRED_SETNE : R600_2OP <0x23, "PRED_SETNE", []>;
 669
 670 let hasSideEffects = 1 in {
 671
 672 def KILLGT : R600_2OP <0x2D, "KILLGT", []>;
 673
 674 } // end hasSideEffects
 675
 676 def AND_INT : R600_2OP_Helper <0x30, "AND_INT", and>;
 677 def OR_INT : R600_2OP_Helper <0x31, "OR_INT", or>;
 678 def XOR_INT : R600_2OP_Helper <0x32, "XOR_INT", xor>;
 679 def NOT_INT : R600_1OP_Helper <0x33, "NOT_INT", not>;
 680 def ADD_INT : R600_2OP_Helper <0x34, "ADD_INT", add>;
 681 def SUB_INT : R600_2OP_Helper <0x35, "SUB_INT", sub>;
 682 def MAX_INT : R600_2OP_Helper <0x36, "MAX_INT", AMDGPUsmax>;
 683 def MIN_INT : R600_2OP_Helper <0x37, "MIN_INT", AMDGPUsmin>;
 684 def MAX_UINT : R600_2OP_Helper <0x38, "MAX_UINT", AMDGPUumax>;
 685 def MIN_UINT : R600_2OP_Helper <0x39, "MIN_UINT", AMDGPUumin>;
 686
 687 def SETE_INT : R600_2OP <
 688   0x3A, "SETE_INT",
 689   [(set (i32 R600_Reg32:$dst),
 690    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETEQ))]
 691 >;
 692
 693 def SETGT_INT : R600_2OP <
 694   0x3B, "SGT_INT",
 695   [(set (i32 R600_Reg32:$dst),
 696    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETGT))]
 697 >;
 698
 699 def SETGE_INT : R600_2OP <
 700   0x3C, "SETGE_INT",
 701   [(set (i32 R600_Reg32:$dst),
 702    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETGE))]
 703 >;
 704
 705 def SETNE_INT : R600_2OP <
 706   0x3D, "SETNE_INT",
 707   [(set (i32 R600_Reg32:$dst),
 708    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETNE))]
 709 >;
 710
 711 def SETGT_UINT : R600_2OP <
 712   0x3E, "SETGT_UINT",
 713   [(set (i32 R600_Reg32:$dst),
 714    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUGT))]
 715 >;
 716
 717 def SETGE_UINT : R600_2OP <
 718   0x3F, "SETGE_UINT",
 719   [(set (i32 R600_Reg32:$dst),
 720     (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUGE))]
 721 >;
 722
 723 def PRED_SETE_INT : R600_2OP <0x42, "PRED_SETE_INT", []>;
 724 def PRED_SETGT_INT : R600_2OP <0x43, "PRED_SETGE_INT", []>;
 725 def PRED_SETGE_INT : R600_2OP <0x44, "PRED_SETGE_INT", []>;
 726 def PRED_SETNE_INT : R600_2OP <0x45, "PRED_SETNE_INT", []>;
 727
 728 def CNDE_INT : R600_3OP <
 729   0x1C, "CNDE_INT",
 730   [(set (i32 R600_Reg32:$dst),
 731    (selectcc (i32 R600_Reg32:$src0), 0,
 732        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
 733        COND_EQ))]
 734 >;
 735
 736 def CNDGE_INT : R600_3OP <
 737   0x1E, "CNDGE_INT",
 738   [(set (i32 R600_Reg32:$dst),
 739    (selectcc (i32 R600_Reg32:$src0), 0,
 740        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
 741        COND_GE))]
 742 >;
 743
 744 def CNDGT_INT : R600_3OP <
 745   0x1D, "CNDGT_INT",
 746   [(set (i32 R600_Reg32:$dst),
 747    (selectcc (i32 R600_Reg32:$src0), 0,
 748        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
 749        COND_GT))]
 750 >;
 751
 752 //===----------------------------------------------------------------------===//
 753 // Texture instructions
 754 //===----------------------------------------------------------------------===//
 755
 756 def TEX_LD : R600_TEX <
 757   0x03, "TEX_LD",
 758   [(set R600_Reg128:$dst, (int_AMDGPU_txf R600_Reg128:$src0, imm:$src1, imm:$src2, imm:$src3, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 759 > {
 760 let AsmString = "TEX_LD $dst, $src0, $src1, $src2, $src3, $resourceId, $samplerId, $textureTarget";
 761 let InOperandList = (ins R600_Reg128:$src0, i32imm:$src1, i32imm:$src2, i32imm:$src3, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget);
 762 }
 763
 764 def TEX_GET_TEXTURE_RESINFO : R600_TEX <
 765   0x04, "TEX_GET_TEXTURE_RESINFO",
 766   [(set R600_Reg128:$dst, (int_AMDGPU_txq R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 767 >;
 768
 769 def TEX_GET_GRADIENTS_H : R600_TEX <
 770   0x07, "TEX_GET_GRADIENTS_H",
 771   [(set R600_Reg128:$dst, (int_AMDGPU_ddx R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 772 >;
 773
 774 def TEX_GET_GRADIENTS_V : R600_TEX <
 775   0x08, "TEX_GET_GRADIENTS_V",
 776   [(set R600_Reg128:$dst, (int_AMDGPU_ddy R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 777 >;
 778
 779 def TEX_SET_GRADIENTS_H : R600_TEX <
 780   0x0B, "TEX_SET_GRADIENTS_H",
 781   []
 782 >;
 783
 784 def TEX_SET_GRADIENTS_V : R600_TEX <
 785   0x0C, "TEX_SET_GRADIENTS_V",
 786   []
 787 >;
 788
 789 def TEX_SAMPLE : R600_TEX <
 790   0x10, "TEX_SAMPLE",
 791   [(set R600_Reg128:$dst, (int_AMDGPU_tex R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 792 >;
 793
 794 def TEX_SAMPLE_C : R600_TEX <
 795   0x18, "TEX_SAMPLE_C",
 796   [(set R600_Reg128:$dst, (int_AMDGPU_tex R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
 797 >;
 798
 799 def TEX_SAMPLE_L : R600_TEX <
 800   0x11, "TEX_SAMPLE_L",
 801   [(set R600_Reg128:$dst, (int_AMDGPU_txl R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 802 >;
 803
 804 def TEX_SAMPLE_C_L : R600_TEX <
 805   0x19, "TEX_SAMPLE_C_L",
 806   [(set R600_Reg128:$dst, (int_AMDGPU_txl R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
 807 >;
 808
 809 def TEX_SAMPLE_LB : R600_TEX <
 810   0x12, "TEX_SAMPLE_LB",
 811   [(set R600_Reg128:$dst, (int_AMDGPU_txb R600_Reg128:$src0,imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 812 >;
 813
 814 def TEX_SAMPLE_C_LB : R600_TEX <
 815   0x1A, "TEX_SAMPLE_C_LB",
 816   [(set R600_Reg128:$dst, (int_AMDGPU_txb R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
 817 >;
 818
 819 def TEX_SAMPLE_G : R600_TEX <
 820   0x14, "TEX_SAMPLE_G",
 821   []
 822 >;
 823
 824 def TEX_SAMPLE_C_G : R600_TEX <
 825   0x1C, "TEX_SAMPLE_C_G",
 826   []
 827 >;
 828
 829 //===----------------------------------------------------------------------===//
 830 // Helper classes for common instructions
 831 //===----------------------------------------------------------------------===//
 832
 833 class MUL_LIT_Common <bits<5> inst> : R600_3OP <
 834   inst, "MUL_LIT",
 835   []
 836 >;
 837
 838 class MULADD_Common <bits<5> inst> : R600_3OP <
 839   inst, "MULADD",
 840   [(set (f32 R600_Reg32:$dst),
 841    (IL_mad R600_Reg32:$src0, R600_Reg32:$src1, R600_Reg32:$src2))]
 842 >;
 843
 844 class CNDE_Common <bits<5> inst> : R600_3OP <
 845   inst, "CNDE",
 846   [(set R600_Reg32:$dst,
 847    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
 848        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
 849        COND_EQ))]
 850 >;
 851
 852 class CNDGT_Common <bits<5> inst> : R600_3OP <
 853   inst, "CNDGT",
 854   [(set R600_Reg32:$dst,
 855    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
 856        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
 857        COND_GT))]
 858 >;
 859
 860 class CNDGE_Common <bits<5> inst> : R600_3OP <
 861   inst, "CNDGE",
 862   [(set R600_Reg32:$dst,
 863    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
 864        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
 865        COND_GE))]
 866 >;
 867
 868 multiclass DOT4_Common <bits<11> inst> {
 869
 870   def _pseudo : R600_REDUCTION <inst,
 871     (ins R600_Reg128:$src0, R600_Reg128:$src1),
 872     "DOT4 $dst $src0, $src1",
 873     [(set R600_Reg32:$dst, (int_AMDGPU_dp4 R600_Reg128:$src0, R600_Reg128:$src1))]
 874   >;
 875
 876   def _real : R600_2OP <inst, "DOT4", []>;
 877 }
 878
 879 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
 880 multiclass CUBE_Common <bits<11> inst> {
 881
 882   def _pseudo : InstR600 <
 883     inst,
 884     (outs R600_Reg128:$dst),
 885     (ins R600_Reg128:$src),
 886     "CUBE $dst $src",
 887     [(set R600_Reg128:$dst, (int_AMDGPU_cube R600_Reg128:$src))],
 888     VecALU
 889   > {
 890     let isPseudo = 1;
 891   }
 892
 893   def _real : R600_2OP <inst, "CUBE", []>;
 894 }
 895 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 0
 896
 897 class EXP_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
 898   inst, "EXP_IEEE", fexp2
 899 >;
 900
 901 class FLT_TO_INT_Common <bits<11> inst> : R600_1OP_Helper <
 902   inst, "FLT_TO_INT", fp_to_sint
 903 >;
 904
 905 class INT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
 906   inst, "INT_TO_FLT", sint_to_fp
 907 >;
 908
 909 class FLT_TO_UINT_Common <bits<11> inst> : R600_1OP_Helper <
 910   inst, "FLT_TO_UINT", fp_to_uint
 911 >;
 912
 913 class UINT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
 914   inst, "UINT_TO_FLT", uint_to_fp
 915 >;
 916
 917 class LOG_CLAMPED_Common <bits<11> inst> : R600_1OP <
 918   inst, "LOG_CLAMPED", []
 919 >;
 920
 921 class LOG_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
 922   inst, "LOG_IEEE", flog2
 923 >;
 924
 925 class LSHL_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHL", shl>;
 926 class LSHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHR", srl>;
 927 class ASHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "ASHR", sra>;
 928 class MULHI_INT_Common <bits<11> inst> : R600_2OP_Helper <
 929   inst, "MULHI_INT", mulhs
 930 >;
 931 class MULHI_UINT_Common <bits<11> inst> : R600_2OP_Helper <
 932   inst, "MULHI", mulhu
 933 >;
 934 class MULLO_INT_Common <bits<11> inst> : R600_2OP_Helper <
 935   inst, "MULLO_INT", mul
 936 >;
 937 class MULLO_UINT_Common <bits<11> inst> : R600_2OP <inst, "MULLO_UINT", []>;
 938
 939 class RECIP_CLAMPED_Common <bits<11> inst> : R600_1OP <
 940   inst, "RECIP_CLAMPED", []
 941 >;
 942
 943 class RECIP_IEEE_Common <bits<11> inst> : R600_1OP <
 944   inst, "RECIP_IEEE", [(set R600_Reg32:$dst, (fdiv FP_ONE, R600_Reg32:$src0))]
 945 >;
 946
 947 class RECIP_UINT_Common <bits<11> inst> : R600_1OP_Helper <
 948   inst, "RECIP_UINT", AMDGPUurecip
 949 >;
 950
 951 class RECIPSQRT_CLAMPED_Common <bits<11> inst> : R600_1OP_Helper <
 952   inst, "RECIPSQRT_CLAMPED", int_AMDGPU_rsq
 953 >;
 954
 955 class RECIPSQRT_IEEE_Common <bits<11> inst> : R600_1OP <
 956   inst, "RECIPSQRT_IEEE", []
 957 >;
 958
 959 class SIN_Common <bits<11> inst> : R600_1OP <
 960   inst, "SIN", []>{
 961   let Trig = 1;
 962 }
 963
 964 class COS_Common <bits<11> inst> : R600_1OP <
 965   inst, "COS", []> {
 966   let Trig = 1;
 967 }
 968
 969 //===----------------------------------------------------------------------===//
 970 // Helper patterns for complex intrinsics
 971 //===----------------------------------------------------------------------===//
 972
 973 multiclass DIV_Common <InstR600 recip_ieee> {
 974 def : Pat<
 975   (int_AMDGPU_div R600_Reg32:$src0, R600_Reg32:$src1),
 976   (MUL R600_Reg32:$src0, (recip_ieee R600_Reg32:$src1))
 977 >;
 978
 979 def : Pat<
 980   (fdiv R600_Reg32:$src0, R600_Reg32:$src1),
 981   (MUL R600_Reg32:$src0, (recip_ieee R600_Reg32:$src1))
 982 >;
 983 }
 984
 985 class TGSI_LIT_Z_Common <InstR600 mul_lit, InstR600 log_clamped, InstR600 exp_ieee> : Pat <
 986   (int_TGSI_lit_z R600_Reg32:$src_x, R600_Reg32:$src_y, R600_Reg32:$src_w),
 987   (exp_ieee (mul_lit (log_clamped (MAX R600_Reg32:$src_y, (f32 ZERO))), R600_Reg32:$src_w, R600_Reg32:$src_x))
 988 >;
 989
 990 //===----------------------------------------------------------------------===//
 991 // R600 / R700 Instructions
 992 //===----------------------------------------------------------------------===//
 993
 994 let Predicates = [isR600] in {
 995
 996   def MUL_LIT_r600 : MUL_LIT_Common<0x0C>;
 997   def MULADD_r600 : MULADD_Common<0x10>;
 998   def CNDE_r600 : CNDE_Common<0x18>;
 999   def CNDGT_r600 : CNDGT_Common<0x19>;
1000   def CNDGE_r600 : CNDGE_Common<0x1A>;
1001   defm DOT4_r600 : DOT4_Common<0x50>;
1002   defm CUBE_r600 : CUBE_Common<0x52>;
1003   def EXP_IEEE_r600 : EXP_IEEE_Common<0x61>;
1004   def LOG_CLAMPED_r600 : LOG_CLAMPED_Common<0x62>;
1005   def LOG_IEEE_r600 : LOG_IEEE_Common<0x63>;
1006   def RECIP_CLAMPED_r600 : RECIP_CLAMPED_Common<0x64>;
1007   def RECIP_IEEE_r600 : RECIP_IEEE_Common<0x66>;
1008   def RECIPSQRT_CLAMPED_r600 : RECIPSQRT_CLAMPED_Common<0x67>;
1009   def RECIPSQRT_IEEE_r600 : RECIPSQRT_IEEE_Common<0x69>;
1010   def FLT_TO_INT_r600 : FLT_TO_INT_Common<0x6b>;
1011   def INT_TO_FLT_r600 : INT_TO_FLT_Common<0x6c>;
1012   def FLT_TO_UINT_r600 : FLT_TO_UINT_Common<0x79>;
1013   def UINT_TO_FLT_r600 : UINT_TO_FLT_Common<0x6d>;
1014   def SIN_r600 : SIN_Common<0x6E>;
1015   def COS_r600 : COS_Common<0x6F>;
1016   def ASHR_r600 : ASHR_Common<0x70>;
1017   def LSHR_r600 : LSHR_Common<0x71>;
1018   def LSHL_r600 : LSHL_Common<0x72>;
1019   def MULLO_INT_r600 : MULLO_INT_Common<0x73>;
1020   def MULHI_INT_r600 : MULHI_INT_Common<0x74>;
1021   def MULLO_UINT_r600 : MULLO_UINT_Common<0x75>;
1022   def MULHI_UINT_r600 : MULHI_UINT_Common<0x76>;
1023   def RECIP_UINT_r600 : RECIP_UINT_Common <0x78>;
1024
1025   defm DIV_r600 : DIV_Common<RECIP_IEEE_r600>;
1026   def TGSI_LIT_Z_r600 : TGSI_LIT_Z_Common<MUL_LIT_r600, LOG_CLAMPED_r600, EXP_IEEE_r600>;
1027
1028   def : Pat<(fsqrt R600_Reg32:$src),
1029     (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_r600 R600_Reg32:$src))>;
1030
1031   def R600_ExportSwz : ExportSwzInst {
1032     let Word1{20-17} = 1; // BURST_COUNT
1033     let Word1{21} = eop;
1034     let Word1{22} = 1; // VALID_PIXEL_MODE
1035     let Word1{30-23} = inst;
1036     let Word1{31} = 1; // BARRIER
1037   }
1038   defm : ExportPattern<R600_ExportSwz, 39>;
1039
1040   def R600_ExportBuf : ExportBufInst {
1041     let Word1{20-17} = 1; // BURST_COUNT
1042     let Word1{21} = eop;
1043     let Word1{22} = 1; // VALID_PIXEL_MODE
1044     let Word1{30-23} = inst;
1045     let Word1{31} = 1; // BARRIER
1046   }
1047   defm : SteamOutputExportPattern<R600_ExportBuf, 0x20, 0x21, 0x22, 0x23>;
1048 }
1049
1050 // Helper pattern for normalizing inputs to triginomic instructions for R700+
1051 // cards.
1052 class COS_PAT <InstR600 trig> : Pat<
1053   (fcos R600_Reg32:$src),
1054   (trig (MUL (MOV_IMM_I32 CONST.TWO_PI_INV), R600_Reg32:$src))
1055 >;
1056
1057 class SIN_PAT <InstR600 trig> : Pat<
1058   (fsin R600_Reg32:$src),
1059   (trig (MUL (MOV_IMM_I32 CONST.TWO_PI_INV), R600_Reg32:$src))
1060 >;
1061
1062 //===----------------------------------------------------------------------===//
1063 // R700 Only instructions
1064 //===----------------------------------------------------------------------===//
1065
1066 let Predicates = [isR700] in {
1067   def SIN_r700 : SIN_Common<0x6E>;
1068   def COS_r700 : COS_Common<0x6F>;
1069
1070   // R700 normalizes inputs to SIN/COS the same as EG
1071   def : SIN_PAT <SIN_r700>;
1072   def : COS_PAT <COS_r700>;
1073 }
1074
1075 //===----------------------------------------------------------------------===//
1076 // Evergreen Only instructions
1077 //===----------------------------------------------------------------------===//
1078
1079 let Predicates = [isEG] in {
1080
1081 def RECIP_IEEE_eg : RECIP_IEEE_Common<0x86>;
1082 defm DIV_eg : DIV_Common<RECIP_IEEE_eg>;
1083
1084 def MULLO_INT_eg : MULLO_INT_Common<0x8F>;
1085 def MULHI_INT_eg : MULHI_INT_Common<0x90>;
1086 def MULLO_UINT_eg : MULLO_UINT_Common<0x91>;
1087 def MULHI_UINT_eg : MULHI_UINT_Common<0x92>;
1088 def RECIP_UINT_eg : RECIP_UINT_Common<0x94>;
1089 def RECIPSQRT_CLAMPED_eg : RECIPSQRT_CLAMPED_Common<0x87>;
1090 def EXP_IEEE_eg : EXP_IEEE_Common<0x81>;
1091 def LOG_IEEE_eg : LOG_IEEE_Common<0x83>;
1092 def RECIP_CLAMPED_eg : RECIP_CLAMPED_Common<0x84>;
1093 def RECIPSQRT_IEEE_eg : RECIPSQRT_IEEE_Common<0x89>;
1094 def SIN_eg : SIN_Common<0x8D>;
1095 def COS_eg : COS_Common<0x8E>;
1096
1097 def : SIN_PAT <SIN_eg>;
1098 def : COS_PAT <COS_eg>;
1099 def : Pat<(fsqrt R600_Reg32:$src),
1100   (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_eg R600_Reg32:$src))>;
1101 } // End Predicates = [isEG]
1102
1103 //===----------------------------------------------------------------------===//
1104 // Evergreen / Cayman Instructions
1105 //===----------------------------------------------------------------------===//
1106
1107 let Predicates = [isEGorCayman] in {
1108
1109   // BFE_UINT - bit_extract, an optimization for mask and shift
1110   // Src0 = Input
1111   // Src1 = Offset
1112   // Src2 = Width
1113   //
1114   // bit_extract = (Input << (32 - Offset - Width)) >> (32 - Width)
1115   //
1116   // Example Usage:
1117   // (Offset, Width)
1118   //
1119   // (0, 8)           = (Input << 24) >> 24  = (Input &  0xff)       >> 0
1120   // (8, 8)           = (Input << 16) >> 24  = (Input &  0xffff)     >> 8
1121   // (16,8)           = (Input <<  8) >> 24  = (Input &  0xffffff)   >> 16
1122   // (24,8)           = (Input <<  0) >> 24  = (Input &  0xffffffff) >> 24
1123   def BFE_UINT_eg : R600_3OP <0x4, "BFE_UINT",
1124     [(set R600_Reg32:$dst, (int_AMDIL_bit_extract_u32 R600_Reg32:$src0,
1125                                                       R600_Reg32:$src1,
1126                                                       R600_Reg32:$src2))],
1127     VecALU
1128   >;
1129
1130   def BIT_ALIGN_INT_eg : R600_3OP <0xC, "BIT_ALIGN_INT",
1131     [(set R600_Reg32:$dst, (AMDGPUbitalign R600_Reg32:$src0, R600_Reg32:$src1,
1132                                           R600_Reg32:$src2))],
1133     VecALU
1134   >;
1135
1136   def MULADD_eg : MULADD_Common<0x14>;
1137   def ASHR_eg : ASHR_Common<0x15>;
1138   def LSHR_eg : LSHR_Common<0x16>;
1139   def LSHL_eg : LSHL_Common<0x17>;
1140   def CNDE_eg : CNDE_Common<0x19>;
1141   def CNDGT_eg : CNDGT_Common<0x1A>;
1142   def CNDGE_eg : CNDGE_Common<0x1B>;
1143   def MUL_LIT_eg : MUL_LIT_Common<0x1F>;
1144   def LOG_CLAMPED_eg : LOG_CLAMPED_Common<0x82>;
1145   defm DOT4_eg : DOT4_Common<0xBE>;
1146   defm CUBE_eg : CUBE_Common<0xC0>;
1147
1148   def TGSI_LIT_Z_eg : TGSI_LIT_Z_Common<MUL_LIT_eg, LOG_CLAMPED_eg, EXP_IEEE_eg>;
1149
1150   def FLT_TO_INT_eg : FLT_TO_INT_Common<0x50> {
1151     let Pattern = [];
1152   }
1153
1154   def INT_TO_FLT_eg : INT_TO_FLT_Common<0x9B>;
1155
1156   def FLT_TO_UINT_eg : FLT_TO_UINT_Common<0x9A> {
1157     let Pattern = [];
1158   }
1159
1160   def UINT_TO_FLT_eg : UINT_TO_FLT_Common<0x9C>;
1161
1162   // TRUNC is used for the FLT_TO_INT instructions to work around a
1163   // perceived problem where the rounding modes are applied differently
1164   // depending on the instruction and the slot they are in.
1165   // See:
1166   // https://bugs.freedesktop.org/show_bug.cgi?id=50232
1167   // Mesa commit: a1a0974401c467cb86ef818f22df67c21774a38c
1168   //
1169   // XXX: Lowering SELECT_CC will sometimes generate fp_to_[su]int nodes,
1170   // which do not need to be truncated since the fp values are 0.0f or 1.0f.
1171   // We should look into handling these cases separately.
1172   def : Pat<(fp_to_sint R600_Reg32:$src0),
1173     (FLT_TO_INT_eg (TRUNC R600_Reg32:$src0))>;
1174
1175   def : Pat<(fp_to_uint R600_Reg32:$src0),
1176     (FLT_TO_UINT_eg (TRUNC R600_Reg32:$src0))>;
1177
1178   def EG_ExportSwz : ExportSwzInst {
1179     let Word1{19-16} = 1; // BURST_COUNT
1180     let Word1{20} = 1; // VALID_PIXEL_MODE
1181     let Word1{21} = eop;
1182     let Word1{29-22} = inst;
1183     let Word1{30} = 0; // MARK
1184     let Word1{31} = 1; // BARRIER
1185   }
1186   defm : ExportPattern<EG_ExportSwz, 83>;
1187
1188   def EG_ExportBuf : ExportBufInst {
1189     let Word1{19-16} = 1; // BURST_COUNT
1190     let Word1{20} = 1; // VALID_PIXEL_MODE
1191     let Word1{21} = eop;
1192     let Word1{29-22} = inst;
1193     let Word1{30} = 0; // MARK
1194     let Word1{31} = 1; // BARRIER
1195   }
1196   defm : SteamOutputExportPattern<EG_ExportBuf, 0x40, 0x41, 0x42, 0x43>;
1197
1198 //===----------------------------------------------------------------------===//
1199 // Memory read/write instructions
1200 //===----------------------------------------------------------------------===//
1201 let usesCustomInserter = 1 in {
1202
1203 class RAT_WRITE_CACHELESS_eg <dag ins, bits<4> comp_mask, string name,
1204                               list<dag> pattern>
1205     : EG_CF_RAT <0x57, 0x2, 0, (outs), ins,
1206                  !strconcat(name, " $rw_gpr, $index_gpr, $eop"), pattern> {
1207   let RIM         = 0;
1208   // XXX: Have a separate instruction for non-indexed writes.
1209   let TYPE        = 1;
1210   let RW_REL      = 0;
1211   let ELEM_SIZE   = 0;
1212
1213   let ARRAY_SIZE  = 0;
1214   let COMP_MASK   = comp_mask;
1215   let BURST_COUNT = 0;
1216   let VPM         = 0;
1217   let MARK        = 0;
1218   let BARRIER     = 1;
1219 }
1220
1221 } // End usesCustomInserter = 1
1222
1223 // 32-bit store
1224 def RAT_WRITE_CACHELESS_32_eg : RAT_WRITE_CACHELESS_eg <
1225   (ins R600_TReg32_X:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1226   0x1, "RAT_WRITE_CACHELESS_32_eg",
1227   [(global_store (i32 R600_TReg32_X:$rw_gpr), R600_TReg32_X:$index_gpr)]
1228 >;
1229
1230 //128-bit store
1231 def RAT_WRITE_CACHELESS_128_eg : RAT_WRITE_CACHELESS_eg <
1232   (ins R600_Reg128:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1233   0xf, "RAT_WRITE_CACHELESS_128",
1234   [(global_store (v4i32 R600_Reg128:$rw_gpr), R600_TReg32_X:$index_gpr)]
1235 >;
1236
1237 class VTX_READ_eg <string name, bits<8> buffer_id, dag outs, list<dag> pattern>
1238     : InstR600ISA <outs, (ins MEMxi:$ptr), name#" $dst, $ptr", pattern> {
1239
1240   // Operands
1241   bits<7> DST_GPR;
1242   bits<7> SRC_GPR;
1243
1244   // Static fields
1245   bits<5> VC_INST = 0;
1246   bits<2> FETCH_TYPE = 2;
1247   bits<1> FETCH_WHOLE_QUAD = 0;
1248   bits<8> BUFFER_ID = buffer_id;
1249   bits<1> SRC_REL = 0;
1250   // XXX: We can infer this field based on the SRC_GPR.  This would allow us
1251   // to store vertex addresses in any channel, not just X.
1252   bits<2> SRC_SEL_X = 0;
1253   bits<6> MEGA_FETCH_COUNT;
1254   bits<1> DST_REL = 0;
1255   bits<3> DST_SEL_X;
1256   bits<3> DST_SEL_Y;
1257   bits<3> DST_SEL_Z;
1258   bits<3> DST_SEL_W;
1259   // The docs say that if this bit is set, then DATA_FORMAT, NUM_FORMAT_ALL,
1260   // FORMAT_COMP_ALL, SRF_MODE_ALL, and ENDIAN_SWAP fields will be ignored,
1261   // however, based on my testing if USE_CONST_FIELDS is set, then all
1262   // these fields need to be set to 0.
1263   bits<1> USE_CONST_FIELDS = 0;
1264   bits<6> DATA_FORMAT;
1265   bits<2> NUM_FORMAT_ALL = 1;
1266   bits<1> FORMAT_COMP_ALL = 0;
1267   bits<1> SRF_MODE_ALL = 0;
1268
1269   // LLVM can only encode 64-bit instructions, so these fields are manually
1270   // encoded in R600CodeEmitter
1271   //
1272   // bits<16> OFFSET;
1273   // bits<2>  ENDIAN_SWAP = 0;
1274   // bits<1>  CONST_BUF_NO_STRIDE = 0;
1275   // bits<1>  MEGA_FETCH = 0;
1276   // bits<1>  ALT_CONST = 0;
1277   // bits<2>  BUFFER_INDEX_MODE = 0;
1278
1279   // VTX_WORD0
1280   let Inst{4-0}   = VC_INST;
1281   let Inst{6-5}   = FETCH_TYPE;
1282   let Inst{7}     = FETCH_WHOLE_QUAD;
1283   let Inst{15-8}  = BUFFER_ID;
1284   let Inst{22-16} = SRC_GPR;
1285   let Inst{23}    = SRC_REL;
1286   let Inst{25-24} = SRC_SEL_X;
1287   let Inst{31-26} = MEGA_FETCH_COUNT;
1288
1289   // VTX_WORD1_GPR
1290   let Inst{38-32} = DST_GPR;
1291   let Inst{39}    = DST_REL;
1292   let Inst{40}    = 0; // Reserved
1293   let Inst{43-41} = DST_SEL_X;
1294   let Inst{46-44} = DST_SEL_Y;
1295   let Inst{49-47} = DST_SEL_Z;
1296   let Inst{52-50} = DST_SEL_W;
1297   let Inst{53}    = USE_CONST_FIELDS;
1298   let Inst{59-54} = DATA_FORMAT;
1299   let Inst{61-60} = NUM_FORMAT_ALL;
1300   let Inst{62}    = FORMAT_COMP_ALL;
1301   let Inst{63}    = SRF_MODE_ALL;
1302
1303   // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1304   // is done in R600CodeEmitter
1305   //
1306   // Inst{79-64} = OFFSET;
1307   // Inst{81-80} = ENDIAN_SWAP;
1308   // Inst{82}    = CONST_BUF_NO_STRIDE;
1309   // Inst{83}    = MEGA_FETCH;
1310   // Inst{84}    = ALT_CONST;
1311   // Inst{86-85} = BUFFER_INDEX_MODE;
1312   // Inst{95-86} = 0; Reserved
1313
1314   // VTX_WORD3 (Padding)
1315   //
1316   // Inst{127-96} = 0;
1317 }
1318
1319 class VTX_READ_8_eg <bits<8> buffer_id, list<dag> pattern>
1320     : VTX_READ_eg <"VTX_READ_8", buffer_id, (outs R600_TReg32_X:$dst),
1321                    pattern> {
1322
1323   let MEGA_FETCH_COUNT = 1;
1324   let DST_SEL_X = 0;
1325   let DST_SEL_Y = 7;   // Masked
1326   let DST_SEL_Z = 7;   // Masked
1327   let DST_SEL_W = 7;   // Masked
1328   let DATA_FORMAT = 1; // FMT_8
1329 }
1330
1331 class VTX_READ_16_eg <bits<8> buffer_id, list<dag> pattern>
1332     : VTX_READ_eg <"VTX_READ_16", buffer_id, (outs R600_TReg32_X:$dst),
1333                     pattern> {
1334   let MEGA_FETCH_COUNT = 2;
1335   let DST_SEL_X = 0;
1336   let DST_SEL_Y = 7;   // Masked
1337   let DST_SEL_Z = 7;   // Masked
1338   let DST_SEL_W = 7;   // Masked
1339   let DATA_FORMAT = 5; // FMT_16
1340
1341 }
1342
1343 class VTX_READ_32_eg <bits<8> buffer_id, list<dag> pattern>
1344     : VTX_READ_eg <"VTX_READ_32", buffer_id, (outs R600_TReg32_X:$dst),
1345                    pattern> {
1346
1347   let MEGA_FETCH_COUNT = 4;
1348   let DST_SEL_X        = 0;
1349   let DST_SEL_Y        = 7;   // Masked
1350   let DST_SEL_Z        = 7;   // Masked
1351   let DST_SEL_W        = 7;   // Masked
1352   let DATA_FORMAT      = 0xD; // COLOR_32
1353
1354   // This is not really necessary, but there were some GPU hangs that appeared
1355   // to be caused by ALU instructions in the next instruction group that wrote
1356   // to the $ptr registers of the VTX_READ.
1357   // e.g.
1358   // %T3_X<def> = VTX_READ_PARAM_32_eg %T2_X<kill>, 24
1359   // %T2_X<def> = MOV %ZERO
1360   //Adding this constraint prevents this from happening.
1361   let Constraints = "$ptr.ptr = $dst";
1362 }
1363
1364 class VTX_READ_128_eg <bits<8> buffer_id, list<dag> pattern>
1365     : VTX_READ_eg <"VTX_READ_128", buffer_id, (outs R600_Reg128:$dst),
1366                    pattern> {
1367
1368   let MEGA_FETCH_COUNT = 16;
1369   let DST_SEL_X        =  0;
1370   let DST_SEL_Y        =  1;
1371   let DST_SEL_Z        =  2;
1372   let DST_SEL_W        =  3;
1373   let DATA_FORMAT      =  0x22; // COLOR_32_32_32_32
1374
1375   // XXX: Need to force VTX_READ_128 instructions to write to the same register
1376   // that holds its buffer address to avoid potential hangs.  We can't use
1377   // the same constraint as VTX_READ_32_eg, because the $ptr.ptr and $dst
1378   // registers are different sizes.
1379 }
1380
1381 //===----------------------------------------------------------------------===//
1382 // VTX Read from parameter memory space
1383 //===----------------------------------------------------------------------===//
1384
1385 def VTX_READ_PARAM_8_eg : VTX_READ_8_eg <0,
1386   [(set (i32 R600_TReg32_X:$dst), (load_param_zexti8 ADDRVTX_READ:$ptr))]
1387 >;
1388
1389 def VTX_READ_PARAM_16_eg : VTX_READ_16_eg <0,
1390   [(set (i32 R600_TReg32_X:$dst), (load_param_zexti16 ADDRVTX_READ:$ptr))]
1391 >;
1392
1393 def VTX_READ_PARAM_32_eg : VTX_READ_32_eg <0,
1394   [(set (i32 R600_TReg32_X:$dst), (load_param ADDRVTX_READ:$ptr))]
1395 >;
1396
1397 //===----------------------------------------------------------------------===//
1398 // VTX Read from global memory space
1399 //===----------------------------------------------------------------------===//
1400
1401 // 8-bit reads
1402 def VTX_READ_GLOBAL_8_eg : VTX_READ_8_eg <1,
1403   [(set (i32 R600_TReg32_X:$dst), (zextloadi8_global ADDRVTX_READ:$ptr))]
1404 >;
1405
1406 // 32-bit reads
1407 def VTX_READ_GLOBAL_32_eg : VTX_READ_32_eg <1,
1408   [(set (i32 R600_TReg32_X:$dst), (global_load ADDRVTX_READ:$ptr))]
1409 >;
1410
1411 // 128-bit reads
1412 def VTX_READ_GLOBAL_128_eg : VTX_READ_128_eg <1,
1413   [(set (v4i32 R600_Reg128:$dst), (global_load ADDRVTX_READ:$ptr))]
1414 >;
1415
1416 //===----------------------------------------------------------------------===//
1417 // Constant Loads
1418 // XXX: We are currently storing all constants in the global address space.
1419 //===----------------------------------------------------------------------===//
1420
1421 def CONSTANT_LOAD_eg : VTX_READ_32_eg <1,
1422   [(set (i32 R600_TReg32_X:$dst), (constant_load ADDRVTX_READ:$ptr))]
1423 >;
1424
1425 }
1426
1427 let Predicates = [isCayman] in {
1428
1429 let isVector = 1 in {
1430
1431 def RECIP_IEEE_cm : RECIP_IEEE_Common<0x86>;
1432
1433 def MULLO_INT_cm : MULLO_INT_Common<0x8F>;
1434 def MULHI_INT_cm : MULHI_INT_Common<0x90>;
1435 def MULLO_UINT_cm : MULLO_UINT_Common<0x91>;
1436 def MULHI_UINT_cm : MULHI_UINT_Common<0x92>;
1437 def RECIPSQRT_CLAMPED_cm : RECIPSQRT_CLAMPED_Common<0x87>;
1438 def EXP_IEEE_cm : EXP_IEEE_Common<0x81>;
1439 def LOG_IEEE_ : LOG_IEEE_Common<0x83>;
1440 def RECIP_CLAMPED_cm : RECIP_CLAMPED_Common<0x84>;
1441 def RECIPSQRT_IEEE_cm : RECIPSQRT_IEEE_Common<0x89>;
1442 def SIN_cm : SIN_Common<0x8D>;
1443 def COS_cm : COS_Common<0x8E>;
1444 } // End isVector = 1
1445
1446 def : SIN_PAT <SIN_cm>;
1447 def : COS_PAT <COS_cm>;
1448
1449 defm DIV_cm : DIV_Common<RECIP_IEEE_cm>;
1450
1451 // RECIP_UINT emulation for Cayman
1452 def : Pat <
1453   (AMDGPUurecip R600_Reg32:$src0),
1454   (FLT_TO_UINT_eg (MUL_IEEE (RECIP_IEEE_cm (UINT_TO_FLT_eg R600_Reg32:$src0)),
1455                             (MOV_IMM_I32 0x4f800000)))
1456 >;
1457
1458
1459 def : Pat<(fsqrt R600_Reg32:$src),
1460   (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_cm R600_Reg32:$src))>;
1461
1462 } // End isCayman
1463
1464 //===----------------------------------------------------------------------===//
1465 // Branch Instructions
1466 //===----------------------------------------------------------------------===//
1467
1468
1469 def IF_PREDICATE_SET  : ILFormat<(outs), (ins GPRI32:$src),
1470   "IF_PREDICATE_SET $src", []>;
1471
1472 def PREDICATED_BREAK : ILFormat<(outs), (ins GPRI32:$src),
1473   "PREDICATED_BREAK $src", []>;
1474
1475 //===----------------------------------------------------------------------===//
1476 // Pseudo instructions
1477 //===----------------------------------------------------------------------===//
1478
1479 let isPseudo = 1 in {
1480
1481 def PRED_X : InstR600 <
1482   0, (outs R600_Predicate_Bit:$dst),
1483   (ins R600_Reg32:$src0, i32imm:$src1, i32imm:$flags),
1484   "", [], NullALU> {
1485   let FlagOperandIdx = 3;
1486 }
1487
1488 let isTerminator = 1, isBranch = 1, isBarrier = 1 in {
1489
1490 def JUMP : InstR600 <0x10,
1491           (outs),
1492           (ins brtarget:$target, R600_Pred:$p),
1493           "JUMP $target ($p)",
1494           [], AnyALU
1495   >;
1496
1497 }  // End isTerminator = 1, isBranch = 1, isBarrier = 1
1498
1499 let usesCustomInserter = 1 in {
1500
1501 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in {
1502
1503 def MASK_WRITE : AMDGPUShaderInst <
1504     (outs),
1505     (ins R600_Reg32:$src),
1506     "MASK_WRITE $src",
1507     []
1508 >;
1509
1510 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 1
1511
1512 def R600_LOAD_CONST : AMDGPUShaderInst <
1513   (outs R600_Reg32:$dst),
1514   (ins i32imm:$src0),
1515   "R600_LOAD_CONST $dst, $src0",
1516   [(set R600_Reg32:$dst, (int_AMDGPU_load_const imm:$src0))]
1517 >;
1518
1519 def RESERVE_REG : AMDGPUShaderInst <
1520   (outs),
1521   (ins i32imm:$src),
1522   "RESERVE_REG $src",
1523   [(int_AMDGPU_reserve_reg imm:$src)]
1524 >;
1525
1526 def TXD: AMDGPUShaderInst <
1527   (outs R600_Reg128:$dst),
1528   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
1529   "TXD $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
1530   [(set R600_Reg128:$dst, (int_AMDGPU_txd R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
1531 >;
1532
1533 def TXD_SHADOW: AMDGPUShaderInst <
1534   (outs R600_Reg128:$dst),
1535   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
1536   "TXD_SHADOW $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
1537   [(set R600_Reg128:$dst, (int_AMDGPU_txd R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
1538 >;
1539
1540 } // End isPseudo = 1
1541 } // End usesCustomInserter = 1
1542
1543 def CLAMP_R600 :  CLAMP <R600_Reg32>;
1544 def FABS_R600 : FABS<R600_Reg32>;
1545 def FNEG_R600 : FNEG<R600_Reg32>;
1546
1547 //===---------------------------------------------------------------------===//
1548 // Return instruction
1549 //===---------------------------------------------------------------------===//
1550 let isTerminator = 1, isReturn = 1, isBarrier = 1, hasCtrlDep = 1 in {
1551   def RETURN          : ILFormat<(outs), (ins variable_ops),
1552       "RETURN", [(IL_retflag)]>;
1553 }
1554
1555 //===--------------------------------------------------------------------===//
1556 // Instructions support
1557 //===--------------------------------------------------------------------===//
1558 //===---------------------------------------------------------------------===//
1559 // Custom Inserter for Branches and returns, this eventually will be a
1560 // seperate pass
1561 //===---------------------------------------------------------------------===//
1562 let isTerminator = 1, usesCustomInserter = 1, isBranch = 1, isBarrier = 1 in {
1563   def BRANCH : ILFormat<(outs), (ins brtarget:$target),
1564       "; Pseudo unconditional branch instruction",
1565       [(br bb:$target)]>;
1566   defm BRANCH_COND : BranchConditional<IL_brcond>;
1567 }
1568
1569 //===---------------------------------------------------------------------===//
1570 // Flow and Program control Instructions
1571 //===---------------------------------------------------------------------===//
1572 let isTerminator=1 in {
1573   def SWITCH      : ILFormat< (outs), (ins GPRI32:$src),
1574   !strconcat("SWITCH", " $src"), []>;
1575   def CASE        : ILFormat< (outs), (ins GPRI32:$src),
1576       !strconcat("CASE", " $src"), []>;
1577   def BREAK       : ILFormat< (outs), (ins),
1578       "BREAK", []>;
1579   def CONTINUE    : ILFormat< (outs), (ins),
1580       "CONTINUE", []>;
1581   def DEFAULT     : ILFormat< (outs), (ins),
1582       "DEFAULT", []>;
1583   def ELSE        : ILFormat< (outs), (ins),
1584       "ELSE", []>;
1585   def ENDSWITCH   : ILFormat< (outs), (ins),
1586       "ENDSWITCH", []>;
1587   def ENDMAIN     : ILFormat< (outs), (ins),
1588       "ENDMAIN", []>;
1589   def END         : ILFormat< (outs), (ins),
1590       "END", []>;
1591   def ENDFUNC     : ILFormat< (outs), (ins),
1592       "ENDFUNC", []>;
1593   def ENDIF       : ILFormat< (outs), (ins),
1594       "ENDIF", []>;
1595   def WHILELOOP   : ILFormat< (outs), (ins),
1596       "WHILE", []>;
1597   def ENDLOOP     : ILFormat< (outs), (ins),
1598       "ENDLOOP", []>;
1599   def FUNC        : ILFormat< (outs), (ins),
1600       "FUNC", []>;
1601   def RETDYN      : ILFormat< (outs), (ins),
1602       "RET_DYN", []>;
1603   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1604   defm IF_LOGICALNZ  : BranchInstr<"IF_LOGICALNZ">;
1605   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1606   defm IF_LOGICALZ   : BranchInstr<"IF_LOGICALZ">;
1607   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1608   defm BREAK_LOGICALNZ : BranchInstr<"BREAK_LOGICALNZ">;
1609   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1610   defm BREAK_LOGICALZ : BranchInstr<"BREAK_LOGICALZ">;
1611   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1612   defm CONTINUE_LOGICALNZ : BranchInstr<"CONTINUE_LOGICALNZ">;
1613   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1614   defm CONTINUE_LOGICALZ : BranchInstr<"CONTINUE_LOGICALZ">;
1615   defm IFC         : BranchInstr2<"IFC">;
1616   defm BREAKC      : BranchInstr2<"BREAKC">;
1617   defm CONTINUEC   : BranchInstr2<"CONTINUEC">;
1618 }
1619
1620 //===----------------------------------------------------------------------===//
1621 // ISel Patterns
1622 //===----------------------------------------------------------------------===//
1623
1624 //CNDGE_INT extra pattern
1625 def : Pat <
1626   (selectcc (i32 R600_Reg32:$src0), -1, (i32 R600_Reg32:$src1),
1627                                         (i32 R600_Reg32:$src2), COND_GT),
1628   (CNDGE_INT R600_Reg32:$src0, R600_Reg32:$src1, R600_Reg32:$src2)
1629 >;
1630
1631 // KIL Patterns
1632 def KILP : Pat <
1633   (int_AMDGPU_kilp),
1634   (MASK_WRITE (KILLGT (f32 ONE), (f32 ZERO)))
1635 >;
1636
1637 def KIL : Pat <
1638   (int_AMDGPU_kill R600_Reg32:$src0),
1639   (MASK_WRITE (KILLGT (f32 ZERO), (f32 R600_Reg32:$src0)))
1640 >;
1641
1642 // SGT Reverse args
1643 def : Pat <
1644   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, COND_LT),
1645   (SGT R600_Reg32:$src1, R600_Reg32:$src0)
1646 >;
1647
1648 // SGE Reverse args
1649 def : Pat <
1650   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, COND_LE),
1651   (SGE R600_Reg32:$src1, R600_Reg32:$src0)
1652 >;
1653
1654 // SETGT_INT reverse args
1655 def : Pat <
1656   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETLT),
1657   (SETGT_INT R600_Reg32:$src1, R600_Reg32:$src0)
1658 >;
1659
1660 // SETGE_INT reverse args
1661 def : Pat <
1662   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETLE),
1663   (SETGE_INT R600_Reg32:$src1, R600_Reg32:$src0)
1664 >;
1665
1666 // SETGT_UINT reverse args
1667 def : Pat <
1668   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETULT),
1669   (SETGT_UINT R600_Reg32:$src1, R600_Reg32:$src0)
1670 >;
1671
1672 // SETGE_UINT reverse args
1673 def : Pat <
1674   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETULE),
1675   (SETGE_UINT R600_Reg32:$src1, R600_Reg32:$src0)
1676 >;
1677
1678 // The next two patterns are special cases for handling 'true if ordered' and
1679 // 'true if unordered' conditionals.  The assumption here is that the behavior of
1680 // SETE and SNE conforms to the Direct3D 10 rules for floating point values
1681 // described here:
1682 // http://msdn.microsoft.com/en-us/library/windows/desktop/cc308050.aspx#alpha_32_bit
1683 // We assume that  SETE returns false when one of the operands is NAN and
1684 // SNE returns true when on of the operands is NAN
1685
1686 //SETE - 'true if ordered'
1687 def : Pat <
1688   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, SETO),
1689   (SETE R600_Reg32:$src0, R600_Reg32:$src1)
1690 >;
1691
1692 //SNE - 'true if unordered'
1693 def : Pat <
1694   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, SETUO),
1695   (SNE R600_Reg32:$src0, R600_Reg32:$src1)
1696 >;
1697
1698 def : Extract_Element <f32, v4f32, R600_Reg128, 0, sel_x>;
1699 def : Extract_Element <f32, v4f32, R600_Reg128, 1, sel_y>;
1700 def : Extract_Element <f32, v4f32, R600_Reg128, 2, sel_z>;
1701 def : Extract_Element <f32, v4f32, R600_Reg128, 3, sel_w>;
1702
1703 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 0, sel_x>;
1704 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 1, sel_y>;
1705 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 2, sel_z>;
1706 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 3, sel_w>;
1707
1708 def : Extract_Element <i32, v4i32, R600_Reg128, 0, sel_x>;
1709 def : Extract_Element <i32, v4i32, R600_Reg128, 1, sel_y>;
1710 def : Extract_Element <i32, v4i32, R600_Reg128, 2, sel_z>;
1711 def : Extract_Element <i32, v4i32, R600_Reg128, 3, sel_w>;
1712
1713 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 0, sel_x>;
1714 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 1, sel_y>;
1715 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 2, sel_z>;
1716 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 3, sel_w>;
1717
1718 def : Vector_Build <v4f32, R600_Reg128, f32, R600_Reg32>;
1719 def : Vector_Build <v4i32, R600_Reg128, i32, R600_Reg32>;
1720
1721 // bitconvert patterns
1722
1723 def : BitConvert <i32, f32, R600_Reg32>;
1724 def : BitConvert <f32, i32, R600_Reg32>;
1725 def : BitConvert <v4f32, v4i32, R600_Reg128>;
1726 def : BitConvert <v4i32, v4f32, R600_Reg128>;
1727
1728 // DWORDADDR pattern
1729 def : DwordAddrPat  <i32, R600_Reg32>;
1730
1731 } // End isR600toCayman Predicate