Various work for tool support in the VM. Update some type names (i.e. _t) and alter API signatures to be more consistent.

arr committed 10 years ago

Commit e5d3f861 parent bcb413516 files · +514 −45Browse files

Showing the changes to src/include (6 of 16 files). Show all

Unified · Split

6 files

src/include/debug.h +1 −0
src/include/disvm.h +7 −3
src/include/opcodes.h +4 −1
src/include/runtime.h +37 −10
src/include/utf8.h +2 −2
src/include/vm_tools.h +63 −0

@@ -24,6 +24,7 @@ namespace disvm · 23 unmodified lines
24	stack,	24	stack,
25	channel,	25	channel,
26	exception,	26	exception,
		27	tool,
27	memory, // Noisy component	28	memory, // Noisy component
28	addressing, // Noisy component [DEBUG build only]	29	addressing, // Noisy component [DEBUG build only]
29		30

src/include/disvm.h+7−3

         // Load the module at the supplied path into the virtual machine
         std::shared_ptr<const runtime::vm_module_t> load_module(const char *path);
+        // Get a collection of all currently loaded modules.
+        // Note this will only include modules that have been loaded by a call to vm_t::load_module.
+        std::vector<std::shared_ptr<const runtime::vm_module_t>> get_loaded_modules() const;
         // Access the scheduler control for this VM.
         runtime::vm_scheduler_control_t &get_scheduler_control() const;
         class loaded_module_t final
         {
         public:
-            loaded_module_t(std::unique_ptr<runtime::vm_string_t> origin, std::shared_ptr<const runtime::vm_module_t> module);
+            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;
             std::unique_ptr<runtime::vm_string_t> origin;
             // Weak reference to a loaded module
-            std::weak_ptr<const runtime::vm_module_t> module;
+            std::weak_ptr<runtime::vm_module_t> module;
         };
         using loaded_modules_t = std::forward_list<loaded_module_t>;
-        std::mutex _modules_lock;
+        mutable std::mutex _modules_lock;
         loaded_modules_t _modules;
         std::unique_ptr<runtime::vm_scheduler_t> _scheduler;

src/include/opcodes.h+4−1

         expf,
         self,
+        // [SPEC] Added opcode for debugging support.
+        brkpt,
         // markers
         first_opcode = invalid,
-        last_opcode = self
+        last_opcode = brkpt
     };
 }

src/include/runtime.h+37−10

 namespace disvm
 {
-    // VM forward declation
+    // Forward declaration
     class vm_t;
     namespace runtime
         // VM memory management
         //
-        // VM forward declation
+        // Forward declaration
         class vm_alloc_t;
         // Finalizer callback for allocations.
             const vm_alloc_instance_finalizer_t finalizer;
         };
-        // Access to type descriptors for VM intrinsic types.
+        // Access to type descriptors for VM intrinsic types
         class intrinsic_type_desc final
         {
         public:
             const bool _is_alloc;
         };
-        // VM forward declation
+        // Forward declaration
         class vm_channel_t;
         // VM request mutex
         public: //static
             static std::shared_ptr<const type_descriptor_t> type_desc();
+            using data_transfer_func_t = void(*)(pointer_t, pointer_t, const type_descriptor_t *);
         public:
             vm_channel_t(
                 std::shared_ptr<const type_descriptor_t> td,
-                std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> transfer,
+                data_transfer_func_t transfer,
                 word_t buffer_len);
             ~vm_channel_t();
         private:
             std::mutex _data_lock;
             std::shared_ptr<const type_descriptor_t> _data_type;
-            std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> _data_transfer;
+            data_transfer_func_t _data_transfer;
             vm_array_t *_data_buffer;
             uint32_t _data_buffer_head; // Next element to remove from buffer
         using src_data_t = inst_data_generic_t;
         using dest_data_t = inst_data_generic_t;
-        // VM forward declation
+        // Forward declaration
         class vm_registers_t;
         // Instruction execution operation
         // Forward declaration
         class vm_thread_t;
+        class vm_tool_dispatch_t;
         // VM registers
         class vm_registers_t
             ~vm_registers_t();
             const vm_thread_t &thread;
+            std::atomic<vm_tool_dispatch_t *> tool_dispatch;
             vm_stack_t stack;  // Frame pointer access (FP)
             vm_pc_t pc;  // Program counter (Index into module code section)
             vm_alloc_t *mp_base;  // Module data base pointer (MP)
                 uint32_t parent_thread_id);
             vm_thread_t(
                 vm_module_ref_t &entry,
+                uint32_t parent_thread_id,
                 const vm_frame_t &initial_frame,
-                vm_pc_t start_pc,
+                vm_pc_t start_pc);
-                uint32_t parent_thread_id);
             ~vm_thread_t();
