// -*- mode:c++ -*-

// Copyright (c) 2015 RISC-V Foundation
// Copyright (c) 2017 The University of Virginia
// Copyright (c) 2020 Barkhausen Institut
// Copyright (c) 2021 StreamComputing Corp
// Copyright (c) 2022 Google LLC
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met: redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer;
// redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution;
// neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

////////////////////////////////////////////////////////////////////
//
// The RISC-V ISA decoder
//

// In theory, all registers should be sign extended if not operating in the
// full MXLEN register, but that will cause memory address out of range as it is
// always regarded as uint64. So we'll zero extend PC related registers and
// memory address, and sign extend others.
decode QUADRANT default Unknown::unknown() {
    0x0: decode COPCODE {
        0x0: CIAddi4spnOp::c_addi4spn({{
            imm = CIMM8<1:1> << 2 |
                  CIMM8<0:0> << 3 |
                  CIMM8<7:6> << 4 |
                  CIMM8<5:2> << 6;
        }}, {{
            if (imm == 0)
                return std::make_shared<IllegalInstFault>("immediate = 0",
                                                           machInst);
            Rp2 = rvSext(sp + imm);
        }}, uint64_t);
        format CompressedLoad {
            0x1: c_fld({{
                offset = CIMM3 << 3 | CIMM2 << 6;
            }}, {{
                STATUS status = xc->readMiscReg(MISCREG_STATUS);
                if (status.fs == FPUStatus::OFF)
                    return std::make_shared<IllegalInstFault>("FPU is off",
                                                               machInst);

                Fp2_bits = Mem;
            }}, {{
                EA = rvZext(Rp1 + offset);
            }});
            0x2: c_lw({{
                offset = CIMM2<1:1> << 2 |
                         CIMM3 << 3 |
                         CIMM2<0:0> << 6;
            }}, {{
                Rp2_sd = Mem_sw;
            }}, {{
                EA = rvZext(Rp1 + offset);
            }});
            0x3: decode RVTYPE {
                0x0: c_flw({{
                    offset = CIMM2<1:1> << 2 |
                             CIMM3 << 3 |
                             CIMM2<0:0> << 6;
                }}, {{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>("FPU is off",
                                                                   machInst);

                    freg_t fd = freg(f32(Mem_uw));
                    Fp2_bits = fd.v;
                }}, {{
                    EA = (uint32_t)(Rp1_uw + offset);
                }});
                0x1: c_ld({{
                    offset = CIMM3 << 3 | CIMM2 << 6;
                }}, {{
                    Rp2_sd = Mem_sd;
                }}, {{
                    EA = Rp1 + offset;
                }});
            }
        }
        format CompressedStore {
            0x5: c_fsd({{
                offset = CIMM3 << 3 | CIMM2 << 6;
            }}, {{
                STATUS status = xc->readMiscReg(MISCREG_STATUS);
                if (status.fs == FPUStatus::OFF)
                    return std::make_shared<IllegalInstFault>("FPU is off",
                                                               machInst);

                Mem = Fp2_bits;
            }}, {{
                EA = rvZext(Rp1 + offset);
            }});
            0x6: c_sw({{
                offset = CIMM2<1:1> << 2 |
                         CIMM3 << 3 |
                         CIMM2<0:0> << 6;
            }}, {{
                Mem_uw = Rp2_uw;
            }}, ea_code={{
                EA = rvZext(Rp1 + offset);
            }});
            0x7: decode RVTYPE {
                0x0: c_fsw({{
                    offset = CIMM2<1:1> << 2 |
                             CIMM3 << 3 |
                             CIMM2<0:0> << 6;
                }}, {{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>("FPU is off",
                                                                   machInst);

                    Mem_uw = unboxF32(boxF32(Fs2_bits));
                }}, {{
                    EA = (uint32_t)(Rp1_uw + offset);
                }});
                0x1: c_sd({{
                    offset = CIMM3 << 3 | CIMM2 << 6;
                }}, {{
                    Mem_ud = Rp2_ud;
                }}, {{
                    EA = Rp1 + offset;
                }});
            }
        }
    }
    0x1: decode COPCODE {
        0x0: CIOp::c_addi({{
            imm = sext<6>(CIMM5 | (CIMM1 << 5));
        }}, {{
            if ((RC1 == 0) != (imm == 0)) {
                if (RC1 == 0) {
                    // imm != 0 is HINT
                } else {
                    // imm == 0 is HINT
                }
            }
            Rc1_sd = rvSext(Rc1_sd + imm);
        }});
        0x1: decode RVTYPE {
            0x0: CJOp::c_jal({{
                ra_sw = NPC_uw;
                NPC_uw = PC_uw + imm;
            }}, IsDirectControl, IsUncondControl, IsCall);
            0x1: CIOp::c_addiw({{
                imm = sext<6>(CIMM5 | (CIMM1 << 5));
            }}, {{
                if (RC1 == 0) {
                    return std::make_shared<IllegalInstFault>(
                            "source reg x0", machInst);
                }
                Rc1_sw = (int32_t)(Rc1_sw + imm);
            }});
        }
        0x2: CIOp::c_li({{
            imm = sext<6>(CIMM5 | (CIMM1 << 5));
        }}, {{
            // RC1 == 0 is HINT
            Rc1_sd = imm;
        }});
        0x3: decode RC1 {
            0x2: CIOp::c_addi16sp({{
                imm = sext<10>((CIMM5<4:4> << 4) |
                               (CIMM5<0:0> << 5) |
                               (CIMM5<3:3> << 6) |
                               (CIMM5<2:1> << 7) |
                               (CIMM1 << 9));
            }}, {{
                if (imm == 0) {
                    return std::make_shared<IllegalInstFault>(
                            "immediate = 0", machInst);
                }
                sp_sd = rvSext(sp_sd + imm);
            }});
            default: CIOp::c_lui({{
                imm = sext<6>(CIMM5 | (CIMM1 << 5)) << 12;
            }}, {{
                // RC1 == 0 is HINT
                if (imm == 0) {
                    return std::make_shared<IllegalInstFault>(
                            "immediate = 0", machInst);
                }
                Rc1_sd = imm;
            }});
        }
        0x4: decode CFUNCT2HIGH {
            format CIOp {
                0x0: c_srli({{
                    imm = CIMM5 | (CIMM1 << 5);
                }}, {{
                    if (rvSelect((bool)CIMM1, false)) {
                        return std::make_shared<IllegalInstFault>(
                                "shmat[5] != 0", machInst);
                    }
                    if (imm == 0) {
                        // C.SRLI64, HINT for RV32/RV64
                    }
                    // The MSB can never be 1, hence no need to sign ext.
                    Rp1 = rvZext(Rp1) >> imm;
                }}, uint64_t);
                0x1: c_srai({{
                    imm = CIMM5 | (CIMM1 << 5);
                }}, {{
                    if (rvSelect((bool)CIMM1, false)) {
                        return std::make_shared<IllegalInstFault>(
                                "shmat[5] != 0", machInst);
                    }
                    if (imm == 0) {
                        // C.SRAI64, HINT for RV32/RV64
                    }
                    Rp1_sd = rvSext(Rp1_sd) >> imm;
                }}, uint64_t);
                0x2: c_andi({{
                    imm = CIMM5;
                    if (CIMM1 > 0)
                        imm |= ~((uint64_t)0x1F);
                }}, {{
                    Rp1 = rvSext(Rp1 & imm);
                }}, uint64_t);
            }
            format CompressedROp {
                0x3: decode CFUNCT1 {
                    0x0: decode CFUNCT2LOW {
                        0x0: c_sub({{
                            Rp1 = rvSext(Rp1 - Rp2);
                        }});
                        0x1: c_xor({{
                            Rp1 = rvSext(Rp1 ^ Rp2);
                        }});
                        0x2: c_or({{
                            Rp1 = rvSext(Rp1 | Rp2);
                        }});
                        0x3: c_and({{
                            Rp1 = rvSext(Rp1 & Rp2);
                        }});
                    }
                    0x1: decode RVTYPE {
                        0x1: decode CFUNCT2LOW {
                            0x0: c_subw({{
                                Rp1_sd = (int32_t)Rp1_sd - Rp2_sw;
                            }});
                            0x1: c_addw({{
                                Rp1_sd = (int32_t)Rp1_sd + Rp2_sw;
                            }});
                        }
                    }
                }
            }
        }
        0x5: CJOp::c_j({{
            NPC = rvZext(PC + imm);
        }}, IsDirectControl, IsUncondControl);
        format CBOp {
            0x6: c_beqz({{
                if (rvSext(Rp1) == 0)
                    NPC = rvZext(PC + imm);
                else
                    NPC = NPC;
            }}, IsDirectControl, IsCondControl);
            0x7: c_bnez({{
                if (rvSext(Rp1) != 0)
                    NPC = rvZext(PC + imm);
                else
                    NPC = NPC;
            }}, IsDirectControl, IsCondControl);
        }
    }
    0x2: decode COPCODE {
        0x0: CIOp::c_slli({{
            imm = CIMM5 | (CIMM1 << 5);
        }}, {{
            if (rvSelect((bool)CIMM1, false)) {
                return std::make_shared<IllegalInstFault>(
                        "shmat[5] != 0", machInst);
            }
            if (imm == 0) {
                // C.SLLI64, HINT for RV32/RV64
            }
            // RC1 == 0 is HINT
            Rc1 = rvSext(Rc1 << imm);
        }}, uint64_t);
        format CompressedLoad {
            0x1: c_fldsp({{
                offset = CIMM5<4:3> << 3 |
                         CIMM1 << 5 |
                         CIMM5<2:0> << 6;
            }}, {{
                STATUS status = xc->readMiscReg(MISCREG_STATUS);
                if (status.fs == FPUStatus::OFF)
                    return std::make_shared<IllegalInstFault>("FPU is off",
                                                               machInst);

                Fc1_bits = Mem;
            }}, {{
                EA = rvZext(sp + offset);
            }});
            0x2: c_lwsp({{
                offset = CIMM5<4:2> << 2 |
                         CIMM1 << 5 |
                         CIMM5<1:0> << 6;
            }}, {{
                if (RC1 == 0) {
                    return std::make_shared<IllegalInstFault>(
                            "source reg x0", machInst);
                }
                Rc1_sw = Mem_sw;
            }}, {{
                EA = rvZext(sp + offset);
            }});
            0x3: decode RVTYPE {
                0x0: c_flwsp({{
                    offset = CIMM5<4:2> << 2 |
                             CIMM1 << 5 |
                             CIMM5<1:0> << 6;
                }}, {{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>("FPU is off",
                                                                   machInst);

                    freg_t fd;
                    fd = freg(f32(Mem_uw));
                    Fd_bits = fd.v;
                }}, {{
                    EA = (uint32_t)(sp_uw + offset);
                }});
                0x1: c_ldsp({{
                    offset = CIMM5<4:3> << 3 |
                             CIMM1 << 5 |
                             CIMM5<2:0> << 6;
                }}, {{
                    if (RC1 == 0) {
                        return std::make_shared<IllegalInstFault>(
                                "source reg x0", machInst);
                    }
                    Rc1_sd = Mem_sd;
                }}, {{
                    EA = sp + offset;
                }});
            }
        }
        0x4: decode CFUNCT1 {
            0x0: decode RC2 {
                0x0: Jump::c_jr({{
                    if (RC1 == 0) {
                        return std::make_shared<IllegalInstFault>(
                                "source reg x0", machInst);
                    }
                    NPC = rvZext(Rc1);
                }}, IsIndirectControl, IsUncondControl);
                default: CROp::c_mv({{
                    // RC1 == 0 is HINT
                    Rc1 = rvSext(Rc2);
                }});
            }
            0x1: decode RC2 {
                0x0: decode RC1 {
                    0x0: SystemOp::c_ebreak({{
                        return std::make_shared<BreakpointFault>(
                            xc->pcState());
                    }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                    default: Jump::c_jalr({{
                        ra = rvSext(NPC);
                        NPC = rvZext(Rc1);
                    }}, IsIndirectControl, IsUncondControl, IsCall);
                }
                default: CompressedROp::c_add({{
                    // RC1 == 0 is HINT
                    Rc1_sd = rvSext(Rc1_sd + Rc2_sd);
                }});
            }
        }
        format CompressedStore {
            0x5: c_fsdsp({{
                offset = CIMM6<5:3> << 3 |
                         CIMM6<2:0> << 6;
            }}, {{
                STATUS status = xc->readMiscReg(MISCREG_STATUS);
                if (status.fs == FPUStatus::OFF)
                    return std::make_shared<IllegalInstFault>("FPU is off",
                                                               machInst);

                Mem_ud = Fc2_bits;
            }}, {{
                EA = rvZext(sp + offset);
            }});
            0x6: c_swsp({{
                offset = CIMM6<5:2> << 2 |
                         CIMM6<1:0> << 6;
            }}, {{
                Mem_uw = Rc2_uw;
            }}, {{
                EA = rvZext(sp + offset);
            }});
            0x7: decode RVTYPE {
                0x0: c_fswsp({{
                    offset = CIMM6<5:2> << 2 |
                             CIMM6<1:0> << 6;
                }}, {{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>("FPU is off",
                                                                   machInst);

                    Mem_uw = unboxF32(boxF32(Fs2_bits));
                }}, {{
                    EA = (uint32_t)(sp_uw + offset);
                }});
                0x1: c_sdsp({{
                    offset = CIMM6<5:3> << 3 |
                             CIMM6<2:0> << 6;
                }}, {{
                    Mem = Rc2;
                }}, {{
                    EA = sp + offset;
                }});
            }
        }
    }
    0x3: decode OPCODE5 {
        0x00: decode FUNCT3 {
            format Load {
                0x0: lb({{
                    Rd_sd = Mem_sb;
                }});
                0x1: lh({{
                    Rd_sd = Mem_sh;
                }});
                0x2: lw({{
                    Rd_sd = Mem_sw;
                }});
                0x3: decode RVTYPE {
                    0x1: ld({{
                        Rd_sd = Mem_sd;
                    }});
                }
                0x4: lbu({{
                    Rd = Mem_ub;
                }});
                0x5: lhu({{
                    Rd = Mem_uh;
                }});
                0x6: decode RVTYPE {
                    0x1: lwu({{
                        Rd = Mem_uw;
                    }});
                }
            }
        }

        0x01: decode FUNCT3 {
            format Load {
                0x1: flh({{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>(
                                    "FPU is off", machInst);
                    freg_t fd;
                    fd = freg(f16(Mem_uh));
                    Fd_bits = fd.v;
                }}, inst_flags=FloatMemReadOp);
                0x2: flw({{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>(
                                    "FPU is off", machInst);
                    freg_t fd;
                    fd = freg(f32(Mem_uw));
                    Fd_bits = fd.v;
                }}, inst_flags=FloatMemReadOp);
                0x3: fld({{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>(
                                    "FPU is off", machInst);
                    freg_t fd;
                    fd = freg(f64(Mem));
                    Fd_bits = fd.v;
                }}, inst_flags=FloatMemReadOp);
            }
        }

        0x03: decode FUNCT3 {
            format FenceOp {
                0x0: fence({{
                }}, uint64_t, IsReadBarrier, IsWriteBarrier, No_OpClass);
                0x1: fence_i({{
                }}, uint64_t, IsNonSpeculative, IsSerializeAfter, No_OpClass);
            }
        }

        0x04: decode FUNCT3 {
            0x1: decode FS3 {
                format IOp {
                    0x00: slli({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        Rd = rvSext(Rs1 << imm);
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0x01: decode RVTYPE {
                        0x0: zip({{
                            Rd_sw = _rvk_emu_zip_32(Rs1_sw);
                        }}, imm_code = {{ imm = SHAMT5; }});
                    }
                    0x02: decode FS2 {
                        0x0: sha256sum0({{
                            Rd_sw = _rvk_emu_sha256sum0(Rs1_sw);
                        }});
                        0x1: sha256sum1({{
                            Rd_sw = _rvk_emu_sha256sum1(Rs1_sw);
                        }});
                        0x2: sha256sig0({{
                            Rd_sw = _rvk_emu_sha256sig0(Rs1_sw);
                        }});
                        0x3: sha256sig1({{
                            Rd_sw = _rvk_emu_sha256sig1(Rs1_sw);
                        }});
                        0x4: decode RVTYPE {
                            0x1: sha512sum0({{
                                Rd_sd = _rvk_emu_sha512sum0(Rs1_sd);
                            }});
                        }
                        0x5: decode RVTYPE {
                            0x1: sha512sum1({{
                                Rd_sd = _rvk_emu_sha512sum1(Rs1_sd);
                            }});
                        }
                        0x6: decode RVTYPE {
                            0x1: sha512sig0({{
                                Rd_sd = _rvk_emu_sha512sig0(Rs1_sd);
                            }});
                        }
                        0x7: decode RVTYPE {
                            0x1: sha512sig1({{
                                Rd_sd = _rvk_emu_sha512sig1(Rs1_sd);
                            }});
                        }
                        0x8: sm3p0({{
                            Rd_sw = _rvk_emu_sm3p0(Rs1_sw);
                        }});
                        0x9: sm3p1({{
                            Rd_sw = _rvk_emu_sm3p1(Rs1_sw);
                        }});
                    }
                    0x05: bseti({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        uint64_t index = imm & rvSelect(32 - 1, 64 - 1);
                        Rd = rvSext(Rs1 | (UINT64_C(1) << index));
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0x06: decode BIT24 {
                        0x0: decode RVTYPE {
                            0x1: aes64im({{
                                Rd_sd = _rvk_emu_aes64im(Rs1_sd);
                            }});
                        }
                        0x1: decode RVTYPE {
                            0x1: aes64ks1i({{
                                Rd_sd = _rvk_emu_aes64ks1i(Rs1_sd, imm);
                            }}, imm_type = int32_t, imm_code={{ imm = RNUM; }});
                        }
                    }
                    0x09: bclri({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        uint64_t index = imm & rvSelect(32 - 1, 64 - 1);
                        Rd = rvSext(Rs1 & (~(UINT64_C(1) << index)));
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0x0d: binvi({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        uint64_t index = imm & rvSelect(32 - 1, 64 - 1);
                        Rd = rvSext(Rs1 ^ (UINT64_C(1) << index));
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                }
                format ROp {
                    0x0c: decode RS2 {
                        0x00: clz({{
                            Rd = (machInst.rv_type == RV32) ? clz32(Rs1) : clz64(Rs1);
                        }});
                        0x01: ctz({{
                            Rd = (machInst.rv_type == RV32) ? ctz32(Rs1) : ctz64(Rs1);
                        }});
                        0x02: cpop({{
                            Rd = (machInst.rv_type == RV32) ? popCount(Rs1<31:0>) : popCount(Rs1);
                        }});
                        0x04: sext_b({{
                            Rd = sext<8>(Rs1_ub);
                        }});
                        0x05: sext_h({{
                            Rd = sext<16>(Rs1_uh);
                        }});
                    }
                }
            }

            format IOp {
                0x0: addi({{
                    Rd_sd = rvSext(Rs1_sd + imm);
                }});
                0x2: slti({{
                    Rd = (rvSext(Rs1_sd) < imm) ? 1 : 0;
                }});
                0x3: sltiu({{
                    Rd = (rvZext(Rs1) < imm) ? 1 : 0;
                }}, uint64_t, imm_code = {{ imm = rvZext(sext<12>(IMM12)); }});
                0x4: xori({{
                    Rd = rvSext(Rs1 ^ imm);
                }}, uint64_t);
                0x5: decode FS3 {
                    0x0: srli({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        Rd = rvSext(rvZext(Rs1) >> imm);
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0x1: decode RVTYPE {
                        0x0: unzip({{
                            Rd_sw = _rvk_emu_unzip_32(Rs1_sw);
                        }}, imm_code = {{ imm = SHAMT5; }});
                    }
                    0x5: orc_b({{
                        uint64_t result = 0;
                        result |= (Rs1<7:0> ? UINT64_C(0xff) : 0x0);
                        result |= (Rs1<15:8> ? UINT64_C(0xff) : 0x0) << 8;
                        result |= (Rs1<23:16> ? UINT64_C(0xff) : 0x0) << 16;
                        result |= (Rs1<31:24> ? UINT64_C(0xff) : 0x0) << 24;
                        result |= (Rs1<39:32> ? UINT64_C(0xff) : 0x0) << 32;
                        result |= (Rs1<47:40> ? UINT64_C(0xff) : 0x0) << 40;
                        result |= (Rs1<55:48> ? UINT64_C(0xff) : 0x0) << 48;
                        result |= (Rs1<63:56> ? UINT64_C(0xff) : 0x0) << 56;
                        Rd = rvSext(result);
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0x8: srai({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        Rd_sd = rvSext(Rs1_sd) >> imm;
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0x9: bexti({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        uint64_t index = imm & rvSelect(32 - 1, 64 - 1);
                        Rd = (Rs1 >> index) & 0x1;
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0xc: rori({{
                        if (rvSelect((bool)SHAMT6BIT5, false)) {
                            return std::make_shared<IllegalInstFault>(
                                    "shmat[5] != 0", machInst);
                        }
                        uint64_t xlen = rvSelect(32, 64);
                        Rd = rvSext((rvZext(Rs1) >> imm)
                            | (Rs1 << ((xlen - imm) & (xlen - 1))));
                    }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                    0xd: decode RS2 {
                        0x18: ROp::rev8({{
                            if (rvSelect((bool)SHAMT6BIT5, false)) {
                                return std::make_shared<IllegalInstFault>(
                                        "shmat[5] != 0", machInst);
                            }
                            if (machInst.rv_type == RV32) {
                                Rd_sd = _rvk_emu_grev_32(Rs1_sd, 0x18);
                            } else {
                                Rd_sd = _rvk_emu_grev_64(Rs1_sd, 0x38);
                            }
                        }});
                        0x07: ROp::brev8({{
                            if (machInst.rv_type == RV32) {
                                Rd_sd = _rvk_emu_brev8_32(Rs1_sd);
                            } else {
                                Rd_sd = _rvk_emu_brev8_64(Rs1_sd);
                            }
                        }});
                    }
                }
                0x6: ori({{
                    Rd = rvSext(Rs1 | imm);
                }}, uint64_t);
                0x7: andi({{
                    Rd = rvSext(Rs1 & imm);
                }}, uint64_t);
            }
        }

        0x05: UOp::auipc({{
            Rd = rvSext(PC + (sext<20>(imm) << 12));
        }});

        0x06: decode RVTYPE {
            0x1: decode FUNCT3 {
                format IOp {
                    0x0: addiw({{
                        Rd_sw = (int32_t)(Rs1_sw + imm);
                    }}, int32_t);
                    0x1: decode FS3 {
                        0x0: slliw({{
                            Rd_sd = Rs1_sw << imm;
                        }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT5; }});
                        0x1: slli_uw({{
                            Rd = ((uint64_t)(Rs1_uw)) << imm;
                        }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT6; }});
                        0xc: decode FS2 {
                            0x0: clzw({{
                                Rd = clz32(Rs1);
                            }});
                            0x1: ctzw({{
                                Rd = ctz32(Rs1);
                            }});
                            0x2: cpopw({{
                                Rd = popCount(Rs1<31:0>);
                            }});
                        }
                    }
                    0x5: decode FS3 {
                        0x0: srliw({{
                            Rd_sd = (int32_t)(Rs1_uw >> imm);
                        }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT5; }});
                        0x8: sraiw({{
                            Rd_sd = Rs1_sw >> imm;
                        }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT5; }});
                        0xc: roriw({{
                            Rd = (int32_t) ((Rs1_uw >> imm) | (Rs1_uw << ((32 - imm) & (32 - 1))));
                        }}, imm_type = uint64_t, imm_code = {{ imm = SHAMT5; }});
                    }
                }
            }
        }

        0x08: decode FUNCT3 {
            format Store {
                0x0: sb({{
                    Mem_ub = Rs2_ub;
                }});
                0x1: sh({{
                    Mem_uh = Rs2_uh;
                }});
                0x2: sw({{
                    Mem_uw = Rs2_uw;
                }});
                0x3: decode RVTYPE {
                    0x1: sd({{
                        Mem_ud = Rs2_ud;
                    }});
                }
            }
        }

        0x09: decode FUNCT3 {
            format Store {
                0x1: fsh({{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>(
                                "FPU is off", machInst);

                    Mem_uh = unboxF16(boxF16(Fs2_bits));
                }}, inst_flags=FloatMemWriteOp);
                0x2: fsw({{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>(
                                "FPU is off", machInst);

                    Mem_uw = unboxF32(boxF32(Fs2_bits));
                }}, inst_flags=FloatMemWriteOp);
                0x3: fsd({{
                    STATUS status = xc->readMiscReg(MISCREG_STATUS);
                    if (status.fs == FPUStatus::OFF)
                        return std::make_shared<IllegalInstFault>(
                                "FPU is off", machInst);

                    Mem_ud = Fs2_bits;
                }}, inst_flags=FloatMemWriteOp);
            }
        }

        0x0b: decode FUNCT3 {
            0x2: decode AMOFUNCT {
                0x2: LoadReserved::lr_w({{
                    Rd_sd = Mem_sw;
                }}, mem_flags=LLSC);
                0x3: StoreCond::sc_w({{
                    Mem_uw = Rs2_uw;
                }}, {{
                    Rd = rvSext(result);
                }}, inst_flags=IsStoreConditional, mem_flags=LLSC);
                0x0: AtomicMemOp::amoadd_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<int32_t> *amo_op =
                          new AtomicGenericOp<int32_t>(Rs2_sw,
                                  [](int32_t* b, int32_t a){ *b += a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x1: AtomicMemOp::amoswap_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<uint32_t> *amo_op =
                          new AtomicGenericOp<uint32_t>(Rs2_uw,
                                  [](uint32_t* b, uint32_t a){ *b = a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x4: AtomicMemOp::amoxor_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<uint32_t> *amo_op =
                          new AtomicGenericOp<uint32_t>(Rs2_uw,
                                  [](uint32_t* b, uint32_t a){ *b ^= a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x8: AtomicMemOp::amoor_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<uint32_t> *amo_op =
                          new AtomicGenericOp<uint32_t>(Rs2_uw,
                                  [](uint32_t* b, uint32_t a){ *b |= a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0xc: AtomicMemOp::amoand_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<uint32_t> *amo_op =
                          new AtomicGenericOp<uint32_t>(Rs2_uw,
                                  [](uint32_t* b, uint32_t a){ *b &= a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x10: AtomicMemOp::amomin_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<int32_t> *amo_op =
                      new AtomicGenericOp<int32_t>(Rs2_sw,
                        [](int32_t* b, int32_t a){ if (a < *b) *b = a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x14: AtomicMemOp::amomax_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<int32_t> *amo_op =
                      new AtomicGenericOp<int32_t>(Rs2_sw,
                        [](int32_t* b, int32_t a){ if (a > *b) *b = a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x18: AtomicMemOp::amominu_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<uint32_t> *amo_op =
                      new AtomicGenericOp<uint32_t>(Rs2_uw,
                        [](uint32_t* b, uint32_t a){ if (a < *b) *b = a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
                0x1c: AtomicMemOp::amomaxu_w({{
                    Rd_sd = Mem_sw;
                }}, {{
                    TypedAtomicOpFunctor<uint32_t> *amo_op =
                      new AtomicGenericOp<uint32_t>(Rs2_uw,
                        [](uint32_t* b, uint32_t a){ if (a > *b) *b = a; });
                }}, mem_flags=ATOMIC_RETURN_OP);
            }
            0x3: decode RVTYPE {
                0x1: decode AMOFUNCT {
                    0x2: LoadReserved::lr_d({{
                        Rd_sd = Mem_sd;
                    }}, mem_flags=LLSC);
                    0x3: StoreCond::sc_d({{
                        Mem = Rs2;
                    }}, {{
                        Rd = result;
                    }}, mem_flags=LLSC, inst_flags=IsStoreConditional);
                    0x0: AtomicMemOp::amoadd_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<int64_t> *amo_op =
                              new AtomicGenericOp<int64_t>(Rs2_sd,
                                      [](int64_t* b, int64_t a){ *b += a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x1: AtomicMemOp::amoswap_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<uint64_t> *amo_op =
                              new AtomicGenericOp<uint64_t>(Rs2_ud,
                                      [](uint64_t* b, uint64_t a){ *b = a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x4: AtomicMemOp::amoxor_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<uint64_t> *amo_op =
                              new AtomicGenericOp<uint64_t>(Rs2_ud,
                                     [](uint64_t* b, uint64_t a){ *b ^= a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x8: AtomicMemOp::amoor_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<uint64_t> *amo_op =
                              new AtomicGenericOp<uint64_t>(Rs2_ud,
                                     [](uint64_t* b, uint64_t a){ *b |= a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0xc: AtomicMemOp::amoand_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<uint64_t> *amo_op =
                              new AtomicGenericOp<uint64_t>(Rs2_ud,
                                     [](uint64_t* b, uint64_t a){ *b &= a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x10: AtomicMemOp::amomin_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<int64_t> *amo_op =
                          new AtomicGenericOp<int64_t>(Rs2_sd,
                            [](int64_t* b, int64_t a){ if (a < *b) *b = a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x14: AtomicMemOp::amomax_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<int64_t> *amo_op =
                          new AtomicGenericOp<int64_t>(Rs2_sd,
                            [](int64_t* b, int64_t a){ if (a > *b) *b = a; });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x18: AtomicMemOp::amominu_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<uint64_t> *amo_op =
                          new AtomicGenericOp<uint64_t>(Rs2_ud,
                            [](uint64_t* b, uint64_t a){
                              if (a < *b) *b = a;
                            });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                    0x1c: AtomicMemOp::amomaxu_d({{
                        Rd_sd = Mem_sd;
                    }}, {{
                        TypedAtomicOpFunctor<uint64_t> *amo_op =
                          new AtomicGenericOp<uint64_t>(Rs2_ud,
                            [](uint64_t* b, uint64_t a){
                              if (a > *b) *b = a;
                            });
                    }}, mem_flags=ATOMIC_RETURN_OP);
                }
            }
        }
        0x0c: decode FUNCT3 {
            format ROp {
                0x0: decode KFUNCT5 {
                    0x00: decode BS {
                        0x0: add({{
                            Rd = rvSext(Rs1_sd + Rs2_sd);
                        }});
                        0x1: sub({{
                            Rd = rvSext(Rs1_sd - Rs2_sd);
                        }});
                    }
                    0x01: decode BS {
                        0x0: mul({{
                            Rd = rvSext(Rs1_sd * Rs2_sd);
                        }}, IntMultOp);
                    }
                    0x08: decode BS {
                        0x1: decode RVTYPE {
                            0x0: sha512sum0r({{
                                Rd_sw = _rvk_emu_sha512sum0r(Rs1_sw, Rs2_sw);
                            }});
                        }
                    }
                    0x09: decode BS {
                        0x1: decode RVTYPE {
                            0x0: sha512sum1r({{
                                Rd_sw = _rvk_emu_sha512sum1r(Rs1_sw, Rs2_sw);
                            }});
                        }
                    }
                    0x0a: decode BS {
                        0x1: decode RVTYPE {
                            0x0: sha512sig0l({{
                                Rd_sw = _rvk_emu_sha512sig0l(Rs1_sw, Rs2_sw);
                            }});
                        }
                    }
                    0x0b: decode BS {
                        0x1: decode RVTYPE {
                            0x0: sha512sig1l({{
                                Rd_sw = _rvk_emu_sha512sig1l(Rs1_sw, Rs2_sw);
                            }});
                        }
                    }
                    0x0e: decode BS {
                        0x1: decode RVTYPE {
                            0x0: sha512sig0h({{
                                Rd_sw = _rvk_emu_sha512sig0h(Rs1_sw, Rs2_sw);
                            }});
                        }
                    }
                    0x0f: decode BS {
                        0x1: decode RVTYPE {
                            0x0: sha512sig1h({{
                                Rd_sw = _rvk_emu_sha512sig1h(Rs1_sw, Rs2_sw);
                            }});
                        }
                    }
                    0x11: decode RVTYPE {
                        0x0: BSOp::aes32esi({{
                            Rd_sw = _rvk_emu_aes32esi(Rs1_sw, Rs2_sw, bs);
                        }});
                    }
                    0x13: decode RVTYPE {
                        0x0: BSOp::aes32esmi({{
                            Rd_sw = _rvk_emu_aes32esmi(Rs1_sw, Rs2_sw, bs);
                        }});
                    }
                    0x15: decode RVTYPE {
                        0x0: BSOp::aes32dsi({{
                            Rd_sw = _rvk_emu_aes32dsi(Rs1_sw, Rs2_sw, bs);
                        }});
                    }
                    0x17: decode RVTYPE {
                        0x0: BSOp::aes32dsmi({{
                            Rd_sw = _rvk_emu_aes32dsmi(Rs1_sw, Rs2_sw, bs);
                        }});
                    }
                    0x18: BSOp::sm4ed({{
                        Rd_sw = _rvk_emu_sm4ed(Rs1_sw, Rs2_sw, bs);
                    }});
                    0x19: decode BS {
                        0x0: decode RVTYPE {
                            0x1: aes64es({{
                                Rd_sd = _rvk_emu_aes64es(Rs1_sd, Rs2_sd);
                            }});
                        }
                    }
                    0x1a: BSOp::sm4ks({{
                        Rd_sw = _rvk_emu_sm4ks(Rs1_sw, Rs2_sw, bs);
                    }});
                    0x1b: decode BS {
                        0x0: decode RVTYPE {
                            0x1: aes64esm({{
                                Rd_sd = _rvk_emu_aes64esm(Rs1_sd, Rs2_sd);
                            }});
                        }
                    }
                    0x1d: decode BS {
                        0x0: decode RVTYPE {
                            0x1: aes64ds({{
                                Rd_sd = _rvk_emu_aes64ds(Rs1_sd, Rs2_sd);
                            }});
                        }
                    }
                    0x1f: decode BS {
                        0x0: decode RVTYPE {
                            0x1: aes64dsm({{
                                Rd_sd = _rvk_emu_aes64dsm(Rs1_sd, Rs2_sd);
                            }});
                        }
                        0x1: decode RVTYPE {
                            0x1: aes64ks2({{
                                Rd_sd = _rvk_emu_aes64ks2(Rs1_sd, Rs2_sd);
                            }});
                        }
                    }
                }
                0x1: decode FUNCT7 {
                    0x0: sll({{
                        Rd = rvSext(Rs1 << rvSelect(Rs2<4:0>, Rs2<5:0>));
                    }});
                    0x1: mulh({{
                        if (machInst.rv_type == RV32) {
                            Rd_sd = mulh_32(Rs1_sd, Rs2_sd);
                        } else {
                            Rd_sd = mulh_64(Rs1_sd, Rs2_sd);
                        }
                    }}, IntMultOp);
                    0x5: clmul({{
                        uint64_t result = 0;
                        for (int i = 0; i < rvSelect(32, 64); i++) {
                            if ((Rs2 >> i) & 1) {
                                result ^= Rs1 << i;
                            }
                        }
                        Rd = rvSext(result);
                    }});
                    0x14: bset({{
                        Rs2 &= rvSelect(32 - 1, 64 - 1);
                        Rd = rvSext(Rs1 | (UINT64_C(1) << Rs2));
                    }});
                    0x24: bclr({{
                        Rs2 &= rvSelect(32 - 1, 64 - 1);
                        Rd = rvSext(Rs1 & (~(UINT64_C(1) << Rs2)));
                    }});
                    0x30: rol({{
                        uint64_t xlen = rvSelect(32, 64);
                        int shamt = Rs2 & (xlen - 1);
                        Rd = rvSext((Rs1 << shamt)
                            | (rvZext(Rs1) >> ((xlen - shamt) & (xlen - 1))));
                    }});
                    0x34: binv({{
                        Rs2 &= rvSelect(32 - 1, 64 - 1);
                        Rd = rvSext(Rs1 ^ (UINT64_C(1) << Rs2));
                    }});
                }
                0x2: decode FUNCT7 {
                    0x0: slt({{
                        Rd = (rvSext(Rs1_sd) < rvSext(Rs2_sd)) ? 1 : 0;
                    }});
                    0x1: mulhsu({{
                        if (machInst.rv_type == RV32) {
                            Rd_sd = mulhsu_32(Rs1_sd, Rs2);
                        } else {
                            Rd_sd = mulhsu_64(Rs1_sd, Rs2);
                        }
                    }}, IntMultOp);
                    0x5: clmulr({{
                        uint64_t result = 0;
                        uint64_t xlen = rvSelect(32, 64);
                        uint64_t zextRs1 = rvZext(Rs1);
                        for (int i = 0; i < xlen; i++) {
                            if ((Rs2 >> i) & 1) {
                                result ^= zextRs1 >> (xlen-i-1);
                            }
                        }
                        Rd = rvSext(result);
                    }});
                    0x10: sh1add({{
                        Rd = rvSext((Rs1 << 1) + Rs2);
                    }});
                    0x14: xperm4({{
                        if (machInst.rv_type == RV32) {
                            Rd_sd = _rvk_emu_xperm4_32(Rs1_sd, Rs2_sd);
                        } else {
                            Rd_sd = _rvk_emu_xperm4_64(Rs1_sd, Rs2_sd);
                        }
                    }});
                }
                0x3: decode FUNCT7 {
                    0x0: sltu({{
                        Rd = (rvZext(Rs1) < rvZext(Rs2)) ? 1 : 0;
                    }});
                    0x1: mulhu({{
                        if (machInst.rv_type == RV32) {
                            Rd = (int32_t)mulhu_32(Rs1, Rs2);
                        } else {
                            Rd = mulhu_64(Rs1, Rs2);
                        }
                    }}, IntMultOp);
                    0x5: clmulh({{
                        uint64_t result = 0;
                        uint64_t xlen = rvSelect(32, 64);
                        uint64_t zextRs1 = rvZext(Rs1);
                        for (int i = 1; i < xlen; i++) {
                            if ((Rs2 >> i) & 1) {
                                result ^= zextRs1 >> (xlen-i);
                            }
                        }
                        // The MSB can never be 1, no need to sign extend.
                        Rd = result;
                    }});
                }
                0x4: decode FUNCT7 {
                    0x0: xor({{
                        Rd = rvSext(Rs1 ^ Rs2);
                    }});
                    0x1: div({{
                        if (machInst.rv_type == RV32) {
                            Rd_sd = div<int32_t>(Rs1, Rs2);
                        } else {
                            Rd_sd = div<int64_t>(Rs1, Rs2);
                        }
                    }}, IntDivOp);
                    0x4: pack({{
                        int xlen = rvSelect(32, 64);
                        Rd = rvSext(
                            (bits(Rs2, xlen/2-1, 0) << (xlen / 2)) | \
                            bits(Rs1, xlen/2-1, 0)
                        );
                    }});
                    0x5: min({{
                        Rd_sd = std::min(rvSext(Rs1_sd), rvSext(Rs2_sd));
                    }});
                    0x10: sh2add({{
                        Rd = rvSext((Rs1 << 2) + Rs2);
                    }});
                    0x14: xperm8({{
                        if (machInst.rv_type == RV32) {
                            Rd_sd = _rvk_emu_xperm8_32(Rs1_sd, Rs2_sd);
                        } else {
                            Rd_sd = _rvk_emu_xperm8_64(Rs1_sd, Rs2_sd);
                        }
                    }});
                    0x20: xnor({{
                        Rd = rvSext(~(Rs1 ^ Rs2));
                    }});
                }
                0x5: decode FUNCT7 {
                    0x0: srl({{
                        Rd = rvSext(rvZext(Rs1) >>
                                    rvSelect(Rs2<4:0>, Rs2<5:0>));
                    }});
                    0x1: divu({{
                        if (machInst.rv_type == RV32) {
                            Rd = (int32_t)divu<uint32_t>(Rs1, Rs2);
                        } else {
                            Rd = divu<uint64_t>(Rs1, Rs2);
                        }
                    }}, IntDivOp);
                    0x20: sra({{
                        Rd = rvSext(Rs1_sd) >> rvSelect(Rs2<4:0>, Rs2<5:0>);
                    }});
                    0x5: minu({{
                        Rd = rvSext(std::min(rvZext(Rs1), rvZext(Rs2)));
                    }});
                    0x24: bext({{
                        Rs2 &= (rvSelect(32, 64) - 1);
                        // It doesn't need to sign ext because MSB is always 0
                        Rd = (Rs1 >> Rs2) & 0x1;
                    }});
                    0x30: ror({{
                        uint64_t xlen = rvSelect(32, 64);
                        int shamt = Rs2 & (xlen - 1);
                        Rd = rvSext((rvZext(Rs1) >> shamt)
                            | (Rs1 << ((xlen - shamt) & (xlen - 1))));
                    }});
                }
                0x6: decode FUNCT7 {
                    0x0: or({{
                        Rd = rvSext(Rs1 | Rs2);
                    }});
                    0x1: rem({{
                        if (machInst.rv_type == RV32) {
                            Rd_sd = rem<int32_t>(Rs1, Rs2);
                        } else {
                            Rd_sd = rem<int64_t>(Rs1, Rs2);
                        }
                    }}, IntDivOp);
                    0x5: max({{
                        Rd_sd = std::max(rvSext(Rs1_sd), rvSext(Rs2_sd));
                    }});
                    0x10: sh3add({{
                        Rd = rvSext((Rs1 << 3) + Rs2);
                    }});
                    0x20: orn({{
                        Rd = rvSext(Rs1 | (~Rs2));
                    }});
                }
                0x7: decode FUNCT7 {
                    0x0: and({{
                        Rd = rvSext(Rs1 & Rs2);
                    }});
                    0x1: remu({{
                        if (machInst.rv_type == RV32) {
                            Rd = (int32_t)remu<uint32_t>(Rs1, Rs2);
                        } else {
                            Rd = remu<uint64_t>(Rs1, Rs2);
                        }
                    }}, IntDivOp);
                    0x4: packh({{
                        // It doesn't need to sign ext as MSB is always 0
                        Rd = (Rs2_ub << 8) | Rs1_ub;
                    }});
                    0x5: maxu({{
                        Rd = rvSext(std::max(rvZext(Rs1), rvZext(Rs2)));
                    }});
                    0x20: andn({{
                        Rd = rvSext(Rs1 & (~Rs2));
                    }});
                }
            }
        }

        0x0d: UOp::lui({{
            Rd = (sext<20>(imm) << 12);
        }});

        0x0e: decode RVTYPE {
            0x1: decode FUNCT3 {
                format ROp {
                    0x0: decode FUNCT7 {
                        0x0: addw({{
                            Rd_sd = Rs1_sw + Rs2_sw;
                        }});
                        0x1: mulw({{
                            Rd_sd = (int32_t)(Rs1_sw*Rs2_sw);
                        }}, IntMultOp);
                        0x4: add_uw({{
                            Rd = Rs1_uw + Rs2;
                        }});
                        0x20: subw({{
                            Rd_sd = Rs1_sw - Rs2_sw;
                        }});
                    }
                    0x1: decode FUNCT7 {
                        0x0: sllw({{
                            Rd_sd = Rs1_sw << Rs2<4:0>;
                        }});
                        0x30: rolw({{
                            int shamt = Rs2 & (32 - 1);
                            Rd = (int32_t) ((Rs1_uw << shamt) | (Rs1_uw >> ((32 - shamt) & (32 - 1))));
                        }});
                    }
                    0x2: decode FUNCT7 {
                        0x10: sh1add_uw({{
                            Rd = (((uint64_t)Rs1_uw) << 1) + Rs2;
                        }});
                    }
                    0x4: decode FUNCT7 {
                        0x1: divw({{
                            Rd_sd = div<int32_t>(Rs1, Rs2);
                        }}, IntDivOp);
                        0x4: packw({{
                            Rd_sd = sext<32>((Rs2_uh << 16) | Rs1_uh);
                        }});
                        0x10: sh2add_uw({{
                            Rd = (((uint64_t)Rs1_uw) << 2) + Rs2;
                        }});
                    }
                    0x5: decode FUNCT7 {
                        0x0: srlw({{
                            Rd_sd = (int32_t)(Rs1_uw >> Rs2<4:0>);
                        }});
                        0x1: divuw({{
                            Rd = sext<32>(divu<uint32_t>(Rs1, Rs2));
                        }}, IntDivOp);
                        0x20: sraw({{
                            Rd_sd = Rs1_sw >> Rs2<4:0>;
                        }});
                        0x30: rorw({{
                            int shamt = Rs2 & (32 - 1);
                            Rd = (int32_t) ((Rs1_uw >> shamt) | (Rs1_uw << ((32 - shamt) & (32 - 1))));
                        }});
                    }
                    0x6:  decode FUNCT7 {
                        0x1: remw({{
                            Rd_sd = rem<int32_t>(Rs1, Rs2);
                        }}, IntDivOp);
                        0x10: sh3add_uw({{
                            Rd = (((uint64_t)Rs1_uw) << 3) + Rs2;
                        }});
                    }
                    0x7: remuw({{
                        Rd = sext<32>(remu<uint32_t>(Rs1, Rs2));
                    }}, IntDivOp);
                }
            }
        }

        format FPROp {
            0x10: decode FUNCT2 {
                0x0: fmadd_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_mulAdd(f32(freg(Fs1_bits)),
                                         f32(freg(Fs2_bits)),
                                         f32(freg(Fs3_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x1: fmadd_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_mulAdd(f64(freg(Fs1_bits)),
                                         f64(freg(Fs2_bits)),
                                         f64(freg(Fs3_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x2: fmadd_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_mulAdd(f16(freg(Fs1_bits)),
                                         f16(freg(Fs2_bits)),
                                         f16(freg(Fs3_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
            }
            0x11: decode FUNCT2 {
                0x0: fmsub_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_mulAdd(f32(freg(Fs1_bits)),
                                    f32(freg(Fs2_bits)),
                                    f32(f32(freg(Fs3_bits)).v ^
                                        mask(31, 31))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x1: fmsub_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_mulAdd(f64(freg(Fs1_bits)),
                                    f64(freg(Fs2_bits)),
                                    f64(f64(freg(Fs3_bits)).v ^
                                        mask(63, 63))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x2: fmsub_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_mulAdd(f16(freg(Fs1_bits)),
                                    f16(freg(Fs2_bits)),
                                    f16(f16(freg(Fs3_bits)).v ^
                                        mask(15, 15))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
            }
            0x12: decode FUNCT2 {
                0x0: fnmsub_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_mulAdd(f32(f32(freg(Fs1_bits)).v ^
                                             mask(31, 31)),
                                         f32(freg(Fs2_bits)),
                                         f32(freg(Fs3_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x1: fnmsub_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_mulAdd(f64(f64(freg(Fs1_bits)).v ^
                                             mask(63, 63)),
                                         f64(freg(Fs2_bits)),
                                         f64(freg(Fs3_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x2: fnmsub_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_mulAdd(f16(f16(freg(Fs1_bits)).v ^
                                             mask(15, 15)),
                                         f16(freg(Fs2_bits)),
                                         f16(freg(Fs3_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
            }
            0x13: decode FUNCT2 {
                0x0: fnmadd_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_mulAdd(f32(f32(freg(Fs1_bits)).v ^
                                             mask(31, 31)),
                                    f32(freg(Fs2_bits)),
                                    f32(f32(freg(Fs3_bits)).v ^
                                        mask(31, 31))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x1: fnmadd_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_mulAdd(f64(f64(freg(Fs1_bits)).v ^
                                             mask(63, 63)),
                                    f64(freg(Fs2_bits)),
                                    f64(f64(freg(Fs3_bits)).v ^
                                        mask(63, 63))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
                0x2: fnmadd_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_mulAdd(f16(f16(freg(Fs1_bits)).v ^
                                             mask(15, 15)),
                                    f16(freg(Fs2_bits)),
                                    f16(f16(freg(Fs3_bits)).v ^
                                        mask(15, 15))));
                    Fd_bits = fd.v;
                }}, FloatMultAccOp);
            }
            0x14: decode FUNCT7 {
                0x0: fadd_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_add(f32(freg(Fs1_bits)),
                                      f32(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatAddOp);
                0x1: fadd_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_add(f64(freg(Fs1_bits)),
                                      f64(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatAddOp);
                0x2: fadd_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_add(f16(freg(Fs1_bits)),
                                      f16(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatAddOp);
                0x4: fsub_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_sub(f32(freg(Fs1_bits)),
                                      f32(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatAddOp);
                0x5: fsub_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_sub(f64(freg(Fs1_bits)),
                                      f64(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatAddOp);
                0x6: fsub_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_sub(f16(freg(Fs1_bits)),
                                      f16(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatAddOp);
                0x8: fmul_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_mul(f32(freg(Fs1_bits)),
                                      f32(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultOp);
                0x9: fmul_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_mul(f64(freg(Fs1_bits)),
                                      f64(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultOp);
                0xa: fmul_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_mul(f16(freg(Fs1_bits)),
                                      f16(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatMultOp);
                0xc: fdiv_s({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f32_div(f32(freg(Fs1_bits)),
                                      f32(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatDivOp);
                0xd: fdiv_d({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f64_div(f64(freg(Fs1_bits)),
                                      f64(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatDivOp);
                0xe: fdiv_h({{
                    RM_REQUIRED;
                    freg_t fd;
                    fd = freg(f16_div(f16(freg(Fs1_bits)),
                                      f16(freg(Fs2_bits))));
                    Fd_bits = fd.v;
                }}, FloatDivOp);
                0x10: decode ROUND_MODE {
                    0x0: fsgnj_s({{
                        auto sign = bits(unboxF32(Fs2_bits), 31);
                        Fd_bits = boxF32(insertBits(unboxF32(Fs1_bits), 31,
                                                    sign));
                        }}, FloatMiscOp);
                    0x1: fsgnjn_s({{
                        auto sign = ~bits(unboxF32(Fs2_bits), 31);
                        Fd_bits = boxF32(insertBits(unboxF32(Fs1_bits), 31,
                                                    sign));
                        }}, FloatMiscOp);
                    0x2: fsgnjx_s({{
                        auto sign = bits(
                            unboxF32(Fs1_bits) ^ unboxF32(Fs2_bits), 31);
                        Fd_bits = boxF32(insertBits(unboxF32(Fs1_bits), 31,
                                                    sign));
                        }}, FloatMiscOp);
                }
                0x11: decode ROUND_MODE {
                    0x0: fsgnj_d({{
                        Fd_bits = insertBits(Fs2_bits, 62, 0, Fs1_bits);
                    }}, FloatMiscOp);
                    0x1: fsgnjn_d({{
                        Fd_bits = insertBits(~Fs2_bits, 62, 0, Fs1_bits);
                    }}, FloatMiscOp);
                    0x2: fsgnjx_d({{
                        Fd_bits = insertBits(
                                Fs1_bits ^ Fs2_bits, 62, 0, Fs1_bits);
                    }}, FloatMiscOp);
                }
                0x12: decode ROUND_MODE {
                    0x0: fsgnj_h({{
                        auto sign = bits(unboxF16(Fs2_bits), 15);
                        Fd_bits = boxF16(insertBits(unboxF16(Fs1_bits), 15,
                                                    sign));
                        }}, FloatMiscOp);
                    0x1: fsgnjn_h({{
                        auto sign = ~bits(unboxF16(Fs2_bits), 15);
                        Fd_bits = boxF16(insertBits(unboxF16(Fs1_bits), 15,
                                                    sign));
                        }}, FloatMiscOp);
                    0x2: fsgnjx_h({{
                        auto sign = bits(
                            unboxF16(Fs1_bits) ^ unboxF16(Fs2_bits), 15);
                        Fd_bits = boxF16(insertBits(unboxF16(Fs1_bits), 15,
                                                    sign));
                        }}, FloatMiscOp);
                }
                0x14: decode ROUND_MODE {
                    0x0: fmin_s({{
                        float32_t fs1 = f32(freg(Fs1_bits));
                        float32_t fs2 = f32(freg(Fs2_bits));
                        float32_t fd;
                        bool less = f32_lt_quiet(fs1, fs2) ||
                            (f32_eq(fs1, fs2) && bits(fs1.v, 31));

                        fd = less || isNaNF32UI(fs2.v) ? fs1 : fs2;
                        if (isNaNF32UI(fs1.v) && isNaNF32UI(fs2.v))
                            fd = f32(defaultNaNF32UI);
                        Fd_bits = freg(fd).v;
                        }}, FloatCmpOp);
                    0x1: fmax_s({{
                        float32_t fs1 = f32(freg(Fs1_bits));
                        float32_t fs2 = f32(freg(Fs2_bits));
                        float32_t fd;
                        bool greater = f32_lt_quiet(fs2, fs1) ||
                            (f32_eq(fs2, fs1) && bits(fs2.v, 31));

                        fd = greater || isNaNF32UI(fs2.v) ? fs1: fs2;
                        if (isNaNF32UI(fs1.v) && isNaNF32UI(fs2.v))
                            fd = f32(defaultNaNF32UI);
                        Fd_bits = freg(fd).v;
                        }}, FloatCmpOp);
                }
                0x15: decode ROUND_MODE {
                    0x0: fmin_d({{
                        float64_t fs1 = f64(freg(Fs1_bits));
                        float64_t fs2 = f64(freg(Fs2_bits));
                        float64_t fd;
                        bool less = f64_lt_quiet(fs1, fs2) ||
                            (f64_eq(fs1, fs2) && bits(fs1.v, 63));

                        fd = less || isNaNF64UI(fs2.v) ? fs1 : fs2;
                        if (isNaNF64UI(fs1.v) && isNaNF64UI(fs2.v))
                            fd = f64(defaultNaNF64UI);
                        Fd_bits = freg(fd).v;
                    }}, FloatCmpOp);
                    0x1: fmax_d({{
                        float64_t fs1 = f64(freg(Fs1_bits));
                        float64_t fs2 = f64(freg(Fs2_bits));
                        float64_t fd;
                        bool greater = f64_lt_quiet(fs2, fs1) ||
                            (f64_eq(fs2, fs1) && bits(fs2.v, 63));

                        fd = greater || isNaNF64UI(fs2.v) ? fs1 : fs2;
                        if (isNaNF64UI(fs1.v) && isNaNF64UI(fs2.v))
                            fd = f64(defaultNaNF64UI);
                        Fd_bits = freg(fd).v;
                    }}, FloatCmpOp);
                }
                0x16: decode ROUND_MODE {
                    0x0: fmin_h({{
                        float16_t fs1 = f16(freg(Fs1_bits));
                        float16_t fs2 = f16(freg(Fs2_bits));
                        float16_t fd;
                        bool less = f16_lt_quiet(fs1, fs2) ||
                            (f16_eq(fs1, fs2) && bits(fs1.v, 15));

                        fd = less || isNaNF16UI(fs2.v) ? fs1 : fs2;
                        if (isNaNF16UI(fs1.v) && isNaNF16UI(fs2.v))
                            fd = f16(defaultNaNF16UI);
                        Fd_bits = freg(fd).v;
                        }}, FloatCmpOp);
                    0x1: fmax_h({{
                        float16_t fs1 = f16(freg(Fs1_bits));
                        float16_t fs2 = f16(freg(Fs2_bits));
                        float16_t fd;
                        bool greater = f16_lt_quiet(fs2, fs1) ||
                            (f16_eq(fs2, fs1) && bits(fs2.v, 15));

                        fd = greater || isNaNF16UI(fs2.v) ? fs1 : fs2;
                        if (isNaNF16UI(fs1.v) && isNaNF16UI(fs2.v))
                            fd = f16(defaultNaNF16UI);
                        Fd_bits = freg(fd).v;
                        }}, FloatCmpOp);
                }
                0x20: decode CONV_SGN {
                    0x1: fcvt_s_d({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(f64_to_f32(f64(freg(Fs1_bits))));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                    0x2: fcvt_s_h({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(f16_to_f32(f16(freg(Fs1_bits))));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                }
                0x21: decode CONV_SGN {
                    0x0: fcvt_d_s({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(f32_to_f64(f32(freg(Fs1_bits))));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                    0x2: fcvt_d_h({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(f16_to_f64(f16(freg(Fs1_bits))));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                }
                0x22: decode CONV_SGN {
                    0x0: fcvt_h_s({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(f32_to_f16(f32(freg(Fs1_bits))));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                    0x1: fcvt_h_d({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(f64_to_f16(f64(freg(Fs1_bits))));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                }
                0x2c: fsqrt_s({{
                    if (RS2 != 0) {
                        return std::make_shared<IllegalInstFault>(
                                "source reg x1", machInst);
                    }
                    freg_t fd;
                    RM_REQUIRED;
                    fd = freg(f32_sqrt(f32(freg(Fs1_bits))));
                    Fd_bits = fd.v;
                }}, FloatSqrtOp);
                0x2d: fsqrt_d({{
                    if (RS2 != 0) {
                        return std::make_shared<IllegalInstFault>(
                                "source reg x1", machInst);
                    }
                    freg_t fd;
                    RM_REQUIRED;
                    fd = freg(f64_sqrt(f64(freg(Fs1_bits))));
                    Fd_bits = fd.v;
                }}, FloatSqrtOp);
                0x2e: fsqrt_h({{
                    if (RS2 != 0) {
                        return std::make_shared<IllegalInstFault>(
                                "source reg x1", machInst);
                    }
                    freg_t fd;
                    RM_REQUIRED;
                    fd = freg(f16_sqrt(f16(freg(Fs1_bits))));
                    Fd_bits = fd.v;
                }}, FloatSqrtOp);
                0x50: decode ROUND_MODE {
                    0x0: fle_s({{
                        Rd = f32_le(f32(freg(Fs1_bits)), f32(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                    0x1: flt_s({{
                        Rd = f32_lt(f32(freg(Fs1_bits)), f32(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                    0x2: feq_s({{
                        Rd = f32_eq(f32(freg(Fs1_bits)), f32(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                }
                0x51: decode ROUND_MODE {
                    0x0: fle_d({{
                        Rd = f64_le(f64(freg(Fs1_bits)), f64(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                    0x1: flt_d({{
                        Rd = f64_lt(f64(freg(Fs1_bits)), f64(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                    0x2: feq_d({{
                        Rd = f64_eq(f64(freg(Fs1_bits)), f64(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                }
                0x52: decode ROUND_MODE {
                    0x0: fle_h({{
                        Rd = f16_le(f16(freg(Fs1_bits)), f16(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                    0x1: flt_h({{
                        Rd = f16_lt(f16(freg(Fs1_bits)), f16(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                    0x2: feq_h({{
                        Rd = f16_eq(f16(freg(Fs1_bits)), f16(freg(Fs2_bits)));
                    }}, FloatCmpOp);
                }
                0x60: decode CONV_SGN {
                    0x0: fcvt_w_s({{
                        RM_REQUIRED;
                        Rd_sd = sext<32>(f32_to_i32(f32(freg(Fs1_bits)), rm,
                                                    true));
                    }}, FloatCvtOp);
                    0x1: fcvt_wu_s({{
                        RM_REQUIRED;
                        Rd = sext<32>(f32_to_ui32(f32(freg(Fs1_bits)), rm,
                                                  true));
                    }}, FloatCvtOp);
                    0x2: decode RVTYPE {
                        0x1: fcvt_l_s({{
                            RM_REQUIRED;
                            Rd_sd = f32_to_i64(f32(freg(Fs1_bits)), rm, true);
                        }}, FloatCvtOp);
                    }
                    0x3: decode RVTYPE {
                        0x1: fcvt_lu_s({{
                            RM_REQUIRED;
                            Rd = f32_to_ui64(f32(freg(Fs1_bits)), rm, true);
                        }}, FloatCvtOp);
                    }
                }
                0x61: decode CONV_SGN {
                    0x0: fcvt_w_d({{
                        RM_REQUIRED;
                        Rd_sd = sext<32>(f64_to_i32(f64(freg(Fs1_bits)), rm,
                                                    true));
                    }}, FloatCvtOp);
                    0x1: fcvt_wu_d({{
                        RM_REQUIRED;
                        Rd = sext<32>(f64_to_ui32(f64(freg(Fs1_bits)), rm,
                                                  true));
                    }}, FloatCvtOp);
                    0x2: decode RVTYPE {
                        0x1: fcvt_l_d({{
                            RM_REQUIRED;
                            Rd_sd = f64_to_i64(f64(freg(Fs1_bits)), rm, true);
                        }}, FloatCvtOp);
                    }
                    0x3: decode RVTYPE {
                        0x1: fcvt_lu_d({{
                            RM_REQUIRED;
                            Rd = f64_to_ui64(f64(freg(Fs1_bits)), rm, true);
                        }}, FloatCvtOp);
                    }
                }
                0x62: decode CONV_SGN {
                    0x0: fcvt_w_h({{
                        RM_REQUIRED;
                        Rd_sd = sext<32>(f16_to_i32(f16(freg(Fs1_bits)), rm,
                                                    true));
                    }}, FloatCvtOp);
                    0x1: fcvt_wu_h({{
                        RM_REQUIRED;
                        Rd = sext<32>(f16_to_ui32(f16(freg(Fs1_bits)), rm,
                                                  true));
                    }}, FloatCvtOp);
                    0x2: decode RVTYPE {
                        0x1: fcvt_l_h({{
                            RM_REQUIRED;
                            Rd_sd = f16_to_i64(f16(freg(Fs1_bits)), rm, true);
                        }}, FloatCvtOp);
                    }
                    0x3: decode RVTYPE {
                        0x1: fcvt_lu_h({{
                            RM_REQUIRED;
                            Rd = f16_to_ui64(f16(freg(Fs1_bits)), rm, true);
                        }}, FloatCvtOp);
                    }
                }
                0x68: decode CONV_SGN {
                    0x0: fcvt_s_w({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(i32_to_f32(Rs1_sw));
                        Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    0x1: fcvt_s_wu({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(ui32_to_f32(Rs1_uw));
                        Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    0x2: decode RVTYPE {
                        0x1: fcvt_s_l({{
                            RM_REQUIRED;
                            freg_t fd;
                            fd = freg(i64_to_f32(Rs1_ud));
                            Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    }
                    0x3: decode RVTYPE {
                        0x1: fcvt_s_lu({{
                            RM_REQUIRED;
                            freg_t fd;
                            fd = freg(ui64_to_f32(Rs1));
                            Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    }
                }
                0x69: decode CONV_SGN {
                    0x0: fcvt_d_w({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(i32_to_f64(Rs1_sw));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                    0x1: fcvt_d_wu({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(ui32_to_f64(Rs1_uw));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                    0x2: decode RVTYPE {
                        0x1: fcvt_d_l({{
                            RM_REQUIRED;
                            freg_t fd;
                            fd = freg(i64_to_f64(Rs1_sd));
                            Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    }
                    0x3: decode RVTYPE {
                        0x1: fcvt_d_lu({{
                            RM_REQUIRED;
                            freg_t fd;
                            fd = freg(ui64_to_f64(Rs1));
                            Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    }
                }
                0x6a: decode CONV_SGN {
                    0x0: fcvt_h_w({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(i32_to_f16((int32_t)Rs1_sw));
                        Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    0x1: fcvt_h_wu({{
                        RM_REQUIRED;
                        freg_t fd;
                        fd = freg(ui32_to_f16((uint32_t)Rs1_uw));
                        Fd_bits = fd.v;
                        }}, FloatCvtOp);
                    0x2: decode RVTYPE {
                        0x1: fcvt_h_l({{
                            RM_REQUIRED;
                            freg_t fd;
                            fd = freg(i64_to_f16(Rs1_ud));
                            Fd_bits = fd.v;
                            }}, FloatCvtOp);
                    }
                    0x3: decode RVTYPE {
                        0x1: fcvt_h_lu({{
                            RM_REQUIRED;
                            freg_t fd;
                            fd = freg(ui64_to_f16(Rs1));
                            Fd_bits = fd.v;
                            }}, FloatCvtOp);
                    }
                }
                0x70: decode ROUND_MODE {
                    0x0: fmv_x_w({{
                        uint64_t result = (uint32_t)Fs1_bits;
                        if ((result&0x80000000) != 0) {
                            result |= (0xFFFFFFFFULL << 32);
                        }
                        Rd = result;
                    }}, FloatCvtOp);
                    0x1: fclass_s({{
                        Rd = rvSext(f32_classify(f32(freg(Fs1_bits))));
                    }}, FloatMiscOp);
                }
                0x71: decode ROUND_MODE {
                    0x0: decode RVTYPE {
                        0x1: fmv_x_d({{
                            Rd = freg(Fs1_bits).v;
                        }}, FloatCvtOp);
                    }
                    0x1: fclass_d({{
                        Rd = f64_classify(f64(freg(Fs1_bits)));
                    }}, FloatMiscOp);
                }
                0x72: decode ROUND_MODE {
                    0x0: fmv_x_h({{
                        uint64_t result = (uint16_t)Fs1_bits;
                        if ((result&0x8000) != 0) {
                            result |= (0xFFFFFFFFFFFFULL << 16);
                        }
                        Rd = result;
                    }}, FloatCvtOp);
                    0x1: fclass_h({{
                        Rd = f16_classify(f16(freg(Fs1_bits)));
                    }}, FloatMiscOp);
                }
                0x78: fmv_w_x({{
                    freg_t fd;
                    fd = freg(f32(Rs1_uw));
                    Fd_bits = fd.v;
                }}, FloatCvtOp);
                0x79: decode RVTYPE {
                    0x1: fmv_d_x({{
                        freg_t fd;
                        fd = freg(f64(Rs1));
                        Fd_bits = fd.v;
                    }}, FloatCvtOp);
                }
                0x7a: fmv_h_x({{
                    freg_t fd;
                    fd = freg(f16(Rs1_uh));
                    Fd_bits = fd.v;
                }}, FloatCvtOp);
            }
        }

        0x18: decode FUNCT3 {
            format BOp {
                0x0: beq({{
                    if (rvSext(Rs1) == rvSext(Rs2)) {
                        NPC = rvZext(PC + imm);
                    } else {
                        NPC = rvZext(NPC);
                    }
                }}, IsDirectControl, IsCondControl);
                0x1: bne({{
                    if (rvSext(Rs1) != rvSext(Rs2)) {
                        NPC = rvZext(PC + imm);
                    } else {
                        NPC = rvZext(NPC);
                    }
                }}, IsDirectControl, IsCondControl);
                0x4: blt({{
                    if (rvSext(Rs1_sd) < rvSext(Rs2_sd)) {
                        NPC = rvZext(PC + imm);
                    } else {
                        NPC = rvZext(NPC);
                    }
                }}, IsDirectControl, IsCondControl);
                0x5: bge({{
                    if (rvSext(Rs1_sd) >= rvSext(Rs2_sd)) {
                        NPC = rvZext(PC + imm);
                    } else {
                        NPC = rvZext(NPC);
                    }
                }}, IsDirectControl, IsCondControl);
                0x6: bltu({{
                    if (rvZext(Rs1) < rvZext(Rs2)) {
                        NPC = rvZext(PC + imm);
                    } else {
                        NPC = rvZext(NPC);
                    }
                }}, IsDirectControl, IsCondControl);
                0x7: bgeu({{
                    if (rvZext(Rs1) >= rvZext(Rs2)) {
                        NPC = rvZext(PC + imm);
                    } else {
                        NPC = rvZext(NPC);
                    }
                }}, IsDirectControl, IsCondControl);
            }
        }

        0x19: decode FUNCT3 {
            0x0: Jump::jalr({{
                Rd = rvSext(NPC);
                NPC = rvZext((imm + Rs1) & (~0x1));
            }}, IsIndirectControl, IsUncondControl);
        }

        0x1b: JOp::jal({{
            Rd = rvSext(NPC);
            NPC = rvZext(PC + imm);
        }}, IsDirectControl, IsUncondControl);

        0x1c: decode FUNCT3 {
            format SystemOp {
                0x0: decode FUNCT7 {
                    0x0: decode RS2 {
                        0x0: ecall({{
                            return std::make_shared<SyscallFault>(
                                (PrivilegeMode)xc->readMiscReg(MISCREG_PRV));
                        }}, IsSerializeAfter, IsNonSpeculative, IsSyscall,
                            No_OpClass);
                        0x1: ebreak({{
                            return std::make_shared<BreakpointFault>(
                                xc->pcState());
                        }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                        0x2: uret({{
                            STATUS status = xc->readMiscReg(MISCREG_STATUS);
                            status.uie = status.upie;
                            status.upie = 1;
                            xc->setMiscReg(MISCREG_STATUS, status);
                            NPC = xc->readMiscReg(MISCREG_UEPC);
                        }}, IsSerializeAfter, IsNonSpeculative, IsReturn);
                    }
                    0x8: decode RS2 {
                        0x2: sret({{
                            STATUS status = xc->readMiscReg(MISCREG_STATUS);
                            auto pm = (PrivilegeMode)xc->readMiscReg(
                                MISCREG_PRV);
                            if (pm == PRV_U ||
                                (pm == PRV_S && status.tsr == 1)) {
                                return std::make_shared<IllegalInstFault>(
                                            "sret in user mode or TSR enabled",
                                            machInst);
                                NPC = NPC;
                            } else {
                                xc->setMiscReg(MISCREG_PRV, status.spp);
                                status.sie = status.spie;
                                status.spie = 1;
                                status.spp = PRV_U;
                                xc->setMiscReg(MISCREG_STATUS, status);
                                NPC = xc->readMiscReg(MISCREG_SEPC);
                            }
                        }}, IsSerializeAfter, IsNonSpeculative, IsReturn);
                        0x5: wfi({{
                            STATUS status = xc->readMiscReg(MISCREG_STATUS);
                            auto pm = (PrivilegeMode)xc->readMiscReg(
                                MISCREG_PRV);
                            if (pm == PRV_U ||
                                (pm == PRV_S && status.tw == 1)) {
                                return std::make_shared<IllegalInstFault>(
                                            "wfi in user mode or TW enabled",
                                            machInst);
                            }
                            // Go to sleep only if there's no pending interrupt
                            // at all, including masked interrupts.
                            auto tc = xc->tcBase();
                            auto cpu = tc->getCpuPtr();
                            auto ic = dynamic_cast<RiscvISA::Interrupts*>(
                                cpu->getInterruptController(tc->threadId()));
                            panic_if(!ic, "Invalid Interrupt Controller.");
                            if (ic->readIP() == 0
                                && xc->readMiscReg(MISCREG_NMIP) == 0) {
                                tc->quiesce();
                            }
                        }}, IsNonSpeculative, IsQuiesce,
                            IsSerializeAfter, No_OpClass);
                    }
                    0x9: sfence_vma({{
                        STATUS status = xc->readMiscReg(MISCREG_STATUS);
                        auto pm = (PrivilegeMode)xc->readMiscReg(MISCREG_PRV);
                        if (pm == PRV_U || (pm == PRV_S && status.tvm == 1)) {
                            return std::make_shared<IllegalInstFault>(
                                        "sfence in user mode or TVM enabled",
                                        machInst);
                        }
                        xc->tcBase()->getMMUPtr()->demapPage(Rs1, Rs2);
                    }}, IsNonSpeculative, IsSerializeAfter, No_OpClass);
                    0x18: mret({{
                        if (xc->readMiscReg(MISCREG_PRV) != PRV_M) {
                            return std::make_shared<IllegalInstFault>(
                                        "mret at lower privilege", machInst);
                            NPC = NPC;
                        } else {
                            STATUS status = xc->readMiscReg(MISCREG_STATUS);
                            xc->setMiscReg(MISCREG_PRV, status.mpp);
                            xc->setMiscReg(MISCREG_NMIE, 1);
                            status.mie = status.mpie;
                            status.mpie = 1;
                            status.mpp = PRV_U;
                            xc->setMiscReg(MISCREG_STATUS, status);
                            NPC = xc->readMiscReg(MISCREG_MEPC);
                        }
                    }}, IsSerializeAfter, IsNonSpeculative, IsReturn);
                }
            }
            format CSROp {
                0x1: csrrw({{
                    Rd = rvSext(data);
                    data = rvZext(Rs1);
                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                0x2: csrrs({{
                    Rd = rvSext(data);
                    data = rvZext(data | Rs1);
                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                0x3: csrrc({{
                    Rd = rvSext(data);
                    data = rvZext(data & ~Rs1);
                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                0x5: csrrwi({{
                    Rd = rvSext(data);
                    data = rvZext(uimm);
                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                0x6: csrrsi({{
                    Rd = rvSext(data);
                    data = rvZext(data | uimm);
                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
                0x7: csrrci({{
                    Rd = rvSext(data);
                    data = rvZext(data & ~uimm);
                }}, IsSerializeAfter, IsNonSpeculative, No_OpClass);
            }
        }

        0x1e: M5Op::M5Op();
    }
}