Add API function to retrieve dissassembly as vector of strings (#644)

Co-authored-by: ben <Avuxo@users.noreply.github.com>

src/dynarmic/backend/x64/a32_interface.cpp

@@ -318,8 +318,12 @@ void Jit::LoadContext(const Context& ctx) {
 }
 
 void Jit::DumpDisassembly() const {
-    const size_t size = (const char*)impl->block_of_code.getCurr() - (const char*)impl->block_of_code.GetCodeBegin();
+    const size_t size = reinterpret_cast<const char*>(impl->block_of_code.getCurr()) - reinterpret_cast<const char*>(impl->block_of_code.GetCodeBegin());
     Common::DumpDisassembledX64(impl->block_of_code.GetCodeBegin(), size);
 }
 
+std::vector<std::string> Jit::Disassemble() const {
+    const size_t size = reinterpret_cast<const char*>(impl->block_of_code.getCurr()) - reinterpret_cast<const char*>(impl->block_of_code.GetCodeBegin());
+    return Common::DisassembleX64(impl->block_of_code.GetCodeBegin(), size);
+}
 }  // namespace Dynarmic::A32

src/dynarmic/backend/x64/a64_interface.cpp

@@ -200,10 +200,15 @@ public:
     }
 
     void DumpDisassembly() const {
-        const size_t size = (const char*)block_of_code.getCurr() - (const char*)block_of_code.GetCodeBegin();
+        const size_t size = reinterpret_cast<const char*>(block_of_code.getCurr()) - reinterpret_cast<const char*>(block_of_code.GetCodeBegin());
         Common::DumpDisassembledX64(block_of_code.GetCodeBegin(), size);
     }
 
+    std::vector<std::string> Disassemble() const {
+        const size_t size = reinterpret_cast<const char*>(block_of_code.getCurr()) - reinterpret_cast<const char*>(block_of_code.GetCodeBegin());
+        return Common::DisassembleX64(block_of_code.GetCodeBegin(), size);
+    }
+
 private:
     static CodePtr GetCurrentBlockThunk(void* thisptr) {
         Jit::Impl* this_ = static_cast<Jit::Impl*>(thisptr);
@@ -402,4 +407,8 @@ void Jit::DumpDisassembly() const {
     return impl->DumpDisassembly();
 }
 
+std::vector<std::string> Jit::Disassemble() const {
+    return impl->Disassemble();
+}
+
 }  // namespace Dynarmic::A64

src/dynarmic/common/fp/unpacked.h

@@ -46,7 +46,7 @@ constexpr FPUnpacked ToNormalized(bool sign, int exponent, u64 value) {
     const int highest_bit = Common::HighestSetBit(value);
     const int offset = static_cast<int>(normalized_point_position) - highest_bit;
     value <<= offset;
-    exponent -= offset - normalized_point_position;
+    exponent -= offset - static_cast<int>(normalized_point_position);
     return {sign, exponent, value};
 }
 

src/dynarmic/common/x64_disassemble.cpp

@@ -21,15 +21,36 @@ void DumpDisassembledX64(const void* ptr, size_t size) {
 
     size_t offset = 0;
     ZydisDecodedInstruction instruction;
-    while (ZYAN_SUCCESS(ZydisDecoderDecodeBuffer(&decoder, (const char*)ptr + offset, size - offset, &instruction))) {
+    while (ZYAN_SUCCESS(ZydisDecoderDecodeBuffer(&decoder, static_cast<const char*>(ptr) + offset, size - offset, &instruction))) {
         fmt::print("{:016x}  ", (u64)ptr + offset);
 
         char buffer[256];
-        ZydisFormatterFormatInstruction(&formatter, &instruction, buffer, sizeof(buffer), (u64)ptr + offset);
+        ZydisFormatterFormatInstruction(&formatter, &instruction, buffer, sizeof(buffer), reinterpret_cast<u64>(ptr) + offset);
         puts(buffer);
 
         offset += instruction.length;
     }
 }
 
+std::vector<std::string> DisassembleX64(const void* ptr, size_t size) {
+    std::vector<std::string> result;
+    ZydisDecoder decoder;
+    ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_ADDRESS_WIDTH_64);
+
+    ZydisFormatter formatter;
+    ZydisFormatterInit(&formatter, ZYDIS_FORMATTER_STYLE_INTEL);
+
+    size_t offset = 0;
+    ZydisDecodedInstruction instruction;
+    while (ZYAN_SUCCESS(ZydisDecoderDecodeBuffer(&decoder, static_cast<const char*>(ptr) + offset, size - offset, &instruction))) {
+        char buffer[256];
+        ZydisFormatterFormatInstruction(&formatter, &instruction, buffer, sizeof(buffer), reinterpret_cast<u64>(ptr) + offset);
+
+        result.push_back(fmt::format("{:016x}  {}", (u64)ptr + offset, buffer));
+
+        offset += instruction.length;
+    }
+
+    return result;
+}
 }  // namespace Dynarmic::Common

src/dynarmic/common/x64_disassemble.h

@@ -5,10 +5,17 @@
 
 #pragma once
 
+#include <string>
+#include <vector>
+
 #include "dynarmic/common/common_types.h"
 
 namespace Dynarmic::Common {
 
 void DumpDisassembledX64(const void* ptr, size_t size);
-
+/**
+ * Disassemble `size' bytes from `ptr' and return the disassembled lines as a vector
+ * of strings.
+ */
+std::vector<std::string> DisassembleX64(const void* ptr, size_t size);
 }  // namespace Dynarmic::Common

src/dynarmic/interface/A32/a32.h

@@ -9,6 +9,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "dynarmic/interface/A32/config.h"
 
@@ -91,6 +92,12 @@ public:
     /// Debugging: Dump a disassembly all compiled code to the console.
     void DumpDisassembly() const;
 
+    /**
+     * Disassemble the instructions following the current pc and return
+     * the resulting instructions as a vector of their string representations.
+     */
+    std::vector<std::string> Disassemble() const;
+
 private:
     bool is_executing = false;
 

src/dynarmic/interface/A64/a64.h

@@ -10,6 +10,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "dynarmic/interface/A64/config.h"
 
@@ -117,6 +118,12 @@ public:
     /// Debugging: Dump a disassembly all of compiled code to the console.
     void DumpDisassembly() const;
 
+    /* 
+     * Disassemble the instructions following the current pc and return
+     * the resulting instructions as a vector of their string representations.
+     */
+    std::vector<std::string> Disassemble() const;
+
 private:
     struct Impl;
     std::unique_ptr<Impl> impl;