Name the entry module in the exec program. Re-write stack walking function for debugger. System exceptions now print out call stack.

arr committed 10 years ago

Commit 794ecfc1 parent 4f6417b5 files · +54 −35Browse files

Unified · Split

5 files

src/exec/main.cpp +3 −0
src/include/runtime.h +8 −9
src/vm/scheduler.cpp +19 −2
src/vm/stack.cpp +0 −21
src/vm/thread.cpp +24 −3

@@ -73,6 +73,9 @@ namespace · 72 unmodified lines
73	e.header.entry_type = 0;	73	e.header.entry_type = 0;
74	e.header.runtime_flag = (runtime_flags_t::has_import);	74	e.header.runtime_flag = (runtime_flags_t::has_import);
75		75
		76	std::array<uint8_t, 8> mod_name = { "_entry_" };
		77	e.module_name = std::make_unique<vm_string_t>(mod_name.size() - 1, mod_name.data());
		78
76	// Inherit the stack extent from the command module and add the entry frame size.	79	// Inherit the stack extent from the command module and add the entry frame size.
77	e.header.stack_extent = command_module->header.stack_extent + sizeof(vm_entry_frame_t);	80	e.header.stack_extent = command_module->header.stack_extent + sizeof(vm_entry_frame_t);
78		81

src/include/runtime.h+8−9

             pointer_t fixed_point_register_2() const;
         };
-        // Callback for stack walk.
-        // Returning 'false' during the stack walk will terminate the walk.
-        // The second parameter is reserved for internal use by the VM and should not be manipulated.
-        using vm_stack_walk_callback_t = std::function<bool(const vm_frame_t *f, const void *reserved)>;
         // VM stack
         class vm_stack_t final
         {
             // Return the current top frame.
             vm_frame_t *peek_frame() const;
-            // Walk the stack getting a callback for each frame.
-            // This function is __not__ thread safe.
-            void walk_stack(vm_stack_walk_callback_t callback) const;
         private:
             std::unique_ptr<vm_alloc_t> _mem;
         };
             pointer_t dest;
         };
+        // Callback for stack walk.
+        // Returning 'false' during the stack walk will terminate the walk.
+        using vm_stack_walk_callback_t = std::function<bool(const pointer_t frame, const vm_pc_t pc, const vm_module_ref_t &module_ref)>;
+        // Walk the stack getting a callback for each frame.
+        // This function is __not__ thread safe if the vm thread being walked is not stopped.
+        void walk_stack(const vm_registers_t &r, vm_stack_walk_callback_t callback);
         // VM thread
         class vm_thread_t final : public vm_alloc_t
         {

src/vm/scheduler.cpp+19−2

 //
 #include <debug.h>
+#include <sstream>
 #include <exceptions.h>
 #include "scheduler.h"
     }
     catch (const vm_system_exception &se)
     {
-        std::printf("%s\n", se.what());
+        std::stringstream err_msg;
+        err_msg << se.what() << "\n";
+        if (current_thread != nullptr)
+        {
+            const auto &r = current_thread->vm_thread->get_registers();
+            walk_stack(r, [&err_msg](const pointer_t, const vm_pc_t pc, const vm_module_ref_t &module_ref)
+            {
+                auto module_name = "<No Name>";
+                if (module_ref.module->module_name != nullptr)
+                    module_name = module_ref.module->module_name->str();
+                err_msg << "\t" << module_name << "@" << pc << "\n";
+                return true;
+            });
+        }
+        std::fprintf(stderr, "%s\n", err_msg.str().c_str());
         instance._terminating = true;
         instance._worker_event.notify_all();
     }
 bool default_scheduler_t::is_idle() const
 {
     std::lock_guard<std::mutex> lock{ _vm_threads_lock };
-    return _running_vm_thread_count == 0 && _runnable_vm_threads.empty() && _blocked_vm_thread_ids.empty() && !_terminating;
+    return (_terminating) || (_running_vm_thread_count == 0 && _runnable_vm_threads.empty() && _blocked_vm_thread_ids.empty());
 }
 vm_scheduler_control_t &default_scheduler_t::get_controller() const

src/vm/stack.cpp+0−21

@@ -295,24 +295,3 @@ vm_frame_t *vm_stack_t::peek_frame() const · 294 unmodified lines
295	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());	295	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
296	return layout->top_frame;	296	return layout->top_frame;
297	}	297	}
298
299	void vm_stack_t::walk_stack(vm_stack_walk_callback_t callback) const
300	{
301	if (callback == nullptr)
302	return;
303
304	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
305	auto current_page = layout->top_page;
306	auto current_frame = layout->top_frame;
307
308	while (current_page != nullptr && current_frame != nullptr)
309	{
310	if (!callback(current_frame, current_page))
311	break;
312
313	current_frame = current_frame->prev_frame();
314
315	if (!current_page->contains_frame(current_frame))
316	current_page = current_page->prev_page;
317	}
318	}

src/vm/thread.cpp+24−3

     debug::assign_debug_pointer(&module_ref);
 }
+void disvm::runtime::walk_stack(const vm_registers_t &r, vm_stack_walk_callback_t callback)
+{
+    assert(callback != nullptr);
+    auto current_pc = r.pc;
+    auto current_module = r.module_ref;
+    auto current_frame = r.stack.peek_frame();
+    while (current_frame != nullptr)
+    {
+        if (!callback(current_frame->base(), current_pc, *current_module))
+            break;
+        current_pc = current_frame->prev_pc();
+        auto prev_module_maybe = current_frame->prev_module_ref();
+        if (prev_module_maybe != nullptr)
+            current_module = prev_module_maybe;
+        current_frame = current_frame->prev_frame();
+    }
+}
 std::shared_ptr<const type_descriptor_t> vm_thread_t::type_desc()
 {
     return intrinsic_type_desc::type<vm_thread_t>();
     catch (const unhandled_user_exception &uue)
     {
         // [TODO] Store the exception
-        std::printf("%s - %s in %s at instruction %d\n", uue.what(), uue.exception_id, uue.module_name, uue.program_counter);
+        std::fprintf(stderr, "%s - %s in %s at instruction %d\n", uue.what(), uue.exception_id, uue.module_name, uue.program_counter);
         _registers.current_thread_state = vm_thread_state_t::broken;
     }
     catch (const index_out_of_range_memory &ioor)
     {
-        std::printf("%s - %d [%d,%d]\n", ioor.what(), ioor.invalid_value, ioor.valid_min, ioor.valid_max);
+        std::fprintf(stderr, "%s - %d [%d,%d]\n", ioor.what(), ioor.invalid_value, ioor.valid_min, ioor.valid_max);
         _registers.current_thread_state = vm_thread_state_t::broken;
     }
     catch (const vm_user_exception &ue)
     {
-        std::printf("%s\n", ue.what());
+        std::fprintf(stderr, "%s\n", ue.what());
         _registers.current_thread_state = vm_thread_state_t::broken;
     }