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

Matt Sinclair (Gerrit) via gem5-dev Mon, 12 Jul 2021 18:26:59 -0700

Matt Sinclair has submitted this change. (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 is
missing due to fatals printing the line they were called.

Change-Id: I7e3690f079b790dceee102063773d5fbbc8619f1
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/47522
Reviewed-by: Matt Sinclair <mattdsincl...@gmail.com>
Maintainer: Matt Sinclair <mattdsincl...@gmail.com>
Tested-by: kokoro <noreply+kok...@google.com>
---
M src/arch/amdgpu/vega/decoder.cc
1 file changed, 229 insertions(+), 0 deletions(-)

Approvals:
  Matt Sinclair: Looks good to me, approved; Looks good to me, approved
  kokoro: Regressions pass

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

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

@@ -4452,42 +4453,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;
     }

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

@@ -6834,108 +6843,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;
     }

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

@@ -7158,42 +7186,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;
     }

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

@@ -7662,48 +7698,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;
     }

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

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

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

@@ -8220,36 +8267,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;
     }

@@ -8412,288 +8465,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;
     }

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

@@ -9090,12 +9192,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;
     }

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

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

@@ -9715,132 +9821,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;
     }

@@ -9877,18 +10005,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;
     }

@@ -9943,18 +10074,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;
     }

@@ -9979,41 +10113,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;
     }

@@ -10068,324 +10210,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;
     }

@@ -10686,30 +10882,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;
     }

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

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

@@ -11484,24 +11687,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;
     }

@@ -12696,132 +12903,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: 3
Gerrit-Owner: Kyle Roarty <kyleroarty1...@gmail.com>
Gerrit-Reviewer: Alex Dutu <alexandru.d...@amd.com>
Gerrit-Reviewer: Gabe Black <gabe.bl...@gmail.com>
Gerrit-Reviewer: Matt Sinclair <mattdsincl...@gmail.com>
Gerrit-Reviewer: Matthew Poremba <matthew.pore...@amd.com>
Gerrit-Reviewer: kokoro <noreply+kok...@google.com>
Gerrit-MessageType: merged

_______________________________________________
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