lib/Target/R600/R600Instructions.td

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