stash

MichaelEstes · MichaelEstes · commit 70d30af05fb7 · 2025-11-24T17:55:03.000-08:00
diff --git a/Compile/Debug/Interop-Debug.sp b/Compile/Debug/Interop-Debug.sp
@@ -21,15 +21,19 @@ Iterator _Interop_Vector::operator::in()
 bool _Interop_Vector::next(it: Iterator)
 {
 	it.index += 1;
-	count := (this.end - this.begin) as int / #sizeof T;
-	return it.index < count;
+	return it.index < this.Count();
 }
 
 *T _Interop_Vector::current(it: Iterator)
 {
 	return this[it.index];
 }
 
+uint _Interop_Vector::Count()
+{
+	return (this.end - this.begin) as int / #sizeof T;
+}
+
 string _Interop_Vector::log() => "Interop Vector";
 
 state _Interop_Map_Node<Value>
diff --git a/Compile/Release/Interop-Release.sp b/Compile/Release/Interop-Release.sp
@@ -20,15 +20,19 @@ Iterator _Interop_Vector::operator::in()
 bool _Interop_Vector::next(it: Iterator)
 {
 	it.index += 1;
-	count := (this.end - this.begin) as int / #sizeof T;
-	return it.index < count;
+	return it.index < this.Count();
 }
 
 *T _Interop_Vector::current(it: Iterator)
 {
 	return this[it.index];
 }
 
+uint _Interop_Vector::Count()
+{
+	return (this.end - this.begin) as int / #sizeof T;
+}
+
 string _Interop_Vector::log() => "Interop Vector";
 
 state _Interop_Map_Node<Value>
diff --git a/Runtime/Global/Meta/Type.sp b/Runtime/Global/Meta/Type.sp
@@ -1,5 +1,14 @@
 package _
 
+[]*_Type InteropToArray(vec: *_Interop_Vector<*_Type>)
+{
+	arr := []*_Type;
+	arr.count = vec.Count();
+	arr.capacity = vec.Count();
+	arr.memory.ptr = vec.begin as *byte;
+	return arr;
+}
+
 bool _Type::IsPrimitive() => this.kind == _TypeKind.PrimitiveType;
 
 bool _Type::IsString() => this.IsPrimitive() && 
@@ -20,4 +29,9 @@ bool _Type::IsStructure() => this.kind == _TypeKind.StructureType;
 
 bool _Type::IsPointer() => this.kind == _TypeKind.PointerType;
 
+bool _Type::IsFunction() => this.kind == _TypeKind.FunctionType;
+
 uint _Type::FixedArrayCount() => this.type.fixedArray.count;
+
+[]*_Type _Type::GetFunctionParams() => InteropToArray(this.type.function.params);
+
diff --git a/Runtime/Math/Math.sp b/Runtime/Math/Math.sp
@@ -96,7 +96,7 @@ int Clamp(value: int, min: int, max: int) => Min(Max(value, min), max);
 
 float FClamp(value: float, min: float, max: float) => FMin(FMax(value, min), max);
 
-int Abs(val: int) => llabs(val);
+int Abs(val: int) => abs(val);
 
 float FAbs(val: float) => fabs(val);
 
diff --git a/Runtime/Math/Quaternion/Quaternion.sp b/Runtime/Math/Quaternion/Quaternion.sp
@@ -144,6 +144,33 @@ Matrix3 Quaternion::ToRotationMatrix()
 	return mat;
 }
 
+Vec3 Quaternion::Forward()
+{
+	f := Vec3();
+	f.x = 2.0 * (this.x * this.z + this.w * this.y);
+	f.y = 2.0 * (this.y * this.z - this.w * this.x);
+	f.z = 1.0 - 2.0 * (this.x * this.x + this.y * this.y);
+	return f;
+}
+
+Vec3 Quaternion::Up()
+{
+	u := Vec3();
+	u.x = 2.0 * (this.x * this.y - this.w * this.z);
+	u.y = 1.0 - 2.0 * (this.x * this.x + this.z * this.z);
+	u.z = 2.0 * (this.y * this.z + this.w * this.x);
+	return u;
+}
+
+Vec3 Quaternion::Left()
+{
+	l := Vec3();
+	l.x = 1.0 - 2.0 * (this.y * this.y + this.z * this.z);
+	l.y = 2.0 * (this.x * this.y + this.w * this.z);
+	l.z = 2.0 * (this.x * this.z - this.w * this.y);
+	return l;
+}
+
 Quaternion Quaternion::PowerOf(n: float32)
 {
 	halfCosAngle := Math.FClamp(this.w, -1.0, 1.0);
diff --git a/Runtime/Math/Vec/Vec2.sp b/Runtime/Math/Vec/Vec2.sp
@@ -43,4 +43,14 @@ ref Norm<Vec2> Vec2::Normalize()
 }
 
 Vec2 Vec2::operator::-(r: Vec2) => Vec2(this.x - r.x, this.y - r.y);
