plan9-archive/DisVM-cpp

src/exec/debugger.cpp+10−3

@@ -322,8 +322,15 @@ namespace · 321 unmodified lines
322	{	322	{
323	auto msg = std::stringstream{};	323	auto msg = std::stringstream{};
324	msg << "Modules:\n";	324	msg << "Modules:\n";
325	for (auto m : cxt.vm.get_loaded_modules())	325
326	msg << " " << m->module_name->str() << "\n";	326	cxt.vm.enum_loaded_modules([&msg](const loaded_vm_module_t &m)
		327	{
		328	auto module_instance = m.module.lock();
		329	if (module_instance == nullptr)
		330	return;
		331
		332	msg << std::setw(24) << module_instance->module_name->str() << std::setw(0) << " " << m.origin->str() << "\n";
		333	});
327		334
328	debug_print_info(msg.str());	335	debug_print_info(msg.str());
329	}	336	}
@@ -625,7 +632,7 @@ namespace · 295 unmodified lines
625	{ "r", "Print registers", nullptr, nullptr, cmd_print_registers },	632	{ "r", "Print registers", nullptr, nullptr, cmd_print_registers },
626	{ "t", "Print all threads", nullptr, nullptr, cmd_print_threads },	633	{ "t", "Print all threads", nullptr, nullptr, cmd_print_threads },
627	{ "m", "Print all loaded modules", nullptr, nullptr, cmd_print_modules },	634	{ "m", "Print all loaded modules", nullptr, nullptr, cmd_print_modules },
628	{ "sw", "Stack walk/back trace", "bt ([0-9]+\|\\)?", "bt, bt 34, bt ", cmd_stacktrace },	635	{ "bt", "Stack walk/back trace for the current or supplied thread", "bt ([0-9]+\|\\)?", "bt, bt 34, bt ", cmd_stacktrace },
629	{ "st", "Switch to thread", "st [0-9]+", "st 42", cmd_switchthread },	636	{ "st", "Switch to thread", "st [0-9]+", "st 42", cmd_switchthread },
630	{ "d", "Disassemble the next/previous N instructions", "d (-?[0-9]+)?", "d, d -4, d 5", cmd_disassemble },	637	{ "d", "Disassemble the next/previous N instructions", "d (-?[0-9]+)?", "d, d -4, d 5", cmd_disassemble },
631	{ "x", "Examine memory", "x [mp\|fp] [0-9]+ ([0-9]+)?", "x mp 3, x fp 20 6", cmd_examine },	638	{ "x", "Examine memory", "x [mp\|fp] [0-9]+ ([0-9]+)?", "x mp 3, x fp 20 6", cmd_examine },

src/include/disvm.h+19−22

         const char * const label; // Optional
     };
