VMInstance.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using KoiVM.Runtime.Data;
using KoiVM.Runtime.Dynamic;
using KoiVM.Runtime.Execution;
using KoiVM.Runtime.Execution.Internal;

namespace KoiVM.Runtime {
	internal unsafe class VMInstance {
		[ThreadStatic] static Dictionary<Module, VMInstance> instances;
		static readonly object initLock = new object();
		static Dictionary<Module, int> initialized = new Dictionary<Module, int>();

		public static VMInstance Instance(Module module) {
			VMInstance inst;
			if (instances == null) {
				instances = new Dictionary<Module, VMInstance>();
			}
			if (!instances.TryGetValue(module, out inst)) {
				inst = new VMInstance(VMData.Instance(module));
				instances[module] = inst;
				lock (initLock) {
					if (!initialized.ContainsKey(module)) {
						inst.Initialize();
						initialized.Add(module, initialized.Count);
					}
				}
			}
			return inst;
		}

		public static VMInstance Instance(int id) {
			foreach (var entry in initialized)
				if (entry.Value == id)
					return Instance(entry.Key);
			return null;
		}

		public static int GetModuleId(Module module) {
			return initialized[module];
		}

		Stack<VMContext> ctxStack = new Stack<VMContext>();
		VMContext currentCtx;

		VMInstance(VMData data) {
			Data = data;
		}

		public VMData Data { get; private set; }

		void Initialize() {
			var initFunc = Data.LookupExport(Constants.HELPER_INIT);
			var codeAddr = (ulong)(Data.KoiSection + initFunc.CodeOffset);
			Run(codeAddr, initFunc.EntryKey, initFunc.Signature, new object[0]);
		}

		public object Run(uint id, object[] arguments) {
			var export = Data.LookupExport(id);
			var codeAddr = (ulong)(Data.KoiSection + export.CodeOffset);
			return Run(codeAddr, export.EntryKey, export.Signature, arguments);
		}

		public object Run(ulong codeAddr, uint key, uint sigId, object[] arguments) {
			var sig = Data.LookupExport(sigId).Signature;
			return Run(codeAddr, key, sig, arguments);
		}

		public void Run(uint id, void*[] typedRefs, void* retTypedRef) {
			var export = Data.LookupExport(id);
			var codeAddr = (ulong)(Data.KoiSection + export.CodeOffset);
			Run(codeAddr, export.EntryKey, export.Signature, typedRefs, retTypedRef);
		}

		public void Run(ulong codeAddr, uint key, uint sigId, void*[] typedRefs, void* retTypedRef) {
			var sig = Data.LookupExport(sigId).Signature;
			Run(codeAddr, key, sig, typedRefs, retTypedRef);
		}

		object Run(ulong codeAddr, uint key, VMFuncSig sig, object[] arguments) {
			if (currentCtx != null)
				ctxStack.Push(currentCtx);
			currentCtx = new VMContext(this);

			try {
				Debug.Assert(sig.ParamTypes.Length == arguments.Length);
				currentCtx.Stack.SetTopPosition((uint)arguments.Length + 1);
				for (uint i = 0; i < arguments.Length; i++) {
					currentCtx.Stack[i + 1] = VMSlot.FromObject(arguments[i], sig.ParamTypes[i]);
				}
				currentCtx.Stack[(uint)arguments.Length + 1] = new VMSlot { U8 = 1 };

				currentCtx.Registers[Constants.REG_K1] = new VMSlot { U4 = key };
				currentCtx.Registers[Constants.REG_BP] = new VMSlot { U4 = 0 };
				currentCtx.Registers[Constants.REG_SP] = new VMSlot { U4 = (uint)arguments.Length + 1 };
				currentCtx.Registers[Constants.REG_IP] = new VMSlot { U8 = codeAddr };
				VMDispatcher.Run(currentCtx);
				Debug.Assert(currentCtx.EHStack.Count == 0);

				object retVal = null;
				if (sig.RetType != typeof(void)) {
					var retSlot = currentCtx.Registers[Constants.REG_R0];
					if (Type.GetTypeCode(sig.RetType) == TypeCode.String && retSlot.O == null)
						retVal = Data.LookupString(retSlot.U4);
					else
						retVal = retSlot.ToObject(sig.RetType);
				}

				return retVal;
			}
			finally {
				currentCtx.Stack.FreeAllLocalloc();

				if (ctxStack.Count > 0)
					currentCtx = ctxStack.Pop();
			}
		}

		void Run(ulong codeAddr, uint key, VMFuncSig sig, void*[] arguments, void* retTypedRef) {
			if (currentCtx != null)
				ctxStack.Push(currentCtx);
			currentCtx = new VMContext(this);

			try {
				Debug.Assert(sig.ParamTypes.Length == arguments.Length);
				currentCtx.Stack.SetTopPosition((uint)arguments.Length + 1);
				for (uint i = 0; i < arguments.Length; i++) {
					var paramType = sig.ParamTypes[i];
					if (paramType.IsByRef) {
						currentCtx.Stack[i + 1] = new VMSlot { O = new TypedRef(arguments[i]) };
					}
					else {
						var typedRef = *(TypedReference*)arguments[i];
						currentCtx.Stack[i + 1] = VMSlot.FromObject(TypedReference.ToObject(typedRef), __reftype(typedRef));
					}
				}
				currentCtx.Stack[(uint)arguments.Length + 1] = new VMSlot { U8 = 1 };

				currentCtx.Registers[Constants.REG_K1] = new VMSlot { U4 = key };
				currentCtx.Registers[Constants.REG_BP] = new VMSlot { U4 = 0 };
				currentCtx.Registers[Constants.REG_SP] = new VMSlot { U4 = (uint)arguments.Length + 1 };
				currentCtx.Registers[Constants.REG_IP] = new VMSlot { U8 = codeAddr };
				VMDispatcher.Run(currentCtx);
				Debug.Assert(currentCtx.EHStack.Count == 0);

				if (sig.RetType != typeof(void)) {
					if (sig.RetType.IsByRef) {
						var retRef = currentCtx.Registers[Constants.REG_R0].O;
						if (!(retRef is IReference))
							throw new ExecutionEngineException();
						((IReference)retRef).ToTypedReference(currentCtx, retTypedRef, sig.RetType.GetElementType());
					}
					else {
						var retSlot = currentCtx.Registers[Constants.REG_R0];
						object retVal;
						if (Type.GetTypeCode(sig.RetType) == TypeCode.String && retSlot.O == null)
							retVal = Data.LookupString(retSlot.U4);
						else
							retVal = retSlot.ToObject(sig.RetType);
						TypedReferenceHelpers.SetTypedRef(retVal, retTypedRef);
					}
				}
			}
			finally {
				currentCtx.Stack.FreeAllLocalloc();

				if (ctxStack.Count > 0)
					currentCtx = ctxStack.Pop();
			}
		}
	}
}