diff --git a/src/common/scripting/jit/jit.cpp b/src/common/scripting/jit/jit.cpp index 189c7185a16..3832117a078 100644 --- a/src/common/scripting/jit/jit.cpp +++ b/src/common/scripting/jit/jit.cpp @@ -323,7 +323,7 @@ void JitCompiler::SetupSimpleFrame() const PType *type = sfunc->Proto->ArgumentTypes[i]; if (sfunc->ArgFlags.Size() && sfunc->ArgFlags[i] & (VARF_Out | VARF_Ref)) { - StoreA(Load(ToPtrPtr(args, argsPos++ * sizeof(VMValue) + offsetof(VMValue, a))), rega++); + StoreA(Load(ToInt8PtrPtr(args, argsPos++ * sizeof(VMValue) + offsetof(VMValue, a))), rega++); } else if (type == TypeVector2) { @@ -350,7 +350,7 @@ void JitCompiler::SetupSimpleFrame() } else { - StoreA(Load(ToPtrPtr(args, argsPos++ * sizeof(VMValue) + offsetof(VMValue, a))), rega++); + StoreA(Load(ToInt8PtrPtr(args, argsPos++ * sizeof(VMValue) + offsetof(VMValue, a))), rega++); } } @@ -379,8 +379,8 @@ void JitCompiler::SetupFullVMFrame() { vmframestack = cc.CreateCall(GetNativeFunc("__CreateFullVMFrame", CreateFullVMFrame), { ConstValueA(sfunc), args, numargs }); - IRValue* Blocks = Load(ToPtrPtr(vmframestack)); // vmframestack->Blocks - vmframe = Load(ToPtrPtr(Blocks, VMFrameStack::OffsetLastFrame())); // Blocks->LastFrame + IRValue* Blocks = Load(ToInt8PtrPtr(vmframestack)); // vmframestack->Blocks + vmframe = Load(ToInt8PtrPtr(Blocks, VMFrameStack::OffsetLastFrame())); // Blocks->LastFrame for (int i = 0; i < sfunc->NumRegD; i++) StoreD(Load(ToInt32Ptr(vmframe, offsetD + i * sizeof(int32_t))), i); @@ -389,10 +389,10 @@ void JitCompiler::SetupFullVMFrame() StoreF(Load(ToDoublePtr(vmframe, offsetF + i * sizeof(double))), i); for (int i = 0; i < sfunc->NumRegS; i++) - StoreS(Load(ToPtrPtr(vmframe, offsetS + i * sizeof(FString))), i); + StoreS(Load(ToInt8PtrPtr(vmframe, offsetS + i * sizeof(FString))), i); for (int i = 0; i < sfunc->NumRegA; i++) - StoreA(Load(ToPtrPtr(vmframe, offsetA + i * sizeof(void*))), i); + StoreA(Load(ToInt8PtrPtr(vmframe, offsetA + i * sizeof(void*))), i); } static void PopFullVMFrame(VMFrameStack * vmframestack) diff --git a/src/common/scripting/jit/jit_call.cpp b/src/common/scripting/jit/jit_call.cpp index caa373f743e..4329ef63bba 100644 --- a/src/common/scripting/jit/jit_call.cpp +++ b/src/common/scripting/jit/jit_call.cpp @@ -37,9 +37,9 @@ void JitCompiler::EmitVtbl(const VMOP *op) cc.SetInsertPoint(continuebb); IRValue* ptrObject = LoadA(b); - IRValue* ptrClass = Load(ToPtrPtr(ptrObject, ConstValueD(myoffsetof(DObject, Class)))); - IRValue* ptrArray = Load(ToPtrPtr(ptrClass, ConstValueD(myoffsetof(PClass, Virtuals) + myoffsetof(FArray, Array)))); - IRValue* ptrFunc = Load(ToPtrPtr(ptrArray, ConstValueD(c * (int)sizeof(void*)))); + IRValue* ptrClass = Load(ToInt8PtrPtr(ptrObject, ConstValueD(myoffsetof(DObject, Class)))); + IRValue* ptrArray = Load(ToInt8PtrPtr(ptrClass, ConstValueD(myoffsetof(PClass, Virtuals) + myoffsetof(FArray, Array)))); + IRValue* ptrFunc = Load(ToInt8PtrPtr(ptrArray, ConstValueD(c * (int)sizeof(void*)))); StoreA(ptrFunc, a); } @@ -83,7 +83,7 @@ void JitCompiler::EmitVMCall(IRValue* vmfunc, VMFunction* target) FillReturns(pc + 1, C); IRValue* paramsptr = OffsetPtr(vmframe, offsetParams); - IRValue* scriptcall = OffsetPtr(vmfunc, myoffsetof(VMScriptFunction, ScriptCall)); + IRValue* scriptcall = Load(ToInt8PtrPtr(vmfunc, myoffsetof(VMScriptFunction, ScriptCall))); /*IRValue* call =*/ cc.CreateCall(cc.CreateBitCast(scriptcall, GetFunctionType5()), { vmfunc, paramsptr, ConstValueD(B), GetCallReturns(), ConstValueD(C) }); //call->setComment(target ? target->PrintableName.GetChars() : "VMCall"); @@ -105,7 +105,7 @@ int JitCompiler::StoreCallParams() if (ParamOpcodes[i]->op == OP_PARAMI) { int abcs = ParamOpcodes[i]->i24; - Store32(ConstValueD(abcs), ToInt32Ptr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, i))); + Store(ConstValueD(abcs), ToInt32Ptr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, i))); continue; } @@ -114,53 +114,53 @@ int JitCompiler::StoreCallParams() switch (ParamOpcodes[i]->a) { case REGT_NIL: - StorePtr(ConstValueA(nullptr), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(ConstValueA(nullptr), ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_INT: - Store32(LoadD(bc), ToInt32Ptr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, i))); + Store(LoadD(bc), ToInt32Ptr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, i))); break; case REGT_INT | REGT_ADDROF: stackPtr = OffsetPtr(vmframe, offsetD + (int)(bc * sizeof(int32_t))); - Store32(LoadD(bc), ToInt32Ptr(stackPtr)); - StorePtr(stackPtr, OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(LoadD(bc), ToInt32Ptr(stackPtr)); + Store(stackPtr, ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_INT | REGT_KONST: - Store32(ConstD(bc), ToInt32Ptr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, i))); + Store(ConstD(bc), ToInt32Ptr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, i))); break; case REGT_STRING: - StorePtr(LoadS(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, sp))); + Store(LoadS(bc), ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, sp))); break; case REGT_STRING | REGT_ADDROF: - StorePtr(LoadS(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(LoadS(bc), ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_STRING | REGT_KONST: - StorePtr(ConstS(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, sp))); + Store(ConstS(bc), ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, sp))); break; case REGT_POINTER: - StorePtr(LoadA(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(LoadA(bc), ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_POINTER | REGT_ADDROF: stackPtr = OffsetPtr(vmframe, offsetA + (int)(bc * sizeof(void*))); - StorePtr(LoadA(bc), stackPtr); - StorePtr(stackPtr, OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(LoadA(bc), ToInt8PtrPtr(stackPtr)); + Store(stackPtr, ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_POINTER | REGT_KONST: - StorePtr(ConstA(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(ConstA(bc), ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_FLOAT: - StoreDouble(LoadF(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, f))); + Store(LoadF(bc), ToDoublePtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, f))); break; case REGT_FLOAT | REGT_MULTIREG2: for (int j = 0; j < 2; j++) { - StoreDouble(LoadF(bc + j), ToDoublePtr(vmframe, offsetParams + (slot + j) * sizeof(VMValue) + myoffsetof(VMValue, f))); + Store(LoadF(bc + j), ToDoublePtr(vmframe, offsetParams + (slot + j) * sizeof(VMValue) + myoffsetof(VMValue, f))); } numparams++; break; case REGT_FLOAT | REGT_MULTIREG3: for (int j = 0; j < 3; j++) { - StoreDouble(LoadF(bc + j), ToDoublePtr(vmframe, offsetParams + (slot + j) * sizeof(VMValue) + myoffsetof(VMValue, f))); + Store(LoadF(bc + j), ToDoublePtr(vmframe, offsetParams + (slot + j) * sizeof(VMValue) + myoffsetof(VMValue, f))); } numparams += 2; break; @@ -170,12 +170,12 @@ int JitCompiler::StoreCallParams() for (int j = 0; j < 3; j++) { if ((unsigned int)(bc + j) < regF.Size()) - StoreDouble(LoadF(bc + j), ToDoublePtr(stackPtr, j * sizeof(double))); + Store(LoadF(bc + j), ToDoublePtr(stackPtr, j * sizeof(double))); } - StorePtr(stackPtr, OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); + Store(stackPtr, ToInt8PtrPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, a))); break; case REGT_FLOAT | REGT_KONST: - StoreDouble(ConstF(bc), OffsetPtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, f))); + Store(ConstF(bc), ToDoublePtr(vmframe, offsetParams + slot * sizeof(VMValue) + myoffsetof(VMValue, f))); break; default: @@ -241,7 +241,7 @@ void JitCompiler::LoadCallResult(int type, int regnum, bool addrof) // We don't have to do anything in this case. String values are never moved to virtual registers. break; case REGT_POINTER: - StoreA(Load(ToPtrPtr(vmframe, offsetA + regnum * sizeof(void*))), regnum); + StoreA(Load(ToInt8PtrPtr(vmframe, offsetA + regnum * sizeof(void*))), regnum); break; default: I_Error("Unknown OP_RESULT/OP_PARAM type encountered in LoadCallResult\n"); @@ -266,7 +266,7 @@ void JitCompiler::FillReturns(const VMOP *retval, int numret) I_Error("OP_RESULT with REGT_KONST is not allowed\n"); } - IRValue* valueptr; + IRValue* valueptr = nullptr; switch (type & REGT_TYPE) { case REGT_INT: @@ -286,8 +286,8 @@ void JitCompiler::FillReturns(const VMOP *retval, int numret) break; } - StorePtr(valueptr, ToPtrPtr(GetCallReturns(), i * sizeof(VMReturn) + myoffsetof(VMReturn, Location))); - Store8(ConstValueD(type), ToPtrPtr(GetCallReturns(), i * sizeof(VMReturn) + myoffsetof(VMReturn, RegType))); + Store(valueptr, ToInt8PtrPtr(GetCallReturns(), i * sizeof(VMReturn) + myoffsetof(VMReturn, Location))); + Store(Trunc8(ConstValueD(type)), ToInt8Ptr(GetCallReturns(), i * sizeof(VMReturn) + myoffsetof(VMReturn, RegType))); } } @@ -497,7 +497,7 @@ void JitCompiler::EmitNativeCall(VMNativeFunction *target) // We don't have to do anything in this case. String values are never moved to virtual registers. break; case REGT_POINTER: - StoreA(Load(ToPtrPtr(vmframe, offsetA + regnum * sizeof(void*))), regnum); + StoreA(Load(ToInt8PtrPtr(vmframe, offsetA + regnum * sizeof(void*))), regnum); break; default: I_Error("Unknown OP_RESULT type encountered\n"); diff --git a/src/common/scripting/jit/jit_flow.cpp b/src/common/scripting/jit/jit_flow.cpp index 0999fcc2c09..6cba24f4643 100644 --- a/src/common/scripting/jit/jit_flow.cpp +++ b/src/common/scripting/jit/jit_flow.cpp @@ -87,7 +87,7 @@ void JitCompiler::EmitRET() cc.CreateCondBr(cc.CreateICmpSLE(ConstValueD(retnum), numret), ifbb, endifbb); cc.SetInsertPoint(ifbb); - IRValue* location = Load(ToPtrPtr(ret, retnum * sizeof(VMReturn))); + IRValue* location = Load(ToInt8PtrPtr(ret, retnum * sizeof(VMReturn))); int regtype = B; int regnum = C; @@ -95,45 +95,45 @@ void JitCompiler::EmitRET() { case REGT_INT: if (regtype & REGT_KONST) - Store32(ConstD(regnum), ToInt32Ptr(location)); + Store(ConstD(regnum), ToInt32Ptr(location)); else - Store32(LoadD(regnum), ToInt32Ptr(location)); + Store(LoadD(regnum), ToInt32Ptr(location)); break; case REGT_FLOAT: if (regtype & REGT_KONST) { if (regtype & REGT_MULTIREG3) { - StoreDouble(ConstF(regnum), ToDoublePtr(location)); - StoreDouble(ConstF(regnum + 1), ToDoublePtr(location, 8)); - StoreDouble(ConstF(regnum + 2), ToDoublePtr(location, 16)); + Store(ConstF(regnum), ToDoublePtr(location)); + Store(ConstF(regnum + 1), ToDoublePtr(location, 8)); + Store(ConstF(regnum + 2), ToDoublePtr(location, 16)); } else if (regtype & REGT_MULTIREG2) { - StoreDouble(ConstF(regnum), ToDoublePtr(location)); - StoreDouble(ConstF(regnum + 1), ToDoublePtr(location, 8)); + Store(ConstF(regnum), ToDoublePtr(location)); + Store(ConstF(regnum + 1), ToDoublePtr(location, 8)); } else { - StoreDouble(ConstF(regnum), ToDoublePtr(location)); + Store(ConstF(regnum), ToDoublePtr(location)); } } else { if (regtype & REGT_MULTIREG3) { - StoreDouble(LoadF(regnum), ToDoublePtr(location)); - StoreDouble(LoadF(regnum + 1), ToDoublePtr(location, 8)); - StoreDouble(LoadF(regnum + 2), ToDoublePtr(location, 16)); + Store(LoadF(regnum), ToDoublePtr(location)); + Store(LoadF(regnum + 1), ToDoublePtr(location, 8)); + Store(LoadF(regnum + 2), ToDoublePtr(location, 16)); } else if (regtype & REGT_MULTIREG2) { - StoreDouble(LoadF(regnum), ToDoublePtr(location)); - StoreDouble(LoadF(regnum + 1), ToDoublePtr(location, 8)); + Store(LoadF(regnum), ToDoublePtr(location)); + Store(LoadF(regnum + 1), ToDoublePtr(location, 8)); } else { - StoreDouble(LoadF(regnum), ToDoublePtr(location)); + Store(LoadF(regnum), ToDoublePtr(location)); } } break; @@ -145,11 +145,11 @@ void JitCompiler::EmitRET() case REGT_POINTER: if (regtype & REGT_KONST) { - StorePtr(ConstA(regnum), ToPtrPtr(location)); + Store(ConstA(regnum), ToInt8PtrPtr(location)); } else { - StorePtr(LoadA(regnum), ToPtrPtr(location)); + Store(LoadA(regnum), ToInt8PtrPtr(location)); } break; } @@ -185,8 +185,8 @@ void JitCompiler::EmitRETI() cc.CreateCondBr(cc.CreateICmpSLE(ConstValueD(retnum), numret), ifbb, endifbb); cc.SetInsertPoint(ifbb); - IRValue* location = Load(ToPtrPtr(ret, retnum * sizeof(VMReturn))); - Store32(ConstValueD(BCs), ToInt32Ptr(location)); + IRValue* location = Load(ToInt8PtrPtr(ret, retnum * sizeof(VMReturn))); + Store(ConstValueD(BCs), ToInt32Ptr(location)); if (a & RET_FINAL) { diff --git a/src/common/scripting/jit/jit_load.cpp b/src/common/scripting/jit/jit_load.cpp index c2523711631..1c8678e3c94 100644 --- a/src/common/scripting/jit/jit_load.cpp +++ b/src/common/scripting/jit/jit_load.cpp @@ -67,8 +67,8 @@ void JitCompiler::EmitMETA() cc.SetInsertPoint(continuebb); IRValue* ptrObject = LoadA(B); - IRValue* ptrClass = Load(ToPtrPtr(ptrObject, ConstValueD(myoffsetof(DObject, Class)))); - IRValue* ptrMeta = Load(ToPtrPtr(ptrClass, ConstValueD(myoffsetof(PClass, Meta)))); + IRValue* ptrClass = Load(ToInt8PtrPtr(ptrObject, ConstValueD(myoffsetof(DObject, Class)))); + IRValue* ptrMeta = Load(ToInt8PtrPtr(ptrClass, ConstValueD(myoffsetof(PClass, Meta)))); StoreA(ptrMeta, A); } @@ -80,7 +80,7 @@ void JitCompiler::EmitCLSS() cc.SetInsertPoint(continuebb); IRValue* ptrObject = LoadA(B); - IRValue* ptrClass = Load(ToPtrPtr(ptrObject, ConstValueD(myoffsetof(DObject, Class)))); + IRValue* ptrClass = Load(ToInt8PtrPtr(ptrObject, ConstValueD(myoffsetof(DObject, Class)))); StoreA(ptrClass, A); } @@ -90,73 +90,73 @@ void JitCompiler::EmitCLSS() void JitCompiler::EmitLB() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadSExt(ToInt8Ptr(LoadA(B), ConstD(C))), A); + StoreD(SExt(Load(ToInt8Ptr(LoadA(B), ConstD(C)))), A); } void JitCompiler::EmitLB_R() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadSExt(ToInt8Ptr(LoadA(B), LoadD(C))), A); + StoreD(SExt(Load(ToInt8Ptr(LoadA(B), LoadD(C)))), A); } void JitCompiler::EmitLH() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadSExt(ToInt16Ptr(LoadA(B), ConstD(C))), A); + StoreD(SExt(Load(ToInt16Ptr(LoadA(B), ConstD(C)))), A); } void JitCompiler::EmitLH_R() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadSExt(ToInt16Ptr(LoadA(B), LoadD(C))), A); + StoreD(SExt(Load(ToInt16Ptr(LoadA(B), LoadD(C)))), A); } void JitCompiler::EmitLW() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadSExt(ToInt32Ptr(LoadA(B), ConstD(C))), A); + StoreD(SExt(Load(ToInt32Ptr(LoadA(B), ConstD(C)))), A); } void JitCompiler::EmitLW_R() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadSExt(ToInt32Ptr(LoadA(B), LoadD(C))), A); + StoreD(SExt(Load(ToInt32Ptr(LoadA(B), LoadD(C)))), A); } void JitCompiler::EmitLBU() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadZExt(ToInt8Ptr(LoadA(B), ConstD(C))), A); + StoreD(ZExt(Load(ToInt8Ptr(LoadA(B), ConstD(C)))), A); } void JitCompiler::EmitLBU_R() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadZExt(ToInt8Ptr(LoadA(B), LoadD(C))), A); + StoreD(ZExt(Load(ToInt8Ptr(LoadA(B), LoadD(C)))), A); } void JitCompiler::EmitLHU() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadZExt(ToInt16Ptr(LoadA(B), ConstD(C))), A); + StoreD(ZExt(Load(ToInt16Ptr(LoadA(B), ConstD(C)))), A); } void JitCompiler::EmitLHU_R() { EmitNullPointerThrow(B, X_READ_NIL); - StoreD(LoadZExt(ToInt16Ptr(LoadA(B), LoadD(C))), A); + StoreD(ZExt(Load(ToInt16Ptr(LoadA(B), LoadD(C)))), A); } void JitCompiler::EmitLSP() { EmitNullPointerThrow(B, X_READ_NIL); - StoreF(LoadFPExt(ToDoublePtr(LoadA(B), ConstD(C))), A); + StoreF(FPExt(Load(ToDoublePtr(LoadA(B), ConstD(C)))), A); } void JitCompiler::EmitLSP_R() { EmitNullPointerThrow(B, X_READ_NIL); - StoreF(LoadFPExt(ToDoublePtr(LoadA(B), LoadD(C))), A); + StoreF(FPExt(Load(ToDoublePtr(LoadA(B), LoadD(C)))), A); } void JitCompiler::EmitLDP() diff --git a/src/common/scripting/jit/jit_store.cpp b/src/common/scripting/jit/jit_store.cpp index 0c9539328b1..fc9f925442a 100644 --- a/src/common/scripting/jit/jit_store.cpp +++ b/src/common/scripting/jit/jit_store.cpp @@ -4,61 +4,61 @@ void JitCompiler::EmitSB() { EmitNullPointerThrow(A, X_WRITE_NIL); - Store8(LoadD(B), ToInt8Ptr(LoadA(A), ConstD(C))); + Store(Trunc8(LoadD(B)), ToInt8Ptr(LoadA(A), ConstD(C))); } void JitCompiler::EmitSB_R() { EmitNullPointerThrow(A, X_WRITE_NIL); - Store8(LoadD(B), ToInt8Ptr(LoadA(A), LoadD(C))); + Store(Trunc8(LoadD(B)), ToInt8Ptr(LoadA(A), LoadD(C))); } void JitCompiler::EmitSH() { EmitNullPointerThrow(A, X_WRITE_NIL); - Store16(LoadD(B), ToInt16Ptr(LoadA(A), ConstD(C))); + Store(Trunc16(LoadD(B)), ToInt16Ptr(LoadA(A), ConstD(C))); } void JitCompiler::EmitSH_R() { EmitNullPointerThrow(A, X_WRITE_NIL); - Store16(LoadD(B), ToInt16Ptr(LoadA(A), LoadD(C))); + Store(Trunc16(LoadD(B)), ToInt16Ptr(LoadA(A), LoadD(C))); } void JitCompiler::EmitSW() { EmitNullPointerThrow(A, X_WRITE_NIL); - Store32(LoadD(B), ToInt32Ptr(LoadA(A), ConstD(C))); + Store(LoadD(B), ToInt32Ptr(LoadA(A), ConstD(C))); } void JitCompiler::EmitSW_R() { EmitNullPointerThrow(A, X_WRITE_NIL); - Store32(LoadD(B), ToInt32Ptr(LoadA(A), LoadD(C))); + Store(LoadD(B), ToInt32Ptr(LoadA(A), LoadD(C))); } void JitCompiler::EmitSSP() { EmitNullPointerThrow(A, X_WRITE_NIL); - StoreFloat(LoadF(B), ToFloatPtr(LoadA(A), ConstD(C))); + Store(FPTrunc(LoadF(B)), ToFloatPtr(LoadA(A), ConstD(C))); } void JitCompiler::EmitSSP_R() { EmitNullPointerThrow(A, X_WRITE_NIL); - StoreFloat(LoadF(B), ToFloatPtr(LoadA(A), LoadD(C))); + Store(FPTrunc(LoadF(B)), ToFloatPtr(LoadA(A), LoadD(C))); } void JitCompiler::EmitSDP() { EmitNullPointerThrow(A, X_WRITE_NIL); - StoreDouble(LoadF(B), ToDoublePtr(LoadA(A), ConstD(C))); + Store(LoadF(B), ToDoublePtr(LoadA(A), ConstD(C))); } void JitCompiler::EmitSDP_R() { EmitNullPointerThrow(A, X_WRITE_NIL); - StoreDouble(LoadF(B), ToDoublePtr(LoadA(A), LoadD(C))); + Store(LoadF(B), ToDoublePtr(LoadA(A), LoadD(C))); } void JitCompiler::EmitSS() @@ -103,34 +103,34 @@ void JitCompiler::EmitSV2() { EmitNullPointerThrow(A, X_WRITE_NIL); IRValue* base = ToDoublePtr(LoadA(A), ConstD(C)); - StoreDouble(LoadF(B), base); - StoreDouble(LoadF(B + 1), OffsetPtr(base, 1)); + Store(LoadF(B), base); + Store(LoadF(B + 1), OffsetPtr(base, 1)); } void JitCompiler::EmitSV2_R() { EmitNullPointerThrow(A, X_WRITE_NIL); IRValue* base = ToDoublePtr(LoadA(A), LoadD(C)); - StoreDouble(LoadF(B), base); - StoreDouble(LoadF(B + 1), OffsetPtr(base, 1)); + Store(LoadF(B), base); + Store(LoadF(B + 1), OffsetPtr(base, 1)); } void JitCompiler::EmitSV3() { EmitNullPointerThrow(A, X_WRITE_NIL); IRValue* base = ToDoublePtr(LoadA(A), ConstD(C)); - StoreDouble(LoadF(B), base); - StoreDouble(LoadF(B + 1), OffsetPtr(base, 1)); - StoreDouble(LoadF(B + 2), OffsetPtr(base, 2)); + Store(LoadF(B), base); + Store(LoadF(B + 1), OffsetPtr(base, 1)); + Store(LoadF(B + 2), OffsetPtr(base, 2)); } void JitCompiler::EmitSV3_R() { EmitNullPointerThrow(A, X_WRITE_NIL); IRValue* base = ToDoublePtr(LoadA(A), LoadD(C)); - StoreDouble(LoadF(B), base); - StoreDouble(LoadF(B + 1), OffsetPtr(base, 1)); - StoreDouble(LoadF(B + 2), OffsetPtr(base, 2)); + Store(LoadF(B), base); + Store(LoadF(B + 1), OffsetPtr(base, 1)); + Store(LoadF(B + 2), OffsetPtr(base, 2)); } void JitCompiler::EmitSBIT() diff --git a/src/common/scripting/jit/jitintern.h b/src/common/scripting/jit/jitintern.h index a41710a0dd2..330e310adde 100644 --- a/src/common/scripting/jit/jitintern.h +++ b/src/common/scripting/jit/jitintern.h @@ -192,6 +192,7 @@ class JitCompiler IRValue* OffsetPtr(IRValue* ptr, IRValue* offset) { return cc.CreateGEP(ptr, { offset }); } IRValue* OffsetPtr(IRValue* ptr, int offset) { return cc.CreateGEP(ptr, { ircontext->getConstantInt(offset) }); } IRValue* ToInt8Ptr(IRValue* ptr, IRValue* offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt8PtrTy()); } + IRValue* ToInt8Ptr(IRValue* ptr, int offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt8PtrTy()); } IRValue* ToInt16Ptr(IRValue* ptr, IRValue* offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt16PtrTy()); } IRValue* ToInt32Ptr(IRValue* ptr, IRValue* offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt32PtrTy()); } IRValue* ToInt32Ptr(IRValue* ptr) { return cc.CreateBitCast(ptr, ircontext->getInt32PtrTy()); } @@ -200,18 +201,16 @@ class JitCompiler IRValue* ToDoublePtr(IRValue* ptr, IRValue* offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getDoublePtrTy()); } IRValue* ToDoublePtr(IRValue* ptr, int offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getDoublePtrTy()); } IRValue* ToDoublePtr(IRValue* ptr) { return cc.CreateBitCast(ptr, ircontext->getDoublePtrTy()); } - IRValue* ToPtrPtr(IRValue* ptr, IRValue* offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt8PtrTy()->getPointerTo(ircontext)); } - IRValue* ToPtrPtr(IRValue* ptr, int offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt8PtrTy()->getPointerTo(ircontext)); } - IRValue* ToPtrPtr(IRValue* ptr) { return cc.CreateBitCast(ptr, ircontext->getInt8PtrTy()->getPointerTo(ircontext)); } - void Store8(IRValue* value, IRValue* ptr) { cc.CreateStore(cc.CreateTrunc(value, ircontext->getInt8Ty()), ptr); } - void Store16(IRValue* value, IRValue* ptr) { cc.CreateStore(cc.CreateTrunc(value, ircontext->getInt16Ty()), ptr); } - void Store32(IRValue* value, IRValue* ptr) { cc.CreateStore(value, ptr); } - void StoreFloat(IRValue* value, IRValue* ptr) { cc.CreateStore(cc.CreateFPTrunc(value, ircontext->getFloatTy()), ptr); } - void StoreDouble(IRValue* value, IRValue* ptr) { cc.CreateStore(value, ptr); } - void StorePtr(IRValue* value, IRValue* ptr) { cc.CreateStore(value, ptr); } - IRValue* LoadZExt(IRValue* ptr) { return cc.CreateZExt(cc.CreateLoad(ptr), ircontext->getInt32Ty()); } - IRValue* LoadSExt(IRValue* ptr) { return cc.CreateSExt(cc.CreateLoad(ptr), ircontext->getInt32Ty()); } - IRValue* LoadFPExt(IRValue* ptr) { return cc.CreateFPExt(cc.CreateLoad(ptr), ircontext->getDoubleTy()); } + IRValue* ToInt8PtrPtr(IRValue* ptr, IRValue* offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt8PtrTy()->getPointerTo(ircontext)); } + IRValue* ToInt8PtrPtr(IRValue* ptr, int offset) { return cc.CreateBitCast(OffsetPtr(ptr, offset), ircontext->getInt8PtrTy()->getPointerTo(ircontext)); } + IRValue* ToInt8PtrPtr(IRValue* ptr) { return cc.CreateBitCast(ptr, ircontext->getInt8PtrTy()->getPointerTo(ircontext)); } + IRValue* Trunc8(IRValue* value) { return cc.CreateTrunc(value, ircontext->getInt8Ty()); } + IRValue* Trunc16(IRValue* value) { return cc.CreateTrunc(value, ircontext->getInt16Ty()); } + IRValue* FPTrunc(IRValue* value) { return cc.CreateFPTrunc(value, ircontext->getFloatTy()); } + IRValue* ZExt(IRValue* value) { return cc.CreateZExt(value, ircontext->getInt32Ty()); } + IRValue* SExt(IRValue* value) { return cc.CreateSExt(value, ircontext->getInt32Ty()); } + IRValue* FPExt(IRValue* value) { return cc.CreateFPExt(value, ircontext->getDoubleTy()); } + void Store(IRValue* value, IRValue* ptr) { cc.CreateStore(value, ptr); } IRValue* Load(IRValue* ptr) { return cc.CreateLoad(ptr); } static void CallAssignString(FString* to, FString* from) { *to = *from; }