plan9-archive/DisVM-cpp

src/exec/debugger.cpp+47−19

 #include <string>
 #include <algorithm>
 #include <map>
-#include <unordered_set>
+#include <set>
 #include <utils.h>
 #include <vm_memory.h>
 #include <vm_asm.h>
     {
         static std::string last_successful_cmd_option;
-        dbg_cmd_cxt_t(debugger &d, const vm_registers_t &r)
+        dbg_cmd_cxt_t(debugger &d, vm_registers_t &r, bool transient_context = false)
             : dbg{ d }
             , exit_break{ false }
+            , current_register{ &r }
             , initial_register{ r }
+            , transient_context{ transient_context }
             , vm{ d.controller->get_vm_instance() }
         {
-            current_register = &initial_register;
             last_successful_cmd = dbg.get_option(last_successful_cmd_option);
         }
         ~dbg_cmd_cxt_t()
         {
-            dbg.set_option(last_successful_cmd_option, std::move(last_successful_cmd));
+            if (!transient_context)
+                dbg.set_option(last_successful_cmd_option, std::move(last_successful_cmd));
         }
+        const bool transient_context;
         bool exit_break;
         std::string last_successful_cmd;
         debugger &dbg;
         const vm_t &vm;
         const vm_registers_t *current_register;
-        const vm_registers_t &initial_register;
+        vm_registers_t &initial_register;
     };
     std::string dbg_cmd_cxt_t::last_successful_cmd_option = "last_successful_cmd";
         if (!r.module_ref->is_builtin_module())
         {
-            assert(r.pc < static_cast<word_t>(r.module_ref->code_section.size()));
+            assert(static_cast<std::size_t>(r.pc) < r.module_ref->code_section.size());
             const auto &op = r.module_ref->code_section[r.pc].op;
             register_string
                 << "\n        Src:  " << op.source
         cxt.exit_break = true;
     }
+    void cmd_step(const std::vector<std::string> &, dbg_cmd_cxt_t &cxt)
+    {
+        cxt.dbg.controller->set_thread_trap_flag(*cxt.current_register, vm_trap_flags_t::instruction);
+        cxt.exit_break = true;
+    }
     void cmd_term(const std::vector<std::string> &, dbg_cmd_cxt_t &)
     {
         throw vm_term_request{};
     {
         auto msg = std::stringstream{};
         for (auto t : cxt.vm.get_scheduler_control().get_all_threads())
-            msg << "  " << std::setw(5) << t->get_thread_id() << "  -  " << t->get_state() << "\n";
+            msg << "  " << std::setw(5) << t->get_thread_id() << "  -  " << t->get_registers().current_thread_state << "\n";
         debug_print_info(msg.str());
     }
             << console_modifiers::reset_all;
     }
-    std::unordered_set<std::string> dbg_options =
+    std::set<std::string> dbg_options =
     {
-        { "bp-cmd" }
+        { "bp-cmd" },
+        { "step-cmd" }
     };
     void set_value_cmd(const std::vector<std::string> &args, dbg_cmd_cxt_t &cxt)
     const dbg_cmd_t cmds[] =
     {
         { "c", "Continue", nullptr, nullptr, cmd_continue },
+        { "s", "Step over", nullptr, nullptr, cmd_step },
         { "term", "Terminate the VM instance", nullptr, nullptr, cmd_term },
         { "r", "Print registers", nullptr, nullptr, cmd_print_registers },
         }
     }