+Vec2 Vec2::operator::-(r: float32) => Vec2(this.x - r, this.y - r);
+
+Vec2 Vec2::operator::+(r: Vec2) => Vec2(this.x + r.x, this.y + r.y);
+Vec2 Vec2::operator::+(r: float32) => Vec2(this.x + r, this.y + r);
+
+Vec2 Vec2::operator::*(r: Vec2) => Vec2(this.x * r.x, this.y * r.y);
+Vec2 Vec2::operator::*(r: float32) => Vec2(this.x * r, this.y * r);
+
+Vec2 Vec2::operator::/(r: Vec2) => Vec2(this.x / r.x, this.y / r.y);
+Vec2 Vec2::operator::/(r: float32) => Vec2(this.x / r, this.y / r);
 
diff --git a/Runtime/Math/Vec/Vec3.sp b/Runtime/Math/Vec/Vec3.sp
@@ -53,6 +53,13 @@ ref Norm<Vec3> Vec3::Normalize()
 }
 
 Vec3 Vec3::operator::-(r: Vec3) => Vec3(this.x - r.x, this.y - r.y, this.z - r.z);
+Vec3 Vec3::operator::-(r: float32) => Vec3(this.x - r, this.y - r, this.z - r);
+
 Vec3 Vec3::operator::+(r: Vec3) => Vec3(this.x + r.x, this.y + r.y, this.z + r.z);
+Vec3 Vec3::operator::+(r: float32) => Vec3(this.x + r, this.y + r, this.z + r);
 
+Vec3 Vec3::operator::*(r: Vec3) => Vec3(this.x * r.x, this.y * r.y, this.z * r.z);
 Vec3 Vec3::operator::*(r: float32) => Vec3(this.x * r, this.y * r, this.z * r);
+
+Vec3 Vec3::operator::/(r: Vec3) => Vec3(this.x / r.x, this.y / r.y, this.z / r.z);
+Vec3 Vec3::operator::/(r: float32) => Vec3(this.x / r, this.y / r, this.z / r);
diff --git a/Runtime/Math/Vec/Vec4.sp b/Runtime/Math/Vec/Vec4.sp
@@ -53,3 +53,13 @@ ref Norm<Vec4> Vec4::Normalize()
 }
 
 Vec4 Vec4::operator::-(r: Vec4) => Vec4(this.x - r.x, this.y - r.y, this.z - r.z, this.w - r.w);
