gem5  v22.1.0.0
instructions.hh
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-2021 Advanced Micro Devices, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright notice,
9  * this list of conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright notice,
12  * this list of conditions and the following disclaimer in the documentation
13  * and/or other materials provided with the distribution.
14  *
15  * 3. Neither the name of the copyright holder nor the names of its
16  * contributors may be used to endorse or promote products derived from this
17  * software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 #ifndef __ARCH_VEGA_INSTS_INSTRUCTIONS_HH__
33 #define __ARCH_VEGA_INSTS_INSTRUCTIONS_HH__
34 
35 #include "arch/amdgpu/vega/gpu_decoder.hh"
36 #include "arch/amdgpu/vega/insts/gpu_static_inst.hh"
37 #include "arch/amdgpu/vega/insts/op_encodings.hh"
38 #include "debug/VEGA.hh"
39 
40 namespace gem5
41 {
42 
43 namespace VegaISA
44 {
45  class Inst_SOP2__S_ADD_U32 : public Inst_SOP2
46  {
47  public:
48  Inst_SOP2__S_ADD_U32(InFmt_SOP2*);
49  ~Inst_SOP2__S_ADD_U32();
50 
51  int
52  getNumOperands() override
53  {
54  return numDstRegOperands() + numSrcRegOperands();
55  } // getNumOperands
56 
57  int numDstRegOperands() override { return 1; }
58  int numSrcRegOperands() override { return 2; }
59 
60  int
61  getOperandSize(int opIdx) override
62  {
63  switch (opIdx) {
64  case 0: //ssrc_0
65  return 4;
66  case 1: //ssrc_1
67  return 4;
68  case 2: //sdst
69  return 4;
70  default:
71  fatal("op idx %i out of bounds\n", opIdx);
72  return -1;
73  }
74  } // getOperandSize
75 
76  void execute(GPUDynInstPtr) override;
77  }; // Inst_SOP2__S_ADD_U32
78 
79  class Inst_SOP2__S_SUB_U32 : public Inst_SOP2
80  {
81  public:
82  Inst_SOP2__S_SUB_U32(InFmt_SOP2*);
83  ~Inst_SOP2__S_SUB_U32();
84 
85  int
86  getNumOperands() override
87  {
88  return numDstRegOperands() + numSrcRegOperands();
89  } // getNumOperands
90 
91  int numDstRegOperands() override { return 1; }
92  int numSrcRegOperands() override { return 2; }
93 
94  int
95  getOperandSize(int opIdx) override
96  {
97  switch (opIdx) {
98  case 0: //ssrc_0
99  return 4;
100  case 1: //ssrc_1
101  return 4;
102  case 2: //sdst
103  return 4;
104  default:
105  fatal("op idx %i out of bounds\n", opIdx);
106  return -1;
107  }
108  } // getOperandSize
109 
110  void execute(GPUDynInstPtr) override;
111  }; // Inst_SOP2__S_SUB_U32
112 
113  class Inst_SOP2__S_ADD_I32 : public Inst_SOP2
114  {
115  public:
116  Inst_SOP2__S_ADD_I32(InFmt_SOP2*);
117  ~Inst_SOP2__S_ADD_I32();
118 
119  int
120  getNumOperands() override
121  {
122  return numDstRegOperands() + numSrcRegOperands();
123  } // getNumOperands
124 
125  int numDstRegOperands() override { return 1; }
126  int numSrcRegOperands() override { return 2; }
127 
128  int
129  getOperandSize(int opIdx) override
130  {
131  switch (opIdx) {
132  case 0: //ssrc_0
133  return 4;
134  case 1: //ssrc_1
135  return 4;
136  case 2: //sdst
137  return 4;
138  default:
139  fatal("op idx %i out of bounds\n", opIdx);
140  return -1;
141  }
142  } // getOperandSize
143 
144  void execute(GPUDynInstPtr) override;
145  }; // Inst_SOP2__S_ADD_I32
146 
147  class Inst_SOP2__S_SUB_I32 : public Inst_SOP2
148  {
149  public:
150  Inst_SOP2__S_SUB_I32(InFmt_SOP2*);
151  ~Inst_SOP2__S_SUB_I32();
152 
153  int
154  getNumOperands() override
155  {
156  return numDstRegOperands() + numSrcRegOperands();
157  } // getNumOperands
158 
159  int numDstRegOperands() override { return 1; }
160  int numSrcRegOperands() override { return 2; }
161 
162  int
163  getOperandSize(int opIdx) override
164  {
165  switch (opIdx) {
166  case 0: //ssrc_0
167  return 4;
168  case 1: //ssrc_1
169  return 4;
170  case 2: //sdst
171  return 4;
172  default:
173  fatal("op idx %i out of bounds\n", opIdx);
174  return -1;
175  }
176  } // getOperandSize
177 
178  void execute(GPUDynInstPtr) override;
179  }; // Inst_SOP2__S_SUB_I32
180 
181  class Inst_SOP2__S_ADDC_U32 : public Inst_SOP2
182  {
183  public:
184  Inst_SOP2__S_ADDC_U32(InFmt_SOP2*);
185  ~Inst_SOP2__S_ADDC_U32();
186 
187  int
188  getNumOperands() override
189  {
190  return numDstRegOperands() + numSrcRegOperands();
191  } // getNumOperands
192 
193  int numDstRegOperands() override { return 1; }
194  int numSrcRegOperands() override { return 2; }
195 
196  int
197  getOperandSize(int opIdx) override
198  {
199  switch (opIdx) {
200  case 0: //ssrc_0
201  return 4;
202  case 1: //ssrc_1
203  return 4;
204  case 2: //sdst
205  return 4;
206  default:
207  fatal("op idx %i out of bounds\n", opIdx);
208  return -1;
209  }
210  } // getOperandSize
211 
212  void execute(GPUDynInstPtr) override;
213  }; // Inst_SOP2__S_ADDC_U32
214 
215  class Inst_SOP2__S_SUBB_U32 : public Inst_SOP2
216  {
217  public:
218  Inst_SOP2__S_SUBB_U32(InFmt_SOP2*);
219  ~Inst_SOP2__S_SUBB_U32();
220 
221  int
222  getNumOperands() override
223  {
224  return numDstRegOperands() + numSrcRegOperands();
225  } // getNumOperands
226 
227  int numDstRegOperands() override { return 1; }
228  int numSrcRegOperands() override { return 2; }
229 
230  int
231  getOperandSize(int opIdx) override
232  {
233  switch (opIdx) {
234  case 0: //ssrc_0
235  return 4;
236  case 1: //ssrc_1
237  return 4;
238  case 2: //sdst
239  return 4;
240  default:
241  fatal("op idx %i out of bounds\n", opIdx);
242  return -1;
243  }
244  } // getOperandSize
245 
246  void execute(GPUDynInstPtr) override;
247  }; // Inst_SOP2__S_SUBB_U32
248 
249  class Inst_SOP2__S_MIN_I32 : public Inst_SOP2
250  {
251  public:
252  Inst_SOP2__S_MIN_I32(InFmt_SOP2*);
253  ~Inst_SOP2__S_MIN_I32();
254 
255  int
256  getNumOperands() override
257  {
258  return numDstRegOperands() + numSrcRegOperands();
259  } // getNumOperands
260 
261  int numDstRegOperands() override { return 1; }
262  int numSrcRegOperands() override { return 2; }
263 
264  int
265  getOperandSize(int opIdx) override
266  {
267  switch (opIdx) {
268  case 0: //ssrc_0
269  return 4;
270  case 1: //ssrc_1
271  return 4;
272  case 2: //sdst
273  return 4;
274  default:
275  fatal("op idx %i out of bounds\n", opIdx);
276  return -1;
277  }
278  } // getOperandSize
279 
280  void execute(GPUDynInstPtr) override;
281  }; // Inst_SOP2__S_MIN_I32
282 
283  class Inst_SOP2__S_MIN_U32 : public Inst_SOP2
284  {
285  public:
286  Inst_SOP2__S_MIN_U32(InFmt_SOP2*);
287  ~Inst_SOP2__S_MIN_U32();
288 
289  int
290  getNumOperands() override
291  {
292  return numDstRegOperands() + numSrcRegOperands();
293  } // getNumOperands
294 
295  int numDstRegOperands() override { return 1; }
296  int numSrcRegOperands() override { return 2; }
297 
298  int
299  getOperandSize(int opIdx) override
300  {
301  switch (opIdx) {
302  case 0: //ssrc_0
303  return 4;
304  case 1: //ssrc_1
305  return 4;
306  case 2: //sdst
307  return 4;
308  default:
309  fatal("op idx %i out of bounds\n", opIdx);
310  return -1;
311  }
312  } // getOperandSize
313 
314  void execute(GPUDynInstPtr) override;
315  }; // Inst_SOP2__S_MIN_U32
316 
317  class Inst_SOP2__S_MAX_I32 : public Inst_SOP2
318  {
319  public:
320  Inst_SOP2__S_MAX_I32(InFmt_SOP2*);
321  ~Inst_SOP2__S_MAX_I32();
322 
323  int
324  getNumOperands() override
325  {
326  return numDstRegOperands() + numSrcRegOperands();
327  } // getNumOperands
328 
329  int numDstRegOperands() override { return 1; }
330  int numSrcRegOperands() override { return 2; }
331 
332  int
333  getOperandSize(int opIdx) override
334  {
335  switch (opIdx) {
336  case 0: //ssrc_0
337  return 4;
338  case 1: //ssrc_1
339  return 4;
340  case 2: //sdst
341  return 4;
342  default:
343  fatal("op idx %i out of bounds\n", opIdx);
344  return -1;
345  }
346  } // getOperandSize
347 
348  void execute(GPUDynInstPtr) override;
349  }; // Inst_SOP2__S_MAX_I32
350 
351  class Inst_SOP2__S_MAX_U32 : public Inst_SOP2
352  {
353  public:
354  Inst_SOP2__S_MAX_U32(InFmt_SOP2*);
355  ~Inst_SOP2__S_MAX_U32();
356 
357  int
358  getNumOperands() override
359  {
360  return numDstRegOperands() + numSrcRegOperands();
361  } // getNumOperands
362 
363  int numDstRegOperands() override { return 1; }
364  int numSrcRegOperands() override { return 2; }
365 
366  int
367  getOperandSize(int opIdx) override
368  {
369  switch (opIdx) {
370  case 0: //ssrc_0
371  return 4;
372  case 1: //ssrc_1
373  return 4;
374  case 2: //sdst
375  return 4;
376  default:
377  fatal("op idx %i out of bounds\n", opIdx);
378  return -1;
379  }
380  } // getOperandSize
381 
382  void execute(GPUDynInstPtr) override;
383  }; // Inst_SOP2__S_MAX_U32
384 
385  class Inst_SOP2__S_CSELECT_B32 : public Inst_SOP2
386  {
387  public:
388  Inst_SOP2__S_CSELECT_B32(InFmt_SOP2*);
389  ~Inst_SOP2__S_CSELECT_B32();
390 
391  int
392  getNumOperands() override
393  {
394  return numDstRegOperands() + numSrcRegOperands();
395  } // getNumOperands
396 
397  int numDstRegOperands() override { return 1; }
398  int numSrcRegOperands() override { return 2; }
399 
400  int
401  getOperandSize(int opIdx) override
402  {
403  switch (opIdx) {
404  case 0: //ssrc_0
405  return 4;
406  case 1: //ssrc_1
407  return 4;
408  case 2: //sdst
409  return 4;
410  default:
411  fatal("op idx %i out of bounds\n", opIdx);
412  return -1;
413  }
414  } // getOperandSize
415 
416  void execute(GPUDynInstPtr) override;
417  }; // Inst_SOP2__S_CSELECT_B32
418 
419  class Inst_SOP2__S_CSELECT_B64 : public Inst_SOP2
420  {
421  public:
422  Inst_SOP2__S_CSELECT_B64(InFmt_SOP2*);
423  ~Inst_SOP2__S_CSELECT_B64();
424 
425  int
426  getNumOperands() override
427  {
428  return numDstRegOperands() + numSrcRegOperands();
429  } // getNumOperands
430 
431  int numDstRegOperands() override { return 1; }
432  int numSrcRegOperands() override { return 2; }
433 
434  int
435  getOperandSize(int opIdx) override
436  {
437  switch (opIdx) {
438  case 0: //ssrc_0
439  return 8;
440  case 1: //ssrc_1
441  return 8;
442  case 2: //sdst
443  return 8;
444  default:
445  fatal("op idx %i out of bounds\n", opIdx);
446  return -1;
447  }
448  } // getOperandSize
449 
450  void execute(GPUDynInstPtr) override;
451  }; // Inst_SOP2__S_CSELECT_B64
452 
453  class Inst_SOP2__S_AND_B32 : public Inst_SOP2
454  {
455  public:
456  Inst_SOP2__S_AND_B32(InFmt_SOP2*);
457  ~Inst_SOP2__S_AND_B32();
458 
459  int
460  getNumOperands() override
461  {
462  return numDstRegOperands() + numSrcRegOperands();
463  } // getNumOperands
464 
465  int numDstRegOperands() override { return 1; }
466  int numSrcRegOperands() override { return 2; }
467 
468  int
469  getOperandSize(int opIdx) override
470  {
471  switch (opIdx) {
472  case 0: //ssrc_0
473  return 4;
474  case 1: //ssrc_1
475  return 4;
476  case 2: //sdst
477  return 4;
478  default:
479  fatal("op idx %i out of bounds\n", opIdx);
480  return -1;
481  }
482  } // getOperandSize
483 
484  void execute(GPUDynInstPtr) override;
485  }; // Inst_SOP2__S_AND_B32
486 
487  class Inst_SOP2__S_AND_B64 : public Inst_SOP2
488  {
489  public:
490  Inst_SOP2__S_AND_B64(InFmt_SOP2*);
491  ~Inst_SOP2__S_AND_B64();
492 
493  int
494  getNumOperands() override
495  {
496  return numDstRegOperands() + numSrcRegOperands();
497  } // getNumOperands
498 
499  int numDstRegOperands() override { return 1; }
500  int numSrcRegOperands() override { return 2; }
501 
502  int
503  getOperandSize(int opIdx) override
504  {
505  switch (opIdx) {
506  case 0: //ssrc_0
507  return 8;
508  case 1: //ssrc_1
509  return 8;
510  case 2: //sdst
511  return 8;
512  default:
513  fatal("op idx %i out of bounds\n", opIdx);
514  return -1;
515  }
516  } // getOperandSize
517 
518  void execute(GPUDynInstPtr) override;
519  }; // Inst_SOP2__S_AND_B64
520 
521  class Inst_SOP2__S_OR_B32 : public Inst_SOP2
522  {
523  public:
524  Inst_SOP2__S_OR_B32(InFmt_SOP2*);
525  ~Inst_SOP2__S_OR_B32();
526 
527  int
528  getNumOperands() override
529  {
530  return numDstRegOperands() + numSrcRegOperands();
531  } // getNumOperands
532 
533  int numDstRegOperands() override { return 1; }
534  int numSrcRegOperands() override { return 2; }
535 
536  int
537  getOperandSize(int opIdx) override
538  {
539  switch (opIdx) {
540  case 0: //ssrc_0
541  return 4;
542  case 1: //ssrc_1
543  return 4;
544  case 2: //sdst
545  return 4;
546  default:
547  fatal("op idx %i out of bounds\n", opIdx);
548  return -1;
549  }
550  } // getOperandSize
551 
552  void execute(GPUDynInstPtr) override;
553  }; // Inst_SOP2__S_OR_B32
554 
555  class Inst_SOP2__S_OR_B64 : public Inst_SOP2
556  {
557  public:
558  Inst_SOP2__S_OR_B64(InFmt_SOP2*);
559  ~Inst_SOP2__S_OR_B64();
560 
561  int
562  getNumOperands() override
563  {
564  return numDstRegOperands() + numSrcRegOperands();
565  } // getNumOperands
566 
567  int numDstRegOperands() override { return 1; }
568  int numSrcRegOperands() override { return 2; }
569 
570  int
571  getOperandSize(int opIdx) override
572  {
573  switch (opIdx) {
574  case 0: //ssrc_0
575  return 8;
576  case 1: //ssrc_1
577  return 8;
578  case 2: //sdst
579  return 8;
580  default:
581  fatal("op idx %i out of bounds\n", opIdx);
582  return -1;
583  }
584  } // getOperandSize
585 
586  void execute(GPUDynInstPtr) override;
587  }; // Inst_SOP2__S_OR_B64
588 
589  class Inst_SOP2__S_XOR_B32 : public Inst_SOP2
590  {
591  public:
592  Inst_SOP2__S_XOR_B32(InFmt_SOP2*);
593  ~Inst_SOP2__S_XOR_B32();
594 
595  int
596  getNumOperands() override
597  {
598  return numDstRegOperands() + numSrcRegOperands();
599  } // getNumOperands
600 
601  int numDstRegOperands() override { return 1; }
602  int numSrcRegOperands() override { return 2; }
603 
604  int
605  getOperandSize(int opIdx) override
606  {
607  switch (opIdx) {
608  case 0: //ssrc_0
609  return 4;
610  case 1: //ssrc_1
611  return 4;
612  case 2: //sdst
613  return 4;
614  default:
615  fatal("op idx %i out of bounds\n", opIdx);
616  return -1;
617  }
618  } // getOperandSize
619 
620  void execute(GPUDynInstPtr) override;
621  }; // Inst_SOP2__S_XOR_B32
622 
623  class Inst_SOP2__S_XOR_B64 : public Inst_SOP2
624  {
625  public:
626  Inst_SOP2__S_XOR_B64(InFmt_SOP2*);
627  ~Inst_SOP2__S_XOR_B64();
628 
629  int
630  getNumOperands() override
631  {
632  return numDstRegOperands() + numSrcRegOperands();
633  } // getNumOperands
634 
635  int numDstRegOperands() override { return 1; }
636  int numSrcRegOperands() override { return 2; }
637 
638  int
639  getOperandSize(int opIdx) override
640  {
641  switch (opIdx) {
642  case 0: //ssrc_0
643  return 8;
644  case 1: //ssrc_1
645  return 8;
646  case 2: //sdst
647  return 8;
648  default:
649  fatal("op idx %i out of bounds\n", opIdx);
650  return -1;
651  }
652  } // getOperandSize
653 
654  void execute(GPUDynInstPtr) override;
655  }; // Inst_SOP2__S_XOR_B64
656 
657  class Inst_SOP2__S_ANDN2_B32 : public Inst_SOP2
658  {
659  public:
660  Inst_SOP2__S_ANDN2_B32(InFmt_SOP2*);
661  ~Inst_SOP2__S_ANDN2_B32();
662 
663  int
664  getNumOperands() override
665  {
666  return numDstRegOperands() + numSrcRegOperands();
667  } // getNumOperands
668 
669  int numDstRegOperands() override { return 1; }
670  int numSrcRegOperands() override { return 2; }
671 
672  int
673  getOperandSize(int opIdx) override
674  {
675  switch (opIdx) {
676  case 0: //ssrc_0
677  return 4;
678  case 1: //ssrc_1
679  return 4;
680  case 2: //sdst
681  return 4;
682  default:
683  fatal("op idx %i out of bounds\n", opIdx);
684  return -1;
685  }
686  } // getOperandSize
687 
688  void execute(GPUDynInstPtr) override;
689  }; // Inst_SOP2__S_ANDN2_B32
690 
691  class Inst_SOP2__S_ANDN2_B64 : public Inst_SOP2
692  {
693  public:
694  Inst_SOP2__S_ANDN2_B64(InFmt_SOP2*);
695  ~Inst_SOP2__S_ANDN2_B64();
696 
697  int
698  getNumOperands() override
699  {
700  return numDstRegOperands() + numSrcRegOperands();
701  } // getNumOperands
702 
703  int numDstRegOperands() override { return 1; }
704  int numSrcRegOperands() override { return 2; }
705 
706  int
707  getOperandSize(int opIdx) override
708  {
709  switch (opIdx) {
710  case 0: //ssrc_0
711  return 8;
712  case 1: //ssrc_1
713  return 8;
714  case 2: //sdst
715  return 8;
716  default:
717  fatal("op idx %i out of bounds\n", opIdx);
718  return -1;
719  }
720  } // getOperandSize
721 
722  void execute(GPUDynInstPtr) override;
723  }; // Inst_SOP2__S_ANDN2_B64
724 
725  class Inst_SOP2__S_ORN2_B32 : public Inst_SOP2
726  {
727  public:
728  Inst_SOP2__S_ORN2_B32(InFmt_SOP2*);
729  ~Inst_SOP2__S_ORN2_B32();
730 
731  int
732  getNumOperands() override
733  {
734  return numDstRegOperands() + numSrcRegOperands();
735  } // getNumOperands
736 
737  int numDstRegOperands() override { return 1; }
738  int numSrcRegOperands() override { return 2; }
739 
740  int
741  getOperandSize(int opIdx) override
742  {
743  switch (opIdx) {
744  case 0: //ssrc_0
745  return 4;
746  case 1: //ssrc_1
747  return 4;
748  case 2: //sdst
749  return 4;
750  default:
751  fatal("op idx %i out of bounds\n", opIdx);
752  return -1;
753  }
754  } // getOperandSize
755 
756  void execute(GPUDynInstPtr) override;
757  }; // Inst_SOP2__S_ORN2_B32
758 
759  class Inst_SOP2__S_ORN2_B64 : public Inst_SOP2
760  {
761  public:
762  Inst_SOP2__S_ORN2_B64(InFmt_SOP2*);
763  ~Inst_SOP2__S_ORN2_B64();
764 
765  int
766  getNumOperands() override
767  {
768  return numDstRegOperands() + numSrcRegOperands();
769  } // getNumOperands
770 
771  int numDstRegOperands() override { return 1; }
772  int numSrcRegOperands() override { return 2; }
773 
774  int
775  getOperandSize(int opIdx) override
776  {
777  switch (opIdx) {
778  case 0: //ssrc_0
779  return 8;
780  case 1: //ssrc_1
781  return 8;
782  case 2: //sdst
783  return 8;
784  default:
785  fatal("op idx %i out of bounds\n", opIdx);
786  return -1;
787  }
788  } // getOperandSize
789 
790  void execute(GPUDynInstPtr) override;
791  }; // Inst_SOP2__S_ORN2_B64
792 
793  class Inst_SOP2__S_NAND_B32 : public Inst_SOP2
794  {
795  public:
796  Inst_SOP2__S_NAND_B32(InFmt_SOP2*);
797  ~Inst_SOP2__S_NAND_B32();
798 
799  int
800  getNumOperands() override
801  {
802  return numDstRegOperands() + numSrcRegOperands();
803  } // getNumOperands
804 
805  int numDstRegOperands() override { return 1; }
806  int numSrcRegOperands() override { return 2; }
807 
808  int
809  getOperandSize(int opIdx) override
810  {
811  switch (opIdx) {
812  case 0: //ssrc_0
813  return 4;
814  case 1: //ssrc_1
815  return 4;
816  case 2: //sdst
817  return 4;
818  default:
819  fatal("op idx %i out of bounds\n", opIdx);
820  return -1;
821  }
822  } // getOperandSize
823 
824  void execute(GPUDynInstPtr) override;
825  }; // Inst_SOP2__S_NAND_B32
826 
827  class Inst_SOP2__S_NAND_B64 : public Inst_SOP2
828  {
829  public:
830  Inst_SOP2__S_NAND_B64(InFmt_SOP2*);
831  ~Inst_SOP2__S_NAND_B64();
832 
833  int
834  getNumOperands() override
835  {
836  return numDstRegOperands() + numSrcRegOperands();
837  } // getNumOperands
838 
839  int numDstRegOperands() override { return 1; }
840  int numSrcRegOperands() override { return 2; }
841 
842  int
843  getOperandSize(int opIdx) override
844  {
845  switch (opIdx) {
846  case 0: //ssrc_0
847  return 8;
848  case 1: //ssrc_1
849  return 8;
850  case 2: //sdst
851  return 8;
852  default:
853  fatal("op idx %i out of bounds\n", opIdx);
854  return -1;
855  }
856  } // getOperandSize
857 
858  void execute(GPUDynInstPtr) override;
859  }; // Inst_SOP2__S_NAND_B64
860 
861  class Inst_SOP2__S_NOR_B32 : public Inst_SOP2
862  {
863  public:
864  Inst_SOP2__S_NOR_B32(InFmt_SOP2*);
865  ~Inst_SOP2__S_NOR_B32();
866 
867  int
868  getNumOperands() override
869  {
870  return numDstRegOperands() + numSrcRegOperands();
871  } // getNumOperands
872 
873  int numDstRegOperands() override { return 1; }
874  int numSrcRegOperands() override { return 2; }
875 
876  int
877  getOperandSize(int opIdx) override
878  {
879  switch (opIdx) {
880  case 0: //ssrc_0
881  return 4;
882  case 1: //ssrc_1
883  return 4;
884  case 2: //sdst
885  return 4;
886  default:
887  fatal("op idx %i out of bounds\n", opIdx);
888  return -1;
889  }
890  } // getOperandSize
891 
892  void execute(GPUDynInstPtr) override;
893  }; // Inst_SOP2__S_NOR_B32
894 
895  class Inst_SOP2__S_NOR_B64 : public Inst_SOP2
896  {
897  public:
898  Inst_SOP2__S_NOR_B64(InFmt_SOP2*);
899  ~Inst_SOP2__S_NOR_B64();
900 
901  int
902  getNumOperands() override
903  {
904  return numDstRegOperands() + numSrcRegOperands();
905  } // getNumOperands
906 
907  int numDstRegOperands() override { return 1; }
908  int numSrcRegOperands() override { return 2; }
909 
910  int
911  getOperandSize(int opIdx) override
912  {
913  switch (opIdx) {
914  case 0: //ssrc_0
915  return 8;
916  case 1: //ssrc_1
917  return 8;
918  case 2: //sdst
919  return 8;
920  default:
921  fatal("op idx %i out of bounds\n", opIdx);
922  return -1;
923  }
924  } // getOperandSize
925 
926  void execute(GPUDynInstPtr) override;
927  }; // Inst_SOP2__S_NOR_B64
928 
929  class Inst_SOP2__S_XNOR_B32 : public Inst_SOP2
930  {
931  public:
932  Inst_SOP2__S_XNOR_B32(InFmt_SOP2*);
933  ~Inst_SOP2__S_XNOR_B32();
934 
935  int
936  getNumOperands() override
937  {
938  return numDstRegOperands() + numSrcRegOperands();
939  } // getNumOperands
940 
941  int numDstRegOperands() override { return 1; }
942  int numSrcRegOperands() override { return 2; }
943 
944  int
945  getOperandSize(int opIdx) override
946  {
947  switch (opIdx) {
948  case 0: //ssrc_0
949  return 4;
950  case 1: //ssrc_1
951  return 4;
952  case 2: //sdst
953  return 4;
954  default:
955  fatal("op idx %i out of bounds\n", opIdx);
956  return -1;
957  }
958  } // getOperandSize
959 
960  void execute(GPUDynInstPtr) override;
961  }; // Inst_SOP2__S_XNOR_B32
962 
963  class Inst_SOP2__S_XNOR_B64 : public Inst_SOP2
964  {
965  public:
966  Inst_SOP2__S_XNOR_B64(InFmt_SOP2*);
967  ~Inst_SOP2__S_XNOR_B64();
968 
969  int
970  getNumOperands() override
971  {
972  return numDstRegOperands() + numSrcRegOperands();
973  } // getNumOperands
974 
975  int numDstRegOperands() override { return 1; }
976  int numSrcRegOperands() override { return 2; }
977 
978  int
979  getOperandSize(int opIdx) override
980  {
981  switch (opIdx) {
982  case 0: //ssrc_0
983  return 8;
984  case 1: //ssrc_1
985  return 8;
986  case 2: //sdst
987  return 8;
988  default:
989  fatal("op idx %i out of bounds\n", opIdx);
990  return -1;
991  }
992  } // getOperandSize
993 
994  void execute(GPUDynInstPtr) override;
995  }; // Inst_SOP2__S_XNOR_B64
996 
997  class Inst_SOP2__S_LSHL_B32 : public Inst_SOP2
998  {
999  public:
1000  Inst_SOP2__S_LSHL_B32(InFmt_SOP2*);
1001  ~Inst_SOP2__S_LSHL_B32();
1002 
1003  int
1004  getNumOperands() override
1005  {
1006  return numDstRegOperands() + numSrcRegOperands();
1007  } // getNumOperands
1008 
1009  int numDstRegOperands() override { return 1; }
1010  int numSrcRegOperands() override { return 2; }
1011 
1012  int
1013  getOperandSize(int opIdx) override
1014  {
1015  switch (opIdx) {
1016  case 0: //ssrc_0
1017  return 4;
1018  case 1: //ssrc_1
1019  return 4;
1020  case 2: //sdst
1021  return 4;
1022  default:
1023  fatal("op idx %i out of bounds\n", opIdx);
1024  return -1;
1025  }
1026  } // getOperandSize
1027 
1028  void execute(GPUDynInstPtr) override;
1029  }; // Inst_SOP2__S_LSHL_B32
1030 
1031  class Inst_SOP2__S_LSHL_B64 : public Inst_SOP2
1032  {
1033  public:
1034  Inst_SOP2__S_LSHL_B64(InFmt_SOP2*);
1035  ~Inst_SOP2__S_LSHL_B64();
1036 
1037  int
1038  getNumOperands() override
1039  {
1040  return numDstRegOperands() + numSrcRegOperands();
1041  } // getNumOperands
1042 
1043  int numDstRegOperands() override { return 1; }
1044  int numSrcRegOperands() override { return 2; }
1045 
1046  int
1047  getOperandSize(int opIdx) override
1048  {
1049  switch (opIdx) {
1050  case 0: //ssrc_0
1051  return 8;
1052  case 1: //ssrc_1
1053  return 4;
1054  case 2: //sdst
1055  return 8;
1056  default:
1057  fatal("op idx %i out of bounds\n", opIdx);
1058  return -1;
1059  }
1060  } // getOperandSize
1061 
1062  void execute(GPUDynInstPtr) override;
1063  }; // Inst_SOP2__S_LSHL_B64
1064 
1065  class Inst_SOP2__S_LSHR_B32 : public Inst_SOP2
1066  {
1067  public:
1068  Inst_SOP2__S_LSHR_B32(InFmt_SOP2*);
1069  ~Inst_SOP2__S_LSHR_B32();
1070 
1071  int
1072  getNumOperands() override
1073  {
1074  return numDstRegOperands() + numSrcRegOperands();
1075  } // getNumOperands
1076 
1077  int numDstRegOperands() override { return 1; }
1078  int numSrcRegOperands() override { return 2; }
1079 
1080  int
1081  getOperandSize(int opIdx) override
1082  {
1083  switch (opIdx) {
1084  case 0: //ssrc_0
1085  return 4;
1086  case 1: //ssrc_1
1087  return 4;
1088  case 2: //sdst
1089  return 4;
1090  default:
1091  fatal("op idx %i out of bounds\n", opIdx);
1092  return -1;
1093  }
1094  } // getOperandSize
1095 
1096  void execute(GPUDynInstPtr) override;
1097  }; // Inst_SOP2__S_LSHR_B32
1098 
1099  class Inst_SOP2__S_LSHR_B64 : public Inst_SOP2
1100  {
1101  public:
1102  Inst_SOP2__S_LSHR_B64(InFmt_SOP2*);
1103  ~Inst_SOP2__S_LSHR_B64();
1104 
1105  int
1106  getNumOperands() override
1107  {
1108  return numDstRegOperands() + numSrcRegOperands();
1109  } // getNumOperands
1110 
1111  int numDstRegOperands() override { return 1; }
1112  int numSrcRegOperands() override { return 2; }
1113 
1114  int
1115  getOperandSize(int opIdx) override
1116  {
1117  switch (opIdx) {
1118  case 0: //ssrc_0
1119  return 8;
1120  case 1: //ssrc_1
1121  return 4;
1122  case 2: //sdst
1123  return 8;
1124  default:
1125  fatal("op idx %i out of bounds\n", opIdx);
1126  return -1;
1127  }
1128  } // getOperandSize
1129 
1130  void execute(GPUDynInstPtr) override;
1131  }; // Inst_SOP2__S_LSHR_B64
1132 
1133  class Inst_SOP2__S_ASHR_I32 : public Inst_SOP2
1134  {
1135  public:
1136  Inst_SOP2__S_ASHR_I32(InFmt_SOP2*);
1137  ~Inst_SOP2__S_ASHR_I32();
1138 
1139  int
1140  getNumOperands() override
1141  {
1142  return numDstRegOperands() + numSrcRegOperands();
1143  } // getNumOperands
1144 
1145  int numDstRegOperands() override { return 1; }
1146  int numSrcRegOperands() override { return 2; }
1147 
1148  int
1149  getOperandSize(int opIdx) override
1150  {
1151  switch (opIdx) {
1152  case 0: //ssrc_0
1153  return 4;
1154  case 1: //ssrc_1
1155  return 4;
1156  case 2: //sdst
1157  return 4;
1158  default:
1159  fatal("op idx %i out of bounds\n", opIdx);
1160  return -1;
1161  }
1162  } // getOperandSize
1163 
1164  void execute(GPUDynInstPtr) override;
1165  }; // Inst_SOP2__S_ASHR_I32
1166 
1167  class Inst_SOP2__S_ASHR_I64 : public Inst_SOP2
1168  {
1169  public:
1170  Inst_SOP2__S_ASHR_I64(InFmt_SOP2*);
1171  ~Inst_SOP2__S_ASHR_I64();
1172 
1173  int
1174  getNumOperands() override
1175  {
1176  return numDstRegOperands() + numSrcRegOperands();
1177  } // getNumOperands
1178 
1179  int numDstRegOperands() override { return 1; }
1180  int numSrcRegOperands() override { return 2; }
1181 
1182  int
1183  getOperandSize(int opIdx) override
1184  {
1185  switch (opIdx) {
1186  case 0: //ssrc_0
1187  return 8;
1188  case 1: //ssrc_1
1189  return 4;
1190  case 2: //sdst
1191  return 8;
1192  default:
1193  fatal("op idx %i out of bounds\n", opIdx);
1194  return -1;
1195  }
1196  } // getOperandSize
1197 
1198  void execute(GPUDynInstPtr) override;
1199  }; // Inst_SOP2__S_ASHR_I64
1200 
1201  class Inst_SOP2__S_BFM_B32 : public Inst_SOP2
1202  {
1203  public:
1204  Inst_SOP2__S_BFM_B32(InFmt_SOP2*);
1205  ~Inst_SOP2__S_BFM_B32();
1206 
1207  int
1208  getNumOperands() override
1209  {
1210  return numDstRegOperands() + numSrcRegOperands();
1211  } // getNumOperands
1212 
1213  int numDstRegOperands() override { return 1; }
1214  int numSrcRegOperands() override { return 2; }
1215 
1216  int
1217  getOperandSize(int opIdx) override
1218  {
1219  switch (opIdx) {
1220  case 0: //ssrc_0
1221  return 4;
1222  case 1: //ssrc_1
1223  return 4;
1224  case 2: //sdst
1225  return 4;
1226  default:
1227  fatal("op idx %i out of bounds\n", opIdx);
1228  return -1;
1229  }
1230  } // getOperandSize
1231 
1232  void execute(GPUDynInstPtr) override;
1233  }; // Inst_SOP2__S_BFM_B32
1234 
1235  class Inst_SOP2__S_BFM_B64 : public Inst_SOP2
1236  {
1237  public:
1238  Inst_SOP2__S_BFM_B64(InFmt_SOP2*);
1239  ~Inst_SOP2__S_BFM_B64();
1240 
1241  int
1242  getNumOperands() override
1243  {
1244  return numDstRegOperands() + numSrcRegOperands();
1245  } // getNumOperands
1246 
1247  int numDstRegOperands() override { return 1; }
1248  int numSrcRegOperands() override { return 2; }
1249 
1250  int
1251  getOperandSize(int opIdx) override
1252  {
1253  switch (opIdx) {
1254  case 0: //ssrc_0
1255  return 4;
1256  case 1: //ssrc_1
1257  return 4;
1258  case 2: //sdst
1259  return 8;
1260  default:
1261  fatal("op idx %i out of bounds\n", opIdx);
1262  return -1;
1263  }
1264  } // getOperandSize
1265 
1266  void execute(GPUDynInstPtr) override;
1267  }; // Inst_SOP2__S_BFM_B64
1268 
1269  class Inst_SOP2__S_MUL_I32 : public Inst_SOP2
1270  {
1271  public:
1272  Inst_SOP2__S_MUL_I32(InFmt_SOP2*);
1273  ~Inst_SOP2__S_MUL_I32();
1274 
1275  int
1276  getNumOperands() override
1277  {
1278  return numDstRegOperands() + numSrcRegOperands();
1279  } // getNumOperands
1280 
1281  int numDstRegOperands() override { return 1; }
1282  int numSrcRegOperands() override { return 2; }
1283 
1284  int
1285  getOperandSize(int opIdx) override
1286  {
1287  switch (opIdx) {
1288  case 0: //ssrc_0
1289  return 4;
1290  case 1: //ssrc_1
1291  return 4;
1292  case 2: //sdst
1293  return 4;
1294  default:
1295  fatal("op idx %i out of bounds\n", opIdx);
1296  return -1;
1297  }
1298  } // getOperandSize
1299 
1300  void execute(GPUDynInstPtr) override;
1301  }; // Inst_SOP2__S_MUL_I32
1302 
1303  class Inst_SOP2__S_BFE_U32 : public Inst_SOP2
1304  {
1305  public:
1306  Inst_SOP2__S_BFE_U32(InFmt_SOP2*);
1307  ~Inst_SOP2__S_BFE_U32();
1308 
1309  int
1310  getNumOperands() override
1311  {
1312  return numDstRegOperands() + numSrcRegOperands();
1313  } // getNumOperands
1314 
1315  int numDstRegOperands() override { return 1; }
1316  int numSrcRegOperands() override { return 2; }
1317 
1318  int
1319  getOperandSize(int opIdx) override
1320  {
1321  switch (opIdx) {
1322  case 0: //ssrc_0
1323  return 4;
1324  case 1: //ssrc_1
1325  return 4;
1326  case 2: //sdst
1327  return 4;
1328  default:
1329  fatal("op idx %i out of bounds\n", opIdx);
1330  return -1;
1331  }
1332  } // getOperandSize
1333 
1334  void execute(GPUDynInstPtr) override;
1335  }; // Inst_SOP2__S_BFE_U32
1336 
1337  class Inst_SOP2__S_BFE_I32 : public Inst_SOP2
1338  {
1339  public:
1340  Inst_SOP2__S_BFE_I32(InFmt_SOP2*);
1341  ~Inst_SOP2__S_BFE_I32();
1342 
1343  int
1344  getNumOperands() override
1345  {
1346  return numDstRegOperands() + numSrcRegOperands();
1347  } // getNumOperands
1348 
1349  int numDstRegOperands() override { return 1; }
1350  int numSrcRegOperands() override { return 2; }
1351 
1352  int
1353  getOperandSize(int opIdx) override
1354  {
1355  switch (opIdx) {
1356  case 0: //ssrc_0
1357  return 4;
1358  case 1: //ssrc_1
1359  return 4;
1360  case 2: //sdst
1361  return 4;
1362  default:
1363  fatal("op idx %i out of bounds\n", opIdx);
1364  return -1;
1365  }
1366  } // getOperandSize
1367 
1368  void execute(GPUDynInstPtr) override;
1369  }; // Inst_SOP2__S_BFE_I32
1370 
1371  class Inst_SOP2__S_BFE_U64 : public Inst_SOP2
1372  {
1373  public:
1374  Inst_SOP2__S_BFE_U64(InFmt_SOP2*);
1375  ~Inst_SOP2__S_BFE_U64();
1376 
1377  int
1378  getNumOperands() override
1379  {
1380  return numDstRegOperands() + numSrcRegOperands();
1381  } // getNumOperands
1382 
1383  int numDstRegOperands() override { return 1; }
1384  int numSrcRegOperands() override { return 2; }
1385 
1386  int
1387  getOperandSize(int opIdx) override
1388  {
1389  switch (opIdx) {
1390  case 0: //ssrc_0
1391  return 8;
1392  case 1: //ssrc_1
1393  return 4;
1394  case 2: //sdst
1395  return 8;
1396  default:
1397  fatal("op idx %i out of bounds\n", opIdx);
1398  return -1;
1399  }
1400  } // getOperandSize
1401 
1402  void execute(GPUDynInstPtr) override;
1403  }; // Inst_SOP2__S_BFE_U64
1404 
1405  class Inst_SOP2__S_BFE_I64 : public Inst_SOP2
1406  {
1407  public:
1408  Inst_SOP2__S_BFE_I64(InFmt_SOP2*);
1409  ~Inst_SOP2__S_BFE_I64();
1410 
1411  int
1412  getNumOperands() override
1413  {
1414  return numDstRegOperands() + numSrcRegOperands();
1415  } // getNumOperands
1416 
1417  int numDstRegOperands() override { return 1; }
1418  int numSrcRegOperands() override { return 2; }
1419 
1420  int
1421  getOperandSize(int opIdx) override
1422  {
1423  switch (opIdx) {
1424  case 0: //ssrc_0
1425  return 8;
1426  case 1: //ssrc_1
1427  return 4;
1428  case 2: //sdst
1429  return 8;
1430  default:
1431  fatal("op idx %i out of bounds\n", opIdx);
1432  return -1;
1433  }
1434  } // getOperandSize
1435 
1436  void execute(GPUDynInstPtr) override;
1437  }; // Inst_SOP2__S_BFE_I64
1438 
1439  class Inst_SOP2__S_CBRANCH_G_FORK : public Inst_SOP2
1440  {
1441  public:
1442  Inst_SOP2__S_CBRANCH_G_FORK(InFmt_SOP2*);
1443  ~Inst_SOP2__S_CBRANCH_G_FORK();
1444 
1445  int
1446  getNumOperands() override
1447  {
1448  return numDstRegOperands() + numSrcRegOperands();
1449  } // getNumOperands
1450 
1451  int numDstRegOperands() override { return 0; }
1452  int numSrcRegOperands() override { return 2; }
1453 
1454  int
1455  getOperandSize(int opIdx) override
1456  {
1457  switch (opIdx) {
1458  case 0: //ssrc_0
1459  return 8;
1460  case 1: //ssrc_1
1461  return 8;
1462  case 2: //sdst
1463  return 4;
1464  default:
1465  fatal("op idx %i out of bounds\n", opIdx);
1466  return -1;
1467  }
1468  } // getOperandSize
1469 
1470  void execute(GPUDynInstPtr) override;
1471  }; // Inst_SOP2__S_CBRANCH_G_FORK
1472 
1473  class Inst_SOP2__S_ABSDIFF_I32 : public Inst_SOP2
1474  {
1475  public:
1476  Inst_SOP2__S_ABSDIFF_I32(InFmt_SOP2*);
1477  ~Inst_SOP2__S_ABSDIFF_I32();
1478 
1479  int
1480  getNumOperands() override
1481  {
1482  return numDstRegOperands() + numSrcRegOperands();
1483  } // getNumOperands
1484 
1485  int numDstRegOperands() override { return 1; }
1486  int numSrcRegOperands() override { return 2; }
1487 
1488  int
1489  getOperandSize(int opIdx) override
1490  {
1491  switch (opIdx) {
1492  case 0: //ssrc_0
1493  return 4;
1494  case 1: //ssrc_1
1495  return 4;
1496  case 2: //sdst
1497  return 4;
1498  default:
1499  fatal("op idx %i out of bounds\n", opIdx);
1500  return -1;
1501  }
1502  } // getOperandSize
1503 
1504  void execute(GPUDynInstPtr) override;
1505  }; // Inst_SOP2__S_ABSDIFF_I32
1506 
1507  class Inst_SOP2__S_RFE_RESTORE_B64 : public Inst_SOP2
1508  {
1509  public:
1510  Inst_SOP2__S_RFE_RESTORE_B64(InFmt_SOP2*);
1511  ~Inst_SOP2__S_RFE_RESTORE_B64();
1512 
1513  int
1514  getNumOperands() override
1515  {
1516  return numDstRegOperands() + numSrcRegOperands();
1517  } // getNumOperands
1518 
1519  int numDstRegOperands() override { return 0; }
1520  int numSrcRegOperands() override { return 2; }
1521 
1522  int
1523  getOperandSize(int opIdx) override
1524  {
1525  switch (opIdx) {
1526  case 0: //ssrc_0
1527  return 8;
1528  case 1: //ssrc_1
1529  return 4;
1530  case 2: //sdst
1531  return 4;
1532  default:
1533  fatal("op idx %i out of bounds\n", opIdx);
1534  return -1;
1535  }
1536  } // getOperandSize
1537 
1538  void execute(GPUDynInstPtr) override;
1539  }; // Inst_SOP2__S_RFE_RESTORE_B64
1540 
1541  class Inst_SOP2__S_MUL_HI_U32 : public Inst_SOP2
1542  {
1543  public:
1544  Inst_SOP2__S_MUL_HI_U32(InFmt_SOP2*);
1545  ~Inst_SOP2__S_MUL_HI_U32();
1546 
1547  int
1548  getNumOperands() override
1549  {
1550  return numDstRegOperands() + numSrcRegOperands();
1551  } // getNumOperands
1552 
1553  int numDstRegOperands() override { return 1; }
1554  int numSrcRegOperands() override { return 2; }
1555 
1556  int
1557  getOperandSize(int opIdx) override
1558  {
1559  switch (opIdx) {
1560  case 0: //ssrc_0
1561  return 4;
1562  case 1: //ssrc_1
1563  return 4;
1564  case 2: //sdst
1565  return 4;
1566  default:
1567  fatal("op idx %i out of bounds\n", opIdx);
1568  return -1;
1569  }
1570  } // getOperandSize
1571 
1572  void execute(GPUDynInstPtr) override;
1573  }; // Inst_SOP2__S_MUL_HI_U32
1574 
1575  class Inst_SOP2__S_MUL_HI_I32 : public Inst_SOP2
1576  {
1577  public:
1578  Inst_SOP2__S_MUL_HI_I32(InFmt_SOP2*);
1579  ~Inst_SOP2__S_MUL_HI_I32();
1580 
1581  int
1582  getNumOperands() override
1583  {
1584  return numDstRegOperands() + numSrcRegOperands();
1585  } // getNumOperands
1586 
1587  int numDstRegOperands() override { return 1; }
1588  int numSrcRegOperands() override { return 2; }
1589 
1590  int
1591  getOperandSize(int opIdx) override
1592  {
1593  switch (opIdx) {
1594  case 0: //ssrc_0
1595  return 4;
1596  case 1: //ssrc_1
1597  return 4;
1598  case 2: //sdst
1599  return 4;
1600  default:
1601  fatal("op idx %i out of bounds\n", opIdx);
1602  return -1;
1603  }
1604  } // getOperandSize
1605 
1606  void execute(GPUDynInstPtr) override;
1607  }; // Inst_SOP2__S_MUL_HI_I32
1608 
1609  class Inst_SOPK__S_MOVK_I32 : public Inst_SOPK
1610  {
1611  public:
1612  Inst_SOPK__S_MOVK_I32(InFmt_SOPK*);
1613  ~Inst_SOPK__S_MOVK_I32();
1614 
1615  int
1616  getNumOperands() override
1617  {
1618  return numDstRegOperands() + numSrcRegOperands();
1619  } // getNumOperands
1620 
1621  int numDstRegOperands() override { return 1; }
1622  int numSrcRegOperands() override { return 1; }
1623 
1624  int
1625  getOperandSize(int opIdx) override
1626  {
1627  switch (opIdx) {
1628  case 0: //simm16
1629  return 2;
1630  case 1: //sdst
1631  return 4;
1632  default:
1633  fatal("op idx %i out of bounds\n", opIdx);
1634  return -1;
1635  }
1636  } // getOperandSize
1637 
1638  void execute(GPUDynInstPtr) override;
1639  }; // Inst_SOPK__S_MOVK_I32
1640 
1641  class Inst_SOPK__S_CMOVK_I32 : public Inst_SOPK
1642  {
1643  public:
1644  Inst_SOPK__S_CMOVK_I32(InFmt_SOPK*);
1645  ~Inst_SOPK__S_CMOVK_I32();
1646 
1647  int
1648  getNumOperands() override
1649  {
1650  return numDstRegOperands() + numSrcRegOperands();
1651  } // getNumOperands
1652 
1653  int numDstRegOperands() override { return 1; }
1654  int numSrcRegOperands() override { return 1; }
1655 
1656  int
1657  getOperandSize(int opIdx) override
1658  {
1659  switch (opIdx) {
1660  case 0: //simm16
1661  return 2;
1662  case 1: //sdst
1663  return 4;
1664  default:
1665  fatal("op idx %i out of bounds\n", opIdx);
1666  return -1;
1667  }
1668  } // getOperandSize
1669 
1670  void execute(GPUDynInstPtr) override;
1671  }; // Inst_SOPK__S_CMOVK_I32
1672 
1673  class Inst_SOPK__S_CMPK_EQ_I32 : public Inst_SOPK
1674  {
1675  public:
1676  Inst_SOPK__S_CMPK_EQ_I32(InFmt_SOPK*);
1677  ~Inst_SOPK__S_CMPK_EQ_I32();
1678 
1679  int
1680  getNumOperands() override
1681  {
1682  return numDstRegOperands() + numSrcRegOperands();
1683  } // getNumOperands
1684 
1685  int numDstRegOperands() override { return 0; }
1686  int numSrcRegOperands() override { return 2; }
1687 
1688  int
1689  getOperandSize(int opIdx) override
1690  {
1691  switch (opIdx) {
1692  case 0: //ssrc
1693  return 4;
1694  case 1: //simm16
1695  return 2;
1696  default:
1697  fatal("op idx %i out of bounds\n", opIdx);
1698  return -1;
1699  }
1700  } // getOperandSize
1701 
1702  void execute(GPUDynInstPtr) override;
1703  }; // Inst_SOPK__S_CMPK_EQ_I32
1704 
1705  class Inst_SOPK__S_CMPK_LG_I32 : public Inst_SOPK
1706  {
1707  public:
1708  Inst_SOPK__S_CMPK_LG_I32(InFmt_SOPK*);
1709  ~Inst_SOPK__S_CMPK_LG_I32();
1710 
1711  int
1712  getNumOperands() override
1713  {
1714  return numDstRegOperands() + numSrcRegOperands();
1715  } // getNumOperands
1716 
1717  int numDstRegOperands() override { return 0; }
1718  int numSrcRegOperands() override { return 2; }
1719 
1720  int
1721  getOperandSize(int opIdx) override
1722  {
1723  switch (opIdx) {
1724  case 0: //ssrc
1725  return 4;
1726  case 1: //simm16
1727  return 2;
1728  default:
1729  fatal("op idx %i out of bounds\n", opIdx);
1730  return -1;
1731  }
1732  } // getOperandSize
1733 
1734  void execute(GPUDynInstPtr) override;
1735  }; // Inst_SOPK__S_CMPK_LG_I32
1736 
1737  class Inst_SOPK__S_CMPK_GT_I32 : public Inst_SOPK
1738  {
1739  public:
1740  Inst_SOPK__S_CMPK_GT_I32(InFmt_SOPK*);
1741  ~Inst_SOPK__S_CMPK_GT_I32();
1742 
1743  int
1744  getNumOperands() override
1745  {
1746  return numDstRegOperands() + numSrcRegOperands();
1747  } // getNumOperands
1748 
1749  int numDstRegOperands() override { return 0; }
1750  int numSrcRegOperands() override { return 2; }
1751 
1752  int
1753  getOperandSize(int opIdx) override
1754  {
1755  switch (opIdx) {
1756  case 0: //ssrc
1757  return 4;
1758  case 1: //simm16
1759  return 2;
1760  default:
1761  fatal("op idx %i out of bounds\n", opIdx);
1762  return -1;
1763  }
1764  } // getOperandSize
1765 
1766  void execute(GPUDynInstPtr) override;
1767  }; // Inst_SOPK__S_CMPK_GT_I32
1768 
1769  class Inst_SOPK__S_CMPK_GE_I32 : public Inst_SOPK
1770  {
1771  public:
1772  Inst_SOPK__S_CMPK_GE_I32(InFmt_SOPK*);
1773  ~Inst_SOPK__S_CMPK_GE_I32();
1774 
1775  int
1776  getNumOperands() override
1777  {
1778  return numDstRegOperands() + numSrcRegOperands();
1779  } // getNumOperands
1780 
1781  int numDstRegOperands() override { return 0; }
1782  int numSrcRegOperands() override { return 2; }
1783 
1784  int
1785  getOperandSize(int opIdx) override
1786  {
1787  switch (opIdx) {
1788  case 0: //ssrc
1789  return 4;
1790  case 1: //simm16
1791  return 2;
1792  default:
1793  fatal("op idx %i out of bounds\n", opIdx);
1794  return -1;
1795  }
1796  } // getOperandSize
1797 
1798  void execute(GPUDynInstPtr) override;
1799  }; // Inst_SOPK__S_CMPK_GE_I32
1800 
1801  class Inst_SOPK__S_CMPK_LT_I32 : public Inst_SOPK
1802  {
1803  public:
1804  Inst_SOPK__S_CMPK_LT_I32(InFmt_SOPK*);
1805  ~Inst_SOPK__S_CMPK_LT_I32();
1806 
1807  int
1808  getNumOperands() override
1809  {
1810  return numDstRegOperands() + numSrcRegOperands();
1811  } // getNumOperands
1812 
1813  int numDstRegOperands() override { return 0; }
1814  int numSrcRegOperands() override { return 2; }
1815 
1816  int
1817  getOperandSize(int opIdx) override
1818  {
1819  switch (opIdx) {
1820  case 0: //ssrc
1821  return 4;
1822  case 1: //simm16
1823  return 2;
1824  default:
1825  fatal("op idx %i out of bounds\n", opIdx);
1826  return -1;
1827  }
1828  } // getOperandSize
1829 
1830  void execute(GPUDynInstPtr) override;
1831  }; // Inst_SOPK__S_CMPK_LT_I32
1832 
1833  class Inst_SOPK__S_CMPK_LE_I32 : public Inst_SOPK
1834  {
1835  public:
1836  Inst_SOPK__S_CMPK_LE_I32(InFmt_SOPK*);
1837  ~Inst_SOPK__S_CMPK_LE_I32();
1838 
1839  int
1840  getNumOperands() override
1841  {
1842  return numDstRegOperands() + numSrcRegOperands();
1843  } // getNumOperands
1844 
1845  int numDstRegOperands() override { return 0; }
1846  int numSrcRegOperands() override { return 2; }
1847 
1848  int
1849  getOperandSize(int opIdx) override
1850  {
1851  switch (opIdx) {
1852  case 0: //ssrc
1853  return 4;
1854  case 1: //simm16
1855  return 2;
1856  default:
1857  fatal("op idx %i out of bounds\n", opIdx);
1858  return -1;
1859  }
1860  } // getOperandSize
1861 
1862  void execute(GPUDynInstPtr) override;
1863  }; // Inst_SOPK__S_CMPK_LE_I32
1864 
1865  class Inst_SOPK__S_CMPK_EQ_U32 : public Inst_SOPK
1866  {
1867  public:
1868  Inst_SOPK__S_CMPK_EQ_U32(InFmt_SOPK*);
1869  ~Inst_SOPK__S_CMPK_EQ_U32();
1870 
1871  int
1872  getNumOperands() override
1873  {
1874  return numDstRegOperands() + numSrcRegOperands();
1875  } // getNumOperands
1876 
1877  int numDstRegOperands() override { return 0; }
1878  int numSrcRegOperands() override { return 2; }
1879 
1880  int
1881  getOperandSize(int opIdx) override
1882  {
1883  switch (opIdx) {
1884  case 0: //ssrc
1885  return 4;
1886  case 1: //simm16
1887  return 2;
1888  default:
1889  fatal("op idx %i out of bounds\n", opIdx);
1890  return -1;
1891  }
1892  } // getOperandSize
1893 
1894  void execute(GPUDynInstPtr) override;
1895  }; // Inst_SOPK__S_CMPK_EQ_U32
1896 
1897  class Inst_SOPK__S_CMPK_LG_U32 : public Inst_SOPK
1898  {
1899  public:
1900  Inst_SOPK__S_CMPK_LG_U32(InFmt_SOPK*);
1901  ~Inst_SOPK__S_CMPK_LG_U32();
1902 
1903  int
1904  getNumOperands() override
1905  {
1906  return numDstRegOperands() + numSrcRegOperands();
1907  } // getNumOperands
1908 
1909  int numDstRegOperands() override { return 0; }
1910  int numSrcRegOperands() override { return 2; }
1911 
1912  int
1913  getOperandSize(int opIdx) override
1914  {
1915  switch (opIdx) {
1916  case 0: //ssrc
1917  return 4;
1918  case 1: //simm16
1919  return 2;
1920  default:
1921  fatal("op idx %i out of bounds\n", opIdx);
1922  return -1;
1923  }
1924  } // getOperandSize
1925 
1926  void execute(GPUDynInstPtr) override;
1927  }; // Inst_SOPK__S_CMPK_LG_U32
1928 
1929  class Inst_SOPK__S_CMPK_GT_U32 : public Inst_SOPK
1930  {
1931  public:
1932  Inst_SOPK__S_CMPK_GT_U32(InFmt_SOPK*);
1933  ~Inst_SOPK__S_CMPK_GT_U32();
1934 
1935  int
1936  getNumOperands() override
1937  {
1938  return numDstRegOperands() + numSrcRegOperands();
1939  } // getNumOperands
1940 
1941  int numDstRegOperands() override { return 0; }
1942  int numSrcRegOperands() override { return 2; }
1943 
1944  int
1945  getOperandSize(int opIdx) override
1946  {
1947  switch (opIdx) {
1948  case 0: //ssrc
1949  return 4;
1950  case 1: //simm16
1951  return 2;
1952  default:
1953  fatal("op idx %i out of bounds\n", opIdx);
1954  return -1;
1955  }
1956  } // getOperandSize
1957 
1958  void execute(GPUDynInstPtr) override;
1959  }; // Inst_SOPK__S_CMPK_GT_U32
1960 
1961  class Inst_SOPK__S_CMPK_GE_U32 : public Inst_SOPK
1962  {
1963  public:
1964  Inst_SOPK__S_CMPK_GE_U32(InFmt_SOPK*);
1965  ~Inst_SOPK__S_CMPK_GE_U32();
1966 
1967  int
1968  getNumOperands() override
1969  {
1970  return numDstRegOperands() + numSrcRegOperands();
1971  } // getNumOperands
1972 
1973  int numDstRegOperands() override { return 0; }
1974  int numSrcRegOperands() override { return 2; }
1975 
1976  int
1977  getOperandSize(int opIdx) override
1978  {
1979  switch (opIdx) {
1980  case 0: //ssrc
1981  return 4;
1982  case 1: //simm16
1983  return 2;
1984  default:
1985  fatal("op idx %i out of bounds\n", opIdx);
1986  return -1;
1987  }
1988  } // getOperandSize
1989 
1990  void execute(GPUDynInstPtr) override;
1991  }; // Inst_SOPK__S_CMPK_GE_U32
1992 
1993  class Inst_SOPK__S_CMPK_LT_U32 : public Inst_SOPK
1994  {
1995  public:
1996  Inst_SOPK__S_CMPK_LT_U32(InFmt_SOPK*);
1997  ~Inst_SOPK__S_CMPK_LT_U32();
1998 
1999  int
2000  getNumOperands() override
2001  {
2002  return numDstRegOperands() + numSrcRegOperands();
2003  } // getNumOperands
2004 
2005  int numDstRegOperands() override { return 0; }
2006  int numSrcRegOperands() override { return 2; }
2007 
2008  int
2009  getOperandSize(int opIdx) override
2010  {
2011  switch (opIdx) {
2012  case 0: //ssrc
2013  return 4;
2014  case 1: //simm16
2015  return 2;
2016  default:
2017  fatal("op idx %i out of bounds\n", opIdx);
2018  return -1;
2019  }
2020  } // getOperandSize
2021 
2022  void execute(GPUDynInstPtr) override;
2023  }; // Inst_SOPK__S_CMPK_LT_U32
2024 
2025  class Inst_SOPK__S_CMPK_LE_U32 : public Inst_SOPK
2026  {
2027  public:
2028  Inst_SOPK__S_CMPK_LE_U32(InFmt_SOPK*);
2029  ~Inst_SOPK__S_CMPK_LE_U32();
2030 
2031  int
2032  getNumOperands() override
2033  {
2034  return numDstRegOperands() + numSrcRegOperands();
2035  } // getNumOperands
2036 
2037  int numDstRegOperands() override { return 0; }
2038  int numSrcRegOperands() override { return 2; }
2039 
2040  int
2041  getOperandSize(int opIdx) override
2042  {
2043  switch (opIdx) {
2044  case 0: //ssrc
2045  return 4;
2046  case 1: //simm16
2047  return 2;
2048  default:
2049  fatal("op idx %i out of bounds\n", opIdx);
2050  return -1;
2051  }
2052  } // getOperandSize
2053 
2054  void execute(GPUDynInstPtr) override;
2055  }; // Inst_SOPK__S_CMPK_LE_U32
2056 
2057  class Inst_SOPK__S_ADDK_I32 : public Inst_SOPK
2058  {
2059  public:
2060  Inst_SOPK__S_ADDK_I32(InFmt_SOPK*);
2061  ~Inst_SOPK__S_ADDK_I32();
2062 
2063  int
2064  getNumOperands() override
2065  {
2066  return numDstRegOperands() + numSrcRegOperands();
2067  } // getNumOperands
2068 
2069  int numDstRegOperands() override { return 1; }
2070  int numSrcRegOperands() override { return 1; }
2071 
2072  int
2073  getOperandSize(int opIdx) override
2074  {
2075  switch (opIdx) {
2076  case 0: //simm16
2077  return 2;
2078  case 1: //sdst
2079  return 4;
2080  default:
2081  fatal("op idx %i out of bounds\n", opIdx);
2082  return -1;
2083  }
2084  } // getOperandSize
2085 
2086  void execute(GPUDynInstPtr) override;
2087  }; // Inst_SOPK__S_ADDK_I32
2088 
2089  class Inst_SOPK__S_MULK_I32 : public Inst_SOPK
2090  {
2091  public:
2092  Inst_SOPK__S_MULK_I32(InFmt_SOPK*);
2093  ~Inst_SOPK__S_MULK_I32();
2094 
2095  int
2096  getNumOperands() override
2097  {
2098  return numDstRegOperands() + numSrcRegOperands();
2099  } // getNumOperands
2100 
2101  int numDstRegOperands() override { return 1; }
2102  int numSrcRegOperands() override { return 1; }
2103 
2104  int
2105  getOperandSize(int opIdx) override
2106  {
2107  switch (opIdx) {
2108  case 0: //simm16
2109  return 2;
2110  case 1: //sdst
2111  return 4;
2112  default:
2113  fatal("op idx %i out of bounds\n", opIdx);
2114  return -1;
2115  }
2116  } // getOperandSize
2117 
2118  void execute(GPUDynInstPtr) override;
2119  }; // Inst_SOPK__S_MULK_I32
2120 
2121  class Inst_SOPK__S_CBRANCH_I_FORK : public Inst_SOPK
2122  {
2123  public:
2124  Inst_SOPK__S_CBRANCH_I_FORK(InFmt_SOPK*);
2125  ~Inst_SOPK__S_CBRANCH_I_FORK();
2126 
2127  int
2128  getNumOperands() override
2129  {
2130  return numDstRegOperands() + numSrcRegOperands();
2131  } // getNumOperands
2132 
2133  int numDstRegOperands() override { return 0; }
2134  int numSrcRegOperands() override { return 2; }
2135 
2136  int
2137  getOperandSize(int opIdx) override
2138  {
2139  switch (opIdx) {
2140  case 0: //sdst
2141  return 8;
2142  case 1: //
2143  return 16;
2144  default:
2145  fatal("op idx %i out of bounds\n", opIdx);
2146  return -1;
2147  }
2148  } // getOperandSize
2149 
2150  void execute(GPUDynInstPtr) override;
2151  }; // Inst_SOPK__S_CBRANCH_I_FORK
2152 
2153  class Inst_SOPK__S_GETREG_B32 : public Inst_SOPK
2154  {
2155  public:
2156  Inst_SOPK__S_GETREG_B32(InFmt_SOPK*);
2157  ~Inst_SOPK__S_GETREG_B32();
2158 
2159  int
2160  getNumOperands() override
2161  {
2162  return numDstRegOperands() + numSrcRegOperands();
2163  } // getNumOperands
2164 
2165  int numDstRegOperands() override { return 1; }
2166  int numSrcRegOperands() override { return 1; }
2167 
2168  int
2169  getOperandSize(int opIdx) override
2170  {
2171  switch (opIdx) {
2172  case 0: //simm16
2173  return 2;
2174  case 1: //sdst
2175  return 4;
2176  default:
2177  fatal("op idx %i out of bounds\n", opIdx);
2178  return -1;
2179  }
2180  } // getOperandSize
2181 
2182  void execute(GPUDynInstPtr) override;
2183  }; // Inst_SOPK__S_GETREG_B32
2184 
2185  class Inst_SOPK__S_SETREG_B32 : public Inst_SOPK
2186  {
2187  public:
2188  Inst_SOPK__S_SETREG_B32(InFmt_SOPK*);
2189  ~Inst_SOPK__S_SETREG_B32();
2190 
2191  int
2192  getNumOperands() override
2193  {
2194  return numDstRegOperands() + numSrcRegOperands();
2195  } // getNumOperands
2196 
2197  int numDstRegOperands() override { return 1; }
2198  int numSrcRegOperands() override { return 1; }
2199 
2200  int
2201  getOperandSize(int opIdx) override
2202  {
2203  switch (opIdx) {
2204  case 0: //ssrc
2205  return 4;
2206  case 1: //simm16
2207  return 2;
2208  default:
2209  fatal("op idx %i out of bounds\n", opIdx);
2210  return -1;
2211  }
2212  } // getOperandSize
2213 
2214  void execute(GPUDynInstPtr) override;
2215  }; // Inst_SOPK__S_SETREG_B32
2216 
2217  class Inst_SOPK__S_SETREG_IMM32_B32 : public Inst_SOPK
2218  {
2219  public:
2220  Inst_SOPK__S_SETREG_IMM32_B32(InFmt_SOPK*);
2221  ~Inst_SOPK__S_SETREG_IMM32_B32();
2222 
2223  int
2224  getNumOperands() override
2225  {
2226  return numDstRegOperands() + numSrcRegOperands();
2227  } // getNumOperands
2228 
2229  int numDstRegOperands() override { return 1; }
2230  int numSrcRegOperands() override { return 1; }
2231 
2232  int
2233  getOperandSize(int opIdx) override
2234  {
2235  switch (opIdx) {
2236  case 0: //simm32
2237  return 4;
2238  case 1: //simm16
2239  return 2;
2240  default:
2241  fatal("op idx %i out of bounds\n", opIdx);
2242  return -1;
2243  }
2244  } // getOperandSize
2245 
2246  void execute(GPUDynInstPtr) override;
2247  }; // Inst_SOPK__S_SETREG_IMM32_B32
2248 
2249  class Inst_SOP1__S_MOV_B32 : public Inst_SOP1
2250  {
2251  public:
2252  Inst_SOP1__S_MOV_B32(InFmt_SOP1*);
2253  ~Inst_SOP1__S_MOV_B32();
2254 
2255  int
2256  getNumOperands() override
2257  {
2258  return numDstRegOperands() + numSrcRegOperands();
2259  } // getNumOperands
2260 
2261  int numDstRegOperands() override { return 1; }
2262  int numSrcRegOperands() override { return 1; }
2263 
2264  int
2265  getOperandSize(int opIdx) override
2266  {
2267  switch (opIdx) {
2268  case 0: //ssrc
2269  return 4;
2270  case 1: //sdst
2271  return 4;
2272  default:
2273  fatal("op idx %i out of bounds\n", opIdx);
2274  return -1;
2275  }
2276  } // getOperandSize
2277 
2278  void execute(GPUDynInstPtr) override;
2279  }; // Inst_SOP1__S_MOV_B32
2280 
2281  class Inst_SOP1__S_MOV_B64 : public Inst_SOP1
2282  {
2283  public:
2284  Inst_SOP1__S_MOV_B64(InFmt_SOP1*);
2285  ~Inst_SOP1__S_MOV_B64();
2286 
2287  int
2288  getNumOperands() override
2289  {
2290  return numDstRegOperands() + numSrcRegOperands();
2291  } // getNumOperands
2292 
2293  int numDstRegOperands() override { return 1; }
2294  int numSrcRegOperands() override { return 1; }
2295 
2296  int
2297  getOperandSize(int opIdx) override
2298  {
2299  switch (opIdx) {
2300  case 0: //ssrc
2301  return 8;
2302  case 1: //sdst
2303  return 8;
2304  default:
2305  fatal("op idx %i out of bounds\n", opIdx);
2306  return -1;
2307  }
2308  } // getOperandSize
2309 
2310  void execute(GPUDynInstPtr) override;
2311  }; // Inst_SOP1__S_MOV_B64
2312 
2313  class Inst_SOP1__S_CMOV_B32 : public Inst_SOP1
2314  {
2315  public:
2316  Inst_SOP1__S_CMOV_B32(InFmt_SOP1*);
2317  ~Inst_SOP1__S_CMOV_B32();
2318 
2319  int
2320  getNumOperands() override
2321  {
2322  return numDstRegOperands() + numSrcRegOperands();
2323  } // getNumOperands
2324 
2325  int numDstRegOperands() override { return 1; }
2326  int numSrcRegOperands() override { return 1; }
2327 
2328  int
2329  getOperandSize(int opIdx) override
2330  {
2331  switch (opIdx) {
2332  case 0: //ssrc
2333  return 4;
2334  case 1: //sdst
2335  return 4;
2336  default:
2337  fatal("op idx %i out of bounds\n", opIdx);
2338  return -1;
2339  }
2340  } // getOperandSize
2341 
2342  void execute(GPUDynInstPtr) override;
2343  }; // Inst_SOP1__S_CMOV_B32
2344 
2345  class Inst_SOP1__S_CMOV_B64 : public Inst_SOP1
2346  {
2347  public:
2348  Inst_SOP1__S_CMOV_B64(InFmt_SOP1*);
2349  ~Inst_SOP1__S_CMOV_B64();
2350 
2351  int
2352  getNumOperands() override
2353  {
2354  return numDstRegOperands() + numSrcRegOperands();
2355  } // getNumOperands
2356 
2357  int numDstRegOperands() override { return 1; }
2358  int numSrcRegOperands() override { return 1; }
2359 
2360  int
2361  getOperandSize(int opIdx) override
2362  {
2363  switch (opIdx) {
2364  case 0: //ssrc
2365  return 8;
2366  case 1: //sdst
2367  return 8;
2368  default:
2369  fatal("op idx %i out of bounds\n", opIdx);
2370  return -1;
2371  }
2372  } // getOperandSize
2373 
2374  void execute(GPUDynInstPtr) override;
2375  }; // Inst_SOP1__S_CMOV_B64
2376 
2377  class Inst_SOP1__S_NOT_B32 : public Inst_SOP1
2378  {
2379  public:
2380  Inst_SOP1__S_NOT_B32(InFmt_SOP1*);
2381  ~Inst_SOP1__S_NOT_B32();
2382 
2383  int
2384  getNumOperands() override
2385  {
2386  return numDstRegOperands() + numSrcRegOperands();
2387  } // getNumOperands
2388 
2389  int numDstRegOperands() override { return 1; }
2390  int numSrcRegOperands() override { return 1; }
2391 
2392  int
2393  getOperandSize(int opIdx) override
2394  {
2395  switch (opIdx) {
2396  case 0: //ssrc
2397  return 4;
2398  case 1: //sdst
2399  return 4;
2400  default:
2401  fatal("op idx %i out of bounds\n", opIdx);
2402  return -1;
2403  }
2404  } // getOperandSize
2405 
2406  void execute(GPUDynInstPtr) override;
2407  }; // Inst_SOP1__S_NOT_B32
2408 
2409  class Inst_SOP1__S_NOT_B64 : public Inst_SOP1
2410  {
2411  public:
2412  Inst_SOP1__S_NOT_B64(InFmt_SOP1*);
2413  ~Inst_SOP1__S_NOT_B64();
2414 
2415  int
2416  getNumOperands() override
2417  {
2418  return numDstRegOperands() + numSrcRegOperands();
2419  } // getNumOperands
2420 
2421  int numDstRegOperands() override { return 1; }
2422  int numSrcRegOperands() override { return 1; }
2423 
2424  int
2425  getOperandSize(int opIdx) override
2426  {
2427  switch (opIdx) {
2428  case 0: //ssrc
2429  return 8;
2430  case 1: //sdst
2431  return 8;
2432  default:
2433  fatal("op idx %i out of bounds\n", opIdx);
2434  return -1;
2435  }
2436  } // getOperandSize
2437 
2438  void execute(GPUDynInstPtr) override;
2439  }; // Inst_SOP1__S_NOT_B64
2440 
2441  class Inst_SOP1__S_WQM_B32 : public Inst_SOP1
2442  {
2443  public:
2444  Inst_SOP1__S_WQM_B32(InFmt_SOP1*);
2445  ~Inst_SOP1__S_WQM_B32();
2446 
2447  int
2448  getNumOperands() override
2449  {
2450  return numDstRegOperands() + numSrcRegOperands();
2451  } // getNumOperands
2452 
2453  int numDstRegOperands() override { return 1; }
2454  int numSrcRegOperands() override { return 1; }
2455 
2456  int
2457  getOperandSize(int opIdx) override
2458  {
2459  switch (opIdx) {
2460  case 0: //ssrc
2461  return 4;
2462  case 1: //sdst
2463  return 4;
2464  default:
2465  fatal("op idx %i out of bounds\n", opIdx);
2466  return -1;
2467  }
2468  } // getOperandSize
2469 
2470  void execute(GPUDynInstPtr) override;
2471  }; // Inst_SOP1__S_WQM_B32
2472 
2473  class Inst_SOP1__S_WQM_B64 : public Inst_SOP1
2474  {
2475  public:
2476  Inst_SOP1__S_WQM_B64(InFmt_SOP1*);
2477  ~Inst_SOP1__S_WQM_B64();
2478 
2479  int
2480  getNumOperands() override
2481  {
2482  return numDstRegOperands() + numSrcRegOperands();
2483  } // getNumOperands
2484 
2485  int numDstRegOperands() override { return 1; }
2486  int numSrcRegOperands() override { return 1; }
2487 
2488  int
2489  getOperandSize(int opIdx) override
2490  {
2491  switch (opIdx) {
2492  case 0: //ssrc
2493  return 8;
2494  case 1: //sdst
2495  return 8;
2496  default:
2497  fatal("op idx %i out of bounds\n", opIdx);
2498  return -1;
2499  }
2500  } // getOperandSize
2501 
2502  void execute(GPUDynInstPtr) override;
2503  }; // Inst_SOP1__S_WQM_B64
2504 
2505  class Inst_SOP1__S_BREV_B32 : public Inst_SOP1
2506  {
2507  public:
2508  Inst_SOP1__S_BREV_B32(InFmt_SOP1*);
2509  ~Inst_SOP1__S_BREV_B32();
2510 
2511  int
2512  getNumOperands() override
2513  {
2514  return numDstRegOperands() + numSrcRegOperands();
2515  } // getNumOperands
2516 
2517  int numDstRegOperands() override { return 1; }
2518  int numSrcRegOperands() override { return 1; }
2519 
2520  int
2521  getOperandSize(int opIdx) override
2522  {
2523  switch (opIdx) {
2524  case 0: //ssrc
2525  return 4;
2526  case 1: //sdst
2527  return 4;
2528  default:
2529  fatal("op idx %i out of bounds\n", opIdx);
2530  return -1;
2531  }
2532  } // getOperandSize
2533 
2534  void execute(GPUDynInstPtr) override;
2535  }; // Inst_SOP1__S_BREV_B32
2536 
2537  class Inst_SOP1__S_BREV_B64 : public Inst_SOP1
2538  {
2539  public:
2540  Inst_SOP1__S_BREV_B64(InFmt_SOP1*);
2541  ~Inst_SOP1__S_BREV_B64();
2542 
2543  int
2544  getNumOperands() override
2545  {
2546  return numDstRegOperands() + numSrcRegOperands();
2547  } // getNumOperands
2548 
2549  int numDstRegOperands() override { return 1; }
2550  int numSrcRegOperands() override { return 1; }
2551 
2552  int
2553  getOperandSize(int opIdx) override
2554  {
2555  switch (opIdx) {
2556  case 0: //ssrc
2557  return 8;
2558  case 1: //sdst
2559  return 8;
2560  default:
2561  fatal("op idx %i out of bounds\n", opIdx);
2562  return -1;
2563  }
2564  } // getOperandSize
2565 
2566  void execute(GPUDynInstPtr) override;
2567  }; // Inst_SOP1__S_BREV_B64
2568 
2569  class Inst_SOP1__S_BCNT0_I32_B32 : public Inst_SOP1
2570  {
2571  public:
2572  Inst_SOP1__S_BCNT0_I32_B32(InFmt_SOP1*);
2573  ~Inst_SOP1__S_BCNT0_I32_B32();
2574 
2575  int
2576  getNumOperands() override
2577  {
2578  return numDstRegOperands() + numSrcRegOperands();
2579  } // getNumOperands
2580 
2581  int numDstRegOperands() override { return 1; }
2582  int numSrcRegOperands() override { return 1; }
2583 
2584  int
2585  getOperandSize(int opIdx) override
2586  {
2587  switch (opIdx) {
2588  case 0: //ssrc
2589  return 4;
2590  case 1: //sdst
2591  return 4;
2592  default:
2593  fatal("op idx %i out of bounds\n", opIdx);
2594  return -1;
2595  }
2596  } // getOperandSize
2597 
2598  void execute(GPUDynInstPtr) override;
2599  }; // Inst_SOP1__S_BCNT0_I32_B32
2600 
2601  class Inst_SOP1__S_BCNT0_I32_B64 : public Inst_SOP1
2602  {
2603  public:
2604  Inst_SOP1__S_BCNT0_I32_B64(InFmt_SOP1*);
2605  ~Inst_SOP1__S_BCNT0_I32_B64();
2606 
2607  int
2608  getNumOperands() override
2609  {
2610  return numDstRegOperands() + numSrcRegOperands();
2611  } // getNumOperands
2612 
2613  int numDstRegOperands() override { return 1; }
2614  int numSrcRegOperands() override { return 1; }
2615 
2616  int
2617  getOperandSize(int opIdx) override
2618  {
2619  switch (opIdx) {
2620  case 0: //ssrc
2621  return 8;
2622  case 1: //sdst
2623  return 4;
2624  default:
2625  fatal("op idx %i out of bounds\n", opIdx);
2626  return -1;
2627  }
2628  } // getOperandSize
2629 
2630  void execute(GPUDynInstPtr) override;
2631  }; // Inst_SOP1__S_BCNT0_I32_B64
2632 
2633  class Inst_SOP1__S_BCNT1_I32_B32 : public Inst_SOP1
2634  {
2635  public:
2636  Inst_SOP1__S_BCNT1_I32_B32(InFmt_SOP1*);
2637  ~Inst_SOP1__S_BCNT1_I32_B32();
2638 
2639  int
2640  getNumOperands() override
2641  {
2642  return numDstRegOperands() + numSrcRegOperands();
2643  } // getNumOperands
2644 
2645  int numDstRegOperands() override { return 1; }
2646  int numSrcRegOperands() override { return 1; }
2647 
2648  int
2649  getOperandSize(int opIdx) override
2650  {
2651  switch (opIdx) {
2652  case 0: //ssrc
2653  return 4;
2654  case 1: //sdst
2655  return 4;
2656  default:
2657  fatal("op idx %i out of bounds\n", opIdx);
2658  return -1;
2659  }
2660  } // getOperandSize
2661 
2662  void execute(GPUDynInstPtr) override;
2663  }; // Inst_SOP1__S_BCNT1_I32_B32
2664 
2665  class Inst_SOP1__S_BCNT1_I32_B64 : public Inst_SOP1
2666  {
2667  public:
2668  Inst_SOP1__S_BCNT1_I32_B64(InFmt_SOP1*);
2669  ~Inst_SOP1__S_BCNT1_I32_B64();
2670 
2671  int
2672  getNumOperands() override
2673  {
2674  return numDstRegOperands() + numSrcRegOperands();
2675  } // getNumOperands
2676 
2677  int numDstRegOperands() override { return 1; }
2678  int numSrcRegOperands() override { return 1; }
2679 
2680  int
2681  getOperandSize(int opIdx) override
2682  {
2683  switch (opIdx) {
2684  case 0: //ssrc
2685  return 8;
2686  case 1: //sdst
2687  return 4;
2688  default:
2689  fatal("op idx %i out of bounds\n", opIdx);
2690  return -1;
2691  }
2692  } // getOperandSize
2693 
2694  void execute(GPUDynInstPtr) override;
2695  }; // Inst_SOP1__S_BCNT1_I32_B64
2696 
2697  class Inst_SOP1__S_FF0_I32_B32 : public Inst_SOP1
2698  {
2699  public:
2700  Inst_SOP1__S_FF0_I32_B32(InFmt_SOP1*);
2701  ~Inst_SOP1__S_FF0_I32_B32();
2702 
2703  int
2704  getNumOperands() override
2705  {
2706  return numDstRegOperands() + numSrcRegOperands();
2707  } // getNumOperands
2708 
2709  int numDstRegOperands() override { return 1; }
2710  int numSrcRegOperands() override { return 1; }
2711 
2712  int
2713  getOperandSize(int opIdx) override
2714  {
2715  switch (opIdx) {
2716  case 0: //ssrc
2717  return 4;
2718  case 1: //sdst
2719  return 4;
2720  default:
2721  fatal("op idx %i out of bounds\n", opIdx);
2722  return -1;
2723  }
2724  } // getOperandSize
2725 
2726  void execute(GPUDynInstPtr) override;
2727  }; // Inst_SOP1__S_FF0_I32_B32
2728 
2729  class Inst_SOP1__S_FF0_I32_B64 : public Inst_SOP1
2730  {
2731  public:
2732  Inst_SOP1__S_FF0_I32_B64(InFmt_SOP1*);
2733  ~Inst_SOP1__S_FF0_I32_B64();
2734 
2735  int
2736  getNumOperands() override
2737  {
2738  return numDstRegOperands() + numSrcRegOperands();
2739  } // getNumOperands
2740 
2741  int numDstRegOperands() override { return 1; }
2742  int numSrcRegOperands() override { return 1; }
2743 
2744  int
2745  getOperandSize(int opIdx) override
2746  {
2747  switch (opIdx) {
2748  case 0: //ssrc
2749  return 8;
2750  case 1: //sdst
2751  return 4;
2752  default:
2753  fatal("op idx %i out of bounds\n", opIdx);
2754  return -1;
2755  }
2756  } // getOperandSize
2757 
2758  void execute(GPUDynInstPtr) override;
2759  }; // Inst_SOP1__S_FF0_I32_B64
2760 
2761  class Inst_SOP1__S_FF1_I32_B32 : public Inst_SOP1
2762  {
2763  public:
2764  Inst_SOP1__S_FF1_I32_B32(InFmt_SOP1*);
2765  ~Inst_SOP1__S_FF1_I32_B32();
2766 
2767  int
2768  getNumOperands() override
2769  {
2770  return numDstRegOperands() + numSrcRegOperands();
2771  } // getNumOperands
2772 
2773  int numDstRegOperands() override { return 1; }
2774  int numSrcRegOperands() override { return 1; }
2775 
2776  int
2777  getOperandSize(int opIdx) override
2778  {
2779  switch (opIdx) {
2780  case 0: //ssrc
2781  return 4;
2782  case 1: //sdst
2783  return 4;
2784  default:
2785  fatal("op idx %i out of bounds\n", opIdx);
2786  return -1;
2787  }
2788  } // getOperandSize
2789 
2790  void execute(GPUDynInstPtr) override;
2791  }; // Inst_SOP1__S_FF1_I32_B32
2792 
2793  class Inst_SOP1__S_FF1_I32_B64 : public Inst_SOP1
2794  {
2795  public:
2796  Inst_SOP1__S_FF1_I32_B64(InFmt_SOP1*);
2797  ~Inst_SOP1__S_FF1_I32_B64();
2798 
2799  int
2800  getNumOperands() override
2801  {
2802  return numDstRegOperands() + numSrcRegOperands();
2803  } // getNumOperands
2804 
2805  int numDstRegOperands() override { return 1; }
2806  int numSrcRegOperands() override { return 1; }
2807 
2808  int
2809  getOperandSize(int opIdx) override
2810  {
2811  switch (opIdx) {
2812  case 0: //ssrc
2813  return 8;
2814  case 1: //sdst
2815  return 4;
2816  default:
2817  fatal("op idx %i out of bounds\n", opIdx);
2818  return -1;
2819  }
2820  } // getOperandSize
2821 
2822  void execute(GPUDynInstPtr) override;
2823  }; // Inst_SOP1__S_FF1_I32_B64
2824 
2825  class Inst_SOP1__S_FLBIT_I32_B32 : public Inst_SOP1
2826  {
2827  public:
2828  Inst_SOP1__S_FLBIT_I32_B32(InFmt_SOP1*);
2829  ~Inst_SOP1__S_FLBIT_I32_B32();
2830 
2831  int
2832  getNumOperands() override
2833  {
2834  return numDstRegOperands() + numSrcRegOperands();
2835  } // getNumOperands
2836 
2837  int numDstRegOperands() override { return 1; }
2838  int numSrcRegOperands() override { return 1; }
2839 
2840  int
2841  getOperandSize(int opIdx) override
2842  {
2843  switch (opIdx) {
2844  case 0: //ssrc
2845  return 4;
2846  case 1: //sdst
2847  return 4;
2848  default:
2849  fatal("op idx %i out of bounds\n", opIdx);
2850  return -1;
2851  }
2852  } // getOperandSize
2853 
2854  void execute(GPUDynInstPtr) override;
2855  }; // Inst_SOP1__S_FLBIT_I32_B32
2856 
2857  class Inst_SOP1__S_FLBIT_I32_B64 : public Inst_SOP1
2858  {
2859  public:
2860  Inst_SOP1__S_FLBIT_I32_B64(InFmt_SOP1*);
2861  ~Inst_SOP1__S_FLBIT_I32_B64();
2862 
2863  int
2864  getNumOperands() override
2865  {
2866  return numDstRegOperands() + numSrcRegOperands();
2867  } // getNumOperands
2868 
2869  int numDstRegOperands() override { return 1; }
2870  int numSrcRegOperands() override { return 1; }
2871 
2872  int
2873  getOperandSize(int opIdx) override
2874  {
2875  switch (opIdx) {
2876  case 0: //ssrc
2877  return 8;
2878  case 1: //sdst
2879  return 4;
2880  default:
2881  fatal("op idx %i out of bounds\n", opIdx);
2882  return -1;
2883  }
2884  } // getOperandSize
2885 
2886  void execute(GPUDynInstPtr) override;
2887  }; // Inst_SOP1__S_FLBIT_I32_B64
2888 
2889  class Inst_SOP1__S_FLBIT_I32 : public Inst_SOP1
2890  {
2891  public:
2892  Inst_SOP1__S_FLBIT_I32(InFmt_SOP1*);
2893  ~Inst_SOP1__S_FLBIT_I32();
2894 
2895  int
2896  getNumOperands() override
2897  {
2898  return numDstRegOperands() + numSrcRegOperands();
2899  } // getNumOperands
2900 
2901  int numDstRegOperands() override { return 1; }
2902  int numSrcRegOperands() override { return 1; }
2903 
2904  int
2905  getOperandSize(int opIdx) override
2906  {
2907  switch (opIdx) {
2908  case 0: //ssrc
2909  return 4;
2910  case 1: //sdst
2911  return 4;
2912  default:
2913  fatal("op idx %i out of bounds\n", opIdx);
2914  return -1;
2915  }
2916  } // getOperandSize
2917 
2918  void execute(GPUDynInstPtr) override;
2919  }; // Inst_SOP1__S_FLBIT_I32
2920 
2921  class Inst_SOP1__S_FLBIT_I32_I64 : public Inst_SOP1
2922  {
2923  public:
2924  Inst_SOP1__S_FLBIT_I32_I64(InFmt_SOP1*);
2925  ~Inst_SOP1__S_FLBIT_I32_I64();
2926 
2927  int
2928  getNumOperands() override
2929  {
2930  return numDstRegOperands() + numSrcRegOperands();
2931  } // getNumOperands
2932 
2933  int numDstRegOperands() override { return 1; }
2934  int numSrcRegOperands() override { return 1; }
2935 
2936  int
2937  getOperandSize(int opIdx) override
2938  {
2939  switch (opIdx) {
2940  case 0: //ssrc
2941  return 8;
2942  case 1: //sdst
2943  return 4;
2944  default:
2945  fatal("op idx %i out of bounds\n", opIdx);
2946  return -1;
2947  }
2948  } // getOperandSize
2949 
2950  void execute(GPUDynInstPtr) override;
2951  }; // Inst_SOP1__S_FLBIT_I32_I64
2952 
2953  class Inst_SOP1__S_SEXT_I32_I8 : public Inst_SOP1
2954  {
2955  public:
2956  Inst_SOP1__S_SEXT_I32_I8(InFmt_SOP1*);
2957  ~Inst_SOP1__S_SEXT_I32_I8();
2958 
2959  int
2960  getNumOperands() override
2961  {
2962  return numDstRegOperands() + numSrcRegOperands();
2963  } // getNumOperands
2964 
2965  int numDstRegOperands() override { return 1; }
2966  int numSrcRegOperands() override { return 1; }
2967 
2968  int
2969  getOperandSize(int opIdx) override
2970  {
2971  switch (opIdx) {
2972  case 0: //ssrc
2973  return 4;
2974  case 1: //sdst
2975  return 4;
2976  default:
2977  fatal("op idx %i out of bounds\n", opIdx);
2978  return -1;
2979  }
2980  } // getOperandSize
2981 
2982  void execute(GPUDynInstPtr) override;
2983  }; // Inst_SOP1__S_SEXT_I32_I8
2984 
2985  class Inst_SOP1__S_SEXT_I32_I16 : public Inst_SOP1
2986  {
2987  public:
2988  Inst_SOP1__S_SEXT_I32_I16(InFmt_SOP1*);
2989  ~Inst_SOP1__S_SEXT_I32_I16();
2990 
2991  int
2992  getNumOperands() override
2993  {
2994  return numDstRegOperands() + numSrcRegOperands();
2995  } // getNumOperands
2996 
2997  int numDstRegOperands() override { return 1; }
2998  int numSrcRegOperands() override { return 1; }
2999 
3000  int
3001  getOperandSize(int opIdx) override
3002  {
3003  switch (opIdx) {
3004  case 0: //ssrc
3005  return 4;
3006  case 1: //sdst
3007  return 4;
3008  default:
3009  fatal("op idx %i out of bounds\n", opIdx);
3010  return -1;
3011  }
3012  } // getOperandSize
3013 
3014  void execute(GPUDynInstPtr) override;
3015  }; // Inst_SOP1__S_SEXT_I32_I16
3016 
3017  class Inst_SOP1__S_BITSET0_B32 : public Inst_SOP1
3018  {
3019  public:
3020  Inst_SOP1__S_BITSET0_B32(InFmt_SOP1*);
3021  ~Inst_SOP1__S_BITSET0_B32();
3022 
3023  int
3024  getNumOperands() override
3025  {
3026  return numDstRegOperands() + numSrcRegOperands();
3027  } // getNumOperands
3028 
3029  int numDstRegOperands() override { return 1; }
3030  int numSrcRegOperands() override { return 1; }
3031 
3032  int
3033  getOperandSize(int opIdx) override
3034  {
3035  switch (opIdx) {
3036  case 0: //ssrc
3037  return 4;
3038  case 1: //sdst
3039  return 4;
3040  default:
3041  fatal("op idx %i out of bounds\n", opIdx);
3042  return -1;
3043  }
3044  } // getOperandSize
3045 
3046  void execute(GPUDynInstPtr) override;
3047  }; // Inst_SOP1__S_BITSET0_B32
3048 
3049  class Inst_SOP1__S_BITSET0_B64 : public Inst_SOP1
3050  {
3051  public:
3052  Inst_SOP1__S_BITSET0_B64(InFmt_SOP1*);
3053  ~Inst_SOP1__S_BITSET0_B64();
3054 
3055  int
3056  getNumOperands() override
3057  {
3058  return numDstRegOperands() + numSrcRegOperands();
3059  } // getNumOperands
3060 
3061  int numDstRegOperands() override { return 1; }
3062  int numSrcRegOperands() override { return 1; }
3063 
3064  int
3065  getOperandSize(int opIdx) override
3066  {
3067  switch (opIdx) {
3068  case 0: //ssrc
3069  return 4;
3070  case 1: //sdst
3071  return 8;
3072  default:
3073  fatal("op idx %i out of bounds\n", opIdx);
3074  return -1;
3075  }
3076  } // getOperandSize
3077 
3078  void execute(GPUDynInstPtr) override;
3079  }; // Inst_SOP1__S_BITSET0_B64
3080 
3081  class Inst_SOP1__S_BITSET1_B32 : public Inst_SOP1
3082  {
3083  public:
3084  Inst_SOP1__S_BITSET1_B32(InFmt_SOP1*);
3085  ~Inst_SOP1__S_BITSET1_B32();
3086 
3087  int
3088  getNumOperands() override
3089  {
3090  return numDstRegOperands() + numSrcRegOperands();
3091  } // getNumOperands
3092 
3093  int numDstRegOperands() override { return 1; }
3094  int numSrcRegOperands() override { return 1; }
3095 
3096  int
3097  getOperandSize(int opIdx) override
3098  {
3099  switch (opIdx) {
3100  case 0: //ssrc
3101  return 4;
3102  case 1: //sdst
3103  return 4;
3104  default:
3105  fatal("op idx %i out of bounds\n", opIdx);
3106  return -1;
3107  }
3108  } // getOperandSize
3109 
3110  void execute(GPUDynInstPtr) override;
3111  }; // Inst_SOP1__S_BITSET1_B32
3112 
3113  class Inst_SOP1__S_BITSET1_B64 : public Inst_SOP1
3114  {
3115  public:
3116  Inst_SOP1__S_BITSET1_B64(InFmt_SOP1*);
3117  ~Inst_SOP1__S_BITSET1_B64();
3118 
3119  int
3120  getNumOperands() override
3121  {
3122  return numDstRegOperands() + numSrcRegOperands();
3123  } // getNumOperands
3124 
3125  int numDstRegOperands() override { return 1; }
3126  int numSrcRegOperands() override { return 1; }
3127 
3128  int
3129  getOperandSize(int opIdx) override
3130  {
3131  switch (opIdx) {
3132  case 0: //ssrc
3133  return 4;
3134  case 1: //sdst
3135  return 8;
3136  default:
3137  fatal("op idx %i out of bounds\n", opIdx);
3138  return -1;
3139  }
3140  } // getOperandSize
3141 
3142  void execute(GPUDynInstPtr) override;
3143  }; // Inst_SOP1__S_BITSET1_B64
3144 
3145  class Inst_SOP1__S_GETPC_B64 : public Inst_SOP1
3146  {
3147  public:
3148  Inst_SOP1__S_GETPC_B64(InFmt_SOP1*);
3149  ~Inst_SOP1__S_GETPC_B64();
3150 
3151  int
3152  getNumOperands() override
3153  {
3154  return numDstRegOperands() + numSrcRegOperands();
3155  } // getNumOperands
3156 
3157  int numDstRegOperands() override { return 1; }
3158  int numSrcRegOperands() override { return 0; }
3159 
3160  int
3161  getOperandSize(int opIdx) override
3162  {
3163  switch (opIdx) {
3164  case 0: //sdst
3165  return 8;
3166  default:
3167  fatal("op idx %i out of bounds\n", opIdx);
3168  return -1;
3169  }
3170  } // getOperandSize
3171 
3172  void execute(GPUDynInstPtr) override;
3173  }; // Inst_SOP1__S_GETPC_B64
3174 
3175  class Inst_SOP1__S_SETPC_B64 : public Inst_SOP1
3176  {
3177  public:
3178  Inst_SOP1__S_SETPC_B64(InFmt_SOP1*);
3179  ~Inst_SOP1__S_SETPC_B64();
3180 
3181  int
3182  getNumOperands() override
3183  {
3184  return numDstRegOperands() + numSrcRegOperands();
3185  } // getNumOperands
3186 
3187  int numDstRegOperands() override { return 0; }
3188  int numSrcRegOperands() override { return 1; }
3189 
3190  int
3191  getOperandSize(int opIdx) override
3192  {
3193  switch (opIdx) {
3194  case 0: //ssrc
3195  return 8;
3196  case 1: //sdst
3197  return 8;
3198  default:
3199  fatal("op idx %i out of bounds\n", opIdx);
3200  return -1;
3201  }
3202  } // getOperandSize
3203 
3204  void execute(GPUDynInstPtr) override;
3205  }; // Inst_SOP1__S_SETPC_B64
3206 
3207  class Inst_SOP1__S_SWAPPC_B64 : public Inst_SOP1
3208  {
3209  public:
3210  Inst_SOP1__S_SWAPPC_B64(InFmt_SOP1*);
3211  ~Inst_SOP1__S_SWAPPC_B64();
3212 
3213  int
3214  getNumOperands() override
3215  {
3216  return numDstRegOperands() + numSrcRegOperands();
3217  } // getNumOperands
3218 
3219  int numDstRegOperands() override { return 1; }
3220  int numSrcRegOperands() override { return 1; }
3221 
3222  int
3223  getOperandSize(int opIdx) override
3224  {
3225  switch (opIdx) {
3226  case 0: //ssrc
3227  return 8;
3228  case 1: //sdst
3229  return 8;
3230  default:
3231  fatal("op idx %i out of bounds\n", opIdx);
3232  return -1;
3233  }
3234  } // getOperandSize
3235 
3236  void execute(GPUDynInstPtr) override;
3237  }; // Inst_SOP1__S_SWAPPC_B64
3238 
3239  class Inst_SOP1__S_RFE_B64 : public Inst_SOP1
3240  {
3241  public:
3242  Inst_SOP1__S_RFE_B64(InFmt_SOP1*);
3243  ~Inst_SOP1__S_RFE_B64();
3244 
3245  int
3246  getNumOperands() override
3247  {
3248  return numDstRegOperands() + numSrcRegOperands();
3249  } // getNumOperands
3250 
3251  int numDstRegOperands() override { return 0; }
3252  int numSrcRegOperands() override { return 1; }
3253 
3254  int
3255  getOperandSize(int opIdx) override
3256  {
3257  switch (opIdx) {
3258  case 0: //ssrc
3259  return 8;
3260  case 1: //sdst
3261  return 8;
3262  default:
3263  fatal("op idx %i out of bounds\n", opIdx);
3264  return -1;
3265  }
3266  } // getOperandSize
3267 
3268  void execute(GPUDynInstPtr) override;
3269  }; // Inst_SOP1__S_RFE_B64
3270 
3271  class Inst_SOP1__S_AND_SAVEEXEC_B64 : public Inst_SOP1
3272  {
3273  public:
3274  Inst_SOP1__S_AND_SAVEEXEC_B64(InFmt_SOP1*);
3275  ~Inst_SOP1__S_AND_SAVEEXEC_B64();
3276 
3277  int
3278  getNumOperands() override
3279  {
3280  return numDstRegOperands() + numSrcRegOperands();
3281  } // getNumOperands
3282 
3283  int numDstRegOperands() override { return 1; }
3284  int numSrcRegOperands() override { return 1; }
3285 
3286  int
3287  getOperandSize(int opIdx) override
3288  {
3289  switch (opIdx) {
3290  case 0: //ssrc
3291  return 8;
3292  case 1: //sdst
3293  return 8;
3294  default:
3295  fatal("op idx %i out of bounds\n", opIdx);
3296  return -1;
3297  }
3298  } // getOperandSize
3299 
3300  void execute(GPUDynInstPtr) override;
3301  }; // Inst_SOP1__S_AND_SAVEEXEC_B64
3302 
3303  class Inst_SOP1__S_OR_SAVEEXEC_B64 : public Inst_SOP1
3304  {
3305  public:
3306  Inst_SOP1__S_OR_SAVEEXEC_B64(InFmt_SOP1*);
3307  ~Inst_SOP1__S_OR_SAVEEXEC_B64();
3308 
3309  int
3310  getNumOperands() override
3311  {
3312  return numDstRegOperands() + numSrcRegOperands();
3313  } // getNumOperands
3314 
3315  int numDstRegOperands() override { return 1; }
3316  int numSrcRegOperands() override { return 1; }
3317 
3318  int
3319  getOperandSize(int opIdx) override
3320  {
3321  switch (opIdx) {
3322  case 0: //ssrc
3323  return 8;
3324  case 1: //sdst
3325  return 8;
3326  default:
3327  fatal("op idx %i out of bounds\n", opIdx);
3328  return -1;
3329  }
3330  } // getOperandSize
3331 
3332  void execute(GPUDynInstPtr) override;
3333  }; // Inst_SOP1__S_OR_SAVEEXEC_B64
3334 
3335  class Inst_SOP1__S_XOR_SAVEEXEC_B64 : public Inst_SOP1
3336  {
3337  public:
3338  Inst_SOP1__S_XOR_SAVEEXEC_B64(InFmt_SOP1*);
3339  ~Inst_SOP1__S_XOR_SAVEEXEC_B64();
3340 
3341  int
3342  getNumOperands() override
3343  {
3344  return numDstRegOperands() + numSrcRegOperands();
3345  } // getNumOperands
3346 
3347  int numDstRegOperands() override { return 1; }
3348  int numSrcRegOperands() override { return 1; }
3349 
3350  int
3351  getOperandSize(int opIdx) override
3352  {
3353  switch (opIdx) {
3354  case 0: //ssrc
3355  return 8;
3356  case 1: //sdst
3357  return 8;
3358  default:
3359  fatal("op idx %i out of bounds\n", opIdx);
3360  return -1;
3361  }
3362  } // getOperandSize
3363 
3364  void execute(GPUDynInstPtr) override;
3365  }; // Inst_SOP1__S_XOR_SAVEEXEC_B64
3366 
3367  class Inst_SOP1__S_ANDN2_SAVEEXEC_B64 : public Inst_SOP1
3368  {
3369  public:
3370  Inst_SOP1__S_ANDN2_SAVEEXEC_B64(InFmt_SOP1*);
3371  ~Inst_SOP1__S_ANDN2_SAVEEXEC_B64();
3372 
3373  int
3374  getNumOperands() override
3375  {
3376  return numDstRegOperands() + numSrcRegOperands();
3377  } // getNumOperands
3378 
3379  int numDstRegOperands() override { return 1; }
3380  int numSrcRegOperands() override { return 1; }
3381 
3382  int
3383  getOperandSize(int opIdx) override
3384  {
3385  switch (opIdx) {
3386  case 0: //ssrc
3387  return 8;
3388  case 1: //sdst
3389  return 8;
3390  default:
3391  fatal("op idx %i out of bounds\n", opIdx);
3392  return -1;
3393  }
3394  } // getOperandSize
3395 
3396  void execute(GPUDynInstPtr) override;
3397  }; // Inst_SOP1__S_ANDN2_SAVEEXEC_B64
3398 
3399  class Inst_SOP1__S_ORN2_SAVEEXEC_B64 : public Inst_SOP1
3400  {
3401  public:
3402  Inst_SOP1__S_ORN2_SAVEEXEC_B64(InFmt_SOP1*);
3403  ~Inst_SOP1__S_ORN2_SAVEEXEC_B64();
3404 
3405  int
3406  getNumOperands() override
3407  {
3408  return numDstRegOperands() + numSrcRegOperands();
3409  } // getNumOperands
3410 
3411  int numDstRegOperands() override { return 1; }
3412  int numSrcRegOperands() override { return 1; }
3413 
3414  int
3415  getOperandSize(int opIdx) override
3416  {
3417  switch (opIdx) {
3418  case 0: //ssrc
3419  return 8;
3420  case 1: //sdst
3421  return 8;
3422  default:
3423  fatal("op idx %i out of bounds\n", opIdx);
3424  return -1;
3425  }
3426  } // getOperandSize
3427 
3428  void execute(GPUDynInstPtr) override;
3429  }; // Inst_SOP1__S_ORN2_SAVEEXEC_B64
3430 
3431  class Inst_SOP1__S_NAND_SAVEEXEC_B64 : public Inst_SOP1
3432  {
3433  public:
3434  Inst_SOP1__S_NAND_SAVEEXEC_B64(InFmt_SOP1*);
3435  ~Inst_SOP1__S_NAND_SAVEEXEC_B64();
3436 
3437  int
3438  getNumOperands() override
3439  {
3440  return numDstRegOperands() + numSrcRegOperands();
3441  } // getNumOperands
3442 
3443  int numDstRegOperands() override { return 1; }
3444  int numSrcRegOperands() override { return 1; }
3445 
3446  int
3447  getOperandSize(int opIdx) override
3448  {
3449  switch (opIdx) {
3450  case 0: //ssrc
3451  return 8;
3452  case 1: //sdst
3453  return 8;
3454  default:
3455  fatal("op idx %i out of bounds\n", opIdx);
3456  return -1;
3457  }
3458  } // getOperandSize
3459 
3460  void execute(GPUDynInstPtr) override;
3461  }; // Inst_SOP1__S_NAND_SAVEEXEC_B64
3462 
3463  class Inst_SOP1__S_NOR_SAVEEXEC_B64 : public Inst_SOP1
3464  {
3465  public:
3466  Inst_SOP1__S_NOR_SAVEEXEC_B64(InFmt_SOP1*);
3467  ~Inst_SOP1__S_NOR_SAVEEXEC_B64();
3468 
3469  int
3470  getNumOperands() override
3471  {
3472  return numDstRegOperands() + numSrcRegOperands();
3473  } // getNumOperands
3474 
3475  int numDstRegOperands() override { return 1; }
3476  int numSrcRegOperands() override { return 1; }
3477 
3478  int
3479  getOperandSize(int opIdx) override
3480  {
3481  switch (opIdx) {
3482  case 0: //ssrc
3483  return 8;
3484  case 1: //sdst
3485  return 8;
3486  default:
3487  fatal("op idx %i out of bounds\n", opIdx);
3488  return -1;
3489  }
3490  } // getOperandSize
3491 
3492  void execute(GPUDynInstPtr) override;
3493  }; // Inst_SOP1__S_NOR_SAVEEXEC_B64
3494 
3495  class Inst_SOP1__S_XNOR_SAVEEXEC_B64 : public Inst_SOP1
3496  {
3497  public:
3498  Inst_SOP1__S_XNOR_SAVEEXEC_B64(InFmt_SOP1*);
3499  ~Inst_SOP1__S_XNOR_SAVEEXEC_B64();
3500 
3501  int
3502  getNumOperands() override
3503  {
3504  return numDstRegOperands() + numSrcRegOperands();
3505  } // getNumOperands
3506 
3507  int numDstRegOperands() override { return 1; }
3508  int numSrcRegOperands() override { return 1; }
3509 
3510  int
3511  getOperandSize(int opIdx) override
3512  {
3513  switch (opIdx) {
3514  case 0: //ssrc
3515  return 8;
3516  case 1: //sdst
3517  return 8;
3518  default:
3519  fatal("op idx %i out of bounds\n", opIdx);
3520  return -1;
3521  }
3522  } // getOperandSize
3523 
3524  void execute(GPUDynInstPtr) override;
3525  }; // Inst_SOP1__S_XNOR_SAVEEXEC_B64
3526 
3527  class Inst_SOP1__S_QUADMASK_B32 : public Inst_SOP1
3528  {
3529  public:
3530  Inst_SOP1__S_QUADMASK_B32(InFmt_SOP1*);
3531  ~Inst_SOP1__S_QUADMASK_B32();
3532 
3533  int
3534  getNumOperands() override
3535  {
3536  return numDstRegOperands() + numSrcRegOperands();
3537  } // getNumOperands
3538 
3539  int numDstRegOperands() override { return 1; }
3540  int numSrcRegOperands() override { return 1; }
3541 
3542  int
3543  getOperandSize(int opIdx) override
3544  {
3545  switch (opIdx) {
3546  case 0: //ssrc
3547  return 4;
3548  case 1: //sdst
3549  return 4;
3550  default:
3551  fatal("op idx %i out of bounds\n", opIdx);
3552  return -1;
3553  }
3554  } // getOperandSize
3555 
3556  void execute(GPUDynInstPtr) override;
3557  }; // Inst_SOP1__S_QUADMASK_B32
3558 
3559  class Inst_SOP1__S_QUADMASK_B64 : public Inst_SOP1
3560  {
3561  public:
3562  Inst_SOP1__S_QUADMASK_B64(InFmt_SOP1*);
3563  ~Inst_SOP1__S_QUADMASK_B64();
3564 
3565  int
3566  getNumOperands() override
3567  {
3568  return numDstRegOperands() + numSrcRegOperands();
3569  } // getNumOperands
3570 
3571  int numDstRegOperands() override { return 1; }
3572  int numSrcRegOperands() override { return 1; }
3573 
3574  int
3575  getOperandSize(int opIdx) override
3576  {
3577  switch (opIdx) {
3578  case 0: //ssrc
3579  return 8;
3580  case 1: //sdst
3581  return 8;
3582  default:
3583  fatal("op idx %i out of bounds\n", opIdx);
3584  return -1;
3585  }
3586  } // getOperandSize
3587 
3588  void execute(GPUDynInstPtr) override;
3589  }; // Inst_SOP1__S_QUADMASK_B64
3590 
3591  class Inst_SOP1__S_MOVRELS_B32 : public Inst_SOP1
3592  {
3593  public:
3594  Inst_SOP1__S_MOVRELS_B32(InFmt_SOP1*);
3595  ~Inst_SOP1__S_MOVRELS_B32();
3596 
3597  int
3598  getNumOperands() override
3599  {
3600  return numDstRegOperands() + numSrcRegOperands();
3601  } // getNumOperands
3602 
3603  int numDstRegOperands() override { return 1; }
3604  int numSrcRegOperands() override { return 1; }
3605 
3606  int
3607  getOperandSize(int opIdx) override
3608  {
3609  switch (opIdx) {
3610  case 0: //ssrc
3611  return 4;
3612  case 1: //sdst
3613  return 4;
3614  default:
3615  fatal("op idx %i out of bounds\n", opIdx);
3616  return -1;
3617  }
3618  } // getOperandSize
3619 
3620  void execute(GPUDynInstPtr) override;
3621  }; // Inst_SOP1__S_MOVRELS_B32
3622 
3623  class Inst_SOP1__S_MOVRELS_B64 : public Inst_SOP1
3624  {
3625  public:
3626  Inst_SOP1__S_MOVRELS_B64(InFmt_SOP1*);
3627  ~Inst_SOP1__S_MOVRELS_B64();
3628 
3629  int
3630  getNumOperands() override
3631  {
3632  return numDstRegOperands() + numSrcRegOperands();
3633  } // getNumOperands
3634 
3635  int numDstRegOperands() override { return 1; }
3636  int numSrcRegOperands() override { return 1; }
3637 
3638  int
3639  getOperandSize(int opIdx) override
3640  {
3641  switch (opIdx) {
3642  case 0: //sdst
3643  return 8;
3644  case 1: //sdst
3645  return 8;
3646  default:
3647  fatal("op idx %i out of bounds\n", opIdx);
3648  return -1;
3649  }
3650  } // getOperandSize
3651 
3652  void execute(GPUDynInstPtr) override;
3653  }; // Inst_SOP1__S_MOVRELS_B64
3654 
3655  class Inst_SOP1__S_MOVRELD_B32 : public Inst_SOP1
3656  {
3657  public:
3658  Inst_SOP1__S_MOVRELD_B32(InFmt_SOP1*);
3659  ~Inst_SOP1__S_MOVRELD_B32();
3660 
3661  int
3662  getNumOperands() override
3663  {
3664  return numDstRegOperands() + numSrcRegOperands();
3665  } // getNumOperands
3666 
3667  int numDstRegOperands() override { return 1; }
3668  int numSrcRegOperands() override { return 1; }
3669 
3670  int
3671  getOperandSize(int opIdx) override
3672  {
3673  switch (opIdx) {
3674  case 0: //ssrc
3675  return 4;
3676  case 1: //sdst
3677  return 4;
3678  default:
3679  fatal("op idx %i out of bounds\n", opIdx);
3680  return -1;
3681  }
3682  } // getOperandSize
3683 
3684  void execute(GPUDynInstPtr) override;
3685  }; // Inst_SOP1__S_MOVRELD_B32
3686 
3687  class Inst_SOP1__S_MOVRELD_B64 : public Inst_SOP1
3688  {
3689  public:
3690  Inst_SOP1__S_MOVRELD_B64(InFmt_SOP1*);
3691  ~Inst_SOP1__S_MOVRELD_B64();
3692 
3693  int
3694  getNumOperands() override
3695  {
3696  return numDstRegOperands() + numSrcRegOperands();
3697  } // getNumOperands
3698 
3699  int numDstRegOperands() override { return 1; }
3700  int numSrcRegOperands() override { return 1; }
3701 
3702  int
3703  getOperandSize(int opIdx) override
3704  {
3705  switch (opIdx) {
3706  case 0: //ssrc
3707  return 8;
3708  case 1: //sdst
3709  return 8;
3710  default:
3711  fatal("op idx %i out of bounds\n", opIdx);
3712  return -1;
3713  }
3714  } // getOperandSize
3715 
3716  void execute(GPUDynInstPtr) override;
3717  }; // Inst_SOP1__S_MOVRELD_B64
3718 
3719  class Inst_SOP1__S_CBRANCH_JOIN : public Inst_SOP1
3720  {
3721  public:
3722  Inst_SOP1__S_CBRANCH_JOIN(InFmt_SOP1*);
3723  ~Inst_SOP1__S_CBRANCH_JOIN();
3724 
3725  int
3726  getNumOperands() override
3727  {
3728  return numDstRegOperands() + numSrcRegOperands();
3729  } // getNumOperands
3730 
3731  int numDstRegOperands() override { return 0; }
3732  int numSrcRegOperands() override { return 1; }
3733 
3734  int
3735  getOperandSize(int opIdx) override
3736  {
3737  switch (opIdx) {
3738  case 0: //ssrc
3739  return 4;
3740  case 1: //sdst
3741  return 4;
3742  default:
3743  fatal("op idx %i out of bounds\n", opIdx);
3744  return -1;
3745  }
3746  } // getOperandSize
3747 
3748  void execute(GPUDynInstPtr) override;
3749  }; // Inst_SOP1__S_CBRANCH_JOIN
3750 
3751  class Inst_SOP1__S_ABS_I32 : public Inst_SOP1
3752  {
3753  public:
3754  Inst_SOP1__S_ABS_I32(InFmt_SOP1*);
3755  ~Inst_SOP1__S_ABS_I32();
3756 
3757  int
3758  getNumOperands() override
3759  {
3760  return numDstRegOperands() + numSrcRegOperands();
3761  } // getNumOperands
3762 
3763  int numDstRegOperands() override { return 1; }
3764  int numSrcRegOperands() override { return 1; }
3765 
3766  int
3767  getOperandSize(int opIdx) override
3768  {
3769  switch (opIdx) {
3770  case 0: //ssrc
3771  return 4;
3772  case 1: //sdst
3773  return 4;
3774  default:
3775  fatal("op idx %i out of bounds\n", opIdx);
3776  return -1;
3777  }
3778  } // getOperandSize
3779 
3780  void execute(GPUDynInstPtr) override;
3781  }; // Inst_SOP1__S_ABS_I32
3782 
3783  class Inst_SOP1__S_MOV_FED_B32 : public Inst_SOP1
3784  {
3785  public:
3786  Inst_SOP1__S_MOV_FED_B32(InFmt_SOP1*);
3787  ~Inst_SOP1__S_MOV_FED_B32();
3788 
3789  int
3790  getNumOperands() override
3791  {
3792  return numDstRegOperands() + numSrcRegOperands();
3793  } // getNumOperands
3794 
3795  int numDstRegOperands() override { return 1; }
3796  int numSrcRegOperands() override { return 1; }
3797 
3798  int
3799  getOperandSize(int opIdx) override
3800  {
3801  switch (opIdx) {
3802  case 0: //ssrc
3803  return 4;
3804  case 1: //sdst
3805  return 4;
3806  default:
3807  fatal("op idx %i out of bounds\n", opIdx);
3808  return -1;
3809  }
3810  } // getOperandSize
3811 
3812  void execute(GPUDynInstPtr) override;
3813  }; // Inst_SOP1__S_MOV_FED_B32
3814 
3815  class Inst_SOP1__S_SET_GPR_IDX_IDX : public Inst_SOP1
3816  {
3817  public:
3818  Inst_SOP1__S_SET_GPR_IDX_IDX(InFmt_SOP1*);
3819  ~Inst_SOP1__S_SET_GPR_IDX_IDX();
3820 
3821  int
3822  getNumOperands() override
3823  {
3824  return numDstRegOperands() + numSrcRegOperands();
3825  } // getNumOperands
3826 
3827  int numDstRegOperands() override { return 0; }
3828  int numSrcRegOperands() override { return 1; }
3829 
3830  int
3831  getOperandSize(int opIdx) override
3832  {
3833  switch (opIdx) {
3834  case 0: //ssrc
3835  return 4;
3836  case 1: //sdst
3837  return 4;
3838  default:
3839  fatal("op idx %i out of bounds\n", opIdx);
3840  return -1;
3841  }
3842  } // getOperandSize
3843 
3844  void execute(GPUDynInstPtr) override;
3845  }; // Inst_SOP1__S_SET_GPR_IDX_IDX
3846 
3847  class Inst_SOPC__S_CMP_EQ_I32 : public Inst_SOPC
3848  {
3849  public:
3850  Inst_SOPC__S_CMP_EQ_I32(InFmt_SOPC*);
3851  ~Inst_SOPC__S_CMP_EQ_I32();
3852 
3853  int
3854  getNumOperands() override
3855  {
3856  return numDstRegOperands() + numSrcRegOperands();
3857  } // getNumOperands
3858 
3859  int numDstRegOperands() override { return 0; }
3860  int numSrcRegOperands() override { return 2; }
3861 
3862  int
3863  getOperandSize(int opIdx) override
3864  {
3865  switch (opIdx) {
3866  case 0: //ssrc_0
3867  return 4;
3868  case 1: //ssrc_1
3869  return 4;
3870  default:
3871  fatal("op idx %i out of bounds\n", opIdx);
3872  return -1;
3873  }
3874  } // getOperandSize
3875 
3876  void execute(GPUDynInstPtr) override;
3877  }; // Inst_SOPC__S_CMP_EQ_I32
3878 
3879  class Inst_SOPC__S_CMP_LG_I32 : public Inst_SOPC
3880  {
3881  public:
3882  Inst_SOPC__S_CMP_LG_I32(InFmt_SOPC*);
3883  ~Inst_SOPC__S_CMP_LG_I32();
3884 
3885  int
3886  getNumOperands() override
3887  {
3888  return numDstRegOperands() + numSrcRegOperands();
3889  } // getNumOperands
3890 
3891  int numDstRegOperands() override { return 0; }
3892  int numSrcRegOperands() override { return 2; }
3893 
3894  int
3895  getOperandSize(int opIdx) override
3896  {
3897  switch (opIdx) {
3898  case 0: //ssrc_0
3899  return 4;
3900  case 1: //ssrc_1
3901  return 4;
3902  default:
3903  fatal("op idx %i out of bounds\n", opIdx);
3904  return -1;
3905  }
3906  } // getOperandSize
3907 
3908  void execute(GPUDynInstPtr) override;
3909  }; // Inst_SOPC__S_CMP_LG_I32
3910 
3911  class Inst_SOPC__S_CMP_GT_I32 : public Inst_SOPC
3912  {
3913  public:
3914  Inst_SOPC__S_CMP_GT_I32(InFmt_SOPC*);
3915  ~Inst_SOPC__S_CMP_GT_I32();
3916 
3917  int
3918  getNumOperands() override
3919  {
3920  return numDstRegOperands() + numSrcRegOperands();
3921  } // getNumOperands
3922 
3923  int numDstRegOperands() override { return 0; }
3924  int numSrcRegOperands() override { return 2; }
3925 
3926  int
3927  getOperandSize(int opIdx) override
3928  {
3929  switch (opIdx) {
3930  case 0: //ssrc_0
3931  return 4;
3932  case 1: //ssrc_1
3933  return 4;
3934  default:
3935  fatal("op idx %i out of bounds\n", opIdx);
3936  return -1;
3937  }
3938  } // getOperandSize
3939 
3940  void execute(GPUDynInstPtr) override;
3941  }; // Inst_SOPC__S_CMP_GT_I32
3942 
3943  class Inst_SOPC__S_CMP_GE_I32 : public Inst_SOPC
3944  {
3945  public:
3946  Inst_SOPC__S_CMP_GE_I32(InFmt_SOPC*);
3947  ~Inst_SOPC__S_CMP_GE_I32();
3948 
3949  int
3950  getNumOperands() override
3951  {
3952  return numDstRegOperands() + numSrcRegOperands();
3953  } // getNumOperands
3954 
3955  int numDstRegOperands() override { return 0; }
3956  int numSrcRegOperands() override { return 2; }
3957 
3958  int
3959  getOperandSize(int opIdx) override
3960  {
3961  switch (opIdx) {
3962  case 0: //ssrc_0
3963  return 4;
3964  case 1: //ssrc_1
3965  return 4;
3966  default:
3967  fatal("op idx %i out of bounds\n", opIdx);
3968  return -1;
3969  }
3970  } // getOperandSize
3971 
3972  void execute(GPUDynInstPtr) override;
3973  }; // Inst_SOPC__S_CMP_GE_I32
3974 
3975  class Inst_SOPC__S_CMP_LT_I32 : public Inst_SOPC
3976  {
3977  public:
3978  Inst_SOPC__S_CMP_LT_I32(InFmt_SOPC*);
3979  ~Inst_SOPC__S_CMP_LT_I32();
3980 
3981  int
3982  getNumOperands() override
3983  {
3984  return numDstRegOperands() + numSrcRegOperands();
3985  } // getNumOperands
3986 
3987  int numDstRegOperands() override { return 0; }
3988  int numSrcRegOperands() override { return 2; }
3989 
3990  int
3991  getOperandSize(int opIdx) override
3992  {
3993  switch (opIdx) {
3994  case 0: //ssrc_0
3995  return 4;
3996  case 1: //ssrc_1
3997  return 4;
3998  default:
3999  fatal("op idx %i out of bounds\n", opIdx);
4000  return -1;
4001  }
4002  } // getOperandSize
4003 
4004  void execute(GPUDynInstPtr) override;
4005  }; // Inst_SOPC__S_CMP_LT_I32
4006 
4007  class Inst_SOPC__S_CMP_LE_I32 : public Inst_SOPC
4008  {
4009  public:
4010  Inst_SOPC__S_CMP_LE_I32(InFmt_SOPC*);
4011  ~Inst_SOPC__S_CMP_LE_I32();
4012 
4013  int
4014  getNumOperands() override
4015  {
4016  return numDstRegOperands() + numSrcRegOperands();
4017  } // getNumOperands
4018 
4019  int numDstRegOperands() override { return 0; }
4020  int numSrcRegOperands() override { return 2; }
4021 
4022  int
4023  getOperandSize(int opIdx) override
4024  {
4025  switch (opIdx) {
4026  case 0: //ssrc_0
4027  return 4;
4028  case 1: //ssrc_1
4029  return 4;
4030  default:
4031  fatal("op idx %i out of bounds\n", opIdx);
4032  return -1;
4033  }
4034  } // getOperandSize
4035 
4036  void execute(GPUDynInstPtr) override;
4037  }; // Inst_SOPC__S_CMP_LE_I32
4038 
4039  class Inst_SOPC__S_CMP_EQ_U32 : public Inst_SOPC
4040  {
4041  public:
4042  Inst_SOPC__S_CMP_EQ_U32(InFmt_SOPC*);
4043  ~Inst_SOPC__S_CMP_EQ_U32();
4044 
4045  int
4046  getNumOperands() override
4047  {
4048  return numDstRegOperands() + numSrcRegOperands();
4049  } // getNumOperands
4050 
4051  int numDstRegOperands() override { return 0; }
4052  int numSrcRegOperands() override { return 2; }
4053 
4054  int
4055  getOperandSize(int opIdx) override
4056  {
4057  switch (opIdx) {
4058  case 0: //ssrc_0
4059  return 4;
4060  case 1: //ssrc_1
4061  return 4;
4062  default:
4063  fatal("op idx %i out of bounds\n", opIdx);
4064  return -1;
4065  }
4066  } // getOperandSize
4067 
4068  void execute(GPUDynInstPtr) override;
4069  }; // Inst_SOPC__S_CMP_EQ_U32
4070 
4071  class Inst_SOPC__S_CMP_LG_U32 : public Inst_SOPC
4072  {
4073  public:
4074  Inst_SOPC__S_CMP_LG_U32(InFmt_SOPC*);
4075  ~Inst_SOPC__S_CMP_LG_U32();
4076 
4077  int
4078  getNumOperands() override
4079  {
4080  return numDstRegOperands() + numSrcRegOperands();
4081  } // getNumOperands
4082 
4083  int numDstRegOperands() override { return 0; }
4084  int numSrcRegOperands() override { return 2; }
4085 
4086  int
4087  getOperandSize(int opIdx) override
4088  {
4089  switch (opIdx) {
4090  case 0: //ssrc_0
4091  return 4;
4092  case 1: //ssrc_1
4093  return 4;
4094  default:
4095  fatal("op idx %i out of bounds\n", opIdx);
4096  return -1;
4097  }
4098  } // getOperandSize
4099 
4100  void execute(GPUDynInstPtr) override;
4101  }; // Inst_SOPC__S_CMP_LG_U32
4102 
4103  class Inst_SOPC__S_CMP_GT_U32 : public Inst_SOPC
4104  {
4105  public:
4106  Inst_SOPC__S_CMP_GT_U32(InFmt_SOPC*);
4107  ~Inst_SOPC__S_CMP_GT_U32();
4108 
4109  int
4110  getNumOperands() override
4111  {
4112  return numDstRegOperands() + numSrcRegOperands();
4113  } // getNumOperands
4114 
4115  int numDstRegOperands() override { return 0; }
4116  int numSrcRegOperands() override { return 2; }
4117 
4118  int
4119  getOperandSize(int opIdx) override
4120  {
4121  switch (opIdx) {
4122  case 0: //ssrc_0
4123  return 4;
4124  case 1: //ssrc_1
4125  return 4;
4126  default:
4127  fatal("op idx %i out of bounds\n", opIdx);
4128  return -1;
4129  }
4130  } // getOperandSize
4131 
4132  void execute(GPUDynInstPtr) override;
4133  }; // Inst_SOPC__S_CMP_GT_U32
4134 
4135  class Inst_SOPC__S_CMP_GE_U32 : public Inst_SOPC
4136  {
4137  public:
4138  Inst_SOPC__S_CMP_GE_U32(InFmt_SOPC*);
4139  ~Inst_SOPC__S_CMP_GE_U32();
4140 
4141  int
4142  getNumOperands() override
4143  {
4144  return numDstRegOperands() + numSrcRegOperands();
4145  } // getNumOperands
4146 
4147  int numDstRegOperands() override { return 0; }
4148  int numSrcRegOperands() override { return 2; }
4149 
4150  int
4151  getOperandSize(int opIdx) override
4152  {
4153  switch (opIdx) {
4154  case 0: //ssrc_0
4155  return 4;
4156  case 1: //ssrc_1
4157  return 4;
4158  default:
4159  fatal("op idx %i out of bounds\n", opIdx);
4160  return -1;
4161  }
4162  } // getOperandSize
4163 
4164  void execute(GPUDynInstPtr) override;
4165  }; // Inst_SOPC__S_CMP_GE_U32
4166 
4167  class Inst_SOPC__S_CMP_LT_U32 : public Inst_SOPC
4168  {
4169  public:
4170  Inst_SOPC__S_CMP_LT_U32(InFmt_SOPC*);
4171  ~Inst_SOPC__S_CMP_LT_U32();
4172 
4173  int
4174  getNumOperands() override
4175  {
4176  return numDstRegOperands() + numSrcRegOperands();
4177  } // getNumOperands
4178 
4179  int numDstRegOperands() override { return 0; }
4180  int numSrcRegOperands() override { return 2; }
4181 
4182  int
4183  getOperandSize(int opIdx) override
4184  {
4185  switch (opIdx) {
4186  case 0: //ssrc_0
4187  return 4;
4188  case 1: //ssrc_1
4189  return 4;
4190  default:
4191  fatal("op idx %i out of bounds\n", opIdx);
4192  return -1;
4193  }
4194  } // getOperandSize
4195 
4196  void execute(GPUDynInstPtr) override;
4197  }; // Inst_SOPC__S_CMP_LT_U32
4198 
4199  class Inst_SOPC__S_CMP_LE_U32 : public Inst_SOPC
4200  {
4201  public:
4202  Inst_SOPC__S_CMP_LE_U32(InFmt_SOPC*);
4203  ~Inst_SOPC__S_CMP_LE_U32();
4204 
4205  int
4206  getNumOperands() override
4207  {
4208  return numDstRegOperands() + numSrcRegOperands();
4209  } // getNumOperands
4210 
4211  int numDstRegOperands() override { return 0; }
4212  int numSrcRegOperands() override { return 2; }
4213 
4214  int
4215  getOperandSize(int opIdx) override
4216  {
4217  switch (opIdx) {
4218  case 0: //ssrc_0
4219  return 4;
4220  case 1: //ssrc_1
4221  return 4;
4222  default:
4223  fatal("op idx %i out of bounds\n", opIdx);
4224  return -1;
4225  }
4226  } // getOperandSize
4227 
4228  void execute(GPUDynInstPtr) override;
4229  }; // Inst_SOPC__S_CMP_LE_U32
4230 
4231  class Inst_SOPC__S_BITCMP0_B32 : public Inst_SOPC
4232  {
4233  public:
4234  Inst_SOPC__S_BITCMP0_B32(InFmt_SOPC*);
4235  ~Inst_SOPC__S_BITCMP0_B32();
4236 
4237  int
4238  getNumOperands() override
4239  {
4240  return numDstRegOperands() + numSrcRegOperands();
4241  } // getNumOperands
4242 
4243  int numDstRegOperands() override { return 0; }
4244  int numSrcRegOperands() override { return 2; }
4245 
4246  int
4247  getOperandSize(int opIdx) override
4248  {
4249  switch (opIdx) {
4250  case 0: //ssrc_0
4251  return 4;
4252  case 1: //ssrc_1
4253  return 4;
4254  default:
4255  fatal("op idx %i out of bounds\n", opIdx);
4256  return -1;
4257  }
4258  } // getOperandSize
4259 
4260  void execute(GPUDynInstPtr) override;
4261  }; // Inst_SOPC__S_BITCMP0_B32
4262 
4263  class Inst_SOPC__S_BITCMP1_B32 : public Inst_SOPC
4264  {
4265  public:
4266  Inst_SOPC__S_BITCMP1_B32(InFmt_SOPC*);
4267  ~Inst_SOPC__S_BITCMP1_B32();
4268 
4269  int
4270  getNumOperands() override
4271  {
4272  return numDstRegOperands() + numSrcRegOperands();
4273  } // getNumOperands
4274 
4275  int numDstRegOperands() override { return 0; }
4276  int numSrcRegOperands() override { return 2; }
4277 
4278  int
4279  getOperandSize(int opIdx) override
4280  {
4281  switch (opIdx) {
4282  case 0: //ssrc_0
4283  return 4;
4284  case 1: //ssrc_1
4285  return 4;
4286  default:
4287  fatal("op idx %i out of bounds\n", opIdx);
4288  return -1;
4289  }
4290  } // getOperandSize
4291 
4292  void execute(GPUDynInstPtr) override;
4293  }; // Inst_SOPC__S_BITCMP1_B32
4294 
4295  class Inst_SOPC__S_BITCMP0_B64 : public Inst_SOPC
4296  {
4297  public:
4298  Inst_SOPC__S_BITCMP0_B64(InFmt_SOPC*);
4299  ~Inst_SOPC__S_BITCMP0_B64();
4300 
4301  int
4302  getNumOperands() override
4303  {
4304  return numDstRegOperands() + numSrcRegOperands();
4305  } // getNumOperands
4306 
4307  int numDstRegOperands() override { return 0; }
4308  int numSrcRegOperands() override { return 2; }
4309 
4310  int
4311  getOperandSize(int opIdx) override
4312  {
4313  switch (opIdx) {
4314  case 0: //ssrc_0
4315  return 8;
4316  case 1: //ssrc_1
4317  return 4;
4318  default:
4319  fatal("op idx %i out of bounds\n", opIdx);
4320  return -1;
4321  }
4322  } // getOperandSize
4323 
4324  void execute(GPUDynInstPtr) override;
4325  }; // Inst_SOPC__S_BITCMP0_B64
4326 
4327  class Inst_SOPC__S_BITCMP1_B64 : public Inst_SOPC
4328  {
4329  public:
4330  Inst_SOPC__S_BITCMP1_B64(InFmt_SOPC*);
4331  ~Inst_SOPC__S_BITCMP1_B64();
4332 
4333  int
4334  getNumOperands() override
4335  {
4336  return numDstRegOperands() + numSrcRegOperands();
4337  } // getNumOperands
4338 
4339  int numDstRegOperands() override { return 0; }
4340  int numSrcRegOperands() override { return 2; }
4341 
4342  int
4343  getOperandSize(int opIdx) override
4344  {
4345  switch (opIdx) {
4346  case 0: //ssrc_0
4347  return 8;
4348  case 1: //ssrc_1
4349  return 4;
4350  default:
4351  fatal("op idx %i out of bounds\n", opIdx);
4352  return -1;
4353  }
4354  } // getOperandSize
4355 
4356  void execute(GPUDynInstPtr) override;
4357  }; // Inst_SOPC__S_BITCMP1_B64
4358 
4359  class Inst_SOPC__S_SETVSKIP : public Inst_SOPC
4360  {
4361  public:
4362  Inst_SOPC__S_SETVSKIP(InFmt_SOPC*);
4363  ~Inst_SOPC__S_SETVSKIP();
4364 
4365  int
4366  getNumOperands() override
4367  {
4368  return numDstRegOperands() + numSrcRegOperands();
4369  } // getNumOperands
4370 
4371  int numDstRegOperands() override { return 0; }
4372  int numSrcRegOperands() override { return 2; }
4373 
4374  int
4375  getOperandSize(int opIdx) override
4376  {
4377  switch (opIdx) {
4378  case 0: //ssrc_0
4379  return 4;
4380  case 1: //ssrc_1
4381  return 4;
4382  default:
4383  fatal("op idx %i out of bounds\n", opIdx);
4384  return -1;
4385  }
4386  } // getOperandSize
4387 
4388  void execute(GPUDynInstPtr) override;
4389  }; // Inst_SOPC__S_SETVSKIP
4390 
4391  class Inst_SOPC__S_SET_GPR_IDX_ON : public Inst_SOPC
4392  {
4393  public:
4394  Inst_SOPC__S_SET_GPR_IDX_ON(InFmt_SOPC*);
4395  ~Inst_SOPC__S_SET_GPR_IDX_ON();
4396 
4397  int
4398  getNumOperands() override
4399  {
4400  return numDstRegOperands() + numSrcRegOperands();
4401  } // getNumOperands
4402 
4403  int numDstRegOperands() override { return 0; }
4404  int numSrcRegOperands() override { return 2; }
4405 
4406  int
4407  getOperandSize(int opIdx) override
4408  {
4409  switch (opIdx) {
4410  case 0: //ssrc_0
4411  return 4;
4412  case 1: //simm4
4413  return 4;
4414  default:
4415  fatal("op idx %i out of bounds\n", opIdx);
4416  return -1;
4417  }
4418  } // getOperandSize
4419 
4420  void execute(GPUDynInstPtr) override;
4421  }; // Inst_SOPC__S_SET_GPR_IDX_ON
4422 
4423  class Inst_SOPC__S_CMP_EQ_U64 : public Inst_SOPC
4424  {
4425  public:
4426  Inst_SOPC__S_CMP_EQ_U64(InFmt_SOPC*);
4427  ~Inst_SOPC__S_CMP_EQ_U64();
4428 
4429  int
4430  getNumOperands() override
4431  {
4432  return numDstRegOperands() + numSrcRegOperands();
4433  } // getNumOperands
4434 
4435  int numDstRegOperands() override { return 0; }
4436  int numSrcRegOperands() override { return 2; }
4437 
4438  int
4439  getOperandSize(int opIdx) override
4440  {
4441  switch (opIdx) {
4442  case 0: //ssrc_0
4443  return 8;
4444  case 1: //ssrc_1
4445  return 8;
4446  default:
4447  fatal("op idx %i out of bounds\n", opIdx);
4448  return -1;
4449  }
4450  } // getOperandSize
4451 
4452  void execute(GPUDynInstPtr) override;
4453  }; // Inst_SOPC__S_CMP_EQ_U64
4454 
4455  class Inst_SOPC__S_CMP_LG_U64 : public Inst_SOPC
4456  {
4457  public:
4458  Inst_SOPC__S_CMP_LG_U64(InFmt_SOPC*);
4459  ~Inst_SOPC__S_CMP_LG_U64();
4460 
4461  int
4462  getNumOperands() override
4463  {
4464  return numDstRegOperands() + numSrcRegOperands();
4465  } // getNumOperands
4466 
4467  int numDstRegOperands() override { return 0; }
4468  int numSrcRegOperands() override { return 2; }
4469 
4470  int
4471  getOperandSize(int opIdx) override
4472  {
4473  switch (opIdx) {
4474  case 0: //ssrc_0
4475  return 8;
4476  case 1: //ssrc_1
4477  return 8;
4478  default:
4479  fatal("op idx %i out of bounds\n", opIdx);
4480  return -1;
4481  }
4482  } // getOperandSize
4483 
4484  void execute(GPUDynInstPtr) override;
4485  }; // Inst_SOPC__S_CMP_LG_U64
4486 
4487  class Inst_SOPP__S_NOP : public Inst_SOPP
4488  {
4489  public:
4490  Inst_SOPP__S_NOP(InFmt_SOPP*);
4491  ~Inst_SOPP__S_NOP();
4492 
4493  int
4494  getNumOperands() override
4495  {
4496  return numDstRegOperands() + numSrcRegOperands();
4497  } // getNumOperands
4498 
4499  int numDstRegOperands() override { return 0; }
4500  int numSrcRegOperands() override { return 1; }
4501 
4502  int
4503  getOperandSize(int opIdx) override
4504  {
4505  switch (opIdx) {
4506  case 0: //simm16
4507  return 2;
4508  default:
4509  fatal("op idx %i out of bounds\n", opIdx);
4510  return -1;
4511  }
4512  } // getOperandSize
4513 
4514  void execute(GPUDynInstPtr) override;
4515  }; // Inst_SOPP__S_NOP
4516 
4517  class Inst_SOPP__S_ENDPGM : public Inst_SOPP
4518  {
4519  public:
4520  Inst_SOPP__S_ENDPGM(InFmt_SOPP*);
4521  ~Inst_SOPP__S_ENDPGM();
4522 
4523  int
4524  getNumOperands() override
4525  {
4526  return numDstRegOperands() + numSrcRegOperands();
4527  } // getNumOperands
4528 
4529  int numDstRegOperands() override { return 0; }
4530  int numSrcRegOperands() override { return 0; }
4531 
4532  int
4533  getOperandSize(int opIdx) override
4534  {
4535  switch (opIdx) {
4536  case 0: //simm16
4537  return 2;
4538  default:
4539  fatal("op idx %i out of bounds\n", opIdx);
4540  return -1;
4541  }
4542  } // getOperandSize
4543 
4544  void execute(GPUDynInstPtr) override;
4545  }; // Inst_SOPP__S_ENDPGM
4546 
4547  class Inst_SOPP__S_BRANCH : public Inst_SOPP
4548  {
4549  public:
4550  Inst_SOPP__S_BRANCH(InFmt_SOPP*);
4551  ~Inst_SOPP__S_BRANCH();
4552 
4553  int
4554  getNumOperands() override
4555  {
4556  return numDstRegOperands() + numSrcRegOperands();
4557  } // getNumOperands
4558 
4559  int numDstRegOperands() override { return 0; }
4560  int numSrcRegOperands() override { return 1; }
4561 
4562  int
4563  getOperandSize(int opIdx) override
4564  {
4565  switch (opIdx) {
4566  case 0: //label
4567  return 2;
4568  default:
4569  fatal("op idx %i out of bounds\n", opIdx);
4570  return -1;
4571  }
4572  } // getOperandSize
4573 
4574  void execute(GPUDynInstPtr) override;
4575  }; // Inst_SOPP__S_BRANCH
4576 
4577  class Inst_SOPP__S_WAKEUP : public Inst_SOPP
4578  {
4579  public:
4580  Inst_SOPP__S_WAKEUP(InFmt_SOPP*);
4581  ~Inst_SOPP__S_WAKEUP();
4582 
4583  int
4584  getNumOperands() override
4585  {
4586  return numDstRegOperands() + numSrcRegOperands();
4587  } // getNumOperands
4588 
4589  int numDstRegOperands() override { return 0; }
4590  int numSrcRegOperands() override { return 0; }
4591 
4592  int
4593  getOperandSize(int opIdx) override
4594  {
4595  switch (opIdx) {
4596  case 0: //simm16
4597  return 2;
4598  default:
4599  fatal("op idx %i out of bounds\n", opIdx);
4600  return -1;
4601  }
4602  } // getOperandSize
4603 
4604  void execute(GPUDynInstPtr) override;
4605  }; // Inst_SOPP__S_WAKEUP
4606 
4607  class Inst_SOPP__S_CBRANCH_SCC0 : public Inst_SOPP
4608  {
4609  public:
4610  Inst_SOPP__S_CBRANCH_SCC0(InFmt_SOPP*);
4611  ~Inst_SOPP__S_CBRANCH_SCC0();
4612 
4613  int
4614  getNumOperands() override
4615  {
4616  return numDstRegOperands() + numSrcRegOperands();
4617  } // getNumOperands
4618 
4619  int numDstRegOperands() override { return 0; }
4620  int numSrcRegOperands() override { return 1; }
4621 
4622  int
4623  getOperandSize(int opIdx) override
4624  {
4625  switch (opIdx) {
4626  case 0: //label
4627  return 2;
4628  default:
4629  fatal("op idx %i out of bounds\n", opIdx);
4630  return -1;
4631  }
4632  } // getOperandSize
4633 
4634  void execute(GPUDynInstPtr) override;
4635  }; // Inst_SOPP__S_CBRANCH_SCC0
4636 
4637  class Inst_SOPP__S_CBRANCH_SCC1 : public Inst_SOPP
4638  {
4639  public:
4640  Inst_SOPP__S_CBRANCH_SCC1(InFmt_SOPP*);
4641  ~Inst_SOPP__S_CBRANCH_SCC1();
4642 
4643  int
4644  getNumOperands() override
4645  {
4646  return numDstRegOperands() + numSrcRegOperands();
4647  } // getNumOperands
4648 
4649  int numDstRegOperands() override { return 0; }
4650  int numSrcRegOperands() override { return 1; }
4651 
4652  int
4653  getOperandSize(int opIdx) override
4654  {
4655  switch (opIdx) {
4656  case 0: //label
4657  return 2;
4658  default:
4659  fatal("op idx %i out of bounds\n", opIdx);
4660  return -1;
4661  }
4662  } // getOperandSize
4663 
4664  void execute(GPUDynInstPtr) override;
4665  }; // Inst_SOPP__S_CBRANCH_SCC1
4666 
4667  class Inst_SOPP__S_CBRANCH_VCCZ : public Inst_SOPP
4668  {
4669  public:
4670  Inst_SOPP__S_CBRANCH_VCCZ(InFmt_SOPP*);
4671  ~Inst_SOPP__S_CBRANCH_VCCZ();
4672 
4673  int
4674  getNumOperands() override
4675  {
4676  return numDstRegOperands() + numSrcRegOperands();
4677  } // getNumOperands
4678 
4679  int numDstRegOperands() override { return 0; }
4680  int numSrcRegOperands() override { return 2; }
4681 
4682  int
4683  getOperandSize(int opIdx) override
4684  {
4685  switch (opIdx) {
4686  case 0: //label
4687  return 2;
4688  case 1:
4689  return 8;
4690  default:
4691  fatal("op idx %i out of bounds\n", opIdx);
4692  return -1;
4693  }
4694  } // getOperandSize
4695 
4696  void execute(GPUDynInstPtr) override;
4697  }; // Inst_SOPP__S_CBRANCH_VCCZ
4698 
4699  class Inst_SOPP__S_CBRANCH_VCCNZ : public Inst_SOPP
4700  {
4701  public:
4702  Inst_SOPP__S_CBRANCH_VCCNZ(InFmt_SOPP*);
4703  ~Inst_SOPP__S_CBRANCH_VCCNZ();
4704 
4705  int
4706  getNumOperands() override
4707  {
4708  return numDstRegOperands() + numSrcRegOperands();
4709  } // getNumOperands
4710 
4711  int numDstRegOperands() override { return 0; }
4712  int numSrcRegOperands() override { return 2; }
4713 
4714  int
4715  getOperandSize(int opIdx) override
4716  {
4717  switch (opIdx) {
4718  case 0: //label
4719  return 2;
4720  case 1:
4721  return 8;
4722  default:
4723  fatal("op idx %i out of bounds\n", opIdx);
4724  return -1;
4725  }
4726  } // getOperandSize
4727 
4728  void execute(GPUDynInstPtr) override;
4729  }; // Inst_SOPP__S_CBRANCH_VCCNZ
4730 
4731  class Inst_SOPP__S_CBRANCH_EXECZ : public Inst_SOPP
4732  {
4733  public:
4734  Inst_SOPP__S_CBRANCH_EXECZ(InFmt_SOPP*);
4735  ~Inst_SOPP__S_CBRANCH_EXECZ();
4736 
4737  int
4738  getNumOperands() override
4739  {
4740  return numDstRegOperands() + numSrcRegOperands();
4741  } // getNumOperands
4742 
4743  int numDstRegOperands() override { return 0; }
4744  int numSrcRegOperands() override { return 1; }
4745 
4746  int
4747  getOperandSize(int opIdx) override
4748  {
4749  switch (opIdx) {
4750  case 0: //label
4751  return 2;
4752  default:
4753  fatal("op idx %i out of bounds\n", opIdx);
4754  return -1;
4755  }
4756  } // getOperandSize
4757 
4758  void execute(GPUDynInstPtr) override;
4759  }; // Inst_SOPP__S_CBRANCH_EXECZ
4760 
4761  class Inst_SOPP__S_CBRANCH_EXECNZ : public Inst_SOPP
4762  {
4763  public:
4764  Inst_SOPP__S_CBRANCH_EXECNZ(InFmt_SOPP*);
4765  ~Inst_SOPP__S_CBRANCH_EXECNZ();
4766 
4767  int
4768  getNumOperands() override
4769  {
4770  return numDstRegOperands() + numSrcRegOperands();
4771  } // getNumOperands
4772 
4773  int numDstRegOperands() override { return 0; }
4774  int numSrcRegOperands() override { return 1; }
4775 
4776  int
4777  getOperandSize(int opIdx) override
4778  {
4779  switch (opIdx) {
4780  case 0: //label
4781  return 2;
4782  default:
4783  fatal("op idx %i out of bounds\n", opIdx);
4784  return -1;
4785  }
4786  } // getOperandSize
4787 
4788  void execute(GPUDynInstPtr) override;
4789  }; // Inst_SOPP__S_CBRANCH_EXECNZ
4790 
4791  class Inst_SOPP__S_BARRIER : public Inst_SOPP
4792  {
4793  public:
4794  Inst_SOPP__S_BARRIER(InFmt_SOPP*);
4795  ~Inst_SOPP__S_BARRIER();
4796 
4797  int
4798  getNumOperands() override
4799  {
4800  return numDstRegOperands() + numSrcRegOperands();
4801  } // getNumOperands
4802 
4803  int numDstRegOperands() override { return 0; }
4804  int numSrcRegOperands() override { return 0; }
4805 
4806  int
4807  getOperandSize(int opIdx) override
4808  {
4809  switch (opIdx) {
4810  case 0: //simm16
4811  return 2;
4812  default:
4813  fatal("op idx %i out of bounds\n", opIdx);
4814  return -1;
4815  }
4816  } // getOperandSize
4817 
4818  void execute(GPUDynInstPtr) override;
4819  }; // Inst_SOPP__S_BARRIER
4820 
4821  class Inst_SOPP__S_SETKILL : public Inst_SOPP
4822  {
4823  public:
4824  Inst_SOPP__S_SETKILL(InFmt_SOPP*);
4825  ~Inst_SOPP__S_SETKILL();
4826 
4827  int
4828  getNumOperands() override
4829  {
4830  return numDstRegOperands() + numSrcRegOperands();
4831  } // getNumOperands
4832 
4833  int numDstRegOperands() override { return 0; }
4834  int numSrcRegOperands() override { return 1; }
4835 
4836  int
4837  getOperandSize(int opIdx) override
4838  {
4839  switch (opIdx) {
4840  case 0: //simm16
4841  return 2;
4842  default:
4843  fatal("op idx %i out of bounds\n", opIdx);
4844  return -1;
4845  }
4846  } // getOperandSize
4847 
4848  void execute(GPUDynInstPtr) override;
4849  }; // Inst_SOPP__S_SETKILL
4850 
4851  class Inst_SOPP__S_WAITCNT : public Inst_SOPP
4852  {
4853  public:
4854  Inst_SOPP__S_WAITCNT(InFmt_SOPP*);
4855  ~Inst_SOPP__S_WAITCNT();
4856 
4857  int
4858  getNumOperands() override
4859  {
4860  return numDstRegOperands() + numSrcRegOperands();
4861  } // getNumOperands
4862 
4863  int numDstRegOperands() override { return 0; }
4864  int numSrcRegOperands() override { return 1; }
4865 
4866  int
4867  getOperandSize(int opIdx) override
4868  {
4869  switch (opIdx) {
4870  case 0: //simm16
4871  return 2;
4872  default:
4873  fatal("op idx %i out of bounds\n", opIdx);
4874  return -1;
4875  }
4876  } // getOperandSize
4877 
4878  void execute(GPUDynInstPtr) override;
4879  }; // Inst_SOPP__S_WAITCNT
4880 
4881  class Inst_SOPP__S_SETHALT : public Inst_SOPP
4882  {
4883  public:
4884  Inst_SOPP__S_SETHALT(InFmt_SOPP*);
4885  ~Inst_SOPP__S_SETHALT();
4886 
4887  int
4888  getNumOperands() override
4889  {
4890  return numDstRegOperands() + numSrcRegOperands();
4891  } // getNumOperands
4892 
4893  int numDstRegOperands() override { return 0; }
4894  int numSrcRegOperands() override { return 1; }
4895 
4896  int
4897  getOperandSize(int opIdx) override
4898  {
4899  switch (opIdx) {
4900  case 0: //simm16
4901  return 2;
4902  default:
4903  fatal("op idx %i out of bounds\n", opIdx);
4904  return -1;
4905  }
4906  } // getOperandSize
4907 
4908  void execute(GPUDynInstPtr) override;
4909  }; // Inst_SOPP__S_SETHALT
4910 
4911  class Inst_SOPP__S_SLEEP : public Inst_SOPP
4912  {
4913  public:
4914  Inst_SOPP__S_SLEEP(InFmt_SOPP*);
4915  ~Inst_SOPP__S_SLEEP();
4916 
4917  int
4918  getNumOperands() override
4919  {
4920  return numDstRegOperands() + numSrcRegOperands();
4921  } // getNumOperands
4922 
4923  int numDstRegOperands() override { return 0; }
4924  int numSrcRegOperands() override { return 1; }
4925 
4926  int
4927  getOperandSize(int opIdx) override
4928  {
4929  switch (opIdx) {
4930  case 0: //simm16
4931  return 2;
4932  default:
4933  fatal("op idx %i out of bounds\n", opIdx);
4934  return -1;
4935  }
4936  } // getOperandSize
4937 
4938  void execute(GPUDynInstPtr) override;
4939  }; // Inst_SOPP__S_SLEEP
4940 
4941  class Inst_SOPP__S_SETPRIO : public Inst_SOPP
4942  {
4943  public:
4944  Inst_SOPP__S_SETPRIO(InFmt_SOPP*);
4945  ~Inst_SOPP__S_SETPRIO();
4946 
4947  int
4948  getNumOperands() override
4949  {
4950  return numDstRegOperands() + numSrcRegOperands();
4951  } // getNumOperands
4952 
4953  int numDstRegOperands() override { return 0; }
4954  int numSrcRegOperands() override { return 1; }
4955 
4956  int
4957  getOperandSize(int opIdx) override
4958  {
4959  switch (opIdx) {
4960  case 0: //simm16
4961  return 2;
4962  default:
4963  fatal("op idx %i out of bounds\n", opIdx);
4964  return -1;
4965  }
4966  } // getOperandSize
4967 
4968  void execute(GPUDynInstPtr) override;
4969  }; // Inst_SOPP__S_SETPRIO
4970 
4971  class Inst_SOPP__S_SENDMSG : public Inst_SOPP
4972  {
4973  public:
4974  Inst_SOPP__S_SENDMSG(InFmt_SOPP*);
4975  ~Inst_SOPP__S_SENDMSG();
4976 
4977  int
4978  getNumOperands() override
4979  {
4980  return numDstRegOperands() + numSrcRegOperands();
4981  } // getNumOperands
4982 
4983  int numDstRegOperands() override { return 0; }
4984  int numSrcRegOperands() override { return 1; }
4985 
4986  int
4987  getOperandSize(int opIdx) override
4988  {
4989  switch (opIdx) {
4990  case 0: //simm16
4991  return 2;
4992  default:
4993  fatal("op idx %i out of bounds\n", opIdx);
4994  return -1;
4995  }
4996  } // getOperandSize
4997 
4998  void execute(GPUDynInstPtr) override;
4999  }; // Inst_SOPP__S_SENDMSG
5000 
5001  class Inst_SOPP__S_SENDMSGHALT : public Inst_SOPP
5002  {
5003  public:
5004  Inst_SOPP__S_SENDMSGHALT(InFmt_SOPP*);
5005  ~Inst_SOPP__S_SENDMSGHALT();
5006 
5007  int
5008  getNumOperands() override
5009  {
5010  return numDstRegOperands() + numSrcRegOperands();
5011  } // getNumOperands
5012 
5013  int numDstRegOperands() override { return 0; }
5014  int numSrcRegOperands() override { return 1; }
5015 
5016  int
5017  getOperandSize(int opIdx) override
5018  {
5019  switch (opIdx) {
5020  case 0: //simm16
5021  return 2;
5022  default:
5023  fatal("op idx %i out of bounds\n", opIdx);
5024  return -1;
5025  }
5026  } // getOperandSize
5027 
5028  void execute(GPUDynInstPtr) override;
5029  }; // Inst_SOPP__S_SENDMSGHALT
5030 
5031  class Inst_SOPP__S_TRAP : public Inst_SOPP
5032  {
5033  public:
5034  Inst_SOPP__S_TRAP(InFmt_SOPP*);
5035  ~Inst_SOPP__S_TRAP();
5036 
5037  int
5038  getNumOperands() override
5039  {
5040  return numDstRegOperands() + numSrcRegOperands();
5041  } // getNumOperands
5042 
5043  int numDstRegOperands() override { return 0; }
5044  int numSrcRegOperands() override { return 1; }
5045 
5046  int
5047  getOperandSize(int opIdx) override
5048  {
5049  switch (opIdx) {
5050  case 0: //simm16
5051  return 2;
5052  default:
5053  fatal("op idx %i out of bounds\n", opIdx);
5054  return -1;
5055  }
5056  } // getOperandSize
5057 
5058  void execute(GPUDynInstPtr) override;
5059  }; // Inst_SOPP__S_TRAP
5060 
5061  class Inst_SOPP__S_ICACHE_INV : public Inst_SOPP
5062  {
5063  public:
5064  Inst_SOPP__S_ICACHE_INV(InFmt_SOPP*);
5065  ~Inst_SOPP__S_ICACHE_INV();
5066 
5067  int
5068  getNumOperands() override
5069  {
5070  return numDstRegOperands() + numSrcRegOperands();
5071  } // getNumOperands
5072 
5073  int numDstRegOperands() override { return 0; }
5074  int numSrcRegOperands() override { return 0; }
5075 
5076  int
5077  getOperandSize(int opIdx) override
5078  {
5079  switch (opIdx) {
5080  case 0: //simm16
5081  return 2;
5082  default:
5083  fatal("op idx %i out of bounds\n", opIdx);
5084  return -1;
5085  }
5086  } // getOperandSize
5087 
5088  void execute(GPUDynInstPtr) override;
5089  }; // Inst_SOPP__S_ICACHE_INV
5090 
5091  class Inst_SOPP__S_INCPERFLEVEL : public Inst_SOPP
5092  {
5093  public:
5094  Inst_SOPP__S_INCPERFLEVEL(InFmt_SOPP*);
5095  ~Inst_SOPP__S_INCPERFLEVEL();
5096 
5097  int
5098  getNumOperands() override
5099  {
5100  return numDstRegOperands() + numSrcRegOperands();
5101  } // getNumOperands
5102 
5103  int numDstRegOperands() override { return 0; }
5104  int numSrcRegOperands() override { return 1; }
5105 
5106  int
5107  getOperandSize(int opIdx) override
5108  {
5109  switch