-    void prompt(debugger &debugger, const vm_registers_t &r)
+    void prompt(debugger &debugger, vm_registers_t &r)
     {
         debugger.controller->suspend_all_threads();
-        std::cout
+        if (debugger.first_break)
-            << console_modifiers::green_font
+        {
-            << console_modifiers::bold
+            debugger.first_break = false;
-            << "'?' for help\n"
+            std::cout
-            << console_modifiers::reset_all;
+                << console_modifiers::green_font
+                << console_modifiers::bold
+                << "'?' for help\n"
+                << console_modifiers::reset_all;
+        }
         std::string cmd;
     : _options{ opt }
     , _tool_id{ 0 }
     , controller{ nullptr }
+    , first_break{ true }
 { }
 std::vector<std::string> debugger::resolve_to_function_source_line(
         debug_print_info(ss.str());
-        auto bp_cmd = get_option({ "bp-cmd" });
+        auto cmd = get_option({ "bp-cmd" });
-        if (!bp_cmd.empty())
+        if (!cmd.empty())
+        {
+            dbg_cmd_cxt_t dbg_cxt{ *this, *cxt.value1.registers, true };
+            execute_single_command(dbg_cxt, std::move(cmd));
+        }
+        prompt(*this, *cxt.value1.registers);
+    }));
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::trap, [&](vm_event_t, vm_event_context_t &cxt)
+    {
+        auto cmd = get_option({ "step-cmd" });
+        if (!cmd.empty())
         {
-            dbg_cmd_cxt_t dbg_cxt{ *this, *cxt.value1.registers };
+            dbg_cmd_cxt_t dbg_cxt{ *this, *cxt.value1.registers, true };
-            execute_single_command(dbg_cxt, std::move(bp_cmd));
+            execute_single_command(dbg_cxt, std::move(cmd));
         }
         prompt(*this, *cxt.value1.registers);

src/exec/exec.h+1−0

@@ -61,6 +61,7 @@ public: // vm_tool_t · 60 unmodified lines
61	public:	61	public:
62	disvm::runtime::vm_tool_controller_t *controller;	62	disvm::runtime::vm_tool_controller_t *controller;
63	std::unordered_set<disvm::runtime::cookie_t> breakpoint_cookies;	63	std::unordered_set<disvm::runtime::cookie_t> breakpoint_cookies;
		64	bool first_break;
64		65
65	private:	66	private:
66	void load_symbols(const disvm::loaded_vm_module_t &);	67	void load_symbols(const disvm::loaded_vm_module_t &);

src/include/runtime.h+12−6

             const vm_string_t &exception_id);
         // VM thread states
-        enum class vm_thread_state_t : uint16_t
+        enum class vm_thread_state_t : uint8_t
         {
             unknown = 0,
             broken,   // thread crashed - the scheduler is free to terminate the entire VM if any thread enters this state.
         };
+        // VM trap flags
+        enum class vm_trap_flags_t : uint8_t
+        {
+            none = 0,
+            instruction = 1 << 0,
+        };
         // Forward declaration
         class vm_thread_t;
         class vm_tool_dispatch_t;
         {
         public:
             vm_registers_t(
-                const vm_thread_t &thread,
+                vm_thread_t &thread,
                 vm_module_ref_t &entry);
             ~vm_registers_t();
-            const vm_thread_t &thread;
+            vm_thread_t &thread;
             std::atomic<vm_tool_dispatch_t *> tool_dispatch;
             vm_stack_t stack;  // Frame pointer access (FP)
             vm_pc_t pc;  // Current Program counter (Index into module code section)
             vm_module_ref_t *module_ref;  // Module reference
             vm_request_mutex_t request_mutex;
-            vm_thread_state_t current_thread_state;
             uint16_t current_thread_quanta;
+            vm_thread_state_t current_thread_state;
+            vm_trap_flags_t trap_flags;
             pointer_t src;
             pointer_t mid;
             // this vm thread.
             void set_tool_dispatch(vm_tool_dispatch_t *dispatch);
-            vm_thread_state_t get_state() const;
             // This function will only return a non-null
             // value if this thread is in the broken state.
             const char *get_error_message() const;

src/include/vm_tools.h+5−0

         union vm_context_value_t
         {
             cookie_t cookie;
+            vm_trap_flags_t trap;
             std::shared_ptr<vm_module_t> *module; // Note this is a pointer to std::shared_ptr<>
             vm_registers_t *registers;
             const vm_thread_t *thread;
             breakpoint,          // value1: vm_registers_t
                                  // value2: cookie_t - cookie of breakpoint. '0' indicates the breakpoint was inserted by the VM or compiler.
+            trap,                // value1: vm_registers_t - The trap flag is unset prior to the event be fired.
+                                 // value2: vm_trap_flags_t
         };
         using vm_event_callback_t = std::function<void(vm_event_t, vm_event_context_t &)>;
             // Manipulate thread execution
             virtual void suspend_all_threads() = 0;
             virtual void resume_all_threads() = 0;
+            virtual void set_thread_trap_flag(const vm_registers_t &, vm_trap_flags_t flag) = 0;
         };
     }
 }

src/vm/scheduler.cpp+3−3