+Vec4 Vec4::operator::-(r: float32) => Vec4(this.x - r, this.y - r, this.z - r, this.w - r);
+
+Vec4 Vec4::operator::+(r: Vec4) => Vec4(this.x + r.x, this.y + r.y, this.z + r.z, this.w + r.w);
+Vec4 Vec4::operator::+(r: float32) => Vec4(this.x + r, this.y + r, this.z + r, this.w + r);
+
+Vec4 Vec4::operator::*(r: Vec4) => Vec4(this.x * r.x, this.y * r.y, this.z * r.z, this.w * r.w);
+Vec4 Vec4::operator::*(r: float32) => Vec4(this.x * r, this.y * r, this.z * r, this.w * r);
+
+Vec4 Vec4::operator::/(r: Vec4) => Vec4(this.x / r.x, this.y / r.y, this.z / r.z, this.w / r.w);
+Vec4 Vec4::operator::/(r: float32) => Vec4(this.x / r, this.y / r, this.z / r, this.w / r);
diff --git a/Src/IR/Interpreter/Interpreter.h b/Src/IR/Interpreter/Interpreter.h
@@ -16,15 +16,15 @@ inline char* global = nullptr;
 
 struct Interpreter
 {
-	char* stack;
-	char* stackFrameStart;
-	char* stackFrameEnd;
+	volatile char* stack;
+	volatile char* stackFrameStart;
+	volatile char* stackFrameEnd;
 	int threadID;
 	DCCallVM* dcCallVM;
 
 	Interpreter(size_t stackSize)
 	{
-		stack = new char[stackSize];
+		stack = new volatile char[stackSize];
 		stackFrameStart = stack;
 		stackFrameEnd = stack;
 		dcCallVM = CreateDynCallVM();
@@ -121,7 +121,7 @@ struct Interpreter
 		threadID = CurrentThreadID();
 	}
 
-	void* Interpret(SpiteIR::IR* ir)
+	volatile void* Interpret(SpiteIR::IR* ir)
 	{
 		SpiteIR::Function* entry = ir->entry;
 		Initialize(ir, entry->parent);
@@ -169,23 +169,23 @@ struct Interpreter
 		{
 			SpiteIR::Operand& param = params->at(i);
 			SpiteIR::Argument* arg = args.at(i);
-			CopyValue(param.reg, arg->value.type, stackFrameStart + offset, frame);
+			CopyValue(param.reg, arg->value.type, (void*)(stackFrameStart + offset), frame);
 			offset += param.type->size;
 		}
 	}
 
-	void* InterpretFunction(SpiteIR::Function* func, size_t start, eastl::vector<SpiteIR::Operand>* params = nullptr)
+	volatile void* InterpretFunction(SpiteIR::Function* func, size_t start, eastl::vector<SpiteIR::Operand>* params = nullptr)
 	{
 		#ifdef _INTERPRETER_EXTS
 		RunFunctionExtensions(func, params, this);
 		#endif
 
-		char* prevStackStart = stackFrameStart;
-		char* prevStackEnd = stackFrameEnd;
+		volatile char* prevStackStart = stackFrameStart;
+		volatile char* prevStackEnd = stackFrameEnd;
 		stackFrameStart = stackFrameStart + start;
 		InterpretAllocations(func->block->allocations);
 
-		if (params) MoveParams(params, func->arguments, prevStackStart);
+		if (params) MoveParams(params, func->arguments, (char*)prevStackStart);
 
 		InterpretBlock(func->block);
 		stackFrameStart = prevStackStart;
@@ -204,8 +204,8 @@ struct Interpreter
 		RunFunctionExtensions(func, &params, this);
 		#endif
 
-		char* prevStackStart = stackFrameStart;
-		char* prevStackEnd = stackFrameEnd;
+		volatile char* prevStackStart = stackFrameStart;
+		volatile char* prevStackEnd = stackFrameEnd;
 		stackFrameStart = stackFrameEnd;
 		InterpretAllocations(func->block->allocations);
 
@@ -221,18 +221,18 @@ struct Interpreter
 		InterpretBlock(func->block);
 		stackFrameStart = prevStackStart;
 		stackFrameEnd = prevStackEnd;
-		return stackFrameStart;
+		return (void*)stackFrameStart;
 	}
 
-	inline void CopyValue(size_t src, SpiteIR::Type* type, void* dst, char* frame)
+	inline void CopyValue(size_t src, SpiteIR::Type* type, volatile void* dst, volatile char* frame)
 	{
-		memcpy(dst, frame + src, type->size);
+		memcpy((void*)dst, (void*)(frame + src), type->size);
 	}
 
-	inline void CopyRegValue(SpiteIR::Operand& src, SpiteIR::Operand& dst, char* frame)
+	inline void CopyRegValue(SpiteIR::Operand& src, SpiteIR::Operand& dst, volatile char* frame)
 	{
-		void* dstPtr = stackFrameStart + dst.reg;
-		memcpy(dstPtr, frame + src.reg, dst.type->size);
+		void* dstPtr = (void*)(stackFrameStart + dst.reg);
+		memcpy(dstPtr, (void*)(frame + src.reg), dst.type->size);
 	}
 
 	inline void InterpretInstruction(SpiteIR::Instruction& inst, SpiteIR::Label*& label)
@@ -385,7 +385,7 @@ struct Interpreter
 		StoreOperand(src, stackFrameStart + storeInst.store.dst.reg);
 	}
 
