Add support for traps in VM Add instruction trap to enable single step scenario in debugger Remote get_state() function from thread

arr committed 9 years ago

Commit cb408a11 parent eb570d98 files · +120 −40Browse files

Showing the changes to src/vm/thread.cpp (1 of 8 files). Show all

Unified · Split

 #include <exceptions.h>
 #include <vm_memory.h>
 #include <debug.h>
+#include <utils.h>
 #include "execution_table.h"
 #include "tool_dispatch.h"
 }
 vm_registers_t::vm_registers_t(
-    const vm_thread_t &thread,
+    vm_thread_t &thread,
     vm_module_ref_t &entry)
     : current_thread_state{ vm_thread_state_t::ready }
     , current_thread_quanta{ 0 }
+    , trap_flags{ vm_trap_flags_t::none }
     , module_ref{ &entry }
     , mp_base{ entry.mp_base }
     , thread{ thread }
 {
     struct execute_with_tool_t final
     {
-        static void begin_exec_loop(vm_registers_t &registers, vm_t &)
+        static void begin_exec_loop(vm_registers_t &r, vm_t &)
         {
-            auto tool_dispatch = registers.tool_dispatch.load();
+            auto tool_dispatch = r.tool_dispatch.load();
             assert(tool_dispatch != nullptr);
-            tool_dispatch->block_if_thread_suspended(registers.thread.get_thread_id());
+            tool_dispatch->block_if_thread_suspended(r.thread.get_thread_id());
+        }
+        static void after_exec(vm_registers_t &r, vm_t &)
+        {
+            if (r.trap_flags == vm_trap_flags_t::none
+                || !util::has_flag(r.trap_flags, vm_trap_flags_t::instruction))
+                return;
+            auto tool_dispatch = r.tool_dispatch.load();
+            assert(tool_dispatch != nullptr);
+            tool_dispatch->on_trap(r, vm_trap_flags_t::instruction);
         }
     };
     struct execute_normal_t final
     {
         static void begin_exec_loop(vm_registers_t &, vm_t &) { }
+        static void after_exec(vm_registers_t &, vm_t &) { }
     };
     template<typename EXEC_DETOUR>
     void execute_impl(vm_registers_t &r, vm_t &vm)
     {
-        auto &execution_duration = r.current_thread_quanta;
+        for (; 0 != r.current_thread_quanta; --r.current_thread_quanta)
-        for (; 0 != execution_duration; --execution_duration)
         {
             EXEC_DETOUR::begin_exec_loop(r, vm);
             assert(r.stack.peek_frame() != nullptr && "Thread state should not be running with empty stack");
             vm_exec_table[opcode](r, vm);
             r.pc = r.next_pc;
+            EXEC_DETOUR::after_exec(r, vm);
             if (r.current_thread_state != vm_thread_state_t::running)
                 break;
         }
     _registers.tool_dispatch = dispatch;
 }
-vm_thread_state_t vm_thread_t::get_state() const
-{
-    return _registers.current_thread_state;
-}
 const char *vm_thread_t::get_error_message() const
 {
     return _error_message;
 const vm_registers_t& vm_thread_t::get_registers() const
 {
     return _registers;
 }