imports/imhex
1
0
Fork 0
mirror of https://github.com/WerWolv/ImHex.git synced 2026-03-28 07:47:03 -05:00
Code Issues Packages Projects Releases Wiki Activity

feat: Add support for Capstone 6, drop support for Capstone 4

Browse Source
This commit is contained in:
WerWolv
2025-11-30 19:49:07 +01:00
parent e5829a316b
commit c33d53b728
6 changed files with 562 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
plugins/disassembler/include/content/helpers/disassembler.hpp → plugins/disassembler/include/content/helpers/capstone.hpp
View File

@@ -4,40 +4,46 @@
#include <array>
#include <capstone/capstone.h>
#include <wolv/utils/string.hpp>
#include <hex/helpers/utils.hpp>
#include <hex/helpers/fmt.hpp>
#define CAPSTONE_AARCH64_COMPAT_HEADER
#define CAPSTONE_SYSTEMZ_COMPAT_HEADER
#include <capstone/capstone.h>
namespace hex::plugin::disasm {
enum class BuiltinArchitecture : i32
{
ARM = CS_ARCH_ARM,
ARM64 = CS_ARCH_ARM64,
MIPS = CS_ARCH_MIPS,
X86 = CS_ARCH_X86,
PPC = CS_ARCH_PPC,
SPARC = CS_ARCH_SPARC,
SYSZ = CS_ARCH_SYSZ,
XCORE = CS_ARCH_XCORE,
M68K = CS_ARCH_M68K,
TMS320C64X = CS_ARCH_TMS320C64X,
M680X = CS_ARCH_M680X,
EVM = CS_ARCH_EVM,
// Make sure these are in the same order as in capstone.h
enum class BuiltinArchitecture : i32 {
ARM = CS_ARCH_ARM,
ARM64 = CS_ARCH_ARM64,
SYSTEMZ = CS_ARCH_SYSZ,
MIPS = CS_ARCH_MIPS,
X86 = CS_ARCH_X86,
POWERPC = CS_ARCH_PPC,
SPARC = CS_ARCH_SPARC,
XCORE = CS_ARCH_XCORE,
M68K = CS_ARCH_M68K,
TMS320C64X = CS_ARCH_TMS320C64X,
M680X = CS_ARCH_M680X,
EVM = CS_ARCH_EVM,
MOS65XX = CS_ARCH_MOS65XX,
WASM = CS_ARCH_WASM,
BPF = CS_ARCH_BPF,
RISCV = CS_ARCH_RISCV,
SUPERH = CS_ARCH_SH,
TRICORE = CS_ARCH_TRICORE,
#if CS_API_MAJOR >= 5
WASM = CS_ARCH_WASM,
RISCV = CS_ARCH_RISCV,
MOS65XX = CS_ARCH_MOS65XX,
BPF = CS_ARCH_BPF,
SUPERH = CS_ARCH_SH,
TRICORE = CS_ARCH_TRICORE,
MAX = TRICORE,
# else
MAX = EVM,
#if CS_API_MAJOR >= 6
ALPHA = CS_ARCH_ALPHA,
HPPA = CS_ARCH_HPPA,
LOONGARCH = CS_ARCH_LOONGARCH,
XTENSA = CS_ARCH_XTENSA,
ARC = CS_ARCH_ARC,
#endif
MAX,
MIN = ARM
};
@@ -52,28 +58,35 @@ namespace hex::plugin::disasm {
}
constexpr static auto ArchitectureNames = []{
std::array<const char *, static_cast<u32>(BuiltinArchitecture::MAX) + 1> names = { };
std::array<const char *, static_cast<u32>(BuiltinArchitecture::MAX)> names = { };
names[CS_ARCH_ARM] = "ARM";
names[CS_ARCH_ARM64] = "AArch64";
names[CS_ARCH_MIPS] = "MIPS";
names[CS_ARCH_X86] = "Intel x86";
names[CS_ARCH_PPC] = "PowerPC";
names[CS_ARCH_SPARC] = "SPARC";
names[CS_ARCH_SYSZ] = "SystemZ";
names[CS_ARCH_XCORE] = "XCore";
names[CS_ARCH_M68K] = "Motorola 68K";
names[CS_ARCH_TMS320C64X] = "TMS320C64x";
names[CS_ARCH_M680X] = "M680X";
names[CS_ARCH_EVM] = "Ethereum Virtual Machine";
using enum BuiltinArchitecture;
#if CS_API_MAJOR >= 5
names[CS_ARCH_WASM] = "WebAssembly";
names[CS_ARCH_RISCV] = "RISC-V";
names[CS_ARCH_MOS65XX] = "MOS Technology 65xx";
names[CS_ARCH_BPF] = "Berkeley Packet Filter";
names[CS_ARCH_SH] = "SuperH";
names[CS_ARCH_TRICORE] = "Tricore";
names[u8(ARM)] = "ARM";
names[u8(ARM64)] = "AArch64";
names[u8(MIPS)] = "MIPS";
names[u8(X86)] = "x86";
names[u8(POWERPC)] = "PowerPC";
names[u8(SPARC)] = "SPARC";
names[u8(SYSTEMZ)] = "z/Architecture";
names[u8(XCORE)] = "xCORE";
names[u8(M68K)] = "M68K";
names[u8(TMS320C64X)] = "TMS320C64x";
names[u8(M680X)] = "M680X";
names[u8(EVM)] = "Ethereum VM";
names[u8(WASM)] = "WebAssembly";
names[u8(RISCV)] = "RISC-V";
names[u8(MOS65XX)] = "MOS65XX";
names[u8(BPF)] = "BPF";
names[u8(SUPERH)] = "SuperH";
names[u8(TRICORE)] = "TriCore";
#if CS_API_MAJOR >= 6
names[u8(ALPHA)] = "Alpha";
names[u8(HPPA)] = "HP/PA";
names[u8(LOONGARCH)] = "LoongArch";
names[u8(XTENSA)] = "Xtensa";
names[u8(ARC)] = "ARC";
#endif
return names;
@@ -155,7 +168,6 @@ namespace hex::plugin::disasm {
arch = CS_ARCH_TMS320C64X;
else if (equalsIgnoreCase(archName, "evm"))
arch = CS_ARCH_EVM;
#if CS_API_MAJOR >= 5
else if (equalsIgnoreCase(archName, "wasm"))
arch = CS_ARCH_WASM;
else if (equalsIgnoreCase(archName, "riscv"))
@@ -168,6 +180,17 @@ namespace hex::plugin::disasm {
arch = CS_ARCH_SH;
else if (equalsIgnoreCase(archName, "tricore"))
arch = CS_ARCH_TRICORE;
#if CS_API_MAJOR >= 6
else if (equalsIgnoreCase(archName, "alpha"))
arch = CS_ARCH_ALPHA;
else if (equalsIgnoreCase(archName, "hppa"))
arch = CS_ARCH_HPPA;
else if (equalsIgnoreCase(archName, "loongarch"))
arch = CS_ARCH_LOONGARCH;
else if (equalsIgnoreCase(archName, "xtensa"))
arch = CS_ARCH_XTENSA;
else if (equalsIgnoreCase(archName, "arc"))
arch = CS_ARCH_ARC;
#endif
else
throw std::runtime_error("Invalid disassembler architecture");
@@ -182,26 +205,81 @@ namespace hex::plugin::disasm {
option.remove_prefix(3);
}
constexpr static std::array<std::pair<std::string_view, cs_mode>, 53> Options = {{
constexpr static std::array<std::pair<std::string_view, cs_mode>, 110> Options = {{
// Common
{ "16bit", CS_MODE_16 },
{ "32bit", CS_MODE_32 },
{ "64bit", CS_MODE_64 },
// ARM
{ "cortex-m", CS_MODE_MCLASS },
{ "armv8", CS_MODE_V8 },
{ "micromips", CS_MODE_MICRO },
{ "mips2", CS_MODE_MIPS2 },
{ "mips3", CS_MODE_MIPS3 },
{ "mips32r6", CS_MODE_MIPS32R6 },
{ "thumb", CS_MODE_THUMB },
#if CS_API_MAJOR >= 6
// ARM64
{ "apple", CS_MODE_APPLE_PROPRIETARY },
#endif
// SPARC
{ "sparcv9", CS_MODE_V9 },
// PowerPC
{ "qpx", CS_MODE_QPX },
{ "spe", CS_MODE_SPE },
{ "ps", CS_MODE_PS },
{ "booke", CS_MODE_BOOKE },
#if CS_API_MAJOR >= 6
{ "aixos", CS_MODE_AIX_OS },
{ "pwr7", CS_MODE_PWR7 },
{ "pwr8", CS_MODE_PWR8 },
{ "pwr9", CS_MODE_PWR9 },
{ "pwr10", CS_MODE_PWR10 },
{ "future", CS_MODE_PPC_ISA_FUTURE },
{ "aixas", CS_MODE_MODERN_AIX_AS },
{ "msync", CS_MODE_MSYNC },
#endif
// M68K
{ "68000", CS_MODE_M68K_000 },
{ "68010", CS_MODE_M68K_010 },
{ "68020", CS_MODE_M68K_020 },
{ "68030", CS_MODE_M68K_030 },
{ "68040", CS_MODE_M68K_040 },
{ "68060", CS_MODE_M68K_060 },
// MIPS
{ "micromips", CS_MODE_MICRO },
{ "mips2", CS_MODE_MIPS2 },
{ "mips3", CS_MODE_MIPS3 },
{ "mips32r6", CS_MODE_MIPS32R6 },
#if CS_API_MAJOR >= 6
{ "mips1", CS_MODE_MIPS1 },
{ "mips4", CS_MODE_MIPS4 },
{ "mips5", CS_MODE_MIPS5 },
{ "mips32r2", CS_MODE_MIPS32R2 },
{ "mips32r3", CS_MODE_MIPS32R3 },
{ "mips32r5", CS_MODE_MIPS32R5 },
{ "mips64r2", CS_MODE_MIPS64R2 },
{ "mips64r3", CS_MODE_MIPS64R3 },
{ "mips64r5", CS_MODE_MIPS64R5 },
{ "mips64r6", CS_MODE_MIPS64R6 },
{ "octeon" , CS_MODE_OCTEON },
{ "octeonp", CS_MODE_OCTEONP },
{ "nanomips", CS_MODE_NANOMIPS },
{ "nms1", CS_MODE_NMS1 },
{ "i7200", CS_MODE_I7200 },
{ "nofloat", CS_MODE_MIPS_NOFLOAT },
{ "ptr64", CS_MODE_MIPS_PTR64 },
{ "micro32r3", CS_MODE_MICRO32R3 },
{ "micro32r6", CS_MODE_MICRO32R6 },
#endif
{ "6301", CS_MODE_M680X_6301 },
{ "6309", CS_MODE_M680X_6309 },
{ "6800", CS_MODE_M680X_6800 },
{ "6801", CS_MODE_M680X_6801 },
// M680X
{ "6301", CS_MODE_M680X_6301 },
{ "6309", CS_MODE_M680X_6309 },
{ "6800", CS_MODE_M680X_6800 },
@@ -212,16 +290,24 @@ namespace hex::plugin::disasm {
{ "6811", CS_MODE_M680X_6811 },
{ "cpu12", CS_MODE_M680X_CPU12 },
{ "hcs08", CS_MODE_M680X_HCS08 },
// BPF
{ "bpfe", CS_MODE_BPF_EXTENDED },
// RISC-V
{ "rv32g", CS_MODE_RISCV32 },
{ "rv64g", CS_MODE_RISCV64 },
{ "riscvc", CS_MODE_RISCVC },
// MOS65XX
{ "6502", CS_MODE_MOS65XX_6502 },
{ "65c02", CS_MODE_MOS65XX_65C02 },
{ "w65c02", CS_MODE_MOS65XX_W65C02 },
{ "65816", CS_MODE_MOS65XX_65816 },
{ "long-m", CS_MODE_MOS65XX_65816_LONG_M },
{ "long-x", CS_MODE_MOS65XX_65816_LONG_X },
// SuperH
{ "sh2", CS_MODE_SH2 },
{ "sh2a", CS_MODE_SH2A },
{ "sh3", CS_MODE_SH3 },
@@ -229,13 +315,48 @@ namespace hex::plugin::disasm {
{ "sh4a", CS_MODE_SH4A },
{ "shfpu", CS_MODE_SHFPU },
{ "shdsp", CS_MODE_SHDSP },
{ "1.1", CS_MODE_TRICORE_110 },
{ "1.2", CS_MODE_TRICORE_120 },
{ "1.3", CS_MODE_TRICORE_130 },
{ "1.3.1", CS_MODE_TRICORE_131 },
{ "1.6", CS_MODE_TRICORE_160 },
{ "1.6.1", CS_MODE_TRICORE_161 },
{ "1.6.2", CS_MODE_TRICORE_162 },
// Tricore
{ "tc1.1", CS_MODE_TRICORE_110 },
{ "tc1.2", CS_MODE_TRICORE_120 },
{ "tc1.3", CS_MODE_TRICORE_130 },
{ "tc1.3.1", CS_MODE_TRICORE_131 },
{ "tc1.6", CS_MODE_TRICORE_160 },
{ "tc1.6.1", CS_MODE_TRICORE_161 },
{ "tc1.6.2", CS_MODE_TRICORE_162 },
#if CS_API_MAJOR >= 6
// HP/PA
{ "hppa1.1", CS_MODE_HPPA_11 },
{ "hppa2.0", CS_MODE_HPPA_20 },
{ "hppa2.0w", CS_MODE_HPPA_20W },
// LoongArch
{ "loongarch32", CS_MODE_LOONGARCH32 },
{ "loongarch64", CS_MODE_LOONGARCH64 },
// SystemZ
{ "arch8", CS_MODE_SYSTEMZ_ARCH8 },
{ "arch9", CS_MODE_SYSTEMZ_ARCH9 },
{ "arch10", CS_MODE_SYSTEMZ_ARCH10 },
{ "arch11", CS_MODE_SYSTEMZ_ARCH11 },
{ "arch12", CS_MODE_SYSTEMZ_ARCH12 },
{ "arch13", CS_MODE_SYSTEMZ_ARCH13 },
{ "arch14", CS_MODE_SYSTEMZ_ARCH14 },
{ "z10", CS_MODE_SYSTEMZ_Z10 },
{ "z196", CS_MODE_SYSTEMZ_Z196 },
{ "zec12", CS_MODE_SYSTEMZ_ZEC12 },
{ "z13", CS_MODE_SYSTEMZ_Z13 },
{ "z14", CS_MODE_SYSTEMZ_Z14 },
{ "z15", CS_MODE_SYSTEMZ_Z15 },
{ "z16", CS_MODE_SYSTEMZ_Z16 },
{ "generic", CS_MODE_SYSTEMZ_GENERIC },
// Xtensa
{ "esp32", CS_MODE_XTENSA_ESP32 },
{ "esp32s2", CS_MODE_XTENSA_ESP32S2 },
{ "esp8266", CS_MODE_XTENSA_ESP8266 },
#endif
}};
bool optionFound = false;

3
plugins/disassembler/include/content/views/view_disassembler.hpp
View File

@@ -5,9 +5,6 @@
#include <hex/ui/view.hpp>
#include <ui/widgets.hpp>
#include <content/helpers/disassembler.hpp>
#include <string>
#include <vector>
#include <hex/api/content_registry/disassemblers.hpp>

59
plugins/disassembler/romfs/lang/en_US.json
View File

@@ -8,6 +8,7 @@
"hex.disassembler.view.disassembler.arm.cortex_m": "Cortex-M",
"hex.disassembler.view.disassembler.arm.default": "Default",
"hex.disassembler.view.disassembler.arm.thumb": "Thumb",
"hex.disassembler.view.disassembler.arm64.apple_extensions": "Proprietary Apple Extensions",
"hex.disassembler.view.disassembler.bpf.classic": "Classic",
"hex.disassembler.view.disassembler.bpf.extended": "Extended",
"hex.disassembler.view.disassembler.image_base_address": "Image Base Address",
@@ -20,6 +21,9 @@
"hex.disassembler.view.disassembler.disassembly.title": "Disassembly",
"hex.disassembler.view.disassembler.export": "Export instructions as...",
"hex.disassembler.view.disassembler.export.popup.error": "Failed to export to ASM file!",
"hex.disassembler.view.disassembler.hppa.1.1": "HP/PA 1.1",
"hex.disassembler.view.disassembler.hppa.2.0": "HP/PA 2.0",
"hex.disassembler.view.disassembler.hppa.2.0w": "HP/PA 2.0 wide",
"hex.disassembler.view.disassembler.image_load_address": "Image Load Address",
"hex.disassembler.view.disassembler.image_load_address.hint": "This is the address of where the disassembled code is being loaded into memory before it's being executed",
"hex.disassembler.view.disassembler.m680x.6301": "6301",
@@ -38,12 +42,29 @@
"hex.disassembler.view.disassembler.m68k.030": "030",
"hex.disassembler.view.disassembler.m68k.040": "040",
"hex.disassembler.view.disassembler.m68k.060": "060",
"hex.disassembler.view.disassembler.mips.micro": "Micro",
"hex.disassembler.view.disassembler.mips.micro": "microMIPS",
"hex.disassembler.view.disassembler.mips.mips1": "MIPS I",
"hex.disassembler.view.disassembler.mips.mips2": "MIPS II",
"hex.disassembler.view.disassembler.mips.mips3": "MIPS III",
"hex.disassembler.view.disassembler.mips.mips4": "MIPS IV",
"hex.disassembler.view.disassembler.mips.mips5": "MIPS V",
"hex.disassembler.view.disassembler.mips.mips32": "MIPS32",
"hex.disassembler.view.disassembler.mips.mips32R2": "MIPS32R2",
"hex.disassembler.view.disassembler.mips.mips32R3": "MIPS32R3",
"hex.disassembler.view.disassembler.mips.mips32R5": "MIPS32R5",
"hex.disassembler.view.disassembler.mips.mips32R6": "MIPS32R6",
"hex.disassembler.view.disassembler.mips.mips64R2": "MIPS64R2",
"hex.disassembler.view.disassembler.mips.mips64R3": "MIPS64R3",
"hex.disassembler.view.disassembler.mips.mips64R5": "MIPS64R5",
"hex.disassembler.view.disassembler.mips.mips64R6": "MIPS64R6",
"hex.disassembler.view.disassembler.mips.mips64": "MIPS64",
"hex.disassembler.view.disassembler.mips.octeon": "Octeon cnMIPS",
"hex.disassembler.view.disassembler.mips.octeonp": "Octeon+ cnMIPS",
"hex.disassembler.view.disassembler.mips.nanomips": "Generic nanoMIPS",
"hex.disassembler.view.disassembler.mips.nms1": "nanoMIPS NMS1",
"hex.disassembler.view.disassembler.mips.i7200": "nanoMIPS I7200",
"hex.disassembler.view.disassembler.mips.nofloat": "No Floating Point",
"hex.disassembler.view.disassembler.mips.ptr64": "64-bit pointers",
"hex.disassembler.view.disassembler.mos65xx.6502": "6502",
"hex.disassembler.view.disassembler.mos65xx.65816": "65816",
"hex.disassembler.view.disassembler.mos65xx.65816_long_m": "65816 Long M",
@@ -67,11 +88,43 @@
"hex.disassembler.view.disassembler.tricore.162": "162",
"hex.disassembler.view.disassembler.name": "Disassembler",
"hex.disassembler.view.disassembler.position": "Position",
"hex.disassembler.view.disassembler.ppc.booke": "Book-E",
"hex.disassembler.view.disassembler.ppc.booke": "BookE",
"hex.disassembler.view.disassembler.ppc.qpx": "Quad Processing Extensions",
"hex.disassembler.view.disassembler.ppc.spe": "Signal Processing Engine",
"hex.disassembler.view.disassembler.ppc.pwr7": "Power 7",
"hex.disassembler.view.disassembler.ppc.pwr8": "Power 8",
"hex.disassembler.view.disassembler.ppc.pwr9": "Power 9",
"hex.disassembler.view.disassembler.ppc.pwr10": "Power 10",
"hex.disassembler.view.disassembler.ppc.future": "Power ISA Future",
"hex.disassembler.view.disassembler.ppc.aixos": "PowerPC AIX-OS",
"hex.disassembler.view.disassembler.ppc.aixas": "PowerPC AIX-OS with modern assembly",
"hex.disassembler.view.disassembler.ppc.msync": "msync Instruction + BookE",
"hex.disassembler.view.disassembler.region": "Code region",
"hex.disassembler.view.disassembler.riscv.compressed": "Compressed",
"hex.disassembler.view.disassembler.settings.mode": "Mode",
"hex.disassembler.view.disassembler.sparc.v9": "Sparc V9"
"hex.disassembler.view.disassembler.sparc.v9": "Sparc V9",
"hex.disassembler.view.disassembler.xtensa.esp32": "ESP32",
"hex.disassembler.view.disassembler.xtensa.esp32s2": "ESP32-S2",
"hex.disassembler.view.disassembler.xtensa.esp8266": "ESP8266",
"hex.disassembler.view.disassembler.systemz.arch8": "ARCH8",
"hex.disassembler.view.disassembler.systemz.arch9": "ARCH9",
"hex.disassembler.view.disassembler.systemz.arch10": "ARCH10",
"hex.disassembler.view.disassembler.systemz.arch11": "ARCH11",
"hex.disassembler.view.disassembler.systemz.arch12": "ARCH12",
"hex.disassembler.view.disassembler.systemz.arch13": "ARCH13",
"hex.disassembler.view.disassembler.systemz.arch14": "ARCH14",
"hex.disassembler.view.disassembler.systemz.z10": "Z10",
"hex.disassembler.view.disassembler.systemz.z196": "Z196",
"hex.disassembler.view.disassembler.systemz.zec12": "ZEC12",
"hex.disassembler.view.disassembler.systemz.z13": "Z13",
"hex.disassembler.view.disassembler.systemz.z14": "Z14",
"hex.disassembler.view.disassembler.systemz.z15": "Z15",
"hex.disassembler.view.disassembler.systemz.z16": "Z16",
"hex.disassembler.view.disassembler.systemz.generic": "Generic",
"hex.disassembler.view.disassembler.settings.syntax": "Syntax",
"hex.disassembler.view.disassembler.settings.syntax.default": "Architecture Default",
"hex.disassembler.view.disassembler.settings.syntax.intel": "Intel",
"hex.disassembler.view.disassembler.settings.syntax.att": "AT&T",
"hex.disassembler.view.disassembler.settings.syntax.masm": "MASM",
"hex.disassembler.view.disassembler.settings.syntax.motorola": "Motorola"
}

386
plugins/disassembler/source/content/disassemblers/capstone_architectures.cpp
View File

@@ -1,6 +1,6 @@
#include <hex/api/content_registry/disassemblers.hpp>
#include <content/helpers/disassembler.hpp>
#include <content/helpers/capstone.hpp>
#include <hex/helpers/fmt.hpp>
#include <imgui.h>
@@ -19,17 +19,19 @@ namespace hex::plugin::disasm {
m_instruction = nullptr;
auto mode = m_mode;
if (bool(m_endian)) {
if (m_endian == std::endian::little) {
mode = cs_mode(u32(mode) | CS_MODE_LITTLE_ENDIAN);
} else {
} else if (m_endian == std::endian::big) {
mode = cs_mode(u32(mode) | CS_MODE_BIG_ENDIAN);
}
if (cs_open(CapstoneDisassembler::toCapstoneArchitecture(m_architecture), mode, &m_handle) != CS_ERR_OK) {
return false;
}
cs_option(m_handle, CS_OPT_SKIPDATA, CS_OPT_ON);
cs_option(m_handle, CS_OPT_SYNTAX, m_syntaxMode);
m_instruction = cs_malloc(m_handle);
@@ -45,10 +47,57 @@ namespace hex::plugin::disasm {
}
void drawSettings() override {
ImGui::RadioButton("hex.ui.common.little_endian"_lang, &m_endian, true);
ImGui::SameLine();
ImGui::RadioButton("hex.ui.common.big_endian"_lang, &m_endian, false);
ImGui::NewLine();
// Endianness selection
{
int selection = [this] {
switch (m_endian) {
default:
case std::endian::little:
return 0;
case std::endian::big:
return 1;
}
}();
std::array options = {
fmt::format("{}: {}", "hex.ui.common.endian"_lang, "hex.ui.common.little"_lang),
fmt::format("{}: {}", "hex.ui.common.endian"_lang, "hex.ui.common.big"_lang)
};
if (ImGui::SliderInt("##endian", &selection, 0, options.size() - 1, options[selection].c_str(), ImGuiSliderFlags_NoInput)) {
switch (selection) {
default:
case 0:
m_endian = std::endian::little;
break;
case 1:
m_endian = std::endian::big;
break;
}
}
}
{
constexpr static std::pair<LangConst, cs_opt_value> Modes[] = {
{ "hex.disassembler.view.disassembler.settings.syntax.default"_lang, CS_OPT_SYNTAX_DEFAULT },
{ "hex.disassembler.view.disassembler.settings.syntax.intel"_lang, CS_OPT_SYNTAX_INTEL },
{ "hex.disassembler.view.disassembler.settings.syntax.att"_lang, CS_OPT_SYNTAX_ATT },
{ "hex.disassembler.view.disassembler.settings.syntax.masm"_lang, CS_OPT_SYNTAX_MASM },
{ "hex.disassembler.view.disassembler.settings.syntax.motorola"_lang, CS_OPT_SYNTAX_MOTOROLA },
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.syntax"_lang, Modes[m_syntaxModeIndex].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_syntaxModeIndex = i;
}
ImGui::EndCombo();
}
m_syntaxMode = cs_opt_value(Modes[m_syntaxModeIndex].second);
}
ImGui::Separator();
}
std::optional<ContentRegistry::Disassemblers::Instruction> disassemble(u64 imageBaseAddress, u64 instructionLoadAddress, u64 instructionDataAddress, std::span<const u8> code) override {
@@ -77,10 +126,12 @@ namespace hex::plugin::disasm {
BuiltinArchitecture m_architecture;
csh m_handle = 0;
cs_insn *m_instruction = nullptr;
int m_syntaxModeIndex = 0;
cs_opt_value m_syntaxMode = CS_OPT_SYNTAX_DEFAULT;
protected:
cs_mode m_mode = cs_mode(0);
int m_endian = true;
std::endian m_endian = std::endian::little;
bool m_initialized = false;
};
@@ -111,6 +162,19 @@ namespace hex::plugin::disasm {
class ArchitectureARM64 : public CapstoneArchitecture {
public:
ArchitectureARM64(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::ARM64, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
#if CS_API_MAJOR >= 6
ImGui::Checkbox("hex.disassembler.view.disassembler.arm64.apple_extensions"_lang, &m_appleExtensions);
m_mode = cs_mode(m_appleExtensions ? CS_MODE_APPLE_PROPRIETARY : cs_mode(0));
#endif
}
private:
[[maybe_unused]] bool m_appleExtensions = false;
};
class ArchitectureMIPS : public CapstoneArchitecture {
@@ -120,24 +184,62 @@ namespace hex::plugin::disasm {
void drawSettings() override {
CapstoneArchitecture::drawSettings();
ImGui::RadioButton("hex.disassembler.view.disassembler.mips.mips32"_lang, &m_mipsMode, CS_MODE_MIPS32);
ImGui::SameLine();
ImGui::RadioButton("hex.disassembler.view.disassembler.mips.mips64"_lang, &m_mipsMode, CS_MODE_MIPS64);
ImGui::SameLine();
ImGui::RadioButton("hex.disassembler.view.disassembler.mips.mips32R6"_lang, &m_mipsMode, CS_MODE_MIPS32R6);
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.mips.mips32"_lang, CS_MODE_MIPS32 },
{ "hex.disassembler.view.disassembler.mips.mips64"_lang, CS_MODE_MIPS64 },
#if CS_API_MAJOR >= 6
{ "hex.disassembler.view.disassembler.mips.mips1"_lang, CS_MODE_MIPS1 },
#endif
{ "hex.disassembler.view.disassembler.mips.mips2"_lang, CS_MODE_MIPS2 },
{ "hex.disassembler.view.disassembler.mips.mips3"_lang, CS_MODE_MIPS3 },
#if CS_API_MAJOR >= 6
{ "hex.disassembler.view.disassembler.mips.mips4"_lang, CS_MODE_MIPS4 },
{ "hex.disassembler.view.disassembler.mips.mips5"_lang, CS_MODE_MIPS5 },
{ "hex.disassembler.view.disassembler.mips.mips32r2"_lang, CS_MODE_MIPS32R2 },
{ "hex.disassembler.view.disassembler.mips.mips32r3"_lang, CS_MODE_MIPS32R3 },
{ "hex.disassembler.view.disassembler.mips.mips32r5"_lang, CS_MODE_MIPS32R5 },
{ "hex.disassembler.view.disassembler.mips.mips64r2"_lang, CS_MODE_MIPS64R2 },
{ "hex.disassembler.view.disassembler.mips.mips64r3"_lang, CS_MODE_MIPS64R3 },
{ "hex.disassembler.view.disassembler.mips.mips64r5"_lang, CS_MODE_MIPS64R5 },
{ "hex.disassembler.view.disassembler.mips.mips64r6"_lang, CS_MODE_MIPS64R6 },
{ "hex.disassembler.view.disassembler.mips.octeon"_lang, CS_MODE_OCTEON },
{ "hex.disassembler.view.disassembler.mips.octeonp"_lang, CS_MODE_OCTEONP },
{ "hex.disassembler.view.disassembler.mips.nanomips"_lang, CS_MODE_NANOMIPS },
{ "hex.disassembler.view.disassembler.mips.nms1"_lang, CS_MODE_NMS1 },
{ "hex.disassembler.view.disassembler.mips.i7200"_lang, CS_MODE_I7200 },
#endif
};
ImGui::RadioButton("hex.disassembler.view.disassembler.mips.mips2"_lang, &m_mipsMode, CS_MODE_MIPS2);
ImGui::SameLine();
ImGui::RadioButton("hex.disassembler.view.disassembler.mips.mips3"_lang, &m_mipsMode, CS_MODE_MIPS3);
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(Modes[m_selectedMode].second);
#if CS_API_MAJOR >= 6
ImGui::Checkbox("hex.disassembler.view.disassembler.mips.nofloat"_lang, &m_nofloats);
ImGui::Checkbox("hex.disassembler.view.disassembler.mips.ptr64"_lang, &m_ptr64);
m_mode = cs_mode(
(m_nofloats ? CS_MODE_MIPS_NOFLOAT : cs_mode(0)) |
(m_ptr64 ? CS_MODE_MIPS_PTR64 : cs_mode(0))
);
#endif
ImGui::Checkbox("hex.disassembler.view.disassembler.mips.micro"_lang, &m_microMode);
m_mode = cs_mode(m_mipsMode | (m_microMode ? CS_MODE_MICRO : cs_mode(0)));
m_mode = cs_mode(m_mode | (m_microMode ? CS_MODE_MICRO : cs_mode(0)));
}
private:
int m_mipsMode = CS_MODE_MIPS32;
int m_selectedMode = 0;
bool m_microMode = false;
[[maybe_unused]] bool m_nofloats = false;
[[maybe_unused]] bool m_ptr64 = false;
};
class ArchitectureX86 : public CapstoneArchitecture {
@@ -162,7 +264,7 @@ namespace hex::plugin::disasm {
class ArchitecturePowerPC : public CapstoneArchitecture {
public:
ArchitecturePowerPC(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::PPC, mode) {}
ArchitecturePowerPC(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::POWERPC, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
@@ -173,13 +275,36 @@ namespace hex::plugin::disasm {
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.qpx"_lang, &m_qpx);
#if CS_API_MAJOR >= 5
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.spe"_lang, &m_spe);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.booke"_lang, &m_booke);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.spe"_lang, &m_spe);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.booke"_lang, &m_booke);
m_mode = cs_mode(m_ppcMode | (m_qpx ? CS_MODE_QPX : cs_mode(0)) | (m_spe ? CS_MODE_SPE : cs_mode(0)) | (m_booke ? CS_MODE_BOOKE : cs_mode(0)));
#else
m_mode = cs_mode(mode | (qpx ? CS_MODE_QPX : cs_mode(0)));
m_mode = cs_mode(
m_ppcMode |
(m_qpx ? CS_MODE_QPX : cs_mode(0)) |
(m_spe ? CS_MODE_SPE : cs_mode(0)) |
(m_booke ? CS_MODE_BOOKE : cs_mode(0))
);
#if CS_API_MAJOR >= 6
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.pwr7"_lang, &m_pwr7);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.pwr8"_lang, &m_pwr8);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.pwr9"_lang, &m_pwr9);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.pwr10"_lang, &m_pwr10);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.aixos"_lang, &m_aixos);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.future"_lang, &m_future);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.aixas"_lang, &m_aixas);
ImGui::Checkbox("hex.disassembler.view.disassembler.ppc.msync"_lang, &m_msync);
m_mode = cs_mode(
u32(m_mode) |
(m_pwr7 ? CS_MODE_PWR7 : cs_mode(0)) |
(m_pwr8 ? CS_MODE_PWR8 : cs_mode(0)) |
(m_pwr9 ? CS_MODE_PWR9 : cs_mode(0)) |
(m_pwr10 ? CS_MODE_PWR10 : cs_mode(0)) |
(m_aixos ? CS_MODE_AIX_OS : cs_mode(0)) |
(m_future ? CS_MODE_PPC_ISA_FUTURE : cs_mode(0)) |
(m_aixas ? CS_MODE_MODERN_AIX_AS : cs_mode(0)) |
(m_msync ? CS_MODE_MSYNC : cs_mode(0))
);
#endif
}
@@ -188,6 +313,14 @@ namespace hex::plugin::disasm {
bool m_qpx = false;
bool m_spe = false;
bool m_booke = false;
[[maybe_unused]] bool m_pwr7 = false;
[[maybe_unused]] bool m_pwr8 = false;
[[maybe_unused]] bool m_pwr9 = false;
[[maybe_unused]] bool m_pwr10 = false;
[[maybe_unused]] bool m_aixos = false;
[[maybe_unused]] bool m_future = false;
[[maybe_unused]] bool m_aixas = false;
[[maybe_unused]] bool m_msync = false;
};
class ArchitectureSPARC : public CapstoneArchitecture {
@@ -208,7 +341,44 @@ namespace hex::plugin::disasm {
class ArchitectureSystemZ : public CapstoneArchitecture {
public:
ArchitectureSystemZ(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::SYSZ, mode) {}
ArchitectureSystemZ(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::SYSTEMZ, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
#if CS_API_MAJOR >= 6
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.systemz.arch8"_lang, CS_MODE_SYSTEMZ_ARCH8},
{ "hex.disassembler.view.disassembler.systemz.arch9"_lang, CS_MODE_SYSTEMZ_ARCH9},
{ "hex.disassembler.view.disassembler.systemz.arch10"_lang, CS_MODE_SYSTEMZ_ARCH10},
{ "hex.disassembler.view.disassembler.systemz.arch11"_lang, CS_MODE_SYSTEMZ_ARCH11},
{ "hex.disassembler.view.disassembler.systemz.arch12"_lang, CS_MODE_SYSTEMZ_ARCH12},
{ "hex.disassembler.view.disassembler.systemz.arch13"_lang, CS_MODE_SYSTEMZ_ARCH13},
{ "hex.disassembler.view.disassembler.systemz.arch14"_lang, CS_MODE_SYSTEMZ_ARCH14},
{ "hex.disassembler.view.disassembler.systemz.z10"_lang, CS_MODE_SYSTEMZ_Z10},
{ "hex.disassembler.view.disassembler.systemz.z196"_lang, CS_MODE_SYSTEMZ_Z196},
{ "hex.disassembler.view.disassembler.systemz.zec12"_lang, CS_MODE_SYSTEMZ_ZEC12},
{ "hex.disassembler.view.disassembler.systemz.z13"_lang, CS_MODE_SYSTEMZ_Z13},
{ "hex.disassembler.view.disassembler.systemz.z14"_lang, CS_MODE_SYSTEMZ_Z14},
{ "hex.disassembler.view.disassembler.systemz.z15"_lang, CS_MODE_SYSTEMZ_Z15},
{ "hex.disassembler.view.disassembler.systemz.z16"_lang, CS_MODE_SYSTEMZ_Z16},
{ "hex.disassembler.view.disassembler.systemz.generic"_lang, CS_MODE_SYSTEMZ_GENERIC},
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(Modes[m_selectedMode].second);
#endif
}
private:
[[maybe_unused]] int m_selectedMode = 0;
};
class ArchitectureXCore : public CapstoneArchitecture {
@@ -223,8 +393,8 @@ namespace hex::plugin::disasm {
void drawSettings() override {
CapstoneArchitecture::drawSettings();
std::pair<const char *, cs_mode> modes[] = {
{"hex.disassembler.view.disassembler.m68k.000"_lang, CS_MODE_M68K_000},
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.m68k.000"_lang, CS_MODE_M68K_000},
{ "hex.disassembler.view.disassembler.m68k.010"_lang, CS_MODE_M68K_010},
{ "hex.disassembler.view.disassembler.m68k.020"_lang, CS_MODE_M68K_020},
{ "hex.disassembler.view.disassembler.m68k.030"_lang, CS_MODE_M68K_030},
@@ -232,15 +402,15 @@ namespace hex::plugin::disasm {
{ "hex.disassembler.view.disassembler.m68k.060"_lang, CS_MODE_M68K_060},
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(modes); i++) {
if (ImGui::Selectable(modes[i].first))
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(modes[m_selectedMode].second);
m_mode = cs_mode(Modes[m_selectedMode].second);
}
private:
@@ -258,7 +428,7 @@ namespace hex::plugin::disasm {
void drawSettings() override {
CapstoneArchitecture::drawSettings();
std::pair<const char *, cs_mode> modes[] = {
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{"hex.disassembler.view.disassembler.m680x.6301"_lang, CS_MODE_M680X_6301 },
{ "hex.disassembler.view.disassembler.m680x.6309"_lang, CS_MODE_M680X_6309 },
{ "hex.disassembler.view.disassembler.m680x.6800"_lang, CS_MODE_M680X_6800 },
@@ -271,15 +441,15 @@ namespace hex::plugin::disasm {
{ "hex.disassembler.view.disassembler.m680x.hcs08"_lang, CS_MODE_M680X_HCS08},
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(modes); i++) {
if (ImGui::Selectable(modes[i].first))
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(modes[m_selectedMode].second);
m_mode = cs_mode(Modes[m_selectedMode].second);
}
private:
@@ -291,8 +461,6 @@ namespace hex::plugin::disasm {
ArchitectureEVM(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::EVM, mode) {}
};
#if CS_API_MAJOR >= 5
class ArchitectureWASM : public CapstoneArchitecture {
public:
ArchitectureWASM(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::WASM, mode) {}
@@ -326,7 +494,7 @@ namespace hex::plugin::disasm {
void drawSettings() override {
CapstoneArchitecture::drawSettings();
std::pair<const char *, cs_mode> modes[] = {
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{"hex.disassembler.view.disassembler.mos65xx.6502"_lang, CS_MODE_MOS65XX_6502 },
{ "hex.disassembler.view.disassembler.mos65xx.65c02"_lang, CS_MODE_MOS65XX_65C02 },
{ "hex.disassembler.view.disassembler.mos65xx.w65c02"_lang, CS_MODE_MOS65XX_W65C02 },
@@ -336,15 +504,15 @@ namespace hex::plugin::disasm {
{ "hex.disassembler.view.disassembler.mos65xx.65816_long_mx"_lang, CS_MODE_MOS65XX_65816_LONG_MX},
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(modes); i++) {
if (ImGui::Selectable(modes[i].first))
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(modes[m_selectedMode].second);
m_mode = cs_mode(Modes[m_selectedMode].second);
}
private:
@@ -376,7 +544,7 @@ namespace hex::plugin::disasm {
void drawSettings() override {
CapstoneArchitecture::drawSettings();
std::pair<const char*, cs_mode> modes[] = {
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.sh.sh2"_lang, CS_MODE_SH2 },
{ "hex.disassembler.view.disassembler.sh.sh2a"_lang, CS_MODE_SH2A },
{ "hex.disassembler.view.disassembler.sh.sh3"_lang, CS_MODE_SH3 },
@@ -384,9 +552,9 @@ namespace hex::plugin::disasm {
{ "hex.disassembler.view.disassembler.sh.sh4a"_lang, CS_MODE_SH4A },
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(modes); i++) {
if (ImGui::Selectable(modes[i].first))
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
@@ -396,7 +564,7 @@ namespace hex::plugin::disasm {
ImGui::SameLine();
ImGui::Checkbox("hex.disassembler.view.disassembler.sh.dsp"_lang, &m_dsp);
m_mode = cs_mode(modes[m_selectedMode].second | (m_fpu ? CS_MODE_SHFPU : cs_mode(0)) | (m_dsp ? CS_MODE_SHDSP : cs_mode(0)));
m_mode = cs_mode(Modes[m_selectedMode].second | (m_fpu ? CS_MODE_SHFPU : cs_mode(0)) | (m_dsp ? CS_MODE_SHDSP : cs_mode(0)));
}
private:
@@ -412,7 +580,7 @@ namespace hex::plugin::disasm {
void drawSettings() override {
CapstoneArchitecture::drawSettings();
std::pair<const char*, cs_mode> modes[] = {
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.tricore.110"_lang, CS_MODE_TRICORE_110 },
{ "hex.disassembler.view.disassembler.tricore.120"_lang, CS_MODE_TRICORE_120 },
{ "hex.disassembler.view.disassembler.tricore.130"_lang, CS_MODE_TRICORE_130 },
@@ -422,21 +590,112 @@ namespace hex::plugin::disasm {
{ "hex.disassembler.view.disassembler.tricore.162"_lang, CS_MODE_TRICORE_162 },
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(modes); i++) {
if (ImGui::Selectable(modes[i].first))
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(modes[m_selectedMode].second);
m_mode = cs_mode(Modes[m_selectedMode].second);
}
private:
int m_selectedMode = 0;
};
#if CS_API_MAJOR >= 6
class ArchitectureAlpha : public CapstoneArchitecture {
public:
ArchitectureAlpha(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::ALPHA, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
}
};
class ArchitectureHPPA : public CapstoneArchitecture {
public:
ArchitectureHPPA(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::HPPA, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.hppa.1.1"_lang, CS_MODE_HPPA_11 },
{ "hex.disassembler.view.disassembler.hppa.2.0"_lang, CS_MODE_HPPA_20 },
{ "hex.disassembler.view.disassembler.hppa.2.0w"_lang, CS_MODE_HPPA_20W },
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(Modes[m_selectedMode].second);
}
private:
int m_selectedMode = 0;
};
class ArchitectureLoongArch : public CapstoneArchitecture {
public:
ArchitectureLoongArch(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::LOONGARCH, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
ImGui::RadioButton("hex.disassembler.view.disassembler.32bit"_lang, &m_mode, CS_MODE_LOONGARCH32);
ImGui::SameLine();
ImGui::RadioButton("hex.disassembler.view.disassembler.64bit"_lang, &m_mode, CS_MODE_LOONGARCH64);
}
int m_mode = CS_MODE_LOONGARCH64;
};
class ArchitectureXtensa : public CapstoneArchitecture {
public:
ArchitectureXtensa(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::XTENSA, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
constexpr static std::pair<LangConst, cs_mode> Modes[] = {
{ "hex.disassembler.view.disassembler.xtensa.esp32"_lang, CS_MODE_XTENSA_ESP32 },
{ "hex.disassembler.view.disassembler.xtensa.esp32s2"_lang, CS_MODE_XTENSA_ESP32S2 },
{ "hex.disassembler.view.disassembler.xtensa.esp8266"_lang, CS_MODE_XTENSA_ESP8266 },
};
if (ImGui::BeginCombo("hex.disassembler.view.disassembler.settings.mode"_lang, Modes[m_selectedMode].first)) {
for (u32 i = 0; i < IM_ARRAYSIZE(Modes); i++) {
if (ImGui::Selectable(Modes[i].first))
m_selectedMode = i;
}
ImGui::EndCombo();
}
m_mode = cs_mode(Modes[m_selectedMode].second);
}
private:
int m_selectedMode = 0;
};
class ArchitectureArc : public CapstoneArchitecture {
public:
ArchitectureArc(cs_mode mode = cs_mode(0)) : CapstoneArchitecture(BuiltinArchitecture::ARC, mode) {}
void drawSettings() override {
CapstoneArchitecture::drawSettings();
}
};
#endif
void registerCapstoneArchitectures() {
@@ -452,14 +711,19 @@ namespace hex::plugin::disasm {
ContentRegistry::Disassemblers::add<ArchitectureTMS320C64X>();
ContentRegistry::Disassemblers::add<ArchitectureM680X>();
ContentRegistry::Disassemblers::add<ArchitectureEVM>();
ContentRegistry::Disassemblers::add<ArchitectureWASM>();
ContentRegistry::Disassemblers::add<ArchitectureRISCV>();
ContentRegistry::Disassemblers::add<ArchitectureMOS65XX>();
ContentRegistry::Disassemblers::add<ArchitectureBPF>();
ContentRegistry::Disassemblers::add<ArchitectureSuperH>();
ContentRegistry::Disassemblers::add<ArchitectureTricore>();
#if CS_API_MAJOR >= 5
ContentRegistry::Disassemblers::add<ArchitectureWASM>();
ContentRegistry::Disassemblers::add<ArchitectureRISCV>();
ContentRegistry::Disassemblers::add<ArchitectureMOS65XX>();
ContentRegistry::Disassemblers::add<ArchitectureBPF>();
ContentRegistry::Disassemblers::add<ArchitectureSuperH>();
ContentRegistry::Disassemblers::add<ArchitectureTricore>();
#if CS_API_MAJOR >= 6
ContentRegistry::Disassemblers::add<ArchitectureAlpha>();
ContentRegistry::Disassemblers::add<ArchitectureHPPA>();
ContentRegistry::Disassemblers::add<ArchitectureLoongArch>();
ContentRegistry::Disassemblers::add<ArchitectureXtensa>();
ContentRegistry::Disassemblers::add<ArchitectureArc>();
#endif
}

3
plugins/disassembler/source/content/pl_builtin_types.cpp
View File

@@ -8,8 +8,7 @@
#include <pl/patterns/pattern.hpp>
#include <capstone/capstone.h>
#include <content/helpers/disassembler.hpp>
#include <content/helpers/capstone.hpp>
namespace hex::plugin::disasm {

2
plugins/disassembler/source/content/pl_visualizers/disassembler.cpp
View File

@@ -1,4 +1,4 @@
#include <content/helpers/disassembler.hpp>
#include <content/helpers/capstone.hpp>
#include <hex/api/localization_manager.hpp>