@@ -130,7 +130,7 @@ vm_scheduler_control_t &default_scheduler_t::get_controller() const · 129 unmodified lines
130	const vm_thread_t& default_scheduler_t::schedule_thread(std::unique_ptr<runtime::vm_thread_t> thread)	130	const vm_thread_t& default_scheduler_t::schedule_thread(std::unique_ptr<runtime::vm_thread_t> thread)
131	{	131	{
132	assert(thread != nullptr);	132	assert(thread != nullptr);
133	if (thread->get_state() != vm_thread_state_t::ready)	133	if (thread->get_registers().current_thread_state != vm_thread_state_t::ready)
134	throw vm_system_exception{ "Scheduled thread in invalid state" };	134	throw vm_system_exception{ "Scheduled thread in invalid state" };
135		135
136	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())	136	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
@@ -284,7 +284,7 @@ std::shared_ptr<default_scheduler_t::thread_instance_t> default_scheduler_t::nex · 147 unmodified lines
284	// Check if the passed in thread should be enqueued	284	// Check if the passed in thread should be enqueued
285	if (prev_thread != nullptr)	285	if (prev_thread != nullptr)
286	{	286	{
287	const auto current_state = prev_thread->vm_thread->get_state();	287	const auto current_state = prev_thread->vm_thread->get_registers().current_thread_state;
288		288
289	// This system thread releases ownership of the vm thread after it has been enqueued	289	// This system thread releases ownership of the vm thread after it has been enqueued
290	std::lock_guard<std::mutex> vm_thread_ownership{ prev_thread->system_thread_ownership, std::adopt_lock };	290	std::lock_guard<std::mutex> vm_thread_ownership{ prev_thread->system_thread_ownership, std::adopt_lock };
@@ -367,7 +367,7 @@ void default_scheduler_t::perform_gc(bool is_gc_thread, std::unique_lock<std::mu · 76 unmodified lines
367	for (auto &p : _all_vm_threads)	367	for (auto &p : _all_vm_threads)
368	{	368	{
369	auto &vm_thread = p.second->vm_thread;	369	auto &vm_thread = p.second->vm_thread;
370	if (vm_thread->get_state() != vm_thread_state_t::broken)	370	if (vm_thread->get_registers().current_thread_state != vm_thread_state_t::broken)
371	result.push_back(vm_thread);	371	result.push_back(vm_thread);
372	}	372	}
373		373

src/vm/thread.cpp+23−12

 #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;
 }

src/vm/tool_dispatch.cpp+25−0

@@ -92,6 +92,22 @@ std::size_t vm_tool_dispatch_t::unload_tool(std::size_t tool_id) · 91 unmodified lines
92	return _tools.size();	92	return _tools.size();
93	}	93	}
94		94
		95	namespace
		96	{
		97	DEFINE_ENUM_FLAG_OPERATORS(vm_trap_flags_t);
		98	}
		99
		100	void vm_tool_dispatch_t::on_trap(vm_registers_t &r, vm_trap_flags_t f)
		101	{
		102	vm_event_context_t cxt{};
		103	cxt.value1.registers = &r;
		104	cxt.value2.trap = f;
		105
		106	// Clear the trap flag
		107	r.trap_flags &= ~f;
		108	_events.fire_event_callbacks(vm_event_t::trap, cxt);
		109	}
		110
95	opcode_t vm_tool_dispatch_t::on_breakpoint(vm_registers_t &r)	111	opcode_t vm_tool_dispatch_t::on_breakpoint(vm_registers_t &r)
96	{	112	{
97	opcode_t original_op;	113	opcode_t original_op;
@@ -361,6 +377,15 @@ void vm_tool_dispatch_t::resume_all_threads() · 263 unmodified lines
361	_threads_resume.notify_all();	377	_threads_resume.notify_all();
362	}	378	}
363		379
		380	void vm_tool_dispatch_t::set_thread_trap_flag(const vm_registers_t &r, vm_trap_flags_t flag)
		381	{
		382	std::lock_guard<std::mutex> suspend_lock{ _threads_resume_lock };
		383	if (!_threads_suspended)
		384	throw vm_system_exception{ "Unable to set thread trap flag while threads are not suspended" };
		385
		386	const_cast<vm_trap_flags_t &>(r.trap_flags) \|= flag;
		387	}
		388
364	std::tuple<opcode_t, cookie_t> vm_tool_dispatch_t::get_original_opcode_and_cookie(const vm_registers_t &r)	389	std::tuple<opcode_t, cookie_t> vm_tool_dispatch_t::get_original_opcode_and_cookie(const vm_registers_t &r)
365	{	390	{
366	const auto module = r.module_ref->module.get();	391	const auto module = r.module_ref->module.get();

src/vm/tool_dispatch.h+4−0

             // Unloads the tool associated with the supplied ID and returns the current tool count
             std::size_t unload_tool(std::size_t tool_id);
+            // Callback for a trap event.
+            void on_trap(vm_registers_t &r, vm_trap_flags_t f);
             // Callback on a breakpoint event.
             // Returns opcode that was replaced by breakpoint opcode.
             opcode_t on_breakpoint(vm_registers_t &r);
             void suspend_all_threads() override;
             void resume_all_threads() override;
+            void set_thread_trap_flag(const vm_registers_t &, vm_trap_flags_t flag) override;
         private:
             std::tuple<opcode_t, cookie_t> get_original_opcode_and_cookie(const vm_registers_t &r);