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