/*
 * Copyright (C) 2021 Igalia S.L.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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.
 */

#include "config.h"

#if ENABLE(DISASSEMBLER) && ENABLE(RISCV64_DISASSEMBLER)

#include "MacroAssemblerCodeRef.h"
#include "RISCV64Assembler.h"
#include <array>
#include <mutex>

namespace JSC {

namespace RISCV64Disassembler {

template<size_t BufferSize>
struct StringBufferBase {
    char* data() { return buffer.data(); }
    size_t size() { return sizeof(char) * buffer.size(); }

    CString createString()
    {
        buffer[BufferSize - 1] = '\0';
        return { buffer.data() };
    }

    std::array<char, BufferSize> buffer;
};

using StringBuffer = StringBufferBase<256>;
using SmallStringBuffer = StringBufferBase<32>;

template<typename RegisterType> const char* registerName(uint8_t) = delete;

template<>
const char* registerName<RISCV64Instructions::RegistersBase::GType>(uint8_t value)
{
    static const std::array<const char*, 32> s_gpRegNames {
        "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
        "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
        "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
        "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
    };

    if (value < 32)
        return s_gpRegNames[value];
    return "<unknown>";
}

template<>
const char* registerName<RISCV64Instructions::RegistersBase::FType>(uint8_t value)
{
    static const std::array<const char*, 32> s_fpRegNames {
        "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
        "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
        "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
        "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
    };

    if (value < 32)
        return s_fpRegNames[value];
    return "<unknown>";
}

const char* roundingMode(uint8_t value)
{
    using RISCV64Instructions::FPRoundingMode;

    switch (value) {
    case unsigned(FPRoundingMode::RNE):
        return "rne";
    case unsigned(FPRoundingMode::RTZ):
        return "rtz";
    case unsigned(FPRoundingMode::RDN):
        return "rdn";
    case unsigned(FPRoundingMode::RUP):
        return "rup";
    case unsigned(FPRoundingMode::RMM):
        return "rmm";
    case unsigned(FPRoundingMode::DYN):
        return "dyn";
    default:
        break;
    }

    return "<unknown>";
}

SmallStringBuffer memoryOperationFlags(uint8_t value)
{
    using RISCV64Instructions::MemoryOperation;

    SmallStringBuffer buffer;
    if (!!value) {
        snprintf(buffer.data(), buffer.size(), "%s%s%s%s",
            (value & unsigned(MemoryOperation::I)) ? "i" : "",
            (value & unsigned(MemoryOperation::O)) ? "o" : "",
            (value & unsigned(MemoryOperation::R)) ? "r" : "",
            (value & unsigned(MemoryOperation::W)) ? "w" : "");
    } else
        snprintf(buffer.data(), buffer.size(), "<none>");
    return buffer;
}

const char* aqrlFlags(uint8_t value)
{
    using RISCV64Instructions::MemoryAccess;

    switch (value) {
    case 0:
        return "";
    case unsigned(MemoryAccess::Acquire):
        return ".aq";
    case unsigned(MemoryAccess::Release):
        return ".rl";
    case unsigned(MemoryAccess::AcquireRelease):
        return ".aqrl";
    default:
        break;
    }

    return "<unknown>";
}

// A simple type that handles a parameter pack of instruction types, along with a contains<T>() helper that serves as a
// compile-time check whether a given type is included in that parameter pack.

template<typename... Args>
struct InstructionList {
    template<typename T>
    static constexpr bool contains()
    {
        return (std::is_same_v<T, Args> || ...);
    }
};

// To enable showing sensible disassembly, different instructions have to be formatted differently. Each such formatting
// class specifies the list of instructions it can format, but generally instructions under a given formatter fall into
// the same class of instructions. The disassemble() static function returns a CString holding the formatted data.

struct RTypeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::ADD, RISCV64Instructions::SUB,
        RISCV64Instructions::SLT, RISCV64Instructions::SLTU,
        RISCV64Instructions::SLL, RISCV64Instructions::SRL, RISCV64Instructions::SRA,
        RISCV64Instructions::XOR, RISCV64Instructions::OR, RISCV64Instructions::AND,
        RISCV64Instructions::ADDW, RISCV64Instructions::SUBW,
        RISCV64Instructions::SLLW, RISCV64Instructions::SRLW, RISCV64Instructions::SRAW,
        RISCV64Instructions::FSGNJ_S, RISCV64Instructions::FSGNJ_D,
        RISCV64Instructions::FSGNJN_S, RISCV64Instructions::FSGNJN_D,
        RISCV64Instructions::FSGNJX_S, RISCV64Instructions::FSGNJX_D,
        RISCV64Instructions::FMIN_S, RISCV64Instructions::FMIN_D,
        RISCV64Instructions::FMAX_S, RISCV64Instructions::FMAX_D,
        RISCV64Instructions::FEQ_S, RISCV64Instructions::FEQ_D,
        RISCV64Instructions::FLT_S, RISCV64Instructions::FLT_D,
        RISCV64Instructions::FLE_S, RISCV64Instructions::FLE_D,
        RISCV64Instructions::MUL, RISCV64Instructions::MULH, RISCV64Instructions::MULHSU, RISCV64Instructions::MULHU,
        RISCV64Instructions::DIV, RISCV64Instructions::DIVU, RISCV64Instructions::REM, RISCV64Instructions::REMU,
        RISCV64Instructions::MULW, RISCV64Instructions::DIVW, RISCV64Instructions::DIVUW, RISCV64Instructions::REMW, RISCV64Instructions::REMUW>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s, %s",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)),
            registerName<typename T::Registers::RS1>(T::rs1(insn)), registerName<typename T::Registers::RS2>(T::rs2(insn)));
        return buffer.createString();
    }
};

