Compare commits
No commits in common. "c9798f4816e6603a9099c43839dbbce4ee23d6af" and "b130322de5e6cf90aeaef449e58080c54cc6c350" have entirely different histories.
c9798f4816
...
b130322de5
346
vm/vm.cpp
346
vm/vm.cpp
@ -128,24 +128,7 @@ void VM::initVariables(void) {
|
||||
}
|
||||
return;
|
||||
}
|
||||
bool VM::dstRegCheck(uint8_t reg) {
|
||||
if (reg == IP || reg == SP || reg == RP) {
|
||||
DBG_ERROR(("Invalid register!\n"));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool VM::srcDstRegCheck(uint8_t dst, uint8_t src) {
|
||||
if (dst == IP || dst == SP || dst == RP) {
|
||||
DBG_ERROR(("Invalid register!\n"));
|
||||
return false;
|
||||
}
|
||||
if (src == IP || src == SP || src == RP) {
|
||||
DBG_ERROR(("Invalid register!\n"));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
INSTRUCTIONS IMPLEMENTATIONS
|
||||
*/
|
||||
@ -159,7 +142,8 @@ bool VM::execMOVI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
imm = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("MOVI %s, 0x%x\n", getRegName(dst), imm));
|
||||
if (!dstRegCheck(dst)) {
|
||||
if (dst == IP) {
|
||||
DBG_ERROR(("Can't MOVI to IP!\n"));
|
||||
return false;
|
||||
}
|
||||
regs[dst] = imm;
|
||||
@ -176,7 +160,8 @@ bool VM::execMOVR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("MOVR %s, %s\n", getRegName(dst), getRegName(src)));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
if (dst == IP || src == IP) {
|
||||
DBG_ERROR(("Can't MOVR IP!\n"));
|
||||
return false;
|
||||
}
|
||||
regs[dst] = regs[src];
|
||||
@ -192,9 +177,6 @@ bool VM::execLODI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("LODI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = *((uint16_t *)&as.data[src]);
|
||||
return true;
|
||||
}
|
||||
@ -208,9 +190,6 @@ bool VM::execLODR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("LODR %s, %s\n", getRegName(dst), getRegName(src)));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = *((uint16_t *)&as.data[regs[src]]);
|
||||
return true;
|
||||
}
|
||||
@ -223,9 +202,6 @@ bool VM::execSTRI(void) {
|
||||
dst = *((uint16_t *)&as.code[regs[IP] + 1]);
|
||||
src = as.code[regs[IP] + 3];
|
||||
DBG_INFO(("STRI 0x%x, %s\n", dst, getRegName(src)));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
*((uint16_t *)&as.data[dst]) = regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -240,9 +216,6 @@ bool VM::execSTRR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("STRR %s, %s\n", getRegName(dst), getRegName(src)));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
*((uint16_t *)&as.data[regs[dst]]) = regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -257,9 +230,6 @@ bool VM::execADDI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("ADDI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] += src;
|
||||
return true;
|
||||
}
|
||||
@ -274,9 +244,6 @@ bool VM::execADDR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("ADDR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] += regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -291,9 +258,6 @@ bool VM::execSUBI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("SUBI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] -= src;
|
||||
return true;
|
||||
}
|
||||
@ -307,9 +271,6 @@ bool VM::execSUBR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("SUBR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] -= regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -323,9 +284,6 @@ bool VM::execANDB(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = as.code[regs[IP] + 2];
|
||||
DBG_INFO(("ANDB %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] &= src;
|
||||
return true;
|
||||
}
|
||||
@ -339,9 +297,6 @@ bool VM::execANDW(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("XORW %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] &= src;
|
||||
return true;
|
||||
}
|
||||
@ -355,9 +310,6 @@ bool VM::execANDR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("ANDR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] &= regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -371,9 +323,6 @@ bool VM::execYORB(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = as.code[regs[IP] + 2];
|
||||
DBG_INFO(("YORB %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] |= src;
|
||||
return true;
|
||||
}
|
||||
@ -387,9 +336,6 @@ bool VM::execYORW(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("XORW %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] |= src;
|
||||
return true;
|
||||
}
|
||||
@ -403,9 +349,6 @@ bool VM::execYORR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("XORR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] |= regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -419,9 +362,6 @@ bool VM::execXORB(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = as.code[regs[IP] + 2];
|
||||
DBG_INFO(("XORB %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] ^= src;
|
||||
return true;
|
||||
}
|
||||
@ -435,9 +375,6 @@ bool VM::execXORW(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("XORW %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] ^= src;
|
||||
return true;
|
||||
}
|
||||
@ -451,9 +388,6 @@ bool VM::execXORR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("XORR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] ^= regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -467,9 +401,6 @@ bool VM::execNOTR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("NOTR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = ~regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -483,9 +414,6 @@ bool VM::execMULI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("SUBI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] *= src;
|
||||
return true;
|
||||
}
|
||||
@ -499,9 +427,6 @@ bool VM::execMULR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("MULR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] *= regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -515,9 +440,6 @@ bool VM::execDIVI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("DIVI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] /= src;
|
||||
return true;
|
||||
}
|
||||
@ -531,9 +453,6 @@ bool VM::execDIVR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("DIVR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] /= regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -547,9 +466,6 @@ bool VM::execSHLI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("SHLI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = regs[dst] << src;
|
||||
return true;
|
||||
}
|
||||
@ -563,9 +479,6 @@ bool VM::execSHLR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("SHLR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = regs[dst] << regs[src];
|
||||
return true;
|
||||
}
|
||||
@ -579,9 +492,6 @@ bool VM::execSHRI(void) {
|
||||
dst = as.code[regs[IP] + 1];
|
||||
src = *((uint16_t *)&as.code[regs[IP] + 2]);
|
||||
DBG_INFO(("SHRI %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!dstRegCheck(dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = regs[dst] >> src;
|
||||
return true;
|
||||
}
|
||||
@ -595,34 +505,25 @@ bool VM::execSHRR(void) {
|
||||
dst = as.code[regs[IP] + 1] >> 4;
|
||||
src = as.code[regs[IP] + 1] & 0b00001111;
|
||||
DBG_INFO(("SHRR %s, 0x%x\n", getRegName(dst), src));
|
||||
if (!srcDstRegCheck(src, dst)) {
|
||||
return false;
|
||||
}
|
||||
regs[dst] = regs[dst] >> regs[src];
|
||||
return true;
|
||||
}
|
||||
bool VM::execPUSH(void) {
|
||||
// TODO: STACK < 0
|
||||
uint8_t src;
|
||||
|
||||
src = as.code[regs[IP] + 1];
|
||||
DBG_INFO(("PUSH %s\n", getRegName(src)));
|
||||
if (regs[SP] + sizeof(uint16_t) > 0xffff) {
|
||||
DBG_ERROR(("Out of bound: stack is going above 0xFFFF!\n"));
|
||||
return false;
|
||||
}
|
||||
memcpy(&as.stack[regs[SP]], ®s[src], sizeof(uint16_t));
|
||||
regs[SP] += sizeof(uint16_t);
|
||||
return true;
|
||||
}
|
||||
bool VM::execPOOP(void) {
|
||||
// TODO: STACK < 0
|
||||
uint8_t dst;
|
||||
|
||||
dst = as.code[regs[IP] + 1];
|
||||
DBG_INFO(("POOP %s\n", getRegName(dst)));
|
||||
if (regs[SP] - sizeof(uint16_t) < 0) {
|
||||
DBG_ERROR(("Out of bound: stack is going below 0!\n"));
|
||||
return false;
|
||||
}
|
||||
regs[SP] -= sizeof(uint16_t);
|
||||
memcpy(®s[dst], &as.stack[regs[SP]], sizeof(uint16_t));
|
||||
return true;
|
||||
@ -862,274 +763,107 @@ bool VM::execGRMN(void) {
|
||||
void VM::run(void) {
|
||||
uint8_t opcode;
|
||||
bool finished = false;
|
||||
bool ret;
|
||||
while (!finished) {
|
||||
opcode = (uint8_t)as.code[regs[IP]];
|
||||
if (opcode == OPS[MOVI]) {
|
||||
ret = execMOVI();
|
||||
if (ret) {
|
||||
execMOVI();
|
||||
regs[IP] += MOVI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("MOVI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[MOVR]) {
|
||||
ret = execMOVR();
|
||||
if (ret) {
|
||||
execMOVR();
|
||||
regs[IP] += MOVR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("MOVR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[LODI]) {
|
||||
ret = execLODI();
|
||||
if (ret) {
|
||||
execLODI();
|
||||
regs[IP] += LODI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("LODI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[LODR]) {
|
||||
ret = execLODR();
|
||||
if (ret) {
|
||||
regs[IP] += LODR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("LODR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
execLODR();
|
||||
regs[IP] += LODR_SIZE;
|
||||
} else if (opcode == OPS[STRI]) {
|
||||
ret = execSTRI();
|
||||
if (ret) {
|
||||
execSTRI();
|
||||
regs[IP] += STRI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("MOVI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[STRR]) {
|
||||
ret = execSTRR();
|
||||
if (ret) {
|
||||
execSTRR();
|
||||
regs[IP] += STRR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("STRR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[ADDI]) {
|
||||
ret = execADDI();
|
||||
if (ret) {
|
||||
execADDI();
|
||||
regs[IP] += ADDI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("ADDI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[ADDR]) {
|
||||
ret = execADDR();
|
||||
if (ret) {
|
||||
execADDR();
|
||||
regs[IP] += ADDR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("ADDR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[SUBI]) {
|
||||
ret = execSUBI();
|
||||
if (ret) {
|
||||
execSUBI();
|
||||
regs[IP] += SUBI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("SUBI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[SUBR]) {
|
||||
ret = execSUBR();
|
||||
if (ret) {
|
||||
execSUBR();
|
||||
regs[IP] += SUBR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("SUBR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[ANDB]) {
|
||||
ret = execANDB();
|
||||
if (ret) {
|
||||
execANDB();
|
||||
regs[IP] += ANDB_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("ANDB FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[ANDW]) {
|
||||
ret = execANDW();
|
||||
if (ret) {
|
||||
execANDW();
|
||||
regs[IP] += ANDW_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("ANDW FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[ANDR]) {
|
||||
ret = execANDR();
|
||||
if (ret) {
|
||||
execANDR();
|
||||
regs[IP] += ANDR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("ANDR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[YORB]) {
|
||||
ret = execYORB();
|
||||
if (ret) {
|
||||
execYORB();
|
||||
regs[IP] += YORB_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("YORB FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[YORW]) {
|
||||
ret = execYORW();
|
||||
if (ret) {
|
||||
execYORW();
|
||||
regs[IP] += YORW_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("YORW FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[YORR]) {
|
||||
ret = execYORR();
|
||||
if (ret) {
|
||||
execYORR();
|
||||
regs[IP] += YORR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("YORR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[XORB]) {
|
||||
ret = execXORB();
|
||||
if (ret) {
|
||||
execXORB();
|
||||
regs[IP] += XORB_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("XORB FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[XORW]) {
|
||||
ret = execXORW();
|
||||
if (ret) {
|
||||
execXORW();
|
||||
regs[IP] += XORW_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("XORW FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[XORR]) {
|
||||
ret = execXORR();
|
||||
if (ret) {
|
||||
execXORR();
|
||||
regs[IP] += XORR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("XORR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[NOTR]) {
|
||||
ret = execNOTR();
|
||||
if (ret) {
|
||||
execNOTR();
|
||||
regs[IP] += NOTR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("NOTR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[MULI]) {
|
||||
ret = execMULI();
|
||||
if (ret) {
|
||||
execMULI();
|
||||
regs[IP] += MULI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("MULI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[MULR]) {
|
||||
ret = execMULR();
|
||||
if (ret) {
|
||||
execMULR();
|
||||
regs[IP] += MULR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("MULR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[DIVI]) {
|
||||
ret = execDIVI();
|
||||
if (ret) {
|
||||
execDIVI();
|
||||
regs[IP] += DIVI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("DIVI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[DIVR]) {
|
||||
ret = execDIVR();
|
||||
if (ret) {
|
||||
execDIVR();
|
||||
regs[IP] += DIVR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("DIVR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[SHLI]) {
|
||||
ret = execSHLI();
|
||||
if (ret) {
|
||||
execSHLI();
|
||||
regs[IP] += SHLI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("SHLI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[SHLR]) {
|
||||
ret = execSHLR();
|
||||
if (ret) {
|
||||
execSHLR();
|
||||
regs[IP] += SHLR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("SHLR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[SHRI]) {
|
||||
ret = execSHRI();
|
||||
if (ret) {
|
||||
execSHRI();
|
||||
regs[IP] += SHRI_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("SHRI FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[SHRR]) {
|
||||
ret = execSHRR();
|
||||
if (ret) {
|
||||
execSHRR();
|
||||
regs[IP] += SHRR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("SHRR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[PUSH]) {
|
||||
ret = execPUSH();
|
||||
if (ret) {
|
||||
execPUSH();
|
||||
regs[IP] += PUSH_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("PUSH FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[POOP]) {
|
||||
ret = execPOOP();
|
||||
if (ret) {
|
||||
execPOOP();
|
||||
regs[IP] += POOP_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("POOP FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[CMPB]) {
|
||||
ret = execCMPB();
|
||||
if (ret) {
|
||||
execCMPB();
|
||||
regs[IP] += CMPB_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("CMPB FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[CMPW]) {
|
||||
ret = execCMPW();
|
||||
if (ret) {
|
||||
execCMPW();
|
||||
regs[IP] += CMPW_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("CMPW FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[CMPR]) {
|
||||
ret = execCMPR();
|
||||
if (ret) {
|
||||
execCMPR();
|
||||
regs[IP] += CMPR_SIZE;
|
||||
} else {
|
||||
DBG_ERROR(("CMPR FAILED.\n"));
|
||||
finished = true;
|
||||
}
|
||||
} else if (opcode == OPS[JMPI]) {
|
||||
execJMPI();
|
||||
} else if (opcode == OPS[JMPR]) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user