Refactor emulator interface

src/emulator/hook_interface.hpp

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "memory_permission.hpp"
+
+#include <cstddef>
+#include <cassert>
+#include <functional>
+
+struct emulator_hook;
+
+using memory_operation = memory_permission;
+
+enum class instruction_hook_continuation : bool
+{
+    run_instruction = false,
+    skip_instruction = true,
+};
+
+enum class memory_violation_continuation : bool
+{
+    stop = false,
+    resume = true,
+};
+
+enum class memory_violation_type : uint8_t
+{
+    unmapped,
+    protection,
+};
+
+struct basic_block
+{
+    uint64_t address;
+    size_t instruction_count;
+    size_t size;
+};
+
+using edge_generation_hook_callback =
+    std::function<void(const basic_block& current_block, const basic_block& previous_block)>;
+using basic_block_hook_callback = std::function<void(const basic_block& block)>;
+
+using instruction_hook_callback = std::function<instruction_hook_continuation()>;
+
+using interrupt_hook_callback = std::function<void(int interrupt)>;
+using simple_memory_hook_callback = std::function<void(uint64_t address, size_t size, uint64_t value)>;
+using complex_memory_hook_callback =
+    std::function<void(uint64_t address, size_t size, uint64_t value, memory_operation operation)>;
+using memory_violation_hook_callback = std::function<memory_violation_continuation(
+    uint64_t address, size_t size, memory_operation operation, memory_violation_type type)>;
+
+class hook_interface
+{
+  public:
+    virtual ~hook_interface() = default;
+
+    virtual emulator_hook* hook_memory_violation(uint64_t address, size_t size,
+                                                 memory_violation_hook_callback callback) = 0;
+
+    virtual emulator_hook* hook_memory_access(uint64_t address, size_t size, memory_operation filter,
+                                              complex_memory_hook_callback callback) = 0;
+    virtual emulator_hook* hook_instruction(int instruction_type, instruction_hook_callback callback) = 0;
+
+    virtual emulator_hook* hook_interrupt(interrupt_hook_callback callback) = 0;
+
+    virtual emulator_hook* hook_edge_generation(edge_generation_hook_callback callback) = 0;
+    virtual emulator_hook* hook_basic_block(basic_block_hook_callback callback) = 0;
+
+    virtual void delete_hook(emulator_hook* hook) = 0;
+
+    emulator_hook* hook_memory_violation(memory_violation_hook_callback callback)
+    {
+        return this->hook_memory_violation(0, std::numeric_limits<size_t>::max(), std::move(callback));
+    }
+
+    emulator_hook* hook_memory_read(const uint64_t address, const size_t size, simple_memory_hook_callback callback)
+    {
+        return this->hook_simple_memory_access(address, size, std::move(callback), memory_operation::read);
+    }
+
+    emulator_hook* hook_memory_write(const uint64_t address, const size_t size, simple_memory_hook_callback callback)
+    {
+        return this->hook_simple_memory_access(address, size, std::move(callback), memory_operation::write);
+    }
+
+    emulator_hook* hook_memory_execution(const uint64_t address, const size_t size,
+                                         simple_memory_hook_callback callback)
+    {
+        return this->hook_simple_memory_access(address, size, std::move(callback), memory_operation::exec);
+    }
+
+  private:
+    emulator_hook* hook_simple_memory_access(const uint64_t address, const size_t size,
+                                             simple_memory_hook_callback callback, const memory_operation operation)
+    {
+        assert((static_cast<uint8_t>(operation) & (static_cast<uint8_t>(operation) - 1)) == 0);
+        return this->hook_memory_access(address, size, operation,
+                                        [c = std::move(callback)](const uint64_t a, const size_t s,
+                                                                  const uint64_t value,
+                                                                  memory_operation) { c(a, s, value); });
+    }
+};