-	inline void StoreOperand(SpiteIR::Operand& src, void* dst)
+	inline void StoreOperand(SpiteIR::Operand& src, volatile void* dst)
 	{
 		switch (src.kind)
 		{
@@ -477,7 +477,7 @@ struct Interpreter
 	inline void InterpretStorePtr(SpiteIR::Instruction& storeInst)
 	{
 		char* ptr = *(char**)(void*)(stackFrameStart + storeInst.store.dst.reg);
-		char* src = stackFrameStart + storeInst.store.src.reg;
+		char* src = (char*)(stackFrameStart + storeInst.store.src.reg);
 		memcpy(ptr, src, storeInst.store.src.type->size);
 	}
 
@@ -490,14 +490,14 @@ struct Interpreter
 
 	inline void InterpretReference(SpiteIR::Instruction& storeInst)
 	{
-		void* ref = (stackFrameStart + storeInst.store.src.reg);
+		volatile void* ref = stackFrameStart + storeInst.store.src.reg;
 		*(size_t*)(stackFrameStart + storeInst.store.dst.reg) = (size_t)ref;
 	}
 
 	inline void InterpretDereference(SpiteIR::Instruction& storeInst)
 	{
 		char* ptr = *(char**)(void*)(stackFrameStart + storeInst.store.src.reg);
-		char* dst = stackFrameStart + storeInst.store.dst.reg;
+		char* dst = (char*)(stackFrameStart + storeInst.store.dst.reg);
 		memcpy(dst, ptr, storeInst.store.dst.type->size);
 	}
 
@@ -723,7 +723,7 @@ struct Interpreter
 			paramPtrs.push_back((void*)(stackFrameStart + param.reg));
 		}
 
-		CallExternalFunction(func, paramPtrs, stackFrameStart + dst, dcCallVM, this);
+		CallExternalFunction(func, paramPtrs, (char*)(stackFrameStart + dst), dcCallVM, this);
 	}
 
 	inline void InterpretCall(SpiteIR::Instruction& callInst)
diff --git a/Src/Lower/LowerDefinitions.h b/Src/Lower/LowerDefinitions.h
@@ -324,10 +324,10 @@ struct LowerDefinitions
 				SpiteIR::Function* func = comp.compileFunc;
 				SpiteIR::Instruction* store = comp.storeInst;
 
-				void* ret = context.interpreter->InterpretFunction(func, 0);
+				volatile void* ret = context.interpreter->InterpretFunction(func, 0);
 				if (store)
 				{
-					SpiteIR::Operand src = CreateValueOperand(ret, func->returnType);
+					SpiteIR::Operand src = CreateValueOperand((void*)ret, func->returnType);
 					store->store.src = src;
 				}
 				deferredCompiles.pop_back();
@@ -2102,7 +2102,7 @@ struct LowerDefinitions
 				literal.f32Literal = 0.0f;
 				break;
 			case SpiteIR::PrimitiveKind::Float:
-				literal.floatLiteral = 0.0f;
+				literal.floatLiteral = 0.0;
 				break;
 			case SpiteIR::PrimitiveKind::String:
 				literal.stringLiteral = context.ir->AllocateString();

Original file line number	Diff line number	Diff line change
`@@ -21,15 +21,19 @@ Iterator _Interop_Vector::operator::in()`
`21`	`21`	`bool _Interop_Vector::next(it: Iterator)`
`22`	`22`	`{`
`23`	`23`	`it.index += 1;`
`24`		`- count := (this.end - this.begin) as int / #sizeof T;`
`25`		`- return it.index < count;`
	`24`	`+ return it.index < this.Count();`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`*T _Interop_Vector::current(it: Iterator)`
`29`	`28`	`{`
`30`	`29`	`return this[it.index];`
`31`	`30`	`}`
`32`	`31`
	`32`	`+uint _Interop_Vector::Count()`
	`33`	`+{`
	`34`	`+ return (this.end - this.begin) as int / #sizeof T;`
	`35`	`+}`
	`36`	`+`
`33`	`37`	`string _Interop_Vector::log() => "Interop Vector";`
`34`	`38`
`35`	`39`	`state _Interop_Map_Node<Value>`
Original file line number	Diff line number	Diff line change
`@@ -20,15 +20,19 @@ Iterator _Interop_Vector::operator::in()`
`20`	`20`	`bool _Interop_Vector::next(it: Iterator)`
`21`	`21`	`{`
`22`	`22`	`it.index += 1;`
`23`		`- count := (this.end - this.begin) as int / #sizeof T;`
`24`		`- return it.index < count;`
	`23`	`+ return it.index < this.Count();`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`*T _Interop_Vector::current(it: Iterator)`
`28`	`27`	`{`
`29`	`28`	`return this[it.index];`
`30`	`29`	`}`
`31`	`30`
	`31`	`+uint _Interop_Vector::Count()`
	`32`	`+{`
	`33`	`+ return (this.end - this.begin) as int / #sizeof T;`
	`34`	`+}`
	`35`	`+`
