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