struct RTypeR2Formatting {
    using List = InstructionList<
        RISCV64Instructions::FMV_X_W, RISCV64Instructions::FMV_W_X,
        RISCV64Instructions::FMV_X_D, RISCV64Instructions::FMV_D_X,
        RISCV64Instructions::FCLASS_S, RISCV64Instructions::FCLASS_D>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s",
            T::name,
            registerName<typename T::Registers::RD>(T::rd(insn)), registerName<typename T::Registers::RS1>(T::rs1(insn)));
        return buffer.createString();
    }
};

struct RTypeWithRoundingModeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::FADD_S,
        RISCV64Instructions::FADD_D,
        RISCV64Instructions::FSUB_S,
        RISCV64Instructions::FSUB_D,
        RISCV64Instructions::FMUL_S,
        RISCV64Instructions::FMUL_D,
        RISCV64Instructions::FDIV_S,
        RISCV64Instructions::FDIV_D>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());
        uint8_t rm = T::rm(insn);

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s, %s%s%s",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)),
            registerName<typename T::Registers::RS1>(T::rs1(insn)), registerName<typename T::Registers::RS2>(T::rs2(insn)),
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : ", rm:",
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : roundingMode(rm));
        return buffer.createString();
    }
};

struct RTypeWithRoundingModeFSQRTFormatting {
    using List = InstructionList<
        RISCV64Instructions::FSQRT_S, RISCV64Instructions::FSQRT_D>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());
        uint8_t rm = T::rm(insn);

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s%s%s",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)),
            registerName<typename T::Registers::RS1>(T::rs1(insn)),
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : ", rm:",
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : roundingMode(rm));
        return buffer.createString();
    }
};

struct RTypeWithRoundingModeFCVTFormatting {
    using List = InstructionList<
        RISCV64Instructions::FCVT_W_S, RISCV64Instructions::FCVT_WU_S,
        RISCV64Instructions::FCVT_S_W, RISCV64Instructions::FCVT_S_WU,
        RISCV64Instructions::FCVT_W_D, RISCV64Instructions::FCVT_WU_D,
        RISCV64Instructions::FCVT_D_W, RISCV64Instructions::FCVT_D_WU,
        RISCV64Instructions::FCVT_L_S, RISCV64Instructions::FCVT_LU_S,
        RISCV64Instructions::FCVT_S_L, RISCV64Instructions::FCVT_S_LU,
        RISCV64Instructions::FCVT_L_D, RISCV64Instructions::FCVT_LU_D,
        RISCV64Instructions::FCVT_D_L, RISCV64Instructions::FCVT_D_LU,
        RISCV64Instructions::FCVT_S_D, RISCV64Instructions::FCVT_D_S>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());
        uint8_t rm = T::rm(insn);

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s%s%s",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)), registerName<typename T::Registers::RS1>(T::rs1(insn)),
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : ", rm:",
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : roundingMode(rm));
        return buffer.createString();
    }
};

