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