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