`32`	`36`	`string _Interop_Vector::log() => "Interop Vector";`
`33`	`37`
`34`	`38`	`state _Interop_Map_Node<Value>`
Original file line number	Diff line number	Diff line change
`@@ -16,15 +16,15 @@ inline char* global = nullptr;`
`16`	`16`
`17`	`17`	`struct Interpreter`
`18`	`18`	`{`
`19`		`- char* stack;`
`20`		`- char* stackFrameStart;`
`21`		`- char* stackFrameEnd;`
	`19`	`+ volatile char* stack;`
	`20`	`+ volatile char* stackFrameStart;`
	`21`	`+ volatile char* stackFrameEnd;`
`22`	`22`	`int threadID;`
`23`	`23`	`DCCallVM* dcCallVM;`
`24`	`24`
`25`	`25`	`Interpreter(size_t stackSize)`
`26`	`26`	`{`
`27`		`- stack = new char[stackSize];`
	`27`	`+ stack = new volatile char[stackSize];`
`28`	`28`	`stackFrameStart = stack;`
`29`	`29`	`stackFrameEnd = stack;`
`30`	`30`	`dcCallVM = CreateDynCallVM();`
`@@ -121,7 +121,7 @@ struct Interpreter`
`121`	`121`	`threadID = CurrentThreadID();`
`122`	`122`	`}`
`123`	`123`
`124`		`- void* Interpret(SpiteIR::IR* ir)`
	`124`	`+ volatile void* Interpret(SpiteIR::IR* ir)`
`125`	`125`	`{`
`126`	`126`	`SpiteIR::Function* entry = ir->entry;`
`127`	`127`	`Initialize(ir, entry->parent);`
`@@ -169,23 +169,23 @@ struct Interpreter`
`169`	`169`	`{`
`170`	`170`	`SpiteIR::Operand& param = params->at(i);`
`171`	`171`	`SpiteIR::Argument* arg = args.at(i);`
`172`		`- CopyValue(param.reg, arg->value.type, stackFrameStart + offset, frame);`
	`172`	`+ CopyValue(param.reg, arg->value.type, (void*)(stackFrameStart + offset), frame);`
