Initial public commit for Dis VM

arr committed 10 years ago

Commit f95902eNo parent (first commit)40 files · +9358 −0Browse files

Showing the changes to src/include (10 of 40 files). Show all

Unified · Split

10 files

src/include/builtin_module.h +66 −0
src/include/debug.h +99 −0
src/include/disvm.h +98 −0
src/include/exceptions.h +137 −0
src/include/module_reader.h +29 −0
src/include/opcodes.h +199 −0
src/include/runtime.h +846 −0
src/include/utf8.h +57 −0
src/include/utils.h +47 −0
src/include/vm_memory.h +109 −0

@@ -0,0 +1,66 @@
	1	//
	2	// Dis VM
	3	// File: builtin_module.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_BUILTIN_MODULE_H_
	8	#define _DISVM_SRC_INCLUDE_BUILTIN_MODULE_H_
	9
	10	#include <cstdint>
	11	#include <memory>
	12	#include "runtime.h"
	13
	14	#define BUILTIN_MODULE_PREFIX_STR "$"
	15	#define BUILTIN_MODULE_PREFIX_CHAR '$'
	16
	17	namespace disvm
	18	{
	19	namespace runtime
	20	{
	21	namespace builtin
	22	{
	23	// Called to initialize built-in modules.
	24	// This will be called once per process hosting a VM.
	25	void initialize_builtin_modules();
	26
	27	// Defined as 'Runtab' in Inferno (limbo/stubs.c)
	28	struct vm_runtab_t
	29	{
	30	// Function identification
	31	char *name;
	32	uint32_t sig;
	33
	34	// Function pointer
	35	vm_exec_t fn;
	36
	37	// Function frame type
	38	word_t frame_size;
	39	word_t frame_pointer_count;
	40	byte_t frame_pointer_map[16];
	41	};
	42
	43	// Called by the built-in module during initialization
	44	void register_module_exports(const char name, word_t table_length, const vm_runtab_t module_runtime_table);
	45
	46	// Get the supplied built-in module.
	47	std::shared_ptr<vm_module_t> get_builtin_module(const char *name);
	48	}
	49
	50	// [SPEC] All allocated frames have the following base layout.
	51	// See 'struct Frame' in Inferno (include/interp.h)
	52	struct vm_frame_base_alloc_t
	53	{
	54	vm_pc_t p_pc; // Previous PC
	55	vm_frame_t *p_fp; // Previous frame pointer
	56	vm_module_ref_t *p_mr; // Previous module ref
	57	pointer_t reserved; // Reserved for VM
	58	};
	59
	60	static_assert(
	61	sizeof(vm_frame_base_alloc_t) == runtime_constants::default_register_count * runtime_constants::default_register_size_bytes,
	62	"Default register allocation should match base allocation type");
	63	}
	64	}
	65
	66	#endif // _DISVM_SRC_INCLUDE_BUILTIN_MODULE_H_

src/include/debug.h+99−0

@@ -0,0 +1,99 @@
	1	//
	2	// Dis VM
	3	// File: debug.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_DEBUG_H_
	8	#define _DISVM_SRC_INCLUDE_DEBUG_H_
	9
	10	#include <array>
	11	#include <cstdarg>
	12	#include <cassert>
	13
	14	namespace disvm
	15	{
	16	namespace debug
	17	{
	18	// Components that have tracing
	19	enum class component_trace_t
	20	{
	21	builtin,
	22	module,
	23	thread,
	24	stack,
	25	channel,
	26	exception,
	27	memory, // Noisy component
	28	addressing, // Noisy component [DEBUG build only]
	29
	30	// Potentially logged from a VM extension.
	31	scheduler,
	32	garbage_collector,
	33
	34	// Tracking purposes
	35	last = garbage_collector
	36	};
	37
	38	// Trace component enable state.
	39	extern std::array<bool, static_cast<std::size_t>(disvm::debug::component_trace_t::last) + 1> trace_enabled;
	40
	41	// Set tracing for a component
	42	inline void set_component_tracing(const component_trace_t c, bool is_enabled)
	43	{
	44	trace_enabled[static_cast<const std::size_t>(c)] = is_enabled;
	45	}
	46
	47	// Check if tracing is enabled on a component (compile time optimization)
	48	template<component_trace_t C>
	49	bool is_component_tracing_enabled()
	50	{
	51	return trace_enabled[static_cast<const std::size_t>(C)];
	52	}
	53
	54	// Check if tracing is enabled on a component
	55	inline bool is_component_tracing_enabled(const component_trace_t c)
	56	{
	57	return trace_enabled[static_cast<const std::size_t>(c)];
	58	}
	59
	60	// Message log level
	61	enum class log_level_t
	62	{
	63	warning,
	64	debug,
	65	};
	66
	67	using log_callback_t = void()(const component_trace_t origin, const log_level_t level, const char msg_fmt, std::va_list args);
	68
	69	// Set the logging callback
	70	// Returns the previous callback.
	71	log_callback_t set_logging_callback(log_callback_t cb);
	72
	73	// Log a message
	74	void log_msg(const component_trace_t origin, const log_level_t level, const char *msg_fmt, ...);
	75
	76	//
	77	// Memory debugging
	78	//
	79
	80	inline void assign_debug_memory(void *dest, std::size_t size_in_bytes)
	81	{
	82	#ifndef NDEBUG
	83	const auto debug_memory = int{ 0xda }; // Dante Alighieri's initials
	84	std::memset(dest, debug_memory, size_in_bytes);
	85	#endif
	86	}
	87
	88	template<typename T>
	89	void assign_debug_pointer(T **t)
	90	{
	91	#ifndef NDEBUG
	92	assert(t != nullptr);
	93	t = reinterpret_cast<T >(0xbada110c);
	94	#endif
	95	}
	96	}
	97	}
	98
	99	#endif // _DISVM_SRC_INCLUDE_DEBUG_H_

src/include/disvm.h+98−0

