lib/Target/R600/R600Instructions.td

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