+    // Loaded module reference
+    class loaded_vm_module_t final
+    {
+    public:
+        // Origin of module
+        std::unique_ptr<runtime::vm_string_t> origin;
+        // Weak reference to a loaded module
+        std::weak_ptr<runtime::vm_module_t> module;
+    };
+    using loaded_vm_module_callback_t = std::function<void(const loaded_vm_module_t&)>;
     // Virtual machine
     class vm_t final
     {
         // Load the module at the supplied path into the virtual machine
         std::shared_ptr<runtime::vm_module_t> load_module(const char *path);
-        // Get a collection of all currently loaded modules.
+        // Enumerate all loaded modules - this can include references to modules that
-        // Note this will only include modules that have been loaded by a call to vm_t::load_module.
+        // have been unloaded due to no longer being used. If the module instance is null, the
-        std::vector<std::shared_ptr<runtime::vm_module_t>> get_loaded_modules() const;
+        // module is no longer loaded.
+        // Note this will only enumerate modules that have been loaded by a call to vm_t::load_module.
+        void enum_loaded_modules(loaded_vm_module_callback_t callback) const;
         // Access the scheduler control for this VM.
         runtime::vm_scheduler_control_t &get_scheduler_control() const;
     private:
         const runtime::vm_thread_t &schedule_thread(std::unique_ptr<runtime::vm_thread_t> thread);
-        // Loaded module reference
+        using loaded_modules_t = std::forward_list<loaded_vm_module_t>;
-        class loaded_module_t final
-        {
-        public:
-            loaded_module_t(std::unique_ptr<runtime::vm_string_t> origin, std::shared_ptr<runtime::vm_module_t> module);
-            loaded_module_t(const loaded_module_t &) = delete;
-            loaded_module_t &operator=(const loaded_module_t &) = delete;
-            loaded_module_t(loaded_module_t &&);
-            ~loaded_module_t();
-            // Origin of module
-            std::unique_ptr<runtime::vm_string_t> origin;
-            // Weak reference to a loaded module
-            std::weak_ptr<runtime::vm_module_t> module;
-        };
-        using loaded_modules_t = std::forward_list<loaded_module_t>;
         mutable std::mutex _modules_lock;
         loaded_modules_t _modules;

src/vm/vm.cpp+13−30

 using namespace disvm;
 using namespace disvm::runtime;
-vm_t::loaded_module_t::loaded_module_t(std::unique_ptr<runtime::vm_string_t> origin, std::shared_ptr<runtime::vm_module_t> module)
-    : origin{ std::move(origin) }
-    , module{ module }
-{
-    assert(this->origin != nullptr);
-}
-vm_t::loaded_module_t::loaded_module_t(loaded_module_t &&other)
-    : origin{ std::move(other.origin) }
-    , module{ std::move(other.module) }
-{
-}
-vm_t::loaded_module_t::~loaded_module_t()
-{
-    if (origin != nullptr)
-        origin->release();
-}
 vm_t::vm_t(
     create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler,
     create_vm_interface_callback_t<runtime::vm_garbage_collector_t> create_gc)
     // Release the scheduler first since it could be using the gc instance.
     _scheduler.reset();
     _gc.reset();
+    std::lock_guard<std::mutex> lock{ _modules_lock };
+    for (auto &m : _modules)
+    {
+        if (m.origin != nullptr)
+            m.origin->release();
+    }
 }
 vm_version_t vm_t::get_version() const
         throw vm_user_exception{ "Invalid module path" };
     std::lock_guard<std::mutex> lock{ _modules_lock };
     // Check if the module is already loaded.
     auto iter = std::begin(_modules);
     while (iter != std::end(_modules))
             _tool_dispatch->on_module_load(new_module, *path_local);
     }
-    _modules.push_front(std::move(loaded_module_t{ std::move(path_local), new_module }));
+    _modules.push_front(std::move(loaded_vm_module_t{ std::move(path_local), new_module }));
     debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "load: vm module: >>%s<<\n", path);
     return new_module;
 }
-std::vector<std::shared_ptr<runtime::vm_module_t>> vm_t::get_loaded_modules() const
+void vm_t::enum_loaded_modules(loaded_vm_module_callback_t callback) const
 {
-    auto result = std::vector<std::shared_ptr<runtime::vm_module_t>>{};
+    if (callback == nullptr)
+        throw vm_system_exception{ "Callback should not be null" };
     std::lock_guard<std::mutex> lock{ _modules_lock };
     for (auto &m : _modules)
-    {
+        callback(m);
-        auto loaded_module_maybe = m.module.lock();
-        if (loaded_module_maybe != nullptr)
-            result.push_back(loaded_module_maybe);
-    }
-    return result;
 }
 runtime::vm_scheduler_control_t &vm_t::get_scheduler_control() const

src/vm/vm_memory.cpp+5−2

             free_memory(const_cast<byte_t *>(td->pointer_map));
             debug::assign_debug_pointer(const_cast<byte_t **>(&td->pointer_map));
-            debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: type descriptor\n");
+            if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
+                debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: type descriptor\n");
             free_memory(td);
         }
     } deleter;
     , pointer_map{ pointer_map }
     , finalizer{ finalizer }
 {
-    debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: type descriptor\n");
+    if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
+        debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: type descriptor\n");
 }