@@ -0,0 +1,98 @@
	1	//
	2	// Dis VM
	3	// File: disvm.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_DISVM_H_
	8	#define _DISVM_SRC_INCLUDE_DISVM_H_
	9
	10	#include "runtime.h"
	11	#include <iosfwd>
	12	#include <memory>
	13	#include <functional>
	14	#include <mutex>
	15	#include <forward_list>
	16
	17	namespace disvm
	18	{
	19	// Read in the module at the supplied path
	20	std::unique_ptr<runtime::vm_module_t> read_module(const char *path);
	21
	22	// Read in a module from the supplied stream
	23	std::unique_ptr<runtime::vm_module_t> read_module(std::istream &data);
	24
	25	template <typename C>
	26	using create_vm_interface_callback_t = std::function<std::unique_ptr<C>(vm_t &)>;
	27
	28	// Virtual machine
	29	class vm_t final
	30	{
	31	public: // static
	32	static const auto root_vm_thread_id = uint32_t{ 0 };
	33
	34	public:
	35	explicit vm_t(
	36	create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler = nullptr,
	37	create_vm_interface_callback_t<runtime::vm_garbage_collector_t> create_gc = nullptr);
	38
	39	explicit vm_t(uint32_t thread_pool_size, uint32_t thread_quanta);
	40
	41	~vm_t();
	42
	43	public:
	44	// Begin execution of the module at the supplied path
	45	const runtime::vm_thread_t& exec(const char *path);
	46
	47	// Begin execution of the supplied module
	48	const runtime::vm_thread_t& exec(std::unique_ptr<runtime::vm_module_t> entry_module);
	49
	50	// Begin execution of a child thread in the supplied module at the indicated program counter
	51	const runtime::vm_thread_t& fork(
	52	const runtime::vm_thread_t &parent,
	53	runtime::vm_module_ref_t &module_ref,
	54	const runtime::vm_frame_t &initial_frame,
	55	runtime::vm_pc_t initial_pc);
	56
	57	// Load the module at the supplied path into the virtual machine
	58	std::shared_ptr<const runtime::vm_module_t> load_module(const char *path);
	59
	60	// Access the scheduler control for this VM.
	61	runtime::vm_scheduler_control_t &get_scheduler_control() const;
	62
	63	// Access the garbage collector for this VM.
	64	runtime::vm_garbage_collector_t &get_garbage_collector() const;
	65
	66	// Spin and sleep until the VM is idle, then return.
	67	// Idle is defined as no vm threads executing, scheduled to be executed, or blocked.
	68	void spin_sleep_till_idle(std::chrono::milliseconds sleep_interval) const;
	69
	70	private:
	71	// Loaded module reference
	72	class loaded_module_t final
	73	{
	74	public:
	75	loaded_module_t(std::unique_ptr<runtime::vm_string_t> origin, std::shared_ptr<const runtime::vm_module_t> module);
	76	loaded_module_t(const loaded_module_t &) = delete;
	77	loaded_module_t &operator=(const loaded_module_t &) = delete;
	78
	79	loaded_module_t(loaded_module_t &&);
	80	~loaded_module_t();
	81
	82	// Origin of module
	83	std::unique_ptr<runtime::vm_string_t> origin;
	84
	85	// Weak reference to a loaded module
	86	std::weak_ptr<const runtime::vm_module_t> module;
	87	};
	88
	89	using loaded_modules_t = std::forward_list<loaded_module_t>;
	90	std::mutex _modules_lock;
	91	loaded_modules_t _modules;
	92
	93	std::unique_ptr<runtime::vm_scheduler_t> _scheduler;
	94	std::unique_ptr<runtime::vm_garbage_collector_t> _gc;
	95	};
	96	}
	97
	98	#endif // _DISVM_SRC_INCLUDE_DISVM_H_

src/include/exceptions.h+137−0

@@ -0,0 +1,137 @@
	1	//
	2	// Dis VM
	3	// File: exceptions.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_EXCEPTIONS_H_
	8	#define _DISVM_SRC_INCLUDE_EXCEPTIONS_H_
	9
	10	#include <cassert>
	11	#include <string>
	12	#include <stdexcept>
	13	#include "runtime.h"
	14
	15	namespace disvm
	16	{
	17	namespace runtime
	18	{
	19	class vm_user_exception : public std::runtime_error
	20	{
	21	public:
	22	explicit vm_user_exception(const char *message)
	23	: std::runtime_error(message)
	24	{ }
	25	};
	26
	27	class vm_system_exception : public std::runtime_error
	28	{
	29	public:
	30	explicit vm_system_exception(const char *message)
	31	: std::runtime_error(message)
	32	{ }
	33	};
	34
	35	class vm_module_exception : public vm_system_exception
	36	{
	37	public:
	38	explicit vm_module_exception(const char *message)
	39	: vm_system_exception(message)
	40	{ }
	41	};
	42
	43	class module_reader_exception final : public vm_module_exception
	44	{
	45	public:
	46	explicit module_reader_exception()
	47	: vm_module_exception("Invalid module")
	48	{ }
	49
	50	explicit module_reader_exception(const char *message)
	51	: vm_module_exception(message)
	52	{ }
	53	};
	54
	55	class divide_by_zero final : public vm_user_exception
	56	{
	57	public:
	58	explicit divide_by_zero()
	59	: vm_user_exception("Divide by 0")
	60	{ }
	61	};
	62
	63	class invalid_utf8 : public vm_user_exception
	64	{
	65	public:
	66	explicit invalid_utf8()
	67	: vm_user_exception("Invalid UTF-8 string")
	68	{ }
	69	};
	70
	71	class dereference_nil final : public vm_user_exception
	72	{
	73	public:
	74	explicit dereference_nil()
	75	: vm_user_exception("Dereference of nil value")
	76	, operation{ nullptr }
	77	{ }
	78
	79	explicit dereference_nil(const char *operation)
	80	: vm_user_exception("Dereference of nil value")
	81	, operation{ operation }
	82	{ }
	83
	84	const char *operation;
	85	};
	86
	87	class type_violation : public vm_user_exception
	88	{
	89	public:
	90	explicit type_violation()
	91	: vm_user_exception("Inconsistent types in operation")
	92	{ }
	93	};
	94
	95	class out_of_range_memory final : public vm_user_exception
	96	{
	97	public:
	98	explicit out_of_range_memory()
	99	: vm_user_exception("Out of range access")
	100	, invalid_value{ 0 }
	101	, range_defined{ false }
	102	, valid_max{ 0 }
	103	, valid_min{ 0 }
	104	{ }
	105
	106	explicit out_of_range_memory(word_t valid_min, word_t valid_max, word_t invalid_valid)
	107	: vm_user_exception("Out of range access")
	108	, invalid_value{ invalid_valid }
	109	, range_defined{ true }
	110	, valid_max{ valid_max }
	111	, valid_min{ valid_min }
	112	{ }
	113
	114	const bool range_defined;
	115	const word_t valid_min;
	116	const word_t valid_max;
	117	const word_t invalid_value;
	118	};
	119
	120	class unhandled_user_exception final : public vm_user_exception
	121	{
	122	public:
	123	explicit unhandled_user_exception(const char exception_id, const char module_name, vm_pc_t current_pc)
	124	: vm_user_exception("Unhandled user exception")
	125	, exception_id{ exception_id }
	126	, module_name{ module_name }
	127	, program_counter{ current_pc }
	128	{ }
	129
	130	const char *exception_id;
	131	const char *module_name;
	132	const vm_pc_t program_counter;
	133	};
	134	}
	135	}
	136
	137	#endif // _DISVM_SRC_INCLUDE_EXCEPTIONS_H_

src/include/module_reader.h+29−0

