Skip to content

Commit

Permalink
Fix wrong types when storing and simplify helpers slightly
Browse files Browse the repository at this point in the history
  • Loading branch information
@dpjudas
dpjudas committed May 13, 2020
1 parent 635ce6c commit e074bb2
Show file tree
Hide file tree
Showing 6 changed files with 99 additions and 100 deletions.
12 changes: 6 additions & 6 deletions src/common/scripting/jit/jit.cpp
View file
Expand Up @@ -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)
{
Expand All @@ -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++);
}
}

Expand Down Expand Up @@ -379,8 +379,8 @@ void JitCompiler::SetupFullVMFrame()
{
vmframestack = cc.CreateCall(GetNativeFunc<VMFrameStack*, VMScriptFunction*, VMValue*, int>("__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);
Expand All @@ -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)
Expand Down
56 changes: 28 additions & 28 deletions src/common/scripting/jit/jit_call.cpp
View file
Expand Up @@ -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);
}

Expand Down Expand Up @@ -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<int, VMFunction*, VMValue*, int, VMReturn*, int>()), { vmfunc, paramsptr, ConstValueD(B), GetCallReturns(), ConstValueD(C) });
//call->setComment(target ? target->PrintableName.GetChars() : "VMCall");
Expand All @@ -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;
}

Expand All @@ -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;
Expand All @@ -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:
Expand Down Expand Up @@ -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");
Expand All @@ -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:
Expand All @@ -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)));
}
}

Expand Down Expand Up @@ -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");
Expand Down
38 changes: 19 additions & 19 deletions src/common/scripting/jit/jit_flow.cpp
View file
Expand Up @@ -87,53 +87,53 @@ 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;
switch (regtype & REGT_TYPE)
{
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;
Expand All @@ -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;
}
Expand Down Expand Up @@ -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)
{
Expand Down
30 changes: 15 additions & 15 deletions src/common/scripting/jit/jit_load.cpp
View file
Expand Up @@ -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);
}

Expand All @@ -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);
}

Expand All @@ -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()
Expand Down

0 comments on commit e074bb2

Please sign in to comment.