struct RTypeWithAqRlDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::SC_W, RISCV64Instructions::SC_D,
        RISCV64Instructions::AMOSWAP_W, RISCV64Instructions::AMOSWAP_D,
        RISCV64Instructions::AMOADD_W, RISCV64Instructions::AMOADD_D,
        RISCV64Instructions::AMOXOR_W, RISCV64Instructions::AMOXOR_D,
        RISCV64Instructions::AMOAND_W, RISCV64Instructions::AMOAND_D,
        RISCV64Instructions::AMOOR_W, RISCV64Instructions::AMOOR_D,
        RISCV64Instructions::AMOMIN_W, RISCV64Instructions::AMOMIN_D,
        RISCV64Instructions::AMOMAX_W, RISCV64Instructions::AMOMAX_D,
        RISCV64Instructions::AMOMINU_W, RISCV64Instructions::AMOMINU_D,
        RISCV64Instructions::AMOMAXU_W, RISCV64Instructions::AMOMAXU_D>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s%s %s, %s, %s",
            T::name, aqrlFlags(T::aqrl(insn)), registerName<typename T::Registers::RD>(T::rd(insn)),
            registerName<typename T::Registers::RS1>(T::rs1(insn)), registerName<typename T::Registers::RS2>(T::rs2(insn)));
        return buffer.createString();
    }
};

struct RTypeWithAqRlLRFormatting {
    using List = InstructionList<
        RISCV64Instructions::LR_W, RISCV64Instructions::LR_D>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s%s %s, %s",
            T::name, aqrlFlags(T::aqrl(insn)),
            registerName<typename T::Registers::RD>(T::rd(insn)), registerName<typename T::Registers::RS1>(T::rs1(insn)));
        return buffer.createString();
    }
};

struct R4TypeWithRoundingModeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::FMADD_S, RISCV64Instructions::FMADD_D,
        RISCV64Instructions::FMSUB_S, RISCV64Instructions::FMSUB_D,
        RISCV64Instructions::FNMSUB_S, RISCV64Instructions::FNMSUB_D,
        RISCV64Instructions::FNMADD_S, RISCV64Instructions::FNMADD_D>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());
        uint8_t rm = T::rm(insn);

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s, %s, %s%s%s",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)), registerName<typename T::Registers::RS1>(T::rs1(insn)),
            registerName<typename T::Registers::RS2>(T::rs2(insn)), registerName<typename T::Registers::RS3>(T::rs3(insn)),
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : ", rm:",
            (rm == unsigned(RISCV64Instructions::FPRoundingMode::DYN)) ? "" : roundingMode(rm));
        return buffer.createString();
    }
};

struct ITypeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::ADDI, RISCV64Instructions::SLTI, RISCV64Instructions::SLTIU,
        RISCV64Instructions::XORI, RISCV64Instructions::ORI, RISCV64Instructions::ANDI,
        RISCV64Instructions::SLLI, RISCV64Instructions::SRLI, RISCV64Instructions::SRAI,
        RISCV64Instructions::ADDIW, RISCV64Instructions::SLLIW, RISCV64Instructions::SRLIW, RISCV64Instructions::SRAIW>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s, %d",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)),
            registerName<typename T::Registers::RS1>(T::rs1(insn)), RISCV64Instructions::IImmediate::value(insn));
        return buffer.createString();
    }
};

struct ITypeImmediateAsOffsetFormatting {
    using List = InstructionList<
        RISCV64Instructions::JALR,
        RISCV64Instructions::LB, RISCV64Instructions::LBU,
        RISCV64Instructions::LH, RISCV64Instructions::LHU,
        RISCV64Instructions::LW, RISCV64Instructions::LWU,
        RISCV64Instructions::LD,
        RISCV64Instructions::FLW, RISCV64Instructions::FLD>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %d(%s)",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)),
            RISCV64Instructions::IImmediate::value(insn), registerName<typename T::Registers::RS1>(T::rs1(insn)));
        return buffer.createString();
    }
};

struct STypeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::SB, RISCV64Instructions::SH, RISCV64Instructions::SW, RISCV64Instructions::SD,
        RISCV64Instructions::FSW, RISCV64Instructions::FSD>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %d(%s)",
            T::name, registerName<typename T::Registers::RS2>(T::rs2(insn)),
            RISCV64Instructions::SImmediate::value(insn), registerName<typename T::Registers::RS1>(T::rs1(insn)));
        return buffer.createString();
    }
};

