gem5 v24.0.0.0
Loading...
Searching...
No Matches
instructions.hh
Go to the documentation of this file.
1/*
2 * Copyright (c) 2015-2021 Advanced Micro Devices, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its
16 * contributors may be used to endorse or promote products derived from this
17 * software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32#ifndef __ARCH_VEGA_INSTS_INSTRUCTIONS_HH__
33#define __ARCH_VEGA_INSTS_INSTRUCTIONS_HH__
34
35#include <cstddef>
36#include <type_traits>
37
42#include "debug/VEGA.hh"
43
44namespace gem5
45{
46
47namespace VegaISA
48{
50 {
51 public:
54
55 int
56 getNumOperands() override
57 {
59 } // getNumOperands
60
61 int numDstRegOperands() override { return 1; }
62 int numSrcRegOperands() override { return 2; }
63
64 int
65 getOperandSize(int opIdx) override
66 {
67 switch (opIdx) {
68 case 0: //ssrc_0
69 return 4;
70 case 1: //ssrc_1
71 return 4;
72 case 2: //sdst
73 return 4;
74 default:
75 fatal("op idx %i out of bounds\n", opIdx);
76 return -1;
77 }
78 } // getOperandSize
79
80 void execute(GPUDynInstPtr) override;
81 }; // Inst_SOP2__S_ADD_U32
82
84 {
85 public:
88
89 int
90 getNumOperands() override
91 {
93 } // getNumOperands
94
95 int numDstRegOperands() override { return 1; }
96 int numSrcRegOperands() override { return 2; }
97
98 int
99 getOperandSize(int opIdx) override
100 {
101 switch (opIdx) {
102 case 0: //ssrc_0
103 return 4;
104 case 1: //ssrc_1
105 return 4;
106 case 2: //sdst
107 return 4;
108 default:
109 fatal("op idx %i out of bounds\n", opIdx);
110 return -1;
111 }
112 } // getOperandSize
113
114 void execute(GPUDynInstPtr) override;
115 }; // Inst_SOP2__S_SUB_U32
116
118 {
119 public:
122
123 int
124 getNumOperands() override
125 {
127 } // getNumOperands
128
129 int numDstRegOperands() override { return 1; }
130 int numSrcRegOperands() override { return 2; }
131
132 int
133 getOperandSize(int opIdx) override
134 {
135 switch (opIdx) {
136 case 0: //ssrc_0
137 return 4;
138 case 1: //ssrc_1
139 return 4;
140 case 2: //sdst
141 return 4;
142 default:
143 fatal("op idx %i out of bounds\n", opIdx);
144 return -1;
145 }
146 } // getOperandSize
147
148 void execute(GPUDynInstPtr) override;
149 }; // Inst_SOP2__S_ADD_I32
150
152 {
153 public:
156
157 int
158 getNumOperands() override
159 {
161 } // getNumOperands
162
163 int numDstRegOperands() override { return 1; }
164 int numSrcRegOperands() override { return 2; }
165
166 int
167 getOperandSize(int opIdx) override
168 {
169 switch (opIdx) {
170 case 0: //ssrc_0
171 return 4;
172 case 1: //ssrc_1
173 return 4;
174 case 2: //sdst
175 return 4;
176 default:
177 fatal("op idx %i out of bounds\n", opIdx);
178 return -1;
179 }
180 } // getOperandSize
181
182 void execute(GPUDynInstPtr) override;
183 }; // Inst_SOP2__S_SUB_I32
184
186 {
187 public:
190
191 int
192 getNumOperands() override
193 {
195 } // getNumOperands
196
197 int numDstRegOperands() override { return 1; }
198 int numSrcRegOperands() override { return 2; }
199
200 int
201 getOperandSize(int opIdx) override
202 {
203 switch (opIdx) {
204 case 0: //ssrc_0
205 return 4;
206 case 1: //ssrc_1
207 return 4;
208 case 2: //sdst
209 return 4;
210 default:
211 fatal("op idx %i out of bounds\n", opIdx);
212 return -1;
213 }
214 } // getOperandSize
215
216 void execute(GPUDynInstPtr) override;
217 }; // Inst_SOP2__S_ADDC_U32
218
220 {
221 public:
224
225 int
226 getNumOperands() override
227 {
229 } // getNumOperands
230
231 int numDstRegOperands() override { return 1; }
232 int numSrcRegOperands() override { return 2; }
233
234 int
235 getOperandSize(int opIdx) override
236 {
237 switch (opIdx) {
238 case 0: //ssrc_0
239 return 4;
240 case 1: //ssrc_1
241 return 4;
242 case 2: //sdst
243 return 4;
244 default:
245 fatal("op idx %i out of bounds\n", opIdx);
246 return -1;
247 }
248 } // getOperandSize
249
250 void execute(GPUDynInstPtr) override;
251 }; // Inst_SOP2__S_SUBB_U32
252
254 {
255 public:
258
259 int
260 getNumOperands() override
261 {
263 } // getNumOperands
264
265 int numDstRegOperands() override { return 1; }
266 int numSrcRegOperands() override { return 2; }
267
268 int
269 getOperandSize(int opIdx) override
270 {
271 switch (opIdx) {
272 case 0: //ssrc_0
273 return 4;
274 case 1: //ssrc_1
275 return 4;
276 case 2: //sdst
277 return 4;
278 default:
279 fatal("op idx %i out of bounds\n", opIdx);
280 return -1;
281 }
282 } // getOperandSize
283
284 void execute(GPUDynInstPtr) override;
285 }; // Inst_SOP2__S_MIN_I32
286
288 {
289 public:
292
293 int
294 getNumOperands() override
295 {
297 } // getNumOperands
298
299 int numDstRegOperands() override { return 1; }
300 int numSrcRegOperands() override { return 2; }
301
302 int
303 getOperandSize(int opIdx) override
304 {
305 switch (opIdx) {
306 case 0: //ssrc_0
307 return 4;
308 case 1: //ssrc_1
309 return 4;
310 case 2: //sdst
311 return 4;
312 default:
313 fatal("op idx %i out of bounds\n", opIdx);
314 return -1;
315 }
316 } // getOperandSize
317
318 void execute(GPUDynInstPtr) override;
319 }; // Inst_SOP2__S_MIN_U32
320
322 {
323 public:
326
327 int
328 getNumOperands() override
329 {
331 } // getNumOperands
332
333 int numDstRegOperands() override { return 1; }
334 int numSrcRegOperands() override { return 2; }
335
336 int
337 getOperandSize(int opIdx) override
338 {
339 switch (opIdx) {
340 case 0: //ssrc_0
341 return 4;
342 case 1: //ssrc_1
343 return 4;
344 case 2: //sdst
345 return 4;
346 default:
347 fatal("op idx %i out of bounds\n", opIdx);
348 return -1;
349 }
350 } // getOperandSize
351
352 void execute(GPUDynInstPtr) override;
353 }; // Inst_SOP2__S_MAX_I32
354
356 {
357 public:
360
361 int
362 getNumOperands() override
363 {
365 } // getNumOperands
366
367 int numDstRegOperands() override { return 1; }
368 int numSrcRegOperands() override { return 2; }
369
370 int
371 getOperandSize(int opIdx) override
372 {
373 switch (opIdx) {
374 case 0: //ssrc_0
375 return 4;
376 case 1: //ssrc_1
377 return 4;
378 case 2: //sdst
379 return 4;
380 default:
381 fatal("op idx %i out of bounds\n", opIdx);
382 return -1;
383 }
384 } // getOperandSize
385
386 void execute(GPUDynInstPtr) override;
387 }; // Inst_SOP2__S_MAX_U32
388
390 {
391 public:
394
395 int
396 getNumOperands() override
397 {
399 } // getNumOperands
400
401 int numDstRegOperands() override { return 1; }
402 int numSrcRegOperands() override { return 2; }
403
404 int
405 getOperandSize(int opIdx) override
406 {
407 switch (opIdx) {
408 case 0: //ssrc_0
409 return 4;
410 case 1: //ssrc_1
411 return 4;
412 case 2: //sdst
413 return 4;
414 default:
415 fatal("op idx %i out of bounds\n", opIdx);
416 return -1;
417 }
418 } // getOperandSize
419
420 void execute(GPUDynInstPtr) override;
421 }; // Inst_SOP2__S_CSELECT_B32
422
424 {
425 public:
428
429 int
430 getNumOperands() override
431 {
433 } // getNumOperands
434
435 int numDstRegOperands() override { return 1; }
436 int numSrcRegOperands() override { return 2; }
437
438 int
439 getOperandSize(int opIdx) override
440 {
441 switch (opIdx) {
442 case 0: //ssrc_0
443 return 8;
444 case 1: //ssrc_1
445 return 8;
446 case 2: //sdst
447 return 8;
448 default:
449 fatal("op idx %i out of bounds\n", opIdx);
450 return -1;
451 }
452 } // getOperandSize
453
454 void execute(GPUDynInstPtr) override;
455 }; // Inst_SOP2__S_CSELECT_B64
456
458 {
459 public:
462
463 int
464 getNumOperands() override
465 {
467 } // getNumOperands
468
469 int numDstRegOperands() override { return 1; }
470 int numSrcRegOperands() override { return 2; }
471
472 int
473 getOperandSize(int opIdx) override
474 {
475 switch (opIdx) {
476 case 0: //ssrc_0
477 return 4;
478 case 1: //ssrc_1
479 return 4;
480 case 2: //sdst
481 return 4;
482 default:
483 fatal("op idx %i out of bounds\n", opIdx);
484 return -1;
485 }
486 } // getOperandSize
487
488 void execute(GPUDynInstPtr) override;
489 }; // Inst_SOP2__S_AND_B32
490
492 {
493 public:
496
497 int
498 getNumOperands() override
499 {
501 } // getNumOperands
502
503 int numDstRegOperands() override { return 1; }
504 int numSrcRegOperands() override { return 2; }
505
506 int
507 getOperandSize(int opIdx) override
508 {
509 switch (opIdx) {
510 case 0: //ssrc_0
511 return 8;
512 case 1: //ssrc_1
513 return 8;
514 case 2: //sdst
515 return 8;
516 default:
517 fatal("op idx %i out of bounds\n", opIdx);
518 return -1;
519 }
520 } // getOperandSize
521
522 void execute(GPUDynInstPtr) override;
523 }; // Inst_SOP2__S_AND_B64
524
526 {
527 public:
530
531 int
532 getNumOperands() override
533 {
535 } // getNumOperands
536
537 int numDstRegOperands() override { return 1; }
538 int numSrcRegOperands() override { return 2; }
539
540 int
541 getOperandSize(int opIdx) override
542 {
543 switch (opIdx) {
544 case 0: //ssrc_0
545 return 4;
546 case 1: //ssrc_1
547 return 4;
548 case 2: //sdst
549 return 4;
550 default:
551 fatal("op idx %i out of bounds\n", opIdx);
552 return -1;
553 }
554 } // getOperandSize
555
556 void execute(GPUDynInstPtr) override;
557 }; // Inst_SOP2__S_OR_B32
558
560 {
561 public:
564
565 int
566 getNumOperands() override
567 {
569 } // getNumOperands
570
571 int numDstRegOperands() override { return 1; }
572 int numSrcRegOperands() override { return 2; }
573
574 int
575 getOperandSize(int opIdx) override
576 {
577 switch (opIdx) {
578 case 0: //ssrc_0
579 return 8;
580 case 1: //ssrc_1
581 return 8;
582 case 2: //sdst
583 return 8;
584 default:
585 fatal("op idx %i out of bounds\n", opIdx);
586 return -1;
587 }
588 } // getOperandSize
589
590 void execute(GPUDynInstPtr) override;
591 }; // Inst_SOP2__S_OR_B64
592
594 {
595 public:
598
599 int
600 getNumOperands() override
601 {
603 } // getNumOperands
604
605 int numDstRegOperands() override { return 1; }
606 int numSrcRegOperands() override { return 2; }
607
608 int
609 getOperandSize(int opIdx) override
610 {
611 switch (opIdx) {
612 case 0: //ssrc_0
613 return 4;
614 case 1: //ssrc_1
615 return 4;
616 case 2: //sdst
617 return 4;
618 default:
619 fatal("op idx %i out of bounds\n", opIdx);
620 return -1;
621 }
622 } // getOperandSize
623
624 void execute(GPUDynInstPtr) override;
625 }; // Inst_SOP2__S_XOR_B32
626
628 {
629 public:
632
633 int
634 getNumOperands() override
635 {
637 } // getNumOperands
638
639 int numDstRegOperands() override { return 1; }
640 int numSrcRegOperands() override { return 2; }
641
642 int
643 getOperandSize(int opIdx) override
644 {
645 switch (opIdx) {
646 case 0: //ssrc_0
647 return 8;
648 case 1: //ssrc_1
649 return 8;
650 case 2: //sdst
651 return 8;
652 default:
653 fatal("op idx %i out of bounds\n", opIdx);
654 return -1;
655 }
656 } // getOperandSize
657
658 void execute(GPUDynInstPtr) override;
659 }; // Inst_SOP2__S_XOR_B64
660
662 {
663 public:
666
667 int
668 getNumOperands() override
669 {
671 } // getNumOperands
672
673 int numDstRegOperands() override { return 1; }
674 int numSrcRegOperands() override { return 2; }
675
676 int
677 getOperandSize(int opIdx) override
678 {
679 switch (opIdx) {
680 case 0: //ssrc_0
681 return 4;
682 case 1: //ssrc_1
683 return 4;
684 case 2: //sdst
685 return 4;
686 default:
687 fatal("op idx %i out of bounds\n", opIdx);
688 return -1;
689 }
690 } // getOperandSize
691
692 void execute(GPUDynInstPtr) override;
693 }; // Inst_SOP2__S_ANDN2_B32
694
696 {
697 public:
700
701 int
702 getNumOperands() override
703 {
705 } // getNumOperands
706
707 int numDstRegOperands() override { return 1; }
708 int numSrcRegOperands() override { return 2; }
709
710 int
711 getOperandSize(int opIdx) override
712 {
713 switch (opIdx) {
714 case 0: //ssrc_0
715 return 8;
716 case 1: //ssrc_1
717 return 8;
718 case 2: //sdst
719 return 8;
720 default:
721 fatal("op idx %i out of bounds\n", opIdx);
722 return -1;
723 }
724 } // getOperandSize
725
726 void execute(GPUDynInstPtr) override;
727 }; // Inst_SOP2__S_ANDN2_B64
728
730 {
731 public:
734
735 int
736 getNumOperands() override
737 {
739 } // getNumOperands
740
741 int numDstRegOperands() override { return 1; }
742 int numSrcRegOperands() override { return 2; }
743
744 int
745 getOperandSize(int opIdx) override
746 {
747 switch (opIdx) {
748 case 0: //ssrc_0
749 return 4;
750 case 1: //ssrc_1
751 return 4;
752 case 2: //sdst
753 return 4;
754 default:
755 fatal("op idx %i out of bounds\n", opIdx);
756 return -1;
757 }
758 } // getOperandSize
759
760 void execute(GPUDynInstPtr) override;
761 }; // Inst_SOP2__S_ORN2_B32
762
764 {
765 public:
768
769 int
770 getNumOperands() override
771 {
773 } // getNumOperands
774
775 int numDstRegOperands() override { return 1; }
776 int numSrcRegOperands() override { return 2; }
777
778 int
779 getOperandSize(int opIdx) override
780 {
781 switch (opIdx) {
782 case 0: //ssrc_0
783 return 8;
784 case 1: //ssrc_1
785 return 8;
786 case 2: //sdst
787 return 8;
788 default:
789 fatal("op idx %i out of bounds\n", opIdx);
790 return -1;
791 }
792 } // getOperandSize
793
794 void execute(GPUDynInstPtr) override;
795 }; // Inst_SOP2__S_ORN2_B64
796
798 {
799 public:
802
803 int
804 getNumOperands() override
805 {
807 } // getNumOperands
808
809 int numDstRegOperands() override { return 1; }
810 int numSrcRegOperands() override { return 2; }
811
812 int
813 getOperandSize(int opIdx) override
814 {
815 switch (opIdx) {
816 case 0: //ssrc_0
817 return 4;
818 case 1: //ssrc_1
819 return 4;
820 case 2: //sdst
821 return 4;
822 default:
823 fatal("op idx %i out of bounds\n", opIdx);
824 return -1;
825 }
826 } // getOperandSize
827
828 void execute(GPUDynInstPtr) override;
829 }; // Inst_SOP2__S_NAND_B32
830
832 {
833 public:
836
837 int
838 getNumOperands() override
839 {
841 } // getNumOperands
842
843 int numDstRegOperands() override { return 1; }
844 int numSrcRegOperands() override { return 2; }
845
846 int
847 getOperandSize(int opIdx) override
848 {
849 switch (opIdx) {
850 case 0: //ssrc_0
851 return 8;
852 case 1: //ssrc_1
853 return 8;
854 case 2: //sdst
855 return 8;
856 default:
857 fatal("op idx %i out of bounds\n", opIdx);
858 return -1;
859 }
860 } // getOperandSize
861
862 void execute(GPUDynInstPtr) override;
863 }; // Inst_SOP2__S_NAND_B64
864
866 {
867 public:
870
871 int
872 getNumOperands() override
873 {
875 } // getNumOperands
876
877 int numDstRegOperands() override { return 1; }
878 int numSrcRegOperands() override { return 2; }
879
880 int
881 getOperandSize(int opIdx) override
882 {
883 switch (opIdx) {
884 case 0: //ssrc_0
885 return 4;
886 case 1: //ssrc_1
887 return 4;
888 case 2: //sdst
889 return 4;
890 default:
891 fatal("op idx %i out of bounds\n", opIdx);
892 return -1;
893 }
894 } // getOperandSize
895
896 void execute(GPUDynInstPtr) override;
897 }; // Inst_SOP2__S_NOR_B32
898
900 {
901 public:
904
905 int
906 getNumOperands() override
907 {
909 } // getNumOperands
910
911 int numDstRegOperands() override { return 1; }
912 int numSrcRegOperands() override { return 2; }
913
914 int
915 getOperandSize(int opIdx) override
916 {
917 switch (opIdx) {
918 case 0: //ssrc_0
919 return 8;
920 case 1: //ssrc_1
921 return 8;
922 case 2: //sdst
923 return 8;
924 default:
925 fatal("op idx %i out of bounds\n", opIdx);
926 return -1;
927 }
928 } // getOperandSize
929
930 void execute(GPUDynInstPtr) override;
931 }; // Inst_SOP2__S_NOR_B64
932
934 {
935 public:
938
939 int
940 getNumOperands() override
941 {
943 } // getNumOperands
944
945 int numDstRegOperands() override { return 1; }
946 int numSrcRegOperands() override { return 2; }
947
948 int
949 getOperandSize(int opIdx) override
950 {
951 switch (opIdx) {
952 case 0: //ssrc_0
953 return 4;
954 case 1: //ssrc_1
955 return 4;
956 case 2: //sdst
957 return 4;
958 default:
959 fatal("op idx %i out of bounds\n", opIdx);
960 return -1;
961 }
962 } // getOperandSize
963
964 void execute(GPUDynInstPtr) override;
965 }; // Inst_SOP2__S_XNOR_B32
966
968 {
969 public:
972
973 int
974 getNumOperands() override
975 {
977 } // getNumOperands
978
979 int numDstRegOperands() override { return 1; }
980 int numSrcRegOperands() override { return 2; }
981
982 int
983 getOperandSize(int opIdx) override
984 {
985 switch (opIdx) {
986 case 0: //ssrc_0
987 return 8;
988 case 1: //ssrc_1
989 return 8;
990 case 2: //sdst
991 return 8;
992 default:
993 fatal("op idx %i out of bounds\n", opIdx);
994 return -1;
995 }
996 } // getOperandSize
997
998 void execute(GPUDynInstPtr) override;
999 }; // Inst_SOP2__S_XNOR_B64
1000
1002 {
1003 public:
1006
1007 int
1009 {
1011 } // getNumOperands
1012
1013 int numDstRegOperands() override { return 1; }
1014 int numSrcRegOperands() override { return 2; }
1015
1016 int
1017 getOperandSize(int opIdx) override
1018 {
1019 switch (opIdx) {
1020 case 0: //ssrc_0
1021 return 4;
1022 case 1: //ssrc_1
1023 return 4;
1024 case 2: //sdst
1025 return 4;
1026 default:
1027 fatal("op idx %i out of bounds\n", opIdx);
1028 return -1;
1029 }
1030 } // getOperandSize
1031
1032 void execute(GPUDynInstPtr) override;
1033 }; // Inst_SOP2__S_LSHL_B32
1034
1036 {
1037 public:
1040
1041 int
1043 {
1045 } // getNumOperands
1046
1047 int numDstRegOperands() override { return 1; }
1048 int numSrcRegOperands() override { return 2; }
1049
1050 int
1051 getOperandSize(int opIdx) override
1052 {
1053 switch (opIdx) {
1054 case 0: //ssrc_0
1055 return 8;
1056 case 1: //ssrc_1
1057 return 4;
1058 case 2: //sdst
1059 return 8;
1060 default:
1061 fatal("op idx %i out of bounds\n", opIdx);
1062 return -1;
1063 }
1064 } // getOperandSize
1065
1066 void execute(GPUDynInstPtr) override;
1067 }; // Inst_SOP2__S_LSHL_B64
1068
1070 {
1071 public:
1074
1075 int
1077 {
1079 } // getNumOperands
1080
1081 int numDstRegOperands() override { return 1; }
1082 int numSrcRegOperands() override { return 2; }
1083
1084 int
1085 getOperandSize(int opIdx) override
1086 {
1087 switch (opIdx) {
1088 case 0: //ssrc_0
1089 return 4;
1090 case 1: //ssrc_1
1091 return 4;
1092 case 2: //sdst
1093 return 4;
1094 default:
1095 fatal("op idx %i out of bounds\n", opIdx);
1096 return -1;
1097 }
1098 } // getOperandSize
1099
1100 void execute(GPUDynInstPtr) override;
1101 }; // Inst_SOP2__S_LSHR_B32
1102
1104 {
1105 public:
1108
1109 int
1111 {
1113 } // getNumOperands
1114
1115 int numDstRegOperands() override { return 1; }
1116 int numSrcRegOperands() override { return 2; }
1117
1118 int
1119 getOperandSize(int opIdx) override
1120 {
1121 switch (opIdx) {
1122 case 0: //ssrc_0
1123 return 8;
1124 case 1: //ssrc_1
1125 return 4;
1126 case 2: //sdst
1127 return 8;
1128 default:
1129 fatal("op idx %i out of bounds\n", opIdx);
1130 return -1;
1131 }
1132 } // getOperandSize
1133
1134 void execute(GPUDynInstPtr) override;
1135 }; // Inst_SOP2__S_LSHR_B64
1136
1138 {
1139 public:
1142
1143 int
1145 {
1147 } // getNumOperands
1148
1149 int numDstRegOperands() override { return 1; }
1150 int numSrcRegOperands() override { return 2; }
1151
1152 int
1153 getOperandSize(int opIdx) override
1154 {
1155 switch (opIdx) {
1156 case 0: //ssrc_0
1157 return 4;
1158 case 1: //ssrc_1
1159 return 4;
1160 case 2: //sdst
1161 return 4;
1162 default:
1163 fatal("op idx %i out of bounds\n", opIdx);
1164 return -1;
1165 }
1166 } // getOperandSize
1167
1168 void execute(GPUDynInstPtr) override;
1169 }; // Inst_SOP2__S_ASHR_I32
1170
1172 {
1173 public:
1176
1177 int
1179 {
1181 } // getNumOperands
1182
1183 int numDstRegOperands() override { return 1; }
1184 int numSrcRegOperands() override { return 2; }
1185
1186 int
1187 getOperandSize(int opIdx) override
1188 {
1189 switch (opIdx) {
1190 case 0: //ssrc_0
1191 return 8;
1192 case 1: //ssrc_1
1193 return 4;
1194 case 2: //sdst
1195 return 8;
1196 default:
1197 fatal("op idx %i out of bounds\n", opIdx);
1198 return -1;
1199 }
1200 } // getOperandSize
1201
1202 void execute(GPUDynInstPtr) override;
1203 }; // Inst_SOP2__S_ASHR_I64
1204
1206 {
1207 public:
1210
1211 int
1213 {
1215 } // getNumOperands
1216
1217 int numDstRegOperands() override { return 1; }
1218 int numSrcRegOperands() override { return 2; }
1219
1220 int
1221 getOperandSize(int opIdx) override
1222 {
1223 switch (opIdx) {
1224 case 0: //ssrc_0
1225 return 4;
1226 case 1: //ssrc_1
1227 return 4;
1228 case 2: //sdst
1229 return 4;
1230 default:
1231 fatal("op idx %i out of bounds\n", opIdx);
1232 return -1;
1233 }
1234 } // getOperandSize
1235
1236 void execute(GPUDynInstPtr) override;
1237 }; // Inst_SOP2__S_BFM_B32
1238
1240 {
1241 public:
1244
1245 int
1247 {
1249 } // getNumOperands
1250
1251 int numDstRegOperands() override { return 1; }
1252 int numSrcRegOperands() override { return 2; }
1253
1254 int
1255 getOperandSize(int opIdx) override
1256 {
1257 switch (opIdx) {
1258 case 0: //ssrc_0
1259 return 4;
1260 case 1: //ssrc_1
1261 return 4;
1262 case 2: //sdst
1263 return 8;
1264 default:
1265 fatal("op idx %i out of bounds\n", opIdx);
1266 return -1;
1267 }
1268 } // getOperandSize
1269
1270 void execute(GPUDynInstPtr) override;
1271 }; // Inst_SOP2__S_BFM_B64
1272
1274 {
1275 public:
1278
1279 int
1281 {
1283 } // getNumOperands
1284
1285 int numDstRegOperands() override { return 1; }
1286 int numSrcRegOperands() override { return 2; }
1287
1288 int
1289 getOperandSize(int opIdx) override
1290 {
1291 switch (opIdx) {
1292 case 0: //ssrc_0
1293 return 4;
1294 case 1: //ssrc_1
1295 return 4;
1296 case 2: //sdst
1297 return 4;
1298 default:
1299 fatal("op idx %i out of bounds\n", opIdx);
1300 return -1;
1301 }
1302 } // getOperandSize
1303
1304 void execute(GPUDynInstPtr) override;
1305 }; // Inst_SOP2__S_MUL_I32
1306
1308 {
1309 public:
1312
1313 int
1315 {
1317 } // getNumOperands
1318
1319 int numDstRegOperands() override { return 1; }
1320 int numSrcRegOperands() override { return 2; }
1321
1322 int
1323 getOperandSize(int opIdx) override
1324 {
1325 switch (opIdx) {
1326 case 0: //ssrc_0
1327 return 4;
1328 case 1: //ssrc_1
1329 return 4;
1330 case 2: //sdst
1331 return 4;
1332 default:
1333 fatal("op idx %i out of bounds\n", opIdx);
1334 return -1;
1335 }
1336 } // getOperandSize
1337
1338 void execute(GPUDynInstPtr) override;
1339 }; // Inst_SOP2__S_BFE_U32
1340
1342 {
1343 public:
1346
1347 int
1349 {
1351 } // getNumOperands
1352
1353 int numDstRegOperands() override { return 1; }
1354 int numSrcRegOperands() override { return 2; }
1355
1356 int
1357 getOperandSize(int opIdx) override
1358 {
1359 switch (opIdx) {
1360 case 0: //ssrc_0
1361 return 4;
1362 case 1: //ssrc_1
1363 return 4;
1364 case 2: //sdst
1365 return 4;
1366 default:
1367 fatal("op idx %i out of bounds\n", opIdx);
1368 return -1;
1369 }
1370 } // getOperandSize
1371
1372 void execute(GPUDynInstPtr) override;
1373 }; // Inst_SOP2__S_BFE_I32
1374
1376 {
1377 public:
1380
1381 int
1383 {
1385 } // getNumOperands
1386
1387 int numDstRegOperands() override { return 1; }
1388 int numSrcRegOperands() override { return 2; }
1389
1390 int
1391 getOperandSize(int opIdx) override
1392 {
1393 switch (opIdx) {
1394 case 0: //ssrc_0
1395 return 8;
1396 case 1: //ssrc_1
1397 return 4;
1398 case 2: //sdst
1399 return 8;
1400 default:
1401 fatal("op idx %i out of bounds\n", opIdx);
1402 return -1;
1403 }
1404 } // getOperandSize
1405
1406 void execute(GPUDynInstPtr) override;
1407 }; // Inst_SOP2__S_BFE_U64
1408
1410 {
1411 public:
1414
1415 int
1417 {
1419 } // getNumOperands
1420
1421 int numDstRegOperands() override { return 1; }
1422 int numSrcRegOperands() override { return 2; }
1423
1424 int
1425 getOperandSize(int opIdx) override
1426 {
1427 switch (opIdx) {
1428 case 0: //ssrc_0
1429 return 8;
1430 case 1: //ssrc_1
1431 return 4;
1432 case 2: //sdst
1433 return 8;
1434 default:
1435 fatal("op idx %i out of bounds\n", opIdx);
1436 return -1;
1437 }
1438 } // getOperandSize
1439
1440 void execute(GPUDynInstPtr) override;
1441 }; // Inst_SOP2__S_BFE_I64
1442
1444 {
1445 public:
1448
1449 int
1451 {
1453 } // getNumOperands
1454
1455 int numDstRegOperands() override { return 0; }
1456 int numSrcRegOperands() override { return 2; }
1457
1458 int
1459 getOperandSize(int opIdx) override
1460 {
1461 switch (opIdx) {
1462 case 0: //ssrc_0
1463 return 8;
1464 case 1: //ssrc_1
1465 return 8;
1466 case 2: //sdst
1467 return 4;
1468 default:
1469 fatal("op idx %i out of bounds\n", opIdx);
1470 return -1;
1471 }
1472 } // getOperandSize
1473
1474 void execute(GPUDynInstPtr) override;
1475 }; // Inst_SOP2__S_CBRANCH_G_FORK
1476
1478 {
1479 public:
1482
1483 int
1485 {
1487 } // getNumOperands
1488
1489 int numDstRegOperands() override { return 1; }
1490 int numSrcRegOperands() override { return 2; }
1491
1492 int
1493 getOperandSize(int opIdx) override
1494 {
1495 switch (opIdx) {
1496 case 0: //ssrc_0
1497 return 4;
1498 case 1: //ssrc_1
1499 return 4;
1500 case 2: //sdst
1501 return 4;
1502 default:
1503 fatal("op idx %i out of bounds\n", opIdx);
1504 return -1;
1505 }
1506 } // getOperandSize
1507
1508 void execute(GPUDynInstPtr) override;
1509 }; // Inst_SOP2__S_ABSDIFF_I32
1510
1512 {
1513 public:
1516
1517 int
1519 {
1521 } // getNumOperands
1522
1523 int numDstRegOperands() override { return 0; }
1524 int numSrcRegOperands() override { return 2; }
1525
1526 int
1527 getOperandSize(int opIdx) override
1528 {
1529 switch (opIdx) {
1530 case 0: //ssrc_0
1531 return 8;
1532 case 1: //ssrc_1
1533 return 4;
1534 case 2: //sdst
1535 return 4;
1536 default:
1537 fatal("op idx %i out of bounds\n", opIdx);
1538 return -1;
1539 }
1540 } // getOperandSize
1541
1542 void execute(GPUDynInstPtr) override;
1543 }; // Inst_SOP2__S_RFE_RESTORE_B64
1544
1546 {
1547 public:
1550
1551 int
1553 {
1555 } // getNumOperands
1556
1557 int numDstRegOperands() override { return 1; }
1558 int numSrcRegOperands() override { return 2; }
1559
1560 int
1561 getOperandSize(int opIdx) override
1562 {
1563 switch (opIdx) {
1564 case 0: //ssrc_0
1565 return 4;
1566 case 1: //ssrc_1
1567 return 4;
1568 case 2: //sdst
1569 return 4;
1570 default:
1571 fatal("op idx %i out of bounds\n", opIdx);
1572 return -1;
1573 }
1574 } // getOperandSize
1575
1576 void execute(GPUDynInstPtr) override;
1577 }; // Inst_SOP2__S_MUL_HI_U32
1578
1580 {
1581 public:
1584
1585 int
1587 {
1589 } // getNumOperands
1590
1591 int numDstRegOperands() override { return 1; }
1592 int numSrcRegOperands() override { return 2; }
1593
1594 int
1595 getOperandSize(int opIdx) override
1596 {
1597 switch (opIdx) {
1598 case 0: //ssrc_0
1599 return 4;
1600 case 1: //ssrc_1
1601 return 4;
1602 case 2: //sdst
1603 return 4;
1604 default:
1605 fatal("op idx %i out of bounds\n", opIdx);
1606 return -1;
1607 }
1608 } // getOperandSize
1609
1610 void execute(GPUDynInstPtr) override;
1611 }; // Inst_SOP2__S_MUL_HI_I32
1612
1614 {
1615 public:
1618
1619 int
1621 {
1623 } // getNumOperands
1624
1625 int numDstRegOperands() override { return 1; }
1626 int numSrcRegOperands() override { return 1; }
1627
1628 int
1629 getOperandSize(int opIdx) override
1630 {
1631 switch (opIdx) {
1632 case 0: //simm16
1633 return 2;
1634 case 1: //sdst
1635 return 4;
1636 default:
1637 fatal("op idx %i out of bounds\n", opIdx);
1638 return -1;
1639 }
1640 } // getOperandSize
1641
1642 void execute(GPUDynInstPtr) override;
1643 }; // Inst_SOPK__S_MOVK_I32
1644
1646 {
1647 public:
1650
1651 int
1653 {
1655 } // getNumOperands
1656
1657 int numDstRegOperands() override { return 1; }
1658 int numSrcRegOperands() override { return 1; }
1659
1660 int
1661 getOperandSize(int opIdx) override
1662 {
1663 switch (opIdx) {
1664 case 0: //simm16
1665 return 2;
1666 case 1: //sdst
1667 return 4;
1668 default:
1669 fatal("op idx %i out of bounds\n", opIdx);
1670 return -1;
1671 }
1672 } // getOperandSize
1673
1674 void execute(GPUDynInstPtr) override;
1675 }; // Inst_SOPK__S_CMOVK_I32
1676
1678 {
1679 public:
1682
1683 int
1685 {
1687 } // getNumOperands
1688
1689 int numDstRegOperands() override { return 0; }
1690 int numSrcRegOperands() override { return 2; }
1691
1692 int
1693 getOperandSize(int opIdx) override
1694 {
1695 switch (opIdx) {
1696 case 0: //ssrc
1697 return 4;
1698 case 1: //simm16
1699 return 2;
1700 default:
1701 fatal("op idx %i out of bounds\n", opIdx);
1702 return -1;
1703 }
1704 } // getOperandSize
1705
1706 void execute(GPUDynInstPtr) override;
1707 }; // Inst_SOPK__S_CMPK_EQ_I32
1708
1710 {
1711 public:
1714
1715 int
1717 {
1719 } // getNumOperands
1720
1721 int numDstRegOperands() override { return 0; }
1722 int numSrcRegOperands() override { return 2; }
1723
1724 int
1725 getOperandSize(int opIdx) override
1726 {
1727 switch (opIdx) {
1728 case 0: //ssrc
1729 return 4;
1730 case 1: //simm16
1731 return 2;
1732 default:
1733 fatal("op idx %i out of bounds\n", opIdx);
1734 return -1;
1735 }
1736 } // getOperandSize
1737
1738 void execute(GPUDynInstPtr) override;
1739 }; // Inst_SOPK__S_CMPK_LG_I32
1740
1742 {
1743 public:
1746
1747 int
1749 {
1751 } // getNumOperands
1752
1753 int numDstRegOperands() override { return 0; }
1754 int numSrcRegOperands() override { return 2; }
1755
1756 int
1757 getOperandSize(int opIdx) override
1758 {
1759 switch (opIdx) {
1760 case 0: //ssrc
1761 return 4;
1762 case 1: //simm16
1763 return 2;
1764 default:
1765 fatal("op idx %i out of bounds\n", opIdx);
1766 return -1;
1767 }
1768 } // getOperandSize
1769
1770 void execute(GPUDynInstPtr) override;
1771 }; // Inst_SOPK__S_CMPK_GT_I32
1772
1774 {
1775 public:
1778
1779 int
1781 {
1783 } // getNumOperands
1784
1785 int numDstRegOperands() override { return 0; }
1786 int numSrcRegOperands() override { return 2; }
1787
1788 int
1789 getOperandSize(int opIdx) override
1790 {
1791 switch (opIdx) {
1792 case 0: //ssrc
1793 return 4;
1794 case 1: //simm16
1795 return 2;
1796 default:
1797 fatal("op idx %i out of bounds\n", opIdx);
1798 return -1;
1799 }
1800 } // getOperandSize
1801
1802 void execute(GPUDynInstPtr) override;
1803 }; // Inst_SOPK__S_CMPK_GE_I32
1804
1806 {
1807 public:
1810
1811 int
1813 {
1815 } // getNumOperands
1816
1817 int numDstRegOperands() override { return 0; }
1818 int numSrcRegOperands() override { return 2; }
1819
1820 int
1821 getOperandSize(int opIdx) override
1822 {
1823 switch (opIdx) {
1824 case 0: //ssrc
1825 return 4;
1826 case 1: //simm16
1827 return 2;
1828 default:
1829 fatal("op idx %i out of bounds\n", opIdx);
1830 return -1;
1831 }
1832 } // getOperandSize
1833
1834 void execute(GPUDynInstPtr) override;
1835 }; // Inst_SOPK__S_CMPK_LT_I32
1836
1838 {
1839 public:
1842
1843 int
1845 {
1847 } // getNumOperands
1848
1849 int numDstRegOperands() override { return 0; }
1850 int numSrcRegOperands() override { return 2; }
1851
1852 int
1853 getOperandSize(int opIdx) override
1854 {
1855 switch (opIdx) {
1856 case 0: //ssrc
1857 return 4;
1858 case 1: //simm16
1859 return 2;
1860 default:
1861 fatal("op idx %i out of bounds\n", opIdx);
1862 return -1;
1863 }
1864 } // getOperandSize
1865
1866 void execute(GPUDynInstPtr) override;
1867 }; // Inst_SOPK__S_CMPK_LE_I32
1868
1870 {
1871 public:
1874
1875 int
1877 {
1879 } // getNumOperands
1880
1881 int numDstRegOperands() override { return 0; }
1882 int numSrcRegOperands() override { return 2; }
1883
1884 int
1885 getOperandSize(int opIdx) override
1886 {
1887 switch (opIdx) {
1888 case 0: //ssrc
1889 return 4;
1890 case 1: //simm16
1891 return 2;
1892 default:
1893 fatal("op idx %i out of bounds\n", opIdx);
1894 return -1;
1895 }
1896 } // getOperandSize
1897
1898 void execute(GPUDynInstPtr) override;
1899 }; // Inst_SOPK__S_CMPK_EQ_U32
1900
1902 {
1903 public:
1906
1907 int
1909 {
1911 } // getNumOperands
1912
1913 int numDstRegOperands() override { return 0; }
1914 int numSrcRegOperands() override { return 2; }
1915
1916 int
1917 getOperandSize(int opIdx) override
1918 {
1919 switch (opIdx) {
1920 case 0: //ssrc
1921 return 4;
1922 case 1: //simm16
1923 return 2;
1924 default:
1925 fatal("op idx %i out of bounds\n", opIdx);
1926 return -1;
1927 }
1928 } // getOperandSize
1929
1930 void execute(GPUDynInstPtr) override;
1931 }; // Inst_SOPK__S_CMPK_LG_U32
1932
1934 {
1935 public:
1938
1939 int
1941 {
1943 } // getNumOperands
1944
1945 int numDstRegOperands() override { return 0; }
1946 int numSrcRegOperands() override { return 2; }
1947
1948 int
1949 getOperandSize(int opIdx) override
1950 {
1951 switch (opIdx) {
1952 case 0: //ssrc
1953 return 4;
1954 case 1: //simm16
1955 return 2;
1956 default:
1957 fatal("op idx %i out of bounds\n", opIdx);
1958 return -1;
1959 }
1960 } // getOperandSize
1961
1962 void execute(GPUDynInstPtr) override;
1963 }; // Inst_SOPK__S_CMPK_GT_U32
1964
1966 {
1967 public:
1970
1971 int
1973 {
1975 } // getNumOperands
1976
1977 int numDstRegOperands() override { return 0; }
1978 int numSrcRegOperands() override { return 2; }
1979
1980 int
1981 getOperandSize(int opIdx) override
1982 {
1983 switch (opIdx) {
1984 case 0: //ssrc
1985 return 4;
1986 case 1: //simm16
1987 return 2;
1988 default:
1989 fatal("op idx %i out of bounds\n", opIdx);
1990 return -1;
1991 }
1992 } // getOperandSize
1993
1994 void execute(GPUDynInstPtr) override;
1995 }; // Inst_SOPK__S_CMPK_GE_U32
1996
1998 {
1999 public:
2002
2003 int
2005 {
2007 } // getNumOperands
2008
2009 int numDstRegOperands() override { return 0; }
2010 int numSrcRegOperands() override { return 2; }
2011
2012 int
2013 getOperandSize(int opIdx) override
2014 {
2015 switch (opIdx) {
2016 case 0: //ssrc
2017 return 4;
2018 case 1: //simm16
2019 return 2;
2020 default:
2021 fatal("op idx %i out of bounds\n", opIdx);
2022 return -1;
2023 }
2024 } // getOperandSize
2025
2026 void execute(GPUDynInstPtr) override;
2027 }; // Inst_SOPK__S_CMPK_LT_U32
2028
2030 {
2031 public:
2034
2035 int
2037 {
2039 } // getNumOperands
2040
2041 int numDstRegOperands() override { return 0; }
2042 int numSrcRegOperands() override { return 2; }
2043
2044 int
2045 getOperandSize(int opIdx) override
2046 {
2047 switch (opIdx) {
2048 case 0: //ssrc
2049 return 4;
2050 case 1: //simm16
2051 return 2;
2052 default:
2053 fatal("op idx %i out of bounds\n", opIdx);
2054 return -1;
2055 }
2056 } // getOperandSize
2057
2058 void execute(GPUDynInstPtr) override;
2059 }; // Inst_SOPK__S_CMPK_LE_U32
2060
2062 {
2063 public:
2066
2067 int
2069 {
2071 } // getNumOperands
2072
2073 int numDstRegOperands() override { return 1; }
2074 int numSrcRegOperands() override { return 1; }
2075
2076 int
2077 getOperandSize(int opIdx) override
2078 {
2079 switch (opIdx) {
2080 case 0: //simm16
2081 return 2;
2082 case 1: //sdst
2083 return 4;
2084 default:
2085 fatal("op idx %i out of bounds\n", opIdx);
2086 return -1;
2087 }
2088 } // getOperandSize
2089
2090 void execute(GPUDynInstPtr) override;
2091 }; // Inst_SOPK__S_ADDK_I32
2092
2094 {
2095 public:
2098
2099 int
2101 {
2103 } // getNumOperands
2104
2105 int numDstRegOperands() override { return 1; }
2106 int numSrcRegOperands() override { return 1; }
2107
2108 int
2109 getOperandSize(int opIdx) override
2110 {
2111 switch (opIdx) {
2112 case 0: //simm16
2113 return 2;
2114 case 1: //sdst
2115 return 4;
2116 default:
2117 fatal("op idx %i out of bounds\n", opIdx);
2118 return -1;
2119 }
2120 } // getOperandSize
2121
2122 void execute(GPUDynInstPtr) override;
2123 }; // Inst_SOPK__S_MULK_I32
2124
2126 {
2127 public:
2130
2131 int
2133 {
2135 } // getNumOperands
2136
2137 int numDstRegOperands() override { return 0; }
2138 int numSrcRegOperands() override { return 2; }
2139
2140 int
2141 getOperandSize(int opIdx) override
2142 {
2143 switch (opIdx) {
2144 case 0: //sdst
2145 return 8;
2146 case 1: //
2147 return 16;
2148 default:
2149 fatal("op idx %i out of bounds\n", opIdx);
2150 return -1;
2151 }
2152 } // getOperandSize
2153
2154 void execute(GPUDynInstPtr) override;
2155 }; // Inst_SOPK__S_CBRANCH_I_FORK
2156
2158 {
2159 public:
2162
2163 int
2165 {
2167 } // getNumOperands
2168
2169 int numDstRegOperands() override { return 1; }
2170 int numSrcRegOperands() override { return 1; }
2171
2172 int
2173 getOperandSize(int opIdx) override
2174 {
2175 switch (opIdx) {
2176 case 0: //simm16
2177 return 2;
2178 case 1: //sdst
2179 return 4;
2180 default:
2181 fatal("op idx %i out of bounds\n", opIdx);
2182 return -1;
2183 }
2184 } // getOperandSize
2185
2186 void execute(GPUDynInstPtr) override;
2187 }; // Inst_SOPK__S_GETREG_B32
2188
2190 {
2191 public:
2194
2195 int
2197 {
2199 } // getNumOperands
2200
2201 int numDstRegOperands() override { return 1; }
2202 int numSrcRegOperands() override { return 1; }
2203
2204 int
2205 getOperandSize(int opIdx) override
2206 {
2207 switch (opIdx) {
2208 case 0: //ssrc
2209 return 4;
2210 case 1: //simm16
2211 return 2;
2212 default:
2213 fatal("op idx %i out of bounds\n", opIdx);
2214 return -1;
2215 }
2216 } // getOperandSize
2217
2218 void execute(GPUDynInstPtr) override;
2219 }; // Inst_SOPK__S_SETREG_B32
2220
2222 {
2223 public:
2226
2227 int
2229 {
2231 } // getNumOperands
2232
2233 int numDstRegOperands() override { return 1; }
2234 int numSrcRegOperands() override { return 1; }
2235
2236 int
2237 getOperandSize(int opIdx) override
2238 {
2239 switch (opIdx) {
2240 case 0: //simm32
2241 return 4;
2242 case 1: //simm16
2243 return 2;
2244 default:
2245 fatal("op idx %i out of bounds\n", opIdx);
2246 return -1;
2247 }
2248 } // getOperandSize
2249
2250 void execute(GPUDynInstPtr) override;
2251 }; // Inst_SOPK__S_SETREG_IMM32_B32
2252
2254 {
2255 public:
2258
2259 int
2261 {
2263 } // getNumOperands
2264
2265 int numDstRegOperands() override { return 1; }
2266 int numSrcRegOperands() override { return 1; }
2267
2268 int
2269 getOperandSize(int opIdx) override
2270 {
2271 switch (opIdx) {
2272 case 0: //ssrc
2273 return 4;
2274 case 1: //sdst
2275 return 4;
2276 default:
2277 fatal("op idx %i out of bounds\n", opIdx);
2278 return -1;
2279 }
2280 } // getOperandSize
2281
2282 void execute(GPUDynInstPtr) override;
2283 }; // Inst_SOP1__S_MOV_B32
2284
2286 {
2287 public:
2290
2291 int
2293 {
2295 } // getNumOperands
2296
2297 int numDstRegOperands() override { return 1; }
2298 int numSrcRegOperands() override { return 1; }
2299
2300 int
2301 getOperandSize(int opIdx) override
2302 {
2303 switch (opIdx) {
2304 case 0: //ssrc
2305 return 8;
2306 case 1: //sdst
2307 return 8;
2308 default:
2309 fatal("op idx %i out of bounds\n", opIdx);
2310 return -1;
2311 }
2312 } // getOperandSize
2313
2314 void execute(GPUDynInstPtr) override;
2315 }; // Inst_SOP1__S_MOV_B64
2316
2318 {
2319 public:
2322
2323 int
2325 {
2327 } // getNumOperands
2328
2329 int numDstRegOperands() override { return 1; }
2330 int numSrcRegOperands() override { return 1; }
2331
2332 int
2333 getOperandSize(int opIdx) override
2334 {
2335 switch (opIdx) {
2336 case 0: //ssrc
2337 return 4;
2338 case 1: //sdst
2339 return 4;
2340 default:
2341 fatal("op idx %i out of bounds\n", opIdx);
2342 return -1;
2343 }
2344 } // getOperandSize
2345
2346 void execute(GPUDynInstPtr) override;
2347 }; // Inst_SOP1__S_CMOV_B32
2348
2350 {
2351 public:
2354
2355 int
2357 {
2359 } // getNumOperands
2360
2361 int numDstRegOperands() override { return 1; }
2362 int numSrcRegOperands() override { return 1; }
2363
2364 int
2365 getOperandSize(int opIdx) override
2366 {
2367 switch (opIdx) {
2368 case 0: //ssrc
2369 return 8;
2370 case 1: //sdst
2371 return 8;
2372 default:
2373 fatal("op idx %i out of bounds\n", opIdx);
2374 return -1;
2375 }
2376 } // getOperandSize
2377
2378 void execute(GPUDynInstPtr) override;
2379 }; // Inst_SOP1__S_CMOV_B64
2380
2382 {
2383 public:
2386
2387 int
2389 {
2391 } // getNumOperands
2392
2393 int numDstRegOperands() override { return 1; }
2394 int numSrcRegOperands() override { return 1; }
2395
2396 int
2397 getOperandSize(int opIdx) override
2398 {
2399 switch (opIdx) {
2400 case 0: //ssrc
2401 return 4;
2402 case 1: //sdst
2403 return 4;
2404 default:
2405 fatal("op idx %i out of bounds\n", opIdx);
2406 return -1;
2407 }
2408 } // getOperandSize
2409
2410 void execute(GPUDynInstPtr) override;
2411 }; // Inst_SOP1__S_NOT_B32
2412
2414 {
2415 public:
2418
2419 int
2421 {
2423 } // getNumOperands
2424
2425 int numDstRegOperands() override { return 1; }
2426 int numSrcRegOperands() override { return 1; }
2427
2428 int
2429 getOperandSize(int opIdx) override
2430 {
2431 switch (opIdx) {
2432 case 0: //ssrc
2433 return 8;
2434 case 1: //sdst
2435 return 8;
2436 default:
2437 fatal("op idx %i out of bounds\n", opIdx);
2438 return -1;
2439 }
2440 } // getOperandSize
2441
2442 void execute(GPUDynInstPtr) override;
2443 }; // Inst_SOP1__S_NOT_B64
2444
2446 {
2447 public:
2450
2451 int
2453 {
2455 } // getNumOperands
2456
2457 int numDstRegOperands() override { return 1; }
2458 int numSrcRegOperands() override { return 1; }
2459
2460 int
2461 getOperandSize(int opIdx) override
2462 {
2463 switch (opIdx) {
2464 case 0: //ssrc
2465 return 4;
2466 case 1: //sdst
2467 return 4;
2468 default:
2469 fatal("op idx %i out of bounds\n", opIdx);
2470 return -1;
2471 }
2472 } // getOperandSize
2473
2474 void execute(GPUDynInstPtr) override;
2475 }; // Inst_SOP1__S_WQM_B32
2476
2478 {
2479 public:
2482
2483 int
2485 {
2487 } // getNumOperands
2488
2489 int numDstRegOperands() override { return 1; }
2490 int numSrcRegOperands() override { return 1; }
2491
2492 int
2493 getOperandSize(int opIdx) override
2494 {
2495 switch (opIdx) {
2496 case 0: //ssrc
2497 return 8;
2498 case 1: //sdst
2499 return 8;
2500 default:
2501 fatal("op idx %i out of bounds\n", opIdx);
2502 return -1;
2503 }
2504 } // getOperandSize
2505
2506 void execute(GPUDynInstPtr) override;
2507 }; // Inst_SOP1__S_WQM_B64
2508
2510 {
2511 public:
2514
2515 int
2517 {
2519 } // getNumOperands
2520
2521 int numDstRegOperands() override { return 1; }
2522 int numSrcRegOperands() override { return 1; }
2523
2524 int
2525 getOperandSize(int opIdx) override
2526 {
2527 switch (opIdx) {
2528 case 0: //ssrc
2529 return 4;
2530 case 1: //sdst
2531 return 4;
2532 default:
2533 fatal("op idx %i out of bounds\n", opIdx);
2534 return -1;
2535 }
2536 } // getOperandSize
2537
2538 void execute(GPUDynInstPtr) override;
2539 }; // Inst_SOP1__S_BREV_B32
2540
2542 {
2543 public:
2546
2547 int
2549 {
2551 } // getNumOperands
2552
2553 int numDstRegOperands() override { return 1; }
2554 int numSrcRegOperands() override { return 1; }
2555
2556 int
2557 getOperandSize(int opIdx) override
2558 {
2559 switch (opIdx) {
2560 case 0: //ssrc
2561 return 8;
2562 case 1: //sdst
2563 return 8;
2564 default:
2565 fatal("op idx %i out of bounds\n", opIdx);
2566 return -1;
2567 }
2568 } // getOperandSize
2569
2570 void execute(GPUDynInstPtr) override;
2571 }; // Inst_SOP1__S_BREV_B64
2572
2574 {
2575 public:
2578
2579 int
2581 {
2583 } // getNumOperands
2584
2585 int numDstRegOperands() override { return 1; }
2586 int numSrcRegOperands() override { return 1; }
2587
2588 int
2589 getOperandSize(int opIdx) override
2590 {
2591 switch (opIdx) {
2592 case 0: //ssrc
2593 return 4;
2594 case 1: //sdst
2595 return 4;
2596 default:
2597 fatal("op idx %i out of bounds\n", opIdx);
2598 return -1;
2599 }
2600 } // getOperandSize
2601
2602 void execute(GPUDynInstPtr) override;
2603 }; // Inst_SOP1__S_BCNT0_I32_B32
2604
2606 {
2607 public:
2610
2611 int
2613 {
2615 } // getNumOperands
2616
2617 int numDstRegOperands() override { return 1; }
2618 int numSrcRegOperands() override { return 1; }
2619
2620 int
2621 getOperandSize(int opIdx) override
2622 {
2623 switch (opIdx) {
2624 case 0: //ssrc
2625 return 8;
2626 case 1: //sdst
2627 return 4;
2628 default:
2629 fatal("op idx %i out of bounds\n", opIdx);
2630 return -1;
2631 }
2632 } // getOperandSize
2633
2634 void execute(GPUDynInstPtr) override;
2635 }; // Inst_SOP1__S_BCNT0_I32_B64
2636
2638 {
2639 public:
2642
2643 int
2645 {
2647 } // getNumOperands
2648
2649 int numDstRegOperands() override { return 1; }
2650 int numSrcRegOperands() override { return 1; }
2651
2652 int
2653 getOperandSize(int opIdx) override
2654 {
2655 switch (opIdx) {
2656 case 0: //ssrc
2657 return 4;
2658 case 1: //sdst
2659 return 4;
2660 default:
2661 fatal("op idx %i out of bounds\n", opIdx);
2662 return -1;
2663 }
2664 } // getOperandSize
2665
2666 void execute(GPUDynInstPtr) override;
2667 }; // Inst_SOP1__S_BCNT1_I32_B32
2668
2670 {
2671 public:
2674
2675 int
2677 {
2679 } // getNumOperands
2680
2681 int numDstRegOperands() override { return 1; }
2682 int numSrcRegOperands() override { return 1; }
2683
2684 int
2685 getOperandSize(int opIdx) override
2686 {
2687 switch (opIdx) {
2688 case 0: //ssrc
2689 return 8;
2690 case 1: //sdst
2691 return 4;
2692 default:
2693 fatal("op idx %i out of bounds\n", opIdx);
2694 return -1;
2695 }
2696 } // getOperandSize
2697
2698 void execute(GPUDynInstPtr) override;
2699 }; // Inst_SOP1__S_BCNT1_I32_B64
2700
2702 {
2703 public:
2706
2707 int
2709 {
2711 } // getNumOperands
2712
2713 int numDstRegOperands() override { return 1; }
2714 int numSrcRegOperands() override { return 1; }
2715
2716 int
2717 getOperandSize(int opIdx) override
2718 {
2719 switch (opIdx) {
2720 case 0: //ssrc
2721 return 4;
2722 case 1: //sdst
2723 return 4;
2724 default:
2725 fatal("op idx %i out of bounds\n", opIdx);
2726 return -1;
2727 }
2728 } // getOperandSize
2729
2730 void execute(GPUDynInstPtr) override;
2731 }; // Inst_SOP1__S_FF0_I32_B32
2732
2734 {
2735 public:
2738
2739 int
2741 {
2743 } // getNumOperands
2744
2745 int numDstRegOperands() override { return 1; }
2746 int numSrcRegOperands() override { return 1; }
2747
2748 int
2749 getOperandSize(int opIdx) override
2750 {
2751 switch (opIdx) {
2752 case 0: //ssrc
2753 return 8;
2754 case 1: //sdst
2755 return 4;
2756 default:
2757 fatal("op idx %i out of bounds\n", opIdx);
2758 return -1;
2759 }
2760 } // getOperandSize
2761
2762 void execute(GPUDynInstPtr) override;
2763 }; // Inst_SOP1__S_FF0_I32_B64
2764
2766 {
2767 public:
2770
2771 int
2773 {
2775 } // getNumOperands
2776
2777 int numDstRegOperands() override { return 1; }
2778 int numSrcRegOperands() override { return 1; }
2779
2780 int
2781 getOperandSize(int opIdx) override
2782 {
2783 switch (opIdx) {
2784 case 0: //ssrc
2785 return 4;
2786 case 1: //sdst
2787 return 4;
2788 default:
2789 fatal("op idx %i out of bounds\n", opIdx);
2790 return -1;
2791 }
2792 } // getOperandSize
2793
2794 void execute(GPUDynInstPtr) override;
2795 }; // Inst_SOP1__S_FF1_I32_B32
2796
2798 {
2799 public:
2802
2803 int
2805 {
2807 } // getNumOperands
2808
2809 int numDstRegOperands() override { return 1; }
2810 int numSrcRegOperands() override { return 1; }
2811
2812 int
2813 getOperandSize(int opIdx) override
2814 {
2815 switch (opIdx) {
2816 case 0: //ssrc
2817 return 8;
2818 case 1: //sdst
2819 return 4;
2820 default:
2821 fatal("op idx %i out of bounds\n", opIdx);
2822 return -1;
2823 }
2824 } // getOperandSize
2825
2826 void execute(GPUDynInstPtr) override;
2827 }; // Inst_SOP1__S_FF1_I32_B64
2828
2830 {
2831 public:
2834
2835 int
2837 {
2839 } // getNumOperands
2840
2841 int numDstRegOperands() override { return 1; }
2842 int numSrcRegOperands() override { return 1; }
2843
2844 int
2845 getOperandSize(int opIdx) override
2846 {
2847 switch (opIdx) {
2848 case 0: //ssrc
2849 return 4;
2850 case 1: //sdst
2851 return 4;
2852 default:
2853 fatal("op idx %i out of bounds\n", opIdx);
2854 return -1;
2855 }
2856 } // getOperandSize
2857
2858 void execute(GPUDynInstPtr) override;
2859 }; // Inst_SOP1__S_FLBIT_I32_B32
2860
2862 {
2863 public:
2866
2867 int
2869 {
2871 } // getNumOperands
2872
2873 int numDstRegOperands() override { return 1; }
2874 int numSrcRegOperands() override { return 1; }
2875
2876 int
2877 getOperandSize(int opIdx) override
2878 {
2879 switch (opIdx) {
2880 case 0: //ssrc
2881 return 8;
2882 case 1: //sdst
2883 return 4;
2884 default:
2885 fatal("op idx %i out of bounds\n", opIdx);
2886 return -1;
2887 }
2888 } // getOperandSize
2889
2890 void execute(GPUDynInstPtr) override;
2891 }; // Inst_SOP1__S_FLBIT_I32_B64
2892
2894 {
2895 public:
2898
2899 int
2901 {
2903 } // getNumOperands
2904
2905 int numDstRegOperands() override { return 1; }
2906 int numSrcRegOperands() override { return 1; }
2907
2908 int
2909 getOperandSize(int opIdx) override
2910 {
2911 switch (opIdx) {
2912 case 0: //ssrc
2913 return 4;
2914 case 1: //sdst
2915 return 4;
2916 default:
2917 fatal("op idx %i out of bounds\n", opIdx);
2918 return -1;
2919 }
2920 } // getOperandSize
2921
2922 void execute(GPUDynInstPtr) override;
2923 }; // Inst_SOP1__S_FLBIT_I32
2924
2926 {
2927 public:
2930
2931 int
2933 {
2935 } // getNumOperands
2936
2937 int numDstRegOperands() override { return 1; }
2938 int numSrcRegOperands() override { return 1; }
2939
2940 int
2941 getOperandSize(int opIdx) override
2942 {
2943 switch (opIdx) {
2944 case 0: //ssrc
2945 return 8;
2946 case 1: //sdst
2947 return 4;
2948 default:
2949 fatal("op idx %i out of bounds\n", opIdx);
2950 return -1;
2951 }
2952 } // getOperandSize
2953
2954 void execute(GPUDynInstPtr) override;
2955 }; // Inst_SOP1__S_FLBIT_I32_I64
2956
2958 {
2959 public:
2962
2963 int
2965 {
2967 } // getNumOperands
2968
2969 int numDstRegOperands() override { return 1; }
2970 int numSrcRegOperands() override { return 1; }
2971
2972 int
2973 getOperandSize(int opIdx) override
2974 {
2975 switch (opIdx) {
2976 case 0: //ssrc
2977 return 4;
2978 case 1: //sdst
2979 return 4;
2980 default:
2981 fatal("op idx %i out of bounds\n", opIdx);
2982 return -1;
2983 }
2984 } // getOperandSize
2985
2986 void execute(GPUDynInstPtr) override;
2987 }; // Inst_SOP1__S_SEXT_I32_I8
2988
2990 {
2991 public:
2994
2995 int
2997 {
2999 } // getNumOperands
3000
3001 int numDstRegOperands() override { return 1; }
3002 int numSrcRegOperands() override { return 1; }
3003
3004 int
3005 getOperandSize(int opIdx) override
3006 {
3007 switch (opIdx) {
3008 case 0: //ssrc
3009 return 4;
3010 case 1: //sdst
3011 return 4;
3012 default:
3013 fatal("op idx %i out of bounds\n", opIdx);
3014 return -1;
3015 }
3016 } // getOperandSize
3017
3018 void execute(GPUDynInstPtr) override;
3019 }; // Inst_SOP1__S_SEXT_I32_I16
3020
3022 {
3023 public:
3026
3027 int
3029 {
3031 } // getNumOperands
3032
3033 int numDstRegOperands() override { return 1; }
3034 int numSrcRegOperands() override { return 1; }
3035
3036 int
3037 getOperandSize(int opIdx) override
3038 {
3039 switch (opIdx) {
3040 case 0: //ssrc
3041 return 4;
3042 case 1: //sdst
3043 return 4;
3044 default:
3045 fatal("op idx %i out of bounds\n", opIdx);
3046 return -1;
3047 }
3048 } // getOperandSize
3049
3050 void execute(GPUDynInstPtr) override;
3051 }; // Inst_SOP1__S_BITSET0_B32
3052
3054 {
3055 public:
3058
3059 int
3061 {
3063 } // getNumOperands
3064
3065 int numDstRegOperands() override { return 1; }
3066 int numSrcRegOperands() override { return 1; }
3067
3068 int
3069 getOperandSize(int opIdx) override
3070 {
3071 switch (opIdx) {
3072 case 0: //ssrc
3073 return 4;
3074 case 1: //sdst
3075 return 8;
3076 default:
3077 fatal("op idx %i out of bounds\n", opIdx);
3078 return -1;
3079 }
3080 } // getOperandSize
3081
3082 void execute(GPUDynInstPtr) override;
3083 }; // Inst_SOP1__S_BITSET0_B64
3084
3086 {
3087 public:
3090
3091 int
3093 {
3095 } // getNumOperands
3096
3097 int numDstRegOperands() override { return 1; }
3098 int numSrcRegOperands() override { return 1; }
3099
3100 int
3101 getOperandSize(int opIdx) override
3102 {
3103 switch (opIdx) {
3104 case 0: //ssrc
3105 return 4;
3106 case 1: //sdst
3107 return 4;
3108 default:
3109 fatal("op idx %i out of bounds\n", opIdx);
3110 return -1;
3111 }
3112 } // getOperandSize
3113
3114 void execute(GPUDynInstPtr) override;
3115 }; // Inst_SOP1__S_BITSET1_B32
3116
3118 {
3119 public:
3122
3123 int
3125 {
3127 } // getNumOperands
3128
3129 int numDstRegOperands() override { return 1; }
3130 int numSrcRegOperands() override { return 1; }
3131
3132 int
3133 getOperandSize(int opIdx) override
3134 {
3135 switch (opIdx) {
3136 case 0: //ssrc
3137 return 4;
3138 case 1: //sdst
3139 return 8;
3140 default:
3141 fatal("op idx %i out of bounds\n", opIdx);
3142 return -1;
3143 }
3144 } // getOperandSize
3145
3146 void execute(GPUDynInstPtr) override;
3147 }; // Inst_SOP1__S_BITSET1_B64
3148
3150 {
3151 public:
3154
3155 int
3157 {
3159 } // getNumOperands
3160
3161 int numDstRegOperands() override { return 1; }
3162 int numSrcRegOperands() override { return 0; }
3163
3164 int
3165 getOperandSize(int opIdx) override
3166 {
3167 switch (opIdx) {
3168 case 0: //sdst
3169 return 8;
3170 default:
3171 fatal("op idx %i out of bounds\n", opIdx);
3172 return -1;
3173 }
3174 } // getOperandSize
3175
3176 void execute(GPUDynInstPtr) override;
3177 }; // Inst_SOP1__S_GETPC_B64
3178
3180 {
3181 public:
3184
3185 int
3187 {
3189 } // getNumOperands
3190
3191 int numDstRegOperands() override { return 0; }
3192 int numSrcRegOperands() override { return 1; }
3193
3194 int
3195 getOperandSize(int opIdx) override
3196 {
3197 switch (opIdx) {
3198 case 0: //ssrc
3199 return 8;
3200 case 1: //sdst
3201 return 8;
3202 default:
3203 fatal("op idx %i out of bounds\n", opIdx);
3204 return -1;
3205 }
3206 } // getOperandSize
3207
3208 void execute(GPUDynInstPtr) override;
3209 }; // Inst_SOP1__S_SETPC_B64
3210
3212 {
3213 public:
3216
3217 int
3219 {
3221 } // getNumOperands
3222
3223 int numDstRegOperands() override { return 1; }
3224 int numSrcRegOperands() override { return 1; }
3225
3226 int
3227 getOperandSize(int opIdx) override
3228 {
3229 switch (opIdx) {
3230 case 0: //ssrc
3231 return 8;
3232 case 1: //sdst
3233 return 8;
3234 default:
3235 fatal("op idx %i out of bounds\n", opIdx);
3236 return -1;
3237 }
3238 } // getOperandSize
3239
3240 void execute(GPUDynInstPtr) override;
3241 }; // Inst_SOP1__S_SWAPPC_B64
3242
3244 {
3245 public:
3248
3249 int
3251 {
3253 } // getNumOperands
3254
3255 int numDstRegOperands() override { return 0; }
3256 int numSrcRegOperands() override { return 1; }
3257
3258 int
3259 getOperandSize(int opIdx) override
3260 {
3261 switch (opIdx) {
3262 case 0: //ssrc
3263 return 8;
3264 case 1: //sdst
3265 return 8;
3266 default:
3267 fatal("op idx %i out of bounds\n", opIdx);
3268 return -1;
3269 }
3270 } // getOperandSize
3271
3272 void execute(GPUDynInstPtr) override;
3273 }; // Inst_SOP1__S_RFE_B64
3274
3276 {
3277 public:
3280
3281 int
3283 {
3285 } // getNumOperands
3286
3287 int numDstRegOperands() override { return 1; }
3288 int numSrcRegOperands() override { return 1; }
3289
3290 int
3291 getOperandSize(int opIdx) override
3292 {
3293 switch (opIdx) {
3294 case 0: //ssrc
3295 return 8;
3296 case 1: //sdst
3297 return 8;
3298 default:
3299 fatal("op idx %i out of bounds\n", opIdx);
3300 return -1;
3301 }
3302 } // getOperandSize
3303
3304 void execute(GPUDynInstPtr) override;
3305 }; // Inst_SOP1__S_AND_SAVEEXEC_B64
3306
3308 {
3309 public:
3312
3313 int
3315 {
3317 } // getNumOperands
3318
3319 int numDstRegOperands() override { return 1; }
3320 int numSrcRegOperands() override { return 1; }
3321
3322 int
3323 getOperandSize(int opIdx) override
3324 {
3325 switch (opIdx) {
3326 case 0: //ssrc
3327 return 8;
3328 case 1: //sdst
3329 return 8;
3330 default:
3331 fatal("op idx %i out of bounds\n", opIdx);
3332 return -1;
3333 }
3334 } // getOperandSize
3335
3336 void execute(GPUDynInstPtr) override;
3337 }; // Inst_SOP1__S_OR_SAVEEXEC_B64
3338
3340 {
3341 public:
3344
3345 int
3347 {
3349 } // getNumOperands
3350
3351 int numDstRegOperands() override { return 1; }
3352 int numSrcRegOperands() override { return 1; }
3353
3354 int
3355 getOperandSize(int opIdx) override
3356 {
3357 switch (opIdx) {
3358 case 0: //ssrc
3359 return 8;
3360 case 1: //sdst
3361 return 8;
3362 default:
3363 fatal("op idx %i out of bounds\n", opIdx);
3364 return -1;
3365 }
3366 } // getOperandSize
3367
3368 void execute(GPUDynInstPtr) override;
3369 }; // Inst_SOP1__S_XOR_SAVEEXEC_B64
3370
3372 {
3373 public:
3376
3377 int
3379 {
3381 } // getNumOperands
3382
3383 int numDstRegOperands() override { return 1; }
3384 int numSrcRegOperands() override { return 1; }
3385
3386 int
3387 getOperandSize(int opIdx) override
3388 {
3389 switch (opIdx) {
3390 case 0: //ssrc
3391 return 8;
3392 case 1: //sdst
3393 return 8;
3394 default:
3395 fatal("op idx %i out of bounds\n", opIdx);
3396 return -1;
3397 }
3398 } // getOperandSize
3399
3400 void execute(GPUDynInstPtr) override;
3401 }; // Inst_SOP1__S_ANDN2_SAVEEXEC_B64
3402
3404 {
3405 public:
3408
3409 int
3411 {
3413 } // getNumOperands
3414
3415 int numDstRegOperands() override { return 1; }
3416 int numSrcRegOperands() override { return 1; }
3417
3418 int
3419 getOperandSize(int opIdx) override
3420 {
3421 switch (opIdx) {
3422 case 0: //ssrc
3423 return 8;
3424 case 1: //sdst
3425 return 8;
3426 default:
3427 fatal("op idx %i out of bounds\n", opIdx);
3428 return -1;
3429 }
3430 } // getOperandSize
3431
3432 void execute(GPUDynInstPtr) override;
3433 }; // Inst_SOP1__S_ORN2_SAVEEXEC_B64
3434
3436 {
3437 public:
3440
3441 int
3443 {
3445 } // getNumOperands
3446
3447 int numDstRegOperands() override { return 1; }
3448 int numSrcRegOperands() override { return 1; }
3449
3450 int
3451 getOperandSize(int opIdx) override
3452 {
3453 switch (opIdx) {
3454 case 0: //ssrc
3455 return 8;
3456 case 1: //sdst
3457 return 8;
3458 default:
3459 fatal("op idx %i out of bounds\n", opIdx);
3460 return -1;
3461 }
3462 } // getOperandSize
3463
3464 void execute(GPUDynInstPtr) override;
3465 }; // Inst_SOP1__S_NAND_SAVEEXEC_B64
3466
3468 {
3469 public:
3472
3473 int
3475 {
3477 } // getNumOperands
3478
3479 int numDstRegOperands() override { return 1; }
3480 int numSrcRegOperands() override { return 1; }
3481
3482 int
3483 getOperandSize(int opIdx) override
3484 {
3485 switch (opIdx) {
3486 case 0: //ssrc
3487 return 8;
3488 case 1: //sdst
3489 return 8;
3490 default:
3491 fatal("op idx %i out of bounds\n", opIdx);
3492 return -1;
3493 }
3494 } // getOperandSize
3495
3496 void execute(GPUDynInstPtr) override;
3497 }; // Inst_SOP1__S_NOR_SAVEEXEC_B64
3498
3500 {
3501 public:
3504
3505 int
3507 {
3509 } // getNumOperands
3510
3511 int numDstRegOperands() override { return 1; }
3512 int numSrcRegOperands() override { return 1; }
3513
3514 int
3515 getOperandSize(int opIdx) override
3516 {
3517 switch (opIdx) {
3518 case 0: //ssrc
3519 return 8;
3520 case 1: //sdst
3521 return 8;
3522 default:
3523 fatal("op idx %i out of bounds\n", opIdx);
3524 return -1;
3525 }
3526 } // getOperandSize
3527
3528 void execute(GPUDynInstPtr) override;
3529 }; // Inst_SOP1__S_XNOR_SAVEEXEC_B64
3530
3532 {
3533 public:
3536
3537 int
3539 {
3541 } // getNumOperands
3542
3543 int numDstRegOperands() override { return 1; }
3544 int numSrcRegOperands() override { return 1; }
3545
3546 int
3547 getOperandSize(int opIdx) override
3548 {
3549 switch (opIdx) {
3550 case 0: //ssrc
3551 return 4;
3552 case 1: //sdst
3553 return 4;
3554 default:
3555 fatal("op idx %i out of bounds\n", opIdx);
3556 return -1;
3557 }
3558 } // getOperandSize
3559
3560 void execute(GPUDynInstPtr) override;
3561 }; // Inst_SOP1__S_QUADMASK_B32
3562
3564 {
3565 public:
3568
3569 int
3571 {
3573 } // getNumOperands
3574
3575 int numDstRegOperands() override { return 1; }
3576 int numSrcRegOperands() override { return 1; }
3577
3578 int
3579 getOperandSize(int opIdx) override
3580 {
3581 switch (opIdx) {
3582 case 0: //ssrc
3583 return 8;
3584 case 1: //sdst
3585 return 8;
3586 default:
3587 fatal("op idx %i out of bounds\n", opIdx);
3588 return -1;
3589 }
3590 } // getOperandSize
3591
3592 void execute(GPUDynInstPtr) override;
3593 }; // Inst_SOP1__S_QUADMASK_B64
3594
3596 {
3597 public:
3600
3601 int
3603 {
3605 } // getNumOperands
3606
3607 int numDstRegOperands() override { return 1; }
3608 int numSrcRegOperands() override { return 1; }
3609
3610 int
3611 getOperandSize(int opIdx) override
3612 {
3613 switch (opIdx) {
3614 case 0: //ssrc
3615 return 4;
3616 case 1: //sdst
3617 return 4;
3618 default:
3619 fatal("op idx %i out of bounds\n", opIdx);
3620 return -1;
3621 }
3622 } // getOperandSize
3623
3624 void execute(GPUDynInstPtr) override;
3625 }; // Inst_SOP1__S_MOVRELS_B32
3626
3628 {
3629 public:
3632
3633 int
3635 {
3637 } // getNumOperands
3638
3639 int numDstRegOperands() override { return 1; }
3640 int numSrcRegOperands() override { return 1; }
3641
3642 int
3643 getOperandSize(int opIdx) override
3644 {
3645 switch (opIdx) {
3646 case 0: //sdst
3647 return 8;
3648 case 1: //sdst
3649 return 8;
3650 default:
3651 fatal("op idx %i out of bounds\n", opIdx);
3652 return -1;
3653 }
3654 } // getOperandSize
3655
3656 void execute(GPUDynInstPtr) override;
3657 }; // Inst_SOP1__S_MOVRELS_B64
3658
3660 {
3661 public:
3664
3665 int
3667 {
3669 } // getNumOperands
3670
3671 int numDstRegOperands() override { return 1; }
3672 int numSrcRegOperands() override { return 1; }
3673
3674 int
3675 getOperandSize(int opIdx) override
3676 {
3677 switch (opIdx) {
3678 case 0: //ssrc
3679 return 4;
3680 case 1: //sdst
3681 return 4;
3682 default:
3683 fatal("op idx %i out of bounds\n", opIdx);
3684 return -1;
3685 }
3686 } // getOperandSize
3687
3688 void execute(GPUDynInstPtr) override;
3689 }; // Inst_SOP1__S_MOVRELD_B32
3690
3692 {
3693 public:
3696
3697 int
3699 {
3701 } // getNumOperands
3702
3703 int numDstRegOperands() override { return 1; }
3704 int numSrcRegOperands() override { return 1; }
3705
3706 int
3707 getOperandSize(int opIdx) override
3708 {
3709 switch (opIdx) {
3710 case 0: //ssrc
3711 return 8;
3712 case 1: //sdst
3713 return 8;
3714 default:
3715 fatal("op idx %i out of bounds\n", opIdx);
3716 return -1;
3717 }
3718 } // getOperandSize
3719
3720 void execute(GPUDynInstPtr) override;
3721 }; // Inst_SOP1__S_MOVRELD_B64
3722
3724 {
3725 public:
3728
3729 int
3731 {
3733 } // getNumOperands
3734
3735 int numDstRegOperands() override { return 0; }
3736 int numSrcRegOperands() override { return 1; }
3737
3738 int
3739 getOperandSize(int opIdx) override
3740 {
3741 switch (opIdx) {
3742 case 0: //ssrc
3743 return 4;
3744 case 1: //sdst
3745 return 4;
3746 default:
3747 fatal("op idx %i out of bounds\n", opIdx);
3748 return -1;
3749 }
3750 } // getOperandSize
3751
3752 void execute(GPUDynInstPtr) override;
3753 }; // Inst_SOP1__S_CBRANCH_JOIN
3754
3756 {
3757 public:
3760
3761 int
3763 {
3765 } // getNumOperands
3766
3767 int numDstRegOperands() override { return 1; }
3768 int numSrcRegOperands() override { return 1; }
3769
3770 int
3771 getOperandSize(int opIdx) override
3772 {
3773 switch (opIdx) {
3774 case 0: //ssrc
3775 return 4;
3776 case 1: //sdst
3777 return 4;
3778 default:
3779 fatal("op idx %i out of bounds\n", opIdx);
3780 return -1;
3781 }
3782 } // getOperandSize
3783
3784 void execute(GPUDynInstPtr) override;
3785 }; // Inst_SOP1__S_ABS_I32
3786
3788 {
3789 public:
3792
3793 int
3795 {
3797 } // getNumOperands
3798
3799 int numDstRegOperands() override { return 1; }
3800 int numSrcRegOperands() override { return 1; }
3801
3802 int
3803 getOperandSize(int opIdx) override
3804 {
3805 switch (opIdx) {
3806 case 0: //ssrc
3807 return 4;
3808 case 1: //sdst
3809 return 4;
3810 default:
3811 fatal("op idx %i out of bounds\n", opIdx);
3812 return -1;
3813 }
3814 } // getOperandSize
3815
3816 void execute(GPUDynInstPtr) override;
3817 }; // Inst_SOP1__S_MOV_FED_B32
3818
3820 {
3821 public:
3824
3825 int
3827 {
3829 } // getNumOperands
3830
3831 int numDstRegOperands() override { return 0; }
3832 int numSrcRegOperands() override { return 1; }
3833
3834 int
3835 getOperandSize(int opIdx) override
3836 {
3837 switch (opIdx) {
3838 case 0: //ssrc
3839 return 4;
3840 case 1: //sdst
3841 return 4;
3842 default:
3843 fatal("op idx %i out of bounds\n", opIdx);
3844 return -1;
3845 }
3846 } // getOperandSize
3847
3848 void execute(GPUDynInstPtr) override;
3849 }; // Inst_SOP1__S_SET_GPR_IDX_IDX
3850
3852 {
3853 public:
3856
3857 int
3859 {
3861 } // getNumOperands
3862
3863 int numDstRegOperands() override { return 0; }
3864 int numSrcRegOperands() override { return 2; }
3865
3866 int
3867 getOperandSize(int opIdx) override
3868 {
3869 switch (opIdx) {
3870 case 0: //ssrc_0
3871 return 4;
3872 case 1: //ssrc_1
3873 return 4;
3874 default:
3875 fatal("op idx %i out of bounds\n", opIdx);
3876 return -1;
3877 }
3878 } // getOperandSize
3879
3880 void execute(GPUDynInstPtr) override;
3881 }; // Inst_SOPC__S_CMP_EQ_I32
3882
3884 {
3885 public:
3888
3889 int
3891 {
3893 } // getNumOperands
3894
3895 int numDstRegOperands() override { return 0; }
3896 int numSrcRegOperands() override { return 2; }
3897
3898 int
3899 getOperandSize(int opIdx) override
3900 {
3901 switch (opIdx) {
3902 case 0: //ssrc_0
3903 return 4;
3904 case 1: //ssrc_1
3905 return 4;
3906 default:
3907 fatal("op idx %i out of bounds\n", opIdx);
3908 return -1;
3909 }
3910 } // getOperandSize
3911
3912 void execute(GPUDynInstPtr) override;
3913 }; // Inst_SOPC__S_CMP_LG_I32
3914
3916 {
3917 public:
3920
3921 int
3923 {
3925 } // getNumOperands
3926
3927 int numDstRegOperands() override { return 0; }
3928 int numSrcRegOperands() override { return 2; }
3929
3930 int
3931 getOperandSize(int opIdx) override
3932 {
3933 switch (opIdx) {
3934 case 0: //ssrc_0
3935 return 4;
3936 case 1: //ssrc_1
3937 return 4;
3938 default:
3939 fatal("op idx %i out of bounds\n", opIdx);
3940 return -1;
3941 }
3942 } // getOperandSize
3943
3944 void execute(GPUDynInstPtr) override;
3945 }; // Inst_SOPC__S_CMP_GT_I32
3946
3948 {
3949 public:
3952
3953 int
3955 {
3957 } // getNumOperands
3958
3959 int numDstRegOperands() override { return 0; }
3960 int numSrcRegOperands() override { return 2; }
3961
3962 int
3963 getOperandSize(int opIdx) override
3964 {
3965 switch (opIdx) {
3966 case 0: //ssrc_0
3967 return 4;
3968 case 1: //ssrc_1
3969 return 4;
3970 default:
3971 fatal("op idx %i out of bounds\n", opIdx);
3972 return -1;
3973 }
3974 } // getOperandSize
3975
3976 void execute(GPUDynInstPtr) override;
3977 }; // Inst_SOPC__S_CMP_GE_I32
3978
3980 {
3981 public:
3984
3985 int
3987 {
3989 } // getNumOperands
3990
3991 int numDstRegOperands() override { return 0; }
3992 int numSrcRegOperands() override { return 2; }
3993
3994 int
3995 getOperandSize(int opIdx) override
3996 {
3997 switch (opIdx) {
3998 case 0: //ssrc_0
3999 return 4;
4000 case 1: //ssrc_1
4001 return 4;
4002 default:
4003 fatal("op idx %i out of bounds\n", opIdx);
4004 return -1;
4005 }
4006 } // getOperandSize
4007
4008 void execute(GPUDynInstPtr) override;
4009 }; // Inst_SOPC__S_CMP_LT_I32
4010
4012 {
4013 public:
4016
4017 int
4019 {
4021 } // getNumOperands
4022
4023 int numDstRegOperands() override { return 0; }
4024 int numSrcRegOperands() override { return 2; }
4025
4026 int
4027 getOperandSize(int opIdx) override
4028 {
4029 switch (opIdx) {
4030 case 0: //ssrc_0
4031 return 4;
4032 case 1: //ssrc_1
4033 return 4;
4034 default:
4035 fatal("op idx %i out of bounds\n", opIdx);
4036 return -1;
4037 }
4038 } // getOperandSize
4039
4040 void execute(GPUDynInstPtr) override;
4041 }; // Inst_SOPC__S_CMP_LE_I32
4042
4044 {
4045 public:
4048
4049 int
4051 {
4053 } // getNumOperands
4054
4055 int numDstRegOperands() override { return 0; }
4056 int numSrcRegOperands() override { return 2; }
4057
4058 int
4059 getOperandSize(int opIdx) override
4060 {
4061 switch (opIdx) {
4062 case 0: //ssrc_0
4063 return 4;
4064 case 1: //ssrc_1
4065 return 4;
4066 default:
4067 fatal("op idx %i out of bounds\n", opIdx);
4068 return -1;
4069 }
4070 } // getOperandSize
4071
4072 void execute(GPUDynInstPtr) override;
4073 }; // Inst_SOPC__S_CMP_EQ_U32
4074
4076 {
4077 public:
4080
4081 int
4083 {
4085 } // getNumOperands
4086
4087 int numDstRegOperands() override { return 0; }
4088 int numSrcRegOperands() override { return 2; }
4089
4090 int
4091 getOperandSize(int opIdx) override
4092 {
4093 switch (opIdx) {
4094 case 0: //ssrc_0
4095 return 4;
4096 case 1: //ssrc_1
4097 return 4;
4098 default:
4099 fatal("op idx %i out of bounds\n", opIdx);
4100 return -1;
4101 }
4102 } // getOperandSize
4103
4104 void execute(GPUDynInstPtr) override;
4105 }; // Inst_SOPC__S_CMP_LG_U32
4106
4108 {
4109 public:
4112
4113 int
4115 {
4117 } // getNumOperands
4118
4119 int numDstRegOperands() override { return 0; }
4120 int numSrcRegOperands() override { return 2; }
4121
4122 int
4123 getOperandSize(int opIdx) override
4124 {
4125 switch (opIdx) {
4126 case 0: //ssrc_0
4127 return 4;
4128 case 1: //ssrc_1
4129 return 4;
4130 default:
4131 fatal("op idx %i out of bounds\n", opIdx);
4132 return -1;
4133 }
4134 } // getOperandSize
4135
4136 void execute(GPUDynInstPtr) override;
4137 }; // Inst_SOPC__S_CMP_GT_U32
4138
4140 {
4141 public:
4144
4145 int
4147 {
4149 } // getNumOperands
4150
4151 int numDstRegOperands() override { return 0; }
4152 int numSrcRegOperands() override { return 2; }
4153
4154 int
4155 getOperandSize(int opIdx) override
4156 {
4157 switch (opIdx) {
4158 case 0: //ssrc_0
4159 return 4;
4160 case 1: //ssrc_1
4161 return 4;
4162 default:
4163 fatal("op idx %i out of bounds\n", opIdx);
4164 return -1;
4165 }
4166 } // getOperandSize
4167
4168 void execute(GPUDynInstPtr) override;
4169 }; // Inst_SOPC__S_CMP_GE_U32
4170
4172 {
4173 public:
4176
4177 int
4179 {
4181 } // getNumOperands
4182
4183 int numDstRegOperands() override { return 0; }
4184 int numSrcRegOperands() override { return 2; }
4185
4186 int
4187 getOperandSize(int opIdx) override
4188 {
4189 switch (opIdx) {
4190 case 0: //ssrc_0
4191 return 4;
4192 case 1: //ssrc_1
4193 return 4;
4194 default:
4195 fatal("op idx %i out of bounds\n", opIdx);
4196 return -1;
4197 }
4198 } // getOperandSize
4199
4200 void execute(GPUDynInstPtr) override;
4201 }; // Inst_SOPC__S_CMP_LT_U32
4202
4204 {
4205 public:
4208
4209 int
4211 {
4213 } // getNumOperands
4214
4215 int numDstRegOperands() override { return 0; }
4216 int numSrcRegOperands() override { return 2; }
4217
4218 int
4219 getOperandSize(int opIdx) override
4220 {
4221 switch (opIdx) {
4222 case 0: //ssrc_0
4223 return 4;
4224 case 1: //ssrc_1
4225 return 4;
4226 default:
4227 fatal("op idx %i out of bounds\n", opIdx);
4228 return -1;
4229 }
4230 } // getOperandSize
4231
4232 void execute(GPUDynInstPtr) override;
4233 }; // Inst_SOPC__S_CMP_LE_U32
4234
4236 {
4237 public:
4240
4241 int
4243 {
4245 } // getNumOperands
4246
4247 int numDstRegOperands() override { return 0; }
4248 int numSrcRegOperands() override { return 2; }
4249
4250 int
4251 getOperandSize(int opIdx) override
4252 {
4253 switch (opIdx) {
4254 case 0: //ssrc_0
4255 return 4;
4256 case 1: //ssrc_1
4257 return 4;
4258 default:
4259 fatal("op idx %i out of bounds\n", opIdx);
4260 return -1;
4261 }
4262 } // getOperandSize
4263
4264 void execute(GPUDynInstPtr) override;
4265 }; // Inst_SOPC__S_BITCMP0_B32
4266
4268 {
4269 public:
4272
4273 int
4275 {
4277 } // getNumOperands
4278
4279 int numDstRegOperands() override { return 0; }
4280 int numSrcRegOperands() override { return 2; }
4281
4282 int
4283 getOperandSize(int opIdx) override
4284 {
4285 switch (opIdx) {
4286 case 0: //ssrc_0
4287 return 4;
4288 case 1: //ssrc_1
4289 return 4;
4290 default:
4291 fatal("op idx %i out of bounds\n", opIdx);
4292 return -1;
4293 }
4294 } // getOperandSize
4295
4296 void execute(GPUDynInstPtr) override;
4297 }; // Inst_SOPC__S_BITCMP1_B32
4298
4300 {
4301 public:
4304
4305 int
4307 {
4309 } // getNumOperands
4310
4311 int numDstRegOperands() override { return 0; }
4312 int numSrcRegOperands() override { return 2; }
4313
4314 int
4315 getOperandSize(int opIdx) override
4316 {
4317 switch (opIdx) {
4318 case 0: //ssrc_0
4319 return 8;
4320 case 1: //ssrc_1
4321 return 4;
4322 default:
4323 fatal("op idx %i out of bounds\n", opIdx);
4324 return -1;
4325 }
4326 } // getOperandSize
4327
4328 void execute(GPUDynInstPtr) override;
4329 }; // Inst_SOPC__S_BITCMP0_B64
4330
4332 {
4333 public:
4336
4337 int
4339 {
4341 } // getNumOperands
4342
4343 int numDstRegOperands() override { return 0; }
4344 int numSrcRegOperands() override { return 2; }
4345
4346 int
4347 getOperandSize(int opIdx) override
4348 {
4349 switch (opIdx) {
4350 case 0: //ssrc_0
4351 return 8;
4352 case 1: //ssrc_1
4353 return 4;
4354 default:
4355 fatal("op idx %i out of bounds\n", opIdx);
4356 return -1;
4357 }
4358 } // getOperandSize
4359
4360 void execute(GPUDynInstPtr) override;
4361 }; // Inst_SOPC__S_BITCMP1_B64
4362
4364 {
4365 public:
4368
4369 int
4371 {
4373 } // getNumOperands
4374
4375 int numDstRegOperands() override { return 0; }
4376 int numSrcRegOperands() override { return 2; }
4377
4378 int
4379 getOperandSize(int opIdx) override
4380 {
4381 switch (opIdx) {
4382 case 0: //ssrc_0
4383 return 4;
4384 case 1: //ssrc_1
4385 return 4;
4386 default:
4387 fatal("op idx %i out of bounds\n", opIdx);
4388 return -1;
4389 }
4390 } // getOperandSize
4391
4392 void execute(GPUDynInstPtr) override;
4393 }; // Inst_SOPC__S_SETVSKIP
4394
4396 {
4397 public:
4400
4401 int
4403 {
4405 } // getNumOperands
4406
4407 int numDstRegOperands() override { return 0; }
4408 int numSrcRegOperands() override { return 2; }
4409
4410 int
4411 getOperandSize(int opIdx) override
4412 {
4413 switch (opIdx) {
4414 case 0: //ssrc_0
4415 return 4;
4416 case 1: //simm4
4417 return 4;
4418 default:
4419 fatal("op idx %i out of bounds\n", opIdx);
4420 return -1;
4421 }
4422 } // getOperandSize
4423
4424 void execute(GPUDynInstPtr) override;
4425 }; // Inst_SOPC__S_SET_GPR_IDX_ON
4426
4428 {
4429 public:
4432
4433 int
4435 {
4437 } // getNumOperands
4438
4439 int numDstRegOperands() override { return 0; }
4440 int numSrcRegOperands() override { return 2; }
4441
4442 int
4443 getOperandSize(int opIdx) override
4444 {
4445 switch (opIdx) {
4446 case 0: //ssrc_0
4447 return 8;
4448 case 1: //ssrc_1
4449 return 8;
4450 default:
4451 fatal("op idx %i out of bounds\n", opIdx);
4452 return -1;
4453 }
4454 } // getOperandSize
4455
4456 void execute(GPUDynInstPtr) override;
4457 }; // Inst_SOPC__S_CMP_EQ_U64
4458
4460 {
4461 public:
4464
4465 int
4467 {
4469 } // getNumOperands
4470
4471 int numDstRegOperands() override { return 0; }
4472 int numSrcRegOperands() override { return 2; }
4473
4474 int
4475 getOperandSize(int opIdx) override
4476 {
4477 switch (opIdx) {
4478 case 0: //ssrc_0
4479 return 8;
4480 case 1: //ssrc_1
4481 return 8;
4482 default:
4483 fatal("op idx %i out of bounds\n", opIdx);
4484 return -1;
4485 }
4486 } // getOperandSize
4487
4488 void execute(GPUDynInstPtr) override;
4489 }; // Inst_SOPC__S_CMP_LG_U64
4490
4492 {
4493 public:
4496
4497 int
4499 {
4501 } // getNumOperands
4502
4503 int numDstRegOperands() override { return 0; }
4504 int numSrcRegOperands() override { return 1; }
4505
4506 int
4507 getOperandSize(int opIdx) override
4508 {
4509 switch (opIdx) {
4510 case 0: //simm16
4511 return 2;
4512 default:
4513 fatal("op idx %i out of bounds\n", opIdx);
4514 return -1;
4515 }
4516 } // getOperandSize
4517
4518 void execute(GPUDynInstPtr) override;
4519 }; // Inst_SOPP__S_NOP
4520
4522 {
4523 public:
4526
4527 int
4529 {
4531 } // getNumOperands
4532
4533 int numDstRegOperands() override { return 0; }
4534 int numSrcRegOperands() override { return 0; }
4535
4536 int
4537 getOperandSize(int opIdx) override
4538 {
4539 switch (opIdx) {
4540 case 0: //simm16
4541 return 2;
4542 default:
4543 fatal("op idx %i out of bounds\n", opIdx);
4544 return -1;
4545 }
4546 } // getOperandSize
4547
4548 void execute(GPUDynInstPtr) override;
4549 }; // Inst_SOPP__S_ENDPGM
4550
4552 {
4553 public:
4556
4557 int
4559 {
4561 } // getNumOperands
4562
4563 int numDstRegOperands() override { return 0; }
4564 int numSrcRegOperands() override { return 1; }
4565
4566 int
4567 getOperandSize(int opIdx) override
4568 {
4569 switch (opIdx) {
4570 case 0: //label
4571 return 2;
4572 default:
4573 fatal("op idx %i out of bounds\n", opIdx);
4574 return -1;
4575 }
4576 } // getOperandSize
4577
4578 void execute(GPUDynInstPtr) override;
4579 }; // Inst_SOPP__S_BRANCH
4580
4582 {
4583 public:
4586
4587 int
4589 {
4591 } // getNumOperands
4592
4593 int numDstRegOperands() override { return 0; }
4594 int numSrcRegOperands() override { return 0; }
4595
4596 int
4597 getOperandSize(int opIdx) override
4598 {
4599 switch (opIdx) {
4600 case 0: //simm16
4601 return 2;
4602 default:
4603 fatal("op idx %i out of bounds\n", opIdx);
4604 return -1;
4605 }
4606 } // getOperandSize
4607
4608 void execute(GPUDynInstPtr) override;
4609 }; // Inst_SOPP__S_WAKEUP
4610
4612 {
4613 public:
4616
4617 int
4619 {
4621 } // getNumOperands
4622
4623 int numDstRegOperands() override { return 0; }
4624 int numSrcRegOperands() override { return 1; }
4625
4626 int
4627 getOperandSize(int opIdx) override
4628 {
4629 switch (opIdx) {
4630 case 0: //label
4631 return 2;
4632 default:
4633 fatal("op idx %i out of bounds\n", opIdx);
4634 return -1;
4635 }
4636 } // getOperandSize
4637
4638 void execute(GPUDynInstPtr) override;
4639 }; // Inst_SOPP__S_CBRANCH_SCC0
4640
4642 {
4643 public:
4646
4647 int
4649 {
4651 } // getNumOperands
4652
4653 int numDstRegOperands() override { return 0; }
4654 int numSrcRegOperands() override { return 1; }
4655
4656 int
4657 getOperandSize(int opIdx) override
4658 {
4659 switch (opIdx) {
4660 case 0: //label
4661 return 2;
4662 default:
4663 fatal("op idx %i out of bounds\n", opIdx);
4664 return -1;
4665 }
4666 } // getOperandSize
4667
4668 void execute(GPUDynInstPtr) override;
4669 }; // Inst_SOPP__S_CBRANCH_SCC1
4670
4672 {
4673 public:
4676
4677 int
4679 {
4681 } // getNumOperands
4682
4683 int numDstRegOperands() override { return 0; }
4684 int numSrcRegOperands() override { return 2; }
4685
4686 int
4687 getOperandSize(int opIdx) override
4688 {
4689 switch (opIdx) {
4690 case 0: //label
4691 return 2;
4692 case 1:
4693 return 8;
4694 default:
4695 fatal("op idx %i out of bounds\n", opIdx);
4696 return -1;
4697 }
4698 } // getOperandSize
4699
4700 void execute(GPUDynInstPtr) override;
4701 }; // Inst_SOPP__S_CBRANCH_VCCZ
4702
4703 class