Change debugger options to enumeration. Alter how the debugger displays the registers. Adding a breakpoint that is already set is a no-op and simply returns the current cookie value. Fix bug in print for the Sys module - don't ignore format modifiers.

arr committed 10 years ago

Commit db76c0c1 parent f29cf0d6 files · +45 −41Browse files

Unified · Split

6 files

src/exec/debugger.cpp +16 −23
src/exec/exec.h +12 −8
src/exec/main.cpp +5 −5
src/vm/sys/print.cpp +1 −0
src/vm/sys/sys_utils.h +3 −3
src/vm/tool_dispatch.cpp +8 −2

         register_string
             << "  Thread ID:  " << r.thread.get_thread_id() << "\n"
-            << "     Module:  " << r.module_ref->module->module_name->str() << "  PC: " << r.pc << "\n"
+            << "         PC:  " << r.pc << "  Module:  " << r.module_ref->module->module_name->str() << "\n"
             << "     Opcode:  " << r.module_ref->code_section[r.pc].op << "\n";
         return register_string.str();
         if (pc < 0 || module->code_section.size() <= static_cast<std::size_t>(pc))
             throw debug_cmd_error_t{ "Invalid IP for module" };
-        try
+        cxt.dbg.breakpoint_cookies.emplace(cxt.dbg.controller->set_breakpoint(module, pc));
-        {
-            cxt.dbg.breakpoint_cookies.push_back(cxt.dbg.controller->set_breakpoint(module, pc));
-        }
-        catch (const vm_system_exception& e)
-        {
-            throw debug_cmd_error_t{ e.what() };
-        }
     }
     void cmd_breakpoint_clear(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
 std::ostream& operator<<(std::ostream &ss, const debugger_options o)
 {
-    ss << "Break on enter: " << std::boolalpha << o.break_on_enter << "\n"
+    ss << "Break on enter: " << std::boolalpha << util::has_flag(o, debugger_options::break_on_enter) << "\n"
-       << "Break on module load: " << std::boolalpha << o.break_on_module_load << "\n"
+       << "Break on module load: " << std::boolalpha << util::has_flag(o, debugger_options::break_on_module_load) << "\n"
-       << "Break on exception: " << std::boolalpha << o.break_on_exception << "\n";
+       << "Break on exception: " << std::boolalpha << util::has_flag(o, debugger_options::break_on_exception) << "\n";
     return ss;
 }
-debugger::debugger(const debugger_options &opt)
+debugger::debugger(const debugger_options opt)
     : _options{ opt }
     , _tool_id{ 0 }
     , controller{ nullptr }
     _tool_id = tool_id;
     controller = &controller_;
-    _event_cookies.push_back(controller->subscribe_event(vm_event_t::thread_begin, [](vm_event_t, vm_event_context_t &cxt)
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::thread_begin, [](vm_event_t, vm_event_context_t &cxt)
     {
         auto t = cxt.value1.thread;
         auto ss = std::stringstream{};
         debug_print_info(ss.str());
     }));
-    _event_cookies.push_back(controller->subscribe_event(vm_event_t::thread_end, [](vm_event_t, vm_event_context_t &cxt)
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::thread_end, [](vm_event_t, vm_event_context_t &cxt)
     {
         auto ss = std::stringstream{};
         ss << "Thread "
         debug_print_info(ss.str());
     }));
-    _event_cookies.push_back(controller->subscribe_event(vm_event_t::exception_raised, [&](vm_event_t, vm_event_context_t &cxt)
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::exception_raised, [&](vm_event_t, vm_event_context_t &cxt)
     {
         auto ss = std::stringstream{};
         ss << "Exception '"
         debug_print_info(ss.str());
-        if (_options.break_on_exception)
+        if (util::has_flag(_options, debugger_options::break_on_exception))
             prompt(*this, *cxt.value1.registers);
     }));
-    _event_cookies.push_back(controller->subscribe_event(vm_event_t::exception_unhandled, [&](vm_event_t, vm_event_context_t &cxt)
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::exception_unhandled, [&](vm_event_t, vm_event_context_t &cxt)
     {
         auto ss = std::stringstream{};
         ss << "Unhandled exception '"
         prompt(*this, *cxt.value1.registers);
     }));
-    _event_cookies.push_back(controller->subscribe_event(vm_event_t::module_thread_load, [&](vm_event_t, vm_event_context_t &cxt)
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::module_thread_load, [&](vm_event_t, vm_event_context_t &cxt)
     {
         auto m = (*cxt.value2.module);
         auto ss = std::stringstream{};
         // If the break on enter flag was set, it will be true
         // and the first module load will be the user entry module.
-        if (_options.break_on_enter)
+        if (util::has_flag(_options, debugger_options::break_on_enter))
         {
             // Reset the break on enter flag and set a breakpoint
             // on the entry PC for the module - 'break on enter'
-            _options.break_on_enter = false;
+            _options ^= debugger_options::break_on_enter;
             controller->set_breakpoint(m, m->header.entry_pc);
         }
-        if (_options.break_on_module_load)
+        if (util::has_flag(_options, debugger_options::break_on_module_load))
             prompt(*this, *cxt.value1.registers);
     }));
-    _event_cookies.push_back(controller->subscribe_event(vm_event_t::breakpoint, [&](vm_event_t, vm_event_context_t &cxt)
+    _event_cookies.emplace(controller->subscribe_event(vm_event_t::breakpoint, [&](vm_event_t, vm_event_context_t &cxt)
     {
         auto ss = std::stringstream{};
         ss << "Breakpoint hit";

src/exec/exec.h+12−8

 #define _DISVM_SRC_EXEC_EXEC_H_
 #include <cstdint>
-#include <vector>
+#include <unordered_set>
 #include <disvm.h>
 #include <vm_tools.h>
+#include <utils.h>
-struct debugger_options
+enum class debugger_options
 {
-    bool break_on_enter;
+    none = 0,
-    bool break_on_module_load;
+    break_on_enter = 1,
-    bool break_on_exception;
+    break_on_module_load = 2,
+    break_on_exception = 4,
 };
+DEFINE_ENUM_FLAG_OPERATORS(debugger_options);
 std::ostream& operator<<(std::ostream &ss, const debugger_options o);
 class debugger final : public disvm::runtime::vm_tool_t
 {
 public:
-    debugger(const debugger_options &);
+    debugger(const debugger_options);
 public: // vm_tool_t
     void on_load(disvm::runtime::vm_tool_controller_t &, std::size_t tool_id) override;
 public:
     disvm::runtime::vm_tool_controller_t *controller;
-    std::vector<disvm::runtime::cookie_t> breakpoint_cookies;
+    std::unordered_set<disvm::runtime::cookie_t> breakpoint_cookies;
 private:
     debugger_options _options;
     std::size_t _tool_id;
-    std::vector<disvm::runtime::cookie_t> _event_cookies;
+    std::unordered_set<disvm::runtime::cookie_t> _event_cookies;
 };
 #endif // _DISVM_SRC_EXEC_EXEC_H_

src/exec/main.cpp+5−5

@@ -195,7 +195,7 @@ struct arg_exception_t : std::runtime_error · 194 unmodified lines
195	struct exec_options	195	struct exec_options
196	{	196	{
197	exec_options()	197	exec_options()
198	: debugger{}	198	: debugger{ debugger_options::none }
199	, enabled_debugger{ false }	199	, enabled_debugger{ false }
200	, quiet_start{ false }	200	, quiet_start{ false }
201	, print_help{ false }	201	, print_help{ false }
@@ -227,7 +227,7 @@ void print_banner(const exec_options &options) · 25 unmodified lines
227	<< "System thread usage: " << options.sys_thread_count << "\n";	227	<< "System thread usage: " << options.sys_thread_count << "\n";
228		228
229	if (options.enabled_debugger)	229	if (options.enabled_debugger)
230	std::cout << options.debugger << "\n";	230	std::cout << "\n" << options.debugger << "\n";
231		231
232	std::cout << std::endl;	232	std::cout << std::endl;
233	}	233	}
@@ -268,11 +268,11 @@ void process_arg(char* arg, std::function<char *()> next, exec_options &options) · 34 unmodified lines
268	{	268	{
269	switch (arg[i])	269	switch (arg[i])
270	{	270	{
271	case 'e': options.debugger.break_on_enter = true;	271	case 'e': options.debugger \|= debugger_options::break_on_enter;
272	break;	272	break;
273	case 'm': options.debugger.break_on_module_load = true;	273	case 'm': options.debugger \|= debugger_options::break_on_module_load;
274	break;	274	break;
275	case 'x': options.debugger.break_on_exception = true;	275	case 'x': options.debugger \|= debugger_options::break_on_exception;
276	break;	276	break;
277	}	277	}
278	}	278	}

src/vm/sys/print.cpp+1−0

@@ -71,6 +71,7 @@ word_t disvm::runtime::sys::printf_to_buffer( · 70 unmodified lines
71	{	71	{
72	// Format flags	72	// Format flags
73	default:	73	default:
		74	format.push_back(static_cast<char>(c));
74	continue;	75	continue;
75	case 'b': // Print big type (64-bit)	76	case 'b': // Print big type (64-bit)
76	format.push_back('l');	77	format.push_back('l');

src/vm/sys/sys_utils.h+3−3

@@ -38,9 +38,9 @@ namespace disvm · 37 unmodified lines
38		38
39	enum class cfs_flags_t	39	enum class cfs_flags_t
40	{	40	{
41	none,	41	none = 0,
42	atomic,	42	atomic = 1,
43	ensure_create,	43	ensure_create = 2,
44	};	44	};
45		45
46	DEFINE_ENUM_FLAG_OPERATORS(cfs_flags_t);	46	DEFINE_ENUM_FLAG_OPERATORS(cfs_flags_t);

src/vm/tool_dispatch.cpp+8−2

     {
         std::lock_guard<std::mutex> lock{ _breakpoints.lock };
+        auto &pc_map = _breakpoints.original_opcodes[reinterpret_cast<std::uintptr_t>(module.get())];
+        // If the real opcode is already a breakpoint and it is known, return the current cookie.
         if (real_opcode == opcode_t::brkpt)
-            throw vm_system_exception{ "Breakpoint already set at PC" };
+        {
+            auto iter = pc_map.find(pc);
+            if (iter != pc_map.cend())
+                return iter->second.second;
+        }
         const auto cookie_id = _breakpoints.cookie_counter++;
         _breakpoints.cookie_to_details[cookie_id] = { module, pc, real_opcode };
         // Record the original opcode
-        auto &pc_map = _breakpoints.original_opcodes[reinterpret_cast<std::uintptr_t>(module.get())];
         pc_map[pc] = std::make_pair(real_opcode, cookie_id);
         // Replace the current opcode with breakpoint