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_GCN3_INSTS_INSTRUCTIONS_HH__
33 #define __ARCH_GCN3_INSTS_INSTRUCTIONS_HH__
34 
35 #include "arch/amdgpu/gcn3/gpu_decoder.hh"
36 #include "arch/amdgpu/gcn3/insts/gpu_static_inst.hh"
37 #include "arch/amdgpu/gcn3/insts/op_encodings.hh"
38 #include "debug/GCN3.hh"
39 
40 namespace gem5
41 {
42 
43 namespace Gcn3ISA
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_SOPK__S_MOVK_I32 : public Inst_SOPK
1542  {
1543  public:
1544  Inst_SOPK__S_MOVK_I32(InFmt_SOPK*);
1545  ~Inst_SOPK__S_MOVK_I32();
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 1; }
1555 
1556  int
1557  getOperandSize(int opIdx) override
1558  {
1559  switch (opIdx) {
1560  case 0: //simm16
1561  return 2;
1562  case 1: //sdst
1563  return 4;
1564  default:
1565  fatal("op idx %i out of bounds\n", opIdx);
1566  return -1;
1567  }
1568  } // getOperandSize
1569 
1570  void execute(GPUDynInstPtr) override;
1571  }; // Inst_SOPK__S_MOVK_I32
1572 
1573  class Inst_SOPK__S_CMOVK_I32 : public Inst_SOPK
1574  {
1575  public:
1576  Inst_SOPK__S_CMOVK_I32(InFmt_SOPK*);
1577  ~Inst_SOPK__S_CMOVK_I32();
1578 
1579  int
1580  getNumOperands() override
1581  {
1582  return numDstRegOperands() + numSrcRegOperands();
1583  } // getNumOperands
1584 
1585  int numDstRegOperands() override { return 1; }
1586  int numSrcRegOperands() override { return 1; }
1587 
1588  int
1589  getOperandSize(int opIdx) override
1590  {
1591  switch (opIdx) {
1592  case 0: //simm16
1593  return 2;
1594  case 1: //sdst
1595  return 4;
1596  default:
1597  fatal("op idx %i out of bounds\n", opIdx);
1598  return -1;
1599  }
1600  } // getOperandSize
1601 
1602  void execute(GPUDynInstPtr) override;
1603  }; // Inst_SOPK__S_CMOVK_I32
1604 
1605  class Inst_SOPK__S_CMPK_EQ_I32 : public Inst_SOPK
1606  {
1607  public:
1608  Inst_SOPK__S_CMPK_EQ_I32(InFmt_SOPK*);
1609  ~Inst_SOPK__S_CMPK_EQ_I32();
1610 
1611  int
1612  getNumOperands() override
1613  {
1614  return numDstRegOperands() + numSrcRegOperands();
1615  } // getNumOperands
1616 
1617  int numDstRegOperands() override { return 0; }
1618  int numSrcRegOperands() override { return 2; }
1619 
1620  int
1621  getOperandSize(int opIdx) override
1622  {
1623  switch (opIdx) {
1624  case 0: //ssrc
1625  return 4;
1626  case 1: //simm16
1627  return 2;
1628  default:
1629  fatal("op idx %i out of bounds\n", opIdx);
1630  return -1;
1631  }
1632  } // getOperandSize
1633 
1634  void execute(GPUDynInstPtr) override;
1635  }; // Inst_SOPK__S_CMPK_EQ_I32
1636 
1637  class Inst_SOPK__S_CMPK_LG_I32 : public Inst_SOPK
1638  {
1639  public:
1640  Inst_SOPK__S_CMPK_LG_I32(InFmt_SOPK*);
1641  ~Inst_SOPK__S_CMPK_LG_I32();
1642 
1643  int
1644  getNumOperands() override
1645  {
1646  return numDstRegOperands() + numSrcRegOperands();
1647  } // getNumOperands
1648 
1649  int numDstRegOperands() override { return 0; }
1650  int numSrcRegOperands() override { return 2; }
1651 
1652  int
1653  getOperandSize(int opIdx) override
1654  {
1655  switch (opIdx) {
1656  case 0: //ssrc
1657  return 4;
1658  case 1: //simm16
1659  return 2;
1660  default:
1661  fatal("op idx %i out of bounds\n", opIdx);
1662  return -1;
1663  }
1664  } // getOperandSize
1665 
1666  void execute(GPUDynInstPtr) override;
1667  }; // Inst_SOPK__S_CMPK_LG_I32
1668 
1669  class Inst_SOPK__S_CMPK_GT_I32 : public Inst_SOPK
1670  {
1671  public:
1672  Inst_SOPK__S_CMPK_GT_I32(InFmt_SOPK*);
1673  ~Inst_SOPK__S_CMPK_GT_I32();
1674 
1675  int
1676  getNumOperands() override
1677  {
1678  return numDstRegOperands() + numSrcRegOperands();
1679  } // getNumOperands
1680 
1681  int numDstRegOperands() override { return 0; }
1682  int numSrcRegOperands() override { return 2; }
1683 
1684  int
1685  getOperandSize(int opIdx) override
1686  {
1687  switch (opIdx) {
1688  case 0: //ssrc
1689  return 4;
1690  case 1: //simm16
1691  return 2;
1692  default:
1693  fatal("op idx %i out of bounds\n", opIdx);
1694  return -1;
1695  }
1696  } // getOperandSize
1697 
1698  void execute(GPUDynInstPtr) override;
1699  }; // Inst_SOPK__S_CMPK_GT_I32
1700 
1701  class Inst_SOPK__S_CMPK_GE_I32 : public Inst_SOPK
1702  {
1703  public:
1704  Inst_SOPK__S_CMPK_GE_I32(InFmt_SOPK*);
1705  ~Inst_SOPK__S_CMPK_GE_I32();
1706 
1707  int
1708  getNumOperands() override
1709  {
1710  return numDstRegOperands() + numSrcRegOperands();
1711  } // getNumOperands
1712 
1713  int numDstRegOperands() override { return 0; }
1714  int numSrcRegOperands() override { return 2; }
1715 
1716  int
1717  getOperandSize(int opIdx) override
1718  {
1719  switch (opIdx) {
1720  case 0: //ssrc
1721  return 4;
1722  case 1: //simm16
1723  return 2;
1724  default:
1725  fatal("op idx %i out of bounds\n", opIdx);
1726  return -1;
1727  }
1728  } // getOperandSize
1729 
1730  void execute(GPUDynInstPtr) override;
1731  }; // Inst_SOPK__S_CMPK_GE_I32
1732 
1733  class Inst_SOPK__S_CMPK_LT_I32 : public Inst_SOPK
1734  {
1735  public:
1736  Inst_SOPK__S_CMPK_LT_I32(InFmt_SOPK*);
1737  ~Inst_SOPK__S_CMPK_LT_I32();
1738 
1739  int
1740  getNumOperands() override
1741  {
1742  return numDstRegOperands() + numSrcRegOperands();
1743  } // getNumOperands
1744 
1745  int numDstRegOperands() override { return 0; }
1746  int numSrcRegOperands() override { return 2; }
1747 
1748  int
1749  getOperandSize(int opIdx) override
1750  {
1751  switch (opIdx) {
1752  case 0: //ssrc
1753  return 4;
1754  case 1: //simm16
1755  return 2;
1756  default:
1757  fatal("op idx %i out of bounds\n", opIdx);
1758  return -1;
1759  }
1760  } // getOperandSize
1761 
1762  void execute(GPUDynInstPtr) override;
1763  }; // Inst_SOPK__S_CMPK_LT_I32
1764 
1765  class Inst_SOPK__S_CMPK_LE_I32 : public Inst_SOPK
1766  {
1767  public:
1768  Inst_SOPK__S_CMPK_LE_I32(InFmt_SOPK*);
1769  ~Inst_SOPK__S_CMPK_LE_I32();
1770 
1771  int
1772  getNumOperands() override
1773  {
1774  return numDstRegOperands() + numSrcRegOperands();
1775  } // getNumOperands
1776 
1777  int numDstRegOperands() override { return 0; }
1778  int numSrcRegOperands() override { return 2; }
1779 
1780  int
1781  getOperandSize(int opIdx) override
1782  {
1783  switch (opIdx) {
1784  case 0: //ssrc
1785  return 4;
1786  case 1: //simm16
1787  return 2;
1788  default:
1789  fatal("op idx %i out of bounds\n", opIdx);
1790  return -1;
1791  }
1792  } // getOperandSize
1793 
1794  void execute(GPUDynInstPtr) override;
1795  }; // Inst_SOPK__S_CMPK_LE_I32
1796 
1797  class Inst_SOPK__S_CMPK_EQ_U32 : public Inst_SOPK
1798  {
1799  public:
1800  Inst_SOPK__S_CMPK_EQ_U32(InFmt_SOPK*);
1801  ~Inst_SOPK__S_CMPK_EQ_U32();
1802 
1803  int
1804  getNumOperands() override
1805  {
1806  return numDstRegOperands() + numSrcRegOperands();
1807  } // getNumOperands
1808 
1809  int numDstRegOperands() override { return 0; }
1810  int numSrcRegOperands() override { return 2; }
1811 
1812  int
1813  getOperandSize(int opIdx) override
1814  {
1815  switch (opIdx) {
1816  case 0: //ssrc
1817  return 4;
1818  case 1: //simm16
1819  return 2;
1820  default:
1821  fatal("op idx %i out of bounds\n", opIdx);
1822  return -1;
1823  }
1824  } // getOperandSize
1825 
1826  void execute(GPUDynInstPtr) override;
1827  }; // Inst_SOPK__S_CMPK_EQ_U32
1828 
1829  class Inst_SOPK__S_CMPK_LG_U32 : public Inst_SOPK
1830  {
1831  public:
1832  Inst_SOPK__S_CMPK_LG_U32(InFmt_SOPK*);
1833  ~Inst_SOPK__S_CMPK_LG_U32();
1834 
1835  int
1836  getNumOperands() override
1837  {
1838  return numDstRegOperands() + numSrcRegOperands();
1839  } // getNumOperands
1840 
1841  int numDstRegOperands() override { return 0; }
1842  int numSrcRegOperands() override { return 2; }
1843 
1844  int
1845  getOperandSize(int opIdx) override
1846  {
1847  switch (opIdx) {
1848  case 0: //ssrc
1849  return 4;
1850  case 1: //simm16
1851  return 2;
1852  default:
1853  fatal("op idx %i out of bounds\n", opIdx);
1854  return -1;
1855  }
1856  } // getOperandSize
1857 
1858  void execute(GPUDynInstPtr) override;
1859  }; // Inst_SOPK__S_CMPK_LG_U32
1860 
1861  class Inst_SOPK__S_CMPK_GT_U32 : public Inst_SOPK
1862  {
1863  public:
1864  Inst_SOPK__S_CMPK_GT_U32(InFmt_SOPK*);
1865  ~Inst_SOPK__S_CMPK_GT_U32();
1866 
1867  int
1868  getNumOperands() override
1869  {
1870  return numDstRegOperands() + numSrcRegOperands();
1871  } // getNumOperands
1872 
1873  int numDstRegOperands() override { return 0; }
1874  int numSrcRegOperands() override { return 2; }
1875 
1876  int
1877  getOperandSize(int opIdx) override
1878  {
1879  switch (opIdx) {
1880  case 0: //ssrc
1881  return 4;
1882  case 1: //simm16
1883  return 2;
1884  default:
1885  fatal("op idx %i out of bounds\n", opIdx);
1886  return -1;
1887  }
1888  } // getOperandSize
1889 
1890  void execute(GPUDynInstPtr) override;
1891  }; // Inst_SOPK__S_CMPK_GT_U32
1892 
1893  class Inst_SOPK__S_CMPK_GE_U32 : public Inst_SOPK
1894  {
1895  public:
1896  Inst_SOPK__S_CMPK_GE_U32(InFmt_SOPK*);
1897  ~Inst_SOPK__S_CMPK_GE_U32();
1898 
1899  int
1900  getNumOperands() override
1901  {
1902  return numDstRegOperands() + numSrcRegOperands();
1903  } // getNumOperands
1904 
1905  int numDstRegOperands() override { return 0; }
1906  int numSrcRegOperands() override { return 2; }
1907 
1908  int
1909  getOperandSize(int opIdx) override
1910  {
1911  switch (opIdx) {
1912  case 0: //ssrc
1913  return 4;
1914  case 1: //simm16
1915  return 2;
1916  default:
1917  fatal("op idx %i out of bounds\n", opIdx);
1918  return -1;
1919  }
1920  } // getOperandSize
1921 
1922  void execute(GPUDynInstPtr) override;
1923  }; // Inst_SOPK__S_CMPK_GE_U32
1924 
1925  class Inst_SOPK__S_CMPK_LT_U32 : public Inst_SOPK
1926  {
1927  public:
1928  Inst_SOPK__S_CMPK_LT_U32(InFmt_SOPK*);
1929  ~Inst_SOPK__S_CMPK_LT_U32();
1930 
1931  int
1932  getNumOperands() override
1933  {
1934  return numDstRegOperands() + numSrcRegOperands();
1935  } // getNumOperands
1936 
1937  int numDstRegOperands() override { return 0; }
1938  int numSrcRegOperands() override { return 2; }
1939 
1940  int
1941  getOperandSize(int opIdx) override
1942  {
1943  switch (opIdx) {
1944  case 0: //ssrc
1945  return 4;
1946  case 1: //simm16
1947  return 2;
1948  default:
1949  fatal("op idx %i out of bounds\n", opIdx);
1950  return -1;
1951  }
1952  } // getOperandSize
1953 
1954  void execute(GPUDynInstPtr) override;
1955  }; // Inst_SOPK__S_CMPK_LT_U32
1956 
1957  class Inst_SOPK__S_CMPK_LE_U32 : public Inst_SOPK
1958  {
1959  public:
1960  Inst_SOPK__S_CMPK_LE_U32(InFmt_SOPK*);
1961  ~Inst_SOPK__S_CMPK_LE_U32();
1962 
1963  int
1964  getNumOperands() override
1965  {
1966  return numDstRegOperands() + numSrcRegOperands();
1967  } // getNumOperands
1968 
1969  int numDstRegOperands() override { return 0; }
1970  int numSrcRegOperands() override { return 2; }
1971 
1972  int
1973  getOperandSize(int opIdx) override
1974  {
1975  switch (opIdx) {
1976  case 0: //ssrc
1977  return 4;
1978  case 1: //simm16
1979  return 2;
1980  default:
1981  fatal("op idx %i out of bounds\n", opIdx);
1982  return -1;
1983  }
1984  } // getOperandSize
1985 
1986  void execute(GPUDynInstPtr) override;
1987  }; // Inst_SOPK__S_CMPK_LE_U32
1988 
1989  class Inst_SOPK__S_ADDK_I32 : public Inst_SOPK
1990  {
1991  public:
1992  Inst_SOPK__S_ADDK_I32(InFmt_SOPK*);
1993  ~Inst_SOPK__S_ADDK_I32();
1994 
1995  int
1996  getNumOperands() override
1997  {
1998  return numDstRegOperands() + numSrcRegOperands();
1999  } // getNumOperands
2000 
2001  int numDstRegOperands() override { return 1; }
2002  int numSrcRegOperands() override { return 1; }
2003 
2004  int
2005  getOperandSize(int opIdx) override
2006  {
2007  switch (opIdx) {
2008  case 0: //simm16
2009  return 2;
2010  case 1: //sdst
2011  return 4;
2012  default:
2013  fatal("op idx %i out of bounds\n", opIdx);
2014  return -1;
2015  }
2016  } // getOperandSize
2017 
2018  void execute(GPUDynInstPtr) override;
2019  }; // Inst_SOPK__S_ADDK_I32
2020 
2021  class Inst_SOPK__S_MULK_I32 : public Inst_SOPK
2022  {
2023  public:
2024  Inst_SOPK__S_MULK_I32(InFmt_SOPK*);
2025  ~Inst_SOPK__S_MULK_I32();
2026 
2027  int
2028  getNumOperands() override
2029  {
2030  return numDstRegOperands() + numSrcRegOperands();
2031  } // getNumOperands
2032 
2033  int numDstRegOperands() override { return 1; }
2034  int numSrcRegOperands() override { return 1; }
2035 
2036  int
2037  getOperandSize(int opIdx) override
2038  {
2039  switch (opIdx) {
2040  case 0: //simm16
2041  return 2;
2042  case 1: //sdst
2043  return 4;
2044  default:
2045  fatal("op idx %i out of bounds\n", opIdx);
2046  return -1;
2047  }
2048  } // getOperandSize
2049 
2050  void execute(GPUDynInstPtr) override;
2051  }; // Inst_SOPK__S_MULK_I32
2052 
2053  class Inst_SOPK__S_CBRANCH_I_FORK : public Inst_SOPK
2054  {
2055  public:
2056  Inst_SOPK__S_CBRANCH_I_FORK(InFmt_SOPK*);
2057  ~Inst_SOPK__S_CBRANCH_I_FORK();
2058 
2059  int
2060  getNumOperands() override
2061  {
2062  return numDstRegOperands() + numSrcRegOperands();
2063  } // getNumOperands
2064 
2065  int numDstRegOperands() override { return 0; }
2066  int numSrcRegOperands() override { return 2; }
2067 
2068  int
2069  getOperandSize(int opIdx) override
2070  {
2071  switch (opIdx) {
2072  case 0: //sdst
2073  return 8;
2074  case 1: //
2075  return 16;
2076  default:
2077  fatal("op idx %i out of bounds\n", opIdx);
2078  return -1;
2079  }
2080  } // getOperandSize
2081 
2082  void execute(GPUDynInstPtr) override;
2083  }; // Inst_SOPK__S_CBRANCH_I_FORK
2084 
2085  class Inst_SOPK__S_GETREG_B32 : public Inst_SOPK
2086  {
2087  public:
2088  Inst_SOPK__S_GETREG_B32(InFmt_SOPK*);
2089  ~Inst_SOPK__S_GETREG_B32();
2090 
2091  int
2092  getNumOperands() override
2093  {
2094  return numDstRegOperands() + numSrcRegOperands();
2095  } // getNumOperands
2096 
2097  int numDstRegOperands() override { return 1; }
2098  int numSrcRegOperands() override { return 1; }
2099 
2100  int
2101  getOperandSize(int opIdx) override
2102  {
2103  switch (opIdx) {
2104  case 0: //simm16
2105  return 2;
2106  case 1: //sdst
2107  return 4;
2108  default:
2109  fatal("op idx %i out of bounds\n", opIdx);
2110  return -1;
2111  }
2112  } // getOperandSize
2113 
2114  void execute(GPUDynInstPtr) override;
2115  }; // Inst_SOPK__S_GETREG_B32
2116 
2117  class Inst_SOPK__S_SETREG_B32 : public Inst_SOPK
2118  {
2119  public:
2120  Inst_SOPK__S_SETREG_B32(InFmt_SOPK*);
2121  ~Inst_SOPK__S_SETREG_B32();
2122 
2123  int
2124  getNumOperands() override
2125  {
2126  return numDstRegOperands() + numSrcRegOperands();
2127  } // getNumOperands
2128 
2129  int numDstRegOperands() override { return 1; }
2130  int numSrcRegOperands() override { return 1; }
2131 
2132  int
2133  getOperandSize(int opIdx) override
2134  {
2135  switch (opIdx) {
2136  case 0: //ssrc
2137  return 4;
2138  case 1: //simm16
2139  return 2;
2140  default:
2141  fatal("op idx %i out of bounds\n", opIdx);
2142  return -1;
2143  }
2144  } // getOperandSize
2145 
2146  void execute(GPUDynInstPtr) override;
2147  }; // Inst_SOPK__S_SETREG_B32
2148 
2149  class Inst_SOPK__S_SETREG_IMM32_B32 : public Inst_SOPK
2150  {
2151  public:
2152  Inst_SOPK__S_SETREG_IMM32_B32(InFmt_SOPK*);
2153  ~Inst_SOPK__S_SETREG_IMM32_B32();
2154 
2155  int
2156  getNumOperands() override
2157  {
2158  return numDstRegOperands() + numSrcRegOperands();
2159  } // getNumOperands
2160 
2161  int numDstRegOperands() override { return 1; }
2162  int numSrcRegOperands() override { return 1; }
2163 
2164  int
2165  getOperandSize(int opIdx) override
2166  {
2167  switch (opIdx) {
2168  case 0: //simm32
2169  return 4;
2170  case 1: //simm16
2171  return 2;
2172  default:
2173  fatal("op idx %i out of bounds\n", opIdx);
2174  return -1;
2175  }
2176  } // getOperandSize
2177 
2178  void execute(GPUDynInstPtr) override;
2179  }; // Inst_SOPK__S_SETREG_IMM32_B32
2180 
2181  class Inst_SOP1__S_MOV_B32 : public Inst_SOP1
2182  {
2183  public:
2184  Inst_SOP1__S_MOV_B32(InFmt_SOP1*);
2185  ~Inst_SOP1__S_MOV_B32();
2186 
2187  int
2188  getNumOperands() override
2189  {
2190  return numDstRegOperands() + numSrcRegOperands();
2191  } // getNumOperands
2192 
2193  int numDstRegOperands() override { return 1; }
2194  int numSrcRegOperands() override { return 1; }
2195 
2196  int
2197  getOperandSize(int opIdx) override
2198  {
2199  switch (opIdx) {
2200  case 0: //ssrc
2201  return 4;
2202  case 1: //sdst
2203  return 4;
2204  default:
2205  fatal("op idx %i out of bounds\n", opIdx);
2206  return -1;
2207  }
2208  } // getOperandSize
2209 
2210  void execute(GPUDynInstPtr) override;
2211  }; // Inst_SOP1__S_MOV_B32
2212 
2213  class Inst_SOP1__S_MOV_B64 : public Inst_SOP1
2214  {
2215  public:
2216  Inst_SOP1__S_MOV_B64(InFmt_SOP1*);
2217  ~Inst_SOP1__S_MOV_B64();
2218 
2219  int
2220  getNumOperands() override
2221  {
2222  return numDstRegOperands() + numSrcRegOperands();
2223  } // getNumOperands
2224 
2225  int numDstRegOperands() override { return 1; }
2226  int numSrcRegOperands() override { return 1; }
2227 
2228  int
2229  getOperandSize(int opIdx) override
2230  {
2231  switch (opIdx) {
2232  case 0: //ssrc
2233  return 8;
2234  case 1: //sdst
2235  return 8;
2236  default:
2237  fatal("op idx %i out of bounds\n", opIdx);
2238  return -1;
2239  }
2240  } // getOperandSize
2241 
2242  void execute(GPUDynInstPtr) override;
2243  }; // Inst_SOP1__S_MOV_B64
2244 
2245  class Inst_SOP1__S_CMOV_B32 : public Inst_SOP1
2246  {
2247  public:
2248  Inst_SOP1__S_CMOV_B32(InFmt_SOP1*);
2249  ~Inst_SOP1__S_CMOV_B32();
2250 
2251  int
2252  getNumOperands() override
2253  {
2254  return numDstRegOperands() + numSrcRegOperands();
2255  } // getNumOperands
2256 
2257  int numDstRegOperands() override { return 1; }
2258  int numSrcRegOperands() override { return 1; }
2259 
2260  int
2261  getOperandSize(int opIdx) override
2262  {
2263  switch (opIdx) {
2264  case 0: //ssrc
2265  return 4;
2266  case 1: //sdst
2267  return 4;
2268  default:
2269  fatal("op idx %i out of bounds\n", opIdx);
2270  return -1;
2271  }
2272  } // getOperandSize
2273 
2274  void execute(GPUDynInstPtr) override;
2275  }; // Inst_SOP1__S_CMOV_B32
2276 
2277  class Inst_SOP1__S_CMOV_B64 : public Inst_SOP1
2278  {
2279  public:
2280  Inst_SOP1__S_CMOV_B64(InFmt_SOP1*);
2281  ~Inst_SOP1__S_CMOV_B64();
2282 
2283  int
2284  getNumOperands() override
2285  {
2286  return numDstRegOperands() + numSrcRegOperands();
2287  } // getNumOperands
2288 
2289  int numDstRegOperands() override { return 1; }
2290  int numSrcRegOperands() override { return 1; }
2291 
2292  int
2293  getOperandSize(int opIdx) override
2294  {
2295  switch (opIdx) {
2296  case 0: //ssrc
2297  return 8;
2298  case 1: //sdst
2299  return 8;
2300  default:
2301  fatal("op idx %i out of bounds\n", opIdx);
2302  return -1;
2303  }
2304  } // getOperandSize
2305 
2306  void execute(GPUDynInstPtr) override;
2307  }; // Inst_SOP1__S_CMOV_B64
2308 
2309  class Inst_SOP1__S_NOT_B32 : public Inst_SOP1
2310  {
2311  public:
2312  Inst_SOP1__S_NOT_B32(InFmt_SOP1*);
2313  ~Inst_SOP1__S_NOT_B32();
2314 
2315  int
2316  getNumOperands() override
2317  {
2318  return numDstRegOperands() + numSrcRegOperands();
2319  } // getNumOperands
2320 
2321  int numDstRegOperands() override { return 1; }
2322  int numSrcRegOperands() override { return 1; }
2323 
2324  int
2325  getOperandSize(int opIdx) override
2326  {
2327  switch (opIdx) {
2328  case 0: //ssrc
2329  return 4;
2330  case 1: //sdst
2331  return 4;
2332  default:
2333  fatal("op idx %i out of bounds\n", opIdx);
2334  return -1;
2335  }
2336  } // getOperandSize
2337 
2338  void execute(GPUDynInstPtr) override;
2339  }; // Inst_SOP1__S_NOT_B32
2340 
2341  class Inst_SOP1__S_NOT_B64 : public Inst_SOP1
2342  {
2343  public:
2344  Inst_SOP1__S_NOT_B64(InFmt_SOP1*);
2345  ~Inst_SOP1__S_NOT_B64();
2346 
2347  int
2348  getNumOperands() override
2349  {
2350  return numDstRegOperands() + numSrcRegOperands();
2351  } // getNumOperands
2352 
2353  int numDstRegOperands() override { return 1; }
2354  int numSrcRegOperands() override { return 1; }
2355 
2356  int
2357  getOperandSize(int opIdx) override
2358  {
2359  switch (opIdx) {
2360  case 0: //ssrc
2361  return 8;
2362  case 1: //sdst
2363  return 8;
2364  default:
2365  fatal("op idx %i out of bounds\n", opIdx);
2366  return -1;
2367  }
2368  } // getOperandSize
2369 
2370  void execute(GPUDynInstPtr) override;
2371  }; // Inst_SOP1__S_NOT_B64
2372 
2373  class Inst_SOP1__S_WQM_B32 : public Inst_SOP1
2374  {
2375  public:
2376  Inst_SOP1__S_WQM_B32(InFmt_SOP1*);
2377  ~Inst_SOP1__S_WQM_B32();
2378 
2379  int
2380  getNumOperands() override
2381  {
2382  return numDstRegOperands() + numSrcRegOperands();
2383  } // getNumOperands
2384 
2385  int numDstRegOperands() override { return 1; }
2386  int numSrcRegOperands() override { return 1; }
2387 
2388  int
2389  getOperandSize(int opIdx) override
2390  {
2391  switch (opIdx) {
2392  case 0: //ssrc
2393  return 4;
2394  case 1: //sdst
2395  return 4;
2396  default:
2397  fatal("op idx %i out of bounds\n", opIdx);
2398  return -1;
2399  }
2400  } // getOperandSize
2401 
2402  void execute(GPUDynInstPtr) override;
2403  }; // Inst_SOP1__S_WQM_B32
2404 
2405  class Inst_SOP1__S_WQM_B64 : public Inst_SOP1
2406  {
2407  public:
2408  Inst_SOP1__S_WQM_B64(InFmt_SOP1*);
2409  ~Inst_SOP1__S_WQM_B64();
2410 
2411  int
2412  getNumOperands() override
2413  {
2414  return numDstRegOperands() + numSrcRegOperands();
2415  } // getNumOperands
2416 
2417  int numDstRegOperands() override { return 1; }
2418  int numSrcRegOperands() override { return 1; }
2419 
2420  int
2421  getOperandSize(int opIdx) override
2422  {
2423  switch (opIdx) {
2424  case 0: //ssrc
2425  return 8;
2426  case 1: //sdst
2427  return 8;
2428  default:
2429  fatal("op idx %i out of bounds\n", opIdx);
2430  return -1;
2431  }
2432  } // getOperandSize
2433 
2434  void execute(GPUDynInstPtr) override;
2435  }; // Inst_SOP1__S_WQM_B64
2436 
2437  class Inst_SOP1__S_BREV_B32 : public Inst_SOP1
2438  {
2439  public:
2440  Inst_SOP1__S_BREV_B32(InFmt_SOP1*);
2441  ~Inst_SOP1__S_BREV_B32();
2442 
2443  int
2444  getNumOperands() override
2445  {
2446  return numDstRegOperands() + numSrcRegOperands();
2447  } // getNumOperands
2448 
2449  int numDstRegOperands() override { return 1; }
2450  int numSrcRegOperands() override { return 1; }
2451 
2452  int
2453  getOperandSize(int opIdx) override
2454  {
2455  switch (opIdx) {
2456  case 0: //ssrc
2457  return 4;
2458  case 1: //sdst
2459  return 4;
2460  default:
2461  fatal("op idx %i out of bounds\n", opIdx);
2462  return -1;
2463  }
2464  } // getOperandSize
2465 
2466  void execute(GPUDynInstPtr) override;
2467  }; // Inst_SOP1__S_BREV_B32
2468 
2469  class Inst_SOP1__S_BREV_B64 : public Inst_SOP1
2470  {
2471  public:
2472  Inst_SOP1__S_BREV_B64(InFmt_SOP1*);
2473  ~Inst_SOP1__S_BREV_B64();
2474 
2475  int
2476  getNumOperands() override
2477  {
2478  return numDstRegOperands() + numSrcRegOperands();
2479  } // getNumOperands
2480 
2481  int numDstRegOperands() override { return 1; }
2482  int numSrcRegOperands() override { return 1; }
2483 
2484  int
2485  getOperandSize(int opIdx) override
2486  {
2487  switch (opIdx) {
2488  case 0: //ssrc
2489  return 8;
2490  case 1: //sdst
2491  return 8;
2492  default:
2493  fatal("op idx %i out of bounds\n", opIdx);
2494  return -1;
2495  }
2496  } // getOperandSize
2497 
2498  void execute(GPUDynInstPtr) override;
2499  }; // Inst_SOP1__S_BREV_B64
2500 
2501  class Inst_SOP1__S_BCNT0_I32_B32 : public Inst_SOP1
2502  {
2503  public:
2504  Inst_SOP1__S_BCNT0_I32_B32(InFmt_SOP1*);
2505  ~Inst_SOP1__S_BCNT0_I32_B32();
2506 
2507  int
2508  getNumOperands() override
2509  {
2510  return numDstRegOperands() + numSrcRegOperands();
2511  } // getNumOperands
2512 
2513  int numDstRegOperands() override { return 1; }
2514  int numSrcRegOperands() override { return 1; }
2515 
2516  int
2517  getOperandSize(int opIdx) override
2518  {
2519  switch (opIdx) {
2520  case 0: //ssrc
2521  return 4;
2522  case 1: //sdst
2523  return 4;
2524  default:
2525  fatal("op idx %i out of bounds\n", opIdx);
2526  return -1;
2527  }
2528  } // getOperandSize
2529 
2530  void execute(GPUDynInstPtr) override;
2531  }; // Inst_SOP1__S_BCNT0_I32_B32
2532 
2533  class Inst_SOP1__S_BCNT0_I32_B64 : public Inst_SOP1
2534  {
2535  public:
2536  Inst_SOP1__S_BCNT0_I32_B64(InFmt_SOP1*);
2537  ~Inst_SOP1__S_BCNT0_I32_B64();
2538 
2539  int
2540  getNumOperands() override
2541  {
2542  return numDstRegOperands() + numSrcRegOperands();
2543  } // getNumOperands
2544 
2545  int numDstRegOperands() override { return 1; }
2546  int numSrcRegOperands() override { return 1; }
2547 
2548  int
2549  getOperandSize(int opIdx) override
2550  {
2551  switch (opIdx) {
2552  case 0: //ssrc
2553  return 8;
2554  case 1: //sdst
2555  return 4;
2556  default:
2557  fatal("op idx %i out of bounds\n", opIdx);
2558  return -1;
2559  }
2560  } // getOperandSize
2561 
2562  void execute(GPUDynInstPtr) override;
2563  }; // Inst_SOP1__S_BCNT0_I32_B64
2564 
2565  class Inst_SOP1__S_BCNT1_I32_B32 : public Inst_SOP1
2566  {
2567  public:
2568  Inst_SOP1__S_BCNT1_I32_B32(InFmt_SOP1*);
2569  ~Inst_SOP1__S_BCNT1_I32_B32();
2570 
2571  int
2572  getNumOperands() override
2573  {
2574  return numDstRegOperands() + numSrcRegOperands();
2575  } // getNumOperands
2576 
2577  int numDstRegOperands() override { return 1; }
2578  int numSrcRegOperands() override { return 1; }
2579 
2580  int
2581  getOperandSize(int opIdx) override
2582  {
2583  switch (opIdx) {
2584  case 0: //ssrc
2585  return 4;
2586  case 1: //sdst
2587  return 4;
2588  default:
2589  fatal("op idx %i out of bounds\n", opIdx);
2590  return -1;
2591  }
2592  } // getOperandSize
2593 
2594  void execute(GPUDynInstPtr) override;
2595  }; // Inst_SOP1__S_BCNT1_I32_B32
2596 
2597  class Inst_SOP1__S_BCNT1_I32_B64 : public Inst_SOP1
2598  {
2599  public:
2600  Inst_SOP1__S_BCNT1_I32_B64(InFmt_SOP1*);
2601  ~Inst_SOP1__S_BCNT1_I32_B64();
2602 
2603  int
2604  getNumOperands() override
2605  {
2606  return numDstRegOperands() + numSrcRegOperands();
2607  } // getNumOperands
2608 
2609  int numDstRegOperands() override { return 1; }
2610  int numSrcRegOperands() override { return 1; }
2611 
2612  int
2613  getOperandSize(int opIdx) override
2614  {
2615  switch (opIdx) {
2616  case 0: //ssrc
2617  return 8;
2618  case 1: //sdst
2619  return 4;
2620  default:
2621  fatal("op idx %i out of bounds\n", opIdx);
2622  return -1;
2623  }
2624  } // getOperandSize
2625 
2626  void execute(GPUDynInstPtr) override;
2627  }; // Inst_SOP1__S_BCNT1_I32_B64
2628 
2629  class Inst_SOP1__S_FF0_I32_B32 : public Inst_SOP1
2630  {
2631  public:
2632  Inst_SOP1__S_FF0_I32_B32(InFmt_SOP1*);
2633  ~Inst_SOP1__S_FF0_I32_B32();
2634 
2635  int
2636  getNumOperands() override
2637  {
2638  return numDstRegOperands() + numSrcRegOperands();
2639  } // getNumOperands
2640 
2641  int numDstRegOperands() override { return 1; }
2642  int numSrcRegOperands() override { return 1; }
2643 
2644  int
2645  getOperandSize(int opIdx) override
2646  {
2647  switch (opIdx) {
2648  case 0: //ssrc
2649  return 4;
2650  case 1: //sdst
2651  return 4;
2652  default:
2653  fatal("op idx %i out of bounds\n", opIdx);
2654  return -1;
2655  }
2656  } // getOperandSize
2657 
2658  void execute(GPUDynInstPtr) override;
2659  }; // Inst_SOP1__S_FF0_I32_B32
2660 
2661  class Inst_SOP1__S_FF0_I32_B64 : public Inst_SOP1
2662  {
2663  public:
2664  Inst_SOP1__S_FF0_I32_B64(InFmt_SOP1*);
2665  ~Inst_SOP1__S_FF0_I32_B64();
2666 
2667  int
2668  getNumOperands() override
2669  {
2670  return numDstRegOperands() + numSrcRegOperands();
2671  } // getNumOperands
2672 
2673  int numDstRegOperands() override { return 1; }
2674  int numSrcRegOperands() override { return 1; }
2675 
2676  int
2677  getOperandSize(int opIdx) override
2678  {
2679  switch (opIdx) {
2680  case 0: //ssrc
2681  return 8;
2682  case 1: //sdst
2683  return 4;
2684  default:
2685  fatal("op idx %i out of bounds\n", opIdx);
2686  return -1;
2687  }
2688  } // getOperandSize
2689 
2690  void execute(GPUDynInstPtr) override;
2691  }; // Inst_SOP1__S_FF0_I32_B64
2692 
2693  class Inst_SOP1__S_FF1_I32_B32 : public Inst_SOP1
2694  {
2695  public:
2696  Inst_SOP1__S_FF1_I32_B32(InFmt_SOP1*);
2697  ~Inst_SOP1__S_FF1_I32_B32();
2698 
2699  int
2700  getNumOperands() override
2701  {
2702  return numDstRegOperands() + numSrcRegOperands();
2703  } // getNumOperands
2704 
2705  int numDstRegOperands() override { return 1; }
2706  int numSrcRegOperands() override { return 1; }
2707 
2708  int
2709  getOperandSize(int opIdx) override
2710  {
2711  switch (opIdx) {
2712  case 0: //ssrc
2713  return 4;
2714  case 1: //sdst
2715  return 4;
2716  default:
2717  fatal("op idx %i out of bounds\n", opIdx);
2718  return -1;
2719  }
2720  } // getOperandSize
2721 
2722  void execute(GPUDynInstPtr) override;
2723  }; // Inst_SOP1__S_FF1_I32_B32
2724 
2725  class Inst_SOP1__S_FF1_I32_B64 : public Inst_SOP1
2726  {
2727  public:
2728  Inst_SOP1__S_FF1_I32_B64(InFmt_SOP1*);
2729  ~Inst_SOP1__S_FF1_I32_B64();
2730 
2731  int
2732  getNumOperands() override
2733  {
2734  return numDstRegOperands() + numSrcRegOperands();
2735  } // getNumOperands
2736 
2737  int numDstRegOperands() override { return 1; }
2738  int numSrcRegOperands() override { return 1; }
2739 
2740  int
2741  getOperandSize(int opIdx) override
2742  {
2743  switch (opIdx) {
2744  case 0: //ssrc
2745  return 8;
2746  case 1: //sdst
2747  return 4;
2748  default:
2749  fatal("op idx %i out of bounds\n", opIdx);
2750  return -1;
2751  }
2752  } // getOperandSize
2753 
2754  void execute(GPUDynInstPtr) override;
2755  }; // Inst_SOP1__S_FF1_I32_B64
2756 
2757  class Inst_SOP1__S_FLBIT_I32_B32 : public Inst_SOP1
2758  {
2759  public:
2760  Inst_SOP1__S_FLBIT_I32_B32(InFmt_SOP1*);
2761  ~Inst_SOP1__S_FLBIT_I32_B32();
2762 
2763  int
2764  getNumOperands() override
2765  {
2766  return numDstRegOperands() + numSrcRegOperands();
2767  } // getNumOperands
2768 
2769  int numDstRegOperands() override { return 1; }
2770  int numSrcRegOperands() override { return 1; }
2771 
2772  int
2773  getOperandSize(int opIdx) override
2774  {
2775  switch (opIdx) {
2776  case 0: //ssrc
2777  return 4;
2778  case 1: //sdst
2779  return 4;
2780  default:
2781  fatal("op idx %i out of bounds\n", opIdx);
2782  return -1;
2783  }
2784  } // getOperandSize
2785 
2786  void execute(GPUDynInstPtr) override;
2787  }; // Inst_SOP1__S_FLBIT_I32_B32
2788 
2789  class Inst_SOP1__S_FLBIT_I32_B64 : public Inst_SOP1
2790  {
2791  public:
2792  Inst_SOP1__S_FLBIT_I32_B64(InFmt_SOP1*);
2793  ~Inst_SOP1__S_FLBIT_I32_B64();
2794 
2795  int
2796  getNumOperands() override
2797  {
2798  return numDstRegOperands() + numSrcRegOperands();
2799  } // getNumOperands
2800 
2801  int numDstRegOperands() override { return 1; }
2802  int numSrcRegOperands() override { return 1; }
2803 
2804  int
2805  getOperandSize(int opIdx) override
2806  {
2807  switch (opIdx) {
2808  case 0: //ssrc
2809  return 8;
2810  case 1: //sdst
2811  return 4;
2812  default:
2813  fatal("op idx %i out of bounds\n", opIdx);
2814  return -1;
2815  }
2816  } // getOperandSize
2817 
2818  void execute(GPUDynInstPtr) override;
2819  }; // Inst_SOP1__S_FLBIT_I32_B64
2820 
2821  class Inst_SOP1__S_FLBIT_I32 : public Inst_SOP1
2822  {
2823  public:
2824  Inst_SOP1__S_FLBIT_I32(InFmt_SOP1*);
2825  ~Inst_SOP1__S_FLBIT_I32();
2826 
2827  int
2828  getNumOperands() override
2829  {
2830  return numDstRegOperands() + numSrcRegOperands();
2831  } // getNumOperands
2832 
2833  int numDstRegOperands() override { return 1; }
2834  int numSrcRegOperands() override { return 1; }
2835 
2836  int
2837  getOperandSize(int opIdx) override
2838  {
2839  switch (opIdx) {
2840  case 0: //ssrc
2841  return 4;
2842  case 1: //sdst
2843  return 4;
2844  default:
2845  fatal("op idx %i out of bounds\n", opIdx);
2846  return -1;
2847  }
2848  } // getOperandSize
2849 
2850  void execute(GPUDynInstPtr) override;
2851  }; // Inst_SOP1__S_FLBIT_I32
2852 
2853  class Inst_SOP1__S_FLBIT_I32_I64 : public Inst_SOP1
2854  {
2855  public:
2856  Inst_SOP1__S_FLBIT_I32_I64(InFmt_SOP1*);
2857  ~Inst_SOP1__S_FLBIT_I32_I64();
2858 
2859  int
2860  getNumOperands() override
2861  {
2862  return numDstRegOperands() + numSrcRegOperands();
2863  } // getNumOperands
2864 
2865  int numDstRegOperands() override { return 1; }
2866  int numSrcRegOperands() override { return 1; }
2867 
2868  int
2869  getOperandSize(int opIdx) override
2870  {
2871  switch (opIdx) {
2872  case 0: //ssrc
2873  return 8;
2874  case 1: //sdst
2875  return 4;
2876  default:
2877  fatal("op idx %i out of bounds\n", opIdx);
2878  return -1;
2879  }
2880  } // getOperandSize
2881 
2882  void execute(GPUDynInstPtr) override;
2883  }; // Inst_SOP1__S_FLBIT_I32_I64
2884 
2885  class Inst_SOP1__S_SEXT_I32_I8 : public Inst_SOP1
2886  {
2887  public:
2888  Inst_SOP1__S_SEXT_I32_I8(InFmt_SOP1*);
2889  ~Inst_SOP1__S_SEXT_I32_I8();
2890 
2891  int
2892  getNumOperands() override
2893  {
2894  return numDstRegOperands() + numSrcRegOperands();
2895  } // getNumOperands
2896 
2897  int numDstRegOperands() override { return 1; }
2898  int numSrcRegOperands() override { return 1; }
2899 
2900  int
2901  getOperandSize(int opIdx) override
2902  {
2903  switch (opIdx) {
2904  case 0: //ssrc
2905  return 4;
2906  case 1: //sdst
2907  return 4;
2908  default:
2909  fatal("op idx %i out of bounds\n", opIdx);
2910  return -1;
2911  }
2912  } // getOperandSize
2913 
2914  void execute(GPUDynInstPtr) override;
2915  }; // Inst_SOP1__S_SEXT_I32_I8
2916 
2917  class Inst_SOP1__S_SEXT_I32_I16 : public Inst_SOP1
2918  {
2919  public:
2920  Inst_SOP1__S_SEXT_I32_I16(InFmt_SOP1*);
2921  ~Inst_SOP1__S_SEXT_I32_I16();
2922 
2923  int
2924  getNumOperands() override
2925  {
2926  return numDstRegOperands() + numSrcRegOperands();
2927  } // getNumOperands
2928 
2929  int numDstRegOperands() override { return 1; }
2930  int numSrcRegOperands() override { return 1; }
2931 
2932  int
2933  getOperandSize(int opIdx) override
2934  {
2935  switch (opIdx) {
2936  case 0: //ssrc
2937  return 4;
2938  case 1: //sdst
2939  return 4;
2940  default:
2941  fatal("op idx %i out of bounds\n", opIdx);
2942  return -1;
2943  }
2944  } // getOperandSize
2945 
2946  void execute(GPUDynInstPtr) override;
2947  }; // Inst_SOP1__S_SEXT_I32_I16
2948 
2949  class Inst_SOP1__S_BITSET0_B32 : public Inst_SOP1
2950  {
2951  public:
2952  Inst_SOP1__S_BITSET0_B32(InFmt_SOP1*);
2953  ~Inst_SOP1__S_BITSET0_B32();
2954 
2955  int
2956  getNumOperands() override
2957  {
2958  return numDstRegOperands() + numSrcRegOperands();
2959  } // getNumOperands
2960 
2961  int numDstRegOperands() override { return 1; }
2962  int numSrcRegOperands() override { return 1; }
2963 
2964  int
2965  getOperandSize(int opIdx) override
2966  {
2967  switch (opIdx) {
2968  case 0: //ssrc
2969  return 4;
2970  case 1: //sdst
2971  return 4;
2972  default:
2973  fatal("op idx %i out of bounds\n", opIdx);
2974  return -1;
2975  }
2976  } // getOperandSize
2977 
2978  void execute(GPUDynInstPtr) override;
2979  }; // Inst_SOP1__S_BITSET0_B32
2980 
2981  class Inst_SOP1__S_BITSET0_B64 : public Inst_SOP1
2982  {
2983  public:
2984  Inst_SOP1__S_BITSET0_B64(InFmt_SOP1*);
2985  ~Inst_SOP1__S_BITSET0_B64();
2986 
2987  int
2988  getNumOperands() override
2989  {
2990  return numDstRegOperands() + numSrcRegOperands();
2991  } // getNumOperands
2992 
2993  int numDstRegOperands() override { return 1; }
2994  int numSrcRegOperands() override { return 1; }
2995 
2996  int
2997  getOperandSize(int opIdx) override
2998  {
2999  switch (opIdx) {
3000  case 0: //ssrc
3001  return 4;
3002  case 1: //sdst
3003  return 8;
3004  default:
3005  fatal("op idx %i out of bounds\n", opIdx);
3006  return -1;
3007  }
3008  } // getOperandSize
3009 
3010  void execute(GPUDynInstPtr) override;
3011  }; // Inst_SOP1__S_BITSET0_B64
3012 
3013  class Inst_SOP1__S_BITSET1_B32 : public Inst_SOP1
3014  {
3015  public:
3016  Inst_SOP1__S_BITSET1_B32(InFmt_SOP1*);
3017  ~Inst_SOP1__S_BITSET1_B32();
3018 
3019  int
3020  getNumOperands() override
3021  {
3022  return numDstRegOperands() + numSrcRegOperands();
3023  } // getNumOperands
3024 
3025  int numDstRegOperands() override { return 1; }
3026  int numSrcRegOperands() override { return 1; }
3027 
3028  int
3029  getOperandSize(int opIdx) override
3030  {
3031  switch (opIdx) {
3032  case 0: //ssrc
3033  return 4;
3034  case 1: //sdst
3035  return 4;
3036  default:
3037  fatal("op idx %i out of bounds\n", opIdx);
3038  return -1;
3039  }
3040  } // getOperandSize
3041 
3042  void execute(GPUDynInstPtr) override;
3043  }; // Inst_SOP1__S_BITSET1_B32
3044 
3045  class Inst_SOP1__S_BITSET1_B64 : public Inst_SOP1
3046  {
3047  public:
3048  Inst_SOP1__S_BITSET1_B64(InFmt_SOP1*);
3049  ~Inst_SOP1__S_BITSET1_B64();
3050 
3051  int
3052  getNumOperands() override
3053  {
3054  return numDstRegOperands() + numSrcRegOperands();
3055  } // getNumOperands
3056 
3057  int numDstRegOperands() override { return 1; }
3058  int numSrcRegOperands() override { return 1; }
3059 
3060  int
3061  getOperandSize(int opIdx) override
3062  {
3063  switch (opIdx) {
3064  case 0: //ssrc
3065  return 4;
3066  case 1: //sdst
3067  return 8;
3068  default:
3069  fatal("op idx %i out of bounds\n", opIdx);
3070  return -1;
3071  }
3072  } // getOperandSize
3073 
3074  void execute(GPUDynInstPtr) override;
3075  }; // Inst_SOP1__S_BITSET1_B64
3076 
3077  class Inst_SOP1__S_GETPC_B64 : public Inst_SOP1
3078  {
3079  public:
3080  Inst_SOP1__S_GETPC_B64(InFmt_SOP1*);
3081  ~Inst_SOP1__S_GETPC_B64();
3082 
3083  int
3084  getNumOperands() override
3085  {
3086  return numDstRegOperands() + numSrcRegOperands();
3087  } // getNumOperands
3088 
3089  int numDstRegOperands() override { return 1; }
3090  int numSrcRegOperands() override { return 0; }
3091 
3092  int
3093  getOperandSize(int opIdx) override
3094  {
3095  switch (opIdx) {
3096  case 0: //sdst
3097  return 8;
3098  default:
3099  fatal("op idx %i out of bounds\n", opIdx);
3100  return -1;
3101  }
3102  } // getOperandSize
3103 
3104  void execute(GPUDynInstPtr) override;
3105  }; // Inst_SOP1__S_GETPC_B64
3106 
3107  class Inst_SOP1__S_SETPC_B64 : public Inst_SOP1
3108  {
3109  public:
3110  Inst_SOP1__S_SETPC_B64(InFmt_SOP1*);
3111  ~Inst_SOP1__S_SETPC_B64();
3112 
3113  int
3114  getNumOperands() override
3115  {
3116  return numDstRegOperands() + numSrcRegOperands();
3117  } // getNumOperands
3118 
3119  int numDstRegOperands() override { return 0; }
3120  int numSrcRegOperands() override { return 1; }
3121 
3122  int
3123  getOperandSize(int opIdx) override
3124  {
3125  switch (opIdx) {
3126  case 0: //ssrc
3127  return 8;
3128  case 1: //sdst
3129  return 8;
3130  default:
3131  fatal("op idx %i out of bounds\n", opIdx);
3132  return -1;
3133  }
3134  } // getOperandSize
3135 
3136  void execute(GPUDynInstPtr) override;
3137  }; // Inst_SOP1__S_SETPC_B64
3138 
3139  class Inst_SOP1__S_SWAPPC_B64 : public Inst_SOP1
3140  {
3141  public:
3142  Inst_SOP1__S_SWAPPC_B64(InFmt_SOP1*);
3143  ~Inst_SOP1__S_SWAPPC_B64();
3144 
3145  int
3146  getNumOperands() override
3147  {
3148  return numDstRegOperands() + numSrcRegOperands();
3149  } // getNumOperands
3150 
3151  int numDstRegOperands() override { return 1; }
3152  int numSrcRegOperands() override { return 1; }
3153 
3154  int
3155  getOperandSize(int opIdx) override
3156  {
3157  switch (opIdx) {
3158  case 0: //ssrc
3159  return 8;
3160  case 1: //sdst
3161  return 8;
3162  default:
3163  fatal("op idx %i out of bounds\n", opIdx);
3164  return -1;
3165  }
3166  } // getOperandSize
3167 
3168  void execute(GPUDynInstPtr) override;
3169  }; // Inst_SOP1__S_SWAPPC_B64
3170 
3171  class Inst_SOP1__S_RFE_B64 : public Inst_SOP1
3172  {
3173  public:
3174  Inst_SOP1__S_RFE_B64(InFmt_SOP1*);
3175  ~Inst_SOP1__S_RFE_B64();
3176 
3177  int
3178  getNumOperands() override
3179  {
3180  return numDstRegOperands() + numSrcRegOperands();
3181  } // getNumOperands
3182 
3183  int numDstRegOperands() override { return 0; }
3184  int numSrcRegOperands() override { return 1; }
3185 
3186  int
3187  getOperandSize(int opIdx) override
3188  {
3189  switch (opIdx) {
3190  case 0: //ssrc
3191  return 8;
3192  case 1: //sdst
3193  return 8;
3194  default:
3195  fatal("op idx %i out of bounds\n", opIdx);
3196  return -1;
3197  }
3198  } // getOperandSize
3199 
3200  void execute(GPUDynInstPtr) override;
3201  }; // Inst_SOP1__S_RFE_B64
3202 
3203  class Inst_SOP1__S_AND_SAVEEXEC_B64 : public Inst_SOP1
3204  {
3205  public:
3206  Inst_SOP1__S_AND_SAVEEXEC_B64(InFmt_SOP1*);
3207  ~Inst_SOP1__S_AND_SAVEEXEC_B64();
3208 
3209  int
3210  getNumOperands() override
3211  {
3212  return numDstRegOperands() + numSrcRegOperands();
3213  } // getNumOperands
3214 
3215  int numDstRegOperands() override { return 1; }
3216  int numSrcRegOperands() override { return 1; }
3217 
3218  int
3219  getOperandSize(int opIdx) override
3220  {
3221  switch (opIdx) {
3222  case 0: //ssrc
3223  return 8;
3224  case 1: //sdst
3225  return 8;
3226  default:
3227  fatal("op idx %i out of bounds\n", opIdx);
3228  return -1;
3229  }
3230  } // getOperandSize
3231 
3232  void execute(GPUDynInstPtr) override;
3233  }; // Inst_SOP1__S_AND_SAVEEXEC_B64
3234 
3235  class Inst_SOP1__S_OR_SAVEEXEC_B64 : public Inst_SOP1
3236  {
3237  public:
3238  Inst_SOP1__S_OR_SAVEEXEC_B64(InFmt_SOP1*);
3239  ~Inst_SOP1__S_OR_SAVEEXEC_B64();
3240 
3241  int
3242  getNumOperands() override
3243  {
3244  return numDstRegOperands() + numSrcRegOperands();
3245  } // getNumOperands
3246 
3247  int numDstRegOperands() override { return 1; }
3248  int numSrcRegOperands() override { return 1; }
3249 
3250  int
3251  getOperandSize(int opIdx) override
3252  {
3253  switch (opIdx) {
3254  case 0: //ssrc
3255  return 8;
3256  case 1: //sdst
3257  return 8;
3258  default:
3259  fatal("op idx %i out of bounds\n", opIdx);
3260  return -1;
3261  }
3262  } // getOperandSize
3263 
3264  void execute(GPUDynInstPtr) override;
3265  }; // Inst_SOP1__S_OR_SAVEEXEC_B64
3266 
3267  class Inst_SOP1__S_XOR_SAVEEXEC_B64 : public Inst_SOP1
3268  {
3269  public:
3270  Inst_SOP1__S_XOR_SAVEEXEC_B64(InFmt_SOP1*);
3271  ~Inst_SOP1__S_XOR_SAVEEXEC_B64();
3272 
3273  int
3274  getNumOperands() override
3275  {
3276  return numDstRegOperands() + numSrcRegOperands();
3277  } // getNumOperands
3278 
3279  int numDstRegOperands() override { return 1; }
3280  int numSrcRegOperands() override { return 1; }
3281 
3282  int
3283  getOperandSize(int opIdx) override
3284  {
3285  switch (opIdx) {
3286  case 0: //ssrc
3287  return 8;
3288  case 1: //sdst
3289  return 8;
3290  default:
3291  fatal("op idx %i out of bounds\n", opIdx);
3292  return -1;
3293  }
3294  } // getOperandSize
3295 
3296  void execute(GPUDynInstPtr) override;
3297  }; // Inst_SOP1__S_XOR_SAVEEXEC_B64
3298 
3299  class Inst_SOP1__S_ANDN2_SAVEEXEC_B64 : public Inst_SOP1
3300  {
3301  public:
3302  Inst_SOP1__S_ANDN2_SAVEEXEC_B64(InFmt_SOP1*);
3303  ~Inst_SOP1__S_ANDN2_SAVEEXEC_B64();
3304 
3305  int
3306  getNumOperands() override
3307  {
3308  return numDstRegOperands() + numSrcRegOperands();
3309  } // getNumOperands
3310 
3311  int numDstRegOperands() override { return 1; }
3312  int numSrcRegOperands() override { return 1; }
3313 
3314  int
3315  getOperandSize(int opIdx) override
3316  {
3317  switch (opIdx) {
3318  case 0: //ssrc
3319  return 8;
3320  case 1: //sdst
3321  return 8;
3322  default:
3323  fatal("op idx %i out of bounds\n", opIdx);
3324  return -1;
3325  }
3326  } // getOperandSize
3327 
3328  void execute(GPUDynInstPtr) override;
3329  }; // Inst_SOP1__S_ANDN2_SAVEEXEC_B64
3330 
3331  class Inst_SOP1__S_ORN2_SAVEEXEC_B64 : public Inst_SOP1
3332  {
3333  public:
3334  Inst_SOP1__S_ORN2_SAVEEXEC_B64(InFmt_SOP1*);
3335  ~Inst_SOP1__S_ORN2_SAVEEXEC_B64();
3336 
3337  int
3338  getNumOperands() override
3339  {
3340  return numDstRegOperands() + numSrcRegOperands();
3341  } // getNumOperands
3342 
3343  int numDstRegOperands() override { return 1; }
3344  int numSrcRegOperands() override { return 1; }
3345 
3346  int
3347  getOperandSize(int opIdx) override
3348  {
3349  switch (opIdx) {
3350  case 0: //ssrc
3351  return 8;
3352  case 1: //sdst
3353  return 8;
3354  default:
3355  fatal("op idx %i out of bounds\n", opIdx);
3356  return -1;
3357  }
3358  } // getOperandSize
3359 
3360  void execute(GPUDynInstPtr) override;
3361  }; // Inst_SOP1__S_ORN2_SAVEEXEC_B64
3362 
3363  class Inst_SOP1__S_NAND_SAVEEXEC_B64 : public Inst_SOP1
3364  {
3365  public:
3366  Inst_SOP1__S_NAND_SAVEEXEC_B64(InFmt_SOP1*);
3367  ~Inst_SOP1__S_NAND_SAVEEXEC_B64();
3368 
3369  int
3370  getNumOperands() override
3371  {
3372  return numDstRegOperands() + numSrcRegOperands();
3373  } // getNumOperands
3374 
3375  int numDstRegOperands() override { return 1; }
3376  int numSrcRegOperands() override { return 1; }
3377 
3378  int
3379  getOperandSize(int opIdx) override
3380  {
3381  switch (opIdx) {
3382  case 0: //ssrc
3383  return 8;
3384  case 1: //sdst
3385  return 8;
3386  default:
3387  fatal("op idx %i out of bounds\n", opIdx);
3388  return -1;
3389  }
3390  } // getOperandSize
3391 
3392  void execute(GPUDynInstPtr) override;
3393  }; // Inst_SOP1__S_NAND_SAVEEXEC_B64
3394 
3395  class Inst_SOP1__S_NOR_SAVEEXEC_B64 : public Inst_SOP1
3396  {
3397  public:
3398  Inst_SOP1__S_NOR_SAVEEXEC_B64(InFmt_SOP1*);
3399  ~Inst_SOP1__S_NOR_SAVEEXEC_B64();
3400 
3401  int
3402  getNumOperands() override
3403  {
3404  return numDstRegOperands() + numSrcRegOperands();
3405  } // getNumOperands
3406 
3407  int numDstRegOperands() override { return 1; }
3408  int numSrcRegOperands() override { return 1; }
3409 
3410  int
3411  getOperandSize(int opIdx) override
3412  {
3413  switch (opIdx) {
3414  case 0: //ssrc
3415  return 8;
3416  case 1: //sdst
3417  return 8;
3418  default:
3419  fatal("op idx %i out of bounds\n", opIdx);
3420  return -1;
3421  }
3422  } // getOperandSize
3423 
3424  void execute(GPUDynInstPtr) override;
3425  }; // Inst_SOP1__S_NOR_SAVEEXEC_B64
3426 
3427  class Inst_SOP1__S_XNOR_SAVEEXEC_B64 : public Inst_SOP1
3428  {
3429  public:
3430  Inst_SOP1__S_XNOR_SAVEEXEC_B64(InFmt_SOP1*);
3431  ~Inst_SOP1__S_XNOR_SAVEEXEC_B64();
3432 
3433  int
3434  getNumOperands() override
3435  {
3436  return numDstRegOperands() + numSrcRegOperands();
3437  } // getNumOperands
3438 
3439  int numDstRegOperands() override { return 1; }
3440  int numSrcRegOperands() override { return 1; }
3441 
3442  int
3443  getOperandSize(int opIdx) override
3444  {
3445  switch (opIdx) {
3446  case 0: //ssrc
3447  return 8;
3448  case 1: //sdst
3449  return 8;
3450  default:
3451  fatal("op idx %i out of bounds\n", opIdx);
3452  return -1;
3453  }
3454  } // getOperandSize
3455 
3456  void execute(GPUDynInstPtr) override;
3457  }; // Inst_SOP1__S_XNOR_SAVEEXEC_B64
3458 
3459  class Inst_SOP1__S_QUADMASK_B32 : public Inst_SOP1
3460  {
3461  public:
3462  Inst_SOP1__S_QUADMASK_B32(InFmt_SOP1*);
3463  ~Inst_SOP1__S_QUADMASK_B32();
3464 
3465  int
3466  getNumOperands() override
3467  {
3468  return numDstRegOperands() + numSrcRegOperands();
3469  } // getNumOperands
3470 
3471  int numDstRegOperands() override { return 1; }
3472  int numSrcRegOperands() override { return 1; }
3473 
3474  int
3475  getOperandSize(int opIdx) override
3476  {
3477  switch (opIdx) {
3478  case 0: //ssrc
3479  return 4;
3480  case 1: //sdst
3481  return 4;
3482  default:
3483  fatal("op idx %i out of bounds\n", opIdx);
3484  return -1;
3485  }
3486  } // getOperandSize
3487 
3488  void execute(GPUDynInstPtr) override;
3489  }; // Inst_SOP1__S_QUADMASK_B32
3490 
3491  class Inst_SOP1__S_QUADMASK_B64 : public Inst_SOP1
3492  {
3493  public:
3494  Inst_SOP1__S_QUADMASK_B64(InFmt_SOP1*);
3495  ~Inst_SOP1__S_QUADMASK_B64();
3496 
3497  int
3498  getNumOperands() override
3499  {
3500  return numDstRegOperands() + numSrcRegOperands();
3501  } // getNumOperands
3502 
3503  int numDstRegOperands() override { return 1; }
3504  int numSrcRegOperands() override { return 1; }
3505 
3506  int
3507  getOperandSize(int opIdx) override
3508  {
3509  switch (opIdx) {
3510  case 0: //ssrc
3511  return 8;
3512  case 1: //sdst
3513  return 8;
3514  default:
3515  fatal("op idx %i out of bounds\n", opIdx);
3516  return -1;
3517  }
3518  } // getOperandSize
3519 
3520  void execute(GPUDynInstPtr) override;
3521  }; // Inst_SOP1__S_QUADMASK_B64
3522 
3523  class Inst_SOP1__S_MOVRELS_B32 : public Inst_SOP1
3524  {
3525  public:
3526  Inst_SOP1__S_MOVRELS_B32(InFmt_SOP1*);
3527  ~Inst_SOP1__S_MOVRELS_B32();
3528 
3529  int
3530  getNumOperands() override
3531  {
3532  return numDstRegOperands() + numSrcRegOperands();
3533  } // getNumOperands
3534 
3535  int numDstRegOperands() override { return 1; }
3536  int numSrcRegOperands() override { return 1; }
3537 
3538  int
3539  getOperandSize(int opIdx) override
3540  {
3541  switch (opIdx) {
3542  case 0: //ssrc
3543  return 4;
3544  case 1: //sdst
3545  return 4;
3546  default:
3547  fatal("op idx %i out of bounds\n", opIdx);
3548  return -1;
3549  }
3550  } // getOperandSize
3551 
3552  void execute(GPUDynInstPtr) override;
3553  }; // Inst_SOP1__S_MOVRELS_B32
3554 
3555  class Inst_SOP1__S_MOVRELS_B64 : public Inst_SOP1
3556  {
3557  public:
3558  Inst_SOP1__S_MOVRELS_B64(InFmt_SOP1*);
3559  ~Inst_SOP1__S_MOVRELS_B64();
3560 
3561  int
3562  getNumOperands() override
3563  {
3564  return numDstRegOperands() + numSrcRegOperands();
3565  } // getNumOperands
3566 
3567  int numDstRegOperands() override { return 1; }
3568  int numSrcRegOperands() override { return 1; }
3569 
3570  int
3571  getOperandSize(int opIdx) override
3572  {
3573  switch (opIdx) {
3574  case 0: //sdst
3575  return 8;
3576  case 1: //sdst
3577  return 8;
3578  default:
3579  fatal("op idx %i out of bounds\n", opIdx);
3580  return -1;
3581  }
3582  } // getOperandSize
3583 
3584  void execute(GPUDynInstPtr) override;
3585  }; // Inst_SOP1__S_MOVRELS_B64
3586 
3587  class Inst_SOP1__S_MOVRELD_B32 : public Inst_SOP1
3588  {
3589  public:
3590  Inst_SOP1__S_MOVRELD_B32(InFmt_SOP1*);
3591  ~Inst_SOP1__S_MOVRELD_B32();
3592 
3593  int
3594  getNumOperands() override
3595  {
3596  return numDstRegOperands() + numSrcRegOperands();
3597  } // getNumOperands
3598 
3599  int numDstRegOperands() override { return 1; }
3600  int numSrcRegOperands() override { return 1; }
3601 
3602  int
3603  getOperandSize(int opIdx) override
3604  {
3605  switch (opIdx) {
3606  case 0: //ssrc
3607  return 4;
3608  case 1: //sdst
3609  return 4;
3610  default:
3611  fatal("op idx %i out of bounds\n", opIdx);
3612  return -1;
3613  }
3614  } // getOperandSize
3615 
3616  void execute(GPUDynInstPtr) override;
3617  }; // Inst_SOP1__S_MOVRELD_B32
3618 
3619  class Inst_SOP1__S_MOVRELD_B64 : public Inst_SOP1
3620  {
3621  public:
3622  Inst_SOP1__S_MOVRELD_B64(InFmt_SOP1*);
3623  ~Inst_SOP1__S_MOVRELD_B64();
3624 
3625  int
3626  getNumOperands() override
3627  {
3628  return numDstRegOperands() + numSrcRegOperands();
3629  } // getNumOperands
3630 
3631  int numDstRegOperands() override { return 1; }
3632  int numSrcRegOperands() override { return 1; }
3633 
3634  int
3635  getOperandSize(int opIdx) override
3636  {
3637  switch (opIdx) {
3638  case 0: //ssrc
3639  return 8;
3640  case 1: //sdst
3641  return 8;
3642  default:
3643  fatal("op idx %i out of bounds\n", opIdx);
3644  return -1;
3645  }
3646  } // getOperandSize
3647 
3648  void execute(GPUDynInstPtr) override;
3649  }; // Inst_SOP1__S_MOVRELD_B64
3650 
3651  class Inst_SOP1__S_CBRANCH_JOIN : public Inst_SOP1
3652  {
3653  public:
3654  Inst_SOP1__S_CBRANCH_JOIN(InFmt_SOP1*);
3655  ~Inst_SOP1__S_CBRANCH_JOIN();
3656 
3657  int
3658  getNumOperands() override
3659  {
3660  return numDstRegOperands() + numSrcRegOperands();
3661  } // getNumOperands
3662 
3663  int numDstRegOperands() override { return 0; }
3664  int numSrcRegOperands() override { return 1; }
3665 
3666  int
3667  getOperandSize(int opIdx) override
3668  {
3669  switch (opIdx) {
3670  case 0: //ssrc
3671  return 4;
3672  case 1: //sdst
3673  return 4;
3674  default:
3675  fatal("op idx %i out of bounds\n", opIdx);
3676  return -1;
3677  }
3678  } // getOperandSize
3679 
3680  void execute(GPUDynInstPtr) override;
3681  }; // Inst_SOP1__S_CBRANCH_JOIN
3682 
3683  class Inst_SOP1__S_ABS_I32 : public Inst_SOP1
3684  {
3685  public:
3686  Inst_SOP1__S_ABS_I32(InFmt_SOP1*);
3687  ~Inst_SOP1__S_ABS_I32();
3688 
3689  int
3690  getNumOperands() override
3691  {
3692  return numDstRegOperands() + numSrcRegOperands();
3693  } // getNumOperands
3694 
3695  int numDstRegOperands() override { return 1; }
3696  int numSrcRegOperands() override { return 1; }
3697 
3698  int
3699  getOperandSize(int opIdx) override
3700  {
3701  switch (opIdx) {
3702  case 0: //ssrc
3703  return 4;
3704  case 1: //sdst
3705  return 4;
3706  default:
3707  fatal("op idx %i out of bounds\n", opIdx);
3708  return -1;
3709  }
3710  } // getOperandSize
3711 
3712  void execute(GPUDynInstPtr) override;
3713  }; // Inst_SOP1__S_ABS_I32
3714 
3715  class Inst_SOP1__S_MOV_FED_B32 : public Inst_SOP1
3716  {
3717  public:
3718  Inst_SOP1__S_MOV_FED_B32(InFmt_SOP1*);
3719  ~Inst_SOP1__S_MOV_FED_B32();
3720 
3721  int
3722  getNumOperands() override
3723  {
3724  return numDstRegOperands() + numSrcRegOperands();
3725  } // getNumOperands
3726 
3727  int numDstRegOperands() override { return 1; }
3728  int numSrcRegOperands() override { return 1; }
3729 
3730  int
3731  getOperandSize(int opIdx) override
3732  {
3733  switch (opIdx) {
3734  case 0: //ssrc
3735  return 4;
3736  case 1: //sdst
3737  return 4;
3738  default:
3739  fatal("op idx %i out of bounds\n", opIdx);
3740  return -1;
3741  }
3742  } // getOperandSize
3743 
3744  void execute(GPUDynInstPtr) override;
3745  }; // Inst_SOP1__S_MOV_FED_B32
3746 
3747  class Inst_SOP1__S_SET_GPR_IDX_IDX : public Inst_SOP1
3748  {
3749  public:
3750  Inst_SOP1__S_SET_GPR_IDX_IDX(InFmt_SOP1*);
3751  ~Inst_SOP1__S_SET_GPR_IDX_IDX();
3752 
3753  int
3754  getNumOperands() override
3755  {
3756  return numDstRegOperands() + numSrcRegOperands();
3757  } // getNumOperands
3758 
3759  int numDstRegOperands() override { return 0; }
3760  int numSrcRegOperands() override { return 1; }
3761 
3762  int
3763  getOperandSize(int opIdx) override
3764  {
3765  switch (opIdx) {
3766  case 0: //ssrc
3767  return 4;
3768  case 1: //sdst
3769  return 4;
3770  default:
3771  fatal("op idx %i out of bounds\n", opIdx);
3772  return -1;
3773  }
3774  } // getOperandSize
3775 
3776  void execute(GPUDynInstPtr) override;
3777  }; // Inst_SOP1__S_SET_GPR_IDX_IDX
3778 
3779  class Inst_SOPC__S_CMP_EQ_I32 : public Inst_SOPC
3780  {
3781  public:
3782  Inst_SOPC__S_CMP_EQ_I32(InFmt_SOPC*);
3783  ~Inst_SOPC__S_CMP_EQ_I32();
3784 
3785  int
3786  getNumOperands() override
3787  {
3788  return numDstRegOperands() + numSrcRegOperands();
3789  } // getNumOperands
3790 
3791  int numDstRegOperands() override { return 0; }
3792  int numSrcRegOperands() override { return 2; }
3793 
3794  int
3795  getOperandSize(int opIdx) override
3796  {
3797  switch (opIdx) {
3798  case 0: //ssrc_0
3799  return 4;
3800  case 1: //ssrc_1
3801  return 4;
3802  default:
3803  fatal("op idx %i out of bounds\n", opIdx);
3804  return -1;
3805  }
3806  } // getOperandSize
3807 
3808  void execute(GPUDynInstPtr) override;
3809  }; // Inst_SOPC__S_CMP_EQ_I32
3810 
3811  class Inst_SOPC__S_CMP_LG_I32 : public Inst_SOPC
3812  {
3813  public:
3814  Inst_SOPC__S_CMP_LG_I32(InFmt_SOPC*);
3815  ~Inst_SOPC__S_CMP_LG_I32();
3816 
3817  int
3818  getNumOperands() override
3819  {
3820  return numDstRegOperands() + numSrcRegOperands();
3821  } // getNumOperands
3822 
3823  int numDstRegOperands() override { return 0; }
3824  int numSrcRegOperands() override { return 2; }
3825 
3826  int
3827  getOperandSize(int opIdx) override
3828  {
3829  switch (opIdx) {
3830  case 0: //ssrc_0
3831  return 4;
3832  case 1: //ssrc_1
3833  return 4;
3834  default:
3835  fatal("op idx %i out of bounds\n", opIdx);
3836  return -1;
3837  }
3838  } // getOperandSize
3839 
3840  void execute(GPUDynInstPtr) override;
3841  }; // Inst_SOPC__S_CMP_LG_I32
3842 
3843  class Inst_SOPC__S_CMP_GT_I32 : public Inst_SOPC
3844  {
3845  public:
3846  Inst_SOPC__S_CMP_GT_I32(InFmt_SOPC*);
3847  ~Inst_SOPC__S_CMP_GT_I32();
3848 
3849  int
3850  getNumOperands() override
3851  {
3852  return numDstRegOperands() + numSrcRegOperands();
3853  } // getNumOperands
3854 
3855  int numDstRegOperands() override { return 0; }
3856  int numSrcRegOperands() override { return 2; }
3857 
3858  int
3859  getOperandSize(int opIdx) override
3860  {
3861  switch (opIdx) {
3862  case 0: //ssrc_0
3863  return 4;
3864  case 1: //ssrc_1
3865  return 4;
3866  default:
3867  fatal("op idx %i out of bounds\n", opIdx);
3868  return -1;
3869  }
3870  } // getOperandSize
3871 
3872  void execute(GPUDynInstPtr) override;
3873  }; // Inst_SOPC__S_CMP_GT_I32
3874 
3875  class Inst_SOPC__S_CMP_GE_I32 : public Inst_SOPC
3876  {
3877  public:
3878  Inst_SOPC__S_CMP_GE_I32(InFmt_SOPC*);
3879  ~Inst_SOPC__S_CMP_GE_I32();
3880 
3881  int
3882  getNumOperands() override
3883  {
3884  return numDstRegOperands() + numSrcRegOperands();
3885  } // getNumOperands
3886 
3887  int numDstRegOperands() override { return 0; }
3888  int numSrcRegOperands() override { return 2; }
3889 
3890  int
3891  getOperandSize(int opIdx) override
3892  {
3893  switch (opIdx) {
3894  case 0: //ssrc_0
3895  return 4;
3896  case 1: //ssrc_1
3897  return 4;
3898  default:
3899  fatal("op idx %i out of bounds\n", opIdx);
3900  return -1;
3901  }
3902  } // getOperandSize
3903 
3904  void execute(GPUDynInstPtr) override;
3905  }; // Inst_SOPC__S_CMP_GE_I32
3906 
3907  class Inst_SOPC__S_CMP_LT_I32 : public Inst_SOPC
3908  {
3909  public:
3910  Inst_SOPC__S_CMP_LT_I32(InFmt_SOPC*);
3911  ~Inst_SOPC__S_CMP_LT_I32();
3912 
3913  int
3914  getNumOperands() override
3915  {
3916  return numDstRegOperands() + numSrcRegOperands();
3917  } // getNumOperands
3918 
3919  int numDstRegOperands() override { return 0; }
3920  int numSrcRegOperands() override { return 2; }
3921 
3922  int
3923  getOperandSize(int opIdx) override
3924  {
3925  switch (opIdx) {
3926  case 0: //ssrc_0
3927  return 4;
3928  case 1: //ssrc_1
3929  return 4;
3930  default:
3931  fatal("op idx %i out of bounds\n", opIdx);
3932  return -1;
3933  }
3934  } // getOperandSize
3935 
3936  void execute(GPUDynInstPtr) override;
3937  }; // Inst_SOPC__S_CMP_LT_I32
3938 
3939  class Inst_SOPC__S_CMP_LE_I32 : public Inst_SOPC
3940  {
3941  public:
3942  Inst_SOPC__S_CMP_LE_I32(InFmt_SOPC*);
3943  ~Inst_SOPC__S_CMP_LE_I32();
3944 
3945  int
3946  getNumOperands() override
3947  {
3948  return numDstRegOperands() + numSrcRegOperands();
3949  } // getNumOperands
3950 
3951  int numDstRegOperands() override { return 0; }
3952  int numSrcRegOperands() override { return 2; }
3953 
3954  int
3955  getOperandSize(int opIdx) override
3956  {
3957  switch (opIdx) {
3958  case 0: //ssrc_0
3959  return 4;
3960  case 1: //ssrc_1
3961  return 4;
3962  default:
3963  fatal("op idx %i out of bounds\n", opIdx);
3964  return -1;
3965  }
3966  } // getOperandSize
3967 
3968  void execute(GPUDynInstPtr) override;
3969  }; // Inst_SOPC__S_CMP_LE_I32
3970 
3971  class Inst_SOPC__S_CMP_EQ_U32 : public Inst_SOPC
3972  {
3973  public:
3974  Inst_SOPC__S_CMP_EQ_U32(InFmt_SOPC*);
3975  ~Inst_SOPC__S_CMP_EQ_U32();
3976 
3977  int
3978  getNumOperands() override
3979  {
3980  return numDstRegOperands() + numSrcRegOperands();
3981  } // getNumOperands
3982 
3983  int numDstRegOperands() override { return 0; }
3984  int numSrcRegOperands() override { return 2; }
3985 
3986  int
3987  getOperandSize(int opIdx) override
3988  {
3989  switch (opIdx) {
3990  case 0: //ssrc_0
3991  return 4;
3992  case 1: //ssrc_1
3993  return 4;
3994  default:
3995  fatal("op idx %i out of bounds\n", opIdx);
3996  return -1;
3997  }
3998  } // getOperandSize
3999 
4000  void execute(GPUDynInstPtr) override;
4001  }; // Inst_SOPC__S_CMP_EQ_U32
4002 
4003  class Inst_SOPC__S_CMP_LG_U32 : public Inst_SOPC
4004  {
4005  public:
4006  Inst_SOPC__S_CMP_LG_U32(InFmt_SOPC*);
4007  ~Inst_SOPC__S_CMP_LG_U32();
4008 
4009  int
4010  getNumOperands() override
4011  {
4012  return numDstRegOperands() + numSrcRegOperands();
4013  } // getNumOperands
4014 
4015  int numDstRegOperands() override { return 0; }
4016  int numSrcRegOperands() override { return 2; }
4017 
4018  int
4019  getOperandSize(int opIdx) override
4020  {
4021  switch (opIdx) {
4022  case 0: //ssrc_0
4023  return 4;
4024  case 1: //ssrc_1
4025  return 4;
4026  default:
4027  fatal("op idx %i out of bounds\n", opIdx);
4028  return -1;
4029  }
4030  } // getOperandSize
4031 
4032  void execute(GPUDynInstPtr) override;
4033  }; // Inst_SOPC__S_CMP_LG_U32
4034 
4035  class Inst_SOPC__S_CMP_GT_U32 : public Inst_SOPC
4036  {
4037  public:
4038  Inst_SOPC__S_CMP_GT_U32(InFmt_SOPC*);
4039  ~Inst_SOPC__S_CMP_GT_U32();
4040 
4041  int
4042  getNumOperands() override
4043  {
4044  return numDstRegOperands() + numSrcRegOperands();
4045  } // getNumOperands
4046 
4047  int numDstRegOperands() override { return 0; }
4048  int numSrcRegOperands() override { return 2; }
4049 
4050  int
4051  getOperandSize(int opIdx) override
4052  {
4053  switch (opIdx) {
4054  case 0: //ssrc_0
4055  return 4;
4056  case 1: //ssrc_1
4057  return 4;
4058  default:
4059  fatal("op idx %i out of bounds\n", opIdx);
4060  return -1;
4061  }
4062  } // getOperandSize
4063 
4064  void execute(GPUDynInstPtr) override;
4065  }; // Inst_SOPC__S_CMP_GT_U32
4066 
4067  class Inst_SOPC__S_CMP_GE_U32 : public Inst_SOPC
4068  {
4069  public:
4070  Inst_SOPC__S_CMP_GE_U32(InFmt_SOPC*);
4071  ~Inst_SOPC__S_CMP_GE_U32();
4072 
4073  int
4074  getNumOperands() override
4075  {
4076  return numDstRegOperands() + numSrcRegOperands();
4077  } // getNumOperands
4078 
4079  int numDstRegOperands() override { return 0; }
4080  int numSrcRegOperands() override { return 2; }
4081 
4082  int
4083  getOperandSize(int opIdx) override
4084  {
4085  switch (opIdx) {
4086  case 0: //ssrc_0
4087  return 4;
4088  case 1: //ssrc_1
4089  return 4;
4090  default:
4091  fatal("op idx %i out of bounds\n", opIdx);
4092  return -1;
4093  }
4094  } // getOperandSize
4095 
4096  void execute(GPUDynInstPtr) override;
4097  }; // Inst_SOPC__S_CMP_GE_U32
4098 
4099  class Inst_SOPC__S_CMP_LT_U32 : public Inst_SOPC
4100  {
4101  public:
4102  Inst_SOPC__S_CMP_LT_U32(InFmt_SOPC*);
4103  ~Inst_SOPC__S_CMP_LT_U32();
4104 
4105  int
4106  getNumOperands() override
4107  {
4108  return numDstRegOperands() + numSrcRegOperands();
4109  } // getNumOperands
4110 
4111  int numDstRegOperands() override { return 0; }
4112  int numSrcRegOperands() override { return 2; }
4113 
4114  int
4115  getOperandSize(int opIdx) override
4116  {
4117  switch (opIdx) {
4118  case 0: //ssrc_0
4119  return 4;
4120  case 1: //ssrc_1
4121  return 4;
4122  default:
4123  fatal("op idx %i out of bounds\n", opIdx);
4124  return -1;
4125  }
4126  } // getOperandSize
4127 
4128  void execute(GPUDynInstPtr) override;
4129  }; // Inst_SOPC__S_CMP_LT_U32
4130 
4131  class Inst_SOPC__S_CMP_LE_U32 : public Inst_SOPC
4132  {
4133  public:
4134  Inst_SOPC__S_CMP_LE_U32(InFmt_SOPC*);
4135  ~Inst_SOPC__S_CMP_LE_U32();
4136 
4137  int
4138  getNumOperands() override
4139  {
4140  return numDstRegOperands() + numSrcRegOperands();
4141  } // getNumOperands
4142 
4143  int numDstRegOperands() override { return 0; }
4144  int numSrcRegOperands() override { return 2; }
4145 
4146  int
4147  getOperandSize(int opIdx) override
4148  {
4149  switch (opIdx) {
4150  case 0: //ssrc_0
4151  return 4;
4152  case 1: //ssrc_1
4153  return 4;
4154  default:
4155  fatal("op idx %i out of bounds\n", opIdx);
4156  return -1;
4157  }
4158  } // getOperandSize
4159 
4160  void execute(GPUDynInstPtr) override;
4161  }; // Inst_SOPC__S_CMP_LE_U32
4162 
4163  class Inst_SOPC__S_BITCMP0_B32 : public Inst_SOPC
4164  {
4165  public:
4166  Inst_SOPC__S_BITCMP0_B32(InFmt_SOPC*);
4167  ~Inst_SOPC__S_BITCMP0_B32();
4168 
4169  int
4170  getNumOperands() override
4171  {
4172  return numDstRegOperands() + numSrcRegOperands();
4173  } // getNumOperands
4174 
4175  int numDstRegOperands() override { return 0; }
4176  int numSrcRegOperands() override { return 2; }
4177 
4178  int
4179  getOperandSize(int opIdx) override
4180  {
4181  switch (opIdx) {
4182  case 0: //ssrc_0
4183  return 4;
4184  case 1: //ssrc_1
4185  return 4;
4186  default:
4187  fatal("op idx %i out of bounds\n", opIdx);
4188  return -1;
4189  }
4190  } // getOperandSize
4191 
4192  void execute(GPUDynInstPtr) override;
4193  }; // Inst_SOPC__S_BITCMP0_B32
4194 
4195  class Inst_SOPC__S_BITCMP1_B32 : public Inst_SOPC
4196  {
4197  public:
4198  Inst_SOPC__S_BITCMP1_B32(InFmt_SOPC*);
4199  ~Inst_SOPC__S_BITCMP1_B32();
4200 
4201  int
4202  getNumOperands() override
4203  {
4204  return numDstRegOperands() + numSrcRegOperands();
4205  } // getNumOperands
4206 
4207  int numDstRegOperands() override { return 0; }
4208  int numSrcRegOperands() override { return 2; }
4209 
4210  int
4211  getOperandSize(int opIdx) override
4212  {
4213  switch (opIdx) {
4214  case 0: //ssrc_0
4215  return 4;
4216  case 1: //ssrc_1
4217  return 4;
4218  default:
4219  fatal("op idx %i out of bounds\n", opIdx);
4220  return -1;
4221  }
4222  } // getOperandSize
4223 
4224  void execute(GPUDynInstPtr) override;
4225  }; // Inst_SOPC__S_BITCMP1_B32
4226 
4227  class Inst_SOPC__S_BITCMP0_B64 : public Inst_SOPC
4228  {
4229  public:
4230  Inst_SOPC__S_BITCMP0_B64(InFmt_SOPC*);
4231  ~Inst_SOPC__S_BITCMP0_B64();
4232 
4233  int
4234  getNumOperands() override
4235  {
4236  return numDstRegOperands() + numSrcRegOperands();
4237  } // getNumOperands
4238 
4239  int numDstRegOperands() override { return 0; }
4240  int numSrcRegOperands() override { return 2; }
4241 
4242  int
4243  getOperandSize(int opIdx) override
4244  {
4245  switch (opIdx) {
4246  case 0: //ssrc_0
4247  return 8;
4248  case 1: //ssrc_1
4249  return 4;
4250  default:
4251  fatal("op idx %i out of bounds\n", opIdx);
4252  return -1;
4253  }
4254  } // getOperandSize
4255 
4256  void execute(GPUDynInstPtr) override;
4257  }; // Inst_SOPC__S_BITCMP0_B64
4258 
4259  class Inst_SOPC__S_BITCMP1_B64 : public Inst_SOPC
4260  {
4261  public:
4262  Inst_SOPC__S_BITCMP1_B64(InFmt_SOPC*);
4263  ~Inst_SOPC__S_BITCMP1_B64();
4264 
4265  int
4266  getNumOperands() override
4267  {
4268  return numDstRegOperands() + numSrcRegOperands();
4269  } // getNumOperands
4270 
4271  int numDstRegOperands() override { return 0; }
4272  int numSrcRegOperands() override { return 2; }
4273 
4274  int
4275  getOperandSize(int opIdx) override
4276  {
4277  switch (opIdx) {
4278  case 0: //ssrc_0
4279  return 8;
4280  case 1: //ssrc_1
4281  return 4;
4282  default:
4283  fatal("op idx %i out of bounds\n", opIdx);
4284  return -1;
4285  }
4286  } // getOperandSize
4287 
4288  void execute(GPUDynInstPtr) override;
4289  }; // Inst_SOPC__S_BITCMP1_B64
4290 
4291  class Inst_SOPC__S_SETVSKIP : public Inst_SOPC
4292  {
4293  public:
4294  Inst_SOPC__S_SETVSKIP(InFmt_SOPC*);
4295  ~Inst_SOPC__S_SETVSKIP();
4296 
4297  int
4298  getNumOperands() override
4299  {
4300  return numDstRegOperands() + numSrcRegOperands();
4301  } // getNumOperands
4302 
4303  int numDstRegOperands() override { return 0; }
4304  int numSrcRegOperands() override { return 2; }
4305 
4306  int
4307  getOperandSize(int opIdx) override
4308  {
4309  switch (opIdx) {
4310  case 0: //ssrc_0
4311  return 4;
4312  case 1: //ssrc_1
4313  return 4;
4314  default:
4315  fatal("op idx %i out of bounds\n", opIdx);
4316  return -1;
4317  }
4318  } // getOperandSize
4319 
4320  void execute(GPUDynInstPtr) override;
4321  }; // Inst_SOPC__S_SETVSKIP
4322 
4323  class Inst_SOPC__S_SET_GPR_IDX_ON : public Inst_SOPC
4324  {
4325  public:
4326  Inst_SOPC__S_SET_GPR_IDX_ON(InFmt_SOPC*);
4327  ~Inst_SOPC__S_SET_GPR_IDX_ON();
4328 
4329  int
4330  getNumOperands() override
4331  {
4332  return numDstRegOperands() + numSrcRegOperands();
4333  } // getNumOperands
4334 
4335  int numDstRegOperands() override { return 0; }
4336  int numSrcRegOperands() override { return 2; }
4337 
4338  int
4339  getOperandSize(int opIdx) override
4340  {
4341  switch (opIdx) {
4342  case 0: //ssrc_0
4343  return 4;
4344  case 1: //simm4
4345  return 4;
4346  default:
4347  fatal("op idx %i out of bounds\n", opIdx);
4348  return -1;
4349  }
4350  } // getOperandSize
4351 
4352  void execute(GPUDynInstPtr) override;
4353  }; // Inst_SOPC__S_SET_GPR_IDX_ON
4354 
4355  class Inst_SOPC__S_CMP_EQ_U64 : public Inst_SOPC
4356  {
4357  public:
4358  Inst_SOPC__S_CMP_EQ_U64(InFmt_SOPC*);
4359  ~Inst_SOPC__S_CMP_EQ_U64();
4360 
4361  int
4362  getNumOperands() override
4363  {
4364  return numDstRegOperands() + numSrcRegOperands();
4365  } // getNumOperands
4366 
4367  int numDstRegOperands() override { return 0; }
4368  int numSrcRegOperands() override { return 2; }
4369 
4370  int
4371  getOperandSize(int opIdx) override
4372  {
4373  switch (opIdx) {
4374  case 0: //ssrc_0
4375  return 8;
4376  case 1: //ssrc_1
4377  return 8;
4378  default:
4379  fatal("op idx %i out of bounds\n", opIdx);
4380  return -1;
4381  }
4382  } // getOperandSize
4383 
4384  void execute(GPUDynInstPtr) override;
4385  }; // Inst_SOPC__S_CMP_EQ_U64
4386 
4387  class Inst_SOPC__S_CMP_LG_U64 : public Inst_SOPC
4388  {
4389  public:
4390  Inst_SOPC__S_CMP_LG_U64(InFmt_SOPC*);
4391  ~Inst_SOPC__S_CMP_LG_U64();
4392 
4393  int
4394  getNumOperands() override
4395  {
4396  return numDstRegOperands() + numSrcRegOperands();
4397  } // getNumOperands
4398 
4399  int numDstRegOperands() override { return 0; }
4400  int numSrcRegOperands() override { return 2; }
4401 
4402  int
4403  getOperandSize(int opIdx) override
4404  {
4405  switch (opIdx) {
4406  case 0: //ssrc_0
4407  return 8;
4408  case 1: //ssrc_1
4409  return 8;
4410  default:
4411  fatal("op idx %i out of bounds\n", opIdx);
4412  return -1;
4413  }
4414  } // getOperandSize
4415 
4416  void execute(GPUDynInstPtr) override;
4417  }; // Inst_SOPC__S_CMP_LG_U64
4418 
4419  class Inst_SOPP__S_NOP : public Inst_SOPP
4420  {
4421  public:
4422  Inst_SOPP__S_NOP(InFmt_SOPP*);
4423  ~Inst_SOPP__S_NOP();
4424 
4425  int
4426  getNumOperands() override
4427  {
4428  return numDstRegOperands() + numSrcRegOperands();
4429  } // getNumOperands
4430 
4431  int numDstRegOperands() override { return 0; }
4432  int numSrcRegOperands() override { return 1; }
4433 
4434  int
4435  getOperandSize(int opIdx) override
4436  {
4437  switch (opIdx) {
4438  case 0: //simm16
4439  return 2;
4440  default:
4441  fatal("op idx %i out of bounds\n", opIdx);
4442  return -1;
4443  }
4444  } // getOperandSize
4445 
4446  void execute(GPUDynInstPtr) override;
4447  }; // Inst_SOPP__S_NOP
4448 
4449  class Inst_SOPP__S_ENDPGM : public Inst_SOPP
4450  {
4451  public:
4452  Inst_SOPP__S_ENDPGM(InFmt_SOPP*);
4453  ~Inst_SOPP__S_ENDPGM();
4454 
4455  int
4456  getNumOperands() override
4457  {
4458  return numDstRegOperands() + numSrcRegOperands();
4459  } // getNumOperands
4460 
4461  int numDstRegOperands() override { return 0; }
4462  int numSrcRegOperands() override { return 0; }
4463 
4464  int
4465  getOperandSize(int opIdx) override
4466  {
4467  switch (opIdx) {
4468  case 0: //simm16
4469  return 2;
4470  default:
4471  fatal("op idx %i out of bounds\n", opIdx);
4472  return -1;
4473  }
4474  } // getOperandSize
4475 
4476  void execute(GPUDynInstPtr) override;
4477  }; // Inst_SOPP__S_ENDPGM
4478 
4479  class Inst_SOPP__S_BRANCH : public Inst_SOPP
4480  {
4481  public:
4482  Inst_SOPP__S_BRANCH(InFmt_SOPP*);
4483  ~Inst_SOPP__S_BRANCH();
4484 
4485  int
4486  getNumOperands() override
4487  {
4488  return numDstRegOperands() + numSrcRegOperands();
4489  } // getNumOperands
4490 
4491  int numDstRegOperands() override { return 0; }
4492  int numSrcRegOperands() override { return 1; }
4493 
4494  int
4495  getOperandSize(int opIdx) override
4496  {
4497  switch (opIdx) {
4498  case 0: //label
4499  return 2;
4500  default:
4501  fatal("op idx %i out of bounds\n", opIdx);
4502  return -1;
4503  }
4504  } // getOperandSize
4505 
4506  void execute(GPUDynInstPtr) override;
4507  }; // Inst_SOPP__S_BRANCH
4508 
4509  class Inst_SOPP__S_WAKEUP : public Inst_SOPP
4510  {
4511  public:
4512  Inst_SOPP__S_WAKEUP(InFmt_SOPP*);
4513  ~Inst_SOPP__S_WAKEUP();
4514 
4515  int
4516  getNumOperands() override
4517  {
4518  return numDstRegOperands() + numSrcRegOperands();
4519  } // getNumOperands
4520 
4521  int numDstRegOperands() override { return 0; }
4522  int numSrcRegOperands() override { return 0; }
4523 
4524  int
4525  getOperandSize(int opIdx) override
4526  {
4527  switch (opIdx) {
4528  case 0: //simm16
4529  return 2;
4530  default:
4531  fatal("op idx %i out of bounds\n", opIdx);
4532  return -1;
4533  }
4534  } // getOperandSize
4535 
4536  void execute(GPUDynInstPtr) override;
4537  }; // Inst_SOPP__S_WAKEUP
4538 
4539  class Inst_SOPP__S_CBRANCH_SCC0 : public Inst_SOPP
4540  {
4541  public:
4542  Inst_SOPP__S_CBRANCH_SCC0(InFmt_SOPP*);
4543  ~Inst_SOPP__S_CBRANCH_SCC0();
4544 
4545  int
4546  getNumOperands() override
4547  {
4548  return numDstRegOperands() + numSrcRegOperands();
4549  } // getNumOperands
4550 
4551  int numDstRegOperands() override { return 0; }
4552  int numSrcRegOperands() override { return 1; }
4553 
4554  int
4555  getOperandSize(int opIdx) override
4556  {
4557  switch (opIdx) {
4558  case 0: //label
4559  return 2;
4560  default:
4561  fatal("op idx %i out of bounds\n", opIdx);
4562  return -1;
4563  }
4564  } // getOperandSize
4565 
4566  void execute(GPUDynInstPtr) override;
4567  }; // Inst_SOPP__S_CBRANCH_SCC0
4568 
4569  class Inst_SOPP__S_CBRANCH_SCC1 : public Inst_SOPP
4570  {
4571  public:
4572  Inst_SOPP__S_CBRANCH_SCC1(InFmt_SOPP*);
4573  ~Inst_SOPP__S_CBRANCH_SCC1();
4574 
4575  int
4576  getNumOperands() override
4577  {
4578  return numDstRegOperands() + numSrcRegOperands();
4579  } // getNumOperands
4580 
4581  int numDstRegOperands() override { return 0; }
4582  int numSrcRegOperands() override { return 1; }
4583 
4584  int
4585  getOperandSize(int opIdx) override
4586  {
4587  switch (opIdx) {
4588  case 0: //label
4589  return 2;
4590  default:
4591  fatal("op idx %i out of bounds\n", opIdx);
4592  return -1;
4593  }
4594  } // getOperandSize
4595 
4596  void execute(GPUDynInstPtr) override;
4597  }; // Inst_SOPP__S_CBRANCH_SCC1
4598 
4599  class Inst_SOPP__S_CBRANCH_VCCZ : public Inst_SOPP
4600  {
4601  public:
4602  Inst_SOPP__S_CBRANCH_VCCZ(InFmt_SOPP*);
4603  ~Inst_SOPP__S_CBRANCH_VCCZ();
4604 
4605  int
4606  getNumOperands() override
4607  {
4608  return numDstRegOperands() + numSrcRegOperands();
4609  } // getNumOperands
4610 
4611  int numDstRegOperands() override { return 0; }
4612  int numSrcRegOperands() override { return 2; }
4613 
4614  int
4615  getOperandSize(int opIdx) override
4616  {
4617  switch (opIdx) {
4618  case 0: //label
4619  return 2;
4620  case 1:
4621  return 8;
4622  default:
4623  fatal("op idx %i out of bounds\n", opIdx);
4624  return -1;
4625  }
4626  } // getOperandSize
4627 
4628  void execute(GPUDynInstPtr) override;
4629  }; // Inst_SOPP__S_CBRANCH_VCCZ
4630 
4631  class Inst_SOPP__S_CBRANCH_VCCNZ : public Inst_SOPP
4632  {
4633  public:
4634  Inst_SOPP__S_CBRANCH_VCCNZ(InFmt_SOPP*);
4635  ~Inst_SOPP__S_CBRANCH_VCCNZ();
4636 
4637  int
4638  getNumOperands() override
4639  {
4640  return numDstRegOperands() + numSrcRegOperands();
4641  } // getNumOperands
4642 
4643  int numDstRegOperands() override { return 0; }
4644  int numSrcRegOperands() override { return 2; }
4645 
4646  int
4647  getOperandSize(int opIdx) override
4648  {
4649  switch (opIdx) {
4650  case 0: //label
4651  return 2;
4652  case 1:
4653  return 8;
4654  default:
4655  fatal("op idx %i out of bounds\n", opIdx);
4656  return -1;
4657  }
4658  } // getOperandSize
4659 
4660  void execute(GPUDynInstPtr) override;
4661  }; // Inst_SOPP__S_CBRANCH_VCCNZ
4662 
4663  class Inst_SOPP__S_CBRANCH_EXECZ : public Inst_SOPP
4664  {
4665  public:
4666  Inst_SOPP__S_CBRANCH_EXECZ(InFmt_SOPP*);
4667  ~Inst_SOPP__S_CBRANCH_EXECZ();
4668 
4669  int
4670  getNumOperands() override
4671  {
4672  return numDstRegOperands() + numSrcRegOperands();
4673  } // getNumOperands
4674 
4675  int numDstRegOperands() override { return 0; }
4676  int numSrcRegOperands() override { return 1; }
4677 
4678  int
4679  getOperandSize(int opIdx) override
4680  {
4681  switch (opIdx) {
4682  case 0: //label
4683  return 2;
4684  default:
4685  fatal("op idx %i out of bounds\n", opIdx);
4686  return -1;
4687  }
4688  } // getOperandSize
4689 
4690  void execute(GPUDynInstPtr) override;
4691  }; // Inst_SOPP__S_CBRANCH_EXECZ
4692 
4693  class Inst_SOPP__S_CBRANCH_EXECNZ : public Inst_SOPP
4694  {
4695  public:
4696  Inst_SOPP__S_CBRANCH_EXECNZ(InFmt_SOPP*);
4697  ~Inst_SOPP__S_CBRANCH_EXECNZ();
4698 
4699  int
4700  getNumOperands() override
4701  {
4702  return numDstRegOperands() + numSrcRegOperands();
4703  } // getNumOperands
4704 
4705  int numDstRegOperands() override { return 0; }
4706  int numSrcRegOperands() override { return 1; }
4707 
4708  int
4709  getOperandSize(int opIdx) override
4710  {
4711  switch (opIdx) {
4712  case 0: //label
4713  return 2;
4714  default:
4715  fatal("op idx %i out of bounds\n", opIdx);
4716  return -1;
4717  }
4718  } // getOperandSize
4719 
4720  void execute(GPUDynInstPtr) override;
4721  }; // Inst_SOPP__S_CBRANCH_EXECNZ
4722 
4723  class Inst_SOPP__S_BARRIER : public Inst_SOPP
4724  {
4725  public:
4726  Inst_SOPP__S_BARRIER(InFmt_SOPP*);
4727  ~Inst_SOPP__S_BARRIER();
4728 
4729  int
4730  getNumOperands() override
4731  {
4732  return numDstRegOperands() + numSrcRegOperands();
4733  } // getNumOperands
4734 
4735  int numDstRegOperands() override { return 0; }
4736  int numSrcRegOperands() override { return 0; }
4737 
4738  int
4739  getOperandSize(int opIdx) override
4740  {
4741  switch (opIdx) {
4742  case 0: //simm16
4743  return 2;
4744  default:
4745  fatal("op idx %i out of bounds\n", opIdx);
4746  return -1;
4747  }
4748  } // getOperandSize
4749 
4750  void execute(GPUDynInstPtr) override;
4751  }; // Inst_SOPP__S_BARRIER
4752 
4753  class Inst_SOPP__S_SETKILL : public Inst_SOPP
4754  {
4755  public:
4756  Inst_SOPP__S_SETKILL(InFmt_SOPP*);
4757  ~Inst_SOPP__S_SETKILL();
4758 
4759  int
4760  getNumOperands() override
4761  {
4762  return numDstRegOperands() + numSrcRegOperands();
4763  } // getNumOperands
4764 
4765  int numDstRegOperands() override { return 0; }
4766  int numSrcRegOperands() override { return 1; }
4767 
4768  int
4769  getOperandSize(int opIdx) override
4770  {
4771  switch (opIdx) {
4772  case 0: //simm16
4773  return 2;
4774  default:
4775  fatal("op idx %i out of bounds\n", opIdx);
4776  return -1;
4777  }
4778  } // getOperandSize
4779 
4780  void execute(GPUDynInstPtr) override;
4781  }; // Inst_SOPP__S_SETKILL
4782 
4783  class Inst_SOPP__S_WAITCNT : public Inst_SOPP
4784  {
4785  public:
4786  Inst_SOPP__S_WAITCNT(InFmt_SOPP*);
4787  ~Inst_SOPP__S_WAITCNT();
4788 
4789  int
4790  getNumOperands() override
4791  {
4792  return numDstRegOperands() + numSrcRegOperands();
4793  } // getNumOperands
4794 
4795  int numDstRegOperands() override { return 0; }
4796  int numSrcRegOperands() override { return 1; }
4797 
4798  int
4799  getOperandSize(int opIdx) override
4800  {
4801  switch (opIdx) {
4802  case 0: //simm16
4803  return 2;
4804  default:
4805  fatal("op idx %i out of bounds\n", opIdx);
4806  return -1;
4807  }
4808  } // getOperandSize
4809 
4810  void execute(GPUDynInstPtr) override;
4811  }; // Inst_SOPP__S_WAITCNT
4812 
4813  class Inst_SOPP__S_SETHALT : public Inst_SOPP
4814  {
4815  public:
4816  Inst_SOPP__S_SETHALT(InFmt_SOPP*);
4817  ~Inst_SOPP__S_SETHALT();
4818 
4819  int
4820  getNumOperands() override
4821  {
4822  return numDstRegOperands() + numSrcRegOperands();
4823  } // getNumOperands
4824 
4825  int numDstRegOperands() override { return 0; }
4826  int numSrcRegOperands() override { return 1; }
4827 
4828  int
4829  getOperandSize(int opIdx) override
4830  {
4831  switch (opIdx) {
4832  case 0: //simm16
4833  return 2;
4834  default:
4835  fatal("op idx %i out of bounds\n", opIdx);
4836  return -1;
4837  }
4838  } // getOperandSize
4839 
4840  void execute(GPUDynInstPtr) override;
4841  }; // Inst_SOPP__S_SETHALT
4842 
4843  class Inst_SOPP__S_SLEEP : public Inst_SOPP
4844  {
4845  public:
4846  Inst_SOPP__S_SLEEP(InFmt_SOPP*);
4847  ~Inst_SOPP__S_SLEEP();
4848 
4849  int
4850  getNumOperands() override
4851  {
4852  return numDstRegOperands() + numSrcRegOperands();
4853  } // getNumOperands
4854 
4855  int numDstRegOperands() override { return 0; }
4856  int numSrcRegOperands() override { return 1; }
4857 
4858  int
4859  getOperandSize(int opIdx) override
4860  {
4861  switch (opIdx) {
4862  case 0: //simm16
4863  return 2;
4864  default:
4865  fatal("op idx %i out of bounds\n", opIdx);
4866  return -1;
4867  }
4868  } // getOperandSize
4869 
4870  void execute(GPUDynInstPtr) override;
4871  }; // Inst_SOPP__S_SLEEP
4872 
4873  class Inst_SOPP__S_SETPRIO : public Inst_SOPP
4874  {
4875  public:
4876  Inst_SOPP__S_SETPRIO(InFmt_SOPP*);
4877  ~Inst_SOPP__S_SETPRIO();
4878 
4879  int
4880  getNumOperands() override
4881  {
4882  return numDstRegOperands() + numSrcRegOperands();
4883  } // getNumOperands
4884 
4885  int numDstRegOperands() override { return 0; }
4886  int numSrcRegOperands() override { return 1; }
4887 
4888  int
4889  getOperandSize(int opIdx) override
4890  {
4891  switch (opIdx) {
4892  case 0: //simm16
4893  return 2;
4894  default:
4895  fatal("op idx %i out of bounds\n", opIdx);
4896  return -1;
4897  }
4898  } // getOperandSize
4899 
4900  void execute(GPUDynInstPtr) override;
4901  }; // Inst_SOPP__S_SETPRIO
4902 
4903  class Inst_SOPP__S_SENDMSG : public Inst_SOPP
4904  {
4905  public:
4906  Inst_SOPP__S_SENDMSG(InFmt_SOPP*);
4907  ~Inst_SOPP__S_SENDMSG();
4908 
4909  int
4910  getNumOperands() override
4911  {
4912  return numDstRegOperands() + numSrcRegOperands();
4913  } // getNumOperands
4914 
4915  int numDstRegOperands() override { return 0; }
4916  int numSrcRegOperands() override { return 1; }
4917 
4918  int
4919  getOperandSize(int opIdx) override
4920  {
4921  switch (opIdx) {
4922  case 0: //simm16
4923  return 2;
4924  default:
4925  fatal("op idx %i out of bounds\n", opIdx);
4926  return -1;
4927  }
4928  } // getOperandSize
4929 
4930  void execute(GPUDynInstPtr) override;
4931  }; // Inst_SOPP__S_SENDMSG
4932 
4933  class Inst_SOPP__S_SENDMSGHALT : public Inst_SOPP
4934  {
4935  public:
4936  Inst_SOPP__S_SENDMSGHALT(InFmt_SOPP*);
4937  ~Inst_SOPP__S_SENDMSGHALT();
4938 
4939  int
4940  getNumOperands() override
4941  {
4942  return numDstRegOperands() + numSrcRegOperands();
4943  } // getNumOperands
4944 
4945  int numDstRegOperands() override { return 0; }
4946  int numSrcRegOperands() override { return 1; }
4947 
4948  int
4949  getOperandSize(int opIdx) override
4950  {
4951  switch (opIdx) {
4952  case 0: //simm16
4953  return 2;
4954  default:
4955  fatal("op idx %i out of bounds\n", opIdx);
4956  return -1;
4957  }
4958  } // getOperandSize
4959 
4960  void execute(GPUDynInstPtr) override;
4961  }; // Inst_SOPP__S_SENDMSGHALT
4962 
4963  class Inst_SOPP__S_TRAP : public Inst_SOPP
4964  {
4965  public:
4966  Inst_SOPP__S_TRAP(InFmt_SOPP*);
4967  ~Inst_SOPP__S_TRAP();
4968 
4969  int
4970  getNumOperands() override
4971  {
4972  return numDstRegOperands() + numSrcRegOperands();
4973  } // getNumOperands
4974 
4975  int numDstRegOperands() override { return 0; }
4976  int numSrcRegOperands() override { return 1; }
4977 
4978  int
4979  getOperandSize(int opIdx) override
4980  {
4981  switch (opIdx) {
4982  case 0: //simm16
4983  return 2;
4984  default:
4985  fatal("op idx %i out of bounds\n", opIdx);
4986  return -1;
4987  }
4988  } // getOperandSize
4989 
4990  void execute(GPUDynInstPtr) override;
4991  }; // Inst_SOPP__S_TRAP
4992 
4993  class Inst_SOPP__S_ICACHE_INV : public Inst_SOPP
4994  {
4995  public:
4996  Inst_SOPP__S_ICACHE_INV(InFmt_SOPP*);
4997  ~Inst_SOPP__S_ICACHE_INV();
4998 
4999  int
5000  getNumOperands() override
5001  {
5002  return numDstRegOperands() + numSrcRegOperands();
5003  } // getNumOperands
5004 
5005  int numDstRegOperands() override { return 0; }
5006  int numSrcRegOperands() override { return 0; }
5007 
5008  int
5009  getOperandSize(int opIdx) override
5010  {
5011  switch (opIdx) {
5012  case 0: //simm16
5013  return 2;
5014  default:
5015  fatal("op idx %i out of bounds\n", opIdx);
5016  return -1;
5017  }
5018  } // getOperandSize
5019 
5020  void execute(GPUDynInstPtr) override;
5021  }; // Inst_SOPP__S_ICACHE_INV
5022 
5023  class Inst_SOPP__S_INCPERFLEVEL : public Inst_SOPP
5024  {
5025  public:
5026  Inst_SOPP__S_INCPERFLEVEL(InFmt_SOPP*);
5027  ~Inst_SOPP__S_INCPERFLEVEL();
5028 
5029  int
5030  getNumOperands() override
5031  {
5032  return numDstRegOperands() + numSrcRegOperands();
5033  } // getNumOperands
5034 
5035  int numDstRegOperands() override { return 0; }
5036  int numSrcRegOperands() override { return 1; }
5037 
5038  int
5039  getOperandSize(int opIdx) override
5040  {
5041  switch (opIdx) {
5042  case 0: //simm16
5043  return 2;
5044  default:
5045  fatal("op idx %i out of bounds\n", opIdx);
5046  return -1;
5047  }
5048  } // getOperandSize
5049 
5050  void execute(GPUDynInstPtr) override;
5051  }; // Inst_SOPP__S_INCPERFLEVEL
5052 
5053  class Inst_SOPP__S_DECPERFLEVEL : public Inst_SOPP
5054  {
5055  public:
5056  Inst_SOPP__S_DECPERFLEVEL(InFmt_SOPP*);
5057  ~Inst_SOPP__S_DECPERFLEVEL();
5058 
5059  int
5060  getNumOperands() override
5061  {
5062  return numDstRegOperands() + numSrcRegOperands();
5063  } // getNumOperands
5064 
5065  int numDstRegOperands() override { return 0; }
5066  int numSrcRegOperands() override { return 1; }
5067 
5068  int
5069  getOperandSize(int opIdx) override
5070  {
5071  switch (opIdx) {
5072  case 0: //simm16
5073  return 2;
5074  default:
5075  fatal("op idx %i out of bounds\n", opIdx);
5076  return -1;
5077  }
5078  } // getOperandSize
5079 
5080  void execute(GPUDynInstPtr) override;
5081  }; // Inst_SOPP__S_DECPERFLEVEL
5082 
5083  class Inst_SOPP__S_TTRACEDATA : public Inst_SOPP
5084  {
5085  public:
5086  Inst_SOPP__S_TTRACEDATA(InFmt_SOPP*);
5087  ~Inst_SOPP__S_TTRACEDATA();
5088 
5089  int
5090  getNumOperands() override
5091  {
5092  return numDstRegOperands() + numSrcRegOperands();
5093  } // getNumOperands
5094 
5095  int numDstRegOperands() override { return 0; }
5096  int numSrcRegOperands() override { return 0; }
5097 
5098  int
5099  getOperandSize(int opIdx) override
5100  {
5101  switch (opIdx) {
5102  case 0: //simm16
5103  return 2;
5104  default:
5105  fatal("op idx %i out of bounds\n", opIdx);
5106  return -1;
5107  }
5108  } // getOperandSize
5109 
5110