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