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

@@ -139,7 +139,7 @@ namespace · 138 unmodified lines
139	139
140	140	register_string
141	141	<< " Thread ID: " << r.thread.get_thread_id() << "\n"
142		− << " Module: " << r.module_ref->module->module_name->str() << " PC: " << r.pc << "\n"
	142	+ << " PC: " << r.pc << " Module: " << r.module_ref->module->module_name->str() << "\n"
143	143	<< " Opcode: " << r.module_ref->code_section[r.pc].op << "\n";
144	144
145	145	return register_string.str();
@@ -389,14 +389,7 @@ namespace · 243 unmodified lines
389	389	if (pc < 0 \|\| module->code_section.size() <= static_cast<std::size_t>(pc))
390	390	throw debug_cmd_error_t{ "Invalid IP for module" };
391	391
392		− try
393		− {
394		− cxt.dbg.breakpoint_cookies.push_back(cxt.dbg.controller->set_breakpoint(module, pc));
395		− }
396		− catch (const vm_system_exception& e)
397		− {
398		− throw debug_cmd_error_t{ e.what() };
399		− }
	392	+ cxt.dbg.breakpoint_cookies.emplace(cxt.dbg.controller->set_breakpoint(module, pc));
400	393	}
401	394
402	395	void cmd_breakpoint_clear(const std::vector<std::string> &a, dbg_cmd_cxt_t &cxt)
@@ -880,14 +873,14 @@ namespace · 477 unmodified lines
880	873
881	874	std::ostream& operator<<(std::ostream &ss, const debugger_options o)
882	875	{
883		− ss << "Break on enter: " << std::boolalpha << o.break_on_enter << "\n"
884		− << "Break on module load: " << std::boolalpha << o.break_on_module_load << "\n"
885		− << "Break on exception: " << std::boolalpha << o.break_on_exception << "\n";
	876	+ ss << "Break on enter: " << std::boolalpha << util::has_flag(o, debugger_options::break_on_enter) << "\n"
	877	+ << "Break on module load: " << std::boolalpha << util::has_flag(o, debugger_options::break_on_module_load) << "\n"
	878	+ << "Break on exception: " << std::boolalpha << util::has_flag(o, debugger_options::break_on_exception) << "\n";
886	879
887	880	return ss;
888	881	}
889	882
890		−debugger::debugger(const debugger_options &opt)
	883	+debugger::debugger(const debugger_options opt)