struct BTypeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::BEQ,
        RISCV64Instructions::BNE,
        RISCV64Instructions::BLT,
        RISCV64Instructions::BGE,
        RISCV64Instructions::BLTU,
        RISCV64Instructions::BGEU>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %s, %d",
            T::name, registerName<typename T::Registers::RS1>(T::rs1(insn)), registerName<typename T::Registers::RS2>(T::rs2(insn)),
            RISCV64Instructions::BImmediate::value(insn));
        return buffer.createString();
    }
};

struct UTypeDefaultFormatting {
    using List = InstructionList<
        RISCV64Instructions::LUI, RISCV64Instructions::AUIPC>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s, %u",
            T::name, registerName<typename T::Registers::RD>(T::rd(insn)), RISCV64Instructions::UImmediate::value(insn));
        return buffer.createString();
    }
};

struct JTypeDefaultFormatting {
    using List = InstructionList<RISCV64Instructions::JAL>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %d(%s)",
            T::name, RISCV64Instructions::JImmediate::value(insn), registerName<typename T::Registers::RD>(T::rd(insn)));
        return buffer.createString();
    }
};

struct FenceInstructionFormatting {
    using List = InstructionList<RISCV64Instructions::FENCE>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(List::contains<T>());

        auto immValue = RISCV64Instructions::IImmediate::value(insn);
        auto predecessorFlags = memoryOperationFlags((immValue >> 4) & ((1 << 4) - 1));
        auto successorFlags = memoryOperationFlags((immValue >> 0) & ((1 << 4) - 1));

        StringBuffer buffer;
        snprintf(buffer.data(), buffer.size(), "%s %s,%s",
            T::name, predecessorFlags.data(), successorFlags.data());
        return buffer.createString();
    }
};

struct FenceIInstructionFormatting {
    using List = InstructionList<RISCV64Instructions::FENCE_I>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue)
    {
        static_assert(List::contains<T>());

        return { T::name };
    }
};

struct EnvironmentInstructionFormatting {
    using List = InstructionList<
        RISCV64Instructions::ECALL, RISCV64Instructions::EBREAK>;

    template<typename T>
    static CString disassemble(RISCV64Instructions::InstructionValue)
    {
        static_assert(List::contains<T>());

        return { T::name };
    }
};

// The Disassembler struct below has a template parameter pack, containing a list of instructions through which it
// should cascade and find a matching instruction type. When found, the DisassemblyFormatting class finds an
// appropriate formatter and uses it to return the disassembly string for the given instruction value.

template<typename T, typename FormattingType, typename... OtherFormattingTypes>
struct DisassemblyFormattingImpl {
    using Type = std::conditional_t<FormattingType::List::template contains<T>(),
        FormattingType,
        typename DisassemblyFormattingImpl<T, OtherFormattingTypes...>::Type>;
};

template<typename T, typename FormattingType>
struct DisassemblyFormattingImpl<T, FormattingType> {
    using Type = FormattingType;
};

template<typename T>
struct DisassemblyFormatting {
    using Type = typename DisassemblyFormattingImpl<T,
        RTypeDefaultFormatting,
        RTypeR2Formatting,
        RTypeWithRoundingModeDefaultFormatting,
        RTypeWithRoundingModeFSQRTFormatting,
        RTypeWithRoundingModeFCVTFormatting,
        RTypeWithAqRlDefaultFormatting,
        RTypeWithAqRlLRFormatting,
        R4TypeWithRoundingModeDefaultFormatting,
        ITypeDefaultFormatting,
        ITypeImmediateAsOffsetFormatting,
        STypeDefaultFormatting,
        BTypeDefaultFormatting,
        UTypeDefaultFormatting,
        JTypeDefaultFormatting,
        FenceInstructionFormatting,
        FenceIInstructionFormatting,
        EnvironmentInstructionFormatting>::Type;

    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        static_assert(Type::List::template contains<T>());
        return Type::template disassemble<T>(insn);
    }
};

template<typename InsnType, typename... OtherInsnTypes>
struct Disassembler {
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        if (InsnType::matches(insn))
            return DisassemblyFormatting<InsnType>::disassemble(insn);
        return Disassembler<OtherInsnTypes...>::disassemble(insn);
    }
};

template<typename InsnType>
struct Disassembler<InsnType> {
    static CString disassemble(RISCV64Instructions::InstructionValue insn)
    {
        if (InsnType::matches(insn))
            return DisassemblyFormatting<InsnType>::disassemble(insn);
        return { };
    }
};

