zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-11 23:32:02 +00:00
Code Issues Projects Releases Packages Wiki Activity

- implement most of the integer math opcodes

Browse source
This commit is contained in:
Magnus Norddahl 2018-08-12 04:34:57 +02:00
parent cbb945d8a7
commit 7108fd6228
1 changed files with 143 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

143
src/scripting/vm/jit.cpp
View file

@ -103,6 +103,48 @@ static bool CanJit(VMScriptFunction *sfunc)
} }
break; break;
case OP_RETI: case OP_RETI:
case OP_SLL_RR:
case OP_SLL_RI:
case OP_SLL_KR:
case OP_SRL_RR:
case OP_SRL_RI:
case OP_SRL_KR:
case OP_SRA_RR:
case OP_SRA_RI:
case OP_SRA_KR:
case OP_ADD_RR:
case OP_ADD_RK:
case OP_ADDI:
case OP_SUB_RR:
case OP_SUB_RK:
case OP_SUB_KR:
case OP_MUL_RR:
case OP_MUL_RK:
case OP_DIV_RR:
case OP_DIV_RK:
case OP_DIV_KR:
case OP_DIVU_RR:
case OP_DIVU_RK:
case OP_DIVU_KR:
//case OP_MOD_RR:
//case OP_MOD_RK:
//case OP_MOD_KR:
//case OP_MODU_RR:
//case OP_MODU_RK:
//case OP_MODU_KR:
case OP_AND_RR:
case OP_AND_RK:
case OP_OR_RR:
case OP_OR_RK:
case OP_XOR_RR:
case OP_XOR_RK:
//case OP_MIN_RR:
//case OP_MIN_RK:
//case OP_MAX_RR:
//case OP_MAX_RK:
//case OP_ABS:
case OP_NEG:
case OP_NOT:
break; break;
} }
} }
@ -431,47 +473,148 @@ JitFuncPtr JitCompile(VMScriptFunction *sfunc)
// Integer math. // Integer math.
case OP_SLL_RR: // dA = dkB << diC case OP_SLL_RR: // dA = dkB << diC
cc.mov(regD[a], regD[B]);
cc.shl(regD[a], regD[C]);
break;
case OP_SLL_RI: case OP_SLL_RI:
cc.mov(regD[a], regD[B]);
cc.shl(regD[a], C);
break;
case OP_SLL_KR: case OP_SLL_KR:
cc.mov(regD[a], konstd[B]);
cc.shl(regD[a], C);
break;
case OP_SRL_RR: // dA = dkB >> diC -- unsigned case OP_SRL_RR: // dA = dkB >> diC -- unsigned
cc.mov(regD[a], regD[B]);
cc.shr(regD[a], regD[C]);
break;
case OP_SRL_RI: case OP_SRL_RI:
cc.mov(regD[a], regD[B]);
cc.shr(regD[a], C);
break;
case OP_SRL_KR: case OP_SRL_KR:
cc.mov(regD[a], konstd[B]);
cc.shr(regD[a], C);
break;
case OP_SRA_RR: // dA = dkB >> diC -- signed case OP_SRA_RR: // dA = dkB >> diC -- signed
cc.mov(regD[a], regD[B]);
cc.sar(regD[a], regD[C]);
break;
case OP_SRA_RI: case OP_SRA_RI:
cc.mov(regD[a], regD[B]);
cc.sar(regD[a], C);
break;
case OP_SRA_KR: case OP_SRA_KR:
cc.mov(regD[a], konstd[B]);
cc.sar(regD[a], regD[C]);
break;
case OP_ADD_RR: // dA = dB + dkC case OP_ADD_RR: // dA = dB + dkC
cc.mov(regD[a], regD[B]);
cc.add(regD[a], regD[C]);
break;
case OP_ADD_RK: case OP_ADD_RK:
cc.mov(regD[a], regD[B]);
cc.add(regD[a], konstd[C]);
break;
case OP_ADDI: // dA = dB + C -- C is a signed 8-bit constant case OP_ADDI: // dA = dB + C -- C is a signed 8-bit constant
cc.mov(regD[a], regD[B]);
cc.add(regD[a], Cs);
break;
case OP_SUB_RR: // dA = dkB - dkC case OP_SUB_RR: // dA = dkB - dkC
cc.mov(regD[a], regD[B]);
cc.sub(regD[a], regD[C]);
break;
case OP_SUB_RK: case OP_SUB_RK:
cc.mov(regD[a], regD[B]);
cc.sub(regD[a], konstd[C]);
break;
case OP_SUB_KR: case OP_SUB_KR:
cc.mov(regD[a], konstd[B]);
cc.sub(regD[a], regD[C]);
break;
case OP_MUL_RR: // dA = dB * dkC case OP_MUL_RR: // dA = dB * dkC
cc.mov(regD[a], regD[B]);
cc.mul(regD[a], regD[C]);
break;
case OP_MUL_RK: case OP_MUL_RK:
cc.mov(regD[a], regD[B]);
cc.mul(regD[a], konstd[C]);
break;
case OP_DIV_RR: // dA = dkB / dkC (signed) case OP_DIV_RR: // dA = dkB / dkC (signed)
// To do: ThrowAbortException(X_DIVISION_BY_ZERO, nullptr);
cc.mov(regD[a], regD[B]);
cc.idiv(regD[a], regD[C]);
break;
case OP_DIV_RK: case OP_DIV_RK:
// To do: ThrowAbortException(X_DIVISION_BY_ZERO, nullptr);
cc.mov(regD[a], regD[B]);
cc.div(regD[a], konstd[C]);
break;
case OP_DIV_KR: case OP_DIV_KR:
// To do: ThrowAbortException(X_DIVISION_BY_ZERO, nullptr);
cc.mov(regD[a], konstd[B]);
cc.idiv(regD[a], regD[C]);
break;
case OP_DIVU_RR: // dA = dkB / dkC (unsigned) case OP_DIVU_RR: // dA = dkB / dkC (unsigned)
// To do: ThrowAbortException(X_DIVISION_BY_ZERO, nullptr);
cc.mov(regD[a], regD[B]);
cc.div(regD[a], regD[C]);
break;
case OP_DIVU_RK: case OP_DIVU_RK:
// To do: ThrowAbortException(X_DIVISION_BY_ZERO, nullptr);
cc.mov(regD[a], regD[B]);
cc.div(regD[a], konstd[C]);
break;
case OP_DIVU_KR: case OP_DIVU_KR:
// To do: ThrowAbortException(X_DIVISION_BY_ZERO, nullptr);
cc.mov(regD[a], konstd[B]);
cc.div(regD[a], regD[C]);
break;
case OP_MOD_RR: // dA = dkB % dkC (signed) case OP_MOD_RR: // dA = dkB % dkC (signed)
case OP_MOD_RK: case OP_MOD_RK:
case OP_MOD_KR: case OP_MOD_KR:
case OP_MODU_RR: // dA = dkB % dkC (unsigned) case OP_MODU_RR: // dA = dkB % dkC (unsigned)
case OP_MODU_RK: case OP_MODU_RK:
case OP_MODU_KR: case OP_MODU_KR:
break;
case OP_AND_RR: // dA = dB & dkC case OP_AND_RR: // dA = dB & dkC
cc.mov(regD[a], regD[B]);
cc.and_(regD[a], regD[C]);
break;
case OP_AND_RK: case OP_AND_RK:
cc.mov(regD[a], regD[B]);
cc.and_(regD[a], konstd[C]);
break;
case OP_OR_RR: // dA = dB | dkC case OP_OR_RR: // dA = dB | dkC
cc.mov(regD[a], regD[B]);
cc.or_(regD[a], regD[C]);
break;
case OP_OR_RK: case OP_OR_RK:
cc.mov(regD[a], regD[B]);
cc.or_(regD[a], konstd[C]);
break;
case OP_XOR_RR: // dA = dB ^ dkC case OP_XOR_RR: // dA = dB ^ dkC
cc.mov(regD[a], regD[B]);
cc.xor_(regD[a], regD[C]);
break;
case OP_XOR_RK: case OP_XOR_RK:
cc.mov(regD[a], regD[B]);
cc.xor_(regD[a], konstd[C]);
break;
case OP_MIN_RR: // dA = min(dB,dkC) case OP_MIN_RR: // dA = min(dB,dkC)
case OP_MIN_RK: case OP_MIN_RK:
case OP_MAX_RR: // dA = max(dB,dkC) case OP_MAX_RR: // dA = max(dB,dkC)
case OP_MAX_RK: case OP_MAX_RK:
case OP_ABS: // dA = abs(dB) case OP_ABS: // dA = abs(dB)
break;
case OP_NEG: // dA = -dB case OP_NEG: // dA = -dB
cc.xor_(regD[a], regD[a]);
cc.sub(regD[a], regD[B]);
break;
case OP_NOT: // dA = ~dB case OP_NOT: // dA = ~dB
cc.mov(regD[a], regD[B]);
cc.not_(regD[a]);
break;
case OP_EQ_R: // if ((dB == dkC) != A) then pc++ case OP_EQ_R: // if ((dB == dkC) != A) then pc++
case OP_EQ_K: case OP_EQ_K:
case OP_LT_RR: // if ((dkB < dkC) != A) then pc++ case OP_LT_RR: // if ((dkB < dkC) != A) then pc++