891	884	: _options{ opt }
892	885	, _tool_id{ 0 }
893	886	, controller{ nullptr }
@@ -898,7 +891,7 @@ void debugger::on_load(vm_tool_controller_t &controller_, std::size_t tool_id) · 4 unmodified lines
898	891	_tool_id = tool_id;
899	892	controller = &controller_;
900	893
901		− _event_cookies.push_back(controller->subscribe_event(vm_event_t::thread_begin, [](vm_event_t, vm_event_context_t &cxt)
	894	+ _event_cookies.emplace(controller->subscribe_event(vm_event_t::thread_begin, [](vm_event_t, vm_event_context_t &cxt)
902	895	{
903	896	auto t = cxt.value1.thread;
904	897	auto ss = std::stringstream{};
@@ -912,7 +905,7 @@ void debugger::on_load(vm_tool_controller_t &controller_, std::size_t tool_id) · 7 unmodified lines
912	905	debug_print_info(ss.str());
913	906	}));
914	907
915		− _event_cookies.push_back(controller->subscribe_event(vm_event_t::thread_end, [](vm_event_t, vm_event_context_t &cxt)
	908	+ _event_cookies.emplace(controller->subscribe_event(vm_event_t::thread_end, [](vm_event_t, vm_event_context_t &cxt)
916	909	{
917	910	auto ss = std::stringstream{};
918	911	ss << "Thread "
@@ -922,7 +915,7 @@ void debugger::on_load(vm_tool_controller_t &controller_, std::size_t tool_id) · 3 unmodified lines
922	915	debug_print_info(ss.str());
923	916	}));
924	917
925		− _event_cookies.push_back(controller->subscribe_event(vm_event_t::exception_raised, [&](vm_event_t, vm_event_context_t &cxt)
	918	+ _event_cookies.emplace(controller->subscribe_event(vm_event_t::exception_raised, [&](vm_event_t, vm_event_context_t &cxt)
926	919	{
927	920	auto ss = std::stringstream{};
928	921	ss << "Exception '"
@@ -931,11 +924,11 @@ void debugger::on_load(vm_tool_controller_t &controller_, std::size_t tool_id) · 2 unmodified lines
931	924
932	925	debug_print_info(ss.str());
933	926
934		− if (_options.break_on_exception)
	927	+ if (util::has_flag(_options, debugger_options::break_on_exception))
935	928	prompt(this, cxt.value1.registers);
936	929	}));
937	930
938		− _event_cookies.push_back(controller->subscribe_event(vm_event_t::exception_unhandled, [&](vm_event_t, vm_event_context_t &cxt)
	931	+ _event_cookies.emplace(controller->subscribe_event(vm_event_t::exception_unhandled, [&](vm_event_t, vm_event_context_t &cxt)
939	932	{
940	933	auto ss = std::stringstream{};
941	934	ss << "Unhandled exception '"
@@ -946,7 +939,7 @@ void debugger::on_load(vm_tool_controller_t &controller_, std::size_t tool_id) · 4 unmodified lines
946	939	prompt(this, cxt.value1.registers);
947	940	}));
948	941
949		− _event_cookies.push_back(controller->subscribe_event(vm_event_t::module_thread_load, [&](vm_event_t, vm_event_context_t &cxt)
	942	+ _event_cookies.emplace(controller->subscribe_event(vm_event_t::module_thread_load, [&](vm_event_t, vm_event_context_t &cxt)
950	943	{
951	944	auto m = (*cxt.value2.module);
952	945	auto ss = std::stringstream{};
@@ -961,19 +954,19 @@ void debugger::on_load(vm_tool_controller_t &controller_, std::size_t tool_id) · 8 unmodified lines
961	954
962	955	// If the break on enter flag was set, it will be true
963	956	// and the first module load will be the user entry module.
964		− if (_options.break_on_enter)
	957	+ if (util::has_flag(_options, debugger_options::break_on_enter))
965	958	{
966	959	// Reset the break on enter flag and set a breakpoint
967	960	// on the entry PC for the module - 'break on enter'
968		− _options.break_on_enter = false;
	961	+ _options ^= debugger_options::break_on_enter;
969	962	controller->set_breakpoint(m, m->header.entry_pc);
970	963	}
971	964
972		− if (_options.break_on_module_load)
	965	+ if (util::has_flag(_options, debugger_options::break_on_module_load))
973	966	prompt(this, cxt.value1.registers);
974	967	}));
975	968
976		− _event_cookies.push_back(controller->subscribe_event(vm_event_t::breakpoint, [&](vm_event_t, vm_event_context_t &cxt)
	969	+ _event_cookies.emplace(controller->subscribe_event(vm_event_t::breakpoint, [&](vm_event_t, vm_event_context_t &cxt)
977	970	{
978	971	auto ss = std::stringstream{};
979	972	ss << "Breakpoint hit";

src/exec/exec.h+12−8

@@ -8,23 +8,27 @@ · 7 unmodified lines
8	8	#define _DISVM_SRC_EXEC_EXEC_H_
9	9
10	10	#include <cstdint>
11		−#include <vector>
	11	+#include <unordered_set>
12	12	#include <disvm.h>
13	13	#include <vm_tools.h>
	14	+#include <utils.h>
14	15
15		−struct debugger_options
	16	+enum class debugger_options
16	17	{
17		− bool break_on_enter;
18		− bool break_on_module_load;
19		− bool break_on_exception;
	18	+ none = 0,
	19	+ break_on_enter = 1,
	20	+ break_on_module_load = 2,
	21	+ break_on_exception = 4,
20	22	};
21	23
	24	+DEFINE_ENUM_FLAG_OPERATORS(debugger_options);
	25	+
22	26	std::ostream& operator<<(std::ostream &ss, const debugger_options o);
23	27
24	28	class debugger final : public disvm::runtime::vm_tool_t
25	29	{
26	30	public:
27		− debugger(const debugger_options &);
	31	+ debugger(const debugger_options);
28	32
29	33	public: // vm_tool_t
30	34	void on_load(disvm::runtime::vm_tool_controller_t &, std::size_t tool_id) override;
@@ -33,12 +37,12 @@ public: // vm_tool_t · 2 unmodified lines
33	37
34	38	public:
35	39	disvm::runtime::vm_tool_controller_t *controller;
36		− std::vector<disvm::runtime::cookie_t> breakpoint_cookies;
	40	+ std::unordered_set<disvm::runtime::cookie_t> breakpoint_cookies;
37	41
38	42	private:
39	43	debugger_options _options;
40	44	std::size_t _tool_id;
41		− std::vector<disvm::runtime::cookie_t> _event_cookies;
	45	+ std::unordered_set<disvm::runtime::cookie_t> _event_cookies;
42	46	};
43	47
44	48	#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	195	struct exec_options
196	196	{
197	197	exec_options()
198		− : debugger{}
	198	+ : debugger{ debugger_options::none }
199	199	, enabled_debugger{ false }
200	200	, quiet_start{ false }
201	201	, print_help{ false }
@@ -227,7 +227,7 @@ void print_banner(const exec_options &options) · 25 unmodified lines
227	227	<< "System thread usage: " << options.sys_thread_count << "\n";
228	228
229	229	if (options.enabled_debugger)
230		− std::cout << options.debugger << "\n";
	230	+ std::cout << "\n" << options.debugger << "\n";
231	231
232	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	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	272	break;
273		− case 'm': options.debugger.break_on_module_load = true;
	273	+ case 'm': options.debugger \|= debugger_options::break_on_module_load;
274	274	break;
275		− case 'x': options.debugger.break_on_exception = true;
	275	+ case 'x': options.debugger \|= debugger_options::break_on_exception;
276	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	72	// Format flags
73	73	default:
	74	+ format.push_back(static_cast<char>(c));
74	75	continue;
75	76	case 'b': // Print big type (64-bit)
76	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	39	enum class cfs_flags_t
40	40	{
41		− none,
42		− atomic,
43		− ensure_create,
	41	+ none = 0,
	42	+ atomic = 1,
	43	+ ensure_create = 2,
44	44	};
45	45
46	46	DEFINE_ENUM_FLAG_OPERATORS(cfs_flags_t);

src/vm/tool_dispatch.cpp+8−2

@@ -245,8 +245,15 @@ cookie_t vm_tool_dispatch_t::set_breakpoint(std::shared_ptr<vm_module_t> module, · 244 unmodified lines
245	245
246	246	{
247	247	std::lock_guard<std::mutex> lock{ _breakpoints.lock };
	248	+ auto &pc_map = _breakpoints.original_opcodes[reinterpret_cast<std::uintptr_t>(module.get())];
	249	+
	250	+ // If the real opcode is already a breakpoint and it is known, return the current cookie.
248	251	if (real_opcode == opcode_t::brkpt)
249		− throw vm_system_exception{ "Breakpoint already set at PC" };
	252	+ {
	253	+ auto iter = pc_map.find(pc);
	254	+ if (iter != pc_map.cend())
	255	+ return iter->second.second;
	256	+ }
250	257
251	258	const auto cookie_id = _breakpoints.cookie_counter++;
252	259
@@ -254,7 +261,6 @@ cookie_t vm_tool_dispatch_t::set_breakpoint(std::shared_ptr<vm_module_t> module, · 1 unmodified line
254	261	_breakpoints.cookie_to_details[cookie_id] = { module, pc, real_opcode };
255	262
256	263	// Record the original opcode
257		− auto &pc_map = _breakpoints.original_opcodes[reinterpret_cast<std::uintptr_t>(module.get())];
258	264	pc_map[pc] = std::make_pair(real_opcode, cookie_id);
259	265
260	266	// Replace the current opcode with breakpoint