CString disassembleOpcode(uint32_t *pc)
{
    using namespace RISCV64Instructions;
    using DisassemblerType = Disassembler<
        // RV32I Base Instruction Set
        LUI, AUIPC, JAL, JALR,
        BEQ, BNE, BLT, BGE, BLTU, BGEU,
        LB, LH, LW, LBU, LHU,
        SB, SH, SW,
        ADDI, SLTI, SLTIU, XORI, ORI, ANDI, SLLI, SRLI, SRAI,
        ADD, SUB, SLL, SLT, SLTU, XOR, SRL, SRA, OR, AND,
        FENCE, ECALL, EBREAK,
        // RV64I Base Instruction Set (in addition to RV32I)
        LWU, LD, SD,
        ADDIW, SLLIW, SRLIW, SRAIW,
        ADDW, SUBW, SLLW, SRLW, SRAW,
        // RV32/RV64 Zifencei Standard Extension
        FENCE_I,
        // RV32M Standard Extension
        MUL, MULH, MULHSU, MULHU,
        DIV, DIVU, REM, REMU,
        // RV64M Standard Extension (in addition to RV32M)
        MULW, DIVW, DIVUW, REMW, REMUW,
        // RV32A Standard Extension
        LR_W, SC_W,
        AMOSWAP_W, AMOADD_W, AMOXOR_W, AMOAND_W, AMOOR_W, AMOMIN_W, AMOMAX_W, AMOMINU_W, AMOMAXU_W,
        // RV64A Standard Extension (in addition to RV32A)
        LR_D, SC_D,
        AMOSWAP_D, AMOADD_D, AMOXOR_D, AMOAND_D, AMOOR_D, AMOMIN_D, AMOMAX_D, AMOMINU_D, AMOMAXU_D,
        // RV32F Standard Extension
        FLW, FSW,
        FMADD_S, FMSUB_S, FNMSUB_S, FNMADD_S,
        FADD_S, FSUB_S, FMUL_S, FDIV_S, FSQRT_S,
        FSGNJ_S, FSGNJN_S, FSGNJX_S, FMIN_S, FMAX_S,
        FCVT_W_S, FCVT_WU_S, FMV_X_W,
        FEQ_S, FLT_S, FLE_S, FCLASS_S,
        FCVT_S_W, FCVT_S_WU, FMV_W_X,
        // RV64F Standard Extension (in addition to RV32F)
        FCVT_L_S, FCVT_LU_S, FCVT_S_L, FCVT_S_LU,
        // RV32D Standard Extension
        FLD, FSD,
        FMADD_D, FMSUB_D, FNMSUB_D, FNMADD_D,
        FADD_D, FSUB_D, FMUL_D, FDIV_D, FSQRT_D,
        FSGNJ_D, FSGNJN_D, FSGNJX_D, FMIN_D, FMAX_D,
        FCVT_S_D, FCVT_D_S,
        FEQ_D, FLT_D, FLE_D, FCLASS_D,
        FCVT_W_D, FCVT_WU_D, FCVT_D_W, FCVT_D_WU,
        // RV64D Standard Extension (in addition to RV32D)
        FCVT_L_D, FCVT_LU_D, FMV_X_D,
        FCVT_D_L, FCVT_D_LU, FMV_D_X>;

    auto disassembly = DisassemblerType::disassemble(InstructionValue { *pc });
    if (!disassembly.isNull())
        return disassembly;
    return CString { "<unrecognized opcode>" };
}

} // namespace RISCV64Disassembler

bool tryToDisassemble(const MacroAssemblerCodePtr<DisassemblyPtrTag>& codePtr, size_t size, const char* prefix, PrintStream& out)
{
    uint32_t* currentPC = codePtr.untaggedExecutableAddress<uint32_t*>();
    size_t byteCount = size;

    while (byteCount) {
        out.printf("%s%#16llx: <%08x> %s\n", prefix, static_cast<unsigned long long>(bitwise_cast<uintptr_t>(currentPC)), *currentPC,
            RISCV64Disassembler::disassembleOpcode(currentPC).data());

        ++currentPC;
        byteCount -= sizeof(uint32_t);
    }

    return true;
}

} // namespace JSC

#endif // ENABLE(DISASSEMBLER) && ENABLE(RISCV64_DISASSEMBLER)