@@ -0,0 +1,29 @@
	1	//
	2	// Dis VM
	3	// File: module_reader.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_MODULE_READER_H_
	8	#define _DISVM_SRC_INCLUDE_MODULE_READER_H_
	9
	10	#include <cstdint>
	11	#include "runtime.h"
	12
	13	namespace disvm
	14	{
	15	namespace format
	16	{
	17	using operand_t = int32_t;
	18	static_assert(sizeof(operand_t) == sizeof(runtime::word_t), "Operand and word should be the same size");
	19	static_assert(sizeof(operand_t) == sizeof(runtime::vm_pc_t), "Operand and VM program counter type should be the same size");
	20
	21	struct magic_number_constants final
	22	{
	23	static const auto xmagic = operand_t{ 819248 }; // Normal module (0xC8030)
	24	static const auto smagic = operand_t{ 923426 }; // Signed module (0xE1722)
	25	};
	26	}
	27	}
	28
	29	#endif // _DISVM_SRC_INCLUDE_MODULE_READER_H_

src/include/opcodes.h+199−0

@@ -0,0 +1,199 @@
	1	//
	2	// Dis VM
	3	// File: opcodes.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_OPCODES_H_
	8	#define _DISVM_SRC_INCLUDE_OPCODES_H_
	9
	10	#include <cstdint>
	11
	12	namespace disvm
	13	{
	14	// Instruction codes for the Dis VM
	15	enum class opcode_t
	16	{
	17	invalid = 0,
	18	alt,
	19	nbalt,
	20	goto_,
	21	call,
	22	frame,
	23	spawn,
	24	runt,
	25	load,
	26	mcall,
	27	mspawn,
	28	mframe,
	29	ret,
	30	jmp,
	31	casew,
	32	exit,
	33	new_,
	34	newa,
	35	newcb,
	36	newcw,
	37	newcf,
	38	newcp,
	39	newcm,
	40	newcmp,
	41	send,
	42	recv,
	43	consb,
	44	consw,
	45	consp,
	46	consf,
	47	consm,
	48	consmp = 0x1f,
	49	headb,
	50	headw,
	51	headp,
	52	headf,
	53	headm,
	54	headmp,
	55	tail,
	56	lea,
	57	indx,
	58	movp,
	59	movm,
	60	movmp,
	61	movb,
	62	movw,
	63	movf,
	64	cvtbw,
	65	cvtwb,
	66	cvtfw,
	67	cvtwf,
	68	cvtca,
	69	cvtac,
	70	cvtwc,
	71	cvtcw,
	72	cvtfc,
	73	cvtcf,
	74	addb,
	75	addw,
	76	addf,
	77	subb,
	78	subw,
	79	subf,
	80	mulb = 0x3f,
	81	mulw,
	82	mulf,
	83	divb,
	84	divw,
	85	divf,
	86	modw,
	87	modb,
	88	andb,
	89	andw,
	90	orb,
	91	orw,
	92	xorb,
	93	xorw,
	94	shlb,
	95	shlw,
	96	shrb,
	97	shrw,
	98	insc,
	99	indc,
	100	addc,
	101	lenc,
	102	lena,
	103	lenl,
	104	beqb,
	105	bneb,
	106	bltb,
	107	bleb,
	108	bgtb,
	109	bgeb,
	110	beqw,
	111	bnew,
	112	bltw = 0x5f,
	113	blew,
	114	bgtw,
	115	bgew,
	116	beqf,
	117	bnef,
	118	bltf,
	119	blef,
	120	bgtf,
	121	bgef,
	122	beqc,
	123	bnec,
	124	bltc,
	125	blec,
	126	bgtc,
	127	bgec,
	128	slicea,
	129	slicela,
	130	slicec,
	131	indw,
	132	indf,
	133	indb,
	134	negf,
	135	movl,
	136	addl,
	137	subl,
	138	divl,
	139	modl,
	140	mull,
	141	andl,
	142	orl,
	143	xorl,
	144	shll = 0x7f,
	145	shrl,
	146	bnel,
	147	bltl,
	148	blel,
	149	bgtl,
	150	bgel,
	151	beql,
	152	cvtlf,
	153	cvtfl,
	154	cvtlw,
	155	cvtwl,
	156	cvtlc,
	157	cvtcl,
	158	headl,
	159	consl,
	160	newcl,
	161	casec,
	162	indl,
	163	movpc,
	164	tcmp,
	165	mnewz,
	166	cvtrf,
	167	cvtfr,
	168	cvtws,
	169	cvtsw,
	170	lsrw,
	171	lsrl,
	172	eclr, // not used
	173	newz,
	174	newaz,
	175	raise,
	176	casel,
	177	mulx,
	178	divx,
	179	cvtxx,
	180	mulx0,
	181	divx0,
	182	cvtxx0,
	183	mulx1,
	184	divx1,
	185	cvtxx1,
	186	cvtfx,
	187	cvtxf,
	188	expw,
	189	expl,
	190	expf,
	191	self,
	192
	193	// markers
	194	first_opcode = invalid,
	195	last_opcode = self
	196	};
	197	}
	198
	199	#endif // _DISVM_SRC_INCLUDE_OPCODES_H_

src/include/runtime.h+846−0

