plan9-archive/DisVM-cpp

.gitignore+23−0

@@ -0,0 +1,23 @@
	1	# Ignore VS noise
	2	Debug
	3	Release
	4	*suo
	5	*filters
	6	*sdf
	7	*sln
	8	*proj
	9	*.VC.opendb
	10	*.db
	11	*.user
	12
	13	# Ignore all log files
	14	*.log
	15
	16	# Ignore VIM temporary files
	17	*~
	18	*.swp
	19
	20	# Ignore limbo binary files
	21	*.dis
	22	*.s
	23	*.sbl

readme.md+21−0

@@ -0,0 +1,21 @@
	1	Dis VM Project Overview
	2	========================
	3
	4	# Build instructions
	5
	6	Dis VM build scripts can be generated using gyp (Generate-Your-Project)
	7
	8	### Requirements
	9	* gyp - http://gyp.gsrc.io
	10	* Python 2.7 - http://www.python.org/download/releases/2.7/
	11
	12	1. Install Python 2.7
	13	2. Get the current source for gyp
	14	3. Generate build file for your platform
	15	* Windows - gyp.bat src/sh/sh.gyp
	16	* Other - gyp_main.py src/sh/sh.gyp
	17
	18	# Source Comment Definitions:
	19	[TODO] - Work to be done in the future.
	20	[SPEC] - A departure or undocumented assumption in the Dis VM specification.
	21	[PERF] - Potential for performance improvement.

src/include/builtin_module.h+66−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_

src/sh/main.cpp+52−0

@@ -0,0 +1,52 @@
	1	//
	2	// Dis VM - Shell
	3	// File: main.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cstdio>
	8	#include <cstdarg>
	9	#include <ctime>
	10	#include <disvm.h>
	11	#include <debug.h>
	12
	13	int main(int argc, char* argv[])
	14	{
	15	auto module = "C:\\Users\\linuxuser27\\source\\disvm\\basic_limbo_tests.dis";
	16	//auto module = "C:\\inferno\\dis\\limbo.dis";
	17	//auto module = "C:\\Users\\linuxuser27\\source\\disvm\\empty.dis";
	18
	19	if (argc >= 2)
	20	module = argv[1];
	21
	22	clock_t t = ::clock();
	23
	24	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::memory, true);
	25	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::module, true);
	26	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::exception, true);
	27	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::scheduler, true);
	28	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::channel, true);
	29	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::addressing, true);
	30	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::stack, true);
	31	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::thread, true);
	32	//disvm::debug::set_component_tracing(disvm::debug::component_trace_t::garbage_collector, true);
	33	disvm::debug::set_logging_callback([](const disvm::debug::component_trace_t, const disvm::debug::log_level_t l, const char *msg, std::va_list ls) { std::vprintf(msg, ls); });
	34
	35	int c = 1;
	36	//for (;;)
	37	{
	38	::printf("####### VM test loop (%d) #######\n", c++);
	39	disvm::vm_t v{ 1, 2048 };
	40
	41	for (auto i = 0; i < 1; ++i)
	42	v.exec(module);
	43
	44	v.spin_sleep_till_idle(std::chrono::milliseconds(10));
	45	}
	46
	47	t = std::clock() - t;
	48	std::printf("\n\n%d msec.\n", t);
	49
	50	return 0;
	51	}
	52

src/sh/sh.gyp+72−0

@@ -0,0 +1,72 @@
	1	{
	2	'targets': [
	3	{
	4	'target_name': 'disvm-sh',
	5	'type': 'executable',
	6	'sources': [
	7	'main.cpp'
	8	],
	9	'configurations': {
	10	'Release': {
	11	'msvs_settings': {
	12	'VCCLCompilerTool': {
	13	'ExceptionHandling': 1,
	14	}
	15	}
	16	}
	17	},
	18	'include_dirs': [
	19	'../include'
	20	],
	21	'dependencies': [
	22	'../vm/disvm.gyp:disvm'
	23	],
	24	'conditions': [
	25	[ 'OS=="mac"', {
	26	'include_dirs': [
	27	'../include/osx'
	28	],
	29	'xcode_settings': {
	30	'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
	31	'OTHER_CPLUSPLUSFLAGS' : ['-std=c++1y','-stdlib=libc++'],
	32	'OTHER_LDFLAGS': ['-stdlib=libc++'],
	33	'MACOSX_DEPLOYMENT_TARGET': '10.10'
	34	}
	35	}],
	36	['OS=="win"', {
	37	'include_dirs': [
	38	'../include/win32'
	39	],
	40	'configurations': {
	41	'Release': {
	42	'msvs_settings': {
	43	'VCCLCompilerTool': {
	44	'ExceptionHandling': 1,
	45	}
	46	}
	47	},
	48	'Debug': {
	49	'msvs_settings': {
	50	'VCCLCompilerTool': {
	51	'ExceptionHandling': 1,
	52	}
	53	}
	54	}
	55	},
	56	'msvs_settings': {
	57	'VCCLCompilerTool': {
	58	'ExceptionHandling': '1', # /EHsc - This seems to only impact Debug, not Release
	59	'TreatWChar_tAsBuiltInType': 'false',
	60	'WarningLevel': '2', # Level 3
	61	'DebugInformationFormat': '3', # PDB
	62	}
	63	}
	64	}],
	65	['OS=="linux"', {
	66	'cflags': ['-std=c++1y'],
	67	'cflags_cc': ['-fexceptions'],
	68	}]
	69	]
	70	}
	71	]
	72	}

src/vm/array.cpp+188−0

@@ -0,0 +1,188 @@
	1	//
	2	// Dis VM
	3	// File: array.cpp
	4	// Author: arr
	5	//
	6
	7	#include <runtime.h>
	8	#include <vm_memory.h>
	9	#include <debug.h>
	10	#include <exceptions.h>
	11
	12	using namespace disvm;
	13	using namespace disvm::runtime;
	14
	15	std::shared_ptr<const type_descriptor_t> vm_array_t::type_desc()
	16	{
	17	return intrinsic_type_desc::type<vm_array_t>();
	18	}
	19
	20	vm_array_t::vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t count)
	21	: vm_alloc_t(vm_array_t::type_desc())
	22	, _arr{ nullptr }
	23	, _element_type{ td }
	24	, _length{ count }
	25	, _original{ nullptr }
	26	{
	27	assert(_element_type != nullptr);
	28	assert(_length >= 0);
	29	_arr = alloc_memory<byte_t>(_length * _element_type->size_in_bytes);
	30	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm array: %d\n", _length);
	31
	32	// Initialize the array
	33	auto arr_local = _arr;
	34	const auto array_len = _length;
	35	const auto &element_type = *_element_type;
	36	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "begin: init: elements: %d\n", array_len);
	37	for (word_t i = 0; i < array_len; ++i)
	38	{
	39	init_memory(element_type, arr_local);
	40	arr_local += element_type.size_in_bytes;
	41	}
	42
	43	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "end: init: elements: %d\n", array_len);
	44	}
	45
	46	vm_array_t::vm_array_t(std::shared_ptr<const type_descriptor_t> td, word_t count, const zero_memory_t&)
	47	: vm_alloc_t(vm_array_t::type_desc())
	48	, _arr{ nullptr }
	49	, _element_type{ td }
	50	, _length{ count }
	51	, _original{ nullptr }
	52	{
	53	assert(_element_type != nullptr);
	54	assert(_length >= 0);
	55	_arr = calloc_memory<byte_t>(_length * _element_type->size_in_bytes);
	56	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "initz: vm array: %d\n", _length);
	57	}
	58
	59	vm_array_t::vm_array_t(vm_array_t *original, word_t begin_index, word_t count)
	60	: vm_alloc_t(vm_array_t::type_desc())
	61	, _arr{ nullptr }
	62	, _element_type{ original->get_element_type() }
	63	, _length{ count }
	64	, _original{ original }
	65	{
	66	assert(_original != nullptr);
	67	assert(0 <= begin_index && begin_index < _original->get_length());
	68	assert(_length >= 0 && (count - begin_index) < _original->get_length());
	69
	70	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	71	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm array: slice: %d %d\n", begin_index, _length);
	72
	73	// Set the data to reference the original array
	74	_arr = _original->_arr + (begin_index * _element_type->size_in_bytes);
	75
	76	// Check if this is a slice of a slice.
	77	if (_original->_original != nullptr)
	78	{
	79	auto actual_original = _original->_original;
	80	dec_ref_count_and_free(_original);
	81
	82	_original = actual_original;
	83	_original->add_ref();
	84	}
	85	}
	86
	87	vm_array_t::vm_array_t(const vm_string_t *s)
	88	: vm_alloc_t(vm_array_t::type_desc())
	89	, _arr{ nullptr }
	90	, _element_type{ intrinsic_type_desc::type<byte_t>() }
	91	, _length{ 0 }
	92	, _original{ nullptr }
	93	{
	94	if (s != nullptr && s->get_length() > 0)
	95	{
	96	auto str = s->str();
	97
	98	// Ignoring the null terminator.
	99	_length = std::strlen(str);
	100	_arr = alloc_memory<byte_t>(_length);
	101	static_assert(sizeof(byte_t) == sizeof(char), "String characters should be byte size");
	102
	103	std::memcpy(_arr, str, _length);
	104	}
	105
	106	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	107	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm array: vm string: %d\n", _length);
	108	}
	109
	110	vm_array_t::~vm_array_t()
	111	{
	112	if (_original != nullptr)
	113	{
	114	// If the array is a sliced (based off of another array) then the
	115	// inner pointer simply points into the original array.
	116	debug::assign_debug_pointer(&_arr);
	117
	118	dec_ref_count_and_free(_original);
	119	debug::assign_debug_pointer(&_original);
	120
	121	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm array: slice\n");
	122	}
	123	else
	124	{
	125	// Free the array
	126	auto arr_local = _arr;
	127	const auto array_len = _length;
	128	const auto &element_type = *_element_type;
	129	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "begin: destroy: elements: %d\n", array_len);
	130	for (word_t i = 0; i < array_len; ++i)
	131	{
	132	destroy_memory(element_type, arr_local);
	133	arr_local += element_type.size_in_bytes;
	134	}
	135	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "end: destroy: elements: %d\n", array_len);
	136
	137	// Free array memory
	138	free_memory(_arr);
	139
	140	debug::assign_debug_pointer(&_arr);
	141	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm array\n");
	142	}
	143
	144	}
	145
	146	std::shared_ptr<const type_descriptor_t> vm_array_t::get_element_type() const
	147	{
	148	return _element_type;
	149	}
	150
	151	word_t vm_array_t::get_length() const
	152	{
	153	return _length;
	154	}
	155
	156	pointer_t vm_array_t::at(word_t index) const
	157	{
	158	if (index < 0 \|\| _length <= index)
	159	throw out_of_range_memory{ 0, _length - 1, index };
	160
	161	return reinterpret_cast<pointer_t>(_arr + (index * _element_type->size_in_bytes));
	162	}
	163
	164	void vm_array_t::copy_from(const vm_array_t &source, word_t this_begin_index)
	165	{
	166	if (this_begin_index < 0 \|\| _length < (this_begin_index + source._length))
	167	throw out_of_range_memory{};
	168
	169	if (source._element_type != _element_type)
	170	throw type_violation{};
	171
	172	auto dest_arr = _arr + (this_begin_index * _element_type->size_in_bytes);
	173
	174	// Increment all pointers if we have reference types.
	175	if (_element_type->map_in_bytes != 0)
	176	{
	177	assert(false && "Not implemented");
	178	//auto &type_desc = *_element_type;
	179	//auto source_array_element = source->_arr;
	180	//for (word_t i = 0; i < source->_length; ++i)
	181	//{
	182	// source_array_element += (i * type_desc.size_in_bytes);
	183	// inc_ref_count_in_alloc(type_desc, source_array_element);
	184	//}
	185	}
	186
	187	std::memcpy(dest_arr, source._arr, (source._length * _element_type->size_in_bytes));
	188	}

src/vm/buffered_reader.h+125−0

@@ -0,0 +1,125 @@
	1	//
	2	// Dis VM
	3	// File: buffered_reader.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_VM_BUFFERED_READER_H_
	8	#define _DISVM_SRC_VM_BUFFERED_READER_H_
	9
	10	#include <cstdint>
	11	#include <cassert>
	12	#include <vector>
	13	#include <tuple>
	14	#include <iosfwd>
	15
	16	namespace disvm
	17	{
	18	namespace util
	19	{
	20	class buffered_reader_t
	21	{
	22	private: // static
	23	static const std::size_t buffer_size = 64 * 1024; // 64k is an optimization for the Windows filesystem manager
	24
	25	public:
	26	buffered_reader_t(std::istream &stream)
	27	: _buffer(buffered_reader_t::buffer_size)
	28	, _current_index{ 0 }
	29	, _current_size{ 0 }
	30	, _stream{ stream }
	31	{
	32	assert(!stream.fail());
	33	}
	34
	35	buffered_reader_t(const buffered_reader_t&) = delete;
	36	buffered_reader_t& operator=(const buffered_reader_t&) = delete;
	37
	38	// Get the next 'n' number of bytes.
	39	// Returns the number of bytes retrieved.
	40	uint32_t get_next_bytes(uint32_t bytes_requested, uint8_t *buffer)
	41	{
	42	if (bytes_requested == 0)
	43	return 0;
	44
	45	assert(buffer != nullptr);
	46
	47	auto bytes_requested_acc = uint32_t{0};
	48	std::size_t amount_in_buffer;
	49
	50	for (;;)
	51	{
	52	bool success = check_buffer_content(amount_in_buffer);
	53	if (!success \|\| amount_in_buffer == 0)
	54	return 0;
	55
	56	// Buffer contains requested amount
	57	if (bytes_requested <= amount_in_buffer)
	58	{
	59	std::memcpy(buffer, (_buffer.data() + _current_index), bytes_requested);
	60	_current_index += bytes_requested;
	61	bytes_requested_acc += bytes_requested;
	62	return bytes_requested_acc;
	63	}
	64	else
	65	{
	66	// Buffer does not contain all the data requested
	67	std::memcpy(buffer, (_buffer.data() + _current_index), amount_in_buffer);
	68	_current_index += amount_in_buffer;
	69
	70	// Subtract the bytes consumed
	71	bytes_requested -= amount_in_buffer;
	72
	73	bytes_requested_acc += amount_in_buffer;
	74	buffer += amount_in_buffer;
	75	}
	76	}
	77	}
	78
	79	// Get the next byte in the buffer.
	80	// Returns success and the byte.
	81	std::tuple<bool, uint8_t> get_next_byte()
	82	{
	83	std::size_t amount_in_buffer;
	84	bool success = check_buffer_content(amount_in_buffer);
	85	if (!success \|\| amount_in_buffer == 0)
	86	return std::make_tuple(false, 0);
	87
	88	return std::make_tuple(true, _buffer[_current_index++]);
	89	}
	90
	91	private:
	92	bool check_buffer_content(std::size_t &amount_in_buffer)
	93	{
	94	// Signed so checking for underflow is easier.
	95	amount_in_buffer = 0;
	96	auto amount_in_buffer_local = _current_size - _current_index;
	97	if (amount_in_buffer_local <= 0)
	98	{
	99	_current_index = 0;
	100	_current_size = 0;
	101
	102	if (_stream.fail())
	103	return false;
	104
	105	_stream.read(_buffer.data(), buffered_reader_t::buffer_size);
	106	_current_size = _stream.fail() ? static_cast<std::size_t>(_stream.gcount()) : buffered_reader_t::buffer_size;
	107
	108	// Reset amount in buffer
	109	amount_in_buffer_local = buffered_reader_t::buffer_size;
	110	}
	111
	112	amount_in_buffer = amount_in_buffer_local;
	113	return true;
	114	}
	115
	116	private:
	117	std::istream &_stream;
	118	std::size_t _current_index;
	119	std::size_t _current_size;
	120	std::vector<char> _buffer;
	121	};
	122	}
	123	}
	124
	125	#endif // _DISVM_SRC_VM_BUFFERED_READER_H_

src/vm/builtin_module.cpp+113−0

@@ -0,0 +1,113 @@
	1	//
	2	// Dis VM
	3	// File: builtin_module.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cassert>
	8	#include <atomic>
	9	#include <mutex>
	10	#include <forward_list>
	11	#include <runtime.h>
	12	#include <module_reader.h>
	13	#include <builtin_module.h>
	14	#include <debug.h>
	15	#include <exceptions.h>
	16
	17	using namespace disvm::runtime;
	18	using namespace disvm::runtime::builtin;
	19
	20	namespace
	21	{
	22	std::atomic_bool builtin_modules_initialized;
	23
	24	std::mutex builtin_modules_lock;
	25	std::forward_list<std::shared_ptr<vm_module_t>> builtin_modules;
	26	}
	27
	28	// Declare initializers for built-in modules.
	29	extern void Sysmodinit(void);
	30
	31	void disvm::runtime::builtin::initialize_builtin_modules()
	32	{
	33	auto is_false = bool{ false };
	34	if (!builtin_modules_initialized.compare_exchange_strong(is_false, true))
	35	return;
	36
	37	// Add built-in module initialization calls here.
	38	// e.g. Sysmodinit()
	39
	40	Sysmodinit();
	41	}
	42
	43	void disvm::runtime::builtin::register_module_exports(const char name, word_t table_length, const vm_runtab_t module_runtime_table)
	44	{
	45	assert(name != nullptr && (module_runtime_table != nullptr \|\| table_length == 0) && 0 <= table_length);
	46	assert(name[0] == BUILTIN_MODULE_PREFIX_CHAR && "Built-in modules should have the \"" BUILTIN_MODULE_PREFIX_STR "\" prefix");
	47
	48	auto new_builtin = std::make_shared<vm_module_t>();
	49
	50	// Define the module header
	51	auto &header = new_builtin->header;
	52	header.magic_number = format::magic_number_constants::xmagic;
	53	header.Signature.length = word_t{ 0 };
	54	header.runtime_flag = runtime_flags_t::builtin;
	55
	56	header.stack_extent = 0;
	57	header.code_size = table_length;
	58	header.data_size = 0;
	59	header.type_size = table_length; // 1 for each function frame type
	60	header.export_size = table_length;
	61	header.entry_pc = runtime_constants::invalid_program_counter;
	62	header.entry_type = -1;
	63
	64	new_builtin->module_name = std::make_unique<vm_string_t>(::strlen(name), reinterpret_cast<const uint8_t *>(name));
	65
	66	// Fill out code, type, and export sections
	67	for (auto i = word_t{ 0 }; i < table_length; ++i)
	68	{
	69	const auto &ex = module_runtime_table[i];
	70
	71	// Type
	72	auto frame_type = type_descriptor_t::create(ex.frame_size, ex.frame_pointer_count, ex.frame_pointer_map);
	73	new_builtin->type_section.push_back(std::move(frame_type));
	74
	75	// Export
	76	auto item = export_function_t{};
	77	item.pc = i;
	78	item.frame_type = i;
	79	item.sig = static_cast<word_t>(ex.sig);
	80	item.name = std::make_unique<vm_string_t>(std::strlen(ex.name), reinterpret_cast<const uint8_t *>(ex.name));
	81
	82	const auto sig = item.sig;
	83	new_builtin->export_section.emplace(sig, std::move(item));
	84
	85	// Instruction
	86	auto vm_instr = vm_instruction_t{};
	87	vm_instr.native = ex.fn;
	88	new_builtin->code_section.push_back(std::move(vm_instr));
	89	}
	90
	91	{
	92	std::lock_guard<std::mutex> lock{ builtin_modules_lock };
	93
	94	#ifndef NDEBUG
	95	for (const auto &m : builtin_modules)
	96	assert(0 != std::strcmp(m->module_name->str(), name) && "Built-in module with matching name already exists");
	97	#endif
	98
	99	builtin_modules.push_front(std::move(new_builtin));
	100	}
	101	}
	102
	103	std::shared_ptr<vm_module_t> disvm::runtime::builtin::get_builtin_module(const char *name)
	104	{
	105	std::lock_guard<std::mutex> lock{ builtin_modules_lock };
	106	for (const auto &m : builtin_modules)
	107	{
	108	if (0 == std::strcmp(m->module_name->str(), name))
	109	return m;
	110	}
	111
	112	throw vm_module_exception{ "Unknown built-in module" };
	113	}

src/vm/channel.cpp+292−0

@@ -0,0 +1,292 @@
	1	//
	2	// Dis VM
	3	// File: channel.cpp
	4	// Author: arr
	5	//
	6
	7	#include <runtime.h>
	8	#include <vm_memory.h>
	9	#include <debug.h>
	10	#include <exceptions.h>
	11
	12	using namespace disvm;
	13	using namespace disvm::runtime;
	14
	15	vm_request_mutex_t::vm_request_mutex_t()
	16	: pending_request{ false }
	17	{ }
	18
	19	vm_channel_request_t::vm_channel_request_t(uint32_t thread_id, vm_request_mutex_t &request_mutex)
	20	: data{ nullptr }
	21	, request_mutex{ request_mutex }
	22	, thread_id{ thread_id }
	23	{ }
	24
	25	std::shared_ptr<const type_descriptor_t> vm_channel_t::type_desc()
	26	{
	27	return intrinsic_type_desc::type<vm_channel_t>();
	28	}
	29
	30	vm_channel_t::vm_channel_t(
	31	std::shared_ptr<const type_descriptor_t> td,
	32	std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> transfer,
	33	word_t buffer_len)
	34	: vm_alloc_t(vm_channel_t::type_desc())
	35	, _data_buffer{ nullptr }
	36	, _data_buffer_head{ 0 }
	37	, _data_buffer_count{ 0 }
	38	, _data_transfer{ transfer }
	39	, _data_type{ td }
	40	{
	41	if (buffer_len < 0)
	42	throw out_of_range_memory{};
	43
	44	if (buffer_len > 0)
	45	_data_buffer = new vm_array_t{ td, buffer_len };
	46
	47	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm channel\n");
	48	}
	49
	50	vm_channel_t::~vm_channel_t()
	51	{
	52	dec_ref_count_and_free(_data_buffer);
	53	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm channel\n");
	54	}
	55
	56	std::shared_ptr<const type_descriptor_t> vm_channel_t::get_data_type() const
	57	{
	58	return _data_type;
	59	}
	60
	61	bool vm_channel_t::send_data(vm_channel_request_t &send_request)
	62	{
	63	assert(send_request.request_handled_callback != nullptr && send_request.data != nullptr);
	64
	65	std::lock(_data_lock, send_request.request_mutex.get().pending_request_lock);
	66	std::unique_lock<std::mutex> data_lock{ _data_lock, std::adopt_lock };
	67	std::lock_guard<std::mutex> curr_req_lock{ send_request.request_mutex.get().pending_request_lock, std::adopt_lock };
	68
	69	if (!send_request.request_mutex.get().pending_request)
	70	return false;
	71
	72	// Assert the sender cannot also be a receiver in the channel
	73	assert(std::end(_data_receivers) == std::find_if(
	74	std::begin(_data_receivers),
	75	std::end(_data_receivers),
	76	[&send_request](const vm_channel_request_t &req) { return req.thread_id == send_request.thread_id; }));
	77
	78	auto pending_req_lock = std::unique_lock<std::mutex>{};
	79	for (;;)
	80	{
	81	if (_data_receivers.empty())
	82	{
	83	// Check if there is room in the channel buffer
	84	if (_data_buffer != nullptr)
	85	{
	86	if (try_send_to_buffer(send_request))
	87	return true;
	88	}
	89
	90	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	91	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: send: queue: %d\n", send_request.thread_id);
	92
	93	_data_senders.emplace_back(std::move(send_request));
	94	return false;
	95	}
	96
	97	auto &receiver_maybe = _data_receivers.front();
	98
	99	// Take lock and check the pending request status
	100	pending_req_lock = std::unique_lock<std::mutex>{ receiver_maybe.request_mutex.get().pending_request_lock };
	101	if (receiver_maybe.request_mutex.get().pending_request)
	102	{
	103	// Indicate both request mutexes as non-pending
	104	send_request.request_mutex.get().pending_request = false;
	105	receiver_maybe.request_mutex.get().pending_request = false;
	106	break;
	107	}
	108
	109	pending_req_lock.unlock();
	110	_data_receivers.pop_front();
	111	}
	112
	113	// Remove the receiver from the list
	114	auto receiver = std::move(_data_receivers.front());
	115	_data_receivers.pop_front();
	116
	117	// Transfer data
	118	_data_transfer(receiver.data, send_request.data, _data_type.get());
	119
	120	// Release channel and pending request lock after data transfer
	121	pending_req_lock.unlock();
	122	data_lock.unlock();
	123
	124	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	125	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: send: %d %d\n", send_request.thread_id, receiver.thread_id);
	126
	127	receiver.request_handled_callback(*this);
	128
	129	return true;
	130	}
	131
	132	bool vm_channel_t::receive_data(vm_channel_request_t &receive_request)
	133	{
	134	assert(receive_request.request_handled_callback != nullptr && receive_request.data != nullptr);
	135
	136	std::lock(_data_lock, receive_request.request_mutex.get().pending_request_lock);
	137	std::unique_lock<std::mutex> data_lock{ _data_lock, std::adopt_lock };
	138	std::lock_guard<std::mutex> curr_req_lock{ receive_request.request_mutex.get().pending_request_lock, std::adopt_lock };
	139
	140	if (!receive_request.request_mutex.get().pending_request)
	141	return false;
	142
	143	// Assert the receiver cannot also be a sender in the channel
	144	assert(std::end(_data_senders) == std::find_if(
	145	std::begin(_data_senders),
	146	std::end(_data_senders),
	147	[&receive_request](const vm_channel_request_t &req) { return req.thread_id == receive_request.thread_id; }));
	148
	149	auto pending_req_lock = std::unique_lock<std::mutex>{};
	150	for (;;)
	151	{
	152	if (_data_senders.empty())
	153	{
	154	// Check if there is data in the channel buffer
	155	if (_data_buffer != nullptr)
	156	{
	157	if (try_receive_from_buffer(receive_request))
	158	return true;
	159	}
	160
	161	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	162	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: receive: queue: %d\n", receive_request.thread_id);
	163
	164	_data_receivers.emplace_back(std::move(receive_request));
	165	return false;
	166	}
	167
	168	auto &sender_maybe = _data_senders.front();
	169
	170	// Take lock and check the pending request status
	171	pending_req_lock = std::unique_lock<std::mutex>{ sender_maybe.request_mutex.get().pending_request_lock };
	172	if (sender_maybe.request_mutex.get().pending_request)
	173	{
	174	// Indicate both request mutexes as non-pending
	175	receive_request.request_mutex.get().pending_request = false;
	176	sender_maybe.request_mutex.get().pending_request = false;
	177	break;
	178	}
	179
	180	pending_req_lock.unlock();
	181	_data_senders.pop_front();
	182	}
	183
	184	// Remove the sender from the list
	185	auto sender = std::move(_data_senders.front());
	186	_data_senders.pop_front();
	187
	188	// Check if there is data in the channel buffer. This is being
	189	// done to avoid starving threads that found a full buffer when
	190	// attempting to satisfy a request.
	191	if (_data_buffer != nullptr && try_receive_from_buffer(receive_request))
	192	{
	193	// Data was taken from the buffer, so the current pending sender
	194	// can now use the empty slot.
	195	auto did_send = try_send_to_buffer(sender);
	196	assert(did_send && "Should be room in buffer");
	197	}
	198	else
	199	{
	200	// Transfer data since there wasn't anything in the buffer
	201	_data_transfer(receive_request.data, sender.data, _data_type.get());
	202
	203	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	204	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: receive: %d %d\n", receive_request.thread_id, sender.thread_id);
	205	}
	206
	207	// Release channel and pending request lock after data transfer
	208	pending_req_lock.unlock();
	209	data_lock.unlock();
	210
	211	sender.request_handled_callback(*this);
	212
	213	return true;
	214	}
	215
	216	void vm_channel_t::cancel_request(uint32_t thread_id)
	217	{
	218	std::lock_guard<std::mutex> lock{ _data_lock };
	219
	220	// Create a predicate function based on the input
	221	auto request_predicate = [thread_id](const vm_channel_request_t &req) { return req.thread_id == thread_id; };
	222
	223	auto receiver_iter = std::find_if(std::begin(_data_receivers), std::end(_data_receivers), request_predicate);
	224	if (receiver_iter != std::end(_data_receivers))
	225	{
	226	_data_receivers.erase(receiver_iter);
	227	}
	228	else
	229	{
	230	auto sender_iter = std::find_if(std::begin(_data_senders), std::end(_data_senders), request_predicate);
	231	if (sender_iter == std::end(_data_senders))
	232	return;
	233
	234	_data_senders.erase(sender_iter);
	235	}
	236
	237	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	238	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: cancel: request: %d\n", thread_id);
	239	}
	240
	241	bool vm_channel_t::try_send_to_buffer(vm_channel_request_t &send_request)
	242	{
	243	assert(_data_buffer != nullptr);
	244
	245	const auto buffer_length = static_cast<uint32_t>(_data_buffer->get_length());
	246	if (_data_buffer_count == buffer_length)
	247	return false;
	248
	249	auto next_buffer_index = _data_buffer_head + _data_buffer_count;
	250	if (next_buffer_index >= buffer_length)
	251	next_buffer_index -= buffer_length;
	252
	253	_data_buffer_count++;
	254
	255	auto dest = _data_buffer->at(next_buffer_index);
	256
	257	// Transfer data to buffer
	258	_data_transfer(dest, send_request.data, _data_type.get());
	259	send_request.request_mutex.get().pending_request = false;
	260
	261	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	262	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: send: buffer: %d\n", send_request.thread_id);
	263
	264	return true;
	265	}
	266
	267	bool vm_channel_t::try_receive_from_buffer(vm_channel_request_t &receive_request)
	268	{
	269	assert(_data_buffer != nullptr);
	270
	271	if (_data_buffer_count == 0)
	272	return false;
	273
	274	auto src = _data_buffer->at(_data_buffer_head);
	275	_data_buffer_head++;
	276
	277	const auto buffer_length = _data_buffer->get_length();
	278	if (_data_buffer_head == buffer_length)
	279	_data_buffer_head = 0;
	280
	281	_data_buffer_count--;
	282
	283	// Transfer data from buffer
	284	_data_transfer(receive_request.data, src, _data_type.get());
	285
	286	receive_request.request_mutex.get().pending_request = false;
	287
	288	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	289	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "channel: receive: buffer: %d\n", receive_request.thread_id);
	290
	291	return true;
	292	}

src/vm/debug.cpp+45−0

@@ -0,0 +1,45 @@
	1	//
	2	// Dis VM
	3	// File: debug.cpp
	4	// Author: arr
	5	//
	6
	7	#include <mutex>
	8	#include <array>
	9	#include <debug.h>
	10
	11	namespace
	12	{
	13	std::mutex log_mutex;
	14	disvm::debug::log_callback_t log_callback = nullptr;
	15	}
	16
	17	std::array<bool, static_cast<std::size_t>(disvm::debug::component_trace_t::last) + 1> disvm::debug::trace_enabled = {};
	18
	19	disvm::debug::log_callback_t disvm::debug::set_logging_callback(log_callback_t cb)
	20	{
	21	std::lock_guard<std::mutex> lock{ log_mutex };
	22	auto tmp = log_callback;
	23	log_callback = cb;
	24	return tmp;
	25	}
	26
	27	void disvm::debug::log_msg(const component_trace_t origin, const log_level_t level, const char *msg_fmt, ...)
	28	{
	29	if (log_callback == nullptr)
	30	return;
	31
	32	if (!is_component_tracing_enabled(origin))
	33	return;
	34
	35	std::va_list args;
	36	va_start(args, msg_fmt);
	37
	38	{
	39	std::lock_guard<std::mutex> lock{ log_mutex };
	40	if (log_callback != nullptr)
	41	log_callback(origin, level, msg_fmt, args);
	42	}
	43
	44	va_end(args);
	45	}

src/vm/disvm.gyp+83−0

@@ -0,0 +1,83 @@
	1	{
	2	'targets': [
	3	{
	4	'target_name': 'disvm',
	5	'type': 'static_library',
	6	'sources': [
	7	'array.cpp',
	8	'builtin_module.cpp',
	9	'channel.cpp',
	10	'debug.cpp',
	11	'execution_table.cpp',
	12	'garbage_collector.cpp',
	13	'list.cpp',
	14	'module_reader.cpp',
	15	'module_ref.cpp',
	16	'scheduler.cpp',
	17	'stack.cpp',
	18	'string.cpp',
	19	'thread.cpp',
	20	'utf8.cpp',
	21	'vm.cpp',
	22	'vm_memory.cpp',
	23	'vm_exception_handler.cpp',
	24	'sys/print.cpp',
	25	'sys/Sysmod.cpp',
	26	],
	27	'include_dirs': [
	28	'../include'
	29	],
	30	'conditions': [
	31	['OS=="linux"', {
	32	'include_dirs': [
	33	'../include/linux'
	34	],
	35	'cflags': ['-std=c++1y'],
	36	'cflags_cc': ['-fexceptions'],
	37	'sources': [ ],
	38	}],
	39	['OS=="mac"', {
	40	'include_dirs': [
	41	'../include/osx'
	42	],
	43	'xcode_settings': {
	44	'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
	45	'OTHER_CPLUSPLUSFLAGS' : ['-std=c++1y', '-stdlib=libc++'],
	46	'MACOSX_DEPLOYMENT_TARGET': '10.10'
	47	},
	48	'sources': [ ],
	49	}],
	50	['OS=="win"', {
	51	'include_dirs': [
	52	'../include/win32'
	53	],
	54	'configurations': {
	55	'Release': {
	56	'msvs_settings': {
	57	'VCCLCompilerTool': {
	58	'ExceptionHandling': 1,
	59	}
	60	}
	61	},
	62	'Debug': {
	63	'msvs_settings': {
	64	'VCCLCompilerTool': {
	65	'ExceptionHandling': 1,
	66	}
	67	}
	68	}
	69	},
	70	'msvs_settings': {
	71	'VCCLCompilerTool': {
	72	'ExceptionHandling': '1', # /EHsc - This seems to only impact Debug, not Release
	73	'TreatWChar_tAsBuiltInType': 'false',
	74	'WarningLevel': '2', # Level 3
	75	'DebugInformationFormat': '3', # PDB
	76	}
	77	},
	78	'sources': [ ],
	79	}]
	80	]
	81	}
	82	]
	83	}

src/vm/execution_table.cpp+1814−0

