Runtime.v3

// Copyright 2023 Wizard authors. All rights reserved.
// See LICENSE for details of Apache 2.0 license.

// Shared runtime routines that are called by different execution tiers, both the
// pure-Virgil (V3) implementation, and any native implementations.
component Runtime {
	def GLOBAL_GET(stack: ExecStack, instance: Instance, global_index: u31) {
		var val = instance.globals[global_index].value;
		stack.push(val);
	}
	def GLOBAL_SET(stack: ExecStack, instance: Instance, global_index: u31) {
		var g = instance.globals[global_index];
		var val = stack.popV(g.valtype);
		g.value = val;
	}
	def TABLE_GET(stack: ExecStack, instance: Instance, table_index: u31) -> Throwable {
		var table = instance.tables[table_index], elems = table.elems;
		var elem = stack.popa(table.decl.size);
		if (elem >= elems.length) return stack.trap(TrapReason.TABLE_OUT_OF_BOUNDS);
		stack.push(elems[elem]);
		return null;
	}
	def TABLE_SET(stack: ExecStack, instance: Instance, table_index: u31) -> Throwable {
		var table = instance.tables[table_index], elems = table.elems;
		var val = stack.popV(table.elemtype);
		var elem = stack.popa(table.decl.size);
		if (elem >= elems.length) return stack.trap(TrapReason.TABLE_OUT_OF_BOUNDS);
		table[int.!(elem)] = val;
		return null;
	}
	def MEMORY_GROW(stack: ExecStack, instance: Instance, mem_index: u31) {
		var memory = instance.memories[mem_index];
		var pages = stack.popa(memory.decl.size);
		var result = memory.grow(pages);
		stack.pusha(memory.decl.size, u64.view(result));
	}
	// --- GC operations -----------------------------------------------------------------------------------------
	def STRUCT_NEW(stack: ExecStack, instance: Instance, struct_index: u31) {
		var decl = StructDecl.!(instance.heaptypes[struct_index]);
		var fields = Array<Value>.new(decl.field_types.length);
		for (i = fields.length - 1; i >= 0; i--) {
			fields[i] = stack.popV(decl.field_types[i].valtype);
		}
		stack.push(Value.Ref(HeapStruct.new(decl, fields)));
	}
	def STRUCT_NEW_DEFAULT(stack: ExecStack, instance: Instance, struct_index: u31) {
		var decl = StructDecl.!(instance.heaptypes[struct_index]);
		var fields = Array<Value>.new(decl.field_types.length);
		for (i < fields.length) {
			fields[i] = Values.default(decl.field_types[i].valtype);
		}
		stack.push(Value.Ref(HeapStruct.new(decl, fields)));
	}
	def STRUCT_GET(stack: ExecStack, instance: Instance, struct_index: u31, field_index: u31) -> Throwable {
		var obj = stack.popStruct();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		stack.push(obj.vals[field_index]);
		return null;
	}
	def STRUCT_GET_S(stack: ExecStack, instance: Instance, struct_index: u31, field_index: u31) -> Throwable {
		var obj = stack.popStruct();
		var decl = StructDecl.!(instance.heaptypes[struct_index]);
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		stack.push(V3Eval.signExtend(decl.field_types[field_index], obj.vals[field_index])); // XXX: pushi
		return null;
	}
	def STRUCT_GET_U(stack: ExecStack, instance: Instance, struct_index: u31, field_index: u31) -> Throwable {
		var obj = stack.popStruct();
		var decl = StructDecl.!(instance.heaptypes[struct_index]);
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		stack.push(V3Eval.zeroExtend(decl.field_types[field_index], obj.vals[field_index])); // XXX: pushi
		return null;
	}
	def STRUCT_SET(stack: ExecStack, instance: Instance, struct_index: u31, field_index: u31) -> Throwable {
		var decl = StructDecl.!(instance.heaptypes[struct_index]);
		var val = stack.popV(decl.field_types[field_index].valtype);
		var obj = stack.popStruct();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		obj.vals[field_index] = val;
		return null;
	}
	def ARRAY_NEW(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var decl = ArrayDecl.!(instance.heaptypes[array_index]);
		var length = stack.popu();
		var elem = stack.popV(decl.elem_types[0].valtype);
		if (length > Execute.limits.max_array_length) return stack.trap(TrapReason.OOM);
		var vals = Array<Value>.new(u31.!(length));
		for (i < vals.length) vals[i] = elem;
		stack.push(Value.Ref(HeapArray.new(decl, vals)));
		return null;
	}
	def ARRAY_NEW_DEFAULT(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var decl = ArrayDecl.!(instance.heaptypes[array_index]);
		var length = stack.popu();
		if (length > Execute.limits.max_array_length) return stack.trap(TrapReason.OOM);
		var vals = Array<Value>.new(u31.!(length));
		var elem = Values.default(decl.elem_types[0].valtype);
		for (i < vals.length) vals[i] = elem;
		stack.push(Value.Ref(HeapArray.new(decl, vals)));
		return null;
	}
	def ARRAY_NEW_FIXED(stack: ExecStack, instance: Instance, array_index: u31, length: u32) -> Throwable {
		var decl = ArrayDecl.!(instance.heaptypes[array_index]);
		if (length > Execute.limits.max_array_length) return stack.trap(TrapReason.OOM);
		var vals = Array<Value>.new(u31.!(length));
		var t = decl.elem_types[0].valtype;
		for (i = vals.length - 1; i >= 0; i--) vals[i] = stack.popV(t);
		stack.push(Value.Ref(HeapArray.new(decl, vals)));
		return null;
	}
	def ARRAY_NEW_DATA(stack: ExecStack, instance: Instance, array_index: u31, data_index: u31) -> Throwable {
		var length = stack.popu();
		var offset = stack.popu();
		if (instance.dropped_data[data_index]) return stack.trap(TrapReason.MEM_OUT_OF_BOUNDS);
		var rtt = ArrayDecl.!(instance.heaptypes[array_index]);
		var ddecl = instance.module.data[data_index];
		if (length > Execute.limits.max_array_length) return stack.trap(TrapReason.OOM);
		var t = bytesToVals(rtt.elem_types[0], ddecl.data, offset, length);
		if (!t.0) return stack.trap(TrapReason.MEM_OUT_OF_BOUNDS);
		stack.push(Value.Ref(HeapArray.new(rtt, t.1)));
		return null;
	}
	def ARRAY_NEW_ELEM(stack: ExecStack, instance: Instance, array_index: u31, elem_index: u31) -> Throwable {
		var length = stack.popu();
		var offset = stack.popu();
		if (instance.dropped_elems[elem_index]) return stack.trap(TrapReason.MEM_OUT_OF_BOUNDS);
		var rtt = ArrayDecl.!(instance.heaptypes[array_index]);
		var edecl = instance.module.elems[elem_index];
		if (length > Execute.limits.max_array_length) return stack.trap(TrapReason.OOM);
		var vals = Array<Value>.new(u31.!(length));
		var r = copyElemsInto(vals, instance, 0, edecl, offset, length);
		if (!r) return stack.trap(TrapReason.TABLE_OUT_OF_BOUNDS); // TODO: elem out of bounds
		stack.push(Value.Ref(HeapArray.new(rtt, vals)));
		return null;
	}
	def ARRAY_GET(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var index = stack.popu();
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		if (index >= u32.view(obj.vals.length)) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		stack.push(obj.vals[index]);
		return null;
	}
	def ARRAY_GET_S(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var decl = ArrayDecl.!(instance.heaptypes[array_index]);
		var index = stack.popu();
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		if (index >= u32.view(obj.vals.length)) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		stack.push(V3Eval.signExtend(decl.elem_types[0], obj.vals[index])); // XXX: pushi
		return null;
	}
	def ARRAY_GET_U(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var decl = ArrayDecl.!(instance.heaptypes[array_index]);
		var index = stack.popu();
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		if (index >= u32.view(obj.vals.length)) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		stack.push(V3Eval.zeroExtend(decl.elem_types[0], obj.vals[index])); // XXX: pushi
		return null;
	}
	def ARRAY_SET(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var decl = ArrayDecl.!(instance.heaptypes[array_index]);
		var val = stack.popV(decl.elem_types[0].valtype);
		var index = stack.popu();
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		if (index >= u32.view(obj.vals.length)) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		obj.vals[index] = val;
		return null;
	}
	def ARRAY_LEN(stack: ExecStack, instance: Instance) -> Throwable {
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		stack.pushi(obj.vals.length);
		return null;
	}
	def ARRAY_FILL(stack: ExecStack, instance: Instance, array_index: u31) -> Throwable {
		var rtt = ArrayDecl.!(instance.heaptypes[array_index]);
		var size = stack.popu();
		var val = stack.popV(rtt.elem_types[0].valtype); // XXX: polymorphic pop
		var offset = stack.popu();
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		var index = ArrayUtil.boundsCheck(obj.vals, offset, size);
		if (index < 0) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		var r = obj.vals[index ..+ size];
		for (i < r.length) r[i] = val;
		return null;
	}
	def ARRAY_COPY(stack: ExecStack, instance: Instance, array_index1: u31, array_index2: u31) -> Throwable {
		var size = stack.popu();
		var src_offset = stack.popu();
		var src = stack.popArray();
		var dst_offset = stack.popu();
		var dst = stack.popArray();
		if (src == null || dst == null) return stack.trap(TrapReason.NULL_DEREF);
		var r = ArrayUtil.safeCopy(dst.vals, dst_offset, src.vals, src_offset, size);
		if (!r) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		return null;
	}
	def ARRAY_INIT_DATA(stack: ExecStack, instance: Instance, array_index: u31, data_index: u31) -> Throwable {
		var size = stack.popu();
		var src_offset = stack.popu();
		var dst_offset = stack.popu();
		var obj = stack.popArray();
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		var rtt = ArrayDecl.!(instance.heaptypes[array_index]);
		if (instance.dropped_data[data_index]) return if(size > 0, stack.trap(TrapReason.DATA_SEGMENT_DROPPED), null);
		var data = instance.module.data[data_index].data;
		if (ArrayUtil.boundsCheck(obj.vals, dst_offset, size) < 0) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		var t = bytesToVals(rtt.elem_types[0], data, src_offset, size);
		if (!t.0) return stack.trap(TrapReason.MEM_OUT_OF_BOUNDS);
		ArrayUtil.safeCopy(obj.vals, dst_offset, t.1, 0, size);
		return null;
	}
	def ARRAY_INIT_ELEM(stack: ExecStack, instance: Instance, array_index: u31, elem_index: u31) -> Throwable {
		var size = stack.popu();
		var src_offset = stack.popu();
		var dst_offset = stack.popu();
		var obj = stack.popArray();
		var rtt = ArrayDecl.!(instance.heaptypes[array_index]);
		if (obj == null) return stack.trap(TrapReason.NULL_DEREF);
		if (instance.dropped_elems[elem_index]) return if(size > 0, stack.trap(TrapReason.ELEM_SEGMENT_DROPPED), null);
		var edecl = instance.module.elems[elem_index];
		var r = copyElemsInto(obj.vals, instance, dst_offset, edecl, src_offset, size);
		if (!r) return stack.trap(TrapReason.ARRAY_INDEX_OOB);
		return null;
	}
	// --- Table operations -----------------------------------------------------------------------------------------
	def TABLE_INIT(stack: ExecStack, instance: Instance, elem_index: u31, table_index: u31) -> Throwable {
		var elem = if (!instance.dropped_elems[elem_index], instance.module.elems[elem_index]);
		var table = instance.tables[table_index], sc = table.decl.size;
		var size = stack.popa(sc);
		var src_offset = stack.popa(sc);
		var dst_offset = stack.popa(sc);
		var t = table.copyE(instance, dst_offset, elem, src_offset, size);
		if (t != TrapReason.NONE) return stack.trap(t);
		return null;
	}
	def TABLE_COPY(stack: ExecStack, instance: Instance, table_index1: u31, table_index2: u31) -> Throwable {
		var dst = instance.tables[table_index1];
		var src = instance.tables[table_index2];
		var size = stack.popa(src.decl.size);
		var src_offset = stack.popa(src.decl.size);
		var dst_offset = stack.popa(dst.decl.size);
		var t = dst.copyT(dst_offset, src, src_offset, size);
		if (t != TrapReason.NONE) return stack.trap(t);
		return null;
	}
	def TABLE_GROW(stack: ExecStack, instance: Instance, table_index: u31) {
		var table = instance.tables[table_index], sc = table.decl.size;
		var size = stack.popa(sc);
		var val = stack.popV(table.elemtype);
		var r = table.grow(size, val);
		stack.pusha(sc, u64.view(r));
	}
	def TABLE_FILL(stack: ExecStack, instance: Instance, table_index: u31) -> Throwable {
		var table = instance.tables[table_index], sc = table.decl.size;
		var size = stack.popa(sc);
		var val = stack.popV(table.elemtype);
		var dest = stack.popa(sc);
		var t = table.fill(dest, val, size);
		if (t != TrapReason.NONE) return stack.trap(t);
		return null;
	}
	def MEMORY_INIT(stack: ExecStack, instance: Instance, data_index: u31, mem_index: u31) -> Throwable {
		var memory = instance.memories[mem_index], sc = memory.decl.size;
		var ddecl = if(!instance.dropped_data[data_index], instance.module.data[data_index]);
		var size = stack.popa(sc);
		var src_offset = stack.popa(sc);
		var dst_offset = stack.popa(sc);
		var t = memory.copyIn(dst_offset, if(ddecl != null, ddecl.data), src_offset, size);
		if (t != TrapReason.NONE) return stack.trap(t);
		return null;
	}
	def MEMORY_COPY(stack: ExecStack, instance: Instance, mem_index1: u31, mem_index2: u31) -> Throwable {
		var dst = instance.memories[mem_index1];
		var src = instance.memories[mem_index2];
		var size = stack.popa(src.decl.size);
		var src_offset = stack.popa(src.decl.size);
		var dst_offset = stack.popa(dst.decl.size);
		var t = dst.copyM(dst_offset, src, src_offset, size);
		if (t != TrapReason.NONE) return stack.trap(t);
		return null;
	}
	def MEMORY_FILL(stack: ExecStack, instance: Instance, mem_index: u31) -> Throwable {
		var memory = instance.memories[mem_index], sc = memory.decl.size;
		var size = stack.popa(sc);
		var val = stack.popu();
		var dest = stack.popa(sc);
		var t = memory.fill(dest, u8.view(val), size);
		if (t != TrapReason.NONE) return stack.trap(t);
		return null;
	}
	// --- Atomic operations -----------------------------------------------------------------------------------------
	def MEMORY_ATOMIC_NOTIFY(stack: ExecStack, instance: Instance, mem_index: u31, offset: u64) -> Throwable { // TODO: nop for now
		var memory = instance.memories[mem_index], sc = memory.decl.size;
		var count = stack.popu();
		var index = stack.popa(sc);
		stack.pushu(0);
		return null;
	}
	def MEMORY_ATOMIC_WAIT32(stack: ExecStack, instance: Instance, mem_index: u31, offset: u64) -> Throwable { // TODO: nop for now
		var memory = instance.memories[mem_index], sc = memory.decl.size;
		var timeout = stack.popw();
		var expected = stack.popu();
		var index = stack.popa(sc);
		stack.pushu(0);
		return null;
	}
	def MEMORY_ATOMIC_WAIT64(stack: ExecStack, instance: Instance, mem_index: u31, offset: u64) -> Throwable { // TODO: nop for now
		var memory = instance.memories[mem_index], sc = memory.decl.size;
		var timeout = stack.popw();
		var expected = stack.popw();
		var index = stack.popa(sc);
		stack.pushu(0);
		return null;
	}
	def ATOMIC_FENCE() { // XXX: nop on single-threaded targets
	}
	// ext:typed-cont
	def CONT_NEW(stack: WasmStack, instance: Instance, cont_index: u32, make_stack: void -> WasmStack) -> Throwable {
		var cont_decl = ContDecl.!(instance.heaptypes[cont_index]);
		var func_ref = stack.popV(ValueType.Ref(true, HeapType.Func(cont_decl.sig)));
		// TODO[ss]: trap if not wasm function (host cannot be continuations)	
		var func = WasmFunction.!(Value.Ref.!(func_ref).val);
		if (func == null) return stack.trap(TrapReason.NULL_DEREF);
		
		var new_stack = make_stack();
		new_stack.reset(func);
		stack.push(Value.Ref(Continuation.new(new_stack, new_stack)));
		return null;
	}
	def CONT_BIND(stack: WasmStack, instance: Instance, in_cont_index: u32, out_cont_index: u32) -> Throwable {
		var in_cont = ContDecl.!(instance.heaptypes[in_cont_index]);
		var out_cont = ContDecl.!(instance.heaptypes[out_cont_index]);
		var n_binds = in_cont.sig.params.length - out_cont.sig.params.length;

		var cont_ref = stack.popV(ValueType.Ref(true, HeapType.Cont(in_cont)));
		var vals = stack.popN(in_cont.sig.params[0 ... n_binds]);

		var cont = Continuation.!(Value.Ref.!(cont_ref).val);
		if (cont == null) return stack.trap(TrapReason.NULL_DEREF);
		if (cont.used) return stack.trap(TrapReason.USED_CONTINUATION);
		cont.used = true;

		var new_cont = Continuation.new(cont.top, cont.bottom);
		new_cont.top.bind(vals);
		stack.push(Value.Ref(new_cont));
		return null;
	}

	def matchRtt(obj: Object, rtt: HeapTypeDecl) -> bool {
		match (obj) {
			x: HeapObject => return ValueTypes.isAssignableHeap(x.decl, rtt);
			x: WasmFunction => return ValueTypes.isAssignableHeap(x.sig, rtt);
		}
		return false;
	}
	def cast(instance: Instance, nullable: bool, ht_val: int, val: Value) -> bool {
		match (ht_val) {
			BpHeapTypeCode.FUNC.val => return checkRef(nullable, Function.?, val);
			BpHeapTypeCode.EXTERN.val => return checkI31OrRef(nullable, Object.?, val);
			BpHeapTypeCode.ARRAY.val => return checkRef(nullable, HeapArray.?, val);
			BpHeapTypeCode.STRUCT.val => return checkRef(nullable, HeapStruct.?, val);
			BpHeapTypeCode.ANY.val => return checkI31OrRef(nullable, Object.?, val);
			BpHeapTypeCode.EQ.val => return checkI31OrRef(nullable, HeapObject.?, val);
			BpHeapTypeCode.I31.val => return checkI31OrRef(nullable, isFalse, val);
			BpHeapTypeCode.NOCONT.val, // fallthru
			BpHeapTypeCode.NOFUNC.val, // fallthru
			BpHeapTypeCode.NOEXTERN.val, // fallthru
			BpHeapTypeCode.NONE.val => return checkRef(nullable, isFalse, val);
			_ => {
				if (!Value.Ref.?(val)) return false;
				var obj = Value.Ref.!(val).val;
				if (obj == null) return nullable;
				var index = u32.!(ht_val); // XXX: make this a runtime error?
				var rtt = instance.heaptypes[index];
				return matchRtt(obj, rtt);
			}
		}
	}
	def copyElemsInto(dest: Array<Value>, instance: Instance, dst_offset: u64, elem: ElemDecl, src_offset: u64, size: u64) -> bool {
		if (elem == null) {
			if (ArrayUtil.boundsCheck(dest, dst_offset, size) < 0) return false;
			if (ArrayUtil.boundsCheck<byte>(null, src_offset, size) < 0) return false;
			return true;
		}
		match (elem.details) {
			FuncRefs(vals) => {
				return ArrayUtil.safeCopyF(dest, dst_offset, vals, src_offset, size, instance.getFunctionAsVal);
			}
			Exprs(vals) => {
				return ArrayUtil.safeCopyF(dest, dst_offset, vals, src_offset, size, instance.evalInitExpr);
			}
		}
	}
}
def bytesToVals(storage: StorageType, data: Array<byte>, offset: u32, length: u32) -> (bool, Array<Value>) { // TODO: MaybeTrap
	var vals = Array<Value>.new(int.!(length));
	var start = ArrayUtil.boundsCheck(data, offset, length);
	if (start < 0) return (false, null);
	var limit = sizeOfStorage(storage) * length + offset;
	if (limit > data.length) return (false, null);
	var d = DataReader.new(data).reset(data, start, int.!(limit));
	match (storage.pack) {
		UNPACKED => {
			match (storage.valtype) {
				I32 => for (i < vals.length) vals[i] = Value.I32(d.read_u32());
				I64 => for (i < vals.length) vals[i] = Value.I64(d.read_u64());
				F32 => for (i < vals.length) vals[i] = Value.F32(d.read_u32());
				F64 => for (i < vals.length) vals[i] = Value.F64(d.read_u64());
				V128 => for (i < vals.length) vals[i] = Value.V128(d.read_u64(), d.read_u64());
				_ => ;
			}
		}
		PACKED_I8 => for (i < vals.length) vals[i] = Value.I32(d.read1());
		PACKED_I16 => for (i < vals.length) vals[i] = Value.I32(d.read1() | (u32.!(d.read1()) << 8));
	}
	return (d.ok, vals);
}
def sizeOfStorage(storage: StorageType) -> u32 {
	match (storage.pack) {
		UNPACKED => {
			match (storage.valtype) {
				I32, F32 => return 4;
				I64, F64 => return 8;
				V128 => return 16;
				_ => return 8;
			}
		}
		PACKED_I8 => return 1;
		PACKED_I16 => return 2;
	}
}
def isFalse(obj: Object) -> bool {
	return false;
}
def checkI31OrRef(nullable: bool, checkRef: Object -> bool, val: Value) -> bool {
	match (val) {
		I31 => return true;
		Ref(obj) => {
			if (obj == null) return nullable;
			return checkRef(obj);
		}
		_ => return false;
	}
}
def checkRef(nullable: bool, q: Object -> bool, val: Value) -> bool {
	if (!Value.Ref.?(val)) return false;
	var obj = Value.Ref.!(val).val;
	if (obj == null) return nullable;
	return q(obj);
}