@@ -0,0 +1,846 @@
	1	//
	2	// Dis VM
	3	// File: runtime.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_RUNTIME_H_
	8	#define _DISVM_SRC_INCLUDE_RUNTIME_H_
	9
	10	#include <cstdint>
	11	#include <cassert>
	12	#include <atomic>
	13	#include <vector>
	14	#include <string>
	15	#include <memory>
	16	#include <deque>
	17	#include <unordered_map>
	18	#include <mutex>
	19	#include <functional>
	20	#include "opcodes.h"
	21
	22	namespace disvm
	23	{
	24	// VM forward declation
	25	class vm_t;
	26
	27	namespace runtime
	28	{
	29	//
	30	// VM primitive data type definitions
	31	//
	32
	33	using byte_t = uint8_t;
	34	using short_word_t = int16_t;
	35	using word_t = int32_t;
	36	using short_real_t = float;
	37	using real_t = double;
	38	using big_t = int64_t;
	39	using pointer_t = std::size_t *;
	40	using vm_pc_t = word_t;
	41
	42	//
	43	// VM memory management
	44	//
	45
	46	// VM forward declation
	47	class vm_alloc_t;
	48
	49	// Finalizer callback for allocations.
	50	using vm_alloc_instance_finalizer_t = void()(vm_alloc_t );
	51
	52	// VM type description
	53	class type_descriptor_t final
	54	{
	55	public: // static
	56	static vm_alloc_instance_finalizer_t no_finalizer;
	57
	58	// Create a type descriptor for type of the supplied size and pointers based on the supplied map.
	59	static std::shared_ptr<const type_descriptor_t> create(const word_t size);
	60	static std::shared_ptr<const type_descriptor_t> create(const word_t size, const std::vector<byte_t> &pointer_map);
	61	static std::shared_ptr<const type_descriptor_t> create(
	62	const word_t size,
	63	const word_t pointer_map_length,
	64	const byte_t *pointer_map,
	65	vm_alloc_instance_finalizer_t finalizer = type_descriptor_t::no_finalizer);
	66
	67	private:
	68	type_descriptor_t(word_t size_in_bytes, word_t map_in_bytes, const byte_t * pointer_map, vm_alloc_instance_finalizer_t finalizer);
	69
	70	public:
	71	type_descriptor_t(const type_descriptor_t&) = delete;
	72	type_descriptor_t& operator=(const type_descriptor_t&) = delete;
	73
	74	const word_t size_in_bytes;
	75	const word_t map_in_bytes;
	76	const byte_t * const pointer_map;
	77	const vm_alloc_instance_finalizer_t finalizer;
	78	};
	79
	80	// Access to type descriptors for VM intrinsic types.
	81	class intrinsic_type_desc final
	82	{
	83	private:
	84	friend vm_t;
	85	static std::atomic_bool is_initialized;
	86	static void initialize();
	87
	88	public:
	89	// Templated type descriptor getter
	90	template<typename IntrinsicType>
	91	static std::shared_ptr<const type_descriptor_t> type();
	92	};
	93
	94	// Type used to indicate allocated memory should be zeroed out.
	95	struct zero_memory_t
	96	{ };
	97
	98	// VM memory allocation
	99	class vm_alloc_t
	100	{
	101	public: // static
	102	static const zero_memory_t zero_memory;
	103
	104	static void *operator new(std::size_t sz);
	105	static void operator delete(void *ptr);
	106
	107	static vm_alloc_t *allocate(std::shared_ptr<const type_descriptor_t> td);
	108	static vm_alloc_t *allocate(std::shared_ptr<const type_descriptor_t> td, const zero_memory_t &);
	109	static vm_alloc_t *copy(const vm_alloc_t &other);
	110	static vm_alloc_t *from_allocation(pointer_t allocation);
	111
	112	template <typename T>
	113	static T *from_allocation(pointer_t allocation)
	114	{
	115	auto alloc_inst = vm_alloc_t::from_allocation(allocation);
	116	assert(alloc_inst == nullptr \|\| alloc_inst->alloc_type == intrinsic_type_desc::type<T>());
	117	return dynamic_cast<T *>(alloc_inst);
	118	}
	119
	120	protected:
	121	vm_alloc_t(std::shared_ptr<const type_descriptor_t> td);
	122
	123	public:
	124	virtual ~vm_alloc_t();
	125
	126	std::size_t add_ref();
	127	std::size_t release();
	128	std::size_t get_ref_count() const;
	129
	130	std::shared_ptr<const type_descriptor_t> alloc_type;
	131
	132	// Reserved for use by the garbage collector.
	133	// This should not be accessed by any other component.
	134	pointer_t gc_reserved;
	135
	136	public:
	137	pointer_t allocation() const;
	138
	139	private:
	140	std::atomic<std::size_t> _ref_count;
	141	};
	142
	143	//
	144	// VM intrinsic type definitions
	145	//
	146
	147	// Type to contain the maximum UTF-8 character value
	148	using rune_t = uint32_t;
	149
	150	// VM string type
	151	class vm_string_t final : public vm_alloc_t
	152	{
	153	public: //static
	154	static std::shared_ptr<const type_descriptor_t> type_desc();
	155
	156	// Compare two string objects
	157	static int compare(const vm_string_t s1, const vm_string_t s2);
	158
	159	public:
	160	vm_string_t();
	161	vm_string_t(std::size_t encoded_str_len, const uint8_t *encoded_str);
	162	vm_string_t(const vm_string_t &s1, const vm_string_t &s2);
	163	vm_string_t(const vm_string_t &other, word_t begin_index, word_t end_index);
	164	vm_string_t(const vm_string_t &) = delete;
	165	~vm_string_t();
	166
	167	// Returns this string.
	168	vm_string_t &append(const vm_string_t &other);
	169
	170	word_t get_length() const;
	171
	172	rune_t get_rune(word_t index) const;
	173
	174	void set_rune(word_t index, rune_t value);
	175
	176	int compare_to(const vm_string_t *s) const;
	177
	178	const char *str() const;
	179
	180	private:
	181	word_t _length;
	182	word_t _length_max;
	183	mutable std::mutex _encoded_str_lock;
	184	mutable char *_encoded_str;
	185	mutable union string_memory_t
	186	{
	187	uint8_t local[16]; // Optimization for short strings
	188	uint8_t *alloc;
	189	} _mem;
	190
	191	uint8_t _character_size; // 1 byte (ASCII) or 4 bytes (multi-byte)
	192	bool _is_alloc;
	193	};
	194
	195	// VM array type
	196	class vm_array_t final : public vm_alloc_t
	197	{
	198	public: //static
	199	static std::shared_ptr<const type_descriptor_t> type_desc();
	200
	201	public:
	202	vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t count);
	203	vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t count, const zero_memory_t&);
	204	vm_array_t(vm_array_t *original, word_t begin_index, word_t count);
	205	vm_array_t(const vm_string_t *s);
	206	~vm_array_t();
	207
	208	std::shared_ptr<const type_descriptor_t> get_element_type() const;
	209
	210	word_t get_length() const;
	211
	212	pointer_t at(word_t index) const;
	213
	214	template<typename T>
	215	T& at(word_t index) const
	216	{
	217	return reinterpret_cast<T >(at(index));
	218	}
	219
	220	// Copy the contents of the source array into this array starting at index
	221	void copy_from(const vm_array_t &source, word_t this_begin_index);
	222
	223	private:
	224	std::shared_ptr<const type_descriptor_t> _element_type;
	225	vm_array_t *_original;
	226	word_t _length;
	227	byte_t *_arr;
	228	};
	229
	230	// VM list type
	231	class vm_list_t final : public vm_alloc_t
	232	{
	233	public: //static
	234	static std::shared_ptr<const type_descriptor_t> type_desc();
	235
	236	public:
	237	vm_list_t(std::shared_ptr<const type_descriptor_t> td, vm_list_t *tail = nullptr);
	238	~vm_list_t();
	239
	240	std::shared_ptr<const type_descriptor_t> get_element_type() const;
	241
	242	word_t get_length() const;
	243
	244	vm_list_t* get_tail() const;
	245
	246	vm_list_t* drop_tail();
	247
	248	// Returns a pointer to the value
	249	pointer_t value() const;
	250
	251	private:
	252	std::shared_ptr<const type_descriptor_t> _element_type;
	253	vm_list_t *_tail;
	254
	255	// Utilizing a union so that all value types can
	256	// be stored without allocating any extra memory.
	257	mutable union element_memory_t
	258	{
	259	pointer_t alloc;
	260	uint64_t local;
	261	} _mem;
	262
	263	const bool _is_alloc;
	264	};
	265
	266	// VM forward declation
	267	class vm_channel_t;
	268
	269	// VM request mutex
	270	struct vm_request_mutex_t
	271	{
	272	vm_request_mutex_t();
	273
	274	std::mutex pending_request_lock;
	275	bool pending_request;
	276	};
	277
	278	// VM channel request
	279	class vm_channel_request_t final
	280	{
	281	public:
	282	// Create a request using the ID of the requesting thread and an associated request mutex.
	283	vm_channel_request_t(uint32_t thread_id, vm_request_mutex_t &request_mutex);
	284
	285	uint32_t thread_id;
	286
	287	// Callback used to indicate the request was handled in the supplied channel.
	288	// This is only called in the event the request was not immediately serviced.
	289	std::function<void(const vm_channel_t &)> request_handled_callback;
	290
	291	// Data of the request
	292	pointer_t data;
	293
	294	std::reference_wrapper<vm_request_mutex_t> request_mutex;
	295	};
	296
	297	// VM channel type
	298	class vm_channel_t final : public vm_alloc_t
	299	{
	300	public: //static
	301	static std::shared_ptr<const type_descriptor_t> type_desc();
	302
	303	public:
	304	vm_channel_t(
	305	std::shared_ptr<const type_descriptor_t> td,
	306	std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> transfer,
	307	word_t buffer_len);
	308	~vm_channel_t();
	309
	310	std::shared_ptr<const type_descriptor_t> get_data_type() const;
	311
	312	// Send data into the channel.
	313	// Returns true if the data was sent, otherwise request is queued and false returned.
	314	bool send_data(vm_channel_request_t &send_request);
	315
	316	// Receive data from the channel.
	317	// Returns true if data was received, otherwise request is queued and false returned.
	318	bool receive_data(vm_channel_request_t &receive_request);
	319
	320	// Cancel an outstanding request from a thread.
	321	void cancel_request(uint32_t thread_id);
	322
	323	private:
	324	// Try to send data into the channel buffer.
	325	// Returns true if data was sent to buffer, otherwise false.
	326	bool try_send_to_buffer(vm_channel_request_t &send_request);
	327
	328	// Try to receive data from the channel buffer.
	329	// Returns true if data was received from buffer, otherwise false.
	330	bool try_receive_from_buffer(vm_channel_request_t &receive_request);
	331
	332	private:
	333	std::mutex _data_lock;
	334	std::shared_ptr<const type_descriptor_t> _data_type;
	335	std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> _data_transfer;
	336
	337	vm_array_t *_data_buffer;
	338	uint32_t _data_buffer_head; // Next element to remove from buffer
	339	uint32_t _data_buffer_count; // Count of elements in buffer
	340
	341	using request_queue_t = std::deque<vm_channel_request_t>;
	342	request_queue_t _data_senders;
	343	request_queue_t _data_receivers;
	344	};
	345
	346	// Alt channel entry.
	347	static_assert(sizeof(word_t) == sizeof(pointer_t), "Alt channel stack layout will be invalid.");
	348	struct vm_alt_channel_stack_layout_t
	349	{
	350	word_t alloc;
	351	word_t data;
	352	};
	353
	354	// Alt channel layout as defined by the specification for the 'alt' instruction.
	355	struct vm_alt_stack_layout_t
	356	{
	357	word_t send_count;
	358	word_t receive_count;
	359	vm_alt_channel_stack_layout_t channels[1];
	360	};
	361
	362	// Runtime constants
	363	struct runtime_constants
	364	{
	365	static const auto nil = std::size_t{ 0 };
	366
	367	static const auto invalid_program_counter = vm_pc_t{ ~0 };
	368
	369	static const auto default_register_count = std::size_t{ 4 };
	370	static const auto default_register_size_bytes = sizeof(word_t);
	371
	372	// See VM frame definition
	373	static const auto fixed_point_register_1_frame_offset = std::size_t{ default_register_count * default_register_size_bytes };
	374	static const auto fixed_point_register_2_frame_offset = fixed_point_register_1_frame_offset + (2 * default_register_size_bytes);
	375	};
	376
	377	// Addressing mode for middle instruction data
	378	enum class address_mode_middle_t
	379	{
	380	none = 0,
	381	small_immediate = 1,
	382	small_offset_indirect_fp = 2,
	383	small_offset_indirect_mp = 3,
	384	};
	385
	386	// Middle instruction data
	387	struct middle_data_t
	388	{
	389	address_mode_middle_t mode;
	390	word_t register1;
	391	};
	392
	393	// Addressing mode for source and destination instruction data
	394	enum class address_mode_t
	395	{
	396	offset_indirect_mp = 0,
	397	offset_indirect_fp = 1,
	398	immediate = 2,
	399	none = 3,
	400	offset_double_indirect_mp = 4,
	401	offset_double_indirect_fp = 5,
	402	reserved_1 = 6,
	403	reserved_2 = 7,
	404	};
	405
	406	// Source and destination instruction data
	407	struct inst_data_generic_t
	408	{
	409	address_mode_t mode;
	410	word_t register1;
	411	word_t register2;
	412	};
	413
	414	using src_data_t = inst_data_generic_t;
	415	using dest_data_t = inst_data_generic_t;
	416
	417	// VM forward declation
	418	class vm_registers_t;
	419
	420	// Instruction execution operation
	421	using vm_exec_t = void(*)(vm_registers_t &, vm_t &);
	422
	423	// Opcode execution operation
	424	struct vm_exec_op_t
	425	{
	426	opcode_t opcode;
	427	src_data_t source;
	428	middle_data_t middle;
	429	dest_data_t destination;
	430	};
	431
	432	// VM Instruction (code section of module)
	433	union vm_instruction_t
	434	{
	435	vm_exec_op_t op;
	436	vm_exec_t native;
	437	};
	438
	439	// Flags that dictate the runtime operations of the module
	440	// [SPEC] Values past 'shared_module' are not fully documented.
	441	enum class runtime_flags_t
	442	{
	443	must_compile = 1 << 0,
	444	dont_compile = 1 << 1,
	445	share_module = 1 << 2, // [TODO] Respect this setting
	446	reserved_1 = 1 << 3, // DYNMOD
	447	has_import_deprecated = 1 << 4,
	448	has_handler = 1 << 5,
	449	has_import = 1 << 6,
	450
	451	builtin = 1 << 7,
	452	};
	453
	454	// Module header
	455	struct header_t
	456	{
	457	word_t magic_number;
	458	struct
	459	{
	460	word_t length;
	461	std::unique_ptr<byte_t[]> signature;
	462	} Signature;
	463
	464	runtime_flags_t runtime_flag;
	465	word_t stack_extent;
	466	word_t code_size;
	467	word_t data_size;
	468	word_t type_size;
	469	word_t export_size;
	470	vm_pc_t entry_pc;
	471	word_t entry_type; // Stack frame type
	472	};
	473
	474	// Export function entry
	475	struct export_function_t
	476	{
	477	export_function_t() = default;
	478	export_function_t(export_function_t &&);
	479
	480	export_function_t(const export_function_t &) = delete;
	481	export_function_t &operator=(const export_function_t &) = delete;
	482
	483	~export_function_t();
	484
	485	vm_pc_t pc;
	486	word_t frame_type;
	487	word_t sig;
	488	std::unique_ptr<vm_string_t> name;
	489	};
	490
	491	// Import function entry
	492	struct import_function_t
	493	{
	494	import_function_t() = default;
	495	import_function_t(import_function_t &&);
	496
	497	import_function_t(const import_function_t &) = delete;
	498	import_function_t &operator=(const import_function_t &) = delete;
	499
	500	~import_function_t();
	501
	502	word_t sig;
	503	std::unique_ptr<vm_string_t> name;
	504	};
	505
	506	// Import table for module
	507	struct import_vm_module_t
	508	{
	509	import_vm_module_t() = default;
	510	import_vm_module_t(import_vm_module_t &&);
	511
	512	import_vm_module_t(const import_vm_module_t &) = delete;
	513	import_vm_module_t &operator=(const import_vm_module_t &) = delete;
	514
	515	~import_vm_module_t() = default;
	516
	517	std::vector<import_function_t> functions;
	518	};
	519
	520	// Exception entry for handler
	521	struct exception_t
	522	{
	523	exception_t() = default;
	524	exception_t(exception_t &&);
	525
	526	exception_t(const exception_t &) = delete;
	527	exception_t &operator=(const exception_t &) = delete;
	528
	529	~exception_t();
	530
	531	vm_pc_t pc;
	532	std::unique_ptr<vm_string_t> name;
	533	};
	534
	535	// Exception handler
	536	struct handler_t
	537	{
	538	handler_t() = default;
	539	handler_t(handler_t &&);
	540
	541	handler_t(const handler_t &) = delete;
	542	handler_t &operator=(const handler_t &) = delete;
	543
	544	~handler_t() = default;
	545
	546	// Byte offset in the handling frame the exception should be placed.
	547	word_t exception_offset;
	548	vm_pc_t begin_pc;
	549	vm_pc_t end_pc;
	550
	551	// Number of cases in exception table where the caught exception is of exception type.
	552	// See exceptions in Limbo language for details.
	553	word_t exception_type_count;
	554
	555	std::shared_ptr<const type_descriptor_t> type_desc;
	556	std::vector<exception_t> exception_table;
	557	};
	558
	559	using code_section_t = std::vector<vm_instruction_t>;
	560	using type_section_map_t = std::vector<std::shared_ptr<const type_descriptor_t>>;
	561	using export_section_t = std::unordered_multimap<word_t, const export_function_t>;
	562	using import_section_t = std::vector<import_vm_module_t>;
	563	using handler_section_t = std::vector<handler_t>;
	564
	565	// VM module
	566	struct vm_module_t
	567	{
	568	vm_module_t() = default;
	569	vm_module_t(const vm_module_t &) = delete;
	570	vm_module_t &operator=(const vm_module_t &) = delete;
	571
	572	~vm_module_t();
	573
	574	// Contains a magic number, digital signature, runtime flags, sizes of the other sections, and a description of the entry point
	575	header_t header;
	576
	577	// Describes a sequence of instructions for the virtual machine
	578	code_section_t code_section;
	579
	580	// template module pointer
	581	std::unique_ptr<vm_alloc_t> original_mp;
	582
	583	// Type descriptors describing the layout of pointers within data types
	584	type_section_map_t type_section;
	585
	586	// Module name
	587	std::unique_ptr<vm_string_t> module_name;
	588
	589	// List of functions exported by this module
	590	export_section_t export_section;
	591
	592	// List of all functions imported from other modules
	593	import_section_t import_section;
	594
	595	// Lists all exception handlers declared in the module
	596	handler_section_t handler_section;
	597	};
	598
	599	// Reference to a function in an imported module.
	600	struct vm_module_function_ref_t
	601	{
	602	vm_pc_t entry_pc;
	603	word_t frame_type;
	604	};
	605
	606	// Reference to a module
	607	class vm_module_ref_t final : public vm_alloc_t
	608	{
	609	public: //static
	610	static std::shared_ptr<const type_descriptor_t> type_desc();
	611
	612	public:
	613	vm_module_ref_t(std::shared_ptr<const vm_module_t> module);
	614	vm_module_ref_t(std::shared_ptr<const vm_module_t> module, const import_vm_module_t &imports);
	615	~vm_module_ref_t();
	616
	617	std::shared_ptr<const vm_module_t> module;
	618	vm_alloc_t *mp_base;
	619	const code_section_t &code_section;
	620	const type_section_map_t &type_section;
	621
	622	bool is_builtin_module() const;
	623	const vm_module_function_ref_t& get_function_ref(word_t index) const;
	624
	625	private:
	626	const bool _builtin_module;
	627	std::unique_ptr<vm_array_t> _function_refs;
	628	};
	629
	630	// VM stack frame
	631	class vm_frame_t final
	632	{
	633	public:
	634	vm_frame_t(std::shared_ptr<const type_descriptor_t> &frame_type);
	635	~vm_frame_t();
	636
	637	std::shared_ptr<const type_descriptor_t> frame_type;
	638
	639	// Copy the frame contents
	640	void copy_frame_contents(const vm_frame_t &other);
	641
	642	// Pointer to the base of the frame.
	643	pointer_t base() const;
	644
	645	template<typename T>
	646	T& base() const
	647	{
	648	return reinterpret_cast<T >(base());
	649	}
	650
	651	vm_pc_t &prev_pc() const;
	652	vm_frame_t *&prev_frame() const;
	653
	654	// This is only set if this frame represents a module transition.
	655	vm_module_ref_t *&prev_module_ref() const;
	656
	657	// Fixed point register positions in frame
	658	// [SPEC] These are not defined in the vm spec.
	659
	660	// 'Stmp' in libinterp/xec.c
	661	pointer_t fixed_point_register_1() const;
	662
	663	// 'Dtmp' in libinterp/xec.c
	664	pointer_t fixed_point_register_2() const;
	665	};
	666
	667	// Callback for stack walk.
	668	// Returning 'false' during the stack walk will terminate the walk.
	669	// The second parameter is reserved for internal use by the VM and should not be manipulated.
	670	using vm_stack_walk_callback_t = std::function<bool(const vm_frame_t f, const void reserved)>;
	671
	672	// VM stack
	673	class vm_stack_t final
	674	{
	675	public:
	676	vm_stack_t(std::size_t stack_extent);
	677	~vm_stack_t();
	678
	679	// Allocate a new frame instance.
	680	vm_frame_t *alloc_frame(std::shared_ptr<const type_descriptor_t> frame_type);
	681
	682	// Push the latest allocated frame as the new top frame.
	683	vm_frame_t *push_frame();
	684
	685	// Remove the top frame and return the next frame in the stack.
	686	vm_frame_t *pop_frame();
	687
	688	// Return the current top frame.
	689	vm_frame_t *peek_frame() const;
	690
	691	// Walk the stack getting a callback for each frame.
	692	// This function is __not__ thread safe.
	693	void walk_stack(vm_stack_walk_callback_t callback) const;
	694
	695	private:
	696	std::unique_ptr<vm_alloc_t> _mem;
	697	};
	698
	699	// Walk the supplied stack and faulting module find the handler, handling stack frame, and program counter for the supplied exception ID.
	700	// If an exception handler cannot be found an 'unhandled_user_exception' exception will be thrown.
	701	std::tuple<const handler_t , vm_frame_t , vm_pc_t> find_exception_handler(
	702	const vm_stack_t &stack,
	703	const vm_module_ref_t &faulting_module,
	704	const vm_pc_t faulting_pc,
	705	const vm_string_t &exception_id);
	706
	707	// VM thread states
	708	enum class vm_thread_state_t
	709	{
	710	unknown = 0,
	711
	712	blocked_in_alt, // blocked in alt instruction
	713	blocked_sending, // blocked waiting to send
	714	blocked_receiving, // blocked waiting to receive
	715
	716	debug, // thread is running under a debugger
	717	ready, // ready to run
	718	running,
	719
	720	release, // interpreter released - executing non-vm instructions
	721
	722	exiting, // exit instruction
	723	empty_stack,
	724
	725	broken, // thread crashed
	726	};
	727
	728	// Forward declaration
	729	class vm_thread_t;
	730
	731	// VM registers
	732	class vm_registers_t
	733	{
	734	public:
	735	vm_registers_t(
	736	const vm_thread_t &thread,
	737	vm_module_ref_t &entry);
	738	~vm_registers_t();
	739
	740	const vm_thread_t &thread;
	741	vm_stack_t stack; // Frame pointer access (FP)
	742	vm_pc_t pc; // Program counter (Index into module code section)
	743	vm_alloc_t *mp_base; // Module data base pointer (MP)
	744	vm_module_ref_t *module_ref; // Module reference
	745	vm_request_mutex_t request_mutex;
	746	vm_thread_state_t current_thread_state;
	747	pointer_t src;
	748	pointer_t mid;
	749	pointer_t dest;
	750	};
	751
	752	// VM thread
	753	class vm_thread_t final : public vm_alloc_t
	754	{
	755	public: //static
	756	static std::shared_ptr<const type_descriptor_t> type_desc();
	757
	758	public:
	759	vm_thread_t(
	760	vm_module_ref_t &entry,
	761	uint32_t parent_thread_id);
	762	vm_thread_t(
	763	vm_module_ref_t &entry,
	764	const vm_frame_t &initial_frame,
	765	vm_pc_t start_pc,
	766	uint32_t parent_thread_id);
	767
	768	~vm_thread_t();
	769
	770	vm_thread_state_t execute(vm_t &virtual_machine, uint32_t quanta);
	771
	772	vm_thread_state_t get_state() const;
	773
	774	uint32_t get_thread_id() const;
	775
	776	uint32_t get_parent_thread_id() const;
	777
	778	const vm_registers_t& get_registers() const;
	779
	780	private:
	781	const uint32_t _thread_id;
	782	const uint32_t _parent_thread_id;
	783	vm_registers_t _registers;
	784	};
	785
	786	//
	787	// VM interfaces
	788	//
	789
	790	// VM thread scheduler control interface
	791	class vm_scheduler_control_t
	792	{
	793	public:
	794	virtual ~vm_scheduler_control_t() = 0;
	795
	796	// Indicates the scheduler should enqueue the blocked thread with the supplied ID.
	797	// There is no indication if this function failed or succeeded.
	798	virtual void enqueue_blocked_thread(uint32_t thread_id) = 0;
	799
	800	// Get all VM threads
	801	virtual std::vector<std::shared_ptr<const vm_thread_t>> get_all_threads() const = 0;
	802	};
	803
	804	// VM thread scheduler interface
	805	class vm_scheduler_t
	806	{
	807	public:
	808	virtual ~vm_scheduler_t() = 0;
	809
	810	// Returns true if there are no vm threads executing, scheduled to be executed, or blocked.
	811	virtual bool is_idle() const = 0;
	812
	813	// Get controller
	814	virtual vm_scheduler_control_t &get_controller() const = 0;
	815
	816	// Schedule the supplied thread for execution
	817	virtual const vm_thread_t& schedule_thread(std::unique_ptr<vm_thread_t> thread) = 0;
	818	};
	819
	820	// VM garbage collector interface
	821	class vm_garbage_collector_t
	822	{
	823	public:
	824	// The supplied allocation is guaranteed to be valid for the lifetime of the callback.
	825	using vm_alloc_callback_t = std::function<void(const vm_alloc_t *)>;
	826
	827	public:
	828	virtual ~vm_garbage_collector_t() = 0;
	829
	830	// Supply an allocation for the collector to track.
	831	// Note that it is assumed the collector implementation will increment the reference count on the supplied alloc.
	832	virtual void track_allocation(vm_alloc_t *alloc) = 0;
	833
	834	// Enumerate allocations that are being tracked by the collector.
	835	// See callback type description.
	836	virtual void enum_tracked_allocations(vm_alloc_callback_t callback) const = 0;
	837
	838	// Called by the scheduler to inform the collector it should attempt to free resources.
	839	// All VM threads are guaranteed to be idle when called.
	840	// Returns true if the collection algorithm was run, otherwise false.
	841	virtual bool collect(std::vector<std::shared_ptr<const vm_thread_t>> &threads) = 0;
	842	};
	843	}
	844	}
	845
	846	#endif // _DISVM_SRC_INCLUDE_RUNTIME_H_

