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 FRACT : R600_1OP_Helper <0x10, "FRACT", AMDGPUfract>;
 715 def TRUNC : R600_1OP_Helper <0x11, "TRUNC", int_AMDGPU_trunc>;
 716 def CEIL : R600_1OP_Helper <0x12, "CEIL", fceil>;
 717 def RNDNE : R600_1OP_Helper <0x13, "RNDNE", frint>;
 718 def FLOOR : R600_1OP_Helper <0x14, "FLOOR", ffloor>;
 719
 720 def MOV : R600_1OP <0x19, "MOV", []>;
 721
 722 let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1 in {
 723
 724 class MOV_IMM <ValueType vt, Operand immType> : AMDGPUInst <
 725   (outs R600_Reg32:$dst),
 726   (ins immType:$imm),
 727   "",
 728   []
 729 >;
 730
 731 } // end let isPseudo = 1, isCodeGenOnly = 1, usesCustomInserter = 1
 732
 733 def MOV_IMM_I32 : MOV_IMM<i32, i32imm>;
 734 def : Pat <
 735   (imm:$val),
 736   (MOV_IMM_I32 imm:$val)
 737 >;
 738
 739 def MOV_IMM_F32 : MOV_IMM<f32, f32imm>;
 740 def : Pat <
 741   (fpimm:$val),
 742   (MOV_IMM_F32  fpimm:$val)
 743 >;
 744
 745 def PRED_SETE : R600_2OP <0x20, "PRED_SETE", []>;
 746 def PRED_SETGT : R600_2OP <0x21, "PRED_SETGT", []>;
 747 def PRED_SETGE : R600_2OP <0x22, "PRED_SETGE", []>;
 748 def PRED_SETNE : R600_2OP <0x23, "PRED_SETNE", []>;
 749
 750 let hasSideEffects = 1 in {
 751
 752 def KILLGT : R600_2OP <0x2D, "KILLGT", []>;
 753
 754 } // end hasSideEffects
 755
 756 def AND_INT : R600_2OP_Helper <0x30, "AND_INT", and>;
 757 def OR_INT : R600_2OP_Helper <0x31, "OR_INT", or>;
 758 def XOR_INT : R600_2OP_Helper <0x32, "XOR_INT", xor>;
 759 def NOT_INT : R600_1OP_Helper <0x33, "NOT_INT", not>;
 760 def ADD_INT : R600_2OP_Helper <0x34, "ADD_INT", add>;
 761 def SUB_INT : R600_2OP_Helper <0x35, "SUB_INT", sub>;
 762 def MAX_INT : R600_2OP_Helper <0x36, "MAX_INT", AMDGPUsmax>;
 763 def MIN_INT : R600_2OP_Helper <0x37, "MIN_INT", AMDGPUsmin>;
 764 def MAX_UINT : R600_2OP_Helper <0x38, "MAX_UINT", AMDGPUumax>;
 765 def MIN_UINT : R600_2OP_Helper <0x39, "MIN_UINT", AMDGPUumin>;
 766
 767 def SETE_INT : R600_2OP <
 768   0x3A, "SETE_INT",
 769   [(set (i32 R600_Reg32:$dst),
 770    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETEQ))]
 771 >;
 772
 773 def SETGT_INT : R600_2OP <
 774   0x3B, "SGT_INT",
 775   [(set (i32 R600_Reg32:$dst),
 776    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETGT))]
 777 >;
 778
 779 def SETGE_INT : R600_2OP <
 780   0x3C, "SETGE_INT",
 781   [(set (i32 R600_Reg32:$dst),
 782    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETGE))]
 783 >;
 784
 785 def SETNE_INT : R600_2OP <
 786   0x3D, "SETNE_INT",
 787   [(set (i32 R600_Reg32:$dst),
 788    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETNE))]
 789 >;
 790
 791 def SETGT_UINT : R600_2OP <
 792   0x3E, "SETGT_UINT",
 793   [(set (i32 R600_Reg32:$dst),
 794    (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUGT))]
 795 >;
 796
 797 def SETGE_UINT : R600_2OP <
 798   0x3F, "SETGE_UINT",
 799   [(set (i32 R600_Reg32:$dst),
 800     (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETUGE))]
 801 >;
 802
 803 def PRED_SETE_INT : R600_2OP <0x42, "PRED_SETE_INT", []>;
 804 def PRED_SETGT_INT : R600_2OP <0x43, "PRED_SETGE_INT", []>;
 805 def PRED_SETGE_INT : R600_2OP <0x44, "PRED_SETGE_INT", []>;
 806 def PRED_SETNE_INT : R600_2OP <0x45, "PRED_SETNE_INT", []>;
 807
 808 def CNDE_INT : R600_3OP <
 809   0x1C, "CNDE_INT",
 810   [(set (i32 R600_Reg32:$dst),
 811    (selectcc (i32 R600_Reg32:$src0), 0,
 812        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
 813        COND_EQ))]
 814 >;
 815
 816 def CNDGE_INT : R600_3OP <
 817   0x1E, "CNDGE_INT",
 818   [(set (i32 R600_Reg32:$dst),
 819    (selectcc (i32 R600_Reg32:$src0), 0,
 820        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
 821        COND_GE))]
 822 >;
 823
 824 def CNDGT_INT : R600_3OP <
 825   0x1D, "CNDGT_INT",
 826   [(set (i32 R600_Reg32:$dst),
 827    (selectcc (i32 R600_Reg32:$src0), 0,
 828        (i32 R600_Reg32:$src1), (i32 R600_Reg32:$src2),
 829        COND_GT))]
 830 >;
 831
 832 //===----------------------------------------------------------------------===//
 833 // Texture instructions
 834 //===----------------------------------------------------------------------===//
 835
 836 def TEX_LD : R600_TEX <
 837   0x03, "TEX_LD",
 838   [(set R600_Reg128:$dst, (int_AMDGPU_txf R600_Reg128:$src0, imm:$src1, imm:$src2, imm:$src3, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 839 > {
 840 let AsmString = "TEX_LD $dst, $src0, $src1, $src2, $src3, $resourceId, $samplerId, $textureTarget";
 841 let InOperandList = (ins R600_Reg128:$src0, i32imm:$src1, i32imm:$src2, i32imm:$src3, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget);
 842 }
 843
 844 def TEX_GET_TEXTURE_RESINFO : R600_TEX <
 845   0x04, "TEX_GET_TEXTURE_RESINFO",
 846   [(set R600_Reg128:$dst, (int_AMDGPU_txq R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 847 >;
 848
 849 def TEX_GET_GRADIENTS_H : R600_TEX <
 850   0x07, "TEX_GET_GRADIENTS_H",
 851   [(set R600_Reg128:$dst, (int_AMDGPU_ddx R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 852 >;
 853
 854 def TEX_GET_GRADIENTS_V : R600_TEX <
 855   0x08, "TEX_GET_GRADIENTS_V",
 856   [(set R600_Reg128:$dst, (int_AMDGPU_ddy R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 857 >;
 858
 859 def TEX_SET_GRADIENTS_H : R600_TEX <
 860   0x0B, "TEX_SET_GRADIENTS_H",
 861   []
 862 >;
 863
 864 def TEX_SET_GRADIENTS_V : R600_TEX <
 865   0x0C, "TEX_SET_GRADIENTS_V",
 866   []
 867 >;
 868
 869 def TEX_SAMPLE : R600_TEX <
 870   0x10, "TEX_SAMPLE",
 871   [(set R600_Reg128:$dst, (int_AMDGPU_tex R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 872 >;
 873
 874 def TEX_SAMPLE_C : R600_TEX <
 875   0x18, "TEX_SAMPLE_C",
 876   [(set R600_Reg128:$dst, (int_AMDGPU_tex R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
 877 >;
 878
 879 def TEX_SAMPLE_L : R600_TEX <
 880   0x11, "TEX_SAMPLE_L",
 881   [(set R600_Reg128:$dst, (int_AMDGPU_txl R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 882 >;
 883
 884 def TEX_SAMPLE_C_L : R600_TEX <
 885   0x19, "TEX_SAMPLE_C_L",
 886   [(set R600_Reg128:$dst, (int_AMDGPU_txl R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
 887 >;
 888
 889 def TEX_SAMPLE_LB : R600_TEX <
 890   0x12, "TEX_SAMPLE_LB",
 891   [(set R600_Reg128:$dst, (int_AMDGPU_txb R600_Reg128:$src0,imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
 892 >;
 893
 894 def TEX_SAMPLE_C_LB : R600_TEX <
 895   0x1A, "TEX_SAMPLE_C_LB",
 896   [(set R600_Reg128:$dst, (int_AMDGPU_txb R600_Reg128:$src0, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
 897 >;
 898
 899 def TEX_SAMPLE_G : R600_TEX <
 900   0x14, "TEX_SAMPLE_G",
 901   []
 902 >;
 903
 904 def TEX_SAMPLE_C_G : R600_TEX <
 905   0x1C, "TEX_SAMPLE_C_G",
 906   []
 907 >;
 908
 909 //===----------------------------------------------------------------------===//
 910 // Helper classes for common instructions
 911 //===----------------------------------------------------------------------===//
 912
 913 class MUL_LIT_Common <bits<5> inst> : R600_3OP <
 914   inst, "MUL_LIT",
 915   []
 916 >;
 917
 918 class MULADD_Common <bits<5> inst> : R600_3OP <
 919   inst, "MULADD",
 920   [(set (f32 R600_Reg32:$dst),
 921    (IL_mad R600_Reg32:$src0, R600_Reg32:$src1, R600_Reg32:$src2))]
 922 >;
 923
 924 class CNDE_Common <bits<5> inst> : R600_3OP <
 925   inst, "CNDE",
 926   [(set R600_Reg32:$dst,
 927    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
 928        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
 929        COND_EQ))]
 930 >;
 931
 932 class CNDGT_Common <bits<5> inst> : R600_3OP <
 933   inst, "CNDGT",
 934   [(set R600_Reg32:$dst,
 935    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
 936        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
 937        COND_GT))]
 938 >;
 939
 940 class CNDGE_Common <bits<5> inst> : R600_3OP <
 941   inst, "CNDGE",
 942   [(set R600_Reg32:$dst,
 943    (selectcc (f32 R600_Reg32:$src0), FP_ZERO,
 944        (f32 R600_Reg32:$src1), (f32 R600_Reg32:$src2),
 945        COND_GE))]
 946 >;
 947
 948 multiclass DOT4_Common <bits<11> inst> {
 949
 950   def _pseudo : R600_REDUCTION <inst,
 951     (ins R600_Reg128:$src0, R600_Reg128:$src1),
 952     "DOT4 $dst $src0, $src1",
 953     [(set R600_Reg32:$dst, (int_AMDGPU_dp4 R600_Reg128:$src0, R600_Reg128:$src1))]
 954   >;
 955
 956   def _real : R600_2OP <inst, "DOT4", []>;
 957 }
 958
 959 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
 960 multiclass CUBE_Common <bits<11> inst> {
 961
 962   def _pseudo : InstR600 <
 963     inst,
 964     (outs R600_Reg128:$dst),
 965     (ins R600_Reg128:$src),
 966     "CUBE $dst $src",
 967     [(set R600_Reg128:$dst, (int_AMDGPU_cube R600_Reg128:$src))],
 968     VecALU
 969   > {
 970     let isPseudo = 1;
 971   }
 972
 973   def _real : R600_2OP <inst, "CUBE", []>;
 974 }
 975 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 0
 976
 977 class EXP_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
 978   inst, "EXP_IEEE", fexp2
 979 >;
 980
 981 class FLT_TO_INT_Common <bits<11> inst> : R600_1OP_Helper <
 982   inst, "FLT_TO_INT", fp_to_sint
 983 >;
 984
 985 class INT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
 986   inst, "INT_TO_FLT", sint_to_fp
 987 >;
 988
 989 class FLT_TO_UINT_Common <bits<11> inst> : R600_1OP_Helper <
 990   inst, "FLT_TO_UINT", fp_to_uint
 991 >;
 992
 993 class UINT_TO_FLT_Common <bits<11> inst> : R600_1OP_Helper <
 994   inst, "UINT_TO_FLT", uint_to_fp
 995 >;
 996
 997 class LOG_CLAMPED_Common <bits<11> inst> : R600_1OP <
 998   inst, "LOG_CLAMPED", []
 999 >;
1000
1001 class LOG_IEEE_Common <bits<11> inst> : R600_1OP_Helper <
1002   inst, "LOG_IEEE", flog2
1003 >;
1004
1005 class LSHL_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHL", shl>;
1006 class LSHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "LSHR", srl>;
1007 class ASHR_Common <bits<11> inst> : R600_2OP_Helper <inst, "ASHR", sra>;
1008 class MULHI_INT_Common <bits<11> inst> : R600_2OP_Helper <
1009   inst, "MULHI_INT", mulhs
1010 >;
1011 class MULHI_UINT_Common <bits<11> inst> : R600_2OP_Helper <
1012   inst, "MULHI", mulhu
1013 >;
1014 class MULLO_INT_Common <bits<11> inst> : R600_2OP_Helper <
1015   inst, "MULLO_INT", mul
1016 >;
1017 class MULLO_UINT_Common <bits<11> inst> : R600_2OP <inst, "MULLO_UINT", []>;
1018
1019 class RECIP_CLAMPED_Common <bits<11> inst> : R600_1OP <
1020   inst, "RECIP_CLAMPED", []
1021 >;
1022
1023 class RECIP_IEEE_Common <bits<11> inst> : R600_1OP <
1024   inst, "RECIP_IEEE", [(set R600_Reg32:$dst, (fdiv FP_ONE, R600_Reg32:$src0))]
1025 >;
1026
1027 class RECIP_UINT_Common <bits<11> inst> : R600_1OP_Helper <
1028   inst, "RECIP_UINT", AMDGPUurecip
1029 >;
1030
1031 class RECIPSQRT_CLAMPED_Common <bits<11> inst> : R600_1OP_Helper <
1032   inst, "RECIPSQRT_CLAMPED", int_AMDGPU_rsq
1033 >;
1034
1035 class RECIPSQRT_IEEE_Common <bits<11> inst> : R600_1OP <
1036   inst, "RECIPSQRT_IEEE", []
1037 >;
1038
1039 class SIN_Common <bits<11> inst> : R600_1OP <
1040   inst, "SIN", []>{
1041   let Trig = 1;
1042 }
1043
1044 class COS_Common <bits<11> inst> : R600_1OP <
1045   inst, "COS", []> {
1046   let Trig = 1;
1047 }
1048
1049 //===----------------------------------------------------------------------===//
1050 // Helper patterns for complex intrinsics
1051 //===----------------------------------------------------------------------===//
1052
1053 multiclass DIV_Common <InstR600 recip_ieee> {
1054 def : Pat<
1055   (int_AMDGPU_div R600_Reg32:$src0, R600_Reg32:$src1),
1056   (MUL R600_Reg32:$src0, (recip_ieee R600_Reg32:$src1))
1057 >;
1058
1059 def : Pat<
1060   (fdiv R600_Reg32:$src0, R600_Reg32:$src1),
1061   (MUL R600_Reg32:$src0, (recip_ieee R600_Reg32:$src1))
1062 >;
1063 }
1064
1065 class TGSI_LIT_Z_Common <InstR600 mul_lit, InstR600 log_clamped, InstR600 exp_ieee> : Pat <
1066   (int_TGSI_lit_z R600_Reg32:$src_x, R600_Reg32:$src_y, R600_Reg32:$src_w),
1067   (exp_ieee (mul_lit (log_clamped (MAX R600_Reg32:$src_y, (f32 ZERO))), R600_Reg32:$src_w, R600_Reg32:$src_x))
1068 >;
1069
1070 //===----------------------------------------------------------------------===//
1071 // R600 / R700 Instructions
1072 //===----------------------------------------------------------------------===//
1073
1074 let Predicates = [isR600] in {
1075
1076   def MUL_LIT_r600 : MUL_LIT_Common<0x0C>;
1077   def MULADD_r600 : MULADD_Common<0x10>;
1078   def CNDE_r600 : CNDE_Common<0x18>;
1079   def CNDGT_r600 : CNDGT_Common<0x19>;
1080   def CNDGE_r600 : CNDGE_Common<0x1A>;
1081   defm DOT4_r600 : DOT4_Common<0x50>;
1082   defm CUBE_r600 : CUBE_Common<0x52>;
1083   def EXP_IEEE_r600 : EXP_IEEE_Common<0x61>;
1084   def LOG_CLAMPED_r600 : LOG_CLAMPED_Common<0x62>;
1085   def LOG_IEEE_r600 : LOG_IEEE_Common<0x63>;
1086   def RECIP_CLAMPED_r600 : RECIP_CLAMPED_Common<0x64>;
1087   def RECIP_IEEE_r600 : RECIP_IEEE_Common<0x66>;
1088   def RECIPSQRT_CLAMPED_r600 : RECIPSQRT_CLAMPED_Common<0x67>;
1089   def RECIPSQRT_IEEE_r600 : RECIPSQRT_IEEE_Common<0x69>;
1090   def FLT_TO_INT_r600 : FLT_TO_INT_Common<0x6b>;
1091   def INT_TO_FLT_r600 : INT_TO_FLT_Common<0x6c>;
1092   def FLT_TO_UINT_r600 : FLT_TO_UINT_Common<0x79>;
1093   def UINT_TO_FLT_r600 : UINT_TO_FLT_Common<0x6d>;
1094   def SIN_r600 : SIN_Common<0x6E>;
1095   def COS_r600 : COS_Common<0x6F>;
1096   def ASHR_r600 : ASHR_Common<0x70>;
1097   def LSHR_r600 : LSHR_Common<0x71>;
1098   def LSHL_r600 : LSHL_Common<0x72>;
1099   def MULLO_INT_r600 : MULLO_INT_Common<0x73>;
1100   def MULHI_INT_r600 : MULHI_INT_Common<0x74>;
1101   def MULLO_UINT_r600 : MULLO_UINT_Common<0x75>;
1102   def MULHI_UINT_r600 : MULHI_UINT_Common<0x76>;
1103   def RECIP_UINT_r600 : RECIP_UINT_Common <0x78>;
1104
1105   defm DIV_r600 : DIV_Common<RECIP_IEEE_r600>;
1106   def TGSI_LIT_Z_r600 : TGSI_LIT_Z_Common<MUL_LIT_r600, LOG_CLAMPED_r600, EXP_IEEE_r600>;
1107
1108   def : Pat<(fsqrt R600_Reg32:$src),
1109     (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_r600 R600_Reg32:$src))>;
1110
1111   def R600_ExportSwz : ExportSwzInst {
1112     let Word1{20-17} = 1; // BURST_COUNT
1113     let Word1{21} = eop;
1114     let Word1{22} = 1; // VALID_PIXEL_MODE
1115     let Word1{30-23} = inst;
1116     let Word1{31} = 1; // BARRIER
1117   }
1118   defm : ExportPattern<R600_ExportSwz, 39>;
1119
1120   def R600_ExportBuf : ExportBufInst {
1121     let Word1{20-17} = 1; // BURST_COUNT
1122     let Word1{21} = eop;
1123     let Word1{22} = 1; // VALID_PIXEL_MODE
1124     let Word1{30-23} = inst;
1125     let Word1{31} = 1; // BARRIER
1126   }
1127   defm : SteamOutputExportPattern<R600_ExportBuf, 0x20, 0x21, 0x22, 0x23>;
1128 }
1129
1130 // Helper pattern for normalizing inputs to triginomic instructions for R700+
1131 // cards.
1132 class COS_PAT <InstR600 trig> : Pat<
1133   (fcos R600_Reg32:$src),
1134   (trig (MUL (MOV_IMM_I32 CONST.TWO_PI_INV), R600_Reg32:$src))
1135 >;
1136
1137 class SIN_PAT <InstR600 trig> : Pat<
1138   (fsin R600_Reg32:$src),
1139   (trig (MUL (MOV_IMM_I32 CONST.TWO_PI_INV), R600_Reg32:$src))
1140 >;
1141
1142 //===----------------------------------------------------------------------===//
1143 // R700 Only instructions
1144 //===----------------------------------------------------------------------===//
1145
1146 let Predicates = [isR700] in {
1147   def SIN_r700 : SIN_Common<0x6E>;
1148   def COS_r700 : COS_Common<0x6F>;
1149
1150   // R700 normalizes inputs to SIN/COS the same as EG
1151   def : SIN_PAT <SIN_r700>;
1152   def : COS_PAT <COS_r700>;
1153 }
1154
1155 //===----------------------------------------------------------------------===//
1156 // Evergreen Only instructions
1157 //===----------------------------------------------------------------------===//
1158
1159 let Predicates = [isEG] in {
1160
1161 def RECIP_IEEE_eg : RECIP_IEEE_Common<0x86>;
1162 defm DIV_eg : DIV_Common<RECIP_IEEE_eg>;
1163
1164 def MULLO_INT_eg : MULLO_INT_Common<0x8F>;
1165 def MULHI_INT_eg : MULHI_INT_Common<0x90>;
1166 def MULLO_UINT_eg : MULLO_UINT_Common<0x91>;
1167 def MULHI_UINT_eg : MULHI_UINT_Common<0x92>;
1168 def RECIP_UINT_eg : RECIP_UINT_Common<0x94>;
1169 def RECIPSQRT_CLAMPED_eg : RECIPSQRT_CLAMPED_Common<0x87>;
1170 def EXP_IEEE_eg : EXP_IEEE_Common<0x81>;
1171 def LOG_IEEE_eg : LOG_IEEE_Common<0x83>;
1172 def RECIP_CLAMPED_eg : RECIP_CLAMPED_Common<0x84>;
1173 def RECIPSQRT_IEEE_eg : RECIPSQRT_IEEE_Common<0x89>;
1174 def SIN_eg : SIN_Common<0x8D>;
1175 def COS_eg : COS_Common<0x8E>;
1176
1177 def : SIN_PAT <SIN_eg>;
1178 def : COS_PAT <COS_eg>;
1179 def : Pat<(fsqrt R600_Reg32:$src),
1180   (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_eg R600_Reg32:$src))>;
1181 } // End Predicates = [isEG]
1182
1183 //===----------------------------------------------------------------------===//
1184 // Evergreen / Cayman Instructions
1185 //===----------------------------------------------------------------------===//
1186
1187 let Predicates = [isEGorCayman] in {
1188
1189   // BFE_UINT - bit_extract, an optimization for mask and shift
1190   // Src0 = Input
1191   // Src1 = Offset
1192   // Src2 = Width
1193   //
1194   // bit_extract = (Input << (32 - Offset - Width)) >> (32 - Width)
1195   //
1196   // Example Usage:
1197   // (Offset, Width)
1198   //
1199   // (0, 8)           = (Input << 24) >> 24  = (Input &  0xff)       >> 0
1200   // (8, 8)           = (Input << 16) >> 24  = (Input &  0xffff)     >> 8
1201   // (16,8)           = (Input <<  8) >> 24  = (Input &  0xffffff)   >> 16
1202   // (24,8)           = (Input <<  0) >> 24  = (Input &  0xffffffff) >> 24
1203   def BFE_UINT_eg : R600_3OP <0x4, "BFE_UINT",
1204     [(set R600_Reg32:$dst, (int_AMDIL_bit_extract_u32 R600_Reg32:$src0,
1205                                                       R600_Reg32:$src1,
1206                                                       R600_Reg32:$src2))],
1207     VecALU
1208   >;
1209
1210   def BIT_ALIGN_INT_eg : R600_3OP <0xC, "BIT_ALIGN_INT",
1211     [(set R600_Reg32:$dst, (AMDGPUbitalign R600_Reg32:$src0, R600_Reg32:$src1,
1212                                           R600_Reg32:$src2))],
1213     VecALU
1214   >;
1215
1216   def MULADD_eg : MULADD_Common<0x14>;
1217   def ASHR_eg : ASHR_Common<0x15>;
1218   def LSHR_eg : LSHR_Common<0x16>;
1219   def LSHL_eg : LSHL_Common<0x17>;
1220   def CNDE_eg : CNDE_Common<0x19>;
1221   def CNDGT_eg : CNDGT_Common<0x1A>;
1222   def CNDGE_eg : CNDGE_Common<0x1B>;
1223   def MUL_LIT_eg : MUL_LIT_Common<0x1F>;
1224   def LOG_CLAMPED_eg : LOG_CLAMPED_Common<0x82>;
1225   defm DOT4_eg : DOT4_Common<0xBE>;
1226   defm CUBE_eg : CUBE_Common<0xC0>;
1227
1228 let hasSideEffects = 1 in {
1229   def MOVA_INT_eg : R600_1OP <0xCC, "MOVA_INT", []>;
1230 }
1231
1232   def TGSI_LIT_Z_eg : TGSI_LIT_Z_Common<MUL_LIT_eg, LOG_CLAMPED_eg, EXP_IEEE_eg>;
1233
1234   def FLT_TO_INT_eg : FLT_TO_INT_Common<0x50> {
1235     let Pattern = [];
1236   }
1237
1238   def INT_TO_FLT_eg : INT_TO_FLT_Common<0x9B>;
1239
1240   def FLT_TO_UINT_eg : FLT_TO_UINT_Common<0x9A> {
1241     let Pattern = [];
1242   }
1243
1244   def UINT_TO_FLT_eg : UINT_TO_FLT_Common<0x9C>;
1245
1246   // TRUNC is used for the FLT_TO_INT instructions to work around a
1247   // perceived problem where the rounding modes are applied differently
1248   // depending on the instruction and the slot they are in.
1249   // See:
1250   // https://bugs.freedesktop.org/show_bug.cgi?id=50232
1251   // Mesa commit: a1a0974401c467cb86ef818f22df67c21774a38c
1252   //
1253   // XXX: Lowering SELECT_CC will sometimes generate fp_to_[su]int nodes,
1254   // which do not need to be truncated since the fp values are 0.0f or 1.0f.
1255   // We should look into handling these cases separately.
1256   def : Pat<(fp_to_sint R600_Reg32:$src0),
1257     (FLT_TO_INT_eg (TRUNC R600_Reg32:$src0))>;
1258
1259   def : Pat<(fp_to_uint R600_Reg32:$src0),
1260     (FLT_TO_UINT_eg (TRUNC R600_Reg32:$src0))>;
1261
1262   def EG_ExportSwz : ExportSwzInst {
1263     let Word1{19-16} = 1; // BURST_COUNT
1264     let Word1{20} = 1; // VALID_PIXEL_MODE
1265     let Word1{21} = eop;
1266     let Word1{29-22} = inst;
1267     let Word1{30} = 0; // MARK
1268     let Word1{31} = 1; // BARRIER
1269   }
1270   defm : ExportPattern<EG_ExportSwz, 83>;
1271
1272   def EG_ExportBuf : ExportBufInst {
1273     let Word1{19-16} = 1; // BURST_COUNT
1274     let Word1{20} = 1; // VALID_PIXEL_MODE
1275     let Word1{21} = eop;
1276     let Word1{29-22} = inst;
1277     let Word1{30} = 0; // MARK
1278     let Word1{31} = 1; // BARRIER
1279   }
1280   defm : SteamOutputExportPattern<EG_ExportBuf, 0x40, 0x41, 0x42, 0x43>;
1281
1282 //===----------------------------------------------------------------------===//
1283 // Memory read/write instructions
1284 //===----------------------------------------------------------------------===//
1285 let usesCustomInserter = 1 in {
1286
1287 class RAT_WRITE_CACHELESS_eg <dag ins, bits<4> comp_mask, string name,
1288                               list<dag> pattern>
1289     : EG_CF_RAT <0x57, 0x2, 0, (outs), ins,
1290                  !strconcat(name, " $rw_gpr, $index_gpr, $eop"), pattern> {
1291   let RIM         = 0;
1292   // XXX: Have a separate instruction for non-indexed writes.
1293   let TYPE        = 1;
1294   let RW_REL      = 0;
1295   let ELEM_SIZE   = 0;
1296
1297   let ARRAY_SIZE  = 0;
1298   let COMP_MASK   = comp_mask;
1299   let BURST_COUNT = 0;
1300   let VPM         = 0;
1301   let MARK        = 0;
1302   let BARRIER     = 1;
1303 }
1304
1305 } // End usesCustomInserter = 1
1306
1307 // 32-bit store
1308 def RAT_WRITE_CACHELESS_32_eg : RAT_WRITE_CACHELESS_eg <
1309   (ins R600_TReg32_X:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1310   0x1, "RAT_WRITE_CACHELESS_32_eg",
1311   [(global_store (i32 R600_TReg32_X:$rw_gpr), R600_TReg32_X:$index_gpr)]
1312 >;
1313
1314 //128-bit store
1315 def RAT_WRITE_CACHELESS_128_eg : RAT_WRITE_CACHELESS_eg <
1316   (ins R600_Reg128:$rw_gpr, R600_TReg32_X:$index_gpr, InstFlag:$eop),
1317   0xf, "RAT_WRITE_CACHELESS_128",
1318   [(global_store (v4i32 R600_Reg128:$rw_gpr), R600_TReg32_X:$index_gpr)]
1319 >;
1320
1321 class VTX_READ_eg <string name, bits<8> buffer_id, dag outs, list<dag> pattern>
1322     : InstR600ISA <outs, (ins MEMxi:$ptr), name#" $dst, $ptr", pattern>,
1323       VTX_WORD1_GPR, VTX_WORD0 {
1324
1325   // Static fields
1326   let VC_INST = 0;
1327   let FETCH_TYPE = 2;
1328   let FETCH_WHOLE_QUAD = 0;
1329   let BUFFER_ID = buffer_id;
1330   let SRC_REL = 0;
1331   // XXX: We can infer this field based on the SRC_GPR.  This would allow us
1332   // to store vertex addresses in any channel, not just X.
1333   let SRC_SEL_X = 0;
1334   let DST_REL = 0;
1335   // The docs say that if this bit is set, then DATA_FORMAT, NUM_FORMAT_ALL,
1336   // FORMAT_COMP_ALL, SRF_MODE_ALL, and ENDIAN_SWAP fields will be ignored,
1337   // however, based on my testing if USE_CONST_FIELDS is set, then all
1338   // these fields need to be set to 0.
1339   let USE_CONST_FIELDS = 0;
1340   let NUM_FORMAT_ALL = 1;
1341   let FORMAT_COMP_ALL = 0;
1342   let SRF_MODE_ALL = 0;
1343
1344   let Inst{31-0} = Word0;
1345   let Inst{63-32} = Word1;
1346   // LLVM can only encode 64-bit instructions, so these fields are manually
1347   // encoded in R600CodeEmitter
1348   //
1349   // bits<16> OFFSET;
1350   // bits<2>  ENDIAN_SWAP = 0;
1351   // bits<1>  CONST_BUF_NO_STRIDE = 0;
1352   // bits<1>  MEGA_FETCH = 0;
1353   // bits<1>  ALT_CONST = 0;
1354   // bits<2>  BUFFER_INDEX_MODE = 0;
1355
1356
1357
1358   // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1359   // is done in R600CodeEmitter
1360   //
1361   // Inst{79-64} = OFFSET;
1362   // Inst{81-80} = ENDIAN_SWAP;
1363   // Inst{82}    = CONST_BUF_NO_STRIDE;
1364   // Inst{83}    = MEGA_FETCH;
1365   // Inst{84}    = ALT_CONST;
1366   // Inst{86-85} = BUFFER_INDEX_MODE;
1367   // Inst{95-86} = 0; Reserved
1368
1369   // VTX_WORD3 (Padding)
1370   //
1371   // Inst{127-96} = 0;
1372 }
1373
1374 class VTX_READ_8_eg <bits<8> buffer_id, list<dag> pattern>
1375     : VTX_READ_eg <"VTX_READ_8", buffer_id, (outs R600_TReg32_X:$dst),
1376                    pattern> {
1377
1378   let MEGA_FETCH_COUNT = 1;
1379   let DST_SEL_X = 0;
1380   let DST_SEL_Y = 7;   // Masked
1381   let DST_SEL_Z = 7;   // Masked
1382   let DST_SEL_W = 7;   // Masked
1383   let DATA_FORMAT = 1; // FMT_8
1384 }
1385
1386 class VTX_READ_16_eg <bits<8> buffer_id, list<dag> pattern>
1387     : VTX_READ_eg <"VTX_READ_16", buffer_id, (outs R600_TReg32_X:$dst),
1388                     pattern> {
1389   let MEGA_FETCH_COUNT = 2;
1390   let DST_SEL_X = 0;
1391   let DST_SEL_Y = 7;   // Masked
1392   let DST_SEL_Z = 7;   // Masked
1393   let DST_SEL_W = 7;   // Masked
1394   let DATA_FORMAT = 5; // FMT_16
1395
1396 }
1397
1398 class VTX_READ_32_eg <bits<8> buffer_id, list<dag> pattern>
1399     : VTX_READ_eg <"VTX_READ_32", buffer_id, (outs R600_TReg32_X:$dst),
1400                    pattern> {
1401
1402   let MEGA_FETCH_COUNT = 4;
1403   let DST_SEL_X        = 0;
1404   let DST_SEL_Y        = 7;   // Masked
1405   let DST_SEL_Z        = 7;   // Masked
1406   let DST_SEL_W        = 7;   // Masked
1407   let DATA_FORMAT      = 0xD; // COLOR_32
1408
1409   // This is not really necessary, but there were some GPU hangs that appeared
1410   // to be caused by ALU instructions in the next instruction group that wrote
1411   // to the $ptr registers of the VTX_READ.
1412   // e.g.
1413   // %T3_X<def> = VTX_READ_PARAM_32_eg %T2_X<kill>, 24
1414   // %T2_X<def> = MOV %ZERO
1415   //Adding this constraint prevents this from happening.
1416   let Constraints = "$ptr.ptr = $dst";
1417 }
1418
1419 class VTX_READ_128_eg <bits<8> buffer_id, list<dag> pattern>
1420     : VTX_READ_eg <"VTX_READ_128", buffer_id, (outs R600_Reg128:$dst),
1421                    pattern> {
1422
1423   let MEGA_FETCH_COUNT = 16;
1424   let DST_SEL_X        =  0;
1425   let DST_SEL_Y        =  1;
1426   let DST_SEL_Z        =  2;
1427   let DST_SEL_W        =  3;
1428   let DATA_FORMAT      =  0x22; // COLOR_32_32_32_32
1429
1430   // XXX: Need to force VTX_READ_128 instructions to write to the same register
1431   // that holds its buffer address to avoid potential hangs.  We can't use
1432   // the same constraint as VTX_READ_32_eg, because the $ptr.ptr and $dst
1433   // registers are different sizes.
1434 }
1435
1436 //===----------------------------------------------------------------------===//
1437 // VTX Read from parameter memory space
1438 //===----------------------------------------------------------------------===//
1439
1440 def VTX_READ_PARAM_8_eg : VTX_READ_8_eg <0,
1441   [(set (i32 R600_TReg32_X:$dst), (load_param_zexti8 ADDRVTX_READ:$ptr))]
1442 >;
1443
1444 def VTX_READ_PARAM_16_eg : VTX_READ_16_eg <0,
1445   [(set (i32 R600_TReg32_X:$dst), (load_param_zexti16 ADDRVTX_READ:$ptr))]
1446 >;
1447
1448 def VTX_READ_PARAM_32_eg : VTX_READ_32_eg <0,
1449   [(set (i32 R600_TReg32_X:$dst), (load_param ADDRVTX_READ:$ptr))]
1450 >;
1451
1452 //===----------------------------------------------------------------------===//
1453 // VTX Read from global memory space
1454 //===----------------------------------------------------------------------===//
1455
1456 // 8-bit reads
1457 def VTX_READ_GLOBAL_8_eg : VTX_READ_8_eg <1,
1458   [(set (i32 R600_TReg32_X:$dst), (zextloadi8_global ADDRVTX_READ:$ptr))]
1459 >;
1460
1461 // 32-bit reads
1462 def VTX_READ_GLOBAL_32_eg : VTX_READ_32_eg <1,
1463   [(set (i32 R600_TReg32_X:$dst), (global_load ADDRVTX_READ:$ptr))]
1464 >;
1465
1466 // 128-bit reads
1467 def VTX_READ_GLOBAL_128_eg : VTX_READ_128_eg <1,
1468   [(set (v4i32 R600_Reg128:$dst), (global_load ADDRVTX_READ:$ptr))]
1469 >;
1470
1471 //===----------------------------------------------------------------------===//
1472 // Constant Loads
1473 // XXX: We are currently storing all constants in the global address space.
1474 //===----------------------------------------------------------------------===//
1475
1476 def CONSTANT_LOAD_eg : VTX_READ_32_eg <1,
1477   [(set (i32 R600_TReg32_X:$dst), (constant_load ADDRVTX_READ:$ptr))]
1478 >;
1479
1480 }
1481
1482 //===----------------------------------------------------------------------===//
1483 // Regist loads and stores - for indirect addressing
1484 //===----------------------------------------------------------------------===//
1485
1486 defm R600_ : RegisterLoadStore <R600_Reg32, FRAMEri, ADDRIndirect>;
1487
1488 let Predicates = [isCayman] in {
1489
1490 let isVector = 1 in {
1491
1492 def RECIP_IEEE_cm : RECIP_IEEE_Common<0x86>;
1493
1494 def MULLO_INT_cm : MULLO_INT_Common<0x8F>;
1495 def MULHI_INT_cm : MULHI_INT_Common<0x90>;
1496 def MULLO_UINT_cm : MULLO_UINT_Common<0x91>;
1497 def MULHI_UINT_cm : MULHI_UINT_Common<0x92>;
1498 def RECIPSQRT_CLAMPED_cm : RECIPSQRT_CLAMPED_Common<0x87>;
1499 def EXP_IEEE_cm : EXP_IEEE_Common<0x81>;
1500 def LOG_IEEE_ : LOG_IEEE_Common<0x83>;
1501 def RECIP_CLAMPED_cm : RECIP_CLAMPED_Common<0x84>;
1502 def RECIPSQRT_IEEE_cm : RECIPSQRT_IEEE_Common<0x89>;
1503 def SIN_cm : SIN_Common<0x8D>;
1504 def COS_cm : COS_Common<0x8E>;
1505 } // End isVector = 1
1506
1507 def : SIN_PAT <SIN_cm>;
1508 def : COS_PAT <COS_cm>;
1509
1510 defm DIV_cm : DIV_Common<RECIP_IEEE_cm>;
1511
1512 // RECIP_UINT emulation for Cayman
1513 def : Pat <
1514   (AMDGPUurecip R600_Reg32:$src0),
1515   (FLT_TO_UINT_eg (MUL_IEEE (RECIP_IEEE_cm (UINT_TO_FLT_eg R600_Reg32:$src0)),
1516                             (MOV_IMM_I32 0x4f800000)))
1517 >;
1518
1519
1520 def : Pat<(fsqrt R600_Reg32:$src),
1521   (MUL R600_Reg32:$src, (RECIPSQRT_CLAMPED_cm R600_Reg32:$src))>;
1522
1523 } // End isCayman
1524
1525 //===----------------------------------------------------------------------===//
1526 // Branch Instructions
1527 //===----------------------------------------------------------------------===//
1528
1529
1530 def IF_PREDICATE_SET  : ILFormat<(outs), (ins GPRI32:$src),
1531   "IF_PREDICATE_SET $src", []>;
1532
1533 def PREDICATED_BREAK : ILFormat<(outs), (ins GPRI32:$src),
1534   "PREDICATED_BREAK $src", []>;
1535
1536 //===----------------------------------------------------------------------===//
1537 // Pseudo instructions
1538 //===----------------------------------------------------------------------===//
1539
1540 let isPseudo = 1 in {
1541
1542 def PRED_X : InstR600 <
1543   0, (outs R600_Predicate_Bit:$dst),
1544   (ins R600_Reg32:$src0, i32imm:$src1, i32imm:$flags),
1545   "", [], NullALU> {
1546   let FlagOperandIdx = 3;
1547 }
1548
1549 let isTerminator = 1, isBranch = 1, isBarrier = 1 in {
1550
1551 def JUMP : InstR600 <0x10,
1552           (outs),
1553           (ins brtarget:$target, R600_Pred:$p),
1554           "JUMP $target ($p)",
1555           [], AnyALU
1556   >;
1557
1558 }  // End isTerminator = 1, isBranch = 1, isBarrier = 1
1559
1560 let usesCustomInserter = 1 in {
1561
1562 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in {
1563
1564 def MASK_WRITE : AMDGPUShaderInst <
1565     (outs),
1566     (ins R600_Reg32:$src),
1567     "MASK_WRITE $src",
1568     []
1569 >;
1570
1571 } // End mayLoad = 0, mayStore = 0, hasSideEffects = 1
1572
1573
1574 def TXD: AMDGPUShaderInst <
1575   (outs R600_Reg128:$dst),
1576   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
1577   "TXD $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
1578   [(set R600_Reg128:$dst, (int_AMDGPU_txd R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, imm:$resourceId, imm:$samplerId, imm:$textureTarget))]
1579 >;
1580
1581 def TXD_SHADOW: AMDGPUShaderInst <
1582   (outs R600_Reg128:$dst),
1583   (ins R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, i32imm:$resourceId, i32imm:$samplerId, i32imm:$textureTarget),
1584   "TXD_SHADOW $dst, $src0, $src1, $src2, $resourceId, $samplerId, $textureTarget",
1585   [(set R600_Reg128:$dst, (int_AMDGPU_txd R600_Reg128:$src0, R600_Reg128:$src1, R600_Reg128:$src2, imm:$resourceId, imm:$samplerId, TEX_SHADOW:$textureTarget))]
1586 >;
1587
1588 } // End isPseudo = 1
1589 } // End usesCustomInserter = 1
1590
1591 def CLAMP_R600 :  CLAMP <R600_Reg32>;
1592 def FABS_R600 : FABS<R600_Reg32>;
1593 def FNEG_R600 : FNEG<R600_Reg32>;
1594
1595 //===---------------------------------------------------------------------===//
1596 // Return instruction
1597 //===---------------------------------------------------------------------===//
1598 let isTerminator = 1, isReturn = 1, isBarrier = 1, hasCtrlDep = 1,
1599     usesCustomInserter = 1 in {
1600   def RETURN          : ILFormat<(outs), (ins variable_ops),
1601       "RETURN", [(IL_retflag)]>;
1602 }
1603
1604
1605 //===----------------------------------------------------------------------===//
1606 // Constant Buffer Addressing Support
1607 //===----------------------------------------------------------------------===//
1608
1609 let isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"  in {
1610 def CONST_COPY : Instruction {
1611   let OutOperandList = (outs R600_Reg32:$dst);
1612   let InOperandList = (ins i32imm:$src);
1613   let Pattern = [(set R600_Reg32:$dst, (CONST_ADDRESS ADDRGA_CONST_OFFSET:$src))];
1614   let AsmString = "CONST_COPY";
1615   let neverHasSideEffects = 1;
1616   let isAsCheapAsAMove = 1;
1617   let Itinerary = NullALU;
1618 }
1619 } // end isCodeGenOnly = 1, isPseudo = 1, Namespace = "AMDGPU"
1620
1621 def TEX_VTX_CONSTBUF :
1622   InstR600ISA <(outs R600_Reg128:$dst), (ins MEMxi:$ptr), "VTX_READ_eg $dst, $ptr",
1623       [(set R600_Reg128:$dst, (CONST_ADDRESS ADDRGA_VAR_OFFSET:$ptr))]>,
1624   VTX_WORD1_GPR, VTX_WORD0 {
1625
1626   let VC_INST = 0;
1627   let FETCH_TYPE = 2;
1628   let FETCH_WHOLE_QUAD = 0;
1629   let BUFFER_ID = 0;
1630   let SRC_REL = 0;
1631   let SRC_SEL_X = 0;
1632   let DST_REL = 0;
1633   let USE_CONST_FIELDS = 0;
1634   let NUM_FORMAT_ALL = 2;
1635   let FORMAT_COMP_ALL = 1;
1636   let SRF_MODE_ALL = 1;
1637   let MEGA_FETCH_COUNT = 16;
1638   let DST_SEL_X        = 0;
1639   let DST_SEL_Y        = 1;
1640   let DST_SEL_Z        = 2;
1641   let DST_SEL_W        = 3;
1642   let DATA_FORMAT      = 35;
1643
1644   let Inst{31-0} = Word0;
1645   let Inst{63-32} = Word1;
1646
1647 // LLVM can only encode 64-bit instructions, so these fields are manually
1648 // encoded in R600CodeEmitter
1649 //
1650 // bits<16> OFFSET;
1651 // bits<2>  ENDIAN_SWAP = 0;
1652 // bits<1>  CONST_BUF_NO_STRIDE = 0;
1653 // bits<1>  MEGA_FETCH = 0;
1654 // bits<1>  ALT_CONST = 0;
1655 // bits<2>  BUFFER_INDEX_MODE = 0;
1656
1657
1658
1659 // VTX_WORD2 (LLVM can only encode 64-bit instructions, so WORD2 encoding
1660 // is done in R600CodeEmitter
1661 //
1662 // Inst{79-64} = OFFSET;
1663 // Inst{81-80} = ENDIAN_SWAP;
1664 // Inst{82}    = CONST_BUF_NO_STRIDE;
1665 // Inst{83}    = MEGA_FETCH;
1666 // Inst{84}    = ALT_CONST;
1667 // Inst{86-85} = BUFFER_INDEX_MODE;
1668 // Inst{95-86} = 0; Reserved
1669
1670 // VTX_WORD3 (Padding)
1671 //
1672 // Inst{127-96} = 0;
1673 }
1674
1675
1676 //===--------------------------------------------------------------------===//
1677 // Instructions support
1678 //===--------------------------------------------------------------------===//
1679 //===---------------------------------------------------------------------===//
1680 // Custom Inserter for Branches and returns, this eventually will be a
1681 // seperate pass
1682 //===---------------------------------------------------------------------===//
1683 let isTerminator = 1, usesCustomInserter = 1, isBranch = 1, isBarrier = 1 in {
1684   def BRANCH : ILFormat<(outs), (ins brtarget:$target),
1685       "; Pseudo unconditional branch instruction",
1686       [(br bb:$target)]>;
1687   defm BRANCH_COND : BranchConditional<IL_brcond>;
1688 }
1689
1690 //===---------------------------------------------------------------------===//
1691 // Flow and Program control Instructions
1692 //===---------------------------------------------------------------------===//
1693 let isTerminator=1 in {
1694   def SWITCH      : ILFormat< (outs), (ins GPRI32:$src),
1695   !strconcat("SWITCH", " $src"), []>;
1696   def CASE        : ILFormat< (outs), (ins GPRI32:$src),
1697       !strconcat("CASE", " $src"), []>;
1698   def BREAK       : ILFormat< (outs), (ins),
1699       "BREAK", []>;
1700   def CONTINUE    : ILFormat< (outs), (ins),
1701       "CONTINUE", []>;
1702   def DEFAULT     : ILFormat< (outs), (ins),
1703       "DEFAULT", []>;
1704   def ELSE        : ILFormat< (outs), (ins),
1705       "ELSE", []>;
1706   def ENDSWITCH   : ILFormat< (outs), (ins),
1707       "ENDSWITCH", []>;
1708   def ENDMAIN     : ILFormat< (outs), (ins),
1709       "ENDMAIN", []>;
1710   def END         : ILFormat< (outs), (ins),
1711       "END", []>;
1712   def ENDFUNC     : ILFormat< (outs), (ins),
1713       "ENDFUNC", []>;
1714   def ENDIF       : ILFormat< (outs), (ins),
1715       "ENDIF", []>;
1716   def WHILELOOP   : ILFormat< (outs), (ins),
1717       "WHILE", []>;
1718   def ENDLOOP     : ILFormat< (outs), (ins),
1719       "ENDLOOP", []>;
1720   def FUNC        : ILFormat< (outs), (ins),
1721       "FUNC", []>;
1722   def RETDYN      : ILFormat< (outs), (ins),
1723       "RET_DYN", []>;
1724   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1725   defm IF_LOGICALNZ  : BranchInstr<"IF_LOGICALNZ">;
1726   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1727   defm IF_LOGICALZ   : BranchInstr<"IF_LOGICALZ">;
1728   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1729   defm BREAK_LOGICALNZ : BranchInstr<"BREAK_LOGICALNZ">;
1730   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1731   defm BREAK_LOGICALZ : BranchInstr<"BREAK_LOGICALZ">;
1732   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1733   defm CONTINUE_LOGICALNZ : BranchInstr<"CONTINUE_LOGICALNZ">;
1734   // This opcode has custom swizzle pattern encoded in Swizzle Encoder
1735   defm CONTINUE_LOGICALZ : BranchInstr<"CONTINUE_LOGICALZ">;
1736   defm IFC         : BranchInstr2<"IFC">;
1737   defm BREAKC      : BranchInstr2<"BREAKC">;
1738   defm CONTINUEC   : BranchInstr2<"CONTINUEC">;
1739 }
1740
1741 //===----------------------------------------------------------------------===//
1742 // ISel Patterns
1743 //===----------------------------------------------------------------------===//
1744
1745 //CNDGE_INT extra pattern
1746 def : Pat <
1747   (selectcc (i32 R600_Reg32:$src0), -1, (i32 R600_Reg32:$src1),
1748                                         (i32 R600_Reg32:$src2), COND_GT),
1749   (CNDGE_INT R600_Reg32:$src0, R600_Reg32:$src1, R600_Reg32:$src2)
1750 >;
1751
1752 // KIL Patterns
1753 def KILP : Pat <
1754   (int_AMDGPU_kilp),
1755   (MASK_WRITE (KILLGT (f32 ONE), (f32 ZERO)))
1756 >;
1757
1758 def KIL : Pat <
1759   (int_AMDGPU_kill R600_Reg32:$src0),
1760   (MASK_WRITE (KILLGT (f32 ZERO), (f32 R600_Reg32:$src0)))
1761 >;
1762
1763 // SGT Reverse args
1764 def : Pat <
1765   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, COND_LT),
1766   (SGT R600_Reg32:$src1, R600_Reg32:$src0)
1767 >;
1768
1769 // SGE Reverse args
1770 def : Pat <
1771   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, COND_LE),
1772   (SGE R600_Reg32:$src1, R600_Reg32:$src0)
1773 >;
1774
1775 // SETGT_INT reverse args
1776 def : Pat <
1777   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETLT),
1778   (SETGT_INT R600_Reg32:$src1, R600_Reg32:$src0)
1779 >;
1780
1781 // SETGE_INT reverse args
1782 def : Pat <
1783   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETLE),
1784   (SETGE_INT R600_Reg32:$src1, R600_Reg32:$src0)
1785 >;
1786
1787 // SETGT_UINT reverse args
1788 def : Pat <
1789   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETULT),
1790   (SETGT_UINT R600_Reg32:$src1, R600_Reg32:$src0)
1791 >;
1792
1793 // SETGE_UINT reverse args
1794 def : Pat <
1795   (selectcc (i32 R600_Reg32:$src0), R600_Reg32:$src1, -1, 0, SETULE),
1796   (SETGE_UINT R600_Reg32:$src1, R600_Reg32:$src0)
1797 >;
1798
1799 // The next two patterns are special cases for handling 'true if ordered' and
1800 // 'true if unordered' conditionals.  The assumption here is that the behavior of
1801 // SETE and SNE conforms to the Direct3D 10 rules for floating point values
1802 // described here:
1803 // http://msdn.microsoft.com/en-us/library/windows/desktop/cc308050.aspx#alpha_32_bit
1804 // We assume that  SETE returns false when one of the operands is NAN and
1805 // SNE returns true when on of the operands is NAN
1806
1807 //SETE - 'true if ordered'
1808 def : Pat <
1809   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, SETO),
1810   (SETE R600_Reg32:$src0, R600_Reg32:$src1)
1811 >;
1812
1813 //SNE - 'true if unordered'
1814 def : Pat <
1815   (selectcc (f32 R600_Reg32:$src0), R600_Reg32:$src1, FP_ONE, FP_ZERO, SETUO),
1816   (SNE R600_Reg32:$src0, R600_Reg32:$src1)
1817 >;
1818
1819 def : Extract_Element <f32, v4f32, R600_Reg128, 0, sel_x>;
1820 def : Extract_Element <f32, v4f32, R600_Reg128, 1, sel_y>;
1821 def : Extract_Element <f32, v4f32, R600_Reg128, 2, sel_z>;
1822 def : Extract_Element <f32, v4f32, R600_Reg128, 3, sel_w>;
1823
1824 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 0, sel_x>;
1825 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 1, sel_y>;
1826 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 2, sel_z>;
1827 def : Insert_Element <f32, v4f32, R600_Reg32, R600_Reg128, 3, sel_w>;
1828
1829 def : Extract_Element <i32, v4i32, R600_Reg128, 0, sel_x>;
1830 def : Extract_Element <i32, v4i32, R600_Reg128, 1, sel_y>;
1831 def : Extract_Element <i32, v4i32, R600_Reg128, 2, sel_z>;
1832 def : Extract_Element <i32, v4i32, R600_Reg128, 3, sel_w>;
1833
1834 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 0, sel_x>;
1835 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 1, sel_y>;
1836 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 2, sel_z>;
1837 def : Insert_Element <i32, v4i32, R600_Reg32, R600_Reg128, 3, sel_w>;
1838
1839 def : Vector_Build <v4f32, R600_Reg128, f32, R600_Reg32>;
1840 def : Vector_Build <v4i32, R600_Reg128, i32, R600_Reg32>;
1841
1842 // bitconvert patterns
1843
1844 def : BitConvert <i32, f32, R600_Reg32>;
1845 def : BitConvert <f32, i32, R600_Reg32>;
1846 def : BitConvert <v4f32, v4i32, R600_Reg128>;
1847 def : BitConvert <v4i32, v4f32, R600_Reg128>;
1848
1849 // DWORDADDR pattern
1850 def : DwordAddrPat  <i32, R600_Reg32>;
1851
1852 } // End isR600toCayman Predicate