[gem5-dev] Change in gem5/gem5[develop]: arch-vega: Add fatal when decoding missing insts

Kyle Roarty (Gerrit) via gem5-dev Thu, 01 Jul 2021 20:23:20 -0700

Kyle Roarty has uploaded this change for review. (https://gem5-review.googlesource.com/c/public/gem5/+/47522 )


Change subject: arch-vega: Add fatal when decoding missing insts
......................................................................

arch-vega: Add fatal when decoding missing insts

Certain instructions don't have implementations in instructions.cc,
and get decoded as a nullptr.

This adds a fatal when decoding a missing instruction, as we aren't
able to properly run a program if all its instructions aren't
implemented, and it allows us to figure out which instruction i
missing due to fatals printing the line they were called.

Change-Id: I7e3690f079b790dceee102063773d5fbbc8619f1
---
M src/arch/amdgpu/vega/decoder.cc
1 file changed, 229 insertions(+), 0 deletions(-)

diff --git a/src/arch/amdgpu/vega/decoder.ccb/src/arch/amdgpu/vega/decoder.cc

index 480d326..94035f6 100644
--- a/src/arch/amdgpu/vega/decoder.cc
+++ b/src/arch/amdgpu/vega/decoder.cc
@@ -4437,6 +4437,7 @@
     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_MUL_HI_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -4449,42 +4450,49 @@
     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_LSHL1_ADD_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_LSHL2_ADD_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_LSHL3_ADD_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_LSHL4_ADD_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_PACK_LL_B32_B16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_PACK_LH_B32_B16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP2__S_HH_B32_B16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -4611,6 +4619,7 @@
     GPUStaticInst*
     Decoder::decode_OP_SOPK__S_CALL_B64(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -6831,108 +6840,126 @@
     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MAD_U32_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MAD_I32_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_XAD_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MIN3_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MIN3_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MIN3_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MAX3_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MAX3_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MAX3_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MED3_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MED3_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_MED3_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_LSHL_ADD_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_ADD_LSHL_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_ADD3_U32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_LSHL_OR_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_AND_OR_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_OR3_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -6999,6 +7026,7 @@
     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_INTERP_P2_LEGACY_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -7155,42 +7183,49 @@
     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_PKNORM_I16_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_PKNORM_U16_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_ADD_I32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_SUB_I32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_ADD_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_SUB_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OPU_VOP3__V_PACK_B32_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -7329,6 +7364,7 @@
     GPUStaticInst*
     Decoder::decode_OP_DS__DS_WRITE_ADDTID_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -7659,48 +7695,56 @@
     GPUStaticInst*
     Decoder::decode_OP_DS__DS_WRITE_B8_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_WRITE_B16_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_U8_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_U8_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_I8_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_I8_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_U16_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_U16_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -7983,6 +8027,7 @@
     GPUStaticInst*
     Decoder::decode_OP_DS__DS_READ_ADDTID_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -8175,6 +8220,7 @@
     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_STORE_BYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -8187,6 +8233,7 @@
     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_STORE_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -8217,36 +8264,42 @@
     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_LOAD_UBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_LOAD_UBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_LOAD_SBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_LOAD_SBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_LOAD_SHORT_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_FLAT__FLAT_LOAD_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -8409,288 +8462,336 @@
     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_UBYTE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_SBYTE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_USHORT(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_SSHORT(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_DWORD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_DWORDX2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_DWORDX3(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_DWORDX4(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_BYTE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_BYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_SHORT(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_DWORD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_DWORDX2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_DWORDX3(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_STORE_DWORDX4(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_UBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_UBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_SBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_SBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_SHORT_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_LOAD_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SWAP(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_CMPSWAP(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_ADD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SUB(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SMIN(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_UMIN(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SMAX(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_UMAX(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_AND(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_OR(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_XOR(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_INC(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_DEC(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SWAP_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_CMPSWAP_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_ADD_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SUB_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SMIN_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_UMIN_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_SMAX_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_UMAX_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_AND_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_OR_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_XOR_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_INC_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_GLOBAL__GLOBAL_ATOMIC_DEC_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9045,6 +9146,7 @@
     GPUStaticInst*
     Decoder::decode_OP_MIMG__IMAGE_GATHER4H(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9087,12 +9189,14 @@
     GPUStaticInst*
     Decoder::decode_OP_MIMG__IMAGE_GATHER4H_PCK(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_MIMG__IMAGE_GATHER8H_PCK(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9496,6 +9600,7 @@
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_STORE_BYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9508,6 +9613,7 @@
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_STORE_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9712,132 +9818,154 @@
     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_UBYTE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_SBYTE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_USHORT(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_SSHORT(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_DWORD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_DWORDX2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_DWORDX3(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_DWORDX4(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_BYTE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_BYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_SHORT(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_DWORD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_DWORDX2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_DWORDX3(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_STORE_DWORDX4(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_UBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_UBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_SBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_SBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_SHORT_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SCRATCH__SCRATCH_LOAD_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9874,18 +10002,21 @@
     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_SCRATCH_LOAD_DWORD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_SCRATCH_LOAD_DWORDX2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_SCRATCH_LOAD_DWORDX4(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9940,18 +10071,21 @@
     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_SCRATCH_STORE_DWORD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_SCRATCH_STORE_DWORDX2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_SCRATCH_STORE_DWORDX4(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -9976,41 +10110,49 @@
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_UBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_UBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_SBYTE_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_SBYTE_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_SHORT_D16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_SHORT_D16_HI(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_LOAD_FORMAT_D16_HI_X(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }
     GPUStaticInst*
     Decoder::decode_OP_MUBUF__BUFFER_STORE_FORMAT_D16_HI_X(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -10065,324 +10207,378 @@
     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_DCACHE_DISCARD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_DCACHE_DISCARD_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SWAP(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_CMPSWAP(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_ADD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SUB(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SMIN(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_UMIN(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SMAX(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_UMAX(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_AND(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_OR(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_XOR(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_INC(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_DEC(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SWAP_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_CMPSWAP_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_ADD_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SUB_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SMIN_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_UMIN_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_SMAX_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_UMAX_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_AND_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_OR_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_XOR_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_INC_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_BUFFER_ATOMIC_DEC_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SWAP(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_CMPSWAP(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_ADD(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SUB(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SMIN(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_UMIN(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SMAX(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_UMAX(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_AND(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_OR(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_XOR(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_INC(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_DEC(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SWAP_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_CMPSWAP_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_ADD_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SUB_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SMIN_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_UMIN_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_SMAX_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_UMAX_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_AND_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_OR_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_XOR_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_INC_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SMEM__S_ATOMIC_DEC_X2(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -10683,30 +10879,35 @@
     GPUStaticInst*
     Decoder::decode_OP_SOP1__S_ANDN1_SAVEEXEC_B64(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP1__S_ORN1_SAVEEXEC_B64(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP1__S_ANDN1_WREXEC_B64(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP1__S_ANDN2_WREXEC_B64(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_SOP1__S_BITREPLICATE_B64_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -11013,6 +11214,7 @@
     GPUStaticInst*
     Decoder::decode_OP_SOPP__S_ENDPGM_ORDERED_PS_DONE(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -11355,6 +11557,7 @@
     GPUStaticInst*
     Decoder::decode_OP_VOP1__V_SCREEN_PARTITION_4SE_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -11481,24 +11684,28 @@
     GPUStaticInst*
     Decoder::decode_OP_VOP1__V_CVT_NORM_I16_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP1__V_CVT_NORM_U16_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP1__V_SAT_PK_U8_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP1__V_SWAP_B32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

@@ -12693,132 +12900,154 @@
     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MAD_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MUL_LO_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_ADD_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_SUB_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_LSHLREV_B16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_LSHRREV_B16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_ASHRREV_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MAX_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MIN_I16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MAD_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_ADD_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_SUB_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MAX_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MIN_U16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_FMA_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_ADD_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MUL_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MIN_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_PK_MAX_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_MAD_MIX_F32(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_MAD_MIXLO_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }

     GPUStaticInst*
     Decoder::decode_OP_VOP3P__V_MAD_MIXHI_F16(MachInst iFmt)
     {
+        fatal("Trying to decode instruction without a class\n");
         return nullptr;
     }


--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/47522

To unsubscribe, or for help writing mail filters, visithttps://gem5-review.googlesource.com/settings


Gerrit-Project: public/gem5
Gerrit-Branch: develop
Gerrit-Change-Id: I7e3690f079b790dceee102063773d5fbbc8619f1
Gerrit-Change-Number: 47522
Gerrit-PatchSet: 1
Gerrit-Owner: Kyle Roarty <kyleroarty1...@gmail.com>
Gerrit-MessageType: newchange

_______________________________________________
gem5-dev mailing list -- gem5-dev@gem5.org
To unsubscribe send an email to gem5-dev-le...@gem5.org
%(web_page_url)slistinfo%(cgiext)s/%(_internal_name)s

[gem5-dev] Change in gem5/gem5[develop]: arch-vega: Add fatal when decoding missing insts

Reply via email to