src/include/utf8.h+57−0

@@ -0,0 +1,57 @@
	1	//
	2	// Dis VM
	3	// File: utf8.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_UTF8_H_
	8	#define _DISVM_SRC_INCLUDE_UTF8_H_
	9
	10	#include <cstdint>
	11	#include "runtime.h"
	12
	13	namespace disvm
	14	{
	15	namespace runtime
	16	{
	17	namespace utf8
	18	{
	19	// As defined in http://tools.ietf.org/html/rfc3629
	20	struct constants
	21	{
	22	static const rune_t multi_byte_value_mask = 0x3f;
	23
	24	static const rune_t max_codepoint_ascii = 0x7f;
	25	static const rune_t max_codepoint_2_byte = 0x7ff;
	26	static const rune_t max_codepoint_3_byte = 0xffff;
	27	static const rune_t max_codepoint_4_byte = 0x10ffff;
	28
	29	static const rune_t max_supported_codepoint = max_codepoint_4_byte;
	30	};
	31
	32	// Compute the number of code points in the supplied string
	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);
	35
	36	enum class decode_state
	37	{
	38	accept = 0,
	39	reject = 12
	40	};
	41
	42	// Decode a byte at a time to form a codepoint.
	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);
	45
	46	// Decode the next codepoint in the supplied string.
	47	// Returns number of characters in string consumed.
	48	std::size_t decode(const uint8_t *str, rune_t &codepoint);
	49
	50	// Encode the rune into the supplied buffer.
	51	// Returns updated pointer in the buffer or null on error.
	52	uint8_t encode(const rune_t rune, uint8_t str);
	53	}
	54	}
	55	}
	56
	57	#endif // _DISVM_SRC_INCLUDE_UTF8_H_

