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