-            vm_thread_state_t execute(vm_t &virtual_machine, const uint32_t quanta);
+            vm_thread_state_t execute(vm_t &vm, const uint32_t quanta);
+            // There is no way to get the current dispatch value.
+            // Setting the dispatch to 'null' detaches all tool related behavior
+            void set_tool_dispatch(vm_tool_dispatch_t *dispatch);
             vm_thread_state_t get_state() const;
         // Create a garbage collector that does nothing.
         std::unique_ptr<vm_garbage_collector_t> create_no_op_gc(vm_t &);
+        // Forward declaration
+        class vm_tool_controller_t;
+        // VM tool interface
+        // Used to implement tools (e.g. debugger or profiler)
+        class vm_tool_t
+        {
+        public:
+            virtual ~vm_tool_t() = 0;
+            // Called when the tool is loaded into the VM
+            virtual void on_load(vm_t &vm, vm_tool_controller_t &controller, std::size_t tool_id) = 0;
+            // Called when the tool is unloaded from the VM.
+            // Note once the tool has been unloaded the vm and controller references supplied during load
+            // should not be used as they may no longer be valid.
+            virtual void on_unload() = 0;
+        };
     }
 }

src/include/utf8.h+2−2

@@ -33,7 +33,7 @@ namespace disvm · 32 unmodified lines
33	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.	33	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
34	std::size_t count_codepoints(const uint8_t *str, const std::size_t max_len);	34	std::size_t count_codepoints(const uint8_t *str, const std::size_t max_len);
35		35
36	enum class decode_state	36	enum class decode_state_t
37	{	37	{
38	accept = 0,	38	accept = 0,
39	reject = 12	39	reject = 12
@@ -41,7 +41,7 @@ namespace disvm · 1 unmodified line
41		41
42	// Decode a byte at a time to form a codepoint.	42	// Decode a byte at a time to form a codepoint.
43	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.	43	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
44	decode_state decode_step(decode_state &state, rune_t &codepoint, uint8_t byte);	44	decode_state_t decode_step(decode_state_t &state, rune_t &codepoint, uint8_t byte);
45		45
46	// Decode the next codepoint in the supplied string.	46	// Decode the next codepoint in the supplied string.
47	// Returns number of characters in string consumed.	47	// Returns number of characters in string consumed.

src/include/vm_tools.h+63−0

@@ -0,0 +1,63 @@
	1	//
	2	// Dis VM
	3	// File: vm_tools.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_VM_TOOLS_H_
	8	#define _DISVM_SRC_INCLUDE_VM_TOOLS_H_
	9
	10	#include <cstdint>
	11	#include <vector>
	12	#include <memory>
	13	#include <functional>
	14	#include "runtime.h"
	15
	16	namespace disvm
	17	{
	18	namespace runtime
	19	{
	20	union vm_context_value_t
	21	{
	22	std::size_t i;
	23	vm_t *vm;
	24	vm_module_t *module;
	25	vm_registers_t *registers;
	26	vm_alloc_t *alloc;
	27	};
	28
	29	struct vm_event_context_t
	30	{
	31	vm_context_value_t value1;
	32	vm_context_value_t value2;
	33	};
	34
	35	enum class vm_event_t
	36	{
	37	module_load, // value1: vm_module_t
	38	module_unload, // value1: vm_module_t
	39	thread_begin, // value1: vm_registers_t
	40	thread_end, // value1: vm_registers_t
	41	exception_raised, // value1: vm_registers_t value2: vm_alloc_t
	42	exception_unhandled, // value1: vm_registers_t value2: vm_alloc_t
	43	breakpoint, // value1: vm_registers_t value2: std::size_t
	44	};
	45
	46	using vm_event_callback_t = std::function<void(vm_event_t, vm_event_context_t &)>;
	47
	48	// VM tool controller
	49	class vm_tool_controller_t
	50	{
	51	public:
	52	// Call the supplied callback when the specified event occurs
	53	virtual std::size_t subscribe_event(vm_event_t, vm_event_callback_t) = 0;
	54	virtual void unsubscribe_event(std::size_t) = 0;
	55
	56	// Set a breakpoint in the supplied module at the specified PC location
	57	virtual std::size_t set_breakpoint(std::shared_ptr<const vm_module_t>, vm_pc_t) = 0;
	58	virtual void clear_breakpoint(std::size_t) = 0;
	59	};
	60	}
	61	}
	62
	63	#endif // _DISVM_SRC_INCLUDE_VM_TOOLS_H_

Various work for tool support in the VM. Update some type names (i.e. _t) and alter API signatures to be more consistent.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code