src/include/utils.h+47−0

@@ -0,0 +1,47 @@
	1	//
	2	// Dis VM
	3	// File: utils.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_UTILS_H_
	8	#define _DISVM_SRC_INCLUDE_UTILS_H_
	9
	10	#include <cstdint>
	11	#include <type_traits>
	12
	13	namespace disvm
	14	{
	15	namespace util
	16	{
	17	template<typename Flags>
	18	inline bool has_flag(const Flags flags, const Flags flag)
	19	{
	20	return (static_cast<std::underlying_type_t<Flags>>(flags) & static_cast<std::underlying_type_t<Flags>>(flag)) != 0;
	21	}
	22
	23	template <typename T1, typename T2>
	24	inline bool are_equal(const T1 &l, const T2 &r)
	25	{
	26	return (l == r);
	27	}
	28
	29	template <typename T1, typename T2, typename... Others>
	30	inline bool are_equal(const T1 &l, const T2 &r, const Others &... args)
	31	{
	32	return (l == r) && are_equal(r, args...);
	33	}
	34	}
	35	}
	36
	37	// Adopted from 'winnt.h' in the Windows SDK
	38	#define DEFINE_ENUM_FLAG_OPERATORS(TYPE) \
	39	inline TYPE operator \| (TYPE a, TYPE b) { return static_cast<TYPE>(static_cast<std::underlying_type_t<TYPE>>(a) \| static_cast<std::underlying_type_t<TYPE>>(b)); } \
	40	inline TYPE &operator \|= (TYPE &a, TYPE b) { a = a \| b; return a; } \
	41	inline TYPE operator & (TYPE a, TYPE b) { return static_cast<TYPE>(static_cast<std::underlying_type_t<TYPE>>(a) & static_cast<std::underlying_type_t<TYPE>>(b)); } \
	42	inline TYPE &operator &= (TYPE &a, TYPE b) { a = a & b; return a; } \
	43	inline TYPE operator ^ (TYPE a, TYPE b) { return static_cast<TYPE>(static_cast<std::underlying_type_t<TYPE>>(a) ^ static_cast<std::underlying_type_t<TYPE>>(b)); } \
	44	inline TYPE &operator ^= (TYPE &a, TYPE b) { a = a ^ b; return a; } \
	45	inline TYPE operator ~ (TYPE a) { return static_cast<TYPE>(~static_cast<std::underlying_type_t<TYPE>>(a)); }
	46
	47	#endif // _DISVM_SRC_INCLUDE_UTILS_H_

