Initial import.

T0/CPU.cs

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining 
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+/*
+ * Execution of code during compilation is done in a virtual CPU
+ * incarnated by this class, that contains the relevant registers.
+ *
+ * Accesses to the data on the stack are mapped to accesses to an
+ * internal array, with no explicit control on boundaries. Since the
+ * internal array may be larger than the actual stack contents,
+ * nonsensical accesses may still "work" to some extent. The whole
+ * thing won't derail beyond the CLR VM, though.
+ */
+
+class CPU {
+
+	/*
+	 * Next instruction to execute is in ipBuf[ipOff].
+	 */
+	internal Opcode[] ipBuf;
+	internal int ipOff;
+
+	/*
+	 * stackBuf and stackPtr implement the data stack. The system
+	 * stack uses frames; 'rsp' points to the current top frame.
+	 */
+	TValue[] stackBuf;
+	int stackPtr;
+	Frame rsp;
+
+	internal CPU()
+	{
+		stackBuf = new TValue[16];
+		stackPtr = -1;
+		rsp = null;
+	}
+
+	/*
+	 * Enter a function, reserving space for 'numLocals' local variables.
+	 */
+	internal void Enter(Opcode[] code, int numLocals)
+	{
+		Frame f = new Frame(rsp, numLocals);
+		rsp = f;
+		f.savedIpBuf = ipBuf;
+		f.savedIpOff = ipOff;
+		ipBuf = code;
+		ipOff = 0;
+	}
+
+	/*
+	 * Exit the current function.
+	 */
+	internal void Exit()
+	{
+		ipBuf = rsp.savedIpBuf;
+		ipOff = rsp.savedIpOff;
+		rsp = rsp.upper;
+	}
+
+	/*
+	 * Get the current stack depth (number of elements).
+	 */
+	internal int Depth {
+		get {
+			return stackPtr + 1;
+		}
+	}
+
+	/*
+	 * Pop a value from the stack.
+	 */
+	internal TValue Pop()
+	{
+		return stackBuf[stackPtr --];
+	}
+
+	/*
+	 * Push a value on the stack.
+	 */
+	internal void Push(TValue v)
+	{
+		int len = stackBuf.Length;
+		if (++ stackPtr == len) {
+			TValue[] nbuf = new TValue[len << 1];
+			Array.Copy(stackBuf, 0, nbuf, 0, len);
+			stackBuf = nbuf;
+		}
+		stackBuf[stackPtr] = v;
+	}
+
+	/*
+	 * Look at the value at depth 'depth' (0 is top of stack). The
+	 * stack is unchanged.
+	 */
+	internal TValue Peek(int depth)
+	{
+		return stackBuf[stackPtr - depth];
+	}
+
+	/*
+	 * Rotate the stack at depth 'depth': the value at that depth
+	 * is moved to the top of stack.
+	 */
+	internal void Rot(int depth)
+	{
+		TValue v = stackBuf[stackPtr - depth];
+		Array.Copy(stackBuf, stackPtr - (depth - 1),
+			stackBuf, stackPtr - depth, depth);
+		stackBuf[stackPtr] = v;
+	}
+
+	/*
+	 * Inverse-rotate the stack at depth 'depth': the value at the
+	 * top of stack is moved to that depth.
+	 */
+	internal void NRot(int depth)
+	{
+		TValue v = stackBuf[stackPtr];
+		Array.Copy(stackBuf, stackPtr - depth,
+			stackBuf, stackPtr - (depth - 1), depth);
+		stackBuf[stackPtr - depth] = v;
+	}
+
+	/*
+	 * Get the current contents of the local variable 'num'.
+	 */
+	internal TValue GetLocal(int num)
+	{
+		return rsp.locals[num];
+	}
+
+	/*
+	 * Set the contents of the local variable 'num'.
+	 */
+	internal void PutLocal(int num, TValue v)
+	{
+		rsp.locals[num] = v;
+	}
+
+	/*
+	 * The system stack really is a linked list of Frame instances.
+	 */
+	class Frame {
+
+		internal Frame upper;
+		internal Opcode[] savedIpBuf;
+		internal int savedIpOff;
+		internal TValue[] locals;
+
+		internal Frame(Frame upper, int numLocals)
+		{
+			this.upper = upper;
+			locals = new TValue[numLocals];
+		}
+	}
+}