@@ -0,0 +1,1814 @@
	1	//
	2	// Dis VM
	3	// File: execution_table.cpp
	4	// Author: arr
	5	//
	6
	7	#include <type_traits>
	8	#include <numeric>
	9	#include <algorithm>
	10	#include <array>
	11	#include <cstdint>
	12	#include <limits>
	13	#include <random>
	14	#include <disvm.h>
	15	#include <vm_memory.h>
	16	#include <opcodes.h>
	17	#include <utils.h>
	18	#include <exceptions.h>
	19	#include <debug.h>
	20	#include "execution_table.h"
	21
	22	using namespace disvm;
	23	using namespace disvm::runtime;
	24
	25	namespace
	26	{
	27	//
	28	// Private VM primitive data type definitions
	29	//
	30
	31	using uword_t = uint32_t; // unsigned word_t
	32	using ubig_t = uint64_t; // unsigned big_t
	33
	34	template<typename ValueType>
	35	ValueType& vt_ref(pointer_t vt)
	36	{
	37	assert(vt != nullptr);
	38	return reinterpret_cast<ValueType >(vt);
	39	}
	40
	41	template<typename AllocType>
	42	typename std::enable_if<std::is_base_of<vm_alloc_t, AllocType>::value, AllocType *>::type
	43	at_val(pointer_t at)
	44	{
	45	assert(at != nullptr);
	46
	47	return vm_alloc_t::from_allocation<AllocType>(reinterpret_cast<pointer_t >(at));
	48	}
	49
	50	template<>
	51	vm_alloc_t *at_val<vm_alloc_t>(pointer_t at)
	52	{
	53	assert(at != nullptr);
	54
	55	return vm_alloc_t::from_allocation(reinterpret_cast<pointer_t >(at));
	56	}
	57
	58	pointer_t &pt_ref(pointer_t pt)
	59	{
	60	assert(pt != nullptr);
	61	return reinterpret_cast<pointer_t >(pt);
	62	}
	63
	64	#define EXEC_DECL(inst_name) void inst_name(vm_registers_t &r, vm_t& vm)
	65
	66	EXEC_DECL(notimpl) { assert(false && "Instruction not implemented"); throw vm_system_exception{ "Instruction not implemented" }; }
	67
	68	EXEC_DECL(invalid) { throw vm_system_exception{ "Illegal Dis VM instruction" }; }
	69
	70	// [SPEC] Documented as 'Clear exception stack' and defined to be used at the discretion of the VM implementation.
	71	// Implemented as a 'spare slot' in Inferno
	72	EXEC_DECL(eclr) { assert(false && "The 'eclr' instruction is not expected to be used"); }
	73
	74	//
	75	// Bit-wise operations
	76	//
	77
	78	EXEC_DECL(andb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.src) & vt_ref<byte_t>(r.mid); }
	79	EXEC_DECL(andw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.src) & vt_ref<word_t>(r.mid); }
	80	EXEC_DECL(andl) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.src) & vt_ref<big_t>(r.mid); }
	81	EXEC_DECL(orb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.src) \| vt_ref<byte_t>(r.mid); }
	82	EXEC_DECL(orw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.src) \| vt_ref<word_t>(r.mid); }
	83	EXEC_DECL(orl) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.src) \| vt_ref<big_t>(r.mid); }
	84	EXEC_DECL(xorb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.src) ^ vt_ref<byte_t>(r.mid); }
	85	EXEC_DECL(xorw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.src) ^ vt_ref<word_t>(r.mid); }
	86	EXEC_DECL(xorl) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.src) ^ vt_ref<big_t>(r.mid); }
	87
	88	//
	89	// Bit-shift operations
	90	//
	91
	92	EXEC_DECL(shlb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.mid) << vt_ref<byte_t>(r.src); }
	93	EXEC_DECL(shlw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.mid) << vt_ref<word_t>(r.src); }
	94	EXEC_DECL(shll) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.mid) << vt_ref<big_t>(r.src); }
	95	EXEC_DECL(shrb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.mid) >> vt_ref<byte_t>(r.src); }
	96	EXEC_DECL(shrw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.mid) >> vt_ref<word_t>(r.src); }
	97	EXEC_DECL(shrl) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.mid) >> vt_ref<big_t>(r.src); }
	98	EXEC_DECL(lsrw) { vt_ref<word_t>(r.dest) = vt_ref<uword_t>(r.mid) >> vt_ref<word_t>(r.src); }
	99	EXEC_DECL(lsrl) { vt_ref<big_t>(r.dest) = vt_ref<ubig_t>(r.mid) >> vt_ref<big_t>(r.src); }
	100
	101	//
	102	// Conversion operations
	103	//
	104
	105	EXEC_DECL(cvtbw) { vt_ref<word_t>(r.dest) = std::numeric_limits<byte_t>::max() & vt_ref<byte_t>(r.src); }
	106	EXEC_DECL(cvtwb) { vt_ref<byte_t>(r.dest) = std::numeric_limits<byte_t>::max() & vt_ref<word_t>(r.src); }
	107	EXEC_DECL(cvtwl) { vt_ref<big_t>(r.dest) = std::numeric_limits<word_t>::max() & vt_ref<word_t>(r.src); }
	108	EXEC_DECL(cvtlw) { vt_ref<word_t>(r.dest) = std::numeric_limits<word_t>::max() & vt_ref<big_t>(r.src); }
	109	EXEC_DECL(cvtrf) { vt_ref<short_real_t>(r.dest) = static_cast<short_real_t>(vt_ref<real_t>(r.src)); }
	110	EXEC_DECL(cvtfr) { vt_ref<real_t>(r.dest) = static_cast<real_t>(vt_ref<short_real_t>(r.src)); }
	111	EXEC_DECL(cvtws) { vt_ref<short_word_t>(r.dest) = std::numeric_limits<short_word_t>::max() & vt_ref<word_t>(r.src); }
	112	EXEC_DECL(cvtsw) { vt_ref<word_t>(r.dest) = std::numeric_limits<short_word_t>::max() & vt_ref<short_word_t>(r.src); }
	113	EXEC_DECL(cvtlf) { vt_ref<real_t>(r.dest) = static_cast<real_t>(vt_ref<big_t>(r.src)); }
	114	EXEC_DECL(cvtfl)
	115	{
	116	auto f = vt_ref<real_t>(r.src);
	117	f = f < 0 ? (f - 0.5) : (f + 0.5);
	118	vt_ref<big_t>(r.dest) = static_cast<big_t>(f);
	119	}
	120
	121	EXEC_DECL(cvtxf) { vt_ref<real_t>(r.dest) = static_cast<real_t>(vt_ref<word_t>(r.src)) * vt_ref<real_t>(r.mid); }
	122	EXEC_DECL(cvtfx)
	123	{
	124	auto f = vt_ref<real_t>(r.src) * vt_ref<real_t>(r.mid);
	125	f = f < 0 ? (f - 0.5) : (f + 0.5);
	126	vt_ref<word_t>(r.dest) = static_cast<word_t>(f);
	127	}
	128
	129	EXEC_DECL(cvtwf) { vt_ref<real_t>(r.dest) = static_cast<real_t>(vt_ref<word_t>(r.src)); }
	130	EXEC_DECL(cvtfw)
	131	{
	132	auto f = vt_ref<real_t>(r.src);
	133	f = f < 0 ? (f - 0.5) : (f + 0.5);
	134	vt_ref<word_t>(r.dest) = static_cast<word_t>(f);
	135	}
	136
	137	EXEC_DECL(cvtxx)
	138	{
	139	const auto p = vt_ref<word_t>(r.mid);
	140	auto res = static_cast<big_t>(vt_ref<word_t>(r.src));
	141	if (p >= 0)
	142	res <<= p;
	143	else
	144	res >>= (-p);
	145
	146	vt_ref<word_t>(r.dest) = static_cast<word_t>(res);
	147	}
	148
	149	EXEC_DECL(cvtca)
	150	{
	151	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	152
	153	auto str = at_val<vm_string_t>(r.src);
	154	auto new_array = new vm_array_t(str);
	155	pt_ref(r.dest) = new_array->allocation();
	156	}
	157
	158	EXEC_DECL(cvtac)
	159	{
	160	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	161
	162	auto str = pointer_t{};
	163	auto arr = at_val<vm_array_t>(r.src);
	164	if (arr != nullptr)
	165	{
	166	if (arr->get_element_type() != intrinsic_type_desc::type<byte_t>())
	167	throw vm_user_exception{ "Invalid array element type for string conversion" };
	168
	169	auto new_string = new vm_string_t(arr->get_length(), reinterpret_cast<uint8_t *>(arr->at(0)));
	170	str = new_string->allocation();
	171	}
	172
	173	pt_ref(r.dest) = str;
	174	}
	175
	176	EXEC_DECL(cvtcw)
	177	{
	178	auto result = word_t{ 0 };
	179	auto str = at_val<vm_string_t>(r.src);
	180	if (str != nullptr)
	181	result = static_cast<word_t>(::strtol(str->str(), nullptr, 10));
	182
	183	vt_ref<word_t>(r.dest) = result;
	184	}
	185
	186	EXEC_DECL(cvtwc)
	187	{
	188	// String represents the largest possible string from a word.
	189	auto buffer = std::array<char, sizeof("�2147483648")>{};
	190
	191	const auto w = vt_ref<word_t>(r.src);
	192	const auto len = ::sprintf(buffer.data(), "%d", w);
	193	assert(static_cast<std::size_t>(len) <= buffer.size());
	194
	195	auto new_string = new vm_string_t(len, reinterpret_cast<uint8_t *>(buffer.data()));
	196	auto str = at_val<vm_string_t>(r.dest);
	197	dec_ref_count_and_free(str);
	198
	199	pt_ref(r.dest) = new_string->allocation();
	200	}
	201
	202	EXEC_DECL(cvtcf)
	203	{
	204	auto result = real_t{ 0.0 };
	205	auto str = at_val<vm_string_t>(r.src);
	206	if (str != nullptr)
	207	result = static_cast<real_t>(::strtod(str->str(), nullptr));
	208
	209	vt_ref<real_t>(r.dest) = result;
	210	}
	211
	212	EXEC_DECL(cvtfc)
	213	{
	214	// String represents the largest possible string from a double with scientific notation.
	215	auto buffer = std::array<char, sizeof("-2.2250738585072014e-308")>{};
	216
	217	const auto real = vt_ref<real_t>(r.src);
	218	const auto len = ::sprintf(buffer.data(), "%g", real);
	219	assert(static_cast<std::size_t>(len) <= buffer.size());
	220
	221	auto new_string = new vm_string_t(len, reinterpret_cast<uint8_t *>(buffer.data()));
	222
	223	auto str = at_val<vm_string_t>(r.dest);
	224	pt_ref(r.dest) = new_string->allocation();
	225	dec_ref_count_and_free(str);
	226	}
	227
	228	EXEC_DECL(cvtcl)
	229	{
	230	auto result = big_t{ 0 };
	231	auto str = at_val<vm_string_t>(r.src);
	232	if (str != nullptr)
	233	result = static_cast<big_t>(::strtoll(str->str(), nullptr, 10));
	234
	235	vt_ref<big_t>(r.dest) = result;
	236	}
	237
	238	EXEC_DECL(cvtlc)
	239	{
	240	// String represents the largest possible string from a 64-bit integer.
	241	auto buffer = std::array<char, sizeof("-9223372036854775808")>{};
	242
	243	const auto b = vt_ref<big_t>(r.src);
	244	const auto len = ::sprintf(buffer.data(), "%lld", b);
	245	assert(static_cast<std::size_t>(len) <= buffer.size());
	246
	247	auto new_string = new vm_string_t(len, reinterpret_cast<uint8_t *>(buffer.data()));
	248
	249	auto str = at_val<vm_string_t>(r.dest);
	250	pt_ref(r.dest) = new_string->allocation();
	251	dec_ref_count_and_free(str);
	252	}
	253
	254	//
	255	// Arithmetic operations
	256	//
	257
	258	EXEC_DECL(negf) { vt_ref<real_t>(r.dest) = -vt_ref<real_t>(r.src); }
	259	EXEC_DECL(addb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.src) + vt_ref<byte_t>(r.mid); }
	260	EXEC_DECL(addw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.src) + vt_ref<word_t>(r.mid); }
	261	EXEC_DECL(addl) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.src) + vt_ref<big_t>(r.mid); }
	262	EXEC_DECL(addf) { vt_ref<real_t>(r.dest) = vt_ref<real_t>(r.src) + vt_ref<real_t>(r.mid); }
	263	EXEC_DECL(subb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.mid) - vt_ref<byte_t>(r.src); }
	264	EXEC_DECL(subw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.mid) - vt_ref<word_t>(r.src); }
	265	EXEC_DECL(subl) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.mid) - vt_ref<big_t>(r.src); }
	266	EXEC_DECL(subf) { vt_ref<real_t>(r.dest) = vt_ref<real_t>(r.mid) - vt_ref<real_t>(r.src); }
	267	EXEC_DECL(mulb) { vt_ref<byte_t>(r.dest) = vt_ref<byte_t>(r.src) * vt_ref<byte_t>(r.mid); }
	268	EXEC_DECL(mulw) { vt_ref<word_t>(r.dest) = vt_ref<word_t>(r.src) * vt_ref<word_t>(r.mid); }
	269	EXEC_DECL(mull) { vt_ref<big_t>(r.dest) = vt_ref<big_t>(r.src) * vt_ref<big_t>(r.mid); }
	270	EXEC_DECL(mulf) { vt_ref<real_t>(r.dest) = vt_ref<real_t>(r.src) * vt_ref<real_t>(r.mid); }
	271
	272	template<typename PrimitiveType>
	273	void _div(vm_registers_t &r)
	274	{
	275	const auto denom = vt_ref<PrimitiveType>(r.src);
	276	if (denom == PrimitiveType{ 0 })
	277	throw divide_by_zero{};
	278
	279	vt_ref<PrimitiveType>(r.dest) = vt_ref<PrimitiveType>(r.mid) / denom;
	280	}
	281
	282	EXEC_DECL(divb) { _div<byte_t>(r); }
	283	EXEC_DECL(divw) { _div<word_t>(r); }
	284	EXEC_DECL(divf) { _div<real_t>(r); }
	285	EXEC_DECL(divl) { _div<big_t>(r); }
	286
	287	template<typename PrimitiveType>
	288	void _mod(vm_registers_t &r)
	289	{
	290	const auto denom = vt_ref<PrimitiveType>(r.src);
	291	if (denom == PrimitiveType{ 0 })
	292	throw divide_by_zero{};
	293
	294	vt_ref<PrimitiveType>(r.dest) = vt_ref<PrimitiveType>(r.mid) % denom;
	295	}
	296
	297	EXEC_DECL(modb) { _mod<byte_t>(r); }
	298	EXEC_DECL(modw) { _mod<word_t>(r); }
	299	EXEC_DECL(modl) { _mod<big_t>(r); }
	300
	301	// [SPEC] 'Exponent' op code
	302	// Undocumented: (http://www.vitanuova.com/inferno/papers/dis.html)
	303	// Limbo reference: (http://www.vitanuova.com/inferno/papers/addendum.pdf)
	304	//
	305	// Inferno implementation: (libinterp/xec.c)
	306	// src1 = power
	307	// src2 = base
	308	//
	309	// exp[w\|l\|f] src1 src2 dst
	310	// dst = src2 'raised to' src1
	311	//
	312	// Result type matches the type of base. Power should be type 'word'.
	313	template<typename PrimitiveType>
	314	void _exp(vm_registers_t &r)
	315	{
	316	auto base = vt_ref<PrimitiveType>(r.mid);
	317	auto power = vt_ref<word_t>(r.src);
	318
	319	auto inverse = false;
	320	if (power < 0)
	321	{
	322	power = (-power);
	323	inverse = true;
	324	}
	325
	326	auto result = PrimitiveType{ 1 };
	327	for (;;)
	328	{
	329	if ((power & 1) != 0)
	330	result *= base;
	331
	332	power >>= 1;
	333	if (power == 0)
	334	break;
	335
	336	base *= base;
	337	}
	338
	339	if (inverse)
	340	result = (1 / result);
	341
	342	vt_ref<PrimitiveType>(r.dest) = result;
	343	}
	344
	345	EXEC_DECL(expw) { _exp<word_t>(r); }
	346	EXEC_DECL(expl) { _exp<big_t>(r); }
	347	EXEC_DECL(expf) { _exp<real_t>(r); }
	348
	349	// [SPEC] 'Fixed point' op codes
	350	// Undocumented: (http://www.vitanuova.com/inferno/papers/dis.html)
	351	// Limbo reference: (http://www.vitanuova.com/inferno/papers/addendum.pdf)
	352	EXEC_DECL(mulx)
	353	{
	354	const auto m = big_t{ vt_ref<word_t>(r.mid) };
	355	const auto s = big_t{ vt_ref<word_t>(r.src) };
	356	auto result = m * s;
	357
	358	const auto p = reinterpret_cast<word_t >(r.stack.peek_frame()->fixed_point_register_2());
	359	if (p >= 0)
	360	result <<= p;
	361	else
	362	result >>= (-p);
	363
	364	vt_ref<word_t>(r.dest) = static_cast<word_t>(result);
	365	}
	366
	367	EXEC_DECL(divx)
	368	{
	369	auto denom = big_t{ vt_ref<word_t>(r.mid) };
	370	const auto p = reinterpret_cast<word_t >(r.stack.peek_frame()->fixed_point_register_2());
	371	if (p >= 0)
	372	denom <<= p;
	373	else
	374	denom >>= (-p);
	375
	376	const auto numerator = big_t{ vt_ref<word_t>(r.src) };
	377	auto result = denom / numerator;
	378
	379	vt_ref<word_t>(r.dest) = static_cast<word_t>(result);
	380	}
	381
	382	//
	383	// Move operations
	384	//
	385
	386	template<typename PrimitiveType>
	387	void _mov_(pointer_t dest, pointer_t src, const type_descriptor_t *)
	388	{
	389	vt_ref<PrimitiveType>(dest) = vt_ref<PrimitiveType>(src);
	390	}
	391
	392	template<>
	393	void _mov_<vm_alloc_t>(pointer_t dest, pointer_t src, const type_descriptor_t *)
	394	{
	395	auto alloc_prev = at_val<vm_alloc_t>(dest);
	396	dec_ref_count_and_free(alloc_prev);
	397
	398	auto alloc = at_val<vm_alloc_t>(src);
	399	if (alloc != nullptr)
	400	{
	401	alloc->add_ref();
	402	pt_ref(dest) = alloc->allocation();
	403	}
	404	else
	405	{
	406	pt_ref(dest) = nullptr;
	407	}
	408	}
	409
	410	EXEC_DECL(movb) { _mov_<byte_t>(r.dest, r.src, nullptr); }
	411	EXEC_DECL(movw) { _mov_<word_t>(r.dest, r.src, nullptr); }
	412	EXEC_DECL(movf) { _mov_<real_t>(r.dest, r.src, nullptr); }
	413	EXEC_DECL(movl) { _mov_<big_t>(r.dest, r.src, nullptr); }
	414	EXEC_DECL(movp) { _mov_<vm_alloc_t>(r.dest, r.src, nullptr); }
	415
	416	EXEC_DECL(movm)
	417	{
	418	assert(r.src != nullptr && r.dest != nullptr);
	419
	420	std::memmove(r.dest, r.src, vt_ref<word_t>(r.mid));
	421	}
	422
	423	EXEC_DECL(movmp)
	424	{
	425	auto type_id = vt_ref<word_t>(r.mid);
	426	const auto &types = r.module_ref->type_section;
	427	assert(0 <= type_id && type_id < static_cast<word_t>(types.size()));
	428	auto type = types[type_id];
	429
	430	disvm::runtime::inc_ref_count_in_memory(*type, r.src);
	431
	432	// Decrement allocated pointers in the destination.
	433	destroy_memory(*type, r.dest);
	434
	435	assert(r.src != nullptr && r.dest != nullptr);
	436	std::memmove(r.dest, r.src, type->size_in_bytes);
	437	}
	438
	439	//
	440	// Compare and Branch operations
	441	//
	442
	443	EXEC_DECL(bltb) { if (vt_ref<byte_t>(r.src) < vt_ref<byte_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	444	EXEC_DECL(bgtb) { if (vt_ref<byte_t>(r.src) > vt_ref<byte_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	445	EXEC_DECL(bleb) { if (vt_ref<byte_t>(r.src) <= vt_ref<byte_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	446	EXEC_DECL(bgeb) { if (vt_ref<byte_t>(r.src) >= vt_ref<byte_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	447	EXEC_DECL(beqb) { if (vt_ref<byte_t>(r.src) == vt_ref<byte_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	448	EXEC_DECL(bneb) { if (vt_ref<byte_t>(r.src) != vt_ref<byte_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	449
	450	EXEC_DECL(bltw) { if (vt_ref<word_t>(r.src) < vt_ref<word_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	451	EXEC_DECL(bgtw) { if (vt_ref<word_t>(r.src) > vt_ref<word_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	452	EXEC_DECL(blew) { if (vt_ref<word_t>(r.src) <= vt_ref<word_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	453	EXEC_DECL(bgew) { if (vt_ref<word_t>(r.src) >= vt_ref<word_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	454	EXEC_DECL(beqw) { if (vt_ref<word_t>(r.src) == vt_ref<word_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	455	EXEC_DECL(bnew) { if (vt_ref<word_t>(r.src) != vt_ref<word_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	456
	457	EXEC_DECL(bltf) { if (vt_ref<real_t>(r.src) < vt_ref<real_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	458	EXEC_DECL(bgtf) { if (vt_ref<real_t>(r.src) > vt_ref<real_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	459	EXEC_DECL(blef) { if (vt_ref<real_t>(r.src) <= vt_ref<real_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	460	EXEC_DECL(bgef) { if (vt_ref<real_t>(r.src) >= vt_ref<real_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	461	EXEC_DECL(beqf) { if (vt_ref<real_t>(r.src) == vt_ref<real_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	462	EXEC_DECL(bnef) { if (vt_ref<real_t>(r.src) != vt_ref<real_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	463
	464	EXEC_DECL(bltl) { if (vt_ref<big_t>(r.src) < vt_ref<big_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	465	EXEC_DECL(bgtl) { if (vt_ref<big_t>(r.src) > vt_ref<big_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	466	EXEC_DECL(blel) { if (vt_ref<big_t>(r.src) <= vt_ref<big_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	467	EXEC_DECL(bgel) { if (vt_ref<big_t>(r.src) >= vt_ref<big_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	468	EXEC_DECL(beql) { if (vt_ref<big_t>(r.src) == vt_ref<big_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	469	EXEC_DECL(bnel) { if (vt_ref<big_t>(r.src) != vt_ref<big_t>(r.mid)) r.pc = vt_ref<vm_pc_t>(r.dest); }
	470
	471	// Define case table constants
	472	// [SPEC]Table format is partially defined in Dis VM specification
	473	// [element count] ([low value (inc)][high value (exc)][program counter])* [fallback program counter]
	474	struct case_op_constants
	475	{
	476	static const auto table_length_index = std::size_t{ 0 };
	477	static const auto first_entry_index = std::size_t{ 1 };
	478	static const auto entry_low_index = std::size_t{ 0 };
	479	static const auto entry_high_index = std::size_t{ 1 };
	480	static const auto entry_pc_index = std::size_t{ 2 };
	481	static const auto entry_length = std::size_t{ 3 };
	482	};
	483
	484	template<typename PrimitiveType>
	485	void _case(vm_registers_t &r)
	486	{
	487	const auto value = vt_ref<PrimitiveType>(r.src);
	488
	489	assert(r.dest != nullptr);
	490	const auto table = reinterpret_cast<const PrimitiveType *>(r.dest);
	491	auto entry_count = table[case_op_constants::table_length_index];
	492	assert(entry_count < std::numeric_limits<word_t>::max());
	493
	494	// Initialize the target PC with the fallback value.
	495	// This value is located after all entries in the table.
	496	auto target_pc = table[case_op_constants::first_entry_index + (entry_count * case_op_constants::entry_length)];
	497
	498	// Move to first entry
	499	auto current_entry = table + case_op_constants::first_entry_index;
	500
	501	// Find the matching table entry
	502	for (; 0 < entry_count; --entry_count)
	503	{
	504	// Check if value is in range
	505	if (value < current_entry[case_op_constants::entry_low_index] \|\| current_entry[case_op_constants::entry_high_index] <= value)
	506	{
	507	current_entry += case_op_constants::entry_length;
	508	continue;
	509	}
	510
	511	target_pc = current_entry[case_op_constants::entry_pc_index];
	512	break;
	513	}
	514
	515	assert(0 <= static_cast<std::size_t>(target_pc) && static_cast<std::size_t>(target_pc) < r.module_ref->code_section.size());
	516	r.pc = static_cast<vm_pc_t>(target_pc);
	517	}
	518
	519	EXEC_DECL(casew) { _case<word_t>(r); }
	520	EXEC_DECL(casel) { _case<big_t>(r); }
	521
	522	// [SPEC] The documentation for the 'casec' instruction is a bit sparse
	523	// The full semantics are the case table should have string cases lexically
	524	// ordered (i.e. e[n] < e[n + 1]).
	525	EXEC_DECL(casec)
	526	{
	527	const auto value = at_val<vm_string_t>(r.src);
	528
	529	assert(r.dest != nullptr);
	530	const auto table = reinterpret_cast<const word_t *>(r.dest);
	531	const auto entry_count = table[case_op_constants::table_length_index];
	532
	533	// Initialize the target PC with the fallback value.
	534	// This value is located after all entries in the table.
	535	auto target_pc = table[case_op_constants::first_entry_index + (entry_count * case_op_constants::entry_length)];
	536
	537	// Move to first entry
	538	auto current_entry = table + case_op_constants::first_entry_index;
	539
	540	// Find the matching table entry
	541	for (auto entry = word_t{ 0 }; entry < entry_count; ++entry)
	542	{
	543	auto string_low = at_val<vm_string_t>(reinterpret_cast<pointer_t>(const_cast<word_t *>(current_entry + case_op_constants::entry_low_index)));
	544
	545	// Compare the value against the low string
	546	int result = vm_string_t::compare(value, string_low);
	547	if (result != 0)
	548	{
	549	// If the value compares less than the low string then skip the high string.
	550	if (result < 0)
	551	{
	552	current_entry += case_op_constants::entry_length;
	553	continue;
	554	}
	555
	556	// Compare the value against the high string
	557	auto string_high = at_val<vm_string_t>(reinterpret_cast<pointer_t>(const_cast<word_t *>(current_entry + case_op_constants::entry_high_index)));
	558	if (string_high == nullptr \|\| vm_string_t::compare(value, string_high) != 0)
	559	{
	560	current_entry += case_op_constants::entry_length;
	561	continue;
	562	}
	563	}
	564
	565	target_pc = current_entry[case_op_constants::entry_pc_index];
	566	break;
	567	}
	568
	569	r.pc = target_pc;
	570	}
	571
	572	//
	573	// String operations
	574	//
	575
	576	EXEC_DECL(bltc) { if (vm_string_t::compare(at_val<vm_string_t>(r.src), at_val<vm_string_t>(r.mid)) < 0) r.pc = vt_ref<vm_pc_t>(r.dest); }
	577	EXEC_DECL(bgtc) { if (vm_string_t::compare(at_val<vm_string_t>(r.src), at_val<vm_string_t>(r.mid)) > 0) r.pc = vt_ref<vm_pc_t>(r.dest); }
	578	EXEC_DECL(blec) { if (vm_string_t::compare(at_val<vm_string_t>(r.src), at_val<vm_string_t>(r.mid)) <= 0) r.pc = vt_ref<vm_pc_t>(r.dest); }
	579	EXEC_DECL(bgec) { if (vm_string_t::compare(at_val<vm_string_t>(r.src), at_val<vm_string_t>(r.mid)) >= 0) r.pc = vt_ref<vm_pc_t>(r.dest); }
	580	EXEC_DECL(beqc) { if (vm_string_t::compare(at_val<vm_string_t>(r.src), at_val<vm_string_t>(r.mid)) == 0) r.pc = vt_ref<vm_pc_t>(r.dest); }
	581	EXEC_DECL(bnec) { if (vm_string_t::compare(at_val<vm_string_t>(r.src), at_val<vm_string_t>(r.mid)) != 0) r.pc = vt_ref<vm_pc_t>(r.dest); }
	582
	583	EXEC_DECL(lenc)
	584	{
	585	auto len = word_t{ 0 };
	586	auto str = at_val<vm_string_t>(r.src);
	587	if (str != nullptr)
	588	len = str->get_length();
	589
	590	vt_ref<word_t>(r.dest) = len;
	591	}
	592
	593	EXEC_DECL(indc)
	594	{
	595	auto str = at_val<vm_string_t>(r.src);
	596	if (str == nullptr)
	597	throw dereference_nil{ "Index string" };
	598
	599	const auto index = vt_ref<word_t>(r.mid);
	600	const auto rune = str->get_rune(index);
	601
	602	vt_ref<rune_t>(r.dest) = rune;
	603	}
	604
	605	// [SPEC] 'Insert Character' op code
	606	// Documented: (http://www.vitanuova.com/inferno/papers/dis.html)
	607	// insc src1 src2 dst
	608	// src1[src2] = dst
	609	//
	610	// Inferno implementation: (libinterp/string.c)
	611	// insc src1 src2 dst
	612	// dst[src2] = src1
	613	EXEC_DECL(insc)
	614	{
	615	auto rune = vt_ref<rune_t>(r.src);
	616	auto index = vt_ref<word_t>(r.mid);
	617	auto str = at_val<vm_string_t>(r.dest);
	618	if (str == nullptr)
	619	str = new vm_string_t();
	620	else if (str->get_ref_count() > 1)
	621	str = new vm_string_t(*str, 0, str->get_length());
	622
	623	// Set the rune at the supplied index.
	624	str->set_rune(index, rune);
	625
	626	auto old_str = at_val<vm_string_t>(r.dest);
	627	if (str != old_str)
	628	{
	629	pt_ref(r.dest) = str->allocation();
	630	dec_ref_count_and_free(old_str);
	631	}
	632	}
	633
	634	vm_string_t _addc(vm_string_t s1, vm_string_t s2, / in out */ bool &append_to_s1)
	635	{
	636	if (s1 == nullptr)
	637	{
	638	if (s2 == nullptr)
	639	return new vm_string_t();
	640
	641	return new vm_string_t(*s2, 0, s2->get_length());
	642	}
	643
	644	// There are other references to this string so we will not alter it.
	645	if (s1->get_ref_count() > 1)
	646	append_to_s1 = false;
	647
	648	if (s2 == nullptr)
	649	{
	650	if (append_to_s1)
	651	return s1;
	652
	653	return new vm_string_t(*s1, 0, s1->get_length());
	654	}
	655
	656	return (append_to_s1) ? &(s1->append(s2)) : new vm_string_t(s1, *s2);
	657	}
	658
	659	// [SPEC] 'Concat strings' op code
	660	// Documented: (http://www.vitanuova.com/inferno/papers/dis.html)
	661	// addc src1 src2 dst
	662	// dst = src1 + src2
	663	//
	664	// Inferno implementation: (libinterp/string.c)
	665	// addc src1 src2 dst
	666	// dst = src2 + src1
	667	EXEC_DECL(addc)
	668	{
	669	auto s1 = at_val<vm_string_t>(r.mid);
	670	auto s2 = at_val<vm_string_t>(r.src);
	671	auto dest_maybe = at_val<vm_string_t>(r.dest);
	672
	673	// If the source is the same as the destination and the
	674	// destination is not null, append the string. This can
	675	// change during the concat process.
	676	auto append_to_source = dest_maybe != nullptr && s1 == dest_maybe;
	677	auto str = _addc(s1, s2, append_to_source);
	678
	679	if (!append_to_source)
	680	{
	681	pt_ref(r.dest) = str->allocation();
	682	dec_ref_count_and_free(dest_maybe);
	683	}
	684	}
	685
	686	EXEC_DECL(slicec)
	687	{
	688	const auto start = vt_ref<word_t>(r.src);
	689	const auto end = vt_ref<word_t>(r.mid);
	690	auto str = at_val<vm_string_t>(r.dest);
	691
	692	if (str != nullptr)
	693	{
	694	auto new_string = new vm_string_t(*str, start, end);
	695	pt_ref(r.dest) = new_string->allocation();
	696	}
	697	else if (start == 0 && end == 0)
	698	{
	699	pt_ref(r.dest) = nullptr;
	700	}
	701	else
	702	{
	703	throw dereference_nil{ "Slice a nil string" };
	704	}
	705
	706	dec_ref_count_and_free(str);
	707	}
	708
	709	//
	710	// Array operations
	711	//
	712
	713	EXEC_DECL(lena)
	714	{
	715	auto len = word_t{ 0 };
	716	auto arr = at_val<vm_array_t>(r.src);
	717	if (arr != nullptr)
	718	len = arr->get_length();
	719
	720	vt_ref<word_t>(r.dest) = len;
	721	}
	722
	723	EXEC_DECL(slicea)
	724	{
	725	const auto begin_index = vt_ref<word_t>(r.src);
	726	const auto end_index = vt_ref<word_t>(r.mid);
	727	const auto length = end_index - begin_index;
	728
	729	auto arr = at_val<vm_array_t>(r.dest);
	730	if (arr == nullptr)
	731	{
	732	if (length == 0)
	733	return;
	734
	735	throw vm_user_exception{ "Slice of empty array is invalid" };
	736	}
	737	else if (begin_index < 0 \|\| arr->get_length() < end_index \|\| length < 0)
	738	{
	739	throw out_of_range_memory{};
	740	}
	741
	742	auto new_array = new vm_array_t(arr, begin_index, length);
	743
	744	if (arr->alloc_type->map_in_bytes > 0)
	745	vm.get_garbage_collector().track_allocation(new_array);
	746
	747	pt_ref(r.dest) = new_array->allocation();
	748	}
	749
	750	EXEC_DECL(slicela)
	751	{
	752	auto src_arr = at_val<vm_array_t>(r.src);
	753	if (src_arr == nullptr)
	754	return;
	755
	756	auto dest_arr = at_val<vm_array_t>(r.dest);
	757	if (dest_arr == nullptr)
	758	throw dereference_nil{ "Slice assignment" };
	759
	760	const auto begin_index = vt_ref<word_t>(r.mid);
	761	dest_arr->copy_from(*src_arr, begin_index);
	762	}
	763
	764	void _index_in(vm_registers_t &r)
	765	{
	766	auto arr = at_val<vm_array_t>(r.src);
	767	if (arr == nullptr)
	768	throw dereference_nil{ "Indexing into array" };
	769
	770	auto index = vt_ref<word_t>(r.dest);
	771	if (index < 0 \|\| arr->get_length() <= index)
	772	throw out_of_range_memory{ 0, arr->get_length(), index };
	773
	774	// Return the address, not the value
	775	pt_ref(r.mid) = arr->at(index);
	776	}
	777
	778	EXEC_DECL(indb) { _index_in(r); }
	779	EXEC_DECL(indw) { _index_in(r); }
	780	EXEC_DECL(indf) { _index_in(r); }
	781	EXEC_DECL(indl) { _index_in(r); }
	782	EXEC_DECL(indx) { _index_in(r); }
	783
	784	//
	785	// List operations
	786	//
	787
	788	EXEC_DECL(lenl)
	789	{
	790	auto len = word_t{ 0 };
	791	auto list = at_val<vm_list_t>(r.src);
	792	if (list != nullptr)
	793	{
	794	assert(list->alloc_type == vm_list_t::type_desc());
	795	len = list->get_length();
	796	}
	797
	798	vt_ref<word_t>(r.dest) = len;
	799	}
	800
	801	template<typename PrimitiveType>
	802	void _cons(vm_registers_t &r)
	803	{
	804	auto tail_maybe = at_val<vm_list_t>(r.dest);
	805	if (tail_maybe != nullptr)
	806	tail_maybe->release();
	807
	808	auto new_list = new vm_list_t(intrinsic_type_desc::type<PrimitiveType>(), tail_maybe);
	809
	810	auto value = vt_ref<PrimitiveType>(r.src);
	811	vt_ref<PrimitiveType>(new_list->value()) = value;
	812
	813	pt_ref(r.dest) = new_list->allocation();
	814	}
	815
	816	EXEC_DECL(consb) { _cons<byte_t>(r); }
	817	EXEC_DECL(consw) { _cons<word_t>(r); }
	818	EXEC_DECL(consf) { _cons<real_t>(r); }
	819	EXEC_DECL(consl) { _cons<big_t>(r); }
	820
	821	EXEC_DECL(consp)
	822	{
	823	auto tail_maybe = at_val<vm_list_t>(r.dest);
	824	if (tail_maybe != nullptr)
	825	tail_maybe->release();
	826
	827	// Create a new list
	828	auto new_list = new vm_list_t(intrinsic_type_desc::type<pointer_t>(), tail_maybe);
	829	auto alloc = at_val<vm_alloc_t>(r.src);
	830	if (alloc != nullptr)
	831	{
	832	alloc->add_ref();
	833	pt_ref(new_list->value()) = alloc->allocation();
	834
	835	vm.get_garbage_collector().track_allocation(new_list);
	836	}
	837	else
	838	{
	839	pt_ref(new_list->value()) = nullptr;
	840	}
	841
	842	// Return the list
	843	pt_ref(r.dest) = new_list->allocation();
	844	}
	845
	846	EXEC_DECL(consmp)
	847	{
	848	auto type_id = vt_ref<word_t>(r.mid);
	849	const auto &types = r.module_ref->type_section;
	850	assert(0 <= type_id && type_id < static_cast<word_t>(types.size()));
	851	auto type = types[type_id];
	852
	853	// Increment the ref count for element content
	854	inc_ref_count_in_memory(*type, r.src);
	855
	856	auto tail_maybe = at_val<vm_list_t>(r.dest);
	857	if (tail_maybe != nullptr)
	858	tail_maybe->release();
	859
	860	// Create a new list
	861	auto new_list = new vm_list_t(type, tail_maybe);
	862	auto destination = new_list->value();
	863	std::memmove(destination, r.src, type->size_in_bytes);
	864
	865	if (type->map_in_bytes > 0)
	866	vm.get_garbage_collector().track_allocation(new_list);
	867
	868	// Return the list
	869	pt_ref(r.dest) = new_list->allocation();
	870	}
	871
	872	template<typename PrimitiveType>
	873	void _head(vm_registers_t &r)
	874	{
	875	auto head = at_val<vm_list_t>(r.src);
	876	if (head == nullptr)
	877	throw dereference_nil{ "Head of list" };
	878
	879	assert(head->get_element_type() == intrinsic_type_desc::type<PrimitiveType>());
	880	auto head_value = head->value();
	881	vt_ref<PrimitiveType>(r.dest) = vt_ref<PrimitiveType>(head_value);
	882	}
	883
	884	EXEC_DECL(headb) { _head<byte_t>(r); }
	885	EXEC_DECL(headw) { _head<word_t>(r); }
	886	EXEC_DECL(headf) { _head<real_t>(r); }
	887	EXEC_DECL(headl) { _head<big_t>(r); }
	888
	889	EXEC_DECL(headp)
	890	{
	891	auto list = at_val<vm_list_t>(r.src);
	892	if (list == nullptr)
	893	throw dereference_nil{ "Head of list" };
	894
	895	r.src = list->value();
	896	movp(r, vm);
	897	}
	898
	899	EXEC_DECL(headmp)
	900	{
	901	auto list = at_val<vm_list_t>(r.src);
	902	if (list == nullptr)
	903	throw dereference_nil{ "Head of list" };
	904
	905	r.src = list->value();
	906	movmp(r, vm);
	907	}
	908
	909	EXEC_DECL(tail)
	910	{
	911	auto list = at_val<vm_list_t>(r.src);
	912	if (list == nullptr)
	913	throw dereference_nil{ "Tail of list" };
	914
	915	assert(list->alloc_type == vm_list_t::type_desc());
	916	auto tail = pointer_t{};
	917
	918	auto tail_maybe = list->get_tail();
	919	if (tail_maybe != nullptr)
	920	tail = tail_maybe->allocation();
	921
	922	// Use the address of the local variable.
	923	r.src = reinterpret_cast<pointer_t>(&tail);
	924	movp(r, vm);
	925	}
	926
	927	//
	928	// Channel operations
	929	//
	930
	931	namespace
	932	{
	933	void _channel_movm(pointer_t dest, pointer_t src, const type_descriptor_t *type)
	934	{
	935	assert(type != nullptr);
	936	std::memmove(dest, src, type->size_in_bytes);
	937	}
	938
	939	void _channel_movmp(pointer_t dest, pointer_t src, const type_descriptor_t *type)
	940	{
	941	assert(type != nullptr);
	942	destroy_memory(*type, dest);
	943
	944	inc_ref_count_in_memory(*type, src);
	945	std::memmove(dest, src, type->size_in_bytes);
	946	}
	947
	948	// [SPEC] 'Create new channel' op codes
	949	// Documented: (http://www.vitanuova.com/inferno/papers/dis.html)
	950	// As documented the src2 register is not used, however the Inferno
	951	// implementation does use the src2 register. It is checked against
	952	// the dst register and if they are not equal the src2 register
	953	// contains the internal buffer size of the channel.
	954	//
	955	// See Inferno implementation: (libinterp/xec.c)
	956	void _newc_(
	957	vm_registers_t &r,
	958	const vm_t &vm,
	959	std::shared_ptr<const type_descriptor_t> type_desc,
	960	std::function<void(pointer_t, pointer_t, const type_descriptor_t *)> transfer)
	961	{
	962	auto buffer_len = word_t{ 0 };
	963	if (r.mid != r.dest)
	964	{
	965	buffer_len = vt_ref<word_t>(r.mid);
	966	if (buffer_len < 0)
	967	throw out_of_range_memory{};
	968	}
	969
	970	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	971	auto new_channel = new vm_channel_t{ type_desc, transfer, buffer_len };
	972
	973	if (type_desc->map_in_bytes > 0)
	974	vm.get_garbage_collector().track_allocation(new_channel);
	975
	976	pt_ref(r.dest) = new_channel->allocation();
	977	}
	978	}
	979
	980	EXEC_DECL(newcb) { _newc_(r, vm, intrinsic_type_desc::type<byte_t>(), _mov_<byte_t>); }
	981	EXEC_DECL(newcw) { _newc_(r, vm, intrinsic_type_desc::type<word_t>(), _mov_<word_t>); }
	982	EXEC_DECL(newcf) { _newc_(r, vm, intrinsic_type_desc::type<real_t>(), _mov_<real_t>); }
	983	EXEC_DECL(newcl) { _newc_(r, vm, intrinsic_type_desc::type<big_t>(), _mov_<big_t>); }
	984	EXEC_DECL(newcp) { _newc_(r, vm, intrinsic_type_desc::type<pointer_t>(), _mov_<vm_alloc_t>); }
	985
	986	EXEC_DECL(newcm)
	987	{
	988	auto memory_size = vt_ref<word_t>(r.src);
	989	auto channel_data_type = type_descriptor_t::create(memory_size);
	990
	991	_newc_(r, vm, channel_data_type, _channel_movm);
	992	}
	993
	994	EXEC_DECL(newcmp)
	995	{
	996	auto type_id = vt_ref<word_t>(r.src);
	997	const auto &types = r.module_ref->type_section;
	998	assert(0 <= type_id && type_id < static_cast<word_t>(types.size()));
	999	auto type = types[type_id];
	1000
	1001	_newc_(r, vm, type, _channel_movmp);
	1002	}
	1003
	1004	EXEC_DECL(send)
	1005	{
	1006	auto channel = at_val<vm_channel_t>(r.dest);
	1007	if (channel == nullptr)
	1008	throw dereference_nil{ "Send to channel" };
	1009
	1010	const auto current_thread_id = r.thread.get_thread_id();
	1011
	1012	assert(!r.request_mutex.pending_request && "There should be no pending request for the thread");
	1013	r.request_mutex.pending_request = true;
	1014
	1015	assert(r.current_thread_state == vm_thread_state_t::running);
	1016	r.current_thread_state = vm_thread_state_t::blocked_sending;
	1017
	1018	// Setup the request
	1019	auto request = vm_channel_request_t{ current_thread_id, r.request_mutex };
	1020	request.data = r.src;
	1021	request.request_handled_callback = [&vm, &r, current_thread_id](const vm_channel_t &)
	1022	{
	1023	assert(!r.request_mutex.pending_request && r.current_thread_state == vm_thread_state_t::blocked_sending);
	1024	vm.get_scheduler_control().enqueue_blocked_thread(current_thread_id);
	1025	};
	1026
	1027	if (channel->send_data(request))
	1028	r.current_thread_state = vm_thread_state_t::running;
	1029	}
	1030
	1031	EXEC_DECL(recv)
	1032	{
	1033	auto channel = at_val<vm_channel_t>(r.src);
	1034	if (channel == nullptr)
	1035	throw dereference_nil{ "Receive from channel" };
	1036
	1037	const auto current_thread_id = r.thread.get_thread_id();
	1038
	1039	assert(!r.request_mutex.pending_request && "There should be no pending request for the thread");
	1040	r.request_mutex.pending_request = true;
	1041
	1042	assert(r.current_thread_state == vm_thread_state_t::running);
	1043	r.current_thread_state = vm_thread_state_t::blocked_receiving;
	1044
	1045	// Setup the request
	1046	auto request = vm_channel_request_t { current_thread_id, r.request_mutex };
	1047	request.data = r.dest;
	1048	request.request_handled_callback = [&vm, &r, current_thread_id](const vm_channel_t &)
	1049	{
	1050	assert(!r.request_mutex.pending_request && r.current_thread_state == vm_thread_state_t::blocked_receiving);
	1051	vm.get_scheduler_control().enqueue_blocked_thread(current_thread_id);
	1052	};
	1053
	1054	if (channel->receive_data(request))
	1055	r.current_thread_state = vm_thread_state_t::running;
	1056	}
	1057
	1058	namespace
	1059	{
	1060	std::minstd_rand alt_channel_selector;
	1061
	1062	word_t cancel_outstanding_channel_requests(uint32_t request_thread_id, vm_alt_stack_layout_t *alt, const vm_channel_t &handled_channel)
	1063	{
	1064	auto alloc = handled_channel.allocation();
	1065
	1066	auto handled_index = word_t{ -1 };
	1067	const auto channel_count = (alt->send_count + alt->receive_count);
	1068	for (auto i = word_t{ 0 }; i < channel_count; ++i)
	1069	{
	1070	auto ch_pointer = reinterpret_cast<pointer_t>(alt->channels[i].alloc);
	1071	if (ch_pointer == alloc)
	1072	{
	1073	assert(handled_index == -1 && "Index should only be set once");
	1074	handled_index = i;
	1075	continue;
	1076	}
	1077
	1078	auto ch = at_val<vm_channel_t>(reinterpret_cast<pointer_t>(&ch_pointer));
	1079	ch->cancel_request(request_thread_id);
	1080	}
	1081
	1082	assert(handled_index != -1 && "Index should be set");
	1083	return handled_index;
	1084	}
	1085
	1086	void exec_alt(vm_registers_t &r, const vm_t &vm, const bool blocking)
	1087	{
	1088	auto alt = reinterpret_cast<vm_alt_stack_layout_t *>(r.src);
	1089	assert(alt != nullptr);
	1090
	1091	const auto current_thread_id = r.thread.get_thread_id();
	1092
	1093	assert(!r.request_mutex.pending_request && "There should be no pending request for the thread");
	1094	r.request_mutex.pending_request = true;
	1095
	1096	assert(r.current_thread_state == vm_thread_state_t::running);
	1097	r.current_thread_state = vm_thread_state_t::blocked_in_alt;
	1098
	1099	// Create request callback
	1100	auto alt_request_handled_callback = [&vm, &r, alt, current_thread_id](const vm_channel_t &handled_channel)
	1101	{
	1102	// Cancel all non-handled requests and determine the
	1103	// index of the channel that handled this request.
	1104	auto handled_index = cancel_outstanding_channel_requests(current_thread_id, alt, handled_channel);
	1105
	1106	// Set the index of the channel that handled the request
	1107	vt_ref<word_t>(r.dest) = handled_index;
	1108
	1109	assert(!r.request_mutex.pending_request && r.current_thread_state == vm_thread_state_t::blocked_in_alt);
	1110	vm.get_scheduler_control().enqueue_blocked_thread(current_thread_id);
	1111	};
	1112
	1113	const auto channel_count = (alt->send_count + alt->receive_count);
	1114	assert(channel_count > 0);
	1115
	1116	// Generate a random channel index sequence.
	1117	auto random_idx_sequence = std::vector<word_t>(channel_count);
	1118	std::iota(std::begin(random_idx_sequence), std::end(random_idx_sequence), 0);
	1119	std::shuffle(std::begin(random_idx_sequence), std::end(random_idx_sequence), alt_channel_selector);
	1120
	1121	auto requests_queued = uint32_t{ 0 };
	1122	auto handled = bool{};
	1123	for (auto rnd_idx : random_idx_sequence)
	1124	{
	1125	auto &channel_stack_layout = alt->channels[rnd_idx];
	1126	if (channel_stack_layout.alloc == runtime_constants::nil)
	1127	throw dereference_nil{ "Alt channel" };
	1128
	1129	auto channel = at_val<vm_channel_t>(reinterpret_cast<pointer_t>(&channel_stack_layout.alloc));
	1130
	1131	auto request = vm_channel_request_t{ current_thread_id, r.request_mutex };
	1132	request.data = reinterpret_cast<pointer_t>(channel_stack_layout.data);
	1133	request.request_handled_callback = alt_request_handled_callback;
	1134
	1135	if (rnd_idx < alt->send_count)
	1136	handled = channel->send_data(request);
	1137	else
	1138	handled = channel->receive_data(request);
	1139
	1140	if (handled)
	1141	{
	1142	// Check if requests need to be handled
	1143	if (requests_queued > 0)
	1144	{
	1145	auto handled_index = cancel_outstanding_channel_requests(current_thread_id, alt, *channel);
	1146	assert(handled_index == rnd_idx);
	1147	}
	1148
	1149	vt_ref<word_t>(r.dest) = rnd_idx;
	1150	r.current_thread_state = vm_thread_state_t::running;
	1151	return;
	1152	}
	1153	else
	1154	{
	1155	requests_queued++;
	1156	}
	1157	}
	1158
	1159	// If this is a non-blocking alt request and we are here no channels
	1160	// were immediately able to handle the request. Try to lock the request
	1161	// so we can cancel it in all channels.
	1162	if (!blocking && r.request_mutex.pending_request_lock.try_lock())
	1163	{
	1164	std::lock_guard<std::mutex> lock{ r.request_mutex.pending_request_lock, std::adopt_lock };
	1165	// Check if a channel handled the request between the initial queueing and now.
	1166	if (r.request_mutex.pending_request)
	1167	{
	1168	r.request_mutex.pending_request = false;
	1169
	1170	if (debug::is_component_tracing_enabled<debug::component_trace_t::channel>())
	1171	debug::log_msg(debug::component_trace_t::channel, debug::log_level_t::debug, "alt: request: non-blocking\n");
	1172
	1173	// Cancel request in all channels.
	1174	for (auto i = word_t{ 0 }; i < channel_count; ++i)
	1175	{
	1176	auto ch_pointer = reinterpret_cast<pointer_t>(alt->channels[i].alloc);
	1177	auto ch = at_val<vm_channel_t>(reinterpret_cast<pointer_t>(&ch_pointer));
	1178	ch->cancel_request(current_thread_id);
	1179	}
	1180
	1181	// Index of a non-blocking request is the final index of the alt.
	1182	vt_ref<word_t>(r.dest) = channel_count;
	1183	r.current_thread_state = vm_thread_state_t::running;
	1184	}
	1185	}
	1186	}
	1187	}
	1188
	1189	EXEC_DECL(alt)
	1190	{
	1191	exec_alt(r, vm, true /* blocking */);
	1192	}
	1193
	1194	EXEC_DECL(nbalt)
	1195	{
	1196	exec_alt(r, vm, false /* blocking */);
	1197	}
	1198
	1199	//
	1200	// Dynamic allocation operations
	1201	//
	1202
	1203	namespace
	1204	{
	1205	void new_instance(vm_registers_t &r, const vm_t &vm, const bool zero_memory)
	1206	{
	1207	const auto type_id = vt_ref<word_t>(r.src);
	1208	const auto &types = r.module_ref->type_section;
	1209	assert(0 <= type_id && type_id < static_cast<word_t>(types.size()));
	1210
	1211	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	1212
	1213	auto type_desc = types[type_id];
	1214	auto new_alloc = !zero_memory ? vm_alloc_t::allocate(type_desc) : vm_alloc_t::allocate(type_desc, vm_alloc_t::zero_memory);
	1215
	1216	if (type_desc->map_in_bytes > 0)
	1217	vm.get_garbage_collector().track_allocation(new_alloc);
	1218
	1219	pt_ref(r.dest) = new_alloc->allocation();
	1220	}
	1221	}
	1222
	1223	EXEC_DECL(new_)
	1224	{
	1225	new_instance(r, vm, false /* zero memory */);
	1226	}
	1227
	1228	EXEC_DECL(newz)
	1229	{
	1230	new_instance(r, vm, true /* zero memory */);
	1231	}
	1232
	1233	EXEC_DECL(mnewz)
	1234	{
	1235	auto target_module = at_val<vm_module_ref_t>(r.src);
	1236	if (target_module == nullptr)
	1237	throw vm_user_exception{ "Module not loaded" };
	1238
	1239	const auto type_id = vt_ref<word_t>(r.mid);
	1240	const auto &types = target_module->type_section;
	1241	assert(0 <= type_id && type_id < static_cast<word_t>(types.size()));
	1242
	1243	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	1244
	1245	auto type_desc = types[type_id];
	1246	auto new_alloc = vm_alloc_t::allocate(type_desc, vm_alloc_t::zero_memory);
	1247
	1248	if (type_desc->map_in_bytes > 0)
	1249	vm.get_garbage_collector().track_allocation(new_alloc);
	1250
	1251	pt_ref(r.dest) = new_alloc->allocation();
	1252	}
	1253
	1254	namespace
	1255	{
	1256	void new_array(vm_registers_t &r, const vm_t &vm, const bool zero_memory)
	1257	{
	1258	assert(r.module_ref != nullptr);
	1259	const auto &types = r.module_ref->type_section;
	1260
	1261	const auto type_id = vt_ref<word_t>(r.mid);
	1262	assert(0 <= type_id && type_id < static_cast<word_t>(types.size()));
	1263	auto type_desc = types[type_id];
	1264
	1265	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	1266
	1267	const auto array_size = vt_ref<word_t>(r.src);
	1268	auto new_array = !zero_memory ? new vm_array_t(type_desc, array_size) : new vm_array_t(type_desc, array_size, vm_alloc_t::zero_memory);
	1269
	1270	if (type_desc->map_in_bytes > 0)
	1271	vm.get_garbage_collector().track_allocation(new_array);
	1272
	1273	pt_ref(r.dest) = new_array->allocation();
	1274	}
	1275	}
	1276
	1277	EXEC_DECL(newa)
	1278	{
	1279	new_array(r, vm, false /* zero memory */);
	1280	}
	1281
	1282	EXEC_DECL(newaz)
	1283	{
	1284	new_array(r, vm, true /* zero memory */);
	1285	}
	1286
	1287	EXEC_DECL(tcmp)
	1288	{
	1289	auto s = at_val<vm_alloc_t>(r.src);
	1290	auto d = at_val<vm_alloc_t>(r.dest);
	1291
	1292	if (s == nullptr)
	1293	return;
	1294
	1295	if (d == nullptr \|\| s->alloc_type != d->alloc_type)
	1296	throw type_violation{};
	1297	}
	1298
	1299	//
	1300	// Stack operations
	1301	//
	1302
	1303	// [SPEC] 'runt' op code
	1304	// Undocumented: (http://www.vitanuova.com/inferno/papers/dis.html)
	1305	//
	1306	// Inferno implementation: (libinterp/xec.c)
	1307	// No operands and appears to be a type of NOP instruction.
	1308	EXEC_DECL(runt) { /* NOP */ }
	1309
	1310	EXEC_DECL(lea) { pt_ref(r.dest) = r.src; }
	1311
	1312	EXEC_DECL(frame)
	1313	{
	1314	const auto &types = r.module_ref->type_section;
	1315
	1316	const auto frame_type_id = vt_ref<word_t>(r.src);
	1317	assert(0 <= frame_type_id && frame_type_id < static_cast<word_t>(types.size()));
	1318	const auto frame_type = types[frame_type_id];
	1319
	1320	pt_ref(r.dest) = r.stack.alloc_frame(frame_type)->base();
	1321	}
	1322
	1323	EXEC_DECL(mframe)
	1324	{
	1325	const auto target_module = at_val<vm_module_ref_t>(r.src);
	1326	if (target_module == nullptr)
	1327	throw vm_user_exception{ "Module not loaded" };
	1328
	1329	const auto &types = target_module->type_section;
	1330
	1331	// Get the function ref index for this module.
	1332	const auto function_id = vt_ref<word_t>(r.mid);
	1333	const auto &function_ref = target_module->get_function_ref(function_id);
	1334
	1335	const auto frame_type_id = function_ref.frame_type;
	1336	assert(0 <= frame_type_id && frame_type_id < static_cast<word_t>(types.size()));
	1337	const auto frame_type = types[frame_type_id];
	1338
	1339	pt_ref(r.dest) = r.stack.alloc_frame(frame_type)->base();
	1340	}
	1341
	1342	EXEC_DECL(ret)
	1343	{
	1344	const auto current_top_frame = r.stack.peek_frame();
	1345	assert(current_top_frame != nullptr);
	1346	r.pc = current_top_frame->prev_pc();
	1347
	1348	if (current_top_frame->prev_module_ref() != nullptr)
	1349	{
	1350	dec_ref_count_and_free(r.module_ref);
	1351	r.module_ref = current_top_frame->prev_module_ref();
	1352	current_top_frame->prev_module_ref() = nullptr;
	1353
	1354	dec_ref_count_and_free(r.mp_base);
	1355	r.mp_base = r.module_ref->mp_base;
	1356	}
	1357
	1358	r.stack.pop_frame();
	1359
	1360	if (debug::is_component_tracing_enabled<debug::component_trace_t::stack>())
	1361	debug::log_msg(debug::component_trace_t::stack, debug::log_level_t::debug, "exit: function\n");
	1362	}
	1363
	1364	EXEC_DECL(call)
	1365	{
	1366	auto top_frame = r.stack.push_frame();
	1367	top_frame->prev_pc() = r.pc;
	1368
	1369	#ifndef NDEBUG
	1370	// Validate the stack state
	1371	const auto frame_base_pointer = pt_ref(r.src);
	1372	assert(frame_base_pointer != nullptr);
	1373	assert(top_frame->base() == frame_base_pointer);
	1374	#endif
	1375
	1376	r.pc = vt_ref<vm_pc_t>(r.dest);
	1377
	1378	debug::log_msg(debug::component_trace_t::stack, debug::log_level_t::debug, "enter: function\n");
	1379	}
	1380
	1381	EXEC_DECL(mcall)
	1382	{
	1383	auto target_module = at_val<vm_module_ref_t>(r.dest);
	1384	if (target_module == nullptr)
	1385	throw vm_user_exception{ "Module not loaded" };
	1386
	1387	// Get the pc for the function call into this module
	1388	const auto export_id = vt_ref<word_t>(r.mid);
	1389	const auto &function_ref = target_module->get_function_ref(export_id);
	1390	const auto function_pc = function_ref.entry_pc;
	1391	assert(static_cast<std::size_t>(function_pc) < target_module->code_section.size());
	1392
	1393	// Push the next frame
	1394	auto top_frame = r.stack.push_frame();
	1395
	1396	#ifndef NDEBUG
	1397	// Validate the stack state
	1398	const auto frame_base_pointer = pt_ref(r.src);
	1399	assert(frame_base_pointer != nullptr);
	1400	assert(top_frame->base() == frame_base_pointer);
	1401	#endif
	1402
	1403	// Store current state
	1404	top_frame->prev_pc() = r.pc;
	1405	top_frame->prev_module_ref() = r.module_ref;
	1406
	1407	if (debug::is_component_tracing_enabled<debug::component_trace_t::stack>())
	1408	{
	1409	debug::log_msg(
	1410	debug::component_trace_t::stack,
	1411	debug::log_level_t::debug,
	1412	"enter: function: inter-module: %d >>%s<< %d %s\n",
	1413	export_id,
	1414	target_module->module->module_name->str(),
	1415	function_pc,
	1416	(target_module->is_builtin_module() ? "true" : "false"));
	1417	}
	1418
	1419	// Set registers for execution
	1420	r.module_ref = target_module;
	1421	r.module_ref->add_ref();
	1422	r.mp_base = r.module_ref->mp_base;
	1423	r.pc = function_pc;
	1424
	1425	if (r.module_ref->is_builtin_module())
	1426	{
	1427	// Execute the built-in function, then return
	1428	const auto &inst = r.module_ref->code_section[function_pc];
	1429	assert(r.mp_base == nullptr && "Built-in modules shouldn't have module data (MP register)");
	1430
	1431	r.current_thread_state = vm_thread_state_t::release;
	1432	inst.native(r, vm);
	1433	ret(r, vm);
	1434	r.current_thread_state = vm_thread_state_t::running;
	1435	}
	1436	else
	1437	{
	1438	r.mp_base->add_ref();
	1439	}
	1440	}
	1441
	1442	EXEC_DECL(jmp) { r.pc = vt_ref<vm_pc_t>(r.dest); }
	1443
	1444	EXEC_DECL(goto_)
	1445	{
	1446	auto pc_index = vt_ref<word_t>(r.src);
	1447
	1448	assert(r.dest != nullptr);
	1449	auto pc_table = reinterpret_cast<vm_pc_t *>(r.dest);
	1450
	1451	r.pc = pc_table[pc_index];
	1452	}
	1453
	1454	//
	1455	// Thread operations
	1456	//
	1457
	1458	EXEC_DECL(spawn)
	1459	{
	1460	// Arguments to the spawned thread are passed on the current
	1461	// thread's stack in a new frame.
	1462	auto spawned_frame = r.stack.push_frame();
	1463
	1464	#ifndef NDEBUG
	1465	// Validate the stack state
	1466	const auto frame_base_pointer = pt_ref(r.src);
	1467	assert(frame_base_pointer != nullptr);
	1468	assert(spawned_frame->base() == frame_base_pointer);
	1469	#endif
	1470
	1471	const auto starting_pc = vt_ref<vm_pc_t>(r.dest);
	1472
	1473	assert(r.module_ref != nullptr);
	1474	vm.fork(r.thread, r.module_ref, spawned_frame, starting_pc);
	1475
	1476	// After the new thread is forked pop off the argument passing frame.
	1477	r.stack.pop_frame();
	1478	}
	1479
	1480	EXEC_DECL(mspawn)
	1481	{
	1482	// Arguments to the spawned thread are passed on the current
	1483	// thread's stack in a new frame.
	1484	auto spawned_frame = r.stack.push_frame();
	1485
	1486	#ifndef NDEBUG
	1487	// Validate the stack state
	1488	const auto frame_base_pointer = pt_ref(r.src);
	1489	assert(frame_base_pointer != nullptr);
	1490	assert(spawned_frame->base() == frame_base_pointer);
	1491	#endif
	1492
	1493	const auto import_function_id = vt_ref<word_t>(r.mid);
	1494	auto target_module_ref = at_val<vm_module_ref_t>(r.dest);
	1495	assert(target_module_ref != nullptr);
	1496
	1497	const auto &function_ref = target_module_ref->get_function_ref(import_function_id);
	1498
	1499	vm.fork(r.thread, target_module_ref, spawned_frame, function_ref.entry_pc);
	1500
	1501	// After the new thread is forked pop off the argument passing frame.
	1502	r.stack.pop_frame();
	1503	}
	1504
	1505	EXEC_DECL(exit)
	1506	{
	1507	assert(false && "test failure");
	1508	r.current_thread_state = vm_thread_state_t::exiting;
	1509	}
	1510
	1511	//
	1512	// Exception operations
	1513	//
	1514
	1515	EXEC_DECL(raise)
	1516	{
	1517	auto e = at_val<vm_alloc_t>(r.src);
	1518	if (e == nullptr)
	1519	throw dereference_nil{ "Raise exception" };
	1520
	1521	const vm_string_t *exception_id;
	1522
	1523	// Determine if a 'string' or 'exception' type was raised.
	1524	if (e->alloc_type == vm_string_t::type_desc())
	1525	{
	1526	// String
	1527	exception_id = dynamic_cast<vm_string_t *>(e);
	1528
	1529	if (debug::is_component_tracing_enabled<debug::component_trace_t::exception>())
	1530	debug::log_msg(debug::component_trace_t::exception, debug::log_level_t::debug, "raise: string: >>%s<<\n", exception_id->str());
	1531	}
	1532	else
	1533	{
	1534	// [SPEC] The exception format is not formally specified.
	1535	// The first pointer in the exception is a string type
	1536	// that is used to uniquely identify the exception type.
	1537	// The remainder of the type is user-defined.
	1538	auto content = e->allocation();
	1539	exception_id = at_val<vm_string_t>(content);
	1540
	1541	if (debug::is_component_tracing_enabled<debug::component_trace_t::exception>())
	1542	debug::log_msg(debug::component_trace_t::exception, debug::log_level_t::debug, "raise: exception: >>%s<<\n", exception_id->str());
	1543	}
	1544
	1545	const handler_t *handler;
	1546	vm_frame_t *target_frame;
	1547	vm_pc_t handler_pc;
	1548
	1549	// The faulting pc is minus one since the VM has already incremented the counter.
	1550	const auto faulting_pc = r.pc - 1;
	1551
	1552	assert(r.module_ref != nullptr);
	1553	std::tie(handler, target_frame, handler_pc) = find_exception_handler(r.stack, r.module_ref, faulting_pc, exception_id);
	1554	assert(target_frame != nullptr);
	1555
	1556	// Now that we know the exception has a handler, take a reference.
	1557	e->add_ref();
	1558
	1559	if (target_frame != r.stack.peek_frame())
	1560	{
	1561	while (target_frame != r.stack.pop_frame())
	1562	{
	1563	// Remove frames from the stack until the target frame is found.
	1564	}
	1565	}
	1566
	1567	// Re-initialize the current frame
	1568	if (handler->type_desc != nullptr)
	1569	{
	1570	destroy_memory(*handler->type_desc, target_frame->base());
	1571	init_memory(*handler->type_desc, target_frame->base());
	1572	}
	1573
	1574	// Set the exception at the appropriate frame offset
	1575	auto frame_pointer = reinterpret_cast<uint8_t *>(target_frame->base());
	1576	auto exception_destination = reinterpret_cast<pointer_t>(frame_pointer + handler->exception_offset);
	1577
	1578	// Destroy any data at this location.
	1579	auto current_value = at_val<vm_alloc_t>(exception_destination);
	1580	dec_ref_count_and_free(current_value);
	1581
	1582	// Set the exception destination.
	1583	pt_ref(exception_destination) = e->allocation();
	1584
	1585	r.pc = handler_pc;
	1586	}
	1587
	1588	//
	1589	// Module operations
	1590	//
	1591
	1592	EXEC_DECL(load)
	1593	{
	1594	// Validate module loading module.
	1595	auto importing_module = r.module_ref->module;
	1596	if (!util::has_flag(importing_module->header.runtime_flag, runtime_flags_t::has_import))
	1597	throw vm_user_exception{ "Invalid importing module" };
	1598
	1599	auto str = at_val<vm_string_t>(r.src);
	1600	assert(str != nullptr);
	1601
	1602	dec_ref_count_and_free(at_val<vm_alloc_t>(r.dest));
	1603	pt_ref(r.dest) = nullptr;
	1604
	1605	auto imported_module = std::shared_ptr<const vm_module_t>{};
	1606
	1607	// Handle self loading module optimization.
	1608	if (::strcmp(str->str(), "$self") == 0)
	1609	{
	1610	imported_module = r.module_ref->module;
	1611	}
	1612	else
	1613	{
	1614	try
	1615	{
	1616	imported_module = vm.load_module(str->str());
	1617	}
	1618	catch (const vm_module_exception &e)
	1619	{
	1620	debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "exception: load: >>%s<<\n", e.what());
	1621	assert(false && "Failure reading module");
	1622	return;
	1623	}
	1624	}
	1625
	1626	auto module_import_index = vt_ref<uint32_t>(r.mid);
	1627	const auto &imports = importing_module->import_section;
	1628
	1629	assert(module_import_index < imports.size());
	1630	const auto &function_imports = imports[module_import_index];
	1631
	1632	auto entry_module_ref = new vm_module_ref_t{ imported_module, function_imports };
	1633	pt_ref(r.dest) = entry_module_ref->allocation();
	1634	}
	1635	}
	1636
	1637	const vm_exec_t disvm::runtime::vm_exec_table[static_cast<std::size_t>(opcode_t::last_opcode) + 1] =
	1638	{
	1639	invalid,
	1640	alt,
	1641	nbalt,
	1642	goto_,
	1643	call,
	1644	frame,
	1645	spawn,
	1646	runt,
	1647	load,
	1648	mcall,
	1649	mspawn,
	1650	mframe,
	1651	ret,
	1652	jmp,
	1653	casew,
	1654	exit,
	1655	new_,
	1656	newa,
	1657	newcb,
	1658	newcw,
	1659	newcf,
	1660	newcp,
	1661	newcm,
	1662	newcmp,
	1663	send,
	1664	recv,
	1665	consb,
	1666	consw,
	1667	consp,
	1668	consf,
	1669	notimpl, // consm,
	1670	consmp,
	1671	headb,
	1672	headw,
	1673	headp,
	1674	headf,
	1675	notimpl, // headm,
	1676	headmp,
	1677	tail,
	1678	lea,
	1679	indx,
	1680	movp,
	1681	movm,
	1682	movmp,
	1683	movb,
	1684	movw,
	1685	movf,
	1686	cvtbw,
	1687	cvtwb,
	1688	cvtfw,
	1689	cvtwf,
	1690	cvtca,
	1691	cvtac,
	1692	cvtwc,
	1693	cvtcw,
	1694	cvtfc,
	1695	cvtcf,
	1696	addb,
	1697	addw,
	1698	addf,
	1699	subb,
	1700	subw,
	1701	subf,
	1702	mulb,
	1703	mulw,
	1704	mulf,
	1705	divb,
	1706	divw,
	1707	divf,
	1708	modw,
	1709	modb,
	1710	andb,
	1711	andw,
	1712	orb,
	1713	orw,
	1714	xorb,
	1715	xorw,
	1716	shlb,
	1717	shlw,
	1718	shrb,
	1719	shrw,
	1720	insc,
	1721	indc,
	1722	addc,
	1723	lenc,
	1724	lena,
	1725	lenl,
	1726	beqb,
	1727	bneb,
	1728	bltb,
	1729	bleb,
	1730	bgtb,
	1731	bgeb,
	1732	beqw,
	1733	bnew,
	1734	bltw,
	1735	blew,
	1736	bgtw,
	1737	bgew,
	1738	beqf,
	1739	bnef,
	1740	bltf,
	1741	blef,
	1742	bgtf,
	1743	bgef,
	1744	beqc,
	1745	bnec,
	1746	bltc,
	1747	blec,
	1748	bgtc,
	1749	bgec,
	1750	slicea,
	1751	slicela,
	1752	slicec,
	1753	indw,
	1754	indf,
	1755	indb,
	1756	negf,
	1757	movl,
	1758	addl,
	1759	subl,
	1760	divl,
	1761	modl,
	1762	mull,
	1763	andl,
	1764	orl,
	1765	xorl,
	1766	shll,
	1767	shrl,
	1768	bnel,
	1769	bltl,
	1770	blel,
	1771	bgtl,
	1772	bgel,
	1773	beql,
	1774	cvtlf,
	1775	cvtfl,
	1776	cvtlw,
	1777	cvtwl,
	1778	cvtlc,
	1779	cvtcl,
	1780	headl,
	1781	consl,
	1782	newcl,
	1783	casec,
	1784	indl,
	1785	notimpl, // movpc,
	1786	tcmp,
	1787	mnewz,
	1788	cvtrf,
	1789	cvtfr,
	1790	cvtws,
	1791	cvtsw,
	1792	lsrw,
	1793	lsrl,
	1794	eclr,
	1795	newz,
	1796	newaz,
	1797	raise,
	1798	casel,
	1799	mulx,
	1800	divx,
	1801	cvtxx,
	1802	notimpl, // mulx0,
	1803	notimpl, // divx0,
	1804	notimpl, // cvtxx0,
	1805	notimpl, // mulx1,
	1806	notimpl, // divx1,
	1807	notimpl, // cvtxx1,
	1808	cvtfx,
	1809	cvtxf,
	1810	expw,
	1811	expl,
	1812	expf,
	1813	notimpl, // self,
	1814	};

src/vm/execution_table.h+21−0

@@ -0,0 +1,21 @@
	1	//
	2	// Dis VM
	3	// File: execution_table.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_VM_EXECUTION_TABLE_H_
	8	#define _DISVM_SRC_VM_EXECUTION_TABLE_H_
	9
	10	#include "runtime.h"
	11
	12	namespace disvm
	13	{
	14	namespace runtime
	15	{
	16	// VM instruction execution table
	17	extern const vm_exec_t vm_exec_table[];
	18	}
	19	}
	20
	21	#endif // _DISVM_SRC_VM_EXECUTION_TABLE_H_

src/vm/garbage_collector.cpp+207−0

@@ -0,0 +1,207 @@
	1	//
	2	// Dis VM
	3	// File: garbage_collector.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cinttypes>
	8	#include <array>
	9	#include <queue>
	10	#include <debug.h>
	11	#include <vm_memory.h>
	12	#include <exceptions.h>
	13	#include "garbage_collector.h"
	14
	15	using namespace disvm;
	16	using namespace disvm::runtime;
	17
	18	// Empty destructors for vm garbage collector 'interfaces'
	19	vm_garbage_collector_t::~vm_garbage_collector_t()
	20	{
	21	}
	22
	23	default_garbage_collector_t::default_garbage_collector_t(vm_t &vm)
	24	: _collection_epoch{ 0 }
	25	, _vm{ vm }
	26	{
	27	}
	28
	29	default_garbage_collector_t::~default_garbage_collector_t()
	30	{
	31	std::lock_guard<std::mutex> lock{ _tracking_allocs_lock };
	32	for (auto a : _tracking_allocs)
	33	dec_ref_count_and_free(a);
	34	}
	35
	36	namespace
	37	{
	38	enum class gc_colour_t
	39	{
	40	white,
	41	grey,
	42	black,
	43	};
	44
	45	const auto current_colours = std::array<gc_colour_t, 3>{ gc_colour_t::white, gc_colour_t::grey, gc_colour_t::black };
	46	const auto sweeper_colours = std::array<gc_colour_t, 3>{ gc_colour_t::grey, gc_colour_t::black, gc_colour_t::white };
	47
	48	gc_colour_t get_current_colour(const std::size_t epoch)
	49	{
	50	return current_colours[epoch % current_colours.size()];
	51	}
	52
	53	gc_colour_t get_sweeper_colour(const std::size_t epoch)
	54	{
	55	return sweeper_colours[epoch % sweeper_colours.size()];
	56	}
	57
	58	gc_colour_t get_gc_colour(const vm_alloc_t *a)
	59	{
	60	return reinterpret_cast<const gc_colour_t >(&a->gc_reserved);
	61	}
	62
	63	void set_gc_colour(vm_alloc_t *a, const gc_colour_t c)
	64	{
	65	a->gc_reserved = reinterpret_cast<pointer_t>(c);
	66	}
	67	}
	68
	69	void default_garbage_collector_t::track_allocation(vm_alloc_t *alloc)
	70	{
	71	assert(alloc != nullptr);
	72
	73	if (debug::is_component_tracing_enabled<debug::component_trace_t::garbage_collector>())
	74	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "gc: track: %#" PRIxPTR "\n", alloc);
	75
	76	alloc->add_ref();
	77	set_gc_colour(alloc, get_current_colour(_collection_epoch));
	78
	79	std::lock_guard<std::mutex> lock{ _tracking_allocs_lock };
	80	_tracking_allocs.push_back(alloc);
	81	}
	82
	83	void default_garbage_collector_t::enum_tracked_allocations(vm_alloc_callback_t callback) const
	84	{
	85	if (callback == nullptr)
	86	throw vm_system_exception{ "Callback should not be null" };
	87
	88	std::lock_guard<std::mutex> lock{ _tracking_allocs_lock };
	89	for (auto a : _tracking_allocs)
	90	callback(a);
	91	}
	92
	93	namespace
	94	{
	95	void mark(const std::vector<std::shared_ptr<const vm_thread_t>> &threads, const gc_colour_t curr_colour)
	96	{
	97	std::queue<vm_alloc_t *> allocs;
	98
	99	auto add_pointer_to_queue = std::function<void(pointer_t p)>{ [&allocs](pointer_t p) -> void
	100	{
	101	auto a = vm_alloc_t::from_allocation(p);
	102	allocs.push(a);
	103	} };
	104
	105	// Get roots from threads
	106	for (const auto &t : threads)
	107	{
	108	const auto &r = t->get_registers();
	109
	110	// Current MP
	111	allocs.push(r.mp_base);
	112
	113	// Traverse the stack for roots
	114	for (auto frame = r.stack.peek_frame(); frame != nullptr; frame = frame->prev_frame())
	115	{
	116	// Previous MP
	117	if (frame->prev_module_ref() != nullptr)
	118	{
	119	auto prev_mp = frame->prev_module_ref()->mp_base;
	120	allocs.push(prev_mp);
	121	}
	122
	123	if (frame->frame_type->map_in_bytes == 0)
	124	continue;
	125
	126	enum_pointer_fields(*frame->frame_type, frame->base(), add_pointer_to_queue);
	127	}
	128	}
	129
	130	const auto log_enabled = debug::is_component_tracing_enabled<debug::component_trace_t::garbage_collector>();
	131	if (log_enabled)
	132	{
	133	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "gc: roots found: %" PRIuPTR "\n", allocs.size());
	134
	135	// If logging is enabled update the callback with logging
	136	add_pointer_to_queue = std::function<void(pointer_t p)>{ [&allocs](pointer_t p) -> void
	137	{
	138	auto a = vm_alloc_t::from_allocation(p);
	139	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "\tref: %#" PRIxPTR "\n", a);
	140	allocs.push(a);
	141	} };
	142	}
	143
	144	// Traverse the graph
	145	while (!allocs.empty())
	146	{
	147	auto curr = allocs.front();
	148	allocs.pop();
	149
	150	if (log_enabled)
	151	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "gc: mark: alloc: %#" PRIxPTR "\n", curr);
	152
	153	if (curr->alloc_type->map_in_bytes > 0)
	154	enum_pointer_fields(*curr->alloc_type, curr->allocation(), add_pointer_to_queue);
	155
	156	set_gc_colour(curr, curr_colour);
	157	}
	158	}
	159
	160	void sweep(std::deque<vm_alloc_t *> &allocs, const gc_colour_t sweeper_colour)
	161	{
	162	auto allocs_local = std::move(allocs);
	163
	164	auto freed = uint32_t{ 0 };
	165	for (auto a : allocs_local)
	166	{
	167	const auto colour = get_gc_colour(a);
	168	if (colour == sweeper_colour)
	169	{
	170	dec_ref_count_and_free(a);
	171	freed++;
	172	continue;
	173	}
	174
	175	allocs.push_back(a);
	176	}
	177
	178	if (debug::is_component_tracing_enabled<debug::component_trace_t::garbage_collector>())
	179	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "gc: sweep: %u\n", freed);
	180	}
	181	}
	182
	183	bool default_garbage_collector_t::collect(std::vector<std::shared_ptr<const vm_thread_t>> &threads)
	184	{
	185	// No need to lock the actual memory allocator since the contract
	186	// for this function call indicates all VM threads should be blocked.
	187	std::lock_guard<std::mutex> lock{ _tracking_allocs_lock };
	188
	189	if (threads.empty() \|\| _tracking_allocs.empty())
	190	return false;
	191
	192	const auto log_enabled = debug::is_component_tracing_enabled<debug::component_trace_t::garbage_collector>();
	193	if (log_enabled)
	194	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "gc: begin: collect\n");
	195
	196	const auto curr_colour = get_current_colour(_collection_epoch);
	197	mark(threads, curr_colour);
	198
	199	const auto sweeper_colour = get_sweeper_colour(_collection_epoch);
	200	sweep(_tracking_allocs, sweeper_colour);
	201
	202	if (log_enabled)
	203	debug::log_msg(debug::component_trace_t::garbage_collector, debug::log_level_t::debug, "gc: end: collect\n");
	204
	205	++_collection_epoch;
	206	return true;
	207	}

src/vm/garbage_collector.h+45−0

@@ -0,0 +1,45 @@
	1	//
	2	// Dis VM
	3	// File: garbage_collector.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_VM_GARBAGE_COLLECTOR_H_
	8	#define _DISVM_SRC_VM_GARBAGE_COLLECTOR_H_
	9
	10	#include <cstdint>
	11	#include <mutex>
	12	#include <deque>
	13	#include <vector>
	14	#include <disvm.h>
	15
	16	namespace disvm
	17	{
	18	namespace runtime
	19	{
	20	// Default garbage collector
	21	class default_garbage_collector_t final : public vm_garbage_collector_t
	22	{
	23	public:
	24	default_garbage_collector_t(vm_t &vm);
	25
	26	~default_garbage_collector_t();
	27
	28	public: // vm_garbage_collector_t
	29	void track_allocation(vm_alloc_t *alloc) override final;
	30
	31	void enum_tracked_allocations(vm_alloc_callback_t callback) const override final;
	32
	33	bool collect(std::vector<std::shared_ptr<const vm_thread_t>> &threads) override final;
	34
	35	private:
	36	vm_t &_vm;
	37
	38	std::size_t _collection_epoch;
	39	mutable std::mutex _tracking_allocs_lock;
	40	std::deque<vm_alloc_t *> _tracking_allocs;
	41	};
	42	}
	43	}
	44
	45	#endif // _DISVM_SRC_VM_GARBAGE_COLLECTOR_H_

src/vm/list.cpp+105−0

@@ -0,0 +1,105 @@
	1	//
	2	// Dis VM
	3	// File: list.cpp
	4	// Author: arr
	5	//
	6
	7	#include <runtime.h>
	8	#include <vm_memory.h>
	9	#include <debug.h>
	10
	11	using namespace disvm;
	12	using namespace disvm::runtime;
	13
	14	std::shared_ptr<const type_descriptor_t> vm_list_t::type_desc()
	15	{
	16	return intrinsic_type_desc::type<vm_list_t>();
	17	}
	18
	19	vm_list_t::vm_list_t(std::shared_ptr<const type_descriptor_t> td, vm_list_t *tail)
	20	: vm_alloc_t(vm_list_t::type_desc())
	21	, _element_type{ td }
	22	, _is_alloc{ sizeof(_mem) < td->size_in_bytes }
	23	, _mem{}
	24	, _tail{ tail }
	25	{
	26	assert(_element_type != nullptr);
	27	if (_tail != nullptr)
	28	{
	29	assert(tail->get_element_type() == _element_type);
	30	_tail->add_ref();
	31	}
	32
	33	// If the default list element storage is not enough, allocate more memory.
	34	if (_is_alloc)
	35	{
	36	_mem.alloc = static_cast<pointer_t>(alloc_memory(_element_type->size_in_bytes));
	37	init_memory(*_element_type, _mem.alloc);
	38	}
	39	else
	40	{
	41	init_memory(*_element_type, &_mem.local);
	42	}
	43
	44	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm list: new\n");
	45	}
	46
	47	vm_list_t::~vm_list_t()
	48	{
	49	// Remove tail
	50	dec_ref_count_and_free(_tail);
	51	_tail = nullptr;
	52
	53	// Destroy and free the list element, if default element size was surpassed.
	54	if (_is_alloc)
	55	{
	56	destroy_memory(*_element_type, _mem.alloc);
	57	free_memory(_mem.alloc);
	58	}
	59	else
	60	{
	61	destroy_memory(*_element_type, &_mem.local);
	62	}
	63
	64	debug::assign_debug_pointer(&_mem.alloc);
	65	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm list\n");
	66	}
	67
	68	std::shared_ptr<const type_descriptor_t> vm_list_t::get_element_type() const
	69	{
	70	return _element_type;
	71	}
	72
	73	word_t vm_list_t::get_length() const
	74	{
	75	auto len = word_t{ 1 };
	76	auto list = _tail;
	77	while (list != nullptr)
	78	{
	79	len++;
	80	list = list->get_tail();
	81	}
	82
	83	return len;
	84	}
	85
	86	vm_list_t *vm_list_t::get_tail() const
	87	{
	88	return _tail;
	89	}
	90
	91	vm_list_t *vm_list_t::drop_tail()
	92	{
	93	auto tail = _tail;
	94	_tail = nullptr;
	95	tail->release();
	96	return tail;
	97	}
	98
	99	pointer_t vm_list_t::value() const
	100	{
	101	if (_is_alloc)
	102	return _mem.alloc;
	103	else
	104	return reinterpret_cast<pointer_t>(&_mem.local);
	105	}

src/vm/module_reader.cpp+800−0

@@ -0,0 +1,800 @@
	1	//
	2	// Dis VM
	3	// File: loader.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cassert>
	8	#include <limits>
	9	#include <memory>
	10	#include <iostream>
	11	#include <fstream>
	12	#include <array>
	13	#include <tuple>
	14	#include <disvm.h>
	15	#include <exceptions.h>
	16	#include <vm_memory.h>
	17	#include <utils.h>
	18	#include <module_reader.h>
	19	#include "buffered_reader.h"
	20
	21	using namespace disvm;
	22	using namespace disvm::runtime;
	23	using namespace disvm::format;
	24
	25	namespace
	26	{
	27	// constants used in module processing
	28	struct module_constants
	29	{
	30	static const auto max_type_pointer_count = operand_t{ 128 * 1024 };
	31	static const auto no_error_handle_type_desc = operand_t{ -1 };
	32	static const auto no_entry_pc = vm_pc_t{ -1 };
	33	static const auto vm_module_type_desc_number = std::size_t{ 0 };
	34	static const auto max_module_name_bytes = std::size_t{ 128 }; // Including null
	35	static const auto array_address_stack_size = std::size_t{ 4 };
	36	};
	37
	38	// enumeration for types in the data section
	39	enum class datum_type_t
	40	{
	41	value_bit8 = 1,
	42	value_bit32 = 2,
	43	utf_string = 3,
	44	value_real64 = 4,
	45	array = 5,
	46	set_array = 6,
	47	restore_load_address = 7,
	48	value_bit64 = 8
	49	};
	50
	51	// Read the next operand as defined in the Dis VM specification.
	52	std::tuple<bool, operand_t> read_next_operand(util::buffered_reader_t &reader)
	53	{
	54	auto result = operand_t{ 0 };
	55
	56	// Converting stack allocation to buffer since max size of operand is a machine word
	57	byte_t buffer[sizeof(result)];
	58
	59	if (!reader.get_next_bytes(1, buffer))
	60	return std::make_tuple(false, 0);
	61
	62	switch (buffer[0] & 0xc0)
	63	{
	64	case 0x00:
	65	// 1 byte operand
	66	result = buffer[0];
	67	break;
	68
	69	case 0x40:
	70	// 1 byte operand - Preserve sign
	71	result = buffer[0] \| ~0x7f;
	72	break;
	73
	74	case 0x80:
	75	// 2 byte operand
	76	if (!reader.get_next_bytes(1, buffer + 1))
	77	return std::make_tuple(false, 0);
	78
	79	// Preserve sign
	80	if ((buffer[0] & 0x20) != 0)
	81	buffer[0] \|= ~0x3f;
	82	else
	83	buffer[0] &= 0x3f;
	84
	85	result = (buffer[0] << 8);
	86	result \|= buffer[1];
	87	break;
	88
	89	case 0xc0:
	90	// 4 byte operand
	91	if (!reader.get_next_bytes(3, buffer + 1))
	92	return std::make_tuple(false, 0);
	93
	94	// Preserve sign
	95	if ((buffer[0] & 0x20) != 0)
	96	buffer[0] \|= ~0x3f;
	97	else
	98	buffer[0] &= 0x3f;
	99
	100	result = (buffer[0] << 24);
	101	result \|= (buffer[1] << 16);
	102	result \|= (buffer[2] << 8);
	103	result \|= buffer[3];
	104	break;
	105
	106	default:
	107	assert(false && "Should not be possible");
	108	}
	109
	110	return std::make_tuple(true, result);
	111	}
	112
	113	// Read the next word as defined in the Dis VM specification.
	114	std::tuple<bool, word_t> read_next_word(util::buffered_reader_t &reader)
	115	{
	116	auto result = word_t{};
	117
	118	// Converting stack allocation to buffer since max size of operand is a machine word
	119	byte_t buffer[sizeof(result)];
	120
	121	if (!reader.get_next_bytes(sizeof(result), buffer))
	122	return std::make_tuple(false, 0);
	123
	124	result = (buffer[0] << 24);
	125	result \|= (buffer[1] << 16);
	126	result \|= (buffer[2] << 8);
	127	result \|= buffer[3];
	128
	129	return std::make_tuple(true, result);
	130	}
	131
	132	real_t convert_to_real(const operand_t f, const operand_t s)
	133	{
	134	auto u64 = static_cast<uint64_t>(f);
	135	u64 = (u64 << 32) \| (static_cast<uint64_t>(s) & 0xffffffff);
	136
	137	auto r = real_t{};
	138	std::memcpy(&r, &u64, sizeof(u64));
	139
	140	static_assert(sizeof(u64) == sizeof(r), "Real should be 64-bits");
	141	return r;
	142	}
	143
	144	bool read_next_string(util::buffered_reader_t &reader, std::vector<uint8_t> &char_buffer)
	145	{
	146	assert(char_buffer.size() == 0);
	147	char_buffer.reserve(1024);
	148
	149	auto success = bool{};
	150	auto value = uint8_t{};
	151	std::tie(success, value) = reader.get_next_byte();
	152	while (success && value != 0)
	153	{
	154	char_buffer.push_back(value);
	155	std::tie(success, value) = reader.get_next_byte();
	156	}
	157
	158	return success;
	159	}
	160
	161	byte_t read_8byte_segments(util::buffered_reader_t &reader, datum_type_t type, uint32_t segment_count, byte_t dest)
	162	{
	163	assert(type == datum_type_t::value_real64 \|\| type == datum_type_t::value_bit64);
	164
	165	auto success = bool{};
	166	auto first = word_t{};
	167	auto second = word_t{};
	168	for (auto idx = uint32_t{ 0 }; idx < segment_count; ++idx)
	169	{
	170	std::tie(success, first) = read_next_word(reader);
	171	if (!success) throw module_reader_exception{ "Failed to read first word" };
	172
	173	std::tie(success, second) = read_next_word(reader);
	174	if (!success) throw module_reader_exception{ "Failed to read second word" };
	175
	176	if (type == datum_type_t::value_real64)
	177	{
	178	auto r = convert_to_real(first, second);
	179	reinterpret_cast<real_t >(dest) = r;
	180	dest += sizeof(r);
	181	}
	182	else
	183	{
	184	auto b = static_cast<big_t>(first);
	185	b = (b << 32) \| (static_cast<big_t>(second) & 0xffffffff);
	186	reinterpret_cast<big_t >(dest) = b;
	187	dest += sizeof(b);
	188	}
	189	}
	190
	191	return dest;
	192	}
	193
	194	std::tuple<address_mode_middle_t, address_mode_t, address_mode_t> convert_to_address_mode(uint8_t instr_addr_mode)
	195	{
	196	// Taken from Dis VM specification
	197	// bit 7 6 5 4 3 2 1 0
	198	// m1 m0 s2 s1 s0 d2 d1 d0
	199
	200	static const auto mid_mask = uint8_t{ 0xc0 };
	201	static const auto src_mask = uint8_t{ 0x38 };
	202	static const auto dest_mask = uint8_t{ 0x07 };
	203	assert((mid_mask \| src_mask \| dest_mask) == std::numeric_limits<uint8_t>::max());
	204
	205	const auto mid = static_cast<address_mode_middle_t>((instr_addr_mode & mid_mask) >> 6);
	206	const auto src = static_cast<address_mode_t>((instr_addr_mode & src_mask) >> 3);
	207	const auto dest = static_cast<address_mode_t>(instr_addr_mode & dest_mask);
	208
	209	return std::make_tuple(mid, src, dest);
	210	}
	211
	212	// See header format definition in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	213	void read_header(util::buffered_reader_t &reader, vm_module_t &modobj)
	214	{
	215	auto success = bool{};
	216	auto &header = modobj.header;
	217
	218	std::tie(success, header.magic_number) = read_next_operand(reader);
	219	if (!success)
	220	throw module_reader_exception{ "Failed to read magic number" };
	221
	222	assert(header.magic_number == magic_number_constants::xmagic \|\| header.magic_number == magic_number_constants::smagic);
	223
	224	// If the object file is signed, read in the signature.
	225	if (header.magic_number == magic_number_constants::smagic)
	226	{
	227	std::tie(success, header.Signature.length) = read_next_operand(reader);
	228	if (!success) throw module_reader_exception{ "Failed to read signature length" };
	229
	230	header.Signature.signature.reset(new byte_t[header.Signature.length]);
	231	const auto bytesRead = reader.get_next_bytes(header.Signature.length, header.Signature.signature.get());
	232	if (bytesRead != header.Signature.length) throw module_reader_exception{ "Failed to read full signature" };
	233	}
	234	else
	235	{
	236	header.Signature.length = word_t{ 0 };
	237	}
	238
	239	auto runtime_flags = operand_t{};
	240	std::tie(success, runtime_flags) = read_next_operand(reader);
	241	if (!success) throw module_reader_exception{ "Failed to read runtime flag" };
	242	header.runtime_flag = static_cast<runtime_flags_t>(runtime_flags);
	243
	244	std::tie(success, header.stack_extent) = read_next_operand(reader);
	245	if (!success) throw module_reader_exception{ "Failed to read stack extent" };
	246
	247	std::tie(success, header.code_size) = read_next_operand(reader);
	248	if (!success) throw module_reader_exception{ "Failed to read code size" };
	249
	250	std::tie(success, header.data_size) = read_next_operand(reader);
	251	if (!success) throw module_reader_exception{ "Failed to read data size" };
	252
	253	std::tie(success, header.type_size) = read_next_operand(reader);
	254	if (!success) throw module_reader_exception{ "Failed to read type size" };
	255
	256	std::tie(success, header.export_size) = read_next_operand(reader);
	257	if (!success) throw module_reader_exception{ "Failed to read export size" };
	258
	259	// [SPEC] If a module does not have an entry program counter it is set to '-1'.
	260	std::tie(success, header.entry_pc) = read_next_operand(reader);
	261	if (!success) throw module_reader_exception{ "Failed to entry pc" };
	262
	263	// [SPEC] If a module does not have an entry program counter the entry type index is set to '-1'.
	264	std::tie(success, header.entry_type) = read_next_operand(reader);
	265	if (!success) throw module_reader_exception{ "Failed to read entry type" };
	266	}
	267
	268	// See code section layout in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	269	void read_code_section(util::buffered_reader_t &reader, vm_module_t &modobj)
	270	{
	271	auto success = bool{};
	272	const auto instruction_count = modobj.header.code_size;
	273
	274	// Allocate memory for the instructions
	275	modobj.code_section.resize(instruction_count);
	276
	277	for (auto c = word_t{ 0 }; c < instruction_count; ++c)
	278	{
	279	// Read in a single instruction
	280	byte_t op_and_addrmode[2] = {};
	281	const auto bytesRead = reader.get_next_bytes(sizeof(op_and_addrmode), op_and_addrmode);
	282	if (bytesRead != sizeof(op_and_addrmode)) throw module_reader_exception{ "Failed to read op code and address mode" };
	283
	284	auto vm_instr = vm_instruction_t{};
	285	auto &instr = vm_instr.op;
	286
	287	instr.opcode = static_cast<opcode_t>(op_and_addrmode[0]);
	288	assert(opcode_t::first_opcode <= instr.opcode && instr.opcode <= opcode_t::last_opcode);
	289
	290	std::tie(instr.middle.mode, instr.source.mode, instr.destination.mode) = convert_to_address_mode(op_and_addrmode[1]);
	291
	292	if (instr.middle.mode != address_mode_middle_t::none)
	293	{
	294	std::tie(success, instr.middle.register1) = read_next_operand(reader);
	295	if (!success) throw module_reader_exception{ "Failed to read middle register" };
	296	}
	297
	298	if (instr.source.mode != address_mode_t::none)
	299	{
	300	std::tie(success, instr.source.register1) = read_next_operand(reader);
	301	if (!success) throw module_reader_exception{ "Failed to read source register 1" };
	302
	303	if (instr.source.mode == address_mode_t::offset_double_indirect_fp \|\|
	304	instr.source.mode == address_mode_t::offset_double_indirect_mp)
	305	{
	306	std::tie(success, instr.source.register2) = read_next_operand(reader);
	307	if (!success) throw module_reader_exception{ "Failed to read source register 2" };
	308
	309	// Double indirect offsets need to be < 2^16-1.
	310	assert(instr.source.register1 <= std::numeric_limits<uint16_t>::max());
	311	assert(instr.source.register2 <= std::numeric_limits<uint16_t>::max());
	312	}
	313	}
	314
	315	if (instr.destination.mode != address_mode_t::none)
	316	{
	317	std::tie(success, instr.destination.register1) = read_next_operand(reader);
	318	if (!success) throw module_reader_exception{ "Failed to read destination register 1" };
	319
	320	if (instr.destination.mode == address_mode_t::offset_double_indirect_fp \|\|
	321	instr.destination.mode == address_mode_t::offset_double_indirect_mp)
	322	{
	323	std::tie(success, instr.destination.register2) = read_next_operand(reader);
	324	if (!success) throw module_reader_exception{ "Failed to destination register 2" };
	325
	326	// Double indirect offsets need to be < 2^16-1.
	327	assert(instr.destination.register1 <= std::numeric_limits<uint16_t>::max());
	328	assert(instr.destination.register2 <= std::numeric_limits<uint16_t>::max());
	329	}
	330	}
	331
	332	modobj.code_section[c] = std::move(vm_instr);
	333	}
	334
	335	if (modobj.header.entry_pc != module_constants::no_entry_pc && static_cast<std::size_t>(modobj.header.entry_pc) >= modobj.code_section.size())
	336	throw module_reader_exception{ "Invalid initial program counter value for code section" };
	337	}
	338
	339	// See type section layout in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	340	void read_type_section(util::buffered_reader_t &reader, vm_module_t &modobj)
	341	{
	342	auto success = bool{};
	343	const auto type_count = modobj.header.type_size;
	344
	345	// Allocate memory for the types
	346	modobj.type_section.resize(type_count);
	347
	348	for (auto c = word_t{ 0 }; c < type_count; ++c)
	349	{
	350	// Read in single type
	351	operand_t desc_number;
	352	std::tie(success, desc_number) = read_next_operand(reader);
	353	if (!success) throw module_reader_exception{ "Failed to read type descriptor number" };
	354
	355	operand_t size;
	356	std::tie(success, size) = read_next_operand(reader);
	357	if (!success) throw module_reader_exception{ "Failed to read type size" };
	358
	359	operand_t map_in_bytes;
	360	std::tie(success, map_in_bytes) = read_next_operand(reader);
	361	if (!success) throw module_reader_exception{ "Failed to read type pointer count" };
	362	if (map_in_bytes > module_constants::max_type_pointer_count) throw module_reader_exception{ "Invalid Limbo type" };
	363
	364	auto pointer_map = std::vector<uint8_t>(map_in_bytes);
	365	if (map_in_bytes != 0)
	366	{
	367	const auto bytesRead = reader.get_next_bytes(map_in_bytes, pointer_map.data());
	368	if (bytesRead != map_in_bytes) throw module_reader_exception{ "Failed to read type pointer map" };
	369	}
	370
	371	modobj.type_section[desc_number] = std::move(type_descriptor_t::create(size, pointer_map));
	372	}
	373	}
	374
	375	// See data section layout in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	376	void read_data_section(util::buffered_reader_t &reader, vm_module_t &modobj)
	377	{
	378	if (modobj.header.data_size != 0)
	379	{
	380	auto vm_module_type = modobj.type_section[module_constants::vm_module_type_desc_number];
	381	if (vm_module_type->size_in_bytes != modobj.header.data_size) throw module_reader_exception{ "Invalid type desc for MP" };
	382
	383	// The Dis VM spec does not guarantee the MP segment (i.e. data segment) of the loaded
	384	// module will be initialized to zero, but it is the C/C++ approach so defer to that.
	385	modobj.original_mp.reset(vm_alloc_t::allocate(vm_module_type, vm_alloc_t::zero_memory));
	386	}
	387
	388	auto array_stack = std::array<byte_t *, module_constants::array_address_stack_size>{};
	389	auto array_stack_pointer = std::size_t{ 0 };
	390	auto success = bool{};
	391	auto code = byte_t{};
	392	auto base = reinterpret_cast<byte_t *>(modobj.original_mp->allocation());
	393	for (;;)
	394	{
	395	auto bytesRead = reader.get_next_bytes(sizeof(code), &code);
	396	if (bytesRead != sizeof(code)) throw module_reader_exception{ "Failed to read data item code" };
	397	if (code == 0)
	398	break;
	399
	400	const auto type = static_cast<datum_type_t>((code & 0xf0) >> 4);
	401	auto count = static_cast<uint32_t>(code & 0x0f);
	402	if (count == 0)
	403	{
	404	std::tie(success, count) = read_next_operand(reader);
	405	if (!success) throw module_reader_exception{ "Failed to read long item datum count" };
	406	}
	407
	408	auto byte_offset = operand_t{};
	409	std::tie(success, byte_offset) = read_next_operand(reader);
	410	if (!success) throw module_reader_exception{ "Failed to read offset" };
	411
	412	// Compute the next data destination.
	413	auto data_dest = base + byte_offset;
	414
	415	switch (type)
	416	{
	417	case datum_type_t::value_bit8:
	418	{
	419	auto byte = uint8_t{};
	420	for (auto idx = uint32_t{ 0 }; idx < count; ++idx)
	421	{
	422	std::tie(success, byte) = reader.get_next_byte();
	423	if (!success) throw module_reader_exception{ "Failed to read 1 byte" };
	424
	425	reinterpret_cast<byte_t >(data_dest) = byte;
	426	data_dest += sizeof(byte);
	427	}
	428	break;
	429	}
	430	case datum_type_t::value_bit32:
	431	{
	432	auto word = word_t{};
	433	for (auto idx = uint32_t{ 0 }; idx < count; ++idx)
	434	{
	435	word = word_t{ 0 };
	436	std::tie(success, word) = read_next_word(reader);
	437	if (!success) throw module_reader_exception{ "Failed to read word" };
	438
	439	reinterpret_cast<word_t >(data_dest) = word;
	440	data_dest += sizeof(word);
	441	}
	442	break;
	443	}
	444	case datum_type_t::utf_string:
	445	{
	446	auto str_buffer = std::vector<uint8_t>(count);
	447	auto bytesRead = reader.get_next_bytes(count, str_buffer.data());
	448	if (bytesRead != count)
	449	throw module_reader_exception{ "Failed to read string data" };
	450
	451	auto new_string = new vm_string_t(str_buffer.size(), str_buffer.data());
	452	reinterpret_cast<pointer_t >(data_dest) = new_string->allocation();
	453	break;
	454	}
	455	case datum_type_t::value_real64:
	456	data_dest = read_8byte_segments(reader, datum_type_t::value_real64, count, data_dest);
	457	break;
	458	case datum_type_t::array:
	459	{
	460	auto element_type = word_t{};
	461	std::tie(success, element_type) = read_next_word(reader);
	462	if (!success) throw module_reader_exception{ "Failed to read word" };
	463
	464	if (element_type < 0 \|\| modobj.header.type_size < element_type)
	465	if (!success) throw module_reader_exception{ "Invalid array element type" };
	466
	467	auto element_count = word_t{};
	468	std::tie(success, element_count) = read_next_word(reader);
	469	if (!success) throw module_reader_exception{ "Failed to read word" };
	470
	471	auto new_array = new vm_array_t(modobj.type_section[element_type], element_count);
	472	reinterpret_cast<pointer_t >(data_dest) = new_array->allocation();
	473	break;
	474	}
	475	case datum_type_t::set_array:
	476	{
	477	if (data_dest == nullptr) throw module_reader_exception{ "Invalid data type processing" };
	478	auto arr_maybe = vm_alloc_t::from_allocation(reinterpret_cast<pointer_t >(data_dest));
	479	assert(arr_maybe != nullptr);
	480
	481	if (arr_maybe->alloc_type != vm_array_t::type_desc())
	482	throw module_reader_exception{ "Data index not an array type" };
	483
	484	auto arr = dynamic_cast<vm_array_t *>(arr_maybe);
	485
	486	auto array_index = word_t{};
	487	std::tie(success, array_index) = read_next_word(reader);
	488	if (!success) throw module_reader_exception{ "Failed to read word" };
	489
	490	if (array_index < 0 \|\| arr->get_length() <= array_index \|\| array_stack_pointer >= module_constants::array_address_stack_size)
	491	throw module_reader_exception{ "Invalid array stack pointer" };
	492
	493	array_stack[array_stack_pointer++] = base;
	494	base = reinterpret_cast<byte_t >(arr->at(0)) + (array_index arr->alloc_type->size_in_bytes);
	495
	496	break;
	497	}
	498	case datum_type_t::restore_load_address:
	499	if (array_stack_pointer == 0) throw module_reader_exception{ "Invalid array stack pointer" };
	500
	501	base = array_stack[--array_stack_pointer];
	502	assert(base != nullptr);
	503
	504	#ifndef NDEBUG
	505	array_stack[array_stack_pointer] = nullptr;
	506	#endif
	507
	508	break;
	509	case datum_type_t::value_bit64:
	510	data_dest = read_8byte_segments(reader, datum_type_t::value_bit64, count, data_dest);
	511	break;
	512	default:
	513	throw module_reader_exception{ "Unknown item data type" };
	514	}
	515	}
	516	}
	517
	518	// See module name in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	519	void read_module_name(util::buffered_reader_t &reader, vm_module_t &modobj)
	520	{
	521	auto string_buffer = std::vector<uint8_t>{};
	522	if (!read_next_string(reader, string_buffer))
	523	throw module_reader_exception{ "Failed to read module name" };
	524
	525	modobj.module_name = std::make_unique<vm_string_t>(string_buffer.size(), string_buffer.data());
	526	assert(modobj.module_name->get_length() <= module_constants::max_module_name_bytes);
	527	}
	528
	529	// See link section in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	530	void read_link_section(util::buffered_reader_t &reader, vm_module_t &modobj)
	531	{
	532	auto success = bool{};
	533	const auto export_count = modobj.header.export_size;
	534
	535	// Allocate memory for the export entries
	536	modobj.export_section.reserve(export_count);
	537
	538	for (auto c = word_t{ 0 }; c < export_count; ++c)
	539	{
	540	// Read in single export item
	541	auto item = export_function_t{};
	542
	543	std::tie(success, item.pc) = read_next_operand(reader);
	544	if (!success) throw module_reader_exception{ "Failed to read linkage pc" };
	545
	546	std::tie(success, item.frame_type) = read_next_operand(reader);
	547	if (!success) throw module_reader_exception{ "Failed to read linkage frame type index" };
	548
	549	std::tie(success, item.sig) = read_next_word(reader);
	550	if (!success) throw module_reader_exception{ "Failed to read linkage signature" };
	551
	552	auto string_buffer = std::vector<uint8_t>{};
	553	if (!read_next_string(reader, string_buffer))
	554	throw module_reader_exception{ "Failed to read linkage name" };
	555
	556	item.name = std::make_unique<vm_string_t>(string_buffer.size(), string_buffer.data());
	557
	558	const auto sig = item.sig;
	559	modobj.export_section.emplace(sig, std::move(item));
	560	}
	561	}
	562
	563	// See import section in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	564	// [SPEC] The specification does not seem to match what is observed in an actual module.
	565	// The function is modeled after the disassembler (dis.b and libinterp/load.c) instead.
	566	void read_import_section(util::buffered_reader_t &reader, vm_module_t &modobj)
	567	{
	568	auto success = bool{};
	569	auto module_import_count = operand_t{};
	570	std::tie(success, module_import_count) = read_next_operand(reader);
	571	if (!success) throw module_reader_exception{ "Failed to read module import count" };
	572
	573	// Allocate memory for module imports
	574	modobj.import_section.reserve(module_import_count);
	575
	576	for (auto c = operand_t{ 0 }; c < module_import_count; ++c)
	577	{
	578	// Read in single module import
	579	import_vm_module_t module{};
	580
	581	auto func_import_count = operand_t{};
	582	std::tie(success, func_import_count) = read_next_operand(reader);
	583	if (!success) throw module_reader_exception{ "Failed to read function import count" };
	584
	585	// Allocate memory for function imports
	586	module.functions.reserve(func_import_count);
	587
	588	for (auto k = operand_t{ 0 }; k < func_import_count; ++k)
	589	{
	590	// Read in single function import
	591	import_function_t func{};
	592
	593	std::tie(success, func.sig) = read_next_word(reader);
	594	if (!success) throw module_reader_exception{ "Failed to read import function signature" };
	595
	596	auto string_buffer = std::vector<uint8_t>{};
	597	if (!read_next_string(reader, string_buffer))
	598	throw module_reader_exception{ "Failed to read import function name" };
	599
	600	func.name = std::make_unique<vm_string_t>(string_buffer.size(), string_buffer.data());
	601
	602	module.functions.push_back(std::move(func));
	603	}
	604
	605	modobj.import_section.push_back(std::move(module));
	606	}
	607
	608	byte_t value;
	609	std::tie(success, value) = reader.get_next_byte();
	610	if (!success \|\| value != 0)
	611	throw module_reader_exception{ "Failed to read final byte from import section" };
	612	}
	613
	614	// See handler section in Dis VM specification (http://www.vitanuova.com/inferno/man/6/dis.html)
	615	void read_handler_section(util::buffered_reader_t &reader, vm_module_t &modobj)
	616	{
	617	auto success = bool{};
	618	auto handler_count = operand_t{};
	619	std::tie(success, handler_count) = read_next_operand(reader);
	620
	621	// Allocate memory for handlers
	622	modobj.handler_section.reserve(handler_count);
	623
	624	for (auto c = operand_t{ 0 }; c < handler_count; ++c)
	625	{
	626	// Read in single handler
	627	handler_t handler{};
	628
	629	std::tie(success, handler.exception_offset) = read_next_operand(reader);
	630	if (!success) throw module_reader_exception{ "Failed to read exception offset" };
	631
	632	std::tie(success, handler.begin_pc) = read_next_operand(reader);
	633	if (!success) throw module_reader_exception{ "Failed to read handler begin program counter" };
	634
	635	std::tie(success, handler.end_pc) = read_next_operand(reader);
	636	if (!success) throw module_reader_exception{ "Failed to read handler end program counter" };
	637
	638	auto type_desc_number = operand_t{};
	639	std::tie(success, type_desc_number) = read_next_operand(reader);
	640	if (!success) throw module_reader_exception{ "Failed to read handler type description ID" };
	641
	642	if (type_desc_number != module_constants::no_error_handle_type_desc)
	643	{
	644	assert(0 <= type_desc_number && type_desc_number < static_cast<operand_t>(modobj.type_section.size()));
	645	handler.type_desc = modobj.type_section[type_desc_number];
	646	assert(handler.type_desc != nullptr);
	647	}
	648
	649	auto handler_cases = operand_t{};
	650	std::tie(success, handler_cases) = read_next_operand(reader);
	651
	652	// [SPEC] The operand read above contains two pieces of data.
	653	// The higher 16-bits represent the number of exception cases that catch exception types.
	654	// The lower 16-bits represent the total number of handled cases.
	655	// In the limbo language strings and exceptions can be caught in an exception handler.
	656	// Based on Inferno implementation libinterp/load.c.
	657	handler.exception_type_count = word_t{ handler_cases >> 16 };
	658	const auto total_count = (handler_cases & 0xffff);
	659
	660	// Allocate memory for exceptions plus the wild card.
	661	handler.exception_table.reserve(total_count + 1);
	662
	663	for (auto k = operand_t{ 0 }; k < total_count; ++k)
	664	{
	665	// Read in single exception
	666	exception_t except{};
	667
	668	auto string_buffer = std::vector<uint8_t>{};
	669	if (!read_next_string(reader, string_buffer))
	670	throw module_reader_exception{ "Failed to read exception name" };
	671
	672	except.name = std::make_unique<vm_string_t>(string_buffer.size(), string_buffer.data());
	673
	674	std::tie(success, except.pc) = read_next_operand(reader);
	675	if (!success) throw module_reader_exception{ "Failed to read exception pc" };
	676
	677	handler.exception_table.push_back(std::move(except));
	678	}
	679
	680	// Read in wildcard exception
	681	exception_t wildcard_exception{};
	682	std::tie(success, wildcard_exception.pc) = read_next_operand(reader);
	683	if (!success) throw module_reader_exception{ "Failed to read wildcard exception pc" };
	684
	685	handler.exception_table.push_back(std::move(wildcard_exception));
	686
	687	modobj.handler_section.push_back(std::move(handler));
	688	}
	689
	690	byte_t value;
	691	std::tie(success, value) = reader.get_next_byte();
	692	if (!success \|\| value != 0)
	693	throw module_reader_exception{ "Failed to read final byte from handler section" };
	694	}
	695	}
	696
	697	export_function_t::export_function_t(export_function_t &&other)
	698	: pc{ other.pc }
	699	, frame_type{ other.frame_type }
	700	, sig{ other.sig }
	701	, name{ std::move(other.name) }
	702	{
	703	}
	704
	705	export_function_t::~export_function_t()
	706	{
	707	if (name != nullptr)
	708	name->release();
	709	}
	710
	711	import_function_t::import_function_t(import_function_t &&other)
	712	: sig{ other.sig }
	713	, name{ std::move(other.name) }
	714	{
	715	}
	716
	717	import_function_t::~import_function_t()
	718	{
	719	if (name != nullptr)
	720	name->release();
	721	}
	722
	723	import_vm_module_t::import_vm_module_t(import_vm_module_t &&other)
	724	: functions{ std::move(other.functions) }
	725	{
	726	}
	727
	728	exception_t::exception_t(exception_t &&other)
	729	: pc{ other.pc }
	730	, name{ std::move(other.name) }
	731	{
	732	}
	733
	734	exception_t::~exception_t()
	735	{
	736	if (name != nullptr)
	737	name->release();
	738	}
	739
	740	handler_t::handler_t(handler_t &&other)
	741	: exception_offset{ other.exception_offset }
	742	, begin_pc{ other.begin_pc }
	743	, end_pc{ other.end_pc }
	744	, type_desc{ std::move(other.type_desc) }
	745	, exception_table{ std::move(other.exception_table) }
	746	, exception_type_count{ other.exception_type_count }
	747	{
	748	}
	749
	750	vm_module_t::~vm_module_t()
	751	{
	752	if (module_name != nullptr)
	753	module_name->release();
	754
	755	if (original_mp != nullptr)
	756	original_mp->release();
	757	}
	758
	759	std::unique_ptr<vm_module_t> disvm::read_module(const char *path)
	760	{
	761	assert(path != nullptr);
	762
	763	auto module_file = std::ifstream{ path, std::ifstream::binary };
	764	if (!module_file.is_open())
	765	{
	766	assert(false && "Failed to open module");
	767	throw vm_user_exception{ "Failed to open module" };
	768	}
	769
	770	return read_module(module_file);
	771	}
	772
	773	std::unique_ptr<runtime::vm_module_t> disvm::read_module(std::istream &data)
	774	{
	775	util::buffered_reader_t reader{ data };
	776
	777	auto modobj = std::make_unique<vm_module_t>();
	778
	779	read_header(reader, *modobj);
	780
	781	if (util::has_flag(modobj->header.runtime_flag, runtime_flags_t::has_import_deprecated))
	782	throw module_reader_exception{ "Obsolete module" };
	783
	784	read_code_section(reader, *modobj);
	785	read_type_section(reader, *modobj);
	786	read_data_section(reader, *modobj);
	787	read_module_name(reader, *modobj);
	788	read_link_section(reader, *modobj);
	789
	790	if (util::has_flag(modobj->header.runtime_flag, runtime_flags_t::has_import))
	791	read_import_section(reader, *modobj);
	792
	793	if (util::has_flag(modobj->header.runtime_flag, runtime_flags_t::has_handler))
	794	read_handler_section(reader, *modobj);
	795
	796	// [TODO] Native code generation - runtime_flags_t::must_compile
	797	assert(!util::has_flag(modobj->header.runtime_flag, runtime_flags_t::must_compile));
	798
	799	return modobj;
	800	}

src/vm/module_ref.cpp+128−0

@@ -0,0 +1,128 @@
	1	//
	2	// Dis VM
	3	// File: module_ref.cpp
	4	// Author: arr
	5	//
	6
	7	#include <runtime.h>
	8	#include <exceptions.h>
	9	#include <vm_memory.h>
	10	#include <utils.h>
	11	#include <debug.h>
	12
	13	using namespace disvm;
	14	using namespace disvm::runtime;
	15
	16	namespace
	17	{
	18	std::unique_ptr<vm_array_t> resolve_imports(const export_section_t &exports, const import_vm_module_t &imports)
	19	{
	20	static auto function_ref_type_desc = type_descriptor_t::create(sizeof(vm_module_function_ref_t), std::vector<byte_t>{});
	21	auto refs = std::make_unique<vm_array_t>(function_ref_type_desc, imports.functions.size());
	22
	23	for (auto index = std::size_t{ 0 }; index < imports.functions.size(); ++index)
	24	{
	25	const auto &import = imports.functions[index];
	26
	27	const auto exports_with_sig = exports.equal_range(import.sig);
	28	if (exports_with_sig.first == exports.cend() && exports_with_sig.second == exports.cend())
	29	throw vm_user_exception{ "Module does not export a function with expected signature" };
	30
	31	auto export_match = exports_with_sig.first;
	32	while (export_match != exports_with_sig.second)
	33	{
	34	// Look for the matching function name in those with matching signature
	35	if (0 == vm_string_t::compare(export_match->second.name.get(), import.name.get()))
	36	break;
	37
	38	++export_match;
	39	}
	40
	41	if (export_match == exports_with_sig.second)
	42	throw vm_user_exception{ "Type check failure for exported function" };
	43
	44	const auto &export_entry = export_match->second;
	45
	46	auto &ref = refs->at<vm_module_function_ref_t>(index);
	47	ref.entry_pc = export_entry.pc;
	48	ref.frame_type = export_entry.frame_type;
	49
	50	if (debug::is_component_tracing_enabled<debug::component_trace_t::module>())
	51	{
	52	debug::log_msg(
	53	debug::component_trace_t::module,
	54	debug::log_level_t::debug,
	55	"export: %d %#08x >>%s<<\n",
	56	index,
	57	export_entry.sig,
	58	export_entry.name->str());
	59	}
	60	}
	61
	62	return refs;
	63	}
	64	}
	65
	66	std::shared_ptr<const type_descriptor_t> vm_module_ref_t::type_desc()
	67	{
	68	return intrinsic_type_desc::type<vm_module_ref_t>();
	69	}
	70
	71	vm_module_ref_t::vm_module_ref_t(std::shared_ptr<const vm_module_t> module)
	72	: vm_alloc_t(vm_module_ref_t::type_desc())
	73	, code_section{ module->code_section }
	74	, module{ module }
	75	, mp_base{ nullptr }
	76	, type_section{ module->type_section }
	77	, _builtin_module{ util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin) }
	78	{
	79	if (module->original_mp != nullptr)
	80	mp_base = vm_alloc_t::copy(*module->original_mp);
	81
	82	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	83	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm module ref\n");
	84	}
	85
	86	vm_module_ref_t::vm_module_ref_t(std::shared_ptr<const vm_module_t> module, const import_vm_module_t &imports)
	87	: vm_alloc_t(vm_module_ref_t::type_desc())
	88	, code_section{ module->code_section }
	89	, module{ module }
	90	, type_section{ module->type_section }
	91	, _function_refs{ resolve_imports(module->export_section, imports) }
	92	, _builtin_module{ util::has_flag(module->header.runtime_flag, runtime_flags_t::builtin) }
	93	{
	94	assert(module->header.data_size == 0 \|\| module->original_mp != nullptr);
	95
	96	if (module->original_mp != nullptr)
	97	mp_base = vm_alloc_t::copy(*module->original_mp);
	98
	99	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	100	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm module ref: exported %d\n", _function_refs->get_length());
	101	}
	102
	103	vm_module_ref_t::~vm_module_ref_t()
	104	{
	105	dec_ref_count_and_free(mp_base);
	106
	107	if (_function_refs != nullptr)
	108	_function_refs->release();
	109
	110	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	111	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm module ref\n");
	112	}
	113
	114	bool vm_module_ref_t::is_builtin_module() const
	115	{
	116	return _builtin_module;
	117	}
	118
	119	const vm_module_function_ref_t& vm_module_ref_t::get_function_ref(word_t index) const
	120	{
	121	assert(_function_refs != nullptr);
	122
	123	if (index < 0 \|\| _function_refs->get_length() <= index)
	124	throw vm_system_exception{ "Invalid function reference index into module reference functions" };
	125
	126	return _function_refs->at<vm_module_function_ref_t>(index);
	127	}
	128

src/vm/scheduler.cpp+332−0

@@ -0,0 +1,332 @@
	1	//
	2	// Dis VM
	3	// File: scheduler.cpp
	4	// Author: arr
	5	//
	6
	7	#include <debug.h>
	8	#include <exceptions.h>
	9	#include "scheduler.h"
	10
	11	using namespace disvm;
	12	using namespace disvm::runtime;
	13
	14	// Empty destructors for vm scheduler 'interfaces'
	15	vm_scheduler_t::~vm_scheduler_t()
	16	{
	17	}
	18
	19	vm_scheduler_control_t::~vm_scheduler_control_t()
	20	{
	21	}
	22
	23	void default_scheduler_t::worker_main(default_scheduler_t &instance)
	24	{
	25	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: worker: start\n");
	26
	27	// [TODO] Handle cases of when a vm_system_exception is thrown
	28
	29	auto current_thread = std::shared_ptr<thread_instance_t>{};
	30	for (;;)
	31	{
	32	current_thread = instance.next_thread(std::move(current_thread));
	33	if (current_thread == nullptr)
	34	{
	35	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: worker: stop\n");
	36	break;
	37	}
	38
	39	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	40	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: worker: execute: %d\n", current_thread->vm_thread->get_thread_id());
	41
	42	current_thread->vm_thread->execute(instance._vm, instance._vm_thread_quanta);
	43	}
	44	}
	45
	46	default_scheduler_t::default_scheduler_t(vm_t &vm, uint32_t system_thread_count, uint32_t thread_quanta)
	47	: _gc_complete{ true }
	48	, _gc_counter{ 1 }
	49	, _worker_thread_count{ system_thread_count }
	50	, _vm{ vm }
	51	, _vm_thread_quanta{ thread_quanta }
	52	{
	53	}
	54
	55	default_scheduler_t::~default_scheduler_t()
	56	{
	57	// Drain the runnable queue and clear out all the threads
	58	{
	59	std::lock_guard<std::mutex> lock{ _vm_threads_lock };
	60	while (!_runnable_vm_threads.empty())
	61	_runnable_vm_threads.pop();
	62
	63	_all_vm_threads.clear();
	64	}
	65
	66	// Set terminating flag
	67	{
	68	std::unique_lock<std::mutex> worker_event_lock{ _worker_event_lock };
	69	_terminating = true;
	70	}
	71
	72	// Notify all workers
	73	_worker_event.notify_all();
	74
	75	// Wait for all worker threads to finish
	76	for (auto &w : _worker_pool)
	77	w.join();
	78
	79	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: shutdown\n");
	80	}
	81
	82	bool default_scheduler_t::is_idle() const
	83	{
	84	std::lock_guard<std::mutex> lock{ _vm_threads_lock };
	85	return _running_vm_thread_count == 0 && _runnable_vm_threads.empty() && _blocked_vm_thread_ids.empty();
	86	}
	87
	88	vm_scheduler_control_t &default_scheduler_t::get_controller() const
	89	{
	90	return const_cast<default_scheduler_t&>(*this);
	91	}
	92
	93	const vm_thread_t& default_scheduler_t::schedule_thread(std::unique_ptr<runtime::vm_thread_t> thread)
	94	{
	95	assert(thread != nullptr);
	96	if (thread->get_state() != vm_thread_state_t::ready)
	97	throw vm_system_exception{ "Scheduled thread in invalid state" };
	98
	99	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	100	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: scheduled: %d\n", thread->get_thread_id());
	101
	102	std::lock_guard<std::mutex> lock{ _vm_threads_lock };
	103
	104	// Create workers on first scheduled thread
	105	if (_worker_pool.empty())
	106	{
	107	for (auto i = uint32_t{ 0 }; i < _worker_thread_count; ++i)
	108	_worker_pool.push_back(std::thread{ default_scheduler_t::worker_main, std::ref(*this) });
	109	}
	110
	111	const auto new_thread_id = thread->get_thread_id();
	112	assert(_all_vm_threads.find(new_thread_id) == _all_vm_threads.cend());
	113
	114	auto new_thread = std::make_shared<thread_instance_t>(std::move(thread));
	115
	116	// Allocate a new container and set the thread entry
	117	_all_vm_threads[new_thread_id] = new_thread;
	118
	119	_runnable_vm_threads.push(new_thread);
	120
	121	// Notify the worker a thread has been enqueued.
	122	_worker_event.notify_one();
	123
	124	return *(new_thread->vm_thread);
	125	}
	126
	127	void default_scheduler_t::enqueue_blocked_thread(uint32_t thread_id)
	128	{
	129	all_thread_map_t::iterator thread_to_enqueue;
	130	{
	131	std::lock_guard<std::mutex> lock{ _vm_threads_lock };
	132	thread_to_enqueue = _all_vm_threads.find(thread_id);
	133	if (thread_to_enqueue == _all_vm_threads.cend())
	134	{
	135	assert(false && "Unknown thread to enqueue");
	136	return;
	137	}
	138	}
	139
	140	auto thread_container = thread_to_enqueue->second;
	141
	142	// Lock the vm thread collections and this vm thread
	143	std::lock(_vm_threads_lock, thread_container->system_thread_ownership);
	144	std::lock_guard<std::mutex> lock_all{ _vm_threads_lock, std::adopt_lock };
	145	std::lock_guard<std::mutex> lock_thread{ thread_container->system_thread_ownership, std::adopt_lock };
	146
	147	// If the thread is not blocked, just return.
	148	auto blocked_iter = _blocked_vm_thread_ids.find(thread_id);
	149	if (blocked_iter == _blocked_vm_thread_ids.cend())
	150	{
	151	assert(false && "Thread to enqueue not blocked");
	152	return;
	153	}
	154
	155	_blocked_vm_thread_ids.erase(blocked_iter);
	156
	157	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	158	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: enqueue blocked: %d\n", thread_id);
	159
	160	enqueue_thread_unsafe(thread_container, vm_thread_state_t::ready);
	161	}
	162
	163	std::vector<std::shared_ptr<const vm_thread_t>> default_scheduler_t::get_all_threads() const
	164	{
	165	auto result = std::vector<std::shared_ptr<const vm_thread_t>>{};
	166
	167	{
	168	std::lock_guard<std::mutex> lock{ _vm_threads_lock };
	169	for (auto &p : _all_vm_threads)
	170	result.push_back(p.second->vm_thread);
	171	}
	172
	173	return result;
	174	}
	175
	176	std::shared_ptr<default_scheduler_t::thread_instance_t> default_scheduler_t::next_thread(std::shared_ptr<thread_instance_t> prev_thread)
	177	{
	178	auto next_thread = std::shared_ptr<thread_instance_t>{};
	179
	180	// Check if the passed in thread should be re-enqueued
	181	if (prev_thread != nullptr)
	182	{
	183	std::lock_guard<std::mutex> lock{ _vm_threads_lock };
	184	--_running_vm_thread_count;
	185	auto current_state = prev_thread->vm_thread->get_state();
	186
	187	// This system thread releases ownership of the vm thread
	188	prev_thread->system_thread_ownership.unlock();
	189	enqueue_thread_unsafe(std::move(prev_thread), current_state);
	190	}
	191
	192	for (;;)
	193	{
	194	// Check for a vm thread in the queue
	195	{
	196	std::unique_lock<std::mutex> lock{ _vm_threads_lock };
	197
	198	// Check if a GC should be performed.
	199	// Matching part of the logic in Inferno (emu/port/dis.c).
	200	if ((_gc_counter & 0xff) == 0)
	201	{
	202	const auto running_thread_count_local = _running_vm_thread_count;
	203	const auto is_gc_thread = running_thread_count_local == 0;
	204	perform_gc(is_gc_thread, lock);
	205	}
	206
	207	if (!_runnable_vm_threads.empty())
	208	{
	209	next_thread = _runnable_vm_threads.front();
	210	_runnable_vm_threads.pop();
	211	++_running_vm_thread_count;
	212	++_gc_counter;
	213
	214	// This system thread now takes ownership of the vm thread
	215	next_thread->system_thread_ownership.lock();
	216	return next_thread;
	217	}
	218
	219	if (!_all_vm_threads.empty() && _blocked_vm_thread_ids.size() == _all_vm_threads.size())
	220	{
	221	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::warning, "scheduler: deadlock detected\n");
	222	assert(false && "VM thread deadlock detected");
	223	}
	224	}
	225
	226	// If the queue is empty, wait for a notification
	227	{
	228	std::unique_lock<std::mutex> worker_event_lock{ _worker_event_lock };
	229	if (_terminating)
	230	return{};
	231
	232	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: worker: waiting\n");
	233	_worker_event.wait(worker_event_lock);
	234
	235	if (_terminating)
	236	return{};
	237	}
	238	}
	239	}
	240
	241	void default_scheduler_t::perform_gc(bool is_gc_thread, std::unique_lock<std::mutex> &all_vm_threads_lock)
	242	{
	243	if (!is_gc_thread)
	244	{
	245	_gc_complete = false;
	246	all_vm_threads_lock.unlock();
	247	std::unique_lock<std::mutex> lock{ _gc_wait };
	248	_gc_done_event.wait(lock, [&]{ return _gc_complete.load(); });
	249
	250	// After the gc completes, take back the lock.
	251	all_vm_threads_lock.lock();
	252	}
	253	else
	254	{
	255	auto result = std::vector<std::shared_ptr<const vm_thread_t>>{};
	256	for (auto &p : _all_vm_threads)
	257	{
	258	auto &vm_thread = p.second->vm_thread;
	259	if (vm_thread->get_state() != vm_thread_state_t::broken)
	260	result.push_back(vm_thread);
	261	}
	262
	263	_vm.get_garbage_collector().collect(result);
	264	_gc_complete = true;
	265	_gc_done_event.notify_all();
	266	}
	267	}
	268
	269	void default_scheduler_t::enqueue_thread_unsafe(std::shared_ptr<thread_instance_t> thread_instance, runtime::vm_thread_state_t current_state)
	270	{
	271	assert(thread_instance != nullptr);
	272
	273	const auto thread_id = thread_instance->vm_thread->get_thread_id();
	274	switch (current_state)
	275	{
	276	case vm_thread_state_t::ready:
	277	case vm_thread_state_t::debug:
	278	{
	279	_runnable_vm_threads.push(thread_instance);
	280
	281	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	282	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: enqueue: %d\n", thread_id);
	283
	284	// Notify a worker a thread has been enqueued.
	285	_worker_event.notify_one();
	286	break;
	287	}
	288
	289	case vm_thread_state_t::blocked_in_alt:
	290	case vm_thread_state_t::blocked_sending:
	291	case vm_thread_state_t::blocked_receiving:
	292	{
	293	_blocked_vm_thread_ids.insert(thread_id);
	294
	295	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	296	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: blocked: %d\n", thread_id);
	297
	298	break;
	299	}
	300
	301	case vm_thread_state_t::empty_stack:
	302	case vm_thread_state_t::exiting:
	303	{
	304	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	305	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: exiting: %d\n", thread_id);
	306
	307	// Remove the thread
	308	auto thread_to_remove = _all_vm_threads.find(thread_id);
	309	assert(thread_to_remove != _all_vm_threads.cend());
	310	_all_vm_threads.erase(thread_to_remove);
	311
	312	break;
	313	}
	314
	315	case vm_thread_state_t::broken:
	316	{
	317	// [TODO] What happens when a thread enters this state but no debugger is attached?
	318	_non_runnable_vm_thread_ids.push_front(thread_id);
	319
	320	if (debug::is_component_tracing_enabled<debug::component_trace_t::scheduler>())
	321	debug::log_msg(debug::component_trace_t::scheduler, debug::log_level_t::debug, "scheduler: broken: %d\n", thread_id);
	322
	323	break;
	324	}
	325
	326	case vm_thread_state_t::release:
	327	case vm_thread_state_t::running:
	328	default:
	329	assert(false && "Unexpected thread state");
	330	throw vm_system_exception{ "Unexpected thread state" };
	331	}
	332	}

src/vm/scheduler.h+102−0

@@ -0,0 +1,102 @@
	1	//
	2	// Dis VM
	3	// File: scheduler.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_VM_SCHEDULER_H_
	8	#define _DISVM_SRC_VM_SCHEDULER_H_
	9
	10	#include <cstdint>
	11	#include <thread>
	12	#include <mutex>
	13	#include <condition_variable>
	14	#include <queue>
	15	#include <forward_list>
	16	#include <unordered_set>
	17	#include <unordered_map>
	18	#include <atomic>
	19	#include <disvm.h>
	20
	21	namespace disvm
	22	{
	23	namespace runtime
	24	{
	25	// Default multi-threaded scheduler
	26	class default_scheduler_t final : public vm_scheduler_t, public vm_scheduler_control_t
	27	{
	28	private: // static
	29	static void worker_main(default_scheduler_t &instance);
	30
	31	public:
	32	default_scheduler_t(vm_t &vm, uint32_t system_thread_count, uint32_t thread_quanta);
	33
	34	~default_scheduler_t();
	35
	36	public: // vm_scheduler_t
	37	bool is_idle() const override final;
	38
	39	vm_scheduler_control_t &get_controller() const override final;
	40
	41	const vm_thread_t& schedule_thread(std::unique_ptr<vm_thread_t> thread) override final;
	42
	43	public: // vm_scheduler_control_t
	44	void enqueue_blocked_thread(uint32_t thread_id) override final;
	45
	46	std::vector<std::shared_ptr<const vm_thread_t>> get_all_threads() const override final;
	47
	48	private:
	49	struct thread_instance_t
	50	{
	51	thread_instance_t(std::unique_ptr<vm_thread_t> t)
	52	: vm_thread{ std::move(t) }
	53	{
	54	}
	55
	56	~thread_instance_t()
	57	{
	58	if (vm_thread != nullptr)
	59	vm_thread->release();
	60	}
	61
	62	std::shared_ptr<vm_thread_t> vm_thread;
	63	std::mutex system_thread_ownership;
	64	};
	65
	66	std::shared_ptr<thread_instance_t> next_thread(std::shared_ptr<thread_instance_t> prev_thread);
	67
	68	void perform_gc(bool is_gc_thread, std::unique_lock<std::mutex> &all_vm_threads_lock);
	69
	70	// Add the thread to the queue in a non-thread safe manner.
	71	void enqueue_thread_unsafe(std::shared_ptr<thread_instance_t> thread, runtime::vm_thread_state_t current_state);
	72
	73	private:
	74	vm_t &_vm;
	75
	76	const uint32_t _worker_thread_count;
	77	std::vector<std::thread> _worker_pool;
	78
	79	std::mutex _worker_event_lock;
	80	std::condition_variable _worker_event;
	81	std::atomic_bool _terminating;
	82
	83	const uint32_t _vm_thread_quanta;
	84	mutable std::mutex _vm_threads_lock;
	85	std::queue<std::shared_ptr<thread_instance_t>> _runnable_vm_threads;
	86	std::size_t _running_vm_thread_count;
	87
	88	std::mutex _gc_wait;
	89	std::condition_variable _gc_done_event;
	90	std::atomic_bool _gc_complete; // Used to avoid spurious wakeups
	91	std::size_t _gc_counter;
	92
	93	std::unordered_set<uint32_t> _blocked_vm_thread_ids;
	94	std::forward_list<uint32_t> _non_runnable_vm_thread_ids;
	95
	96	using all_thread_map_t = std::unordered_map<uint32_t, std::shared_ptr<thread_instance_t>>;
	97	all_thread_map_t _all_vm_threads;
	98	};
	99	}
	100	}
	101
	102	#endif // _DISVM_SRC_VM_SCHEDULER_H_

src/vm/stack.cpp+314−0

@@ -0,0 +1,314 @@
	1	//
	2	// Dis VM
	3	// File: stack.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cinttypes>
	8	#include <runtime.h>
	9	#include <builtin_module.h>
	10	#include <vm_memory.h>
	11	#include <debug.h>
	12	#include <exceptions.h>
	13
	14	using namespace disvm;
	15	using namespace disvm::runtime;
	16
	17	namespace
	18	{
	19	struct vm_stack_page
	20	{
	21	vm_stack_page *prev_page;
	22	uintptr_t page_limit_addr;
	23	vm_frame_t *page_top_frame; // Do not free. This is used as a tracking pointer.
	24
	25	void *stack_data() const
	26	{
	27	// The beginning of the stack data is at the end of the struct.
	28	return reinterpret_cast<uint8_t >(const_cast<vm_stack_page >(this)) + sizeof(vm_stack_page);
	29	}
	30
	31	bool contains_frame(const vm_frame_t *frame) const
	32	{
	33	return reinterpret_cast<uintptr_t>(stack_data()) <= reinterpret_cast<uintptr_t>(frame) && reinterpret_cast<uintptr_t>(frame) < page_limit_addr;
	34	}
	35	};
	36
	37	struct vm_stack_layout final : public vm_alloc_t
	38	{
	39	static std::shared_ptr<const type_descriptor_t> type_desc()
	40	{
	41	static auto td = type_descriptor_t::create(0);
	42	return td;
	43	}
	44
	45	vm_stack_layout(std::size_t stack_page_size)
	46	: vm_alloc_t(type_desc())
	47	, stack_page_size{ stack_page_size }
	48	, top_frame{ nullptr }
	49	, top_page{ nullptr }
	50	{
	51	new_page();
	52	}
	53
	54	~vm_stack_layout()
	55	{
	56	assert(top_page != nullptr);
	57	free_memory(top_page);
	58	}
	59
	60	const std::size_t stack_page_size;
	61
	62	vm_stack_page *top_page;
	63	vm_frame_t *top_frame; // Do not free. This is used as a tracking pointer.
	64
	65	// Create a new 'top page' and return stack data address
	66	void *new_page()
	67	{
	68	auto current_stack_page = top_page;
	69	top_page = alloc_memory<vm_stack_page>(sizeof(vm_stack_page) + stack_page_size);
	70
	71	// Initialize the stack allocation.
	72	top_page->prev_page = current_stack_page;
	73
	74	// The top frame member is only for tracking and so is initialized to null.
	75	top_page->page_top_frame = nullptr;
	76	top_page->page_limit_addr = reinterpret_cast<uintptr_t>(top_page)+stack_page_size;
	77
	78	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "alloc: vm stack alloc: %#" PRIxPTR " %#" PRIxPTR "\n", top_page, top_page->page_limit_addr);
	79
	80	return top_page->stack_data();
	81	}
	82
	83	// Drop the current page and move to the previous one
	84	void drop_page()
	85	{
	86	auto current_stack_page = top_page->prev_page;
	87	assert(current_stack_page != nullptr);
	88
	89	free_memory(top_page);
	90	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "free: vm stack alloc\n");
	91
	92	// Set the top page
	93	top_page = current_stack_page;
	94	}
	95	};
	96	}
	97
	98	vm_frame_t::vm_frame_t(std::shared_ptr<const type_descriptor_t> &td)
	99	: frame_type{ std::move(td) }
	100	{
	101	assert(frame_type != nullptr);
	102
	103	// Initialize the new frame
	104	init_memory(*frame_type, base());
	105
	106	prev_pc() = runtime_constants::invalid_program_counter;
	107	prev_frame() = nullptr;
	108	prev_module_ref() = nullptr;
	109
	110	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	111	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm frame: %#" PRIxPTR " %d\n", this, frame_type->size_in_bytes);
	112	}
	113
	114	vm_frame_t::~vm_frame_t()
	115	{
	116	dec_ref_count_and_free(prev_module_ref());
	117
	118	destroy_memory(*frame_type, base());
	119
	120	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	121	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm frame: %#" PRIxPTR "\n", this);
	122	}
	123
	124	void vm_frame_t::copy_frame_contents(const vm_frame_t &other)
	125	{
	126	auto this_frame_base = reinterpret_cast<uint8_t *>(base());
	127	auto this_frame_contents = this_frame_base + sizeof(vm_frame_base_alloc_t);
	128
	129	auto other_frame_base = reinterpret_cast<uint8_t *>(other.base());
	130	auto other_frame_contents = other_frame_base + sizeof(vm_frame_base_alloc_t);
	131
	132	assert(frame_type->size_in_bytes > sizeof(vm_frame_base_alloc_t));
	133	std::memcpy(this_frame_contents, other_frame_contents, frame_type->size_in_bytes - sizeof(vm_frame_base_alloc_t));
	134
	135	inc_ref_count_in_memory(*frame_type, this_frame_base);
	136	}
	137
	138	pointer_t vm_frame_t::base() const
	139	{
	140	// The beginning of the frame data is at the end of the frame struct.
	141	return reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t >(const_cast<vm_frame_t >(this)) + sizeof(vm_frame_t));
	142	}
	143
	144	vm_pc_t &vm_frame_t::prev_pc() const
	145	{
	146	return base<vm_frame_base_alloc_t>().p_pc;
	147	}
	148
	149	vm_frame_t *&vm_frame_t::prev_frame() const
	150	{
	151	return base<vm_frame_base_alloc_t>().p_fp;
	152	}
	153
	154	vm_module_ref_t *&vm_frame_t::prev_module_ref() const
	155	{
	156	return base<vm_frame_base_alloc_t>().p_mr;
	157	}
	158
	159	pointer_t vm_frame_t::fixed_point_register_1() const
	160	{
	161	const auto offset = runtime_constants::fixed_point_register_1_frame_offset;
	162	assert(offset < frame_type->size_in_bytes);
	163
	164	auto p = reinterpret_cast<uint8_t *>(base()) + offset;
	165	return reinterpret_cast<pointer_t>(p);
	166	}
	167
	168	pointer_t vm_frame_t::fixed_point_register_2() const
	169	{
	170	const auto offset = runtime_constants::fixed_point_register_2_frame_offset;
	171	assert(offset < frame_type->size_in_bytes);
	172
	173	auto p = reinterpret_cast<uint8_t *>(base()) + offset;
	174	return reinterpret_cast<pointer_t>(p);
	175	}
	176
	177	vm_stack_t::vm_stack_t(std::size_t stack_extent)
	178	: _mem{ std::make_unique<vm_stack_layout>(stack_extent) }
	179	{
	180	assert(stack_extent != 0);
	181	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm stack\n");
	182	}
	183
	184	vm_stack_t::~vm_stack_t()
	185	{
	186	while (nullptr != pop_frame())
	187	{
	188	// Pop all frames off the stack
	189	}
	190
	191	// Free stack memory
	192	_mem->release();
	193	_mem.reset();
	194
	195	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm stack\n");
	196	}
	197
	198	vm_frame_t *vm_stack_t::alloc_frame(std::shared_ptr<const type_descriptor_t> frame_type)
	199	{
	200	assert(frame_type != nullptr);
	201	assert(sizeof(vm_frame_base_alloc_t) < frame_type->size_in_bytes && "Requested frame size less than VM frame base size");
	202
	203	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
	204
	205	auto page_top_frame = layout->top_page->page_top_frame;
	206	const auto new_frame_size = sizeof(vm_frame_t) + frame_type->size_in_bytes;
	207	if (layout->stack_page_size < new_frame_size)
	208	throw vm_system_exception{ "Requested stack frame larger than stack page" };
	209
	210	vm_frame_t *new_frame;
	211	if (page_top_frame == nullptr)
	212	{
	213	new_frame = ::new(layout->top_page->stack_data())vm_frame_t{ frame_type };
	214	}
	215	else
	216	{
	217	auto current_page_top_frame_addr = reinterpret_cast<std::size_t>(page_top_frame);
	218	auto new_frame_addr_maybe = current_page_top_frame_addr + (sizeof(vm_frame_t) + page_top_frame->frame_type->size_in_bytes);
	219
	220	// If the new frame is not going to fit on the current page, create a new page.
	221	if ((new_frame_addr_maybe + new_frame_size) >= layout->top_page->page_limit_addr)
	222	new_frame_addr_maybe = reinterpret_cast<uintptr_t>(layout->new_page());
	223
	224	new_frame = ::new(reinterpret_cast<void *>(new_frame_addr_maybe))vm_frame_t{ frame_type };
	225	}
	226
	227	// Record the top frame on the page
	228	layout->top_page->page_top_frame = new_frame;
	229
	230	return new_frame;
	231	}
	232
	233	vm_frame_t *vm_stack_t::push_frame()
	234	{
	235	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
	236
	237	auto current_top_frame = layout->top_frame;
	238	auto new_top_frame = layout->top_page->page_top_frame;
	239	new_top_frame->prev_frame() = current_top_frame;
	240
	241	layout->top_frame = new_top_frame;
	242
	243	if (debug::is_component_tracing_enabled<debug::component_trace_t::stack>())
	244	debug::log_msg(debug::component_trace_t::stack, debug::log_level_t::debug, "update: push vm frame: %#" PRIxPTR "\n", new_top_frame);
	245
	246	return new_top_frame;
	247	}
	248
	249	vm_frame_t *vm_stack_t::pop_frame()
	250	{
	251	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
	252
	253	auto current_frame = layout->top_frame;
	254	if (current_frame == nullptr)
	255	return nullptr;
	256
	257	{
	258	// Dispose of the current top frame and update the current frame.
	259	auto previous_frame = current_frame;
	260	current_frame = previous_frame->prev_frame();
	261
	262	// Call destructor on previous frame since we allocated
	263	// the frame on the stack page.
	264	previous_frame->~vm_frame_t();
	265	}
	266
	267	layout->top_frame = current_frame;
	268	layout->top_page->page_top_frame = current_frame;
	269
	270	// Check if the stack page is no longer needed.
	271	if (current_frame != nullptr)
	272	{
	273	// Clean up the stack page allocation if the current frame is on a previous page
	274	if (!layout->top_page->contains_frame(current_frame))
	275	{
	276	layout->drop_page();
	277
	278	// Ensure the current frame is in the new page.
	279	assert(layout->top_page->contains_frame(current_frame));
	280	}
	281	}
	282
	283	if (debug::is_component_tracing_enabled<debug::component_trace_t::stack>())
	284	debug::log_msg(debug::component_trace_t::stack, debug::log_level_t::debug, "update: pop vm frame: %#" PRIxPTR "\n", current_frame);
	285
	286	return current_frame;
	287	}
	288
	289	vm_frame_t *vm_stack_t::peek_frame() const
	290	{
	291	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
	292	return layout->top_frame;
	293	}
	294
	295	void vm_stack_t::walk_stack(vm_stack_walk_callback_t callback) const
	296	{
	297	if (callback == nullptr)
	298	return;
	299
	300	auto layout = dynamic_cast<vm_stack_layout *>(_mem.get());
	301	auto current_page = layout->top_page;
	302	auto current_frame = layout->top_frame;
	303
	304	while (current_page != nullptr && current_frame != nullptr)
	305	{
	306	if (!callback(current_frame, current_page))
	307	break;
	308
	309	current_frame = current_frame->prev_frame();
	310
	311	if (!current_page->contains_frame(current_frame))
	312	current_page = current_page->prev_page;
	313	}
	314	}

src/vm/string.cpp+522−0

@@ -0,0 +1,522 @@
	1	//
	2	// Dis VM
	3	// File: string.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cinttypes>
	8	#include <runtime.h>
	9	#include <utf8.h>
	10	#include <vm_memory.h>
	11	#include <debug.h>
	12	#include <exceptions.h>
	13
	14	using namespace disvm;
	15	using namespace disvm::runtime;
	16
	17	std::shared_ptr<const type_descriptor_t> vm_string_t::type_desc()
	18	{
	19	return intrinsic_type_desc::type<vm_string_t>();
	20	}
	21
	22	namespace
	23	{
	24	// Enumeration for character type compare cases.
	25	enum class compare_case
	26	{
	27	ascii_ascii,
	28	ascii_rune,
	29	rune_ascii,
	30	rune_rune
	31	};
	32
	33	// Scenario matrix for compare cases
	34	const compare_case scenario_matrix[][2] =
	35	{
	36	{ compare_case::ascii_ascii, compare_case::ascii_rune },
	37	{ compare_case::rune_ascii, compare_case::rune_rune },
	38	};
	39
	40	// Case indices
	41	const auto ascii_idx = std::size_t{ 0 };
	42	const auto rune_idx = std::size_t{ 1 };
	43
	44	// Compare function for character types.
	45	template <typename CharacterType1, typename CharacterType2>
	46	int _compare(word_t len, CharacterType1 s1, CharacterType2 s2)
	47	{
	48	for (auto i = word_t{ 0 }; i < len; ++i)
	49	{
	50	const auto sc1 = static_cast<rune_t>(s1[i]);
	51	const auto sc2 = static_cast<rune_t>(s2[i]);
	52
	53	if (sc1 != sc2)
	54	return (sc1 < sc2) ? (-1) : 1;
	55	}
	56
	57	return 0;
	58	}
	59	}
	60
	61	int vm_string_t::compare(const vm_string_t s1, const vm_string_t s2)
	62	{
	63	auto len_1 = word_t{ 0 };
	64	auto scen_1 = ascii_idx;
	65	void *str_mem_1 = "";
	66	if (s1 != nullptr)
	67	{
	68	len_1 = s1->_length;
	69	scen_1 = s1->_character_size == sizeof(char) ? ascii_idx : rune_idx;
	70	str_mem_1 = (s1->_is_alloc) ? s1->_mem.alloc : s1->_mem.local;
	71	}
	72
	73	auto len_2 = word_t{ 0 };
	74	auto scen_2 = ascii_idx;
	75	void *str_mem_2 = "";
	76	if (s2 != nullptr)
	77	{
	78	len_2 = s2->_length;
	79	scen_2 = s2->_character_size == sizeof(char) ? ascii_idx : rune_idx;
	80	str_mem_2 = (s2->_is_alloc) ? s2->_mem.alloc : s2->_mem.local;
	81	}
	82
	83	// Check the simple compare case between the same string.
	84	if (str_mem_1 == str_mem_2)
	85	return 0;
	86
	87	const auto scenario = scenario_matrix[scen_1][scen_2];
	88
	89	auto result = int{ 0 };
	90	const auto min_length = std::min(len_1, len_2);
	91	switch (scenario)
	92	{
	93	default:
	94	assert(false && "Unknown compare scenario");
	95	case compare_case::ascii_ascii:
	96	case compare_case::rune_rune:
	97	result = std::memcmp(str_mem_1, str_mem_2, min_length);
	98	break;
	99	case compare_case::ascii_rune:
	100	result = _compare(min_length, reinterpret_cast<char >(str_mem_1), reinterpret_cast<rune_t >(str_mem_2));
	101	break;
	102	case compare_case::rune_ascii:
	103	result = _compare(min_length, reinterpret_cast<rune_t >(str_mem_1), reinterpret_cast<char >(str_mem_2));
	104	break;
	105	}
	106
	107	if (result != 0)
	108	return result;
	109
	110	// Comparing lengths if one string is a proper sub-string of the other.
	111	return (len_1 - len_2);
	112	}
	113
	114	namespace
	115	{
	116	template<typename DestCharacterType, typename SourceCharacterType>
	117	void copy_characters_to(DestCharacterType dest, word_t dest_start, const SourceCharacterType source, word_t source_length)
	118	{
	119	for (auto i = word_t{ 0 }; i < source_length; ++i)
	120	dest[dest_start + i] = static_cast<DestCharacterType>(source[i]);
	121	}
	122
	123	template<>
	124	void copy_characters_to(char dest, word_t dest_start, const char source, word_t source_length)
	125	{
	126	assert(dest != nullptr && source != nullptr);
	127	std::memcpy((dest + dest_start), source, source_length);
	128	}
	129
	130	template<>
	131	void copy_characters_to(rune_t dest, word_t dest_start, const rune_t source, word_t source_length)
	132	{
	133	assert(dest != nullptr && source != nullptr);
	134	std::memcpy((dest + dest_start), source, (source_length * sizeof(rune_t)));
	135	}
	136
	137	void combine(
	138	bool dest_is_rune,
	139	uint8_t *dest,
	140	bool source1_is_rune,
	141	word_t source1_length,
	142	const uint8_t *source1,
	143	bool source2_is_rune,
	144	word_t source2_length,
	145	const uint8_t *source2)
	146	{
	147	if (dest_is_rune)
	148	{
	149	auto dest_rune = reinterpret_cast<rune_t *>(dest);
	150	if (source1_is_rune)
	151	copy_characters_to(dest_rune, 0, reinterpret_cast<const rune_t *>(source1), source1_length);
	152	else
	153	copy_characters_to(dest_rune, 0, source1, source1_length);
	154
	155	if (source2_is_rune)
	156	copy_characters_to(dest_rune, source1_length, reinterpret_cast<const rune_t *>(source2), source2_length);
	157	else
	158	copy_characters_to(dest_rune, source1_length, source2, source2_length);
	159	}
	160	else
	161	{
	162	copy_characters_to(dest, 0, source1, source1_length);
	163	copy_characters_to(dest, source1_length, source2, source2_length);
	164	}
	165	}
	166
	167	word_t compute_max_length(word_t current_length)
	168	{
	169	// Length + 1 (null) + space for string expansion
	170	return (current_length + 1 + (current_length / 4));
	171	}
	172	}
	173
	174	vm_string_t::vm_string_t()
	175	: vm_alloc_t(vm_string_t::type_desc())
	176	, _character_size{ sizeof(char) }
	177	, _encoded_str{ nullptr }
	178	, _is_alloc{ false }
	179	, _length{ 0 }
	180	, _length_max{ sizeof(_mem.local) }
	181	, _mem{}
	182	{ }
	183
	184	vm_string_t::vm_string_t(std::size_t encoded_str_len, const uint8_t *encoded_str)
	185	: vm_alloc_t(vm_string_t::type_desc())
	186	, _character_size{ sizeof(char) }
	187	, _encoded_str{ nullptr }
	188	, _is_alloc{ false }
	189	, _length{ 0 }
	190	, _length_max{ sizeof(_mem.local) }
	191	, _mem{}
	192	{
	193	assert((encoded_str_len > 0 && encoded_str != nullptr) \|\| (encoded_str_len == 0 && encoded_str == nullptr));
	194	auto character_count = utf8::count_codepoints(encoded_str, encoded_str_len);
	195	_character_size = (encoded_str_len != character_count) ? sizeof(rune_t) : sizeof(char);
	196
	197	_length = static_cast<word_t>(character_count);
	198	_length_max = sizeof(_mem.local) / _character_size;
	199
	200	// Allocate memory based on character count and size
	201	auto dest = _mem.local;
	202	if ((encoded_str_len + 1) > sizeof(_mem.local))
	203	{
	204	// If we are going to allocate, make sure it is larger than needed.
	205	_length_max = compute_max_length(_length);
	206	_mem.alloc = calloc_memory<uint8_t>(_length_max * _character_size);
	207	_is_alloc = true;
	208
	209	dest = _mem.alloc;
	210	}
	211
	212	// Copy over the entire buffer if ASCII or convert and copy if multi-byte
	213	if (_character_size == sizeof(char))
	214	{
	215	std::memcpy(dest, encoded_str, encoded_str_len);
	216	}
	217	else
	218	{
	219	auto rune_dest = reinterpret_cast<rune_t *>(dest);
	220	for (auto i = word_t{ 0 }; i < _length; ++i)
	221	encoded_str += utf8::decode(encoded_str, rune_dest[i]);
	222	}
	223
	224	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	225	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm string: %d %d >>%s<<\n", _length, (_length_max * _character_size), dest);
	226	}
	227
	228	vm_string_t::vm_string_t(const vm_string_t &s1, const vm_string_t &s2)
	229	: vm_alloc_t(vm_string_t::type_desc())
	230	, _character_size{ std::max(s1._character_size, s2._character_size) }
	231	, _encoded_str{ nullptr }
	232	, _is_alloc{ true }
	233	, _length{ s1._length + s2._length }
	234	, _length_max{ s1._length + s2._length }
	235	, _mem{}
	236	{
	237	_mem.alloc = calloc_memory<uint8_t>(_length_max * _character_size);
	238
	239	const auto s1_data = (s1._is_alloc) ? s1._mem.alloc : s1._mem.local;
	240	const auto s2_data = (s2._is_alloc) ? s2._mem.alloc : s2._mem.local;
	241
	242	// Combine the two strings
	243	combine(
	244	_character_size == sizeof(rune_t),
	245	_mem.alloc,
	246	s1._character_size == sizeof(rune_t),
	247	s1._length,
	248	s1_data,
	249	s2._character_size == sizeof(rune_t),
	250	s2._length,
	251	s2_data);
	252	}
	253
	254	vm_string_t::vm_string_t(const vm_string_t &other, word_t begin_index, word_t end_index)
	255	: vm_alloc_t(other.alloc_type)
	256	, _character_size{ other._character_size }
	257	, _encoded_str{ nullptr }
	258	, _is_alloc{ other._is_alloc }
	259	, _length{ end_index - begin_index }
	260	, _length_max{ compute_max_length(end_index - begin_index) }
	261	, _mem{}
	262	{
	263	if (end_index <= begin_index)
	264	throw out_of_range_memory{};
	265
	266	if (begin_index < 0)
	267	throw out_of_range_memory{ 0, other._length, begin_index };
	268
	269	if (other._length < end_index)
	270	throw out_of_range_memory{ 0, other._length, end_index };
	271
	272	// Allocate memory based on character count and size
	273	auto src = other._mem.local;
	274	auto dest = _mem.local;
	275	const auto length_in_bytes = _length * _character_size;
	276	if (_is_alloc)
	277	{
	278	src = other._mem.alloc;
	279	_mem.alloc = calloc_memory<uint8_t>(_length_max);
	280	dest = _mem.alloc;
	281	}
	282
	283	// Copy over string content starting at the correct index (char vs. rune_t)
	284	::memcpy(dest, (src + (begin_index * _character_size)), length_in_bytes);
	285	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "copy: vm string: %#" PRIxPTR " %d %d %#" PRIxPTR "\n", &other, begin_index, end_index, this);
	286	}
	287
	288	vm_string_t::~vm_string_t()
	289	{
	290	// Free memory and string buffer
	291	if (_is_alloc)
	292	{
	293	if (static_cast<void >(_mem.alloc) != static_cast<void >(_encoded_str))
	294	free_memory(_encoded_str);
	295
	296	free_memory(_mem.alloc);
	297	}
	298	else
	299	{
	300	if (static_cast<void >(_mem.local) != static_cast<void >(_encoded_str))
	301	free_memory(_encoded_str);
	302	}
	303
	304	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm string\n");
	305
	306	debug::assign_debug_pointer(&_mem.alloc);
	307	debug::assign_debug_pointer(&_encoded_str);
	308	}
	309
	310	vm_string_t &vm_string_t::append(const vm_string_t &other)
	311	{
	312	// This function does not adhere to the immutable string contract.
	313	// Therefore, it is unsafe to call this function if there is more
	314	// than 1 reference to this string instance.
	315	assert(get_ref_count() <= 1);
	316
	317	// Check if the new string has any length at all.
	318	const auto other_length = other._length;
	319	if (other_length == 0)
	320	return *this;
	321
	322	const auto other_is_rune = other._character_size == sizeof(rune_t);
	323	const auto other_source = (other._is_alloc) ? other._mem.alloc : other._mem.local;
	324
	325	const auto local_is_rune = _character_size == sizeof(rune_t);
	326	const auto local_length = _length;
	327	const auto local_source = (_is_alloc) ? _mem.alloc : _mem.local;
	328
	329	// Release the encoded string for this instance.
	330	{
	331	std::lock_guard<std::mutex> lock{ _encoded_str_lock };
	332	if (_encoded_str != reinterpret_cast<char*>(local_source))
	333	{
	334	free_memory(_encoded_str);
	335	_encoded_str = nullptr;
	336	}
	337	}
	338
	339	// Define the values for the appended string
	340	const auto new_length = local_length + other_length;
	341	const auto new_length_max = (new_length == 0) ? static_cast<word_t>(sizeof(_mem.local)) : compute_max_length(new_length);
	342	const auto new_is_rune = local_is_rune \|\| other_is_rune;
	343	uint8_t *new_source = nullptr;
	344
	345	// Check if this string and the supplied string have the same character size.
	346	if (new_is_rune)
	347	new_source = calloc_memory<uint8_t>(new_length_max * sizeof(rune_t));
	348	else
	349	new_source = calloc_memory<uint8_t>(new_length_max);
	350
	351	// Combine the two string sources
	352	combine(
	353	new_is_rune,
	354	new_source,
	355	local_is_rune,
	356	local_length,
	357	local_source,
	358	other_is_rune,
	359	other_length,
	360	other_source);
	361
	362	_length = new_length;
	363	_length_max = new_length_max;
	364
	365	// Free the local allocation
	366	if (_is_alloc)
	367	{
	368	free_memory(local_source);
	369	_mem.alloc = nullptr;
	370	}
	371
	372	_mem.alloc = new_source;
	373	_is_alloc = true;
	374	_character_size = new_is_rune ? sizeof(rune_t) : sizeof(char);
	375
	376	return *this;
	377	}
	378
	379	word_t vm_string_t::get_length() const
	380	{
	381	return _length;
	382	}
	383
	384	rune_t vm_string_t::get_rune(word_t index) const
	385	{
	386	if (index < 0 && _length <= index)
	387	throw out_of_range_memory{ 0, _length - 1, index };
	388
	389	// Determine if local or allocated memory
	390	auto source = reinterpret_cast<const char *>(_mem.local);
	391	if (_is_alloc)
	392	source = reinterpret_cast<const char *>(_mem.alloc);
	393
	394	// Check if multi-byte or ASCII
	395	if (_character_size != sizeof(char))
	396	return reinterpret_cast<const rune_t *>(source)[index];
	397	else
	398	return static_cast<const rune_t>(source[index]);
	399	}
	400
	401	void vm_string_t::set_rune(word_t index, rune_t value)
	402	{
	403	// This function does not adhere to the immutable string contract.
	404	// Therefore, it is unsafe to call this function if there is more
	405	// than 1 reference to this string instance.
	406	assert(get_ref_count() <= 1);
	407
	408	if (value > utf8::constants::max_supported_codepoint)
	409	throw invalid_utf8{};
	410
	411	// Index equal to length is allowed to grow the string
	412	if (index < 0 && _length <= index)
	413	throw out_of_range_memory{ 0, _length, index };
	414
	415	// Determine if local or allocated memory
	416	auto source = static_cast<uint8_t *>(_mem.local);
	417	if (_is_alloc)
	418	{
	419	source = static_cast<uint8_t *>(_mem.alloc);
	420
	421	// Since we are setting a rune, the string value should be freed.
	422	if (_encoded_str != nullptr)
	423	free_memory(_encoded_str);
	424	}
	425
	426	// Reset the string so it can be regenerated.
	427	_encoded_str = nullptr;
	428
	429	const auto new_character_size = (value > utf8::constants::max_codepoint_ascii) ? sizeof(rune_t) : sizeof(char);
	430	assert(new_character_size < std::numeric_limits<uint8_t>::max());
	431
	432	if (new_character_size > _character_size) // Expand the string if the new character is non-ASCII.
	433	{
	434	_character_size = static_cast<uint8_t>(new_character_size);
	435	assert(_character_size == sizeof(rune_t));
	436
	437	_length_max = (_length == 0) ? static_cast<word_t>(sizeof(_mem.local)) : compute_max_length(_length);
	438	auto new_alloc = calloc_memory<rune_t>(_length_max * _character_size);
	439
	440	// Copy source into the new alloc.
	441	copy_characters_to(new_alloc, 0, source, _length);
	442
	443	// Free memory, if allocated
	444	if (_is_alloc)
	445	free_memory(source);
	446
	447	debug::assign_debug_memory(&_mem, sizeof(_mem));
	448
	449	_is_alloc = true;
	450	_mem.alloc = reinterpret_cast<uint8_t *>(new_alloc);
	451	source = _mem.alloc;
	452	}
	453	else if (static_cast<word_t>(_length_max) <= index) // Check if string can accomodate the new character.
	454	{
	455	_length_max = (_length == 0) ? static_cast<word_t>(sizeof(_mem.local)) : compute_max_length(_length);
	456	auto new_alloc = calloc_memory<uint8_t>(_length_max * _character_size);
	457	::memcpy(new_alloc, source, _length * _character_size);
	458
	459	// Free memory, if allocated
	460	if (_is_alloc)
	461	free_memory(source);
	462
	463	debug::assign_debug_memory(&_mem, sizeof(_mem));
	464
	465	_is_alloc = true;
	466	_mem.alloc = new_alloc;
	467	source = _mem.alloc;
	468	}
	469
	470	// Check if multi-byte or ASCII.
	471	if (_character_size != sizeof(char))
	472	reinterpret_cast<rune_t *>(source)[index] = value;
	473	else
	474	source[index] = static_cast<uint8_t>(value & utf8::constants::max_codepoint_ascii);
	475
	476	// Increment the length, if the index matches the length.
	477	if (_length == index)
	478	_length++;
	479	}
	480
	481	int vm_string_t::compare_to(const vm_string_t *s) const
	482	{
	483	return vm_string_t::compare(this, s);
	484	}
	485
	486	const char *vm_string_t::str() const
	487	{
	488	if (_encoded_str != nullptr)
	489	return _encoded_str;
	490
	491	{
	492	// [PERF] Use a spin-lock instead of a mutex here.
	493	std::lock_guard<std::mutex> lock{ _encoded_str_lock };
	494
	495	if (_encoded_str != nullptr)
	496	return _encoded_str;
	497
	498	// If the string is ASCII then just return the memory
	499	if (_character_size == sizeof(char))
	500	{
	501	_encoded_str = (_is_alloc) ? reinterpret_cast<char >(_mem.alloc) : reinterpret_cast<char >(_mem.local);
	502	return _encoded_str;
	503	}
	504
	505	const auto rune_str = (_is_alloc) ? reinterpret_cast<rune_t >(_mem.alloc) : reinterpret_cast<rune_t >(_mem.local);
	506	const auto str_len = (_length * _character_size) + 1; // Plus 1 for a null terminator
	507	auto encoded_str_local = alloc_memory<char>(str_len);
	508
	509	auto s = reinterpret_cast<uint8_t *>(encoded_str_local);
	510	for (auto i = word_t{ 0 }; i < _length; ++i)
	511	{
	512	auto curr_rune = rune_str[i];
	513	s = utf8::encode(curr_rune, s);
	514	}
	515
	516	// Ensure the final value is null.
	517	*s = 0;
	518
	519	_encoded_str = encoded_str_local;
	520	return _encoded_str;
	521	}
	522	}

src/vm/sys/Sysmod.cpp+478−0

@@ -0,0 +1,478 @@
	1	//
	2	// Dis VM
	3	// File: Sysmod.cpp
	4	// Author: arr
	5	//
	6
	7	#include <array>
	8	#include <chrono>
	9	#include <thread>
	10	#include <exceptions.h>
	11	#include <utf8.h>
	12	#include "Sysmod.h"
	13	#include "sys_utils.h"
	14
	15	using namespace disvm;
	16	using namespace disvm::runtime;
	17
	18	namespace
	19	{
	20	disvm::runtime::builtin::vm_runtab_t Sysmodtab[] = {
	21	"announce",0xb7c4ac0,Sys_announce,40,2,{ 0x0,0x80, },
	22	"aprint",0x77442d46,Sys_aprint,0,0,{ 0 },
	23	"bind",0x66326d91,Sys_bind,48,2,{ 0x0,0xc0, },
	24	"byte2char",0x3d6094f9,Sys_byte2char,40,2,{ 0x0,0x80, },
	25	"char2byte",0x2ba5ab41,Sys_char2byte,48,2,{ 0x0,0x40, },
	26	"chdir",0xc6935858,Sys_chdir,40,2,{ 0x0,0x80, },
	27	"create",0x54db77d9,Sys_create,48,2,{ 0x0,0x80, },
	28	"dial",0x29e90174,Sys_dial,40,2,{ 0x0,0xc0, },
	29	"dirread",0x72210d71,Sys_dirread,40,2,{ 0x0,0x80, },
	30	"dup",0x6584767b,Sys_dup,40,0,{ 0 },
	31	"export",0x6fc6dc03,Sys_export,48,2,{ 0x0,0xc0, },
	32	"fauth",0x20ccc34b,Sys_fauth,40,2,{ 0x0,0xc0, },
	33	"fd2path",0x749c6042,Sys_fd2path,40,2,{ 0x0,0x80, },
	34	"fildes",0x1478f993,Sys_fildes,40,0,{ 0 },
	35	"file2chan",0x9f34d686,Sys_file2chan,40,2,{ 0x0,0xc0, },
	36	"fprint",0xf46486c8,Sys_fprint,0,0,{ 0 },
	37	"fstat",0xda4499c2,Sys_fstat,40,2,{ 0x0,0x80, },
	38	"fversion",0xfe9c0a06,Sys_fversion,48,2,{ 0x0,0xa0, },
	39	"fwstat",0x50a6c7e0,Sys_fwstat,104,2,{ 0x0,0xbc, },
	40	"iounit",0x5583b730,Sys_iounit,40,2,{ 0x0,0x80, },
	41	"listen",0xb97416e0,Sys_listen,48,2,{ 0x0,0xe0, },
	42	"millisec",0x616977e8,Sys_millisec,32,0,{ 0 },
	43	"mount",0x74c17b3a,Sys_mount,56,2,{ 0x0,0xe8, },
	44	"open",0x8f477f99,Sys_open,40,2,{ 0x0,0x80, },
	45	"pctl",0x5df27fb,Sys_pctl,40,2,{ 0x0,0x40, },
	46	"pipe",0x1f2c52ea,Sys_pipe,40,2,{ 0x0,0x80, },
	47	"pread",0x9d8aac6,Sys_pread,56,2,{ 0x0,0xc0, },
	48	"print",0xac849033,Sys_print,0,0,{ 0 },
	49	"pwrite",0x9d8aac6,Sys_pwrite,56,2,{ 0x0,0xc0, },
	50	"read",0x7cfef557,Sys_read,48,2,{ 0x0,0xc0, },
	51	"readn",0x7cfef557,Sys_readn,48,2,{ 0x0,0xc0, },
	52	"remove",0xc6935858,Sys_remove,40,2,{ 0x0,0x80, },
	53	"seek",0xaeccaddb,Sys_seek,56,2,{ 0x0,0x80, },
	54	"sleep",0xe67bf126,Sys_sleep,40,0,{ 0 },
	55	"sprint",0x4c0624b6,Sys_sprint,0,0,{ 0 },
	56	"stat",0x319328dd,Sys_stat,40,2,{ 0x0,0x80, },
	57	"stream",0xb9e8f9ea,Sys_stream,48,2,{ 0x0,0xc0, },
	58	"tokenize",0x57338f20,Sys_tokenize,40,2,{ 0x0,0xc0, },
	59	"unmount",0x21e337e3,Sys_unmount,40,2,{ 0x0,0xc0, },
	60	"utfbytes",0x1d4a1f4,Sys_utfbytes,40,2,{ 0x0,0x80, },
	61	"werrstr",0xc6935858,Sys_werrstr,40,2,{ 0x0,0x80, },
	62	"write",0x7cfef557,Sys_write,48,2,{ 0x0,0xc0, },
	63	"wstat",0x56b02096,Sys_wstat,104,2,{ 0x0,0xbc, },
	64	0
	65	};
	66
	67	const word_t Sysmodlen = 43;
	68	}
	69
	70	std::shared_ptr<const type_descriptor_t> T_Qid;
	71	std::shared_ptr<const type_descriptor_t> T_Dir;
	72	std::shared_ptr<const type_descriptor_t> T_FD;
	73	std::shared_ptr<const type_descriptor_t> T_Connection;
	74	std::shared_ptr<const type_descriptor_t> T_FileIO;
	75
	76	void
	77	Sysmodinit(void)
	78	{
	79	builtin::register_module_exports(Sys_PATH, Sysmodlen, Sysmodtab);
	80	T_Qid = type_descriptor_t::create(sizeof(Sys_Qid), sizeof(Sys_Qid_map), Sys_Qid_map);
	81	T_Dir = type_descriptor_t::create(sizeof(Sys_Dir), sizeof(Sys_Dir_map), Sys_Dir_map);
	82	T_FD = type_descriptor_t::create(sizeof(Sys_FD), sizeof(Sys_FD_map), Sys_FD_map);
	83	T_Connection = type_descriptor_t::create(sizeof(Sys_Connection), sizeof(Sys_Connection_map), Sys_Connection_map);
	84	T_FileIO = type_descriptor_t::create(sizeof(Sys_FileIO), sizeof(Sys_FileIO_map), Sys_FileIO_map);
	85	}
	86
	87	void
	88	Sys_announce(vm_registers_t &r, vm_t &vm)
	89	{
	90	auto &fp = r.stack.peek_frame()->base<F_Sys_announce>();
	91	throw vm_system_exception{ "Instruction not implemented" };
	92	}
	93
	94	void
	95	Sys_aprint(vm_registers_t &r, vm_t &vm)
	96	{
	97	auto &fp = r.stack.peek_frame()->base<F_Sys_aprint>();
	98	throw vm_system_exception{ "Instruction not implemented" };
	99	}
	100
	101	void
	102	Sys_bind(vm_registers_t &r, vm_t &vm)
	103	{
	104	auto &fp = r.stack.peek_frame()->base<F_Sys_bind>();
	105	throw vm_system_exception{ "Instruction not implemented" };
	106	}
	107
	108	void
	109	Sys_byte2char(vm_registers_t &r, vm_t &vm)
	110	{
	111	auto &fp = r.stack.peek_frame()->base<F_Sys_byte2char>();
	112
	113	auto buffer = vm_alloc_t::from_allocation<vm_array_t>(fp.buf);
	114	assert(buffer->get_element_type()->size_in_bytes == intrinsic_type_desc::type<byte_t>()->size_in_bytes);
	115
	116	const auto n = fp.n;
	117	if (buffer == nullptr \|\| n >= buffer->get_length())
	118	throw out_of_range_memory{};
	119
	120	// Initialize for failure.
	121	fp.ret->t0 = Sys_UTFerror;
	122	fp.ret->t1 = 0;
	123	fp.ret->t2 = 0;
	124
	125	auto state = utf8::decode_state::accept;
	126	auto result = rune_t{};
	127	const auto buffer_len = buffer->get_length();
	128	for (auto i = n; i < buffer_len; ++i)
	129	{
	130	auto b = buffer->at<byte_t>(i);
	131	state = utf8::decode_step(state, result, b);
	132	if (state == utf8::decode_state::accept)
	133	{
	134	fp.ret->t0 = result;
	135	fp.ret->t1 = (i - n) + 1; // Number of bytes consumed
	136	fp.ret->t2 = 1;
	137	return;
	138	}
	139	else if (state == utf8::decode_state::reject)
	140	{
	141	fp.ret->t1 = 1;
	142	return;
	143	}
	144	}
	145	}
	146
	147	void
	148	Sys_char2byte(vm_registers_t &r, vm_t &vm)
	149	{
	150	auto &fp = r.stack.peek_frame()->base<F_Sys_char2byte>();
	151
	152	auto buffer = vm_alloc_t::from_allocation<vm_array_t>(fp.buf);
	153	assert(buffer->get_element_type()->size_in_bytes == intrinsic_type_desc::type<byte_t>()->size_in_bytes);
	154
	155	const auto n = fp.n;
	156	if (buffer == nullptr \|\| n >= buffer->get_length())
	157	throw out_of_range_memory{};
	158
	159	const auto rune = static_cast<rune_t>(fp.c);
	160
	161	static_assert(Sys_UTFmax == sizeof(rune_t), "UTF max should be same size as rune");
	162	uint8_t buffer_local[sizeof(Sys_UTFmax)];
	163	auto begin = buffer_local;
	164
	165	auto end = utf8::encode(rune, begin);
	166	const auto count = static_cast<word_t>(end - begin);
	167
	168	// Initialize for failure.
	169	*fp.ret = 0;
	170
	171	const auto final_index = n + count;
	172	if (final_index > buffer->get_length())
	173	return;
	174
	175	// Insert the bytes into the buffer
	176	for (auto i = word_t{ n }; i < final_index; ++i)
	177	{
	178	buffer->at<uint8_t>(i) = *begin;
	179	begin++;
	180	}
	181
	182	*fp.ret = count;
	183	}
	184
	185	void
	186	Sys_chdir(vm_registers_t &r, vm_t &vm)
	187	{
	188	auto &fp = r.stack.peek_frame()->base<F_Sys_chdir>();
	189	throw vm_system_exception{ "Instruction not implemented" };
	190	}
	191
	192	void
	193	Sys_create(vm_registers_t &r, vm_t &vm)
	194	{
	195	auto &fp = r.stack.peek_frame()->base<F_Sys_create>();
	196	throw vm_system_exception{ "Instruction not implemented" };
	197	}
	198
	199	void
	200	Sys_dial(vm_registers_t &r, vm_t &vm)
	201	{
	202	auto &fp = r.stack.peek_frame()->base<F_Sys_dial>();
	203	throw vm_system_exception{ "Instruction not implemented" };
	204	}
	205
	206	void
	207	Sys_dirread(vm_registers_t &r, vm_t &vm)
	208	{
	209	auto &fp = r.stack.peek_frame()->base<F_Sys_dirread>();
	210	throw vm_system_exception{ "Instruction not implemented" };
	211	}
	212
	213	void
	214	Sys_dup(vm_registers_t &r, vm_t &vm)
	215	{
	216	auto &fp = r.stack.peek_frame()->base<F_Sys_dup>();
	217	throw vm_system_exception{ "Instruction not implemented" };
	218	}
	219
	220	void
	221	Sys_export(vm_registers_t &r, vm_t &vm)
	222	{
	223	auto &fp = r.stack.peek_frame()->base<F_Sys_export>();
	224	throw vm_system_exception{ "Instruction not implemented" };
	225	}
	226
	227	void
	228	Sys_fauth(vm_registers_t &r, vm_t &vm)
	229	{
	230	auto &fp = r.stack.peek_frame()->base<F_Sys_fauth>();
	231	throw vm_system_exception{ "Instruction not implemented" };
	232	}
	233
	234	void
	235	Sys_fd2path(vm_registers_t &r, vm_t &vm)
	236	{
	237	auto &fp = r.stack.peek_frame()->base<F_Sys_fd2path>();
	238	throw vm_system_exception{ "Instruction not implemented" };
	239	}
	240
	241	void
	242	Sys_fildes(vm_registers_t &r, vm_t &vm)
	243	{
	244	auto &fp = r.stack.peek_frame()->base<F_Sys_fildes>();
	245	throw vm_system_exception{ "Instruction not implemented" };
	246	}
	247
	248	void
	249	Sys_file2chan(vm_registers_t &r, vm_t &vm)
	250	{
	251	auto &fp = r.stack.peek_frame()->base<F_Sys_file2chan>();
	252	throw vm_system_exception{ "Instruction not implemented" };
	253	}
	254
	255	void
	256	Sys_fprint(vm_registers_t &r, vm_t &vm)
	257	{
	258	auto &fp = r.stack.peek_frame()->base<F_Sys_fprint>();
	259	throw vm_system_exception{ "Instruction not implemented" };
	260	}
	261
	262	void
	263	Sys_fstat(vm_registers_t &r, vm_t &vm)
	264	{
	265	auto &fp = r.stack.peek_frame()->base<F_Sys_fstat>();
	266	throw vm_system_exception{ "Instruction not implemented" };
	267	}
	268
	269	void
	270	Sys_fversion(vm_registers_t &r, vm_t &vm)
	271	{
	272	auto &fp = r.stack.peek_frame()->base<F_Sys_fversion>();
	273	throw vm_system_exception{ "Instruction not implemented" };
	274	}
	275
	276	void
	277	Sys_fwstat(vm_registers_t &r, vm_t &vm)
	278	{
	279	auto &fp = r.stack.peek_frame()->base<F_Sys_fwstat>();
	280	throw vm_system_exception{ "Instruction not implemented" };
	281	}
	282
	283	void
	284	Sys_iounit(vm_registers_t &r, vm_t &vm)
	285	{
	286	auto &fp = r.stack.peek_frame()->base<F_Sys_iounit>();
	287	throw vm_system_exception{ "Instruction not implemented" };
	288	}
	289
	290	void
	291	Sys_listen(vm_registers_t &r, vm_t &vm)
	292	{
	293	auto &fp = r.stack.peek_frame()->base<F_Sys_listen>();
	294	throw vm_system_exception{ "Instruction not implemented" };
	295	}
	296
	297	void
	298	Sys_millisec(vm_registers_t &r, vm_t &vm)
	299	{
	300	const auto current_time = std::chrono::steady_clock::now();
	301	const auto current_time_in_ms = std::chrono::duration_cast<std::chrono::milliseconds>(current_time.time_since_epoch());
	302
	303	auto &fp = r.stack.peek_frame()->base<F_Sys_millisec>();
	304	*fp.ret = static_cast<word_t>(current_time_in_ms.count());
	305	}
	306
	307	void
	308	Sys_mount(vm_registers_t &r, vm_t &vm)
	309	{
	310	auto &fp = r.stack.peek_frame()->base<F_Sys_mount>();
	311	throw vm_system_exception{ "Instruction not implemented" };
	312	}
	313
	314	void
	315	Sys_open(vm_registers_t &r, vm_t &vm)
	316	{
	317	auto &fp = r.stack.peek_frame()->base<F_Sys_open>();
	318	throw vm_system_exception{ "Instruction not implemented" };
	319	}
	320
	321	void
	322	Sys_pctl(vm_registers_t &r, vm_t &vm)
	323	{
	324	auto &fp = r.stack.peek_frame()->base<F_Sys_pctl>();
	325	throw vm_system_exception{ "Instruction not implemented" };
	326	}
	327
	328	void
	329	Sys_pipe(vm_registers_t &r, vm_t &vm)
	330	{
	331	auto &fp = r.stack.peek_frame()->base<F_Sys_pipe>();
	332	throw vm_system_exception{ "Instruction not implemented" };
	333	}
	334
	335	void
	336	Sys_pread(vm_registers_t &r, vm_t &vm)
	337	{
	338	auto &fp = r.stack.peek_frame()->base<F_Sys_pread>();
	339	throw vm_system_exception{ "Instruction not implemented" };
	340	}
	341
	342	void
	343	Sys_print(vm_registers_t &r, vm_t &vm)
	344	{
	345	auto &fp = r.stack.peek_frame()->base<F_Sys_print>();
	346	auto str = vm_alloc_t::from_allocation<vm_string_t>(fp.s);
	347
	348	if (str == nullptr)
	349	throw dereference_nil{ "Print string" };
	350
	351	auto static_buffer = std::array<char, 1024>{};
	352	auto written = printf_to_buffer(*str, &fp.vargs, static_buffer.size(), static_buffer.data());
	353	if (written >= 0)
	354	{
	355	std::printf(static_buffer.data());
	356	}
	357	else
	358	{
	359	auto dynamic_buffer = std::vector<char>(static_buffer.size() * 2);
	360	written = printf_to_dynamic_buffer(*str, &fp.vargs, dynamic_buffer);
	361	std::printf(dynamic_buffer.data());
	362	}
	363
	364	*fp.ret = written;
	365	}
	366
	367	void
	368	Sys_pwrite(vm_registers_t &r, vm_t &vm)
	369	{
	370	auto &fp = r.stack.peek_frame()->base<F_Sys_pwrite>();
	371	throw vm_system_exception{ "Instruction not implemented" };
	372	}
	373
	374	void
	375	Sys_read(vm_registers_t &r, vm_t &vm)
	376	{
	377	auto &fp = r.stack.peek_frame()->base<F_Sys_read>();
	378	throw vm_system_exception{ "Instruction not implemented" };
	379	}
	380
	381	void
	382	Sys_readn(vm_registers_t &r, vm_t &vm)
	383	{
	384	auto &fp = r.stack.peek_frame()->base<F_Sys_readn>();
	385	throw vm_system_exception{ "Instruction not implemented" };
	386	}
	387
	388	void
	389	Sys_remove(vm_registers_t &r, vm_t &vm)
	390	{
	391	auto &fp = r.stack.peek_frame()->base<F_Sys_remove>();
	392	throw vm_system_exception{ "Instruction not implemented" };
	393	}
	394
	395	void
	396	Sys_seek(vm_registers_t &r, vm_t &vm)
	397	{
	398	auto &fp = r.stack.peek_frame()->base<F_Sys_seek>();
	399	throw vm_system_exception{ "Instruction not implemented" };
	400	}
	401
	402	void
	403	Sys_sleep(vm_registers_t &r, vm_t &vm)
	404	{
	405	auto &fp = r.stack.peek_frame()->base<F_Sys_sleep>();
	406
	407	const auto period_ms = fp.period;
	408
	409	// [TODO] Thread should yield to another according to the sleep() specification.
	410	r.current_thread_state = vm_thread_state_t::release;
	411	std::this_thread::sleep_for(std::chrono::milliseconds(period_ms));
	412	r.current_thread_state = vm_thread_state_t::ready;
	413
	414	*fp.ret = 0;
	415	}
	416
	417	void
	418	Sys_sprint(vm_registers_t &r, vm_t &vm)
	419	{
	420	auto &fp = r.stack.peek_frame()->base<F_Sys_sprint>();
	421	throw vm_system_exception{ "Instruction not implemented" };
	422	}
	423
	424	void
	425	Sys_stat(vm_registers_t &r, vm_t &vm)
	426	{
	427	auto &fp = r.stack.peek_frame()->base<F_Sys_stat>();
	428	throw vm_system_exception{ "Instruction not implemented" };
	429	}
	430
	431	void
	432	Sys_stream(vm_registers_t &r, vm_t &vm)
	433	{
	434	auto &fp = r.stack.peek_frame()->base<F_Sys_stream>();
	435	throw vm_system_exception{ "Instruction not implemented" };
	436	}
	437
	438	void
	439	Sys_tokenize(vm_registers_t &r, vm_t &vm)
	440	{
	441	auto &fp = r.stack.peek_frame()->base<F_Sys_tokenize>();
	442	throw vm_system_exception{ "Instruction not implemented" };
	443	}
	444
	445	void
	446	Sys_unmount(vm_registers_t &r, vm_t &vm)
	447	{
	448	auto &fp = r.stack.peek_frame()->base<F_Sys_unmount>();
	449	throw vm_system_exception{ "Instruction not implemented" };
	450	}
	451
	452	void
	453	Sys_utfbytes(vm_registers_t &r, vm_t &vm)
	454	{
	455	auto &fp = r.stack.peek_frame()->base<F_Sys_utfbytes>();
	456	throw vm_system_exception{ "Instruction not implemented" };
	457	}
	458
	459	void
	460	Sys_werrstr(vm_registers_t &r, vm_t &vm)
	461	{
	462	auto &fp = r.stack.peek_frame()->base<F_Sys_werrstr>();
	463	throw vm_system_exception{ "Instruction not implemented" };
	464	}
	465
	466	void
	467	Sys_write(vm_registers_t &r, vm_t &vm)
	468	{
	469	auto &fp = r.stack.peek_frame()->base<F_Sys_write>();
	470	throw vm_system_exception{ "Instruction not implemented" };
	471	}
	472
	473	void
	474	Sys_wstat(vm_registers_t &r, vm_t &vm)
	475	{
	476	auto &fp = r.stack.peek_frame()->base<F_Sys_wstat>();
	477	throw vm_system_exception{ "Instruction not implemented" };
	478	}

src/vm/sys/Sysmod.h+464−0

@@ -0,0 +1,464 @@
	1	//
	2	// Dis VM
	3	// File: Sysmod.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_VM_SYS_SYSMOD_H_
	8	#define _DISVM_SRC_VM_SYS_SYSMOD_H_
	9
	10	#include <vector>
	11	#include <disvm.h>
	12	#include <builtin_module.h>
	13
	14	using namespace disvm;
	15	using namespace disvm::runtime;
	16
	17	struct Sys_Qid
	18	{
	19	big_t path;
	20	word_t vers;
	21	word_t qtype;
	22	};
	23	const byte_t Sys_Qid_map[] = { 0 };
	24	struct Sys_Dir
	25	{
	26	/* vm_string_t */ pointer_t name;
	27	/* vm_string_t */ pointer_t uid;
	28	/* vm_string_t */ pointer_t gid;
	29	/* vm_string_t */ pointer_t muid;
	30	Sys_Qid qid;
	31	word_t mode;
	32	word_t atime;
	33	word_t mtime;
	34	byte_t _pad44[4];
	35	big_t length;
	36	word_t dtype;
	37	word_t dev;
	38	};
	39	const byte_t Sys_Dir_map[] = { 0xf0, };
	40	struct Sys_FD
	41	{
	42	word_t fd;
	43	};
	44	const byte_t Sys_FD_map[] = { 0 };
	45	struct Sys_Connection
	46	{
	47	/* Sys_FD */ pointer_t dfd;
	48	/* Sys_FD */ pointer_t cfd;
	49	/* vm_string_t */ pointer_t dir;
	50	};
	51	const byte_t Sys_Connection_map[] = { 0xe0, };
	52	using Sys_Rread = struct { /* vm_array_t / pointer_t t0; / vm_string_t */ pointer_t t1; };
	53	#define Sys_Rread_map {0xc0,}
	54	using Sys_Rwrite = struct { word_t t0; /* vm_string_t */ pointer_t t1; };
	55	#define Sys_Rwrite_map {0x40,}
	56	struct Sys_FileIO
	57	{
	58	/* vm_channel_t */ pointer_t read;
	59	/* vm_channel_t */ pointer_t write;
	60	};
	61	using Sys_FileIO_read = struct { word_t t0; word_t t1; word_t t2; /* vm_channel_t */ pointer_t t3; };
	62	#define Sys_FileIO_read_map {0x10,}
	63	using Sys_FileIO_write = struct { word_t t0; /* vm_array_t / pointer_t t1; word_t t2; / vm_channel_t */ pointer_t t3; };
	64	#define Sys_FileIO_write_map {0x50,}
	65	const byte_t Sys_FileIO_map[] = { 0xc0, };
	66	void Sys_announce(vm_registers_t &r, vm_t &vm);
	67	struct F_Sys_announce : public vm_frame_base_alloc_t
	68	{
	69	struct { word_t t0; Sys_Connection t1; }*ret;
	70	byte_t temps[12];
	71	/* vm_string_t */ pointer_t addr;
	72	};
	73	void Sys_aprint(vm_registers_t &r, vm_t &vm);
	74	struct F_Sys_aprint : public vm_frame_base_alloc_t
	75	{
	76	/* vm_array_t / pointer_t ret;
	77	byte_t temps[12];
	78	/* vm_string_t */ pointer_t s;
	79	byte_t vargs;
	80	};
	81	void Sys_bind(vm_registers_t &r, vm_t &vm);
	82	struct F_Sys_bind : public vm_frame_base_alloc_t
	83	{
	84	word_t* ret;
	85	byte_t temps[12];
	86	/* vm_string_t */ pointer_t s;
	87	/* vm_string_t */ pointer_t on;
	88	word_t flags;
	89	};
	90	void Sys_byte2char(vm_registers_t &r, vm_t &vm);
	91	struct F_Sys_byte2char : public vm_frame_base_alloc_t
	92	{
	93	struct { word_t t0; word_t t1; word_t t2; }*ret;
	94	byte_t temps[12];
	95	/* vm_array_t */ pointer_t buf;
	96	word_t n;
	97	};
	98	void Sys_char2byte(vm_registers_t &r, vm_t &vm);
	99	struct F_Sys_char2byte : public vm_frame_base_alloc_t
	100	{
	101	word_t* ret;
	102	byte_t temps[12];
	103	word_t c;
	104	/* vm_array_t */ pointer_t buf;
	105	word_t n;
	106	};
	107	void Sys_chdir(vm_registers_t &r, vm_t &vm);
	108	struct F_Sys_chdir : public vm_frame_base_alloc_t
	109	{
	110	word_t* ret;
	111	byte_t temps[12];
	112	/* vm_string_t */ pointer_t path;
	113	};
	114	void Sys_create(vm_registers_t &r, vm_t &vm);
	115	struct F_Sys_create : public vm_frame_base_alloc_t
	116	{
	117	/* Sys_FD / pointer_t ret;
	118	byte_t temps[12];
	119	/* vm_string_t */ pointer_t s;
	120	word_t mode;
	121	word_t perm;
	122	};
	123	void Sys_dial(vm_registers_t &r, vm_t &vm);
	124	struct F_Sys_dial : public vm_frame_base_alloc_t
	125	{
	126	struct { word_t t0; Sys_Connection t1; }*ret;
	127	byte_t temps[12];
	128	/* vm_string_t */ pointer_t addr;
	129	/* vm_string_t */ pointer_t local;
	130	};
	131	void Sys_dirread(vm_registers_t &r, vm_t &vm);
	132	struct F_Sys_dirread : public vm_frame_base_alloc_t
	133	{
	134	struct { word_t t0; /* vm_array_t / pointer_t t1; }ret;
	135	byte_t temps[12];
	136	/* Sys_FD */ pointer_t fd;
	137	};
	138	void Sys_dup(vm_registers_t &r, vm_t &vm);
	139	struct F_Sys_dup : public vm_frame_base_alloc_t
	140	{
	141	word_t* ret;
	142	byte_t temps[12];
	143	word_t old;
	144	word_t new_;
	145	};
	146	void Sys_export(vm_registers_t &r, vm_t &vm);
	147	struct F_Sys_export : public vm_frame_base_alloc_t
	148	{
	149	word_t* ret;
	150	byte_t temps[12];
	151	/* Sys_FD */ pointer_t c;
	152	/* vm_string_t */ pointer_t dir;
	153	word_t flag;
	154	};
	155	void Sys_fauth(vm_registers_t &r, vm_t &vm);
	156	struct F_Sys_fauth : public vm_frame_base_alloc_t
	157	{
	158	/* Sys_FD / pointer_t ret;
	159	byte_t temps[12];
	160	/* Sys_FD */ pointer_t fd;
	161	/* vm_string_t */ pointer_t aname;
	162	};
	163	void Sys_fd2path(vm_registers_t &r, vm_t &vm);
	164	struct F_Sys_fd2path : public vm_frame_base_alloc_t
	165	{
	166	/* vm_string_t / pointer_t ret;
	167	byte_t temps[12];
	168	/* Sys_FD */ pointer_t fd;
	169	};
	170	void Sys_fildes(vm_registers_t &r, vm_t &vm);
	171	struct F_Sys_fildes : public vm_frame_base_alloc_t
	172	{
	173	/* Sys_FD / pointer_t ret;
	174	byte_t temps[12];
	175	word_t fd;
	176	};
	177	void Sys_file2chan(vm_registers_t &r, vm_t &vm);
	178	struct F_Sys_file2chan : public vm_frame_base_alloc_t
	179	{
	180	/* Sys_FileIO / pointer_t ret;
	181	byte_t temps[12];
	182	/* vm_string_t */ pointer_t dir;
	183	/* vm_string_t */ pointer_t file;
	184	};
	185	void Sys_fprint(vm_registers_t &r, vm_t &vm);
	186	struct F_Sys_fprint : public vm_frame_base_alloc_t
	187	{
	188	word_t* ret;
	189	byte_t temps[12];
	190	/* Sys_FD */ pointer_t fd;
	191	/* vm_string_t */ pointer_t s;
	192	byte_t vargs;
	193	};
	194	void Sys_fstat(vm_registers_t &r, vm_t &vm);
	195	struct F_Sys_fstat : public vm_frame_base_alloc_t
	196	{
	197	struct { word_t t0; byte_t _pad4[4]; Sys_Dir t1; }*ret;
	198	byte_t temps[12];
	199	/* Sys_FD */ pointer_t fd;
	200	};
	201	void Sys_fversion(vm_registers_t &r, vm_t &vm);
	202	struct F_Sys_fversion : public vm_frame_base_alloc_t
	203	{
	204	struct { word_t t0; /* vm_string_t / pointer_t t1; }ret;
	205	byte_t temps[12];
	206	/* Sys_FD */ pointer_t fd;
	207	word_t msize;
	208	/* vm_string_t */ pointer_t version;
	209	};
	210	void Sys_fwstat(vm_registers_t &r, vm_t &vm);
	211	struct F_Sys_fwstat : public vm_frame_base_alloc_t
	212	{
	213	word_t* ret;
	214	byte_t temps[12];
	215	/* Sys_FD */ pointer_t fd;
	216	byte_t _pad36[4];
	217	Sys_Dir d;
	218	};
	219	void Sys_iounit(vm_registers_t &r, vm_t &vm);
	220	struct F_Sys_iounit : public vm_frame_base_alloc_t
	221	{
	222	word_t* ret;
	223	byte_t temps[12];
	224	/* Sys_FD */ pointer_t fd;
	225	};
	226	void Sys_listen(vm_registers_t &r, vm_t &vm);
	227	struct F_Sys_listen : public vm_frame_base_alloc_t
	228	{
	229	struct { word_t t0; Sys_Connection t1; }*ret;
	230	byte_t temps[12];
	231	Sys_Connection c;
	232	};
	233	void Sys_millisec(vm_registers_t &r, vm_t &vm);
	234	struct F_Sys_millisec : public vm_frame_base_alloc_t
	235	{
	236	word_t* ret;
	237	byte_t temps[12];
	238	};
	239	void Sys_mount(vm_registers_t &r, vm_t &vm);
	240	struct F_Sys_mount : public vm_frame_base_alloc_t
	241	{
	242	word_t* ret;
	243	byte_t temps[12];
	244	/* Sys_FD */ pointer_t fd;
	245	/* Sys_FD */ pointer_t afd;
	246	/* vm_string_t */ pointer_t on;
	247	word_t flags;
	248	/* vm_string_t */ pointer_t spec;
	249	};
	250	void Sys_open(vm_registers_t &r, vm_t &vm);
	251	struct F_Sys_open : public vm_frame_base_alloc_t
	252	{
	253	/* Sys_FD / pointer_t ret;
	254	byte_t temps[12];
	255	/* vm_string_t */ pointer_t s;
	256	word_t mode;
	257	};
	258	void Sys_pctl(vm_registers_t &r, vm_t &vm);
	259	struct F_Sys_pctl : public vm_frame_base_alloc_t
	260	{
	261	word_t* ret;
	262	byte_t temps[12];
	263	word_t flags;
	264	/* vm_list_t */ pointer_t movefd;
	265	};
	266	void Sys_pipe(vm_registers_t &r, vm_t &vm);
	267	struct F_Sys_pipe : public vm_frame_base_alloc_t
	268	{
	269	word_t* ret;
	270	byte_t temps[12];
	271	/* vm_array_t */ pointer_t fds;
	272	};
	273	void Sys_pread(vm_registers_t &r, vm_t &vm);
	274	struct F_Sys_pread : public vm_frame_base_alloc_t
	275	{
	276	word_t* ret;
	277	byte_t temps[12];
	278	/* Sys_FD */ pointer_t fd;
	279	/* vm_array_t */ pointer_t buf;
	280	word_t n;
	281	byte_t _pad44[4];
	282	big_t off;
	283	};
	284	void Sys_print(vm_registers_t &r, vm_t &vm);
	285	struct F_Sys_print : public vm_frame_base_alloc_t
	286	{
	287	word_t* ret;
	288	byte_t temps[12];
	289	/* vm_string_t */ pointer_t s;
	290	byte_t vargs;
	291	};
	292	void Sys_pwrite(vm_registers_t &r, vm_t &vm);
	293	struct F_Sys_pwrite : public vm_frame_base_alloc_t
	294	{
	295	word_t* ret;
	296	byte_t temps[12];
	297	/* Sys_FD */ pointer_t fd;
	298	/* vm_array_t */ pointer_t buf;
	299	word_t n;
	300	byte_t _pad44[4];
	301	big_t off;
	302	};
	303	void Sys_read(vm_registers_t &r, vm_t &vm);
	304	struct F_Sys_read : public vm_frame_base_alloc_t
	305	{
	306	word_t* ret;
	307	byte_t temps[12];
	308	/* Sys_FD */ pointer_t fd;
	309	/* vm_array_t */ pointer_t buf;
	310	word_t n;
	311	};
	312	void Sys_readn(vm_registers_t &r, vm_t &vm);
	313	struct F_Sys_readn : public vm_frame_base_alloc_t
	314	{
	315	word_t* ret;
	316	byte_t temps[12];
	317	/* Sys_FD */ pointer_t fd;
	318	/* vm_array_t */ pointer_t buf;
	319	word_t n;
	320	};
	321	void Sys_remove(vm_registers_t &r, vm_t &vm);
	322	struct F_Sys_remove : public vm_frame_base_alloc_t
	323	{
	324	word_t* ret;
	325	byte_t temps[12];
	326	/* vm_string_t */ pointer_t s;
	327	};
	328	void Sys_seek(vm_registers_t &r, vm_t &vm);
	329	struct F_Sys_seek : public vm_frame_base_alloc_t
	330	{
	331	big_t* ret;
	332	byte_t temps[12];
	333	/* Sys_FD */ pointer_t fd;
	334	byte_t _pad36[4];
	335	big_t off;
	336	word_t start;
	337	};
	338	void Sys_sleep(vm_registers_t &r, vm_t &vm);
	339	struct F_Sys_sleep : public vm_frame_base_alloc_t
	340	{
	341	word_t* ret;
	342	byte_t temps[12];
	343	word_t period;
	344	};
	345	void Sys_sprint(vm_registers_t &r, vm_t &vm);
	346	struct F_Sys_sprint : public vm_frame_base_alloc_t
	347	{
	348	/* vm_string_t / pointer_t ret;
	349	byte_t temps[12];
	350	/* vm_string_t */ pointer_t s;
	351	byte_t vargs;
	352	};
	353	void Sys_stat(vm_registers_t &r, vm_t &vm);
	354	struct F_Sys_stat : public vm_frame_base_alloc_t
	355	{
	356	struct { word_t t0; byte_t _pad4[4]; Sys_Dir t1; }*ret;
	357	byte_t temps[12];
	358	/* vm_string_t */ pointer_t s;
	359	};
	360	void Sys_stream(vm_registers_t &r, vm_t &vm);
	361	struct F_Sys_stream : public vm_frame_base_alloc_t
	362	{
	363	word_t* ret;
	364	byte_t temps[12];
	365	/* Sys_FD */ pointer_t src;
	366	/* Sys_FD */ pointer_t dst;
	367	word_t bufsiz;
	368	};
	369	void Sys_tokenize(vm_registers_t &r, vm_t &vm);
	370	struct F_Sys_tokenize : public vm_frame_base_alloc_t
	371	{
	372	struct { word_t t0; /* vm_list_t / pointer_t t1; }ret;
	373	byte_t temps[12];
	374	/* vm_string_t */ pointer_t s;
	375	/* vm_string_t */ pointer_t delim;
	376	};
	377	void Sys_unmount(vm_registers_t &r, vm_t &vm);
	378	struct F_Sys_unmount : public vm_frame_base_alloc_t
	379	{
	380	word_t* ret;
	381	byte_t temps[12];
	382	/* vm_string_t */ pointer_t s1;
	383	/* vm_string_t */ pointer_t s2;
	384	};
	385	void Sys_utfbytes(vm_registers_t &r, vm_t &vm);
	386	struct F_Sys_utfbytes : public vm_frame_base_alloc_t
	387	{
	388	word_t* ret;
	389	byte_t temps[12];
	390	/* vm_array_t */ pointer_t buf;
	391	word_t n;
	392	};
	393	void Sys_werrstr(vm_registers_t &r, vm_t &vm);
	394	struct F_Sys_werrstr : public vm_frame_base_alloc_t
	395	{
	396	word_t* ret;
	397	byte_t temps[12];
	398	/* vm_string_t */ pointer_t s;
	399	};
	400	void Sys_write(vm_registers_t &r, vm_t &vm);
	401	struct F_Sys_write : public vm_frame_base_alloc_t
	402	{
	403	word_t* ret;
	404	byte_t temps[12];
	405	/* Sys_FD */ pointer_t fd;
	406	/* vm_array_t */ pointer_t buf;
	407	word_t n;
	408	};
	409	void Sys_wstat(vm_registers_t &r, vm_t &vm);
	410	struct F_Sys_wstat : public vm_frame_base_alloc_t
	411	{
	412	word_t* ret;
	413	byte_t temps[12];
	414	/* vm_string_t */ pointer_t s;
	415	byte_t _pad36[4];
	416	Sys_Dir d;
	417	};
	418	const char *Sys_PATH = "$Sys";
	419	const word_t Sys_Maxint = 0x7fffffff;
	420	const word_t Sys_QTDIR = 0x80;
	421	const word_t Sys_QTAPPEND = 0x40;
	422	const word_t Sys_QTEXCL = 0x20;
	423	const word_t Sys_QTAUTH = 0x8;
	424	const word_t Sys_QTTMP = 0x4;
	425	const word_t Sys_QTFILE = 0x0;
	426	const word_t Sys_ATOMICIO = 0x2000;
	427	const word_t Sys_SEEKSTART = 0x0;
	428	const word_t Sys_SEEKRELA = 0x1;
	429	const word_t Sys_SEEKEND = 0x2;
	430	const word_t Sys_NAMEMAX = 0x100;
	431	const word_t Sys_ERRMAX = 0x80;
	432	const word_t Sys_WAITLEN = 0xc0;
	433	const word_t Sys_OREAD = 0x0;
	434	const word_t Sys_OWRITE = 0x1;
	435	const word_t Sys_ORDWR = 0x2;
	436	const word_t Sys_OTRUNC = 0x10;
	437	const word_t Sys_ORCLOSE = 0x40;
	438	const word_t Sys_OEXCL = 0x1000;
	439	const word_t Sys_DMDIR = 0x80000000;
	440	const word_t Sys_DMAPPEND = 0x40000000;
	441	const word_t Sys_DMEXCL = 0x20000000;
	442	const word_t Sys_DMAUTH = 0x8000000;
	443	const word_t Sys_DMTMP = 0x4000000;
	444	const word_t Sys_MREPL = 0x0;
	445	const word_t Sys_MBEFORE = 0x1;
	446	const word_t Sys_MAFTER = 0x2;
	447	const word_t Sys_MCREATE = 0x4;
	448	const word_t Sys_MCACHE = 0x10;
	449	const word_t Sys_NEWFD = 0x1;
	450	const word_t Sys_FORKFD = 0x2;
	451	const word_t Sys_NEWNS = 0x4;
	452	const word_t Sys_FORKNS = 0x8;
	453	const word_t Sys_NEWPGRP = 0x10;
	454	const word_t Sys_NODEVS = 0x20;
	455	const word_t Sys_NEWENV = 0x40;
	456	const word_t Sys_FORKENV = 0x80;
	457	const word_t Sys_EXPWAIT = 0x0;
	458	const word_t Sys_EXPASYNC = 0x1;
	459	const word_t Sys_UTFmax = 0x4;
	460	const word_t Sys_UTFerror = 0xfffd;
	461	const word_t Sys_Runemax = 0x10ffff;
	462	const word_t Sys_Runemask = 0x1fffff;
	463
	464	#endif // _DISVM_SRC_VM_SYS_SYSMOD_H_

src/vm/sys/print.cpp+131−0

@@ -0,0 +1,131 @@
	1	//
	2	// Dis VM
	3	// File: print.cpp
	4	// Author: arr
	5	//
	6
	7	#include <array>
	8	#include <cinttypes>
	9	#include <utf8.h>
	10	#include "sys_utils.h"
	11
	12	using namespace disvm::runtime;
	13	using namespace disvm::runtime::utf8;
	14
	15	// Shamelessly adopted and altered from Inferno implementation (xprint - libinterp/runt.c)
	16	// [TODO] Handle UTF-8
	17	word_t printf_to_buffer(const vm_string_t &msg_fmt, byte_t msg_args, std::size_t buffer_size, char buffer)
	18	{
	19	auto b_curr = buffer;
	20	const auto b_end = buffer + (buffer_size - 1);
	21	const auto fmt_len = msg_fmt.get_length();
	22	auto i = word_t{ 0 };
	23
	24	// Loop over the entire format string
	25	while (i < fmt_len)
	26	{
	27	if (b_curr >= b_end)
	28	return -1;
	29
	30	auto c = msg_fmt.get_rune(i);
	31	++i;
	32	if (c != '%')
	33	{
	34	b_curr = reinterpret_cast<char >(utf8::encode(c, reinterpret_cast<uint8_t >(b_curr)));
	35	continue;
	36	}
	37
	38	auto format = std::vector<char>{};
	39	format.push_back('%');
	40	auto wb = int{ 0 };
	41	auto big_flag = false;
	42
	43	// Decode the format specifier
	44	while (i < fmt_len)
	45	{
	46	c = msg_fmt.get_rune(i);
	47	++i;
	48	switch (c)
	49	{
	50	// Format flags
	51	default:
	52	continue;
	53	case 'b': // Print big type (64-bit)
	54	format.push_back('l');
	55	format.push_back('l');
	56	big_flag = true;
	57	continue;
	58
	59	// Format verbs
	60	case '%': // Escaped specifier
	61	wb = std::snprintf(b_curr, (b_end - b_curr), "%%%%");
	62	break;
	63	case 'o': // octal
	64	case 'd': // decimal
	65	case 'x': // hexidecimal
	66	case 'X': // Upper-case hexidecimal
	67	format.push_back(static_cast<char>(c));
	68	format.push_back('\0');
	69	if (big_flag)
	70	{
	71	const auto b = reinterpret_cast<big_t >(msg_args);
	72	wb = std::snprintf(b_curr, (b_end - b_curr), format.data(), b);
	73	msg_args += sizeof(b);
	74	}
	75	else
	76	{
	77	const auto w = reinterpret_cast<word_t >(msg_args);
	78	wb = std::snprintf(b_curr, (b_end - b_curr), format.data(), w);
	79	msg_args += sizeof(w);
	80	}
	81	break;
	82	case 's': // string
	83	{
	84	auto s = vm_alloc_t::from_allocation<vm_string_t>(reinterpret_cast<pointer_t >(msg_args));
	85	if (s != nullptr)
	86	wb = std::snprintf(b_curr, (b_end - b_curr), "%s", s->str());
	87
	88	msg_args += sizeof(pointer_t);
	89	break;
	90	}
	91	// [SPEC] Undocumented format verb for debugging VM objects.
	92	case 'H':
	93	{
	94	auto alloc = vm_alloc_t::from_allocation(reinterpret_cast<pointer_t >(msg_args));
	95	auto rc = static_cast<std::size_t>(-1);
	96	const void *type_alloc = nullptr;
	97	if (alloc != nullptr)
	98	{
	99	rc = alloc->get_ref_count();
	100	type_alloc = alloc->alloc_type.get();
	101	}
	102
	103	wb = std::snprintf(b_curr, (b_end - b_curr), "%" PRIdPTR ".%#08" PRIxPTR, rc, reinterpret_cast<std::size_t>(type_alloc));
	104	msg_args += sizeof(pointer_t);
	105	break;
	106	}
	107	}
	108
	109	break;
	110	}
	111
	112	if (wb < 0)
	113	return -1;
	114
	115	b_curr += wb;
	116	}
	117
	118	assert(*b_curr == '\0' && "The buffer should be null-terminated");
	119	return (b_curr - buffer);
	120	}
	121
	122	word_t printf_to_dynamic_buffer(const vm_string_t &msg_fmt, byte_t *msg_args, std::vector<char> &buffer)
	123	{
	124	auto result = word_t{ 0 };
	125	while (-1 == (result = printf_to_buffer(msg_fmt, msg_args, buffer.size(), buffer.data())))
	126	{
	127	buffer.resize(buffer.size() * 2);
	128	}
	129
	130	return result;
	131	}

src/vm/sys/sys_utils.h+21−0

@@ -0,0 +1,21 @@
	1	//
	2	// Dis VM
	3	// File: sys_utils.h
	4	// Author: arr
	5	//
	6
	7	#ifndef _DISVM_SRC_VM_SYS_UTILS_H_
	8	#define _DISVM_SRC_VM_SYS_UTILS_H_
	9
	10	#include <vector>
	11	#include <disvm.h>
	12
	13	// Prints the format and arguments to the supplied buffer.
	14	// Returns the number of bytes written.
	15	disvm::runtime::word_t printf_to_buffer(const disvm::runtime::vm_string_t &msg_fmt, disvm::runtime::byte_t msg_args, std::size_t buffer_size, char buffer);
	16
	17	// Prints the format and arguments to the supplied dynamic buffer.
	18	// Returns the number of bytes written.
	19	disvm::runtime::word_t printf_to_dynamic_buffer(const disvm::runtime::vm_string_t &msg_fmt, disvm::runtime::byte_t *msg_args, std::vector<char> &buffer);
	20
	21	#endif // _DISVM_SRC_VM_SYS_UTILS_H_

src/vm/thread.cpp+298−0

@@ -0,0 +1,298 @@
	1	//
	2	// Dis VM
	3	// File: thread.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cinttypes>
	8	#include <cassert>
	9	#include <memory>
	10	#include <atomic>
	11	#include <disvm.h>
	12	#include <exceptions.h>
	13	#include <vm_memory.h>
	14	#include <debug.h>
	15	#include "execution_table.h"
	16
	17	using namespace disvm;
	18	using namespace disvm::runtime;
	19
	20	namespace
	21	{
	22	// Update VM registers based on the instruction.
	23	void decode_address(const vm_exec_op_t &inst, vm_registers_t &reg)
	24	{
	25	switch (inst.source.mode)
	26	{
	27	case address_mode_t::offset_indirect_fp:
	28	reg.src = reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(reg.stack.peek_frame()->base()) + inst.source.register1);
	29	break;
	30	case address_mode_t::offset_indirect_mp:
	31	reg.src = reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(reg.mp_base->allocation()) + inst.source.register1);
	32	break;
	33	case address_mode_t::offset_double_indirect_fp:
	34	{
	35	const auto frame_offset = reinterpret_cast<std::size_t >(reinterpret_cast<uint8_t *>(reg.stack.peek_frame()->base()) + inst.source.register1);
	36	reg.src = reinterpret_cast<pointer_t>(frame_offset + inst.source.register2);
	37	break;
	38	}
	39	case address_mode_t::offset_double_indirect_mp:
	40	{
	41	const auto mp_offset = reinterpret_cast<std::size_t >(reinterpret_cast<uint8_t *>(reg.mp_base->allocation()) + inst.source.register1);
	42	reg.src = reinterpret_cast<pointer_t>(mp_offset + inst.source.register2);
	43	break;
	44	}
	45	case address_mode_t::immediate:
	46	reg.src = reinterpret_cast<pointer_t>(const_cast<word_t *>(&inst.source.register1));
	47	break;
	48	case address_mode_t::none:
	49	reg.src = nullptr;
	50	break;
	51	default:
	52	assert(false && "Unknown source addressing");
	53	}
	54
	55	switch (inst.destination.mode)
	56	{
	57	case address_mode_t::offset_indirect_fp:
	58	reg.dest = reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(reg.stack.peek_frame()->base()) + inst.destination.register1);
	59	break;
	60	case address_mode_t::offset_indirect_mp:
	61	reg.dest = reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(reg.mp_base->allocation()) + inst.destination.register1);
	62	break;
	63	case address_mode_t::offset_double_indirect_fp:
	64	{
	65	const auto frame_offset = reinterpret_cast<std::size_t >(reinterpret_cast<uint8_t *>(reg.stack.peek_frame()->base()) + inst.destination.register1);
	66	reg.dest = reinterpret_cast<pointer_t>(frame_offset + inst.destination.register2);
	67	break;
	68	}
	69	case address_mode_t::offset_double_indirect_mp:
	70	{
	71	const auto mp_offset = reinterpret_cast<std::size_t >(reinterpret_cast<uint8_t *>(reg.mp_base->allocation()) + inst.destination.register1);
	72	reg.dest = reinterpret_cast<pointer_t>(mp_offset + inst.destination.register2);
	73	break;
	74	}
	75	case address_mode_t::immediate:
	76	reg.dest = reinterpret_cast<pointer_t>(const_cast<word_t *>(&inst.destination.register1));
	77	break;
	78	case address_mode_t::none:
	79	reg.dest = nullptr;
	80	break;
	81	default:
	82	assert(false && "Unknown destination addressing");
	83	}
	84
	85	switch (inst.middle.mode)
	86	{
	87	case address_mode_middle_t::small_offset_indirect_fp:
	88	reg.mid = reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(reg.stack.peek_frame()->base()) + inst.middle.register1);
	89	break;
	90	case address_mode_middle_t::small_offset_indirect_mp:
	91	reg.mid = reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(reg.mp_base->allocation()) + inst.middle.register1);
	92	break;
	93	case address_mode_middle_t::small_immediate:
	94	reg.mid = reinterpret_cast<pointer_t>(const_cast<word_t *>(&inst.middle.register1));
	95	break;
	96	case address_mode_middle_t::none:
	97	// [SPEC] This is an undocumented expectation but required in many operations (e.g. i++).
	98	reg.mid = reg.dest;
	99	break;
	100	default:
	101	assert(false && "Unknown middle addressing");
	102	}
	103
	104	#ifndef NDEBUG
	105	// This is a perf critical function so logging is only available in debug builds
	106	if (debug::is_component_tracing_enabled<debug::component_trace_t::addressing>())
	107	{
	108	debug::log_msg(
	109	debug::component_trace_t::addressing,
	110	debug::log_level_t::debug,
	111	"decode: registers: %d (%#" PRIxPTR " %#" PRIxPTR " %#" PRIxPTR ")\n",
	112	inst.opcode,
	113	reg.src,
	114	reg.mid,
	115	reg.dest);
	116	}
	117	#endif
	118	}
	119
	120	std::atomic<uint32_t> thread_id_counter(1);
	121
	122	uint32_t get_unique_thread_id()
	123	{
	124	return thread_id_counter.fetch_add(1);
	125	}
	126	}
	127
	128	vm_registers_t::vm_registers_t(
	129	const vm_thread_t &thread,
	130	vm_module_ref_t &entry)
	131	: current_thread_state{ vm_thread_state_t::ready }
	132	, module_ref{ &entry }
	133	, mp_base{ entry.mp_base }
	134	, thread{ thread }
	135	, pc{ entry.module->header.entry_pc }
	136	, stack{ entry.module->header.stack_extent }
	137	, src{ nullptr }
	138	, mid{ nullptr }
	139	, dest{ nullptr }
	140	{
	141	// Add a reference to the module ref and MP register
	142	if (mp_base != nullptr)
	143	mp_base->add_ref();
	144
	145	module_ref->add_ref();
	146	}
	147
	148	vm_registers_t::~vm_registers_t()
	149	{
	150	dec_ref_count_and_free(mp_base);
	151	debug::assign_debug_pointer(&mp_base);
	152
	153	dec_ref_count_and_free(module_ref);
	154	debug::assign_debug_pointer(&module_ref);
	155	}
	156
	157	std::shared_ptr<const type_descriptor_t> vm_thread_t::type_desc()
	158	{
	159	return intrinsic_type_desc::type<vm_thread_t>();
	160	}
	161
	162	vm_thread_t::vm_thread_t(
	163	vm_module_ref_t &entry,
	164	uint32_t parent_thread_id)
	165	: vm_alloc_t(vm_thread_t::type_desc())
	166	, _parent_thread_id{ parent_thread_id }
	167	, _registers{ *this, entry }
	168	, _thread_id{ get_unique_thread_id() }
	169	{
	170	assert(_parent_thread_id != _thread_id);
	171	assert(static_cast<std::size_t>(_registers.pc) < entry.code_section.size());
	172
	173	// Set up the stack
	174	const auto entry_type = entry.module->header.entry_type;
	175	auto frame_type = entry.type_section[entry_type];
	176	_registers.stack.alloc_frame(frame_type);
	177
	178	// Pushing the initial frame sets the FP register
	179	_registers.stack.push_frame();
	180
	181	debug::log_msg(debug::component_trace_t::thread, debug::log_level_t::debug, "init: vm thread: %d %d\n", _thread_id, _parent_thread_id);
	182	}
	183
	184	vm_thread_t::vm_thread_t(
	185	vm_module_ref_t &entry,
	186	const vm_frame_t &initial_frame,
	187	vm_pc_t start_pc,
	188	uint32_t parent_thread_id)
	189	: vm_alloc_t(vm_thread_t::type_desc())
	190	, _parent_thread_id{ parent_thread_id }
	191	, _registers{ *this, entry }
	192	, _thread_id{ get_unique_thread_id() }
	193	{
	194	_registers.pc = start_pc;
	195
	196	assert(_parent_thread_id != _thread_id);
	197	assert(static_cast<std::size_t>(_registers.pc) < entry.code_section.size());
	198
	199	// Set the stack
	200	auto frame_type = initial_frame.frame_type;
	201	_registers.stack.alloc_frame(frame_type);
	202
	203	// Pushing the initial frame sets the FP register
	204	auto current_frame = _registers.stack.push_frame();
	205
	206	// Copy over the frame into this thread - pass arguments to the thread
	207	current_frame->copy_frame_contents(initial_frame);
	208
	209	debug::log_msg(debug::component_trace_t::thread, debug::log_level_t::debug, "init: vm thread: %d %d\n", _thread_id, _parent_thread_id);
	210	}
	211
	212	vm_thread_t::~vm_thread_t()
	213	{
	214	debug::log_msg(debug::component_trace_t::thread, debug::log_level_t::debug, "destroy: vm thread: %d %d\n", _thread_id, _parent_thread_id);
	215	}
	216
	217	vm_thread_state_t vm_thread_t::execute(vm_t &virtual_machine, uint32_t quanta)
	218	{
	219	_registers.current_thread_state = vm_thread_state_t::running;
	220	assert(_registers.pc != runtime_constants::invalid_program_counter);
	221
	222	auto execution_duration = uint32_t{ 0 };
	223
	224	try
	225	{
	226	for (; execution_duration < quanta; ++execution_duration)
	227	{
	228	if (_registers.stack.peek_frame() == nullptr)
	229	{
	230	debug::log_msg(debug::component_trace_t::thread, debug::log_level_t::debug, "exit: vm thread: stack exhausted: %d\n", _thread_id);
	231	_registers.current_thread_state = vm_thread_state_t::empty_stack;
	232	break;
	233	}
	234
	235	const auto &code_section = _registers.module_ref->code_section;
	236	assert(static_cast<std::size_t>(_registers.pc) < code_section.size());
	237
	238	const auto &inst = code_section[_registers.pc].op;
	239	decode_address(inst, _registers);
	240	_registers.pc++;
	241	vm_exec_table[static_cast<std::size_t>(inst.opcode)](_registers, virtual_machine);
	242
	243	if (_registers.current_thread_state != vm_thread_state_t::running)
	244	break;
	245	}
	246	}
	247	catch (const unhandled_user_exception &uue)
	248	{
	249	// [TODO] Store the exception
	250	debug::log_msg(debug::component_trace_t::thread, debug::log_level_t::debug, "broken: vm thread: unhandled: >>%s<< %d >>%s<<\n", uue.exception_id, uue.program_counter, uue.module_name);
	251	_registers.current_thread_state = vm_thread_state_t::broken;
	252	}
	253	catch (const vm_user_exception &ue)
	254	{
	255	// [TODO] Store the exception
	256	debug::log_msg(debug::component_trace_t::thread, debug::log_level_t::debug, "broken: vm thread: >>%s<<\n", ue.what());
	257	_registers.current_thread_state = vm_thread_state_t::broken;
	258	}
	259
	260	// Log the execution result
	261	if (debug::is_component_tracing_enabled<debug::component_trace_t::thread>())
	262	{
	263	debug::log_msg(
	264	debug::component_trace_t::thread,
	265	debug::log_level_t::debug,
	266	"status: vm thread: execute: %d %d %d %d\n",
	267	_thread_id,
	268	execution_duration,
	269	quanta,
	270	_registers.current_thread_state);
	271	}
	272
	273	// If the thread is still in the running state transition it back to ready.
	274	if (_registers.current_thread_state == vm_thread_state_t::running)
	275	_registers.current_thread_state = vm_thread_state_t::ready;
	276
	277	return _registers.current_thread_state;
	278	}
	279
	280	vm_thread_state_t vm_thread_t::get_state() const
	281	{
	282	return _registers.current_thread_state;
	283	}
	284
	285	uint32_t vm_thread_t::get_thread_id() const
	286	{
	287	return _thread_id;
	288	}
	289
	290	uint32_t vm_thread_t::get_parent_thread_id() const
	291	{
	292	return _parent_thread_id;
	293	}
	294
	295	const vm_registers_t& vm_thread_t::get_registers() const
	296	{
	297	return _registers;
	298	}

src/vm/utf8.cpp+136−0

@@ -0,0 +1,136 @@
	1	//
	2	// Dis VM
	3	// File: utf8.cpp
	4	// Author: arr
	5	//
	6
	7	// Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de>
	8	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
	9	// Most code in this file falls under the above copyright. It was augmented only to be more C++ friendly.
	10
	11	#include <cinttypes>
	12	#include <utf8.h>
	13	#include <exceptions.h>
	14
	15	using namespace disvm::runtime;
	16
	17	namespace
	18	{
	19	const uint8_t utf8d[] =
	20	{
	21	// The first part of the table maps bytes to character classes that
	22	// to reduce the size of the transition table and create bitmasks.
	23	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	24	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	25	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	26	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	27	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
	28	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
	29	8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	30	10, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 11, 6, 6, 6, 5, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
	31
	32	// The second part is a transition table that maps a combination
	33	// of a state of the automaton and a character class to a state.
	34	0, 12, 24, 36, 60, 96, 84, 12, 12, 12, 48, 72, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
	35	12, 0, 12, 12, 12, 12, 12, 0, 12, 0, 12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 24, 12, 12,
	36	12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12,
	37	12, 12, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12,
	38	12, 36, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
	39	};
	40	}
	41
	42	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
	43	utf8::decode_state disvm::runtime::utf8::decode_step(utf8::decode_state &state, rune_t &codepoint, uint8_t byte)
	44	{
	45	auto type = uint32_t{ utf8d[byte] };
	46
	47	codepoint = (state != utf8::decode_state::accept) ?
	48	(byte & 0x3fu) \| (codepoint << 6) :
	49	(0xff >> type) & (byte);
	50
	51	state = static_cast<utf8::decode_state>(utf8d[256 + static_cast<uint32_t>(state) + type]);
	52	return state;
	53	}
	54
	55	// Adopted from 'countCodePoints(uint8_t* s, size_t* count)'
	56	// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
	57	std::size_t disvm::runtime::utf8::count_codepoints(const uint8_t *str, const std::size_t max_len)
	58	{
	59	assert(str != nullptr);
	60	auto single_character = rune_t{};
	61	auto points = std::size_t{ 0 };
	62	auto state = utf8::decode_state::accept;
	63
	64	for (auto i = std::size_t{ 0 }; i < max_len; ++i)
	65	{
	66	if (utf8::decode_state::accept == utf8::decode_step(state, single_character, str[i]))
	67	points++;
	68	}
	69
	70	if (state != utf8::decode_state::accept)
	71	throw invalid_utf8{};
	72
	73	return points;
	74	}
	75
	76	std::size_t disvm::runtime::utf8::decode(const uint8_t *str, rune_t &codepoint)
	77	{
	78	assert(str != nullptr);
	79	auto state = utf8::decode_state::accept;
	80
	81	codepoint = 0;
	82	auto begin = str;
	83	auto curr = str;
	84	auto c = uint8_t{};
	85	while (0 != (c = *curr))
	86	{
	87	curr++;
	88	state = utf8::decode_step(state, codepoint, c);
	89	if (state == utf8::decode_state::accept)
	90	return (curr - begin);
	91	}
	92
	93	// Empty string
	94	if (begin == curr)
	95	return 0;
	96
	97	throw invalid_utf8{};
	98	}
	99
	100	uint8_t disvm::runtime::utf8::encode(const rune_t rune, uint8_t str)
	101	{
	102	assert(str != nullptr);
	103	if (rune <= utf8::constants::max_codepoint_ascii)
	104	{
	105	// Layout: 0xxxxxxx
	106	str[0] = static_cast<uint8_t>(rune);
	107	return (str + 1);
	108	}
	109	else if (rune <= utf8::constants::max_codepoint_2_byte)
	110	{
	111	// Layout: 110xxxxx 10xxxxxx
	112	str[0] = static_cast<uint8_t>(0xc0 + (rune >> 6));
	113	str[1] = static_cast<uint8_t>(0x80 + (rune & utf8::constants::multi_byte_value_mask));
	114	return (str + 2);
	115	}
	116	else if (rune <= utf8::constants::max_codepoint_3_byte)
	117	{
	118	// Layout: 1110xxxx 10xxxxxx 10xxxxxx
	119	str[0] = static_cast<uint8_t>(0xe0 + (rune >> 12));
	120	str[1] = static_cast<uint8_t>(0x80 + ((rune >> 6) & utf8::constants::multi_byte_value_mask));
	121	str[2] = static_cast<uint8_t>(0x80 + (rune & utf8::constants::multi_byte_value_mask));
	122	return (str + 3);
	123	}
	124	else if (rune <= utf8::constants::max_codepoint_4_byte)
	125	{
	126	// Layout: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
	127	str[0] = static_cast<uint8_t>(0xf0 + (rune >> 18));
	128	str[1] = static_cast<uint8_t>(0x80 + ((rune >> 12) & utf8::constants::multi_byte_value_mask));
	129	str[2] = static_cast<uint8_t>(0x80 + ((rune >> 6) & utf8::constants::multi_byte_value_mask));
	130	str[3] = static_cast<uint8_t>(0x80 + (rune & utf8::constants::multi_byte_value_mask));
	131	return (str + 4);
	132	}
	133
	134	assert(false && "Unsupported UTF-8 character");
	135	return nullptr;
	136	}

src/vm/vm.cpp+197−0

@@ -0,0 +1,197 @@
	1	//
	2	// Dis VM
	3	// File: vm.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cassert>
	8	#include <memory>
	9	#include <algorithm>
	10	#include <disvm.h>
	11	#include <debug.h>
	12	#include <runtime.h>
	13	#include <exceptions.h>
	14	#include <builtin_module.h>
	15	#include "scheduler.h"
	16	#include "garbage_collector.h"
	17
	18	using namespace disvm;
	19	using namespace disvm::runtime;
	20
	21	vm_t::loaded_module_t::loaded_module_t(std::unique_ptr<runtime::vm_string_t> origin, std::shared_ptr<const runtime::vm_module_t> module)
	22	: origin{ std::move(origin) }
	23	, module{ module }
	24	{
	25	assert(this->origin != nullptr);
	26	}
	27
	28	vm_t::loaded_module_t::loaded_module_t(loaded_module_t &&other)
	29	: origin{ std::move(other.origin) }
	30	, module{ std::move(other.module) }
	31	{
	32	}
	33
	34	vm_t::loaded_module_t::~loaded_module_t()
	35	{
	36	if (origin != nullptr)
	37	origin->release();
	38	}
	39
	40	vm_t::vm_t(
	41	create_vm_interface_callback_t<runtime::vm_scheduler_t> create_scheduler,
	42	create_vm_interface_callback_t<runtime::vm_garbage_collector_t> create_gc)
	43	{
	44	// Initialize intrinsic type descriptors
	45	intrinsic_type_desc::initialize();
	46
	47	// Initialize built-in modules.
	48	builtin::initialize_builtin_modules();
	49
	50	if (create_gc == nullptr)
	51	_gc = std::make_unique<default_garbage_collector_t>(*this);
	52	else
	53	_gc = create_gc(*this);
	54
	55	if (create_scheduler == nullptr)
	56	{
	57	const auto system_thread_count = uint32_t{ 1 };
	58
	59	// The Inferno implementation defined the thread quanta as 2048 (include/interp.h)
	60	const auto thread_quanta = uint32_t{ 2048 };
	61
	62	_scheduler = std::make_unique<default_scheduler_t>(*this, system_thread_count, thread_quanta);
	63	}
	64	else
	65	{
	66	_scheduler = create_scheduler(*this);
	67	}
	68	}
	69
	70	vm_t::vm_t(uint32_t system_thread_count, uint32_t thread_quanta)
	71	{
	72	// Initialize intrinsic type descriptors
	73	runtime::intrinsic_type_desc::initialize();
	74
	75	// Initialize built-in modules.
	76	builtin::initialize_builtin_modules();
	77
	78	_gc = std::make_unique<default_garbage_collector_t>(*this);
	79	_scheduler = std::make_unique<default_scheduler_t>(*this, system_thread_count, thread_quanta);
	80	}
	81
	82	vm_t::~vm_t()
	83	{
	84	// Release the scheduler first since it could be using the gc instance.
	85	_scheduler.reset();
	86	_gc.reset();
	87	}
	88
	89	namespace
	90	{
	91	const runtime::vm_thread_t& _exec(runtime::vm_scheduler_t &s, std::unique_ptr<runtime::vm_module_ref_t> &entry_module_ref)
	92	{
	93	auto thread = std::make_unique<vm_thread_t>(*entry_module_ref, vm_t::root_vm_thread_id);
	94
	95	// Now that the thread has been created and has inherited ownership of the pointer, relinquish the smart pointer's ownership.
	96	entry_module_ref->release(); // decrement the vm alloc ref count
	97	entry_module_ref.release(); // release the smart pointer
	98
	99	return s.schedule_thread(std::move(thread));
	100	}
	101	}
	102
	103	const runtime::vm_thread_t& vm_t::exec(const char *path)
	104	{
	105	assert(path != nullptr);
	106	auto entry_module = load_module(path);
	107
	108	auto entry_module_ref = std::make_unique<vm_module_ref_t>(entry_module);
	109	return _exec(*_scheduler, entry_module_ref);
	110	}
	111
	112	const runtime::vm_thread_t& vm_t::exec(std::unique_ptr<runtime::vm_module_t> entry_module)
	113	{
	114	assert(entry_module != nullptr);
	115
	116	auto entry_module_ref = std::make_unique<vm_module_ref_t>(std::move(entry_module));
	117	return _exec(*_scheduler, entry_module_ref);
	118	}
	119
	120	const runtime::vm_thread_t& vm_t::fork(
	121	const runtime::vm_thread_t &parent,
	122	runtime::vm_module_ref_t &module_ref,
	123	const runtime::vm_frame_t &initial_frame,
	124	runtime::vm_pc_t initial_pc)
	125	{
	126	if (initial_pc < 0 \|\| static_cast<vm_pc_t>(module_ref.code_section.size()) <= initial_pc)
	127	throw vm_system_exception{ "Invalid entry program counter" };
	128
	129	auto thread = std::make_unique<vm_thread_t>(module_ref, initial_frame, initial_pc, parent.get_thread_id());
	130	return _scheduler->schedule_thread(std::move(thread));
	131	}
	132
	133	std::shared_ptr<const runtime::vm_module_t> vm_t::load_module(const char *path)
	134	{
	135	if (path == nullptr)
	136	throw vm_user_exception{ "Invalid module path" };
	137
	138	std::lock_guard<std::mutex> lock{ _modules_lock };
	139
	140	// Check if the module is already loaded.
	141	auto iter = std::begin(_modules);
	142	while (iter != std::end(_modules))
	143	{
	144	if (0 == ::strcmp(iter->origin->str(), path))
	145	{
	146	auto module = iter->module.lock();
	147
	148	// If an entry exists but is null, the module was loaded before. Read the module again and return.
	149	if (module == nullptr)
	150	{
	151	module = std::shared_ptr<vm_module_t>{ std::move(read_module(path)) };
	152	iter->module = module;
	153
	154	debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "reload: vm module: >>%s<<\n", path);
	155	}
	156
	157	return module;
	158	}
	159
	160	++iter;
	161	}
	162
	163	auto new_module = std::shared_ptr<vm_module_t>{};
	164	if (path[0] == BUILTIN_MODULE_PREFIX_CHAR)
	165	{
	166	new_module = std::move(builtin::get_builtin_module(path));
	167	}
	168	else
	169	{
	170	// Read in the module
	171	new_module = std::move(read_module(path));
	172	}
	173
	174	auto path_local = std::make_unique<vm_string_t>(std::strlen(path), reinterpret_cast<const uint8_t *>(path));
	175	_modules.push_front(std::move(loaded_module_t{ std::move(path_local), new_module }));
	176
	177	debug::log_msg(debug::component_trace_t::module, debug::log_level_t::debug, "load: vm module: >>%s<<\n", path);
	178
	179	return new_module;
	180	}
	181
	182	runtime::vm_scheduler_control_t &vm_t::get_scheduler_control() const
	183	{
	184	return _scheduler->get_controller();
	185	}
	186
	187	runtime::vm_garbage_collector_t &vm_t::get_garbage_collector() const
	188	{
	189	return *_gc;
	190	}
	191
	192	void vm_t::spin_sleep_till_idle(std::chrono::milliseconds sleep_interval) const
	193	{
	194	do
	195	std::this_thread::sleep_for(sleep_interval);
	196	while (!_scheduler->is_idle());
	197	}

src/vm/vm_exception_handler.cpp+71−0

@@ -0,0 +1,71 @@
	1	//
	2	// Dis VM
	3	// File: vm_exception_handler.cpp
	4	// Author: arr
	5	//
	6
	7	#include <cstdint>
	8	#include <runtime.h>
	9	#include <vm_memory.h>
	10	#include <exceptions.h>
	11	#include <debug.h>
	12
	13	using namespace disvm;
	14	using namespace disvm::runtime;
	15
	16	std::tuple<const handler_t , vm_frame_t , vm_pc_t> disvm::runtime::find_exception_handler(
	17	const vm_stack_t &stack,
	18	const vm_module_ref_t &faulting_module,
	19	const vm_pc_t faulting_pc,
	20	const vm_string_t &exception_id)
	21	{
	22	auto unwind_depth = uint32_t{ 0 };
	23	auto current_module = &faulting_module;
	24	auto current_pc = faulting_pc;
	25	auto current_frame = stack.peek_frame();
	26
	27	while (current_frame != nullptr)
	28	{
	29	debug::log_msg(debug::component_trace_t::exception, debug::log_level_t::debug, "begin: handler: %d\n", unwind_depth);
	30
	31	auto &handler_section = current_module->module->handler_section;
	32
	33	for (auto &handler : handler_section)
	34	{
	35	// Outside pc range of this handler
	36	if (current_pc < handler.begin_pc \|\| handler.end_pc <= current_pc)
	37	continue;
	38
	39	// Find the appropriate exception case
	40	for (const auto &exception : handler.exception_table)
	41	{
	42	auto exception_name = exception.name.get();
	43	if (exception_id.compare_to(exception_name) == 0)
	44	{
	45	debug::log_msg(debug::component_trace_t::exception, debug::log_level_t::debug, "end: handler: match: %d\n", unwind_depth);
	46	return std::tuple<const handler_t , vm_frame_t , std::size_t>{ &handler, current_frame, exception.pc };
	47	}
	48	else if (exception_name == nullptr && exception.pc != runtime_constants::invalid_program_counter)
	49	{
	50	debug::log_msg(debug::component_trace_t::exception, debug::log_level_t::debug, "end: handler: fallback: %d\n", unwind_depth);
	51	return std::tuple<const handler_t , vm_frame_t , std::size_t>{ &handler, current_frame, exception.pc };
	52	}
	53	}
	54	}
	55
	56	// Decrement the frame program counter. See raise instruction for details.
	57	current_pc = static_cast<word_t>(current_frame->prev_pc() - 1);
	58
	59	// Update the current module if it changes walking up the stack.
	60	auto prev_mod_ref = current_frame->prev_module_ref();
	61	if (prev_mod_ref != nullptr)
	62	current_module = prev_mod_ref;
	63
	64	// Move up the stack.
	65	current_frame = current_frame->prev_frame();
	66	++unwind_depth;
	67	}
	68
	69	auto faulting_module_name = faulting_module.module->module_name->str();
	70	throw unhandled_user_exception{ exception_id.str(), faulting_module_name, faulting_pc };
	71	}

src/vm/vm_memory.cpp+471−0

@@ -0,0 +1,471 @@
	1	//
	2	// Dis VM
	3	// File: vm_memory.cpp
	4	// Author: arr
	5	//
	6
	7	#include <memory>
	8	#include <atomic>
	9	#include <bitset>
	10	#include <mutex>
	11	#include <condition_variable>
	12	#include <cinttypes>
	13	#include <vm_memory.h>
	14	#include <debug.h>
	15	#include <exceptions.h>
	16
	17	using namespace disvm;
	18	using namespace disvm::runtime;
	19
	20	namespace
	21	{
	22	std::mutex global_lock;
	23	std::condition_variable release_lock;
	24
	25	enum class lock_state_t
	26	{
	27	none,
	28	pending,
	29	active
	30	};
	31
	32	std::atomic<uint32_t> allocating_thread_count;
	33	std::atomic<lock_state_t> lock_state;
	34
	35	struct safe_alloc final
	36	{
	37	safe_alloc()
	38	{
	39	allocating_thread_count++;
	40	if (lock_state != lock_state_t::none)
	41	{
	42	allocating_thread_count--;
	43
	44	std::unique_lock<std::mutex> lock{ global_lock };
	45	release_lock.wait(lock, [&]{ return lock_state == lock_state_t::none; });
	46
	47	allocating_thread_count++;
	48	}
	49	}
	50
	51	~safe_alloc()
	52	{
	53	assert(allocating_thread_count > 0);
	54	allocating_thread_count--;
	55	}
	56	};
	57	}
	58
	59	global_alloc_lock_t::global_alloc_lock_t(bool owner)
	60	: _owner{ owner }
	61	{ }
	62
	63	global_alloc_lock_t::global_alloc_lock_t(global_alloc_lock_t &&other)
	64	: _owner{ other._owner }
	65	{
	66	other._owner = false;
	67	}
	68
	69	global_alloc_lock_t::~global_alloc_lock_t()
	70	{
	71	if (_owner)
	72	{
	73	lock_state = lock_state_t::none;
	74	release_lock.notify_all();
	75	}
	76	}
	77
	78	// Lock all allocations on the VM heap.
	79	global_alloc_lock_t disvm::runtime::get_global_alloc_lock()
	80	{
	81	auto expected = lock_state_t::none;
	82
	83	// Block while trying to get lock
	84	while (!lock_state.compare_exchange_strong(expected, lock_state_t::pending))
	85	{
	86	std::unique_lock<std::mutex> lock{ global_lock };
	87	release_lock.wait(lock);
	88	}
	89
	90	while (allocating_thread_count != 0)
	91	{
	92	// Spin-wait for all allocating threads to stop
	93	}
	94
	95	// Transition to active lock state
	96	lock_state = lock_state_t::active;
	97
	98	return{ true };
	99	}
	100
	101	void *disvm::runtime::alloc_memory(std::size_t amount_in_bytes)
	102	{
	103	safe_alloc s;
	104
	105	auto memory = std::malloc(amount_in_bytes);
	106	if (memory == nullptr)
	107	throw vm_system_exception{ "Out of memory" };
	108
	109	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	110	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "alloc: %#" PRIxPTR " %d\n", memory, amount_in_bytes);
	111
	112	return memory;
	113	}
	114
	115	void *disvm::runtime::calloc_memory(std::size_t amount_in_bytes)
	116	{
	117	safe_alloc s;
	118
	119	auto memory = std::calloc(amount_in_bytes, sizeof(uint8_t));
	120	if (memory == nullptr)
	121	throw vm_system_exception{ "Out of memory" };
	122
	123	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	124	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "alloc: zeroed: %#" PRIxPTR " %d\n", memory, amount_in_bytes);
	125
	126	return memory;
	127	}
	128
	129	void disvm::runtime::free_memory(void *memory)
	130	{
	131	if (memory == nullptr)
	132	return;
	133
	134	if (debug::is_component_tracing_enabled<debug::component_trace_t::memory>())
	135	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "free: %#" PRIxPTR "\n", memory);
	136
	137	std::free(memory);
	138	}
	139
	140	void disvm::runtime::init_memory(const type_descriptor_t &type_desc, void *data)
	141	{
	142	assert(data != nullptr);
	143	auto memory_word_len = std::size_t{ type_desc.size_in_bytes / sizeof(word_t) };
	144	if (memory_word_len == 0)
	145	return;
	146
	147	debug::assign_debug_memory(data, type_desc.size_in_bytes);
	148
	149	auto memory = reinterpret_cast<word_t *>(data);
	150	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.
	151	for (auto i = word_t{ 0 }; i < type_desc.map_in_bytes; ++i, memory += 8)
	152	{
	153	const auto words8 = type_desc.pointer_map[i];
	154	if (words8 != 0)
	155	{
	156	auto flags = std::bitset<sizeof(words8) * 8>{ words8 };
	157
	158	// Enumerating the flags in reverse order so memory access is linear.
	159	if (flags[7]) memory[0] = runtime_constants::nil;
	160	if (flags[6]) memory[1] = runtime_constants::nil;
	161	if (flags[5]) memory[2] = runtime_constants::nil;
	162	if (flags[4]) memory[3] = runtime_constants::nil;
	163	if (flags[3]) memory[4] = runtime_constants::nil;
	164	if (flags[2]) memory[5] = runtime_constants::nil;
	165	if (flags[1]) memory[6] = runtime_constants::nil;
	166	if (flags[0]) memory[7] = runtime_constants::nil;
	167	}
	168	}
	169	}
	170
	171	namespace
	172	{
	173	void dec_ref_and_free_pointer_field(pointer_t pointer_field)
	174	{
	175	assert(pointer_field != nullptr);
	176	dec_ref_count_and_free(vm_alloc_t::from_allocation(pointer_field));
	177	}
	178
	179	void add_ref_pointer_field(pointer_t pointer_field)
	180	{
	181	assert(pointer_field != nullptr);
	182	vm_alloc_t::from_allocation(pointer_field)->add_ref();
	183	}
	184	}
	185
	186	void disvm::runtime::destroy_memory(const type_descriptor_t &type_desc, void *data)
	187	{
	188	enum_pointer_fields(type_desc, data, dec_ref_and_free_pointer_field);
	189
	190	debug::assign_debug_memory(data, type_desc.size_in_bytes);
	191	}
	192
	193	void disvm::runtime::inc_ref_count_in_memory(const type_descriptor_t &type_desc, void *data)
	194	{
	195	if (data == nullptr)
	196	return;
	197
	198	enum_pointer_fields(type_desc, data, add_ref_pointer_field);
	199	}
	200
	201	void disvm::runtime::dec_ref_count_and_free(vm_alloc_t *alloc)
	202	{
	203	if (alloc == nullptr)
	204	return;
	205
	206	auto current_ref = alloc->release();
	207	if (current_ref == 0)
	208	delete alloc;
	209	}
	210
	211	const zero_memory_t vm_alloc_t::zero_memory = {};
	212
	213	void *vm_alloc_t::operator new(std::size_t sz)
	214	{
	215	return alloc_memory(sz);
	216	}
	217
	218	void vm_alloc_t::operator delete(void *ptr)
	219	{
	220	free_memory(ptr);
	221	}
	222
	223	vm_alloc_t *vm_alloc_t::allocate(std::shared_ptr<const type_descriptor_t> td)
	224	{
	225	assert(td != nullptr);
	226	if (td->size_in_bytes <= 0)
	227	throw vm_system_exception{ "Invalid dynamic memory allocation size" };
	228
	229	auto mem = alloc_memory(sizeof(vm_alloc_t) + td->size_in_bytes);
	230	auto alloc = ::new(mem)vm_alloc_t{ td };
	231
	232	// Initialize pointer types
	233	init_memory(*td, alloc->allocation());
	234
	235	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: vm alloc: %d\n", td->size_in_bytes);
	236	return alloc;
	237	}
	238
	239	vm_alloc_t *vm_alloc_t::allocate(std::shared_ptr<const type_descriptor_t> td, const zero_memory_t &)
	240	{
	241	assert(td != nullptr);
	242	if (td->size_in_bytes <= 0)
	243	throw vm_system_exception{ "Invalid dynamic memory allocation size" };
	244
	245	// No need to initialize memory since it is already zeroed out.
	246	auto mem = calloc_memory(sizeof(vm_alloc_t) + td->size_in_bytes);
	247	auto alloc = ::new(mem)vm_alloc_t{ td };
	248
	249	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "initz: vm alloc: %d\n", td->size_in_bytes);
	250	return alloc;
	251	}
	252
	253	vm_alloc_t *vm_alloc_t::copy(const vm_alloc_t &other)
	254	{
	255	auto alloc_copy = vm_alloc_t::allocate(other.alloc_type);
	256
	257	// Copy the current memory contents of the allocation
	258	std::memcpy(alloc_copy->allocation(), other.allocation(), alloc_copy->alloc_type->size_in_bytes);
	259
	260	// Ref count all dynamic allocations
	261	inc_ref_count_in_memory(*alloc_copy->alloc_type, alloc_copy->allocation());
	262
	263	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "copy: vm alloc: %#" PRIxPTR " %#" PRIxPTR "\n", &other, alloc_copy);
	264	return alloc_copy;
	265	}
	266
	267	vm_alloc_t *vm_alloc_t::from_allocation(pointer_t allocation)
	268	{
	269	if (allocation == nullptr)
	270	return nullptr;
	271
	272	return reinterpret_cast<vm_alloc_t >(reinterpret_cast<uint8_t >(allocation) - sizeof(vm_alloc_t));
	273	}
	274
	275	vm_alloc_t::vm_alloc_t(std::shared_ptr<const type_descriptor_t> td)
	276	: alloc_type{ td }
	277	, gc_reserved{ nullptr }
	278	, _ref_count{ 1 }
	279	{
	280	assert(alloc_type != nullptr);
	281	}
	282
	283	vm_alloc_t::~vm_alloc_t()
	284	{
	285	assert(_ref_count == 0);
	286
	287	auto finalizer = alloc_type->finalizer;
	288	if (finalizer != type_descriptor_t::no_finalizer)
	289	finalizer(this);
	290
	291	// Free pointer types
	292	destroy_memory(*alloc_type, allocation());
	293	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: vm alloc\n");
	294	}
	295
	296	std::size_t vm_alloc_t::add_ref()
	297	{
	298	assert(_ref_count > 0);
	299
	300	auto prev_value = _ref_count.fetch_add(1, std::memory_order::memory_order_relaxed);
	301	return (prev_value + 1);
	302	}
	303
	304	std::size_t vm_alloc_t::release()
	305	{
	306	assert(_ref_count > 0);
	307
	308	auto prev_value = _ref_count.fetch_sub(1, std::memory_order::memory_order_relaxed);
	309	return (prev_value - 1);
	310	}
	311
	312	std::size_t vm_alloc_t::get_ref_count() const
	313	{
	314	return _ref_count;
	315	}
	316
	317	pointer_t vm_alloc_t::allocation() const
	318	{
	319	// Remove const on the this pointer so the offset can be computed.
	320	auto non_const_this = const_cast<vm_alloc_t *>(this);
	321	return reinterpret_cast<pointer_t>(reinterpret_cast<uint8_t *>(non_const_this)+sizeof(vm_alloc_t));
	322	}
	323
	324	namespace
	325	{
	326	namespace hidden_type_desc
	327	{
	328	std::shared_ptr<const type_descriptor_t> byte;
	329	std::shared_ptr<const type_descriptor_t> short_word;
	330	std::shared_ptr<const type_descriptor_t> word;
	331	std::shared_ptr<const type_descriptor_t> short_real;
	332	std::shared_ptr<const type_descriptor_t> real;
	333	std::shared_ptr<const type_descriptor_t> big;
	334	std::shared_ptr<const type_descriptor_t> pointer;
	335
	336	std::shared_ptr<const type_descriptor_t> vm_array;
	337	std::shared_ptr<const type_descriptor_t> vm_list;
	338	std::shared_ptr<const type_descriptor_t> vm_channel;
	339	std::shared_ptr<const type_descriptor_t> vm_string;
	340
	341	std::shared_ptr<const type_descriptor_t> vm_module_ref;
	342	std::shared_ptr<const type_descriptor_t> vm_stack;
	343	std::shared_ptr<const type_descriptor_t> vm_thread;
	344	}
	345	}
	346
	347	std::atomic_bool intrinsic_type_desc::is_initialized;
	348
	349	void intrinsic_type_desc::initialize()
	350	{
	351	auto is_false = bool{ false };
	352	if (!intrinsic_type_desc::is_initialized.compare_exchange_strong(is_false, true))
	353	return;
	354
	355	hidden_type_desc::byte = type_descriptor_t::create(sizeof(byte_t));
	356	hidden_type_desc::short_word = type_descriptor_t::create(sizeof(short_word_t));
	357	hidden_type_desc::word = type_descriptor_t::create(sizeof(word_t));
	358	hidden_type_desc::short_real = type_descriptor_t::create(sizeof(short_real_t));
	359	hidden_type_desc::real = type_descriptor_t::create(sizeof(real_t));
	360	hidden_type_desc::big = type_descriptor_t::create(sizeof(big_t));
	361	hidden_type_desc::pointer = type_descriptor_t::create(sizeof(pointer_t), std::vector<byte_t>{0x80});
	362
	363	hidden_type_desc::vm_array = type_descriptor_t::create(0);
	364	hidden_type_desc::vm_list = type_descriptor_t::create(0);
	365	hidden_type_desc::vm_channel = type_descriptor_t::create(0);
	366	hidden_type_desc::vm_string = type_descriptor_t::create(0);
	367
	368	hidden_type_desc::vm_module_ref = type_descriptor_t::create(0);
	369	hidden_type_desc::vm_stack = type_descriptor_t::create(0);
	370	hidden_type_desc::vm_thread = type_descriptor_t::create(0);
	371	}
	372
	373	template<>
	374	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<byte_t>() { return hidden_type_desc::byte; }
	375
	376	template<>
	377	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<short_word_t>() { return hidden_type_desc::short_word; }
	378
	379	template<>
	380	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<word_t>() { return hidden_type_desc::word; }
	381
	382	template<>
	383	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<short_real_t>() { return hidden_type_desc::short_real; }
	384
	385	template<>
	386	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<real_t>() { return hidden_type_desc::real; }
	387
	388	template<>
	389	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<big_t>() { return hidden_type_desc::big; }
	390
	391	template<>
	392	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<pointer_t>() { return hidden_type_desc::pointer; }
	393
	394	template<>
	395	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_array_t>() { return hidden_type_desc::vm_array; }
	396
	397	template<>
	398	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_list_t>() { return hidden_type_desc::vm_list; }
	399
	400	template<>
	401	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_channel_t>() { return hidden_type_desc::vm_channel; }
	402
	403	template<>
	404	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_string_t>() { return hidden_type_desc::vm_string; }
	405
	406	template<>
	407	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_module_ref_t>() { return hidden_type_desc::vm_module_ref; }
	408
	409	template<>
	410	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_stack_t>() { return hidden_type_desc::vm_stack; }
	411
	412	template<>
	413	static std::shared_ptr<const type_descriptor_t> intrinsic_type_desc::type<vm_thread_t>() { return hidden_type_desc::vm_thread; }
	414
	415	vm_alloc_instance_finalizer_t type_descriptor_t::no_finalizer = nullptr;
	416
	417	std::shared_ptr<const type_descriptor_t> type_descriptor_t::create(const word_t size)
	418	{
	419	return type_descriptor_t::create(size, 0, nullptr);
	420	}
	421
	422	std::shared_ptr<const type_descriptor_t> type_descriptor_t::create(const word_t size, const std::vector<byte_t> &pointer_map)
	423	{
	424	assert(pointer_map.size() < static_cast<std::size_t>(std::numeric_limits<word_t>::max()));
	425	return type_descriptor_t::create(size, static_cast<word_t>(pointer_map.size()), pointer_map.data());
	426	}
	427
	428	std::shared_ptr<const type_descriptor_t> type_descriptor_t::create(
	429	const word_t size,
	430	const word_t pointer_map_length,
	431	const byte_t *pointer_map,
	432	const vm_alloc_instance_finalizer_t finalizer)
	433	{
	434	struct
	435	{
	436	void operator()(type_descriptor_t *td)
	437	{
	438	free_memory(const_cast<byte_t *>(td->pointer_map));
	439	debug::assign_debug_pointer(const_cast<byte_t **>(&td->pointer_map));
	440
	441	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "destroy: type descriptor\n");
	442	free_memory(td);
	443	}
	444	} deleter;
	445
	446	auto new_type_memory = alloc_memory(sizeof(type_descriptor_t));
	447
	448	byte_t *pointer_map_local = nullptr;
	449	if (pointer_map_length > 0)
	450	{
	451	pointer_map_local = alloc_memory<byte_t>(pointer_map_length);
	452	for (auto i = word_t{ 0 }; i < pointer_map_length; ++i)
	453	pointer_map_local[i] = pointer_map[i];
	454	}
	455
	456	auto new_type = ::new(new_type_memory) type_descriptor_t{ size, pointer_map_length, pointer_map_local, finalizer };
	457	return std::shared_ptr<type_descriptor_t>{ new_type, deleter };
	458	}
	459
	460	type_descriptor_t::type_descriptor_t(
	461	word_t size_in_bytes,
	462	word_t map_in_bytes,
	463	const byte_t * pointer_map,
	464	vm_alloc_instance_finalizer_t finalizer)
	465	: size_in_bytes{ size_in_bytes }
	466	, map_in_bytes{ map_in_bytes }
	467	, pointer_map{ pointer_map }
	468	, finalizer{ finalizer }
	469	{
	470	debug::log_msg(debug::component_trace_t::memory, debug::log_level_t::debug, "init: type descriptor\n");
	471	}