lib/Target/R600/R600Instructions.td

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