gem5  v21.1.0.2
op_encodings.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-2021 Advanced Micro Devices, Inc.
3  * All rights reserved.
4  *
5  * For use for simulation and test purposes only
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright notice,
11  * this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright notice,
14  * this list of conditions and the following disclaimer in the documentation
15  * and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the copyright holder nor the names of its
18  * contributors may be used to endorse or promote products derived from this
19  * software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  */
33 
35 
36 #include <iomanip>
37 
38 namespace gem5
39 {
40 
41 namespace VegaISA
42 {
43  // --- Inst_SOP2 base class methods ---
44 
45  Inst_SOP2::Inst_SOP2(InFmt_SOP2 *iFmt, const std::string &opcode)
47  {
48  setFlag(Scalar);
49 
50  // copy first instruction DWORD
51  instData = iFmt[0];
52  if (hasSecondDword(iFmt)) {
53  // copy second instruction DWORD into union
54  extData = ((MachInst)iFmt)[1];
55  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
56  varSize = 4 + 4;
57  } else {
58  varSize = 4;
59  } // if
60  } // Inst_SOP2
61 
62  void
64  {
65  int opNum = 0;
66 
67  // Needed because can't take addr of bitfield
68  int reg = instData.SSRC0;
69  srcOps.emplace_back(reg, getOperandSize(opNum), true,
70  isScalarReg(instData.SSRC0), false, false);
71  opNum++;
72 
73  reg = instData.SSRC1;
74  srcOps.emplace_back(reg, getOperandSize(opNum), true,
75  isScalarReg(instData.SSRC1), false, false);
76  opNum++;
77 
78  reg = instData.SDST;
79  dstOps.emplace_back(reg, getOperandSize(opNum), false,
80  isScalarReg(instData.SDST), false, false);
81 
82  assert(srcOps.size() == numSrcRegOperands());
83  assert(dstOps.size() == numDstRegOperands());
84  }
85 
86  int
88  {
89  return varSize;
90  } // instSize
91 
92  bool
94  {
95  if (iFmt->SSRC0 == REG_SRC_LITERAL)
96  return true;
97 
98  if (iFmt->SSRC1 == REG_SRC_LITERAL)
99  return true;
100 
101  return false;
102  }
103 
104  void
106  {
107  std::stringstream dis_stream;
108  dis_stream << _opcode << " ";
109  dis_stream << opSelectorToRegSym(instData.SDST) << ", ";
110 
111  if (instData.SSRC0 == REG_SRC_LITERAL) {
112  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
113  << _srcLiteral << ", ";
114  } else {
115  dis_stream << opSelectorToRegSym(instData.SSRC0) << ", ";
116  }
117 
118  if (instData.SSRC1 == REG_SRC_LITERAL) {
119  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
120  << _srcLiteral;
121  } else {
122  dis_stream << opSelectorToRegSym(instData.SSRC1);
123  }
124 
125  disassembly = dis_stream.str();
126  }
127 
128  // --- Inst_SOPK base class methods ---
129 
130  Inst_SOPK::Inst_SOPK(InFmt_SOPK *iFmt, const std::string &opcode)
132  {
133  setFlag(Scalar);
134 
135  // copy first instruction DWORD
136  instData = iFmt[0];
137  if (hasSecondDword(iFmt)) {
138  // copy second instruction DWORD into union
139  extData = ((MachInst)iFmt)[1];
140  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
141  varSize = 4 + 4;
142  } else {
143  varSize = 4;
144  } // if
145  } // Inst_SOPK
146 
148  {
149  } // ~Inst_SOPK
150 
151  void
153  {
154  int opNum = 0;
155 
156  // Needed because can't take addr of bitfield
157  int reg = instData.SDST;
158  if (numSrcRegOperands() == getNumOperands()) {
159  srcOps.emplace_back(reg, getOperandSize(opNum), true,
160  isScalarReg(reg), false, false);
161  opNum++;
162  }
163 
164  reg = instData.SIMM16;
165  srcOps.emplace_back(reg, getOperandSize(opNum), true,
166  false, false, true);
167  opNum++;
168 
169  if (numDstRegOperands()) {
170  reg = instData.SDST;
171  dstOps.emplace_back(reg, getOperandSize(opNum), false,
172  isScalarReg(reg), false, false);
173  }
174 
175  assert(srcOps.size() == numSrcRegOperands());
176  assert(dstOps.size() == numDstRegOperands());
177  }
178 
179  int
181  {
182  return varSize;
183  } // instSize
184 
185  bool
187  {
188  /*
189  SOPK can be a 64-bit instruction, i.e., have a second dword:
190  S_SETREG_IMM32_B32 writes some or all of the LSBs of a 32-bit
191  literal constant into a hardware register;
192  the way to detect such special case is to explicitly check the
193  opcode (20/0x14)
194  */
195  if (iFmt->OP == 0x14)
196  return true;
197 
198  return false;
199  }
200 
201 
202  void
204  {
205  std::stringstream dis_stream;
206  dis_stream << _opcode << " ";
207 
208  // S_SETREG_IMM32_B32 is a 64-bit instruction, using a
209  // 32-bit literal constant
210  if (instData.OP == 0x14) {
211  dis_stream << "0x" << std::hex << std::setfill('0')
212  << std::setw(8) << extData.imm_u32 << ", ";
213  } else {
214  dis_stream << opSelectorToRegSym(instData.SDST) << ", ";
215  }
216 
217  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(4)
218  << instData.SIMM16;
219 
220  disassembly = dis_stream.str();
221  }
222 
223  // --- Inst_SOP1 base class methods ---
224 
225  Inst_SOP1::Inst_SOP1(InFmt_SOP1 *iFmt, const std::string &opcode)
227  {
228  setFlag(Scalar);
229 
230  // copy first instruction DWORD
231  instData = iFmt[0];
232  if (hasSecondDword(iFmt)) {
233  // copy second instruction DWORD into union
234  extData = ((MachInst)iFmt)[1];
235  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
236  varSize = 4 + 4;
237  } else {
238  varSize = 4;
239  } // if
240  } // Inst_SOP1
241 
243  {
244  } // ~Inst_SOP1
245 
246  void
248  {
249  int opNum = 0;
250 
251  // Needed because can't take addr of bitfield
252  int reg = instData.SSRC0;
253  if (instData.OP != 0x1C) {
254  srcOps.emplace_back(reg, getOperandSize(opNum), true,
255  isScalarReg(instData.SSRC0), false, false);
256  opNum++;
257  }
258 
259  reg = instData.SDST;
260  dstOps.emplace_back(reg, getOperandSize(opNum), false,
261  isScalarReg(instData.SDST), false, false);
262 
263  assert(srcOps.size() == numSrcRegOperands());
264  assert(dstOps.size() == numDstRegOperands());
265  }
266 
267  int
269  {
270  return varSize;
271  } // instSize
272 
273  bool
275  {
276  if (iFmt->SSRC0 == REG_SRC_LITERAL)
277  return true;
278 
279  return false;
280  }
281 
282  void
284  {
285  std::stringstream dis_stream;
286  dis_stream << _opcode << " ";
287  dis_stream << opSelectorToRegSym(instData.SDST) << ", ";
288 
289  if (instData.SSRC0 == REG_SRC_LITERAL) {
290  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
291  << extData.imm_u32;
292  } else {
293  dis_stream << opSelectorToRegSym(instData.SSRC0);
294  }
295 
296  disassembly = dis_stream.str();
297  }
298 
299  // --- Inst_SOPC base class methods ---
300 
301  Inst_SOPC::Inst_SOPC(InFmt_SOPC *iFmt, const std::string &opcode)
303  {
304  setFlag(Scalar);
305 
306  // copy first instruction DWORD
307  instData = iFmt[0];
308  if (hasSecondDword(iFmt)) {
309  // copy second instruction DWORD into union
310  extData = ((MachInst)iFmt)[1];
311  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
312  varSize = 4 + 4;
313  } else {
314  varSize = 4;
315  } // if
316  } // Inst_SOPC
317 
319  {
320  } // ~Inst_SOPC
321 
322  void
324  {
325  int opNum = 0;
326 
327  // Needed because can't take addr of bitfield
328  int reg = instData.SSRC0;
329  srcOps.emplace_back(reg, getOperandSize(opNum), true,
330  isScalarReg(instData.SSRC0), false, false);
331  opNum++;
332 
333  reg = instData.SSRC1;
334  srcOps.emplace_back(reg, getOperandSize(opNum), true,
335  isScalarReg(instData.SSRC1), false, false);
336 
337  }
338 
339  int
341  {
342  return varSize;
343  } // instSize
344 
345  bool
347  {
348  if (iFmt->SSRC0 == REG_SRC_LITERAL)
349  return true;
350 
351  if (iFmt->SSRC1 == REG_SRC_LITERAL)
352  return true;
353 
354  return false;
355  }
356 
357  void
359  {
360  std::stringstream dis_stream;
361  dis_stream << _opcode << " ";
362 
363  if (instData.SSRC0 == REG_SRC_LITERAL) {
364  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
365  << extData.imm_u32;
366  } else {
367  dis_stream << opSelectorToRegSym(instData.SSRC0) << ", ";
368  }
369 
370  if (instData.SSRC1 == REG_SRC_LITERAL) {
371  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
372  << extData.imm_u32;
373  } else {
374  dis_stream << opSelectorToRegSym(instData.SSRC1);
375  }
376 
377  disassembly = dis_stream.str();
378  }
379 
380  // --- Inst_SOPP base class methods ---
381 
382  Inst_SOPP::Inst_SOPP(InFmt_SOPP *iFmt, const std::string &opcode)
384  {
385  setFlag(Scalar);
386 
387  // copy first instruction DWORD
388  instData = iFmt[0];
389  } // Inst_SOPP
390 
392  {
393  } // ~Inst_SOPP
394 
395  void
397  {
398  int opNum = 0;
399 
400 
401  if (numSrcRegOperands()) {
402  // Needed because can't take addr of bitfield
403  int reg = instData.SIMM16;
404  srcOps.emplace_back(reg, getOperandSize(opNum), true,
405  false, false, true);
406 
407  opNum++;
408 
409  if (readsVCC()) {
410  srcOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), true,
411  true, false, false);
412  opNum++;
413  }
414  }
415  assert(srcOps.size() == numSrcRegOperands());
416  assert(dstOps.size() == numDstRegOperands());
417  }
418 
419  int
421  {
422  return 4;
423  } // instSize
424 
425  void
427  {
428  std::stringstream dis_stream;
429  dis_stream << _opcode;
430 
431  switch (instData.OP) {
432  case 8:
433  {
434  dis_stream << " ";
435  int dest = 4 * instData.SIMM16 + 4;
436  dis_stream << "label_" << std::hex << dest;
437  }
438  break;
439  case 12:
440  {
441  dis_stream << " ";
442 
443  int vm_cnt = 0;
444  int exp_cnt = 0;
445  int lgkm_cnt = 0;
446 
447  vm_cnt = bits<uint16_t>(instData.SIMM16, 3, 0);
448  exp_cnt = bits<uint16_t>(instData.SIMM16, 6, 4);
449  lgkm_cnt = bits<uint16_t>(instData.SIMM16, 11, 8);
450 
451  // if the counts are not maxed out, then we
452  // print out the count value
453  if (vm_cnt != 0xf) {
454  dis_stream << "vmcnt(" << vm_cnt << ")";
455  }
456 
457  if (lgkm_cnt != 0xf) {
458  if (vm_cnt != 0xf)
459  dis_stream << " & ";
460 
461  dis_stream << "lgkmcnt(" << lgkm_cnt << ")";
462  }
463 
464  if (exp_cnt != 0x7) {
465  if (vm_cnt != 0xf || lgkm_cnt != 0xf)
466  dis_stream << " & ";
467 
468  dis_stream << "expcnt(" << exp_cnt << ")";
469  }
470  }
471  break;
472  default:
473  break;
474  }
475 
476  disassembly = dis_stream.str();
477  }
478 
479  // --- Inst_SMEM base class methods ---
480 
481  Inst_SMEM::Inst_SMEM(InFmt_SMEM *iFmt, const std::string &opcode)
483  {
484  setFlag(Scalar);
485  setFlag(SMEM);
486 
487  // copy first instruction DWORD
488  instData = iFmt[0];
489  // copy second instruction DWORD
490  extData = ((InFmt_SMEM_1 *)iFmt)[1];
491  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
492 
493  if (instData.GLC)
494  setFlag(GroupCoherent);
495  } // Inst_SMEM
496 
498  {
499  } // ~Inst_SMEM
500 
501  void
503  {
504  // Formats:
505  // 0 src + 0 dst
506  // 3 src + 0 dst
507  // 2 src + 1 dst
508  // 0 src + 1 dst
509  int opNum = 0;
510  // Needed because can't take addr of bitfield
511  int reg = 0;
512 
513  if (numSrcRegOperands()) {
514  reg = instData.SDATA;
515  if (numSrcRegOperands() == getNumOperands()) {
516  srcOps.emplace_back(reg, getOperandSize(opNum), true,
517  isScalarReg(reg), false, false);
518  opNum++;
519  }
520 
521  reg = instData.SBASE;
522  srcOps.emplace_back(reg, getOperandSize(opNum), true,
523  true, false, false);
524  opNum++;
525 
526  reg = extData.OFFSET;
527  if (instData.IMM) {
528  srcOps.emplace_back(reg, getOperandSize(opNum), true,
529  false, false, true);
530  } else {
531  srcOps.emplace_back(reg, getOperandSize(opNum), true,
532  isScalarReg(reg), false, false);
533  }
534  opNum++;
535  }
536 
537  if (numDstRegOperands()) {
538  reg = instData.SDATA;
539  dstOps.emplace_back(reg, getOperandSize(opNum), false,
540  isScalarReg(reg), false, false);
541  }
542 
543  assert(srcOps.size() == numSrcRegOperands());
544  assert(dstOps.size() == numDstRegOperands());
545  }
546 
547  int
549  {
550  return 8;
551  } // instSize
552 
553  void
555  {
556  std::stringstream dis_stream;
557  dis_stream << _opcode << " ";
558  if (numDstRegOperands()) {
559  if (getOperandSize(getNumOperands() - 1) > 4) {
560  dis_stream << "s[" << instData.SDATA << ":"
562  4 - 1 << "], ";
563  } else {
564  dis_stream << "s" << instData.SDATA << ", ";
565  }
566  }
567 
568  // SBASE has an implied LSB of 0, so we need
569  // to shift by one to get the actual value
570  dis_stream << "s[" << (instData.SBASE << 1) << ":"
571  << ((instData.SBASE << 1) + 1) << "], ";
572 
573  if (instData.IMM) {
574  // IMM == 1 implies OFFSET should be
575  // used as the offset
576  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(2)
577  << extData.OFFSET;
578  } else {
579  // IMM == 0 implies OFFSET should be
580  // used to specify SGRP in which the
581  // offset is held
582  dis_stream << "s" << extData.OFFSET;
583  }
584 
585  disassembly = dis_stream.str();
586  }
587 
588  // --- Inst_VOP2 base class methods ---
589 
590  Inst_VOP2::Inst_VOP2(InFmt_VOP2 *iFmt, const std::string &opcode)
592  {
593  // copy first instruction DWORD
594  instData = iFmt[0];
595  if (hasSecondDword(iFmt)) {
596  // copy second instruction DWORD into union
597  extData = ((MachInst)iFmt)[1];
598  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
599  varSize = 4 + 4;
600  if (iFmt->SRC0 == REG_SRC_DPP) {
601  setFlag(IsDPP);
602  } else if (iFmt->SRC0 == REG_SRC_SWDA) {
603  setFlag(IsSDWA);
604  }
605  } else {
606  varSize = 4;
607  } // if
608  } // Inst_VOP2
609 
611  {
612  } // ~Inst_VOP2
613 
614  void
616  {
617  int opNum = 0;
618 
619  // Needed because can't take addr of bitfield
620  int reg = instData.SRC0;
621  srcOps.emplace_back(reg, getOperandSize(opNum), true,
622  isScalarReg(reg), isVectorReg(reg), false);
623  opNum++;
624 
625  reg = instData.VSRC1;
626  srcOps.emplace_back(reg, getOperandSize(opNum), true,
627  false, true, false);
628  opNum++;
629 
630  // VCC read
631  if (readsVCC()) {
632  srcOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), true,
633  true, false, false);
634  opNum++;
635  }
636 
637  // VDST
638  reg = instData.VDST;
639  dstOps.emplace_back(reg, getOperandSize(opNum), false,
640  false, true, false);
641  opNum++;
642 
643  // VCC write
644  if (writesVCC()) {
645  dstOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), false,
646  true, false, false);
647  }
648 
649  assert(srcOps.size() == numSrcRegOperands());
650  assert(dstOps.size() == numDstRegOperands());
651  }
652 
653  int
655  {
656  return varSize;
657  } // instSize
658 
659  bool
661  {
662  /*
663  There are a few cases where VOP2 instructions have a second dword:
664 
665  1. SRC0 is a literal
666  2. SRC0 is being used to add a data parallel primitive (DPP)
667  operation to the instruction.
668  3. SRC0 is being used for sub d-word addressing (SDWA) of the
669  operands in the instruction.
670  4. VOP2 instructions also have four special opcodes:',
671  V_MADMK_{F16, F32} (0x24, 0x17), and V_MADAK_{F16, F32}',
672  (0x25, 0x18), that are always 64b. the only way to',
673  detect these special cases is to explicitly check,',
674  the opcodes',
675  */
676  if (iFmt->SRC0 == REG_SRC_LITERAL || (iFmt->SRC0 == REG_SRC_DPP) ||
677  (iFmt->SRC0 == REG_SRC_SWDA) || iFmt->OP == 0x17 ||
678  iFmt->OP == 0x18 || iFmt->OP == 0x24 || iFmt->OP == 0x25)
679  return true;
680 
681  return false;
682  }
683 
684  void
686  {
687  std::stringstream dis_stream;
688  dis_stream << _opcode << " ";
689  dis_stream << "v" << instData.VDST << ", ";
690 
691  if (writesVCC())
692  dis_stream << "vcc, ";
693 
694  if ((instData.SRC0 == REG_SRC_LITERAL) ||
695  (instData.SRC0 == REG_SRC_DPP) ||
696  (instData.SRC0 == REG_SRC_SWDA)) {
697  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
698  << _srcLiteral << ", ";
699  } else {
700  dis_stream << opSelectorToRegSym(instData.SRC0) << ", ";
701  }
702 
703  // VOP2 instructions have four special opcodes:',
704  // V_MADMK_{F16, F32} (0x24, 0x17), and V_MADAK_{F16, F32}',
705  // (0x25, 0x18), that are always 64b. the only way to',
706  // detect these special cases is to explicitly check,',
707  // the opcodes',
708  if (instData.OP == 0x17 || instData.OP == 0x18 || instData.OP == 0x24
709  || instData.OP == 0x25) {
710  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
711  << extData.imm_u32 << ", ";
712  }
713 
714  dis_stream << std::resetiosflags(std::ios_base::basefield) << "v"
715  << instData.VSRC1;
716 
717  if (readsVCC())
718  dis_stream << ", vcc";
719 
720  disassembly = dis_stream.str();
721  }
722 
723  // --- Inst_VOP1 base class methods ---
724 
725  Inst_VOP1::Inst_VOP1(InFmt_VOP1 *iFmt, const std::string &opcode)
727  {
728  // copy first instruction DWORD
729  instData = iFmt[0];
730  if (hasSecondDword(iFmt)) {
731  // copy second instruction DWORD into union
732  extData = ((MachInst)iFmt)[1];
733  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
734  varSize = 4 + 4;
735  if (iFmt->SRC0 == REG_SRC_DPP) {
736  setFlag(IsDPP);
737  } else if (iFmt->SRC0 == REG_SRC_SWDA) {
738  setFlag(IsSDWA);
739  }
740  } else {
741  varSize = 4;
742  } // if
743  } // Inst_VOP1
744 
746  {
747  } // ~Inst_VOP1
748 
749  void
751  {
752  int opNum = 0;
753  // Needed because can't take addr of bitfield
754  int reg = instData.SRC0;
755 
756  if (numSrcRegOperands()) {
757  srcOps.emplace_back(reg, getOperandSize(opNum), true,
758  isScalarReg(reg), isVectorReg(reg), false);
759  opNum++;
760  }
761 
762  if (numDstRegOperands()) {
763  reg = instData.VDST;
764  dstOps.emplace_back(reg, getOperandSize(opNum), false,
765  false, true, false);
766  }
767 
768  assert(srcOps.size() == numSrcRegOperands());
769  assert(dstOps.size() == numDstRegOperands());
770  }
771 
772  int
774  {
775  return varSize;
776  } // instSize
777 
778  bool
780  {
781  /*
782  There are several cases where VOP1 instructions have a second dword:
783 
784  1. SRC0 is a literal.
785  2. SRC0 is being used to add a data parallel primitive (DPP)
786  operation to the instruction.
787  3. SRC0 is being used for sub d-word addressing (SDWA) of the
788  operands in the instruction.
789  */
790  if ((iFmt->SRC0 == REG_SRC_LITERAL) || (iFmt->SRC0 == REG_SRC_DPP) ||
791  (iFmt->SRC0 == REG_SRC_SWDA))
792  return true;
793 
794  return false;
795  }
796 
797  void
799  {
800  std::stringstream dis_stream;
801  dis_stream << _opcode << " ";
802  dis_stream << "v" << instData.VDST << ", ";
803 
804  if ((instData.SRC0 == REG_SRC_LITERAL) ||
805  (instData.SRC0 == REG_SRC_DPP) ||
806  (instData.SRC0 == REG_SRC_SWDA)) {
807  dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
808  << _srcLiteral;
809  } else {
810  dis_stream << opSelectorToRegSym(instData.SRC0);
811  }
812 
813  disassembly = dis_stream.str();
814  }
815 
816  // --- Inst_VOPC base class methods ---
817 
818  Inst_VOPC::Inst_VOPC(InFmt_VOPC *iFmt, const std::string &opcode)
820  {
821  setFlag(WritesVCC);
822  // copy first instruction DWORD
823  instData = iFmt[0];
824  if (hasSecondDword(iFmt)) {
825  // copy second instruction DWORD into union
826  extData = ((MachInst)iFmt)[1];
827  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
828  varSize = 4 + 4;
829  if (iFmt->SRC0 == REG_SRC_DPP) {
830  setFlag(IsDPP);
831  } else if (iFmt->SRC0 == REG_SRC_SWDA) {
832  setFlag(IsSDWA);
833  }
834  } else {
835  varSize = 4;
836  } // if
837  } // Inst_VOPC
838 
840  {
841  } // ~Inst_VOPC
842 
843  void
845  {
846  int opNum = 0;
847 
848  // Needed because can't take addr of bitfield
849  int reg = instData.SRC0;
850  srcOps.emplace_back(reg, getOperandSize(opNum), true,
851  isScalarReg(reg), isVectorReg(reg), false);
852  opNum++;
853 
854  reg = instData.VSRC1;
855  srcOps.emplace_back(reg, getOperandSize(opNum), true,
856  false, true, false);
857  opNum++;
858 
859  assert(writesVCC());
860  dstOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), false,
861  true, false, false);
862 
863  assert(srcOps.size() == numSrcRegOperands());
864  assert(dstOps.size() == numDstRegOperands());
865  }
866 
867  int
869  {
870  return varSize;
871  } // instSize
872 
873  bool
875  {
876  /*
877  There are several cases where VOPC instructions have a second dword:
878 
879  1. SRC0 is a literal.
880  2. SRC0 is being used to add a data parallel primitive (DPP)
881  operation to the instruction.
882  3. SRC0 is being used for sub d-word addressing (SDWA) of the
883  operands in the instruction.
884  */
885  if ((iFmt->SRC0 == REG_SRC_LITERAL) || (iFmt->SRC0 == REG_SRC_DPP) ||
886  (iFmt->SRC0 == REG_SRC_SWDA))
887  return true;
888 
889  return false;
890  }
891 
892  void
894  {
895  std::stringstream dis_stream;
896  dis_stream << _opcode << " vcc, ";
897 
898  dis_stream << opSelectorToRegSym(instData.SRC0) << ", ";
899  dis_stream << "v" << instData.VSRC1;
900 
901  disassembly = dis_stream.str();
902  }
903 
904  // --- Inst_VINTRP base class methods ---
905 
906  Inst_VINTRP::Inst_VINTRP(InFmt_VINTRP *iFmt, const std::string &opcode)
908  {
909  // copy first instruction DWORD
910  instData = iFmt[0];
911  } // Inst_VINTRP
912 
914  {
915  } // ~Inst_VINTRP
916 
917  int
919  {
920  return 4;
921  } // instSize
922 
923  // --- Inst_VOP3A base class methods ---
924 
925  Inst_VOP3A::Inst_VOP3A(InFmt_VOP3A *iFmt, const std::string &opcode,
926  bool sgpr_dst)
927  : VEGAGPUStaticInst(opcode), sgprDst(sgpr_dst)
928  {
929  // copy first instruction DWORD
930  instData = iFmt[0];
931  // copy second instruction DWORD
932  extData = ((InFmt_VOP3_1 *)iFmt)[1];
933  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
934  } // Inst_VOP3A
935 
937  {
938  } // ~Inst_VOP3A
939 
940  void
942  {
943  // Also takes care of bitfield addr issue
944  unsigned int srcs[3] = {extData.SRC0, extData.SRC1, extData.SRC2};
945 
946  int opNum = 0;
947 
948  int numSrc = numSrcRegOperands() - readsVCC();
949  int numDst = numDstRegOperands() - writesVCC();
950 
951  for (opNum = 0; opNum < numSrc; opNum++) {
952  srcOps.emplace_back(srcs[opNum], getOperandSize(opNum), true,
953  isScalarReg(srcs[opNum]),
954  isVectorReg(srcs[opNum]), false);
955  }
956 
957  if (readsVCC()) {
958  srcOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), true,
959  true, false, false);
960  opNum++;
961  }
962 
963  if (numDst) {
964  // Needed because can't take addr of bitfield
965  int reg = instData.VDST;
966  dstOps.emplace_back(reg, getOperandSize(opNum), false,
967  sgprDst, !sgprDst, false);
968  opNum++;
969  }
970 
971  if (writesVCC()) {
972  dstOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), false,
973  true, false, false);
974  }
975 
976  assert(srcOps.size() == numSrcRegOperands());
977  assert(dstOps.size() == numDstRegOperands());
978  }
979 
980  int
982  {
983  return 8;
984  } // instSize
985 
986  void
988  {
989  std::stringstream dis_stream;
990  dis_stream << _opcode << " ";
991  int num_regs = 0;
992 
993  if (getOperandSize(getNumOperands() - 1) > 4) {
994  num_regs = getOperandSize(getNumOperands() - 1) / 4;
995  if (sgprDst)
996  dis_stream << "s[";
997  else
998  dis_stream << "v[";
999  dis_stream << instData.VDST << ":" << instData.VDST +
1000  num_regs - 1 << "], ";
1001  } else {
1002  if (sgprDst)
1003  dis_stream << "s";
1004  else
1005  dis_stream << "v";
1006  dis_stream << instData.VDST << ", ";
1007  }
1008 
1009  num_regs = getOperandSize(0) / 4;
1010 
1011  if (extData.NEG & 0x1) {
1012  dis_stream << "-" << opSelectorToRegSym(extData.SRC0, num_regs);
1013  } else {
1014  dis_stream << opSelectorToRegSym(extData.SRC0, num_regs);
1015  }
1016 
1017  if (numSrcRegOperands() > 1) {
1018  num_regs = getOperandSize(1) / 4;
1019 
1020  if (extData.NEG & 0x2) {
1021  dis_stream << ", -"
1022  << opSelectorToRegSym(extData.SRC1, num_regs);
1023  } else {
1024  dis_stream << ", "
1025  << opSelectorToRegSym(extData.SRC1, num_regs);
1026  }
1027  }
1028 
1029  if (numSrcRegOperands() > 2) {
1030  num_regs = getOperandSize(2) / 4;
1031 
1032  if (extData.NEG & 0x4) {
1033  dis_stream << ", -"
1034  << opSelectorToRegSym(extData.SRC2, num_regs);
1035  } else {
1036  dis_stream << ", "
1037  << opSelectorToRegSym(extData.SRC2, num_regs);
1038  }
1039  }
1040 
1041  disassembly = dis_stream.str();
1042  }
1043 
1044  // --- Inst_VOP3B base class methods ---
1045 
1046  Inst_VOP3B::Inst_VOP3B(InFmt_VOP3B *iFmt, const std::string &opcode)
1048  {
1049  // copy first instruction DWORD
1050  instData = iFmt[0];
1051  // copy second instruction DWORD
1052  extData = ((InFmt_VOP3_1 *)iFmt)[1];
1053  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1054  } // Inst_VOP3B
1055 
1057  {
1058  } // ~Inst_VOP3B
1059 
1060  void
1062  {
1063  // Also takes care of bitfield addr issue
1064  unsigned int srcs[3] = {extData.SRC0, extData.SRC1, extData.SRC2};
1065 
1066  int opNum = 0;
1067 
1068  int numSrc = numSrcRegOperands() - readsVCC();
1069  int numDst = numDstRegOperands() - writesVCC();
1070 
1071  for (opNum = 0; opNum < numSrc; opNum++) {
1072  srcOps.emplace_back(srcs[opNum], getOperandSize(opNum), true,
1073  isScalarReg(srcs[opNum]),
1074  isVectorReg(srcs[opNum]), false);
1075  }
1076 
1077  if (readsVCC()) {
1078  srcOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), true,
1079  true, false, false);
1080  opNum++;
1081  }
1082 
1083  if (numDst) {
1084  // Needed because can't take addr of bitfield
1085  int reg = instData.VDST;
1086  dstOps.emplace_back(reg, getOperandSize(opNum), false,
1087  false, true, false);
1088  opNum++;
1089  }
1090 
1091  if (writesVCC()) {
1092  dstOps.emplace_back(REG_VCC_LO, getOperandSize(opNum), false,
1093  true, false, false);
1094  }
1095 
1096  assert(srcOps.size() == numSrcRegOperands());
1097  assert(dstOps.size() == numDstRegOperands());
1098  }
1099 
1100  int
1102  {
1103  return 8;
1104  } // instSize
1105 
1106  void
1108  {
1109  std::stringstream dis_stream;
1110  dis_stream << _opcode << " ";
1111 
1112  dis_stream << "v" << instData.VDST << ", ";
1113 
1114  if (numDstRegOperands() == 2) {
1115  if (getOperandSize(getNumOperands() - 1) > 4) {
1116  int num_regs = getOperandSize(getNumOperands() - 1) / 4;
1117  dis_stream << opSelectorToRegSym(instData.SDST, num_regs)
1118  << ", ";
1119  } else {
1120  dis_stream << opSelectorToRegSym(instData.SDST) << ", ";
1121  }
1122  }
1123 
1124  if (extData.NEG & 0x1) {
1125  dis_stream << "-" << opSelectorToRegSym(extData.SRC0) << ", ";
1126  } else {
1127  dis_stream << opSelectorToRegSym(extData.SRC0) << ", ";
1128  }
1129 
1130  if (extData.NEG & 0x2) {
1131  dis_stream << "-" << opSelectorToRegSym(extData.SRC1);
1132  } else {
1133  dis_stream << opSelectorToRegSym(extData.SRC1);
1134  }
1135 
1136  if (numSrcRegOperands() == 3) {
1137  if (extData.NEG & 0x4) {
1138  dis_stream << ", -" << opSelectorToRegSym(extData.SRC2);
1139  } else {
1140  dis_stream << ", " << opSelectorToRegSym(extData.SRC2);
1141  }
1142  }
1143 
1144  if (readsVCC())
1145  dis_stream << ", vcc";
1146 
1147  disassembly = dis_stream.str();
1148  }
1149 
1150  // --- Inst_DS base class methods ---
1151 
1152  Inst_DS::Inst_DS(InFmt_DS *iFmt, const std::string &opcode)
1154  {
1155  setFlag(LDS);
1156 
1157  // copy first instruction DWORD
1158  instData = iFmt[0];
1159  // copy second instruction DWORD
1160  extData = ((InFmt_DS_1 *)iFmt)[1];
1161  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1162  } // Inst_DS
1163 
1165  {
1166  } // ~Inst_DS
1167 
1168  void
1170  {
1171  unsigned int srcs[3] = {extData.ADDR, extData.DATA0, extData.DATA1};
1172 
1173  int opIdx = 0;
1174 
1175  for (opIdx = 0; opIdx < numSrcRegOperands(); opIdx++){
1176  srcOps.emplace_back(srcs[opIdx], getOperandSize(opIdx), true,
1177  false, true, false);
1178  }
1179 
1180  if (numDstRegOperands()) {
1181  // Needed because can't take addr of bitfield
1182  int reg = extData.VDST;
1183  dstOps.emplace_back(reg, getOperandSize(opIdx), false,
1184  false, true, false);
1185  }
1186 
1187  assert(srcOps.size() == numSrcRegOperands());
1188  assert(dstOps.size() == numDstRegOperands());
1189  }
1190 
1191  int
1193  {
1194  return 8;
1195  } // instSize
1196 
1197  void
1199  {
1200  std::stringstream dis_stream;
1201  dis_stream << _opcode << " ";
1202 
1203  if (numDstRegOperands())
1204  dis_stream << "v" << extData.VDST << ", ";
1205 
1206  dis_stream << "v" << extData.ADDR;
1207 
1208  if (numSrcRegOperands() > 1)
1209  dis_stream << ", v" << extData.DATA0;
1210 
1211  if (numSrcRegOperands() > 2)
1212  dis_stream << ", v" << extData.DATA1;
1213 
1214  uint16_t offset = 0;
1215 
1216  if (instData.OFFSET1) {
1217  offset += instData.OFFSET1;
1218  offset <<= 8;
1219  }
1220 
1221  if (instData.OFFSET0)
1222  offset += instData.OFFSET0;
1223 
1224  if (offset)
1225  dis_stream << " offset:" << offset;
1226 
1227  disassembly = dis_stream.str();
1228  }
1229 
1230  // --- Inst_MUBUF base class methods ---
1231 
1232  Inst_MUBUF::Inst_MUBUF(InFmt_MUBUF *iFmt, const std::string &opcode)
1234  {
1235  // copy first instruction DWORD
1236  instData = iFmt[0];
1237  // copy second instruction DWORD
1238  extData = ((InFmt_MUBUF_1 *)iFmt)[1];
1239  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1240  setFlag(TextureMem);
1241 
1242  if (instData.GLC)
1243  setFlag(GroupCoherent);
1244 
1245  if (instData.SLC)
1246  setFlag(SystemCoherent);
1247  } // Inst_MUBUF
1248 
1250  {
1251  } // ~Inst_MUBUF
1252 
1253  void
1255  {
1256  // Currently there are three formats:
1257  // 0 src + 0 dst
1258  // 3 src + 1 dst
1259  // 4 src + 0 dst
1260  int opNum = 0;
1261 
1262  // Needed because can't take addr of bitfield;
1263  int reg = 0;
1264 
1265  if (numSrcRegOperands()) {
1266  if (numSrcRegOperands() == getNumOperands()) {
1267  reg = extData.VDATA;
1268  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1269  false, true, false);
1270  opNum++;
1271  }
1272 
1273  reg = extData.VADDR;
1274  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1275  false, true, false);
1276  opNum++;
1277 
1278  reg = extData.SRSRC;
1279  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1280  true, false, false);
1281  opNum++;
1282 
1283  reg = extData.SOFFSET;
1284  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1285  true, false, false);
1286  opNum++;
1287  }
1288 
1289  // extData.VDATA moves in the reg list depending on the instruction
1290  if (numDstRegOperands()) {
1291  reg = extData.VDATA;
1292  dstOps.emplace_back(reg, getOperandSize(opNum), false,
1293  false, true, false);
1294  }
1295 
1296  assert(srcOps.size() == numSrcRegOperands());
1297  assert(dstOps.size() == numDstRegOperands());
1298  }
1299 
1300  int
1302  {
1303  return 8;
1304  } // instSize
1305 
1306  void
1308  {
1309  // SRSRC is always in units of 4 SGPRs
1310  int srsrc_val = extData.SRSRC * 4;
1311  std::stringstream dis_stream;
1312  dis_stream << _opcode << " ";
1313  dis_stream << "v" << extData.VDATA << ", v" << extData.VADDR << ", ";
1314  dis_stream << "s[" << srsrc_val << ":"
1315  << srsrc_val + 3 << "], ";
1316  dis_stream << "s" << extData.SOFFSET;
1317 
1318  if (instData.OFFSET)
1319  dis_stream << ", offset:" << instData.OFFSET;
1320 
1321  disassembly = dis_stream.str();
1322  }
1323 
1324  // --- Inst_MTBUF base class methods ---
1325 
1326  Inst_MTBUF::Inst_MTBUF(InFmt_MTBUF *iFmt, const std::string &opcode)
1328  {
1329  // copy first instruction DWORD
1330  instData = iFmt[0];
1331  // copy second instruction DWORD
1332  extData = ((InFmt_MTBUF_1 *)iFmt)[1];
1333  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1334  setFlag(TextureMem);
1335 
1336  if (instData.GLC)
1337  setFlag(GroupCoherent);
1338 
1339  if (extData.SLC)
1340  setFlag(SystemCoherent);
1341  } // Inst_MTBUF
1342 
1344  {
1345  } // ~Inst_MTBUF
1346 
1347  void
1349  {
1350  // Currently there are two formats:
1351  // 3 src + 1 dst
1352  // 4 src + 0 dst
1353  int opNum = 0;
1354 
1355  // Needed because can't take addr of bitfield
1356  int reg = 0;
1357 
1358  if (numSrcRegOperands() == getNumOperands()) {
1359  reg = extData.VDATA;
1360  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1361  false, true, false);
1362  opNum++;
1363  }
1364 
1365  reg = extData.VADDR;
1366  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1367  false, true, false);
1368  opNum++;
1369 
1370  reg = extData.SRSRC;
1371  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1372  true, false, false);
1373  opNum++;
1374 
1375  reg = extData.SOFFSET;
1376  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1377  true, false, false);
1378  opNum++;
1379 
1380  // extData.VDATA moves in the reg list depending on the instruction
1381  if (numDstRegOperands()) {
1382  reg = extData.VDATA;
1383  dstOps.emplace_back(reg, getOperandSize(opNum), false,
1384  false, true, false);
1385  }
1386 
1387  assert(srcOps.size() == numSrcRegOperands());
1388  assert(dstOps.size() == numDstRegOperands());
1389  }
1390 
1391  int
1393  {
1394  return 8;
1395  } // instSize
1396 
1397  // --- Inst_MIMG base class methods ---
1398 
1399  Inst_MIMG::Inst_MIMG(InFmt_MIMG *iFmt, const std::string &opcode)
1401  {
1402  // copy first instruction DWORD
1403  instData = iFmt[0];
1404  // copy second instruction DWORD
1405  extData = ((InFmt_MIMG_1 *)iFmt)[1];
1406  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1407  setFlag(TextureMem);
1408 
1409  if (instData.GLC)
1410  setFlag(GroupCoherent);
1411 
1412  if (instData.SLC)
1413  setFlag(SystemCoherent);
1414  } // Inst_MIMG
1415 
1417  {
1418  } // ~Inst_MIMG
1419 
1420  void
1422  {
1423  // Three formats:
1424  // 1 dst + 2 src : s,s,d
1425  // 0 dst + 3 src : s,s,s
1426  // 1 dst + 3 src : s,s,s,d
1427  int opNum = 0;
1428 
1429  // Needed because can't take addr of bitfield
1430  int reg = 0;
1431 
1432  if (numSrcRegOperands() == getNumOperands()) {
1433  reg = extData.VDATA;
1434  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1435  false, true, false);
1436  opNum++;
1437  }
1438 
1439  reg = extData.VADDR;
1440  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1441  false, true, false);
1442  opNum++;
1443 
1444  reg = extData.SRSRC;
1445  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1446  true, false, false);
1447  opNum++;
1448 
1449  if (getNumOperands() == 4) {
1450  reg = extData.SSAMP;
1451  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1452  true, false, false);
1453  opNum++;
1454  }
1455 
1456  // extData.VDATA moves in the reg list depending on the instruction
1457  if (numDstRegOperands()) {
1458  reg = extData.VDATA;
1459  dstOps.emplace_back(reg, getOperandSize(opNum), false,
1460  false, true, false);
1461  }
1462 
1463  assert(srcOps.size() == numSrcRegOperands());
1464  assert(dstOps.size() == numDstRegOperands());
1465  }
1466 
1467  int
1469  {
1470  return 8;
1471  } // instSize
1472 
1473  // --- Inst_EXP base class methods ---
1474 
1475  Inst_EXP::Inst_EXP(InFmt_EXP *iFmt, const std::string &opcode)
1477  {
1478  // copy first instruction DWORD
1479  instData = iFmt[0];
1480  // copy second instruction DWORD
1481  extData = ((InFmt_EXP_1 *)iFmt)[1];
1482  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1483  } // Inst_EXP
1484 
1486  {
1487  } // ~Inst_EXP
1488 
1489  void
1491  {
1492  // Only 1 instruction, 1 format: 1 dst + 4 src
1493  int opNum = 0;
1494 
1495  // Avoids taking addr of bitfield
1496  unsigned int srcs[4] = {extData.VSRC0, extData.VSRC1,
1498 
1499  for (opNum = 0; opNum < 4; opNum++) {
1500  srcOps.emplace_back(srcs[opNum], getOperandSize(opNum), true,
1501  false, true, false);
1502  }
1503 
1504  //TODO: Add the dst operand, don't know what it is right now
1505  }
1506 
1507  int
1509  {
1510  return 8;
1511  } // instSize
1512 
1513  // --- Inst_FLAT base class methods ---
1514 
1515  Inst_FLAT::Inst_FLAT(InFmt_FLAT *iFmt, const std::string &opcode)
1517  {
1518  setFlag(Flat);
1519  // copy first instruction DWORD
1520  instData = iFmt[0];
1521  // copy second instruction DWORD
1522  extData = ((InFmt_FLAT_1 *)iFmt)[1];
1523  _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
1524 
1525  if (instData.GLC)
1526  setFlag(GroupCoherent);
1527 
1528  if (instData.SLC)
1529  setFlag(SystemCoherent);
1530  } // Inst_FLAT
1531 
1533  {
1534  } // ~Inst_FLAT
1535 
1536  void
1538  {
1539  //3 formats:
1540  // 1 dst + 1 src (load)
1541  // 0 dst + 2 src (store)
1542  // 1 dst + 2 src (atomic)
1543  int opNum = 0;
1544 
1545  // Needed because can't take addr of bitfield
1546  int reg = 0;
1547 
1548  if (getNumOperands() > 2)
1549  assert(isAtomic());
1550 
1551  reg = extData.ADDR;
1552  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1553  false, true, false);
1554  opNum++;
1555 
1556  if (numSrcRegOperands() == 2) {
1557  reg = extData.DATA;
1558  srcOps.emplace_back(reg, getOperandSize(opNum), true,
1559  false, true, false);
1560  opNum++;
1561  }
1562 
1563  if (numDstRegOperands()) {
1564  reg = extData.VDST;
1565  dstOps.emplace_back(reg, getOperandSize(opNum), false,
1566  false, true, false);
1567  }
1568 
1569  assert(srcOps.size() == numSrcRegOperands());
1570  assert(dstOps.size() == numDstRegOperands());
1571  }
1572 
1573  int
1575  {
1576  return 8;
1577  } // instSize
1578 
1579  void
1581  {
1582  std::stringstream dis_stream;
1583  dis_stream << _opcode << " ";
1584 
1585  if (isLoad())
1586  dis_stream << "v" << extData.VDST << ", ";
1587 
1588  dis_stream << "v[" << extData.ADDR << ":" << extData.ADDR + 1 << "]";
1589 
1590  if (isStore())
1591  dis_stream << ", v" << extData.DATA;
1592 
1593  disassembly = dis_stream.str();
1594  }
1595 } // namespace VegaISA
1596 } // namespace gem5
gem5::VegaISA::Inst_SOPK::extData
InstFormat extData
Definition: op_encodings.hh:111
gem5::statistics::Scalar
This is a simple scalar statistic, like a counter.
Definition: statistics.hh:1927
gem5::VegaISA::Inst_SOP2::instSize
int instSize() const override
Definition: op_encodings.cc:87
gem5::VegaISA::Inst_MUBUF::instSize
int instSize() const override
Definition: op_encodings.cc:1301
gem5::VegaISA::Inst_VOPC::extData
InstFormat extData
Definition: op_encodings.hh:318
gem5::VegaISA::Inst_DS::~Inst_DS
~Inst_DS()
Definition: op_encodings.cc:1164
gem5::VegaISA::InFmt_SMEM
Definition: gpu_decoder.hh:1725
gem5::VegaISA::Inst_VOP3A::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:941
gem5::VegaISA::InFmt_VOP2::VDST
unsigned int VDST
Definition: gpu_decoder.hh:1797
gem5::VegaISA::InFmt_EXP_1::VSRC1
unsigned int VSRC1
Definition: gpu_decoder.hh:1630
gem5::VegaISA::InFmt_MIMG_1::VDATA
unsigned int VDATA
Definition: gpu_decoder.hh:1675
gem5::VegaISA::InFmt_MTBUF_1::SOFFSET
unsigned int SOFFSET
Definition: gpu_decoder.hh:1700
gem5::VegaISA::Inst_MIMG::instData
InFmt_MIMG instData
Definition: op_encodings.hh:727
gem5::VegaISA::Inst_SOP1::Inst_SOP1
Inst_SOP1(InFmt_SOP1 *, const std::string &opcode)
Definition: op_encodings.cc:225
gem5::VegaISA::InFmt_FLAT_1::ADDR
unsigned int ADDR
Definition: gpu_decoder.hh:1647
gem5::VegaISA::Inst_SOP2::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:63
gem5::VegaISA::Inst_SOPK::Inst_SOPK
Inst_SOPK(InFmt_SOPK *, const std::string &opcode)
Definition: op_encodings.cc:130
gem5::VegaISA::Inst_MUBUF::instData
InFmt_MUBUF instData
Definition: op_encodings.hh:688
gem5::VegaISA::Inst_SMEM::Inst_SMEM
Inst_SMEM(InFmt_SMEM *, const std::string &opcode)
Definition: op_encodings.cc:481
gem5::VegaISA::Inst_VOP3A::instData
InFmt_VOP3A instData
Definition: op_encodings.hh:351
gem5::VegaISA::Inst_SOPK::instData
InFmt_SOPK instData
Definition: op_encodings.hh:109
gem5::VegaISA::Inst_SOP1::extData
InstFormat extData
Definition: op_encodings.hh:133
gem5::VegaISA::opSelectorToRegSym
std::string opSelectorToRegSym(int opIdx, int numRegs=0)
Definition: registers.cc:42
gem5::VegaISA::InFmt_MUBUF_1::SRSRC
unsigned int SRSRC
Definition: gpu_decoder.hh:1719
gem5::VegaISA::InFmt_SOP1::OP
unsigned int OP
Definition: gpu_decoder.hh:1745
gem5::GPUStaticInst::numSrcRegOperands
virtual int numSrcRegOperands()=0
gem5::VegaISA::InFmt_SOPP::SIMM16
unsigned int SIMM16
Definition: gpu_decoder.hh:1773
gem5::VegaISA::InFmt_SOPP::OP
unsigned int OP
Definition: gpu_decoder.hh:1774
gem5::VegaISA::VEGAGPUStaticInst
Definition: gpu_static_inst.hh:49
gem5::VegaISA::InFmt_MUBUF::GLC
unsigned int GLC
Definition: gpu_decoder.hh:1707
gem5::VegaISA::Inst_VOP2::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:615
gem5::VegaISA::Inst_VOP3A::sgprDst
const bool sgprDst
the v_cmp and readlane instructions in the VOP3 encoding are unique because they are the only instruc...
Definition: op_encodings.hh:367
gem5::VegaISA::Inst_DS::extData
InFmt_DS_1 extData
Definition: op_encodings.hh:486
gem5::VegaISA::Inst_MIMG::Inst_MIMG
Inst_MIMG(InFmt_MIMG *, const std::string &opcode)
Definition: op_encodings.cc:1399
gem5::VegaISA::InstFormat::imm_u32
uint32_t imm_u32
Definition: gpu_decoder.hh:1936
gem5::VegaISA::InFmt_SOP1::SSRC0
unsigned int SSRC0
Definition: gpu_decoder.hh:1744
gem5::VegaISA::InFmt_MUBUF::OFFSET
unsigned int OFFSET
Definition: gpu_decoder.hh:1704
gem5::VegaISA::InFmt_SOPC::SSRC1
unsigned int SSRC1
Definition: gpu_decoder.hh:1760
gem5::VegaISA::Inst_VOP3B::~Inst_VOP3B
~Inst_VOP3B()
Definition: op_encodings.cc:1056
gem5::VegaISA::Inst_SOP2::instData
InFmt_SOP2 instData
Definition: op_encodings.hh:87
gem5::VegaISA::Inst_SOP2::varSize
uint32_t varSize
Definition: op_encodings.hh:90
gem5::VegaISA::Inst_VOP2::Inst_VOP2
Inst_VOP2(InFmt_VOP2 *, const std::string &opcode)
Definition: op_encodings.cc:590
gem5::VegaISA::Inst_VOPC::Inst_VOPC
Inst_VOPC(InFmt_VOPC *, const std::string &opcode)
Definition: op_encodings.cc:818
gem5::GPUStaticInst::disassembly
std::string disassembly
Definition: gpu_static_inst.hh:300
gem5::GPUStaticInst::srcOps
std::vector< OperandInfo > srcOps
Definition: gpu_static_inst.hh:303
gem5::VegaISA::InFmt_VOP2::VSRC1
unsigned int VSRC1
Definition: gpu_decoder.hh:1796
gem5::VegaISA::InFmt_EXP_1::VSRC2
unsigned int VSRC2
Definition: gpu_decoder.hh:1631
gem5::VegaISA::Inst_VOP3B::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:1107
gem5::VegaISA::VEGAGPUStaticInst::_srcLiteral
ScalarRegU32 _srcLiteral
if the instruction has a src literal - an immediate value that is part of the instruction stream - we...
Definition: gpu_static_inst.hh:84
gem5::VegaISA::Inst_VOP3B::instSize
int instSize() const override
Definition: op_encodings.cc:1101
gem5::VegaISA::InFmt_VOP3_1::NEG
unsigned int NEG
Definition: gpu_decoder.hh:1816
gem5::VegaISA::Inst_VOP2::extData
InstFormat extData
Definition: op_encodings.hh:274
gem5::VegaISA::InFmt_SMEM_1
Definition: gpu_decoder.hh:1737
gem5::VegaISA::InFmt_VOP3A
Definition: gpu_decoder.hh:1802
gem5::VegaISA::InFmt_VOP2::OP
unsigned int OP
Definition: gpu_decoder.hh:1798
gem5::VegaISA::Inst_VOP1::Inst_VOP1
Inst_VOP1(InFmt_VOP1 *, const std::string &opcode)
Definition: op_encodings.cc:725
gem5::VegaISA::Inst_SOPC::hasSecondDword
bool hasSecondDword(InFmt_SOPC *)
Definition: op_encodings.cc:346
gem5::VegaISA::Inst_MIMG::extData
InFmt_MIMG_1 extData
Definition: op_encodings.hh:729
gem5::VegaISA::Inst_VOP3A::Inst_VOP3A
Inst_VOP3A(InFmt_VOP3A *, const std::string &opcode, bool sgpr_dst)
Definition: op_encodings.cc:925
gem5::GPUStaticInst::writesVCC
bool writesVCC() const
Definition: gpu_static_inst.hh:150
gem5::VegaISA::Inst_SOPC::~Inst_SOPC
~Inst_SOPC()
Definition: op_encodings.cc:318
gem5::VegaISA::REG_VCC_LO
@ REG_VCC_LO
Definition: gpu_registers.hh:58
gem5::VegaISA::VEGAGPUStaticInst::getOperandSize
int getOperandSize(int opIdx) override
Definition: gpu_static_inst.hh:64
gem5::VegaISA::InFmt_MIMG
Definition: gpu_decoder.hh:1658
gem5::VegaISA::Inst_MUBUF::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:1307
gem5::VegaISA::Inst_VINTRP::~Inst_VINTRP
~Inst_VINTRP()
Definition: op_encodings.cc:913
gem5::VegaISA::Inst_EXP::instSize
int instSize() const override
Definition: op_encodings.cc:1508
gem5::VegaISA::Inst_VOP3A::instSize
int instSize() const override
Definition: op_encodings.cc:981
gem5::VegaISA::InFmt_SMEM::SBASE
unsigned int SBASE
Definition: gpu_decoder.hh:1726
gem5::VegaISA::InFmt_DS
Definition: gpu_decoder.hh:1602
gem5::VegaISA::InFmt_MUBUF_1::VADDR
unsigned int VADDR
Definition: gpu_decoder.hh:1717
gem5::VegaISA::Inst_SOPK::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:203
gem5::VegaISA::Inst_VOP1::~Inst_VOP1
~Inst_VOP1()
Definition: op_encodings.cc:745
gem5::VegaISA::Inst_VOP1::instSize
int instSize() const override
Definition: op_encodings.cc:773
gem5::VegaISA::Inst_VOP3B::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1061
gem5::VegaISA::Inst_SMEM::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:554
gem5::VegaISA::InFmt_VOP3_1::SRC2
unsigned int SRC2
Definition: gpu_decoder.hh:1814
gem5::VegaISA::Inst_SOPP::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:426
gem5::VegaISA::Inst_VOP2::hasSecondDword
bool hasSecondDword(InFmt_VOP2 *)
Definition: op_encodings.cc:660
gem5::VegaISA::Inst_VOP3A::extData
InFmt_VOP3_1 extData
Definition: op_encodings.hh:353
gem5::VegaISA::InFmt_FLAT_1::VDST
unsigned int VDST
Definition: gpu_decoder.hh:1651
gem5::VegaISA::Inst_FLAT::Inst_FLAT
Inst_FLAT(InFmt_FLAT *, const std::string &opcode)
Definition: op_encodings.cc:1515
gem5::VegaISA::Inst_FLAT::instSize
int instSize() const override
Definition: op_encodings.cc:1574
gem5::VegaISA::Inst_EXP::~Inst_EXP
~Inst_EXP()
Definition: op_encodings.cc:1485
gem5::VegaISA::Inst_SOPC::instData
InFmt_SOPC instData
Definition: op_encodings.hh:153
gem5::VegaISA::Inst_MIMG::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1421
gem5::VegaISA::REG_SRC_SWDA
@ REG_SRC_SWDA
Definition: gpu_registers.hh:126
gem5::GPUStaticInst::isStore
bool isStore() const
Definition: gpu_static_inst.hh:135
gem5::VegaISA::Inst_VINTRP::instData
InFmt_VINTRP instData
Definition: op_encodings.hh:335
gem5::VegaISA::InFmt_MTBUF
Definition: gpu_decoder.hh:1682
gem5::VegaISA::Inst_MTBUF::extData
InFmt_MTBUF_1 extData
Definition: op_encodings.hh:710
gem5::VegaISA::InFmt_MUBUF_1::VDATA
unsigned int VDATA
Definition: gpu_decoder.hh:1718
gem5::VegaISA::InFmt_DS::OFFSET0
unsigned int OFFSET0
Definition: gpu_decoder.hh:1603
gem5::VegaISA::Inst_FLAT::~Inst_FLAT
~Inst_FLAT()
Definition: op_encodings.cc:1532
gem5::VegaISA::InFmt_SOPP
Definition: gpu_decoder.hh:1772
gem5::VegaISA::InFmt_MUBUF
Definition: gpu_decoder.hh:1703
gem5::VegaISA::Inst_SOPP::Inst_SOPP
Inst_SOPP(InFmt_SOPP *, const std::string &opcode)
Definition: op_encodings.cc:382
gem5::VegaISA::Inst_MIMG::instSize
int instSize() const override
Definition: op_encodings.cc:1468
gem5::VegaISA::Inst_VOPC::~Inst_VOPC
~Inst_VOPC()
Definition: op_encodings.cc:839
gem5::VegaISA::Inst_SOPP::instData
InFmt_SOPP instData
Definition: op_encodings.hh:175
gem5::VegaISA::Inst_SOPK::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:152
gem5::VegaISA::InFmt_FLAT::GLC
unsigned int GLC
Definition: gpu_decoder.hh:1639
gem5::VegaISA::InFmt_MIMG::GLC
unsigned int GLC
Definition: gpu_decoder.hh:1663
gem5::VegaISA::InFmt_FLAT::SLC
unsigned int SLC
Definition: gpu_decoder.hh:1640
gem5::ArmISA::opcode
Bitfield< 24, 21 > opcode
Definition: types.hh:92
gem5::VegaISA::InFmt_SMEM_1::OFFSET
unsigned int OFFSET
Definition: gpu_decoder.hh:1738
gem5::VegaISA::Inst_VOP1::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:798
gem5::VegaISA::InFmt_MIMG_1::SSAMP
unsigned int SSAMP
Definition: gpu_decoder.hh:1677
gem5::VegaISA::InFmt_MUBUF_1::SOFFSET
unsigned int SOFFSET
Definition: gpu_decoder.hh:1722
gem5::VegaISA::Inst_SOPC::Inst_SOPC
Inst_SOPC(InFmt_SOPC *, const std::string &opcode)
Definition: op_encodings.cc:301
gem5::GPUStaticInst::getNumOperands
virtual int getNumOperands()=0
gem5::VegaISA::InFmt_EXP
Definition: gpu_decoder.hh:1618
gem5::VegaISA::Inst_VOPC::instSize
int instSize() const override
Definition: op_encodings.cc:868
gem5::VegaISA::isScalarReg
bool isScalarReg(int opIdx)
Definition: registers.cc:227
gem5::VegaISA::Inst_VOP2::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:685
gem5::VegaISA::MachInst
InstFormat * MachInst
used to represent the encoding of a VEGA inst.
Definition: gpu_types.hh:63
gem5::VegaISA::InFmt_SOP2::SSRC1
unsigned int SSRC1
Definition: gpu_decoder.hh:1752
gem5::VegaISA::Inst_VOPC::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:893
gem5::VegaISA::InFmt_DS_1::DATA0
unsigned int DATA0
Definition: gpu_decoder.hh:1613
gem5::VegaISA::Inst_SOP2::Inst_SOP2
Inst_SOP2(InFmt_SOP2 *, const std::string &opcode)
Definition: op_encodings.cc:45
gem5::GPUStaticInst::dstOps
std::vector< OperandInfo > dstOps
Definition: gpu_static_inst.hh:304
gem5::VegaISA::Inst_SOPC::instSize
int instSize() const override
Definition: op_encodings.cc:340
gem5::VegaISA::Inst_VOP1::extData
InstFormat extData
Definition: op_encodings.hh:296
gem5::VegaISA::InFmt_EXP_1
Definition: gpu_decoder.hh:1628
gem5::VegaISA::Inst_FLAT::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:1580
gem5::VegaISA::InFmt_VOP3_1::SRC0
unsigned int SRC0
Definition: gpu_decoder.hh:1812
gem5::VegaISA::REG_SRC_LITERAL
@ REG_SRC_LITERAL
Definition: gpu_registers.hh:132
gem5::VegaISA::InFmt_VINTRP
Definition: gpu_decoder.hh:1778
gem5::VegaISA::Inst_VOP2::instSize
int instSize() const override
Definition: op_encodings.cc:654
gem5::VegaISA::InFmt_VOPC::VSRC1
unsigned int VSRC1
Definition: gpu_decoder.hh:1829
gem5::VegaISA::Inst_VOP3A::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:987
gem5::VegaISA::Inst_MUBUF::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1254
gem5::VegaISA::Inst_MUBUF::Inst_MUBUF
Inst_MUBUF(InFmt_MUBUF *, const std::string &opcode)
Definition: op_encodings.cc:1232
gem5::VegaISA::Inst_FLAT::instData
InFmt_FLAT instData
Definition: op_encodings.hh:808
gem5::ArmISA::offset
Bitfield< 23, 0 > offset
Definition: types.hh:144
gem5::VegaISA::InFmt_SOPK::SIMM16
unsigned int SIMM16
Definition: gpu_decoder.hh:1766
gem5::VegaISA::Inst_EXP::Inst_EXP
Inst_EXP(InFmt_EXP *, const std::string &opcode)
Definition: op_encodings.cc:1475
gem5::VegaISA::Inst_VOPC::hasSecondDword
bool hasSecondDword(InFmt_VOPC *)
Definition: op_encodings.cc:874
gem5::VegaISA::InFmt_SMEM::SDATA
unsigned int SDATA
Definition: gpu_decoder.hh:1727
op_encodings.hh
gem5::VegaISA::Inst_SOPC::extData
InstFormat extData
Definition: op_encodings.hh:155
gem5::VegaISA::InFmt_SMEM::IMM
unsigned int IMM
Definition: gpu_decoder.hh:1732
gem5::VegaISA::InFmt_MIMG::SLC
unsigned int SLC
Definition: gpu_decoder.hh:1669
gem5::VegaISA::Inst_VOP2::instData
InFmt_VOP2 instData
Definition: op_encodings.hh:272
gem5::VegaISA::InFmt_VOP3B::VDST
unsigned int VDST
Definition: gpu_decoder.hh:1820
gem5::VegaISA::InFmt_DS_1::VDST
unsigned int VDST
Definition: gpu_decoder.hh:1615
gem5::VegaISA::Inst_VOP3A::~Inst_VOP3A
~Inst_VOP3A()
Definition: op_encodings.cc:936
gem5::VegaISA::Inst_SMEM::extData
InFmt_SMEM_1 extData
Definition: op_encodings.hh:256
gem5::VegaISA::Inst_MUBUF::~Inst_MUBUF
~Inst_MUBUF()
Definition: op_encodings.cc:1249
gem5::VegaISA::InFmt_MUBUF::SLC
unsigned int SLC
Definition: gpu_decoder.hh:1710
gem5::VegaISA::Inst_VOPC::varSize
uint32_t varSize
Definition: op_encodings.hh:319
gem5::VegaISA::Inst_SOP2::extData
InstFormat extData
Definition: op_encodings.hh:89
gem5::VegaISA::Inst_VOP2::~Inst_VOP2
~Inst_VOP2()
Definition: op_encodings.cc:610
gem5::VegaISA::Inst_VOP3B::instData
InFmt_VOP3B instData
Definition: op_encodings.hh:383
gem5::VegaISA::InFmt_VOP3B::SDST
unsigned int SDST
Definition: gpu_decoder.hh:1821
gem5::GPUStaticInst::readsVCC
bool readsVCC() const
Definition: gpu_static_inst.hh:149
gem5::VegaISA::isVectorReg
bool isVectorReg(int opIdx)
Definition: registers.cc:240
gem5::GPUStaticInst::isLoad
bool isLoad() const
Definition: gpu_static_inst.hh:134
gem5::VegaISA::InFmt_VOP2
Definition: gpu_decoder.hh:1794
gem5::VegaISA::Inst_SOP1::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:247
gem5::VegaISA::InFmt_SOP2::SSRC0
unsigned int SSRC0
Definition: gpu_decoder.hh:1751
gem5::VegaISA::Inst_SMEM::~Inst_SMEM
~Inst_SMEM()
Definition: op_encodings.cc:497
gem5::VegaISA::Inst_SOP2::hasSecondDword
bool hasSecondDword(InFmt_SOP2 *)
Definition: op_encodings.cc:93
gem5::VegaISA::Inst_SOP2::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:105
gem5::VegaISA::InFmt_SOP2
Definition: gpu_decoder.hh:1750
gem5::VegaISA::Inst_VINTRP::Inst_VINTRP
Inst_VINTRP(InFmt_VINTRP *, const std::string &opcode)
Definition: op_encodings.cc:906
gem5::VegaISA::InFmt_SMEM::GLC
unsigned int GLC
Definition: gpu_decoder.hh:1731
gem5::VegaISA::InFmt_EXP_1::VSRC0
unsigned int VSRC0
Definition: gpu_decoder.hh:1629
gem5::VegaISA::Inst_SOPK::varSize
uint32_t varSize
Definition: op_encodings.hh:112
gem5::X86ISA::reg
Bitfield< 5, 3 > reg
Definition: types.hh:92
gem5::VegaISA::Inst_SOPC::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:358
gem5::VegaISA::Inst_SOP1::instSize
int instSize() const override
Definition: op_encodings.cc:268
gem5::VegaISA::Inst_VOP2::varSize
uint32_t varSize
Definition: op_encodings.hh:275
gem5::VegaISA::InFmt_VOP1::VDST
unsigned int VDST
Definition: gpu_decoder.hh:1790
gem5::VegaISA::InFmt_SOPC::SSRC0
unsigned int SSRC0
Definition: gpu_decoder.hh:1759
gem5::VegaISA::Inst_MIMG::~Inst_MIMG
~Inst_MIMG()
Definition: op_encodings.cc:1416
gem5::VegaISA::Inst_MTBUF::instSize
int instSize() const override
Definition: op_encodings.cc:1392
gem5::VegaISA::Inst_FLAT::extData
InFmt_FLAT_1 extData
Definition: op_encodings.hh:810
gem5::VegaISA::Inst_VOP1::varSize
uint32_t varSize
Definition: op_encodings.hh:297
gem5::VegaISA::Inst_MTBUF::Inst_MTBUF
Inst_MTBUF(InFmt_MTBUF *, const std::string &opcode)
Definition: op_encodings.cc:1326
gem5::VegaISA::Inst_VOP3B::extData
InFmt_VOP3_1 extData
Definition: op_encodings.hh:385
gem5::VegaISA::Inst_SOP1::varSize
uint32_t varSize
Definition: op_encodings.hh:134
gem5::VegaISA::Inst_EXP::instData
InFmt_EXP instData
Definition: op_encodings.hh:743
gem5::GPUStaticInst::_opcode
const std::string _opcode
Definition: gpu_static_inst.hh:299
gem5::VegaISA::InFmt_SOPK
Definition: gpu_decoder.hh:1765
gem5::VegaISA::Inst_SOPP::~Inst_SOPP
~Inst_SOPP()
Definition: op_encodings.cc:391
gem5::VegaISA::Inst_SOP1::instData
InFmt_SOP1 instData
Definition: op_encodings.hh:131
gem5::VegaISA::InFmt_MUBUF_1
Definition: gpu_decoder.hh:1716
gem5::VegaISA::Inst_VOPC::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:844
gem5::VegaISA::InFmt_MIMG_1
Definition: gpu_decoder.hh:1673
gem5::VegaISA::InFmt_VOP3A::VDST
unsigned int VDST
Definition: gpu_decoder.hh:1803
gem5::VegaISA::InFmt_DS_1::DATA1
unsigned int DATA1
Definition: gpu_decoder.hh:1614
gem5::VegaISA::Inst_VINTRP::instSize
int instSize() const override
Definition: op_encodings.cc:918
gem5::VegaISA::Inst_SOPP::instSize
int instSize() const override
Definition: op_encodings.cc:420
gem5::VegaISA::Inst_SOPC::varSize
uint32_t varSize
Definition: op_encodings.hh:156
gem5::VegaISA::Inst_DS::instSize
int instSize() const override
Definition: op_encodings.cc:1192
gem5::VegaISA::Inst_DS::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:1198
gem5::VegaISA::Inst_DS::Inst_DS
Inst_DS(InFmt_DS *, const std::string &opcode)
Definition: op_encodings.cc:1152
gem5::VegaISA::InFmt_SOP2::SDST
unsigned int SDST
Definition: gpu_decoder.hh:1753
gem5::VegaISA::InFmt_VOP3_1
Definition: gpu_decoder.hh:1811
gem5::VegaISA::REG_SRC_DPP
@ REG_SRC_DPP
Definition: gpu_registers.hh:127
gem5::VegaISA::Inst_SOPK::hasSecondDword
bool hasSecondDword(InFmt_SOPK *)
Definition: op_encodings.cc:186
gem5::VegaISA::Inst_SOPP::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:396
gem5::VegaISA::InFmt_MTBUF_1::SRSRC
unsigned int SRSRC
Definition: gpu_decoder.hh:1696
gem5::GPUStaticInst::isAtomic
bool isAtomic() const
Definition: gpu_static_inst.hh:138
gem5::VegaISA::InFmt_VOP1
Definition: gpu_decoder.hh:1787
gem5::VegaISA::Inst_EXP::extData
InFmt_EXP_1 extData
Definition: op_encodings.hh:745
gem5::VegaISA::InFmt_MTBUF_1::SLC
unsigned int SLC
Definition: gpu_decoder.hh:1698
gem5::VegaISA::InFmt_MIMG_1::SRSRC
unsigned int SRSRC
Definition: gpu_decoder.hh:1676
gem5::VegaISA::InFmt_MTBUF_1::VADDR
unsigned int VADDR
Definition: gpu_decoder.hh:1694
gem5::VegaISA::InFmt_SOPK::OP
unsigned int OP
Definition: gpu_decoder.hh:1768
gem5::VegaISA::InFmt_SOP1::SDST
unsigned int SDST
Definition: gpu_decoder.hh:1746
gem5::VegaISA::Inst_MTBUF::instData
InFmt_MTBUF instData
Definition: op_encodings.hh:708
gem5::VegaISA::InFmt_SOP1
Definition: gpu_decoder.hh:1743
gem5::VegaISA::InFmt_VOP1::SRC0
unsigned int SRC0
Definition: gpu_decoder.hh:1788
gem5::VegaISA::InFmt_SOPK::SDST
unsigned int SDST
Definition: gpu_decoder.hh:1767
gem5::VegaISA::InFmt_VOPC
Definition: gpu_decoder.hh:1827
gem5::VegaISA::Inst_VOP3B::Inst_VOP3B
Inst_VOP3B(InFmt_VOP3B *, const std::string &opcode)
Definition: op_encodings.cc:1046
gem5::VegaISA::Inst_VOP1::hasSecondDword
bool hasSecondDword(InFmt_VOP1 *)
Definition: op_encodings.cc:779
gem5::VegaISA::Inst_SOP1::hasSecondDword
bool hasSecondDword(InFmt_SOP1 *)
Definition: op_encodings.cc:274
gem5::VegaISA::InFmt_DS_1::ADDR
unsigned int ADDR
Definition: gpu_decoder.hh:1612
gem5::VegaISA::Inst_VOP1::instData
InFmt_VOP1 instData
Definition: op_encodings.hh:294
gem5::VegaISA::Inst_SOPK::instSize
int instSize() const override
Definition: op_encodings.cc:180
gem5::VegaISA::InFmt_VOP3_1::SRC1
unsigned int SRC1
Definition: gpu_decoder.hh:1813
gem5::VegaISA::InFmt_FLAT_1::DATA
unsigned int DATA
Definition: gpu_decoder.hh:1648
gem5::VegaISA::Inst_MTBUF::~Inst_MTBUF
~Inst_MTBUF()
Definition: op_encodings.cc:1343
gem5::VegaISA::InFmt_EXP_1::VSRC3
unsigned int VSRC3
Definition: gpu_decoder.hh:1632
gem5
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
Definition: decoder.cc:40
gem5::VegaISA::InFmt_DS::OFFSET1
unsigned int OFFSET1
Definition: gpu_decoder.hh:1604
gem5::VegaISA::Inst_SOP1::generateDisassembly
void generateDisassembly() override
Definition: op_encodings.cc:283
gem5::VegaISA::InFmt_DS_1
Definition: gpu_decoder.hh:1611
gem5::VegaISA::InFmt_SOPC
Definition: gpu_decoder.hh:1758
gem5::VegaISA::InFmt_MTBUF::GLC
unsigned int GLC
Definition: gpu_decoder.hh:1686
gem5::VegaISA::Inst_DS::instData
InFmt_DS instData
Definition: op_encodings.hh:484
gem5::VegaISA::Inst_VOP1::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:750
gem5::VegaISA::Inst_SMEM::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:502
gem5::VegaISA::InFmt_VOPC::SRC0
unsigned int SRC0
Definition: gpu_decoder.hh:1828
gem5::VegaISA::InFmt_MTBUF_1::VDATA
unsigned int VDATA
Definition: gpu_decoder.hh:1695
gem5::VegaISA::Inst_MUBUF::extData
InFmt_MUBUF_1 extData
Definition: op_encodings.hh:690
gem5::VegaISA::InFmt_MIMG_1::VADDR
unsigned int VADDR
Definition: gpu_decoder.hh:1674
gem5::VegaISA::InFmt_FLAT_1
Definition: gpu_decoder.hh:1646
gem5::VegaISA::Inst_EXP::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1490
gem5::VegaISA::InFmt_MTBUF_1
Definition: gpu_decoder.hh:1693
gem5::VegaISA::Inst_SOPK::~Inst_SOPK
~Inst_SOPK()
Definition: op_encodings.cc:147
gem5::VegaISA::Inst_VOPC::instData
InFmt_VOPC instData
Definition: op_encodings.hh:316
gem5::VegaISA::Inst_MTBUF::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1348
gem5::VegaISA::InFmt_FLAT
Definition: gpu_decoder.hh:1635
gem5::VegaISA::Inst_SOPC::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:323
gem5::GPUStaticInst::numDstRegOperands
virtual int numDstRegOperands()=0
gem5::VegaISA::Inst_FLAT::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1537
gem5::VegaISA::InFmt_VOP2::SRC0
unsigned int SRC0
Definition: gpu_decoder.hh:1795
gem5::VegaISA::Inst_DS::initOperandInfo
void initOperandInfo() override
Definition: op_encodings.cc:1169
gem5::GPUStaticInst::setFlag
void setFlag(Flags flag)
Definition: gpu_static_inst.hh:245
gem5::VegaISA::Inst_SMEM::instData
InFmt_SMEM instData
Definition: op_encodings.hh:254
gem5::VegaISA::InFmt_VOP3B
Definition: gpu_decoder.hh:1819
gem5::VegaISA::Inst_SMEM::instSize
int instSize() const override
Definition: op_encodings.cc:548
gem5::VegaISA::Inst_SOP1::~Inst_SOP1
~Inst_SOP1()
Definition: op_encodings.cc:242

Generated on Tue Sep 21 2021 12:24:20 for gem5 by doxygen 1.8.17