[stack-switching] X86_64Stack compression

[stack-switching] Correct suspension logic after compression

[stack-switching] Compression bug fixes

[stack-switching] Temp

[stack-switching] Comment regarding tag coercion

[stack-switching] Fixed REF <=> REF_U64 tag coercion error

[stack-switching] Removed debug messages

[stack-switching] Lots of debugging

[stack-switching] memory mapping bug fixed

[stack-switching] Removed debug

[stack-switching] temp: debug

[stack-switching] Parameter overlap test case

[stack-switching] Code jump error in fast-int

Author: linxuanm

src/engine/Debug.v3

@@ -13,6 +13,7 @@ component Debug {
 	def stack = false;
 	def memory = false;
 	def diagnostic = false;
+	def compression = false;
 
 	// Prevents arguments from being dead-code-eliminated.
 	def keepAlive<T>(x: T) { }

src/engine/Sidetable.v3

@@ -82,7 +82,11 @@ component Sidetables {
 			BR => 			size = Sidetable_BrEntry.size;
 			BR_IF => 		size = Sidetable_BrEntry.size;
 			BR_TABLE =>		{ var count = immptr.skip_labels(); size = (1 + count) * Sidetable_BrEntry.size; }
-			TRY_TABLE =>		{ var count = immptr.skip_catches(); size = count * Sidetable_CatchEntry.size; }
+			TRY_TABLE =>		{
+				immptr.read_BlockTypeCode();
+				var count = immptr.skip_catches();
+				size = count * Sidetable_CatchEntry.size;
+			}
 			BR_ON_NULL =>		size = Sidetable_BrEntry.size;
 			BR_ON_NON_NULL =>	size = Sidetable_BrEntry.size;
 			BR_ON_CAST =>		size = Sidetable_BrEntry.size;

src/engine/Value.v3

@@ -71,7 +71,7 @@ component Values {
 					var id = if(x.decl == null, -1, x.decl.heaptype_index);
 					buf.put1("<ref array #%d>", id);
 				}
-				x: Object => x.render(buf);
+				x: Object => { x.render(buf); }
 				null => buf.puts("<ref null>");
 			}
 			I31(val) => buf.put1("i31:%d", u32.view(val));

src/engine/WasmStack.v3

@@ -2,7 +2,7 @@
 // See LICENSE for details of Apache 2.0 license.
 
 // An execution stack.
-class ExecStack {
+class ExecStack extends Object {
 	def popV(t: ValueType) -> Value;
 	def popi() -> i32;
 	def popu() -> u32;
@@ -51,10 +51,14 @@ class ExecStack {
 	}
 }
 
+// Represents a suspendable stack that can be used to instantiate a continuation.
+class VersionedStack extends ExecStack {
+	var version: u64;
+}
+
 // Represents a stack on which Wasm code can be executed.
-class WasmStack extends ExecStack {
+class WasmStack extends VersionedStack {
 	var parent: WasmStack;
-	var version: u64;
 
 	// ext:stack-switching
 	// Denotes the bottom stack of a suspended continuation (with {this} as the top stack).

src/engine/continuation/BoxedContinuation.v3

@@ -29,4 +29,7 @@ component Continuations {
 
 	def getStoredStack(cont: Continuation) -> WasmStack { return cont.stack; }
 	def getStoredVersion(cont: Continuation) -> u64 { return 0; } // boxed cont does not store version
+
+	def objectIsContinuation(obj: Object) -> bool { return Continuation.?(obj); }
+	def objectToContinuation(obj: Object) -> Continuation { return Continuation.!(obj); }
 }

src/engine/continuation/UnboxedContinuation.v3

@@ -25,4 +25,7 @@ component Continuations {
 
 	def getStoredStack(cont: Continuation) -> WasmStack { return cont.stack; }
 	def getStoredVersion(cont: Continuation) -> u64 { return cont.version; }
+
+	def objectIsContinuation(obj: Object) -> bool { return false; }
+	def objectToContinuation(obj: Object) -> Continuation;
 }

src/engine/x86-64/Mmap.v3

@@ -49,4 +49,8 @@ class MemoryRange {
 	def range(offset: int, length: int) -> Range<byte> {
 		return CiRuntime.forgeRange(this.start + offset, length);
 	}
+
+	def render(buf: StringBuilder) -> StringBuilder {
+		return buf.put2("MemRange[0x%x, 0x%x)", start - Pointer.NULL, end - Pointer.NULL);
+	}
 }

src/engine/x86-64/X86_64Interpreter.v3

@@ -4230,6 +4230,7 @@ class X86_64InterpreterGen(ic: X86_64InterpreterCode, w: DataWriter) {
 	}
 	// generates cleanup code for after a child stack returns
 	private def genOnResumeFinish(skip_tag: bool) {
+		restoreCurPcFromFrame();
 		restoreCallerIVars();
 		restoreDispatchTableReg();
 		var r_stack = r_tmp1;

src/engine/x86-64/X86_64Runtime.v3

@@ -135,6 +135,18 @@ component X86_64Runtime {
 	// is found). Then, the tag parameters and the continuation is pushed onto
 	// the handler stack.
 	def runtime_handle_suspend(stack: X86_64Stack, instance: Instance, tag_id: u31) -> Throwable {
+		// TODO[sc]: remove this check
+		Trace.OUT.put2(
+			"suspending on stack=0x%x, rsp=0x%x",
+			Pointer.atObject(stack) - Pointer.NULL,
+			stack.rsp - Pointer.NULL
+		).ln();
+		var old_parent = stack.parent;
+		var compressed = X86_64Compression.compress(stack);
+		X86_64Compression.decompress(stack, compressed);
+		stack.parent = old_parent;
+		if (old_parent != null) stack.parent_rsp_ptr.store<Pointer>(X86_64Stack.!(old_parent).rsp);
+
 		var tag = instance.tags[tag_id];
 		var vals = stack.popN(tag.sig.params);
 		var cont = Runtime.unwindStackChain(stack, instance, tag_id, WasmStack.tryHandleSuspension);

src/engine/x86-64/X86_64Stack.v3

@@ -33,7 +33,7 @@ class X86_64Stack extends WasmStack {
 		}
 		clear();
 		if (valuerep.tagged) RiGc.registerScanner(this, X86_64Stack.scan);
-		if (Trace.stack && Debug.stack) Trace.OUT.put2("newStack start=0x%x, end=0x%x", mapping.range.start - Pointer.NULL, mapping.range.end - Pointer.NULL).ln();
+		if (Debug.stack) Trace.OUT.put2("newStack start=0x%x, end=0x%x", mapping.range.start - Pointer.NULL, mapping.range.end - Pointer.NULL).ln();
 	}
 	// Gets the state of this stack.
 	def state() -> StackState {
@@ -120,7 +120,7 @@ class X86_64Stack extends WasmStack {
 	// stop the stackwalk. Otherwise stop at the return-parent stub. In any case, return the last
 	// valid stack pointer, and a boolean indicating if the walk stopped early (due to {f} returning {false}).
 	// (XXX: takes a function {f} with an additional parameter, and the parameter, to avoid a closure).
-	private def walk<P>(f: (Pointer, RiUserCode, StackFramePos, P) -> bool, param: P, start_sp: Pointer, continue_to_parent: bool) -> (bool, StackFramePos) {
+	def walk<P>(f: (Pointer, RiUserCode, StackFramePos, P) -> bool, param: P, start_sp: Pointer, continue_to_parent: bool) -> (bool, StackFramePos) {
 		var stack = this;
 		var sp = start_sp;
 		if (Trace.stack && Debug.stack) {
@@ -185,7 +185,7 @@ class X86_64Stack extends WasmStack {
 		}
 		// Increment by {Pointer.SIZE} to skip the return address pushed by {resume}.
 		var frame = TargetFrame(rsp + Pointer.SIZE);
-		var accessor = frame.getFrameAccessor();
+		var accessor = frame.getFrameAccessorOfStack(this);
 		var func = accessor.func();
 		var handler = func.decl.findSuspensionHandler(func.instance, tag, accessor.pc());
 		if (handler.handler_pc < 0) { // not found
@@ -469,9 +469,15 @@ class X86_64Stack extends WasmStack {
 		code.scanFrame(ip, pos.frame.sp);
 		return true;
 	}
+	// XXX: If you ever get a nonsensical stacktrace (i.e., non-contiguous, untraceble
+	// call stack) where a virtual call on a value returned by {X86_64Stack.readValue}
+	// shows up somewhere in it, it's almost certainly the REF <=> REF_U64 tag coercion.
 	def readValue(base: Pointer, offset: int) -> Value {
+		// TODO: correctly tag the REF_U64 storage kind (requires typed REF_NULL loads).
 		if (!valuerep.tagged) fatal("untyped frame access requires value tagging to be enabled");
 		var tp = base + offset * valuerep.slot_size;
+
+		if (!mapping.range.contains(base)) System.error("FrameAccessError", "base out of bounds");
 		if (!mapping.range.contains(tp)) System.error("FrameAccessError", "out of bounds");
 		var vp = tp + valuerep.tag_size;
 		var tag = tp.load<u8>() & '\x7F';
@@ -484,6 +490,7 @@ class X86_64Stack extends WasmStack {
 			BpTypeCode.NULLEXTERNREF.code,
 			BpTypeCode.I31REF.code => return readI31OrObject(vp);
 
+			// TODO: check if nullref needs REF_U64 coercion
 			BpTypeCode.STRUCTREF.code,
 			BpTypeCode.NULLREF.code,
 			BpTypeCode.ARRAYREF.code,
@@ -572,6 +579,22 @@ class X86_64Stack extends WasmStack {
 		if (bits == 0) return Values.REF_NULL;
 		if ((bits & 1) == 1) return Value.I31(u31.view(bits >> 1));
 		var obj = vp.load<Object>();
+		// TODO[sc]: revisit this check
+		if (FeatureDisable.unboxedConts) {
+			if (Continuations.objectIsContinuation(obj)) {
+				return Value.Cont(Continuations.objectToContinuation(obj));
+			}
+		} else {
+			if (WasmStack.?(obj)) {
+				var version = (vp + 8).load<u64>();
+				return Value.Cont(Continuations.continuationWithVersion(WasmStack.!(obj), version));
+			}
+		}
+
+		if (ExecStack.?(obj)) {
+			// {vp} points to an unboxed continuation.
+			var x = 1 / 0;
+		}
 		return Value.Ref(obj);
 	}
 	def popResult(rt: Array<ValueType>) -> Result {
@@ -589,7 +612,7 @@ def G = X86_64MasmRegs.toGpr, X = X86_64MasmRegs.toXmmr;
 component X86_64Stacks {
 	var RESUME_STUB_POINTER: Pointer;
 
-	def getFrameAccessor(sp: Pointer) -> X86_64FrameAccessor {
+	def getFrameAccessorOfStack(sp: Pointer, stack: X86_64Stack) -> X86_64FrameAccessor {
 		var retip = (sp + -RETADDR_SIZE).load<Pointer>();
 		var code = RiRuntime.findUserCode(retip);
 		match (code) {
@@ -598,7 +621,7 @@ component X86_64Stacks {
 				if (prev != null) return prev;
 				// Interpreter frames store the {WasmFunction} _and_ {FuncDecl}.
 				var decl = (sp + X86_64InterpreterFrame.func_decl.offset).load<FuncDecl>();
-				var n = X86_64FrameAccessor.new(X86_64Runtime.curStack, sp, decl);
+				var n = X86_64FrameAccessor.new(stack, sp, decl);
 				(sp + X86_64InterpreterFrame.accessor.offset).store<X86_64FrameAccessor>(n);
 				return n;
 			}
@@ -608,13 +631,19 @@ component X86_64Stacks {
 				// SPC frames only store the {WasmFunction}.
 				var wf = (sp + X86_64InterpreterFrame.wasm_func.offset).load<WasmFunction>();
 				// TODO: assert wf.decl == x.decl()
-				var n = X86_64FrameAccessor.new(X86_64Runtime.curStack, sp, wf.decl);
+				var n = X86_64FrameAccessor.new(stack, sp, wf.decl);
 				(sp + X86_64InterpreterFrame.accessor.offset).store<X86_64FrameAccessor>(n);
 				return n;
 			}
 		}
 		return null;
 	}
+
+	// TODO[cleanup]: defaulting to {curStack} should be deprecated with stack-switching
+	def getFrameAccessor(sp: Pointer) -> X86_64FrameAccessor {
+		return getFrameAccessorOfStack(sp, X86_64Runtime.curStack);
+	}
+
 	def traceIpAndSp(ip: Pointer, sp: Pointer, out: Range<byte> -> void) {
 		var buf = X86_64Runtime.globalFrameDescriptionBuf;
 		buf.put2("\t@[ip=0x%x, sp=0x%x] ", ip - Pointer.NULL, sp - Pointer.NULL).send(out);
@@ -1025,6 +1054,13 @@ class X86_64FrameAccessor(stack: X86_64Stack, sp: Pointer, decl: FuncDecl) exten
 		var vfp = (sp + X86_64InterpreterFrame.vfp.offset).load<Pointer>();
 		return stack.readValue(vfp, i);
 	}
+	// Get the value at {vfp + i}.
+	// XXX: refactor
+	def getValue(i: int) -> Value {
+		checkNotUnwound();
+		var vfp = (sp + X86_64InterpreterFrame.vfp.offset).load<Pointer>();
+		return stack.readValue(vfp, i);
+	}
 	// Get the value of frame variable {i}.
 	def getFrameVar(i: int) -> Value {
 		checkNotUnwound();
@@ -1116,7 +1152,7 @@ class X86_64FrameAccessor(stack: X86_64Stack, sp: Pointer, decl: FuncDecl) exten
 		var st_ptr = if(stp == st_entries.length, Pointer.atContents(st_entries), Pointer.atElement(func.sidetable.entries, stp));
 		(sp + X86_64InterpreterFrame.stp.offset)	.store<Pointer>(st_ptr);
 	}
-	private def vfp() -> Pointer {
+	def vfp() -> Pointer {
 		return (sp + X86_64InterpreterFrame.vfp.offset).load<Pointer>();
 	}
 	private def set_vsp(p: Pointer) {