lib/Target/R600/R600InstrFormats.td

   1 //===-- R600InstrFormats.td - R600 Instruction Encodings ------------------===//
   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 Instruction format definitions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 class InstR600 <dag outs, dag ins, string asm, list<dag> pattern,
  15                 InstrItinClass itin>
  16     : AMDGPUInst <outs, ins, asm, pattern> {
  17
  18   field bits<64> Inst;
  19   bit TransOnly = 0;
  20   bit Trig = 0;
  21   bit Op3 = 0;
  22   bit isVector = 0;
  23   bits<2> FlagOperandIdx = 0;
  24   bit Op1 = 0;
  25   bit Op2 = 0;
  26   bit HasNativeOperands = 0;
  27   bit VTXInst = 0;
  28   bit TEXInst = 0;
  29
  30   let Namespace = "AMDGPU";
  31   let OutOperandList = outs;
  32   let InOperandList = ins;
  33   let AsmString = asm;
  34   let Pattern = pattern;
  35   let Itinerary = itin;
  36
  37   let TSFlags{0} = TransOnly;
  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   let TSFlags{12} = VTXInst;
  49   let TSFlags{13} = TEXInst;
  50 }
  51
  52 //===----------------------------------------------------------------------===//
  53 // ALU instructions
  54 //===----------------------------------------------------------------------===//
  55
  56 class R600ALU_Word0 {
  57   field bits<32> Word0;
  58
  59   bits<11> src0;
  60   bits<1>  src0_neg;
  61   bits<1>  src0_rel;
  62   bits<11> src1;
  63   bits<1>  src1_rel;
  64   bits<1>  src1_neg;
  65   bits<3>  index_mode = 0;
  66   bits<2>  pred_sel;
  67   bits<1>  last;
  68
  69   bits<9>  src0_sel  = src0{8-0};
  70   bits<2>  src0_chan = src0{10-9};
  71   bits<9>  src1_sel  = src1{8-0};
  72   bits<2>  src1_chan = src1{10-9};
  73
  74   let Word0{8-0}   = src0_sel;
  75   let Word0{9}     = src0_rel;
  76   let Word0{11-10} = src0_chan;
  77   let Word0{12}    = src0_neg;
  78   let Word0{21-13} = src1_sel;
  79   let Word0{22}    = src1_rel;
  80   let Word0{24-23} = src1_chan;
  81   let Word0{25}    = src1_neg;
  82   let Word0{28-26} = index_mode;
  83   let Word0{30-29} = pred_sel;
  84   let Word0{31}    = last;
  85 }
  86
  87 class R600ALU_Word1 {
  88   field bits<32> Word1;
  89
  90   bits<11> dst;
  91   bits<3>  bank_swizzle;
  92   bits<1>  dst_rel;
  93   bits<1>  clamp;
  94
  95   bits<7>  dst_sel  = dst{6-0};
  96   bits<2>  dst_chan = dst{10-9};
  97
  98   let Word1{20-18} = bank_swizzle;
  99   let Word1{27-21} = dst_sel;
 100   let Word1{28}    = dst_rel;
 101   let Word1{30-29} = dst_chan;
 102   let Word1{31}    = clamp;
 103 }
 104
 105 class R600ALU_Word1_OP2 <bits<11> alu_inst> : R600ALU_Word1{
 106
 107   bits<1>  src0_abs;
 108   bits<1>  src1_abs;
 109   bits<1>  update_exec_mask;
 110   bits<1>  update_pred;
 111   bits<1>  write;
 112   bits<2>  omod;
 113
 114   let Word1{0}     = src0_abs;
 115   let Word1{1}     = src1_abs;
 116   let Word1{2}     = update_exec_mask;
 117   let Word1{3}     = update_pred;
 118   let Word1{4}     = write;
 119   let Word1{6-5}   = omod;
 120   let Word1{17-7}  = alu_inst;
 121 }
 122
 123 class R600ALU_Word1_OP3 <bits<5> alu_inst> : R600ALU_Word1{
 124
 125   bits<11> src2;
 126   bits<1>  src2_rel;
 127   bits<1>  src2_neg;
 128
 129   bits<9>  src2_sel = src2{8-0};
 130   bits<2>  src2_chan = src2{10-9};
 131
 132   let Word1{8-0}   = src2_sel;
 133   let Word1{9}     = src2_rel;
 134   let Word1{11-10} = src2_chan;
 135   let Word1{12}    = src2_neg;
 136   let Word1{17-13} = alu_inst;
 137 }
 138
 139 /*
 140 XXX: R600 subtarget uses a slightly different encoding than the other
 141 subtargets.  We currently handle this in R600MCCodeEmitter, but we may
 142 want to use these instruction classes in the future.
 143
 144 class R600ALU_Word1_OP2_r600 : R600ALU_Word1_OP2 {
 145
 146   bits<1>  fog_merge;
 147   bits<10> alu_inst;
 148
 149   let Inst{37}    = fog_merge;
 150   let Inst{39-38} = omod;
 151   let Inst{49-40} = alu_inst;
 152 }
 153
 154 class R600ALU_Word1_OP2_r700 : R600ALU_Word1_OP2 {
 155
 156   bits<11> alu_inst;
 157
 158   let Inst{38-37} = omod;
 159   let Inst{49-39} = alu_inst;
 160 }
 161 */
 162
 163 //===----------------------------------------------------------------------===//
 164 // Vertex Fetch instructions
 165 //===----------------------------------------------------------------------===//
 166
 167 class VTX_WORD0 {
 168   field bits<32> Word0;
 169   bits<7> src_gpr;
 170   bits<5> VC_INST;
 171   bits<2> FETCH_TYPE;
 172   bits<1> FETCH_WHOLE_QUAD;
 173   bits<8> BUFFER_ID;
 174   bits<1> SRC_REL;
 175   bits<2> SRC_SEL_X;
 176
 177   let Word0{4-0}   = VC_INST;
 178   let Word0{6-5}   = FETCH_TYPE;
 179   let Word0{7}     = FETCH_WHOLE_QUAD;
 180   let Word0{15-8}  = BUFFER_ID;
 181   let Word0{22-16} = src_gpr;
 182   let Word0{23}    = SRC_REL;
 183   let Word0{25-24} = SRC_SEL_X;
 184 }
 185
 186 class VTX_WORD0_eg : VTX_WORD0 {
 187
 188   bits<6> MEGA_FETCH_COUNT;
 189
 190   let Word0{31-26} = MEGA_FETCH_COUNT;
 191 }
 192
 193 class VTX_WORD0_cm : VTX_WORD0 {
 194
 195   bits<2> SRC_SEL_Y;
 196   bits<2> STRUCTURED_READ;
 197   bits<1> LDS_REQ;
 198   bits<1> COALESCED_READ;
 199
 200   let Word0{27-26} = SRC_SEL_Y;
 201   let Word0{29-28} = STRUCTURED_READ;
 202   let Word0{30}    = LDS_REQ;
 203   let Word0{31}    = COALESCED_READ;
 204 }
 205
 206 class VTX_WORD1_GPR {
 207   field bits<32> Word1;
 208   bits<7> dst_gpr;
 209   bits<1> DST_REL;
 210   bits<3> DST_SEL_X;
 211   bits<3> DST_SEL_Y;
 212   bits<3> DST_SEL_Z;
 213   bits<3> DST_SEL_W;
 214   bits<1> USE_CONST_FIELDS;
 215   bits<6> DATA_FORMAT;
 216   bits<2> NUM_FORMAT_ALL;
 217   bits<1> FORMAT_COMP_ALL;
 218   bits<1> SRF_MODE_ALL;
 219
 220   let Word1{6-0} = dst_gpr;
 221   let Word1{7}    = DST_REL;
 222   let Word1{8}    = 0; // Reserved
 223   let Word1{11-9} = DST_SEL_X;
 224   let Word1{14-12} = DST_SEL_Y;
 225   let Word1{17-15} = DST_SEL_Z;
 226   let Word1{20-18} = DST_SEL_W;
 227   let Word1{21}    = USE_CONST_FIELDS;
 228   let Word1{27-22} = DATA_FORMAT;
 229   let Word1{29-28} = NUM_FORMAT_ALL;
 230   let Word1{30}    = FORMAT_COMP_ALL;
 231   let Word1{31}    = SRF_MODE_ALL;
 232 }
 233
 234 //===----------------------------------------------------------------------===//
 235 // Texture fetch instructions
 236 //===----------------------------------------------------------------------===//
 237
 238 class TEX_WORD0 {
 239   field bits<32> Word0;
 240
 241   bits<5> TEX_INST;
 242   bits<2> INST_MOD;
 243   bits<1> FETCH_WHOLE_QUAD;
 244   bits<8> RESOURCE_ID;
 245   bits<7> SRC_GPR;
 246   bits<1> SRC_REL;
 247   bits<1> ALT_CONST;
 248   bits<2> RESOURCE_INDEX_MODE;
 249   bits<2> SAMPLER_INDEX_MODE;
 250
 251   let Word0{4-0} = TEX_INST;
 252   let Word0{6-5} = INST_MOD;
 253   let Word0{7} = FETCH_WHOLE_QUAD;
 254   let Word0{15-8} = RESOURCE_ID;
 255   let Word0{22-16} = SRC_GPR;
 256   let Word0{23} = SRC_REL;
 257   let Word0{24} = ALT_CONST;
 258   let Word0{26-25} = RESOURCE_INDEX_MODE;
 259   let Word0{28-27} = SAMPLER_INDEX_MODE;
 260 }
 261
 262 class TEX_WORD1 {
 263   field bits<32> Word1;
 264
 265   bits<7> DST_GPR;
 266   bits<1> DST_REL;
 267   bits<3> DST_SEL_X;
 268   bits<3> DST_SEL_Y;
 269   bits<3> DST_SEL_Z;
 270   bits<3> DST_SEL_W;
 271   bits<7> LOD_BIAS;
 272   bits<1> COORD_TYPE_X;
 273   bits<1> COORD_TYPE_Y;
 274   bits<1> COORD_TYPE_Z;
 275   bits<1> COORD_TYPE_W;
 276
 277   let Word1{6-0} = DST_GPR;
 278   let Word1{7} = DST_REL;
 279   let Word1{11-9} = DST_SEL_X;
 280   let Word1{14-12} = DST_SEL_Y;
 281   let Word1{17-15} = DST_SEL_Z;
 282   let Word1{20-18} = DST_SEL_W;
 283   let Word1{27-21} = LOD_BIAS;
 284   let Word1{28} = COORD_TYPE_X;
 285   let Word1{29} = COORD_TYPE_Y;
 286   let Word1{30} = COORD_TYPE_Z;
 287   let Word1{31} = COORD_TYPE_W;
 288 }
 289
 290 class TEX_WORD2 {
 291   field bits<32> Word2;
 292
 293   bits<5> OFFSET_X;
 294   bits<5> OFFSET_Y;
 295   bits<5> OFFSET_Z;
 296   bits<5> SAMPLER_ID;
 297   bits<3> SRC_SEL_X;
 298   bits<3> SRC_SEL_Y;
 299   bits<3> SRC_SEL_Z;
 300   bits<3> SRC_SEL_W;
 301
 302   let Word2{4-0} = OFFSET_X;
 303   let Word2{9-5} = OFFSET_Y;
 304   let Word2{14-10} = OFFSET_Z;
 305   let Word2{19-15} = SAMPLER_ID;
 306   let Word2{22-20} = SRC_SEL_X;
 307   let Word2{25-23} = SRC_SEL_Y;
 308   let Word2{28-26} = SRC_SEL_Z;
 309   let Word2{31-29} = SRC_SEL_W;
 310 }
 311
 312 //===----------------------------------------------------------------------===//
 313 // Control Flow Instructions
 314 //===----------------------------------------------------------------------===//
 315
 316 class CF_WORD1_R600 {
 317   field bits<32> Word1;
 318
 319   bits<3> POP_COUNT;
 320   bits<5> CF_CONST;
 321   bits<2> COND;
 322   bits<3> COUNT;
 323   bits<6> CALL_COUNT;
 324   bits<1> COUNT_3;
 325   bits<1> END_OF_PROGRAM;
 326   bits<1> VALID_PIXEL_MODE;
 327   bits<7> CF_INST;
 328   bits<1> WHOLE_QUAD_MODE;
 329   bits<1> BARRIER;
 330
 331   let Word1{2-0} = POP_COUNT;
 332   let Word1{7-3} = CF_CONST;
 333   let Word1{9-8} = COND;
 334   let Word1{12-10} = COUNT;
 335   let Word1{18-13} = CALL_COUNT;
 336   let Word1{19} = COUNT_3;
 337   let Word1{21} = END_OF_PROGRAM;
 338   let Word1{22} = VALID_PIXEL_MODE;
 339   let Word1{29-23} = CF_INST;
 340   let Word1{30} = WHOLE_QUAD_MODE;
 341   let Word1{31} = BARRIER;
 342 }
 343
 344 class CF_WORD0_EG {
 345   field bits<32> Word0;
 346
 347   bits<24> ADDR;
 348   bits<3> JUMPTABLE_SEL;
 349
 350   let Word0{23-0} = ADDR;
 351   let Word0{26-24} = JUMPTABLE_SEL;
 352 }
 353
 354 class CF_WORD1_EG {
 355   field bits<32> Word1;
 356
 357   bits<3> POP_COUNT;
 358   bits<5> CF_CONST;
 359   bits<2> COND;
 360   bits<6> COUNT;
 361   bits<1> VALID_PIXEL_MODE;
 362   bits<1> END_OF_PROGRAM;
 363   bits<8> CF_INST;
 364   bits<1> BARRIER;
 365
 366   let Word1{2-0} = POP_COUNT;
 367   let Word1{7-3} = CF_CONST;
 368   let Word1{9-8} = COND;
 369   let Word1{15-10} = COUNT;
 370   let Word1{20} = VALID_PIXEL_MODE;
 371   let Word1{21} = END_OF_PROGRAM;
 372   let Word1{29-22} = CF_INST;
 373   let Word1{31} = BARRIER;
 374 }
 375
 376 class CF_ALU_WORD0 {
 377   field bits<32> Word0;
 378
 379   bits<22> ADDR;
 380   bits<4> KCACHE_BANK0;
 381   bits<4> KCACHE_BANK1;
 382   bits<2> KCACHE_MODE0;
 383
 384   let Word0{21-0} = ADDR;
 385   let Word0{25-22} = KCACHE_BANK0;
 386   let Word0{29-26} = KCACHE_BANK1;
 387   let Word0{31-30} = KCACHE_MODE0;
 388 }
 389
 390 class CF_ALU_WORD1 {
 391   field bits<32> Word1;
 392
 393   bits<2> KCACHE_MODE1;
 394   bits<8> KCACHE_ADDR0;
 395   bits<8> KCACHE_ADDR1;
 396   bits<7> COUNT;
 397   bits<1> ALT_CONST;
 398   bits<4> CF_INST;
 399   bits<1> WHOLE_QUAD_MODE;
 400   bits<1> BARRIER;
 401
 402   let Word1{1-0} = KCACHE_MODE1;
 403   let Word1{9-2} = KCACHE_ADDR0;
 404   let Word1{17-10} = KCACHE_ADDR1;
 405   let Word1{24-18} = COUNT;
 406   let Word1{25} = ALT_CONST;
 407   let Word1{29-26} = CF_INST;
 408   let Word1{30} = WHOLE_QUAD_MODE;
 409   let Word1{31} = BARRIER;
 410 }
 411
 412 class CF_ALLOC_EXPORT_WORD0_RAT {
 413   field bits<32> Word0;
 414
 415   bits<4> rat_id;
 416   bits<6> rat_inst;
 417   bits<2> rim;
 418   bits<2> type;
 419   bits<7> rw_gpr;
 420   bits<1> rw_rel;
 421   bits<7> index_gpr;
 422   bits<2> elem_size;
 423
 424   let Word0{3-0}   = rat_id;
 425   let Word0{9-4}   = rat_inst;
 426   let Word0{10}    = 0; // Reserved
 427   let Word0{12-11} = rim;
 428   let Word0{14-13} = type;
 429   let Word0{21-15} = rw_gpr;
 430   let Word0{22}    = rw_rel;
 431   let Word0{29-23} = index_gpr;
 432   let Word0{31-30} = elem_size;
 433 }
 434
 435 class CF_ALLOC_EXPORT_WORD1_BUF {
 436   field bits<32> Word1;
 437
 438   bits<12> array_size;
 439   bits<4>  comp_mask;
 440   bits<4>  burst_count;
 441   bits<1>  vpm;
 442   bits<1>  eop;
 443   bits<8>  cf_inst;
 444   bits<1>  mark;
 445   bits<1>  barrier;
 446
 447   let Word1{11-0} = array_size;
 448   let Word1{15-12} = comp_mask;
 449   let Word1{19-16} = burst_count;
 450   let Word1{20}    = vpm;
 451   let Word1{21}    = eop;
 452   let Word1{29-22} = cf_inst;
 453   let Word1{30}    = mark;
 454   let Word1{31}    = barrier;
 455 }