src/include/vm_memory.h+109−0

@@ -0,0 +1,109 @@
	1	//
	2	// Dis VM
	3	// File: vm_memory.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_INCLUDE_VM_MEMORY_H_
	8	#define _DISVM_SRC_INCLUDE_VM_MEMORY_H_
	9
	10	#include <cstdint>
	11	#include <cassert>
	12	#include <mutex>
	13	#include <memory>
	14	#include <bitset>
	15	#include <functional>
	16	#include "runtime.h"
	17
	18	namespace disvm
	19	{
	20	namespace runtime
	21	{
	22	class global_alloc_lock_t final
	23	{
	24	public:
	25	global_alloc_lock_t(const global_alloc_lock_t &) = delete;
	26	global_alloc_lock_t& operator=(const global_alloc_lock_t &) = delete;
	27
	28	global_alloc_lock_t(global_alloc_lock_t &&);
	29
	30	~global_alloc_lock_t();
	31
	32	private:
	33	bool _owner;
	34	global_alloc_lock_t(bool owner);
	35	friend global_alloc_lock_t get_global_alloc_lock();
	36	};
	37
	38	// Take the global allocation lock for the VM heap.
	39	// While this lock is taken all further allocations will block.
	40	global_alloc_lock_t get_global_alloc_lock();
	41
	42	// Allocate memory from the VM heap
	43	void *alloc_memory(std::size_t amount_in_bytes);
	44
	45	template<typename T>
	46	T *alloc_memory(std::size_t amount_in_bytes = sizeof(T))
	47	{
	48	return reinterpret_cast<T *>(alloc_memory(amount_in_bytes));
	49	}
	50
	51	// Allocate memory from the VM heap and initialize to 0.
	52	void *calloc_memory(std::size_t amount_in_bytes);
	53
	54	template<typename T>
	55	T *calloc_memory(std::size_t amount_in_bytes = sizeof(T))
	56	{
	57	return reinterpret_cast<T *>(calloc_memory(amount_in_bytes));
	58	}
	59
	60	// Free memory on the VM heap
	61	void free_memory(void *memory);
	62
	63	// Initialize supplied memory based on the type descriptor
	64	void init_memory(const type_descriptor_t &type_desc, void *data);
	65
	66	// Destroy supplied memory based on the type descriptor
	67	void destroy_memory(const type_descriptor_t &type_desc, void *data);
	68
	69	// Increment the ref count of all points in the supplied memory allocation
	70	void inc_ref_count_in_memory(const type_descriptor_t &type_desc, void *data);
	71
	72	// Decrement the ref count and if 0 free the allocation.
	73	void dec_ref_count_and_free(vm_alloc_t *alloc);
	74
	75	using pointer_field_callback_t = std::function<void(pointer_t)>;
	76
	77	// The callback will be called on all non-null pointer fields.
	78	inline void enum_pointer_fields(const type_descriptor_t &type_desc, void *data, pointer_field_callback_t callback)
	79	{
	80	assert(data != nullptr && callback != nullptr);
	81	auto memory_word_len = std::size_t{ type_desc.size_in_bytes / sizeof(word_t) };
	82	if (memory_word_len == 0)
	83	return;
	84
	85	auto memory = reinterpret_cast<word_t *>(data);
	86	assert((memory_word_len / sizeof(word_t)) <= static_cast<std::size_t>(type_desc.size_in_bytes)); // type desc is in bytes convert len to bytes from words.
	87	for (auto i = word_t{ 0 }; i < type_desc.map_in_bytes; ++i, memory += 8)
	88	{
	89	const auto words8 = type_desc.pointer_map[i];
	90	if (words8 != 0)
	91	{
	92	auto flags = std::bitset<sizeof(words8) * 8>{ words8 };
	93
	94	// Enumerating the flags in reverse order so memory access is linear.
	95	if (flags[7] && (memory[0] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[0]));
	96	if (flags[6] && (memory[1] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[1]));
	97	if (flags[5] && (memory[2] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[2]));
	98	if (flags[4] && (memory[3] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[3]));
	99	if (flags[3] && (memory[4] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[4]));
	100	if (flags[2] && (memory[5] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[5]));
	101	if (flags[1] && (memory[6] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[6]));
	102	if (flags[0] && (memory[7] != runtime_constants::nil)) callback(reinterpret_cast<pointer_t>(memory[7]));
	103	}
	104	}
	105	}
	106	}
	107	}
	108
	109	#endif // _DISVM_SRC_INCLUDE_VM_MEMORY_H_