`173`	`173`	`offset += param.type->size;`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`		`- void* InterpretFunction(SpiteIR::Function* func, size_t start, eastl::vector<SpiteIR::Operand>* params = nullptr)`
	`177`	`+ volatile void* InterpretFunction(SpiteIR::Function* func, size_t start, eastl::vector<SpiteIR::Operand>* params = nullptr)`
`178`	`178`	`{`
`179`	`179`	`#ifdef _INTERPRETER_EXTS`
`180`	`180`	`RunFunctionExtensions(func, params, this);`
`181`	`181`	`#endif`
`182`	`182`
`183`		`- char* prevStackStart = stackFrameStart;`
`184`		`- char* prevStackEnd = stackFrameEnd;`
	`183`	`+ volatile char* prevStackStart = stackFrameStart;`
	`184`	`+ volatile char* prevStackEnd = stackFrameEnd;`
`185`	`185`	`stackFrameStart = stackFrameStart + start;`
`186`	`186`	`InterpretAllocations(func->block->allocations);`
`187`	`187`
`188`		`- if (params) MoveParams(params, func->arguments, prevStackStart);`
	`188`	`+ if (params) MoveParams(params, func->arguments, (char*)prevStackStart);`
`189`	`189`
`190`	`190`	`InterpretBlock(func->block);`
`191`	`191`	`stackFrameStart = prevStackStart;`
`@@ -204,8 +204,8 @@ struct Interpreter`
`204`	`204`	`RunFunctionExtensions(func, &params, this);`
`205`	`205`	`#endif`
`206`	`206`
`207`		`- char* prevStackStart = stackFrameStart;`
`208`		`- char* prevStackEnd = stackFrameEnd;`
	`207`	`+ volatile char* prevStackStart = stackFrameStart;`
	`208`	`+ volatile char* prevStackEnd = stackFrameEnd;`
`209`	`209`	`stackFrameStart = stackFrameEnd;`
`210`	`210`	`InterpretAllocations(func->block->allocations);`
`211`	`211`
`@@ -221,18 +221,18 @@ struct Interpreter`
`221`	`221`	`InterpretBlock(func->block);`
`222`	`222`	`stackFrameStart = prevStackStart;`
`223`	`223`	`stackFrameEnd = prevStackEnd;`
`224`		`- return stackFrameStart;`
	`224`	`+ return (void*)stackFrameStart;`
`225`	`225`	`}`
`226`	`226`
`227`		`- inline void CopyValue(size_t src, SpiteIR::Type* type, void* dst, char* frame)`
	`227`	`+ inline void CopyValue(size_t src, SpiteIR::Type* type, volatile void* dst, volatile char* frame)`
`228`	`228`	`{`
`229`		`- memcpy(dst, frame + src, type->size);`
	`229`	`+ memcpy((void)dst, (void)(frame + src), type->size);`
`230`	`230`	`}`
`231`	`231`
`232`		`- inline void CopyRegValue(SpiteIR::Operand& src, SpiteIR::Operand& dst, char* frame)`
	`232`	`+ inline void CopyRegValue(SpiteIR::Operand& src, SpiteIR::Operand& dst, volatile char* frame)`
`233`	`233`	`{`
`234`		`- void* dstPtr = stackFrameStart + dst.reg;`
`235`		`- memcpy(dstPtr, frame + src.reg, dst.type->size);`
	`234`	`+ void* dstPtr = (void*)(stackFrameStart + dst.reg);`
	`235`	`+ memcpy(dstPtr, (void*)(frame + src.reg), dst.type->size);`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`inline void InterpretInstruction(SpiteIR::Instruction& inst, SpiteIR::Label*& label)`
`@@ -385,7 +385,7 @@ struct Interpreter`
`385`	`385`	`StoreOperand(src, stackFrameStart + storeInst.store.dst.reg);`
`386`	`386`	`}`
`387`	`387`
`388`		`- inline void StoreOperand(SpiteIR::Operand& src, void* dst)`
	`388`	`+ inline void StoreOperand(SpiteIR::Operand& src, volatile void* dst)`
`389`	`389`	`{`
`390`	`390`	`switch (src.kind)`
`391`	`391`	`{`
`@@ -477,7 +477,7 @@ struct Interpreter`
`477`	`477`	`inline void InterpretStorePtr(SpiteIR::Instruction& storeInst)`
`478`	`478`	`{`
`479`	`479`	`char* ptr = (char)(void)(stackFrameStart + storeInst.store.dst.reg);`
`480`		`- char* src = stackFrameStart + storeInst.store.src.reg;`
	`480`	`+ char* src = (char*)(stackFrameStart + storeInst.store.src.reg);`
`481`	`481`	`memcpy(ptr, src, storeInst.store.src.type->size);`
`482`	`482`	`}`
`483`	`483`
`@@ -490,14 +490,14 @@ struct Interpreter`
`490`	`490`
`491`	`491`	`inline void InterpretReference(SpiteIR::Instruction& storeInst)`
`492`	`492`	`{`
`493`		`- void* ref = (stackFrameStart + storeInst.store.src.reg);`
	`493`	`+ volatile void* ref = stackFrameStart + storeInst.store.src.reg;`
`494`	`494`	`(size_t)(stackFrameStart + storeInst.store.dst.reg) = (size_t)ref;`
`495`	`495`	`}`
`496`	`496`
`497`	`497`	`inline void InterpretDereference(SpiteIR::Instruction& storeInst)`
`498`	`498`	`{`
`499`	`499`	`char* ptr = (char)(void)(stackFrameStart + storeInst.store.src.reg);`
`500`		`- char* dst = stackFrameStart + storeInst.store.dst.reg;`
	`500`	`+ char* dst = (char*)(stackFrameStart + storeInst.store.dst.reg);`
`501`	`501`	`memcpy(dst, ptr, storeInst.store.dst.type->size);`
`502`	`502`	`}`
`503`	`503`
`@@ -723,7 +723,7 @@ struct Interpreter`
`723`	`723`	`paramPtrs.push_back((void*)(stackFrameStart + param.reg));`
`724`	`724`	`}`
`725`	`725`
`726`		`- CallExternalFunction(func, paramPtrs, stackFrameStart + dst, dcCallVM, this);`
	`726`	`+ CallExternalFunction(func, paramPtrs, (char*)(stackFrameStart + dst), dcCallVM, this);`
`727`	`727`	`}`
`728`	`728`
`729`	`729`	`inline void InterpretCall(SpiteIR::Instruction& callInst)`