summaryrefslogtreecommitdiff
path: root/src/virtualmachine/VirtualMachine.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/virtualmachine/VirtualMachine.cpp')
-rw-r--r--src/virtualmachine/VirtualMachine.cpp664
1 files changed, 664 insertions, 0 deletions
diff --git a/src/virtualmachine/VirtualMachine.cpp b/src/virtualmachine/VirtualMachine.cpp
new file mode 100644
index 0000000..ce12b87
--- /dev/null
+++ b/src/virtualmachine/VirtualMachine.cpp
@@ -0,0 +1,664 @@
+#include <string>
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+#include "VirtualMachine.h"
+
+namespace vm
+{
+
+ VirtualMachine::VirtualMachine(int hunkMbytes):
+ bigEndian(false),
+ hunk(NULL),
+ hunkSize(1048576),
+ hunkFree(0),
+ rom(NULL),
+ romSize(0),
+ ram(NULL),
+ ramSize(0),
+ dataStack(0),
+ returnStack(0),
+ DP(0), /* Datastack pointer. */
+ RP(0), /* Return stack pointer. */
+ PC(0),
+ cm(0),
+ cycles(0)
+ {
+ hunk = new char[hunkSize];
+ std::fill(hunk, hunk+hunkSize, 0);
+ }
+
+ VirtualMachine::~VirtualMachine()
+ {
+ delete[] hunk;
+ }
+
+ #define crumb printf
+
+ int VirtualMachine::opcodeParameterSize(int opcode)
+ {
+ #define OP(n) OP##n
+ switch (opcode)
+ {
+ case OP(ENTER):
+ case OP(LEAVE):
+ case OP(LOCAL):
+ case OP(EQ):
+ case OP(NE):
+ case OP(LTI):
+ case OP(LEI):
+ case OP(GTI):
+ case OP(GEI):
+ case OP(LTU):
+ case OP(LEU):
+ case OP(GTU):
+ case OP(GEU):
+ case OP(EQF):
+ case OP(NEF):
+ case OP(LTF):
+ case OP(LEF):
+ case OP(GTF):
+ case OP(GEF):
+ case OP(CONST):
+ case OP(BLOCK_COPY):
+ return sizeof(uint4_t);
+ break;
+ case OP(ARG):
+ return sizeof(uint1_t);
+ break;
+ }
+ return 0;
+ #undef OP
+ }
+
+ /* Read one octet from file. */
+ int VirtualMachine::readByte(FILE *qvmfile)
+ {
+ int o;
+ o = fgetc(qvmfile);
+ if (o < 0) o = 0; /* EOF (hack) */
+ return o;
+ }
+
+ /* Read little-endian 32-bit integer from file. */
+ int VirtualMachine::readInt(FILE *qvmfile)
+ {
+ int a, b, c, d, n;
+
+ a = readByte(qvmfile);
+ b = readByte(qvmfile);
+ c = readByte(qvmfile);
+ d = readByte(qvmfile);
+ n = (a) | (b << 8) | (c << 16) | (d << 24);
+ return n;
+ }
+
+ int VirtualMachine::LoadProgram(char * filename)
+ {
+ FILE * qvmfile = fopen(filename, "rb");
+ qvm_header_t qvminfo;
+ int i, n;
+ uint1_t x[4];
+ word w;
+
+ crumb("Loading file...\n");
+ qvminfo.magic = readInt(qvmfile); /* magic. */
+ if (qvminfo.magic != QVM_MAGIC)
+ {
+ crumb("Invalid magic");
+ //q3vm_error("Does not appear to be a QVM file.");
+ /* XXX: option to force continue. */
+ return 0;
+ }
+ crumb("Magic OK\n");
+ /* variable-length instructions mean instruction count != code length */
+ qvminfo.inscount = readInt(qvmfile);
+ qvminfo.codeoff = readInt(qvmfile);
+ qvminfo.codelen = readInt(qvmfile);
+ qvminfo.dataoff = readInt(qvmfile);
+ qvminfo.datalen = readInt(qvmfile);
+ qvminfo.litlen = readInt(qvmfile);
+ qvminfo.bsslen = readInt(qvmfile);
+
+ /* Code segment should follow... */
+ /* XXX: use fseek with SEEK_CUR? */
+ crumb("Searching for .code @ %d from %d\n", qvminfo.codeoff, ftell(qvmfile));
+ // rom = (q3vm_rom_t*)(hunk); /* ROM-in-hunk */
+ rom = (Instruction*)calloc(qvminfo.inscount, sizeof(rom[0]));
+ while (ftell(qvmfile) < qvminfo.codeoff)
+ readByte(qvmfile);
+ while (romSize < qvminfo.inscount)
+ {
+ n = readByte(qvmfile);
+ w.int4 = 0;
+ if ((i = opcodeParameterSize(n)))
+ {
+ x[0] = x[1] = x[2] = x[3] = 0;
+ fread(&x, 1, i, qvmfile);
+ w.uint4 = (x[0]) | (x[1] << 8) | (x[2] << 16) | (x[3] << 24);
+ }
+ rom[romSize].Operation = n;
+ rom[romSize].Parameter = w;
+ romSize++;
+ }
+ crumb("After loading code: at %d, should be %d\n", ftell(qvmfile), qvminfo.codeoff + qvminfo.codelen);
+
+ /* Then data segment. */
+ // ram = hunk + ((romlen + 3) & ~3); /* RAM-in-hunk */
+ ram = hunk;
+ crumb("Searching for .data @ %d from %d\n", qvminfo.dataoff, ftell(qvmfile));
+ while (ftell(qvmfile) < qvminfo.dataoff)
+ readByte(qvmfile);
+ for (n = 0; n < (qvminfo.datalen / sizeof(uint1_t)); n++)
+ {
+ i = fread(&x, 1, sizeof(x), qvmfile);
+ w.uint4 = (x[0]) | (x[1] << 8) | (x[2] << 16) | (x[3] << 24);
+ *((word*)(ram + ramSize)) = w;
+ ramSize += sizeof(word);
+ }
+ /* lit segment follows data segment. */
+ /* Assembler should have already padded properly. */
+ crumb("Loading .lit\n");
+ for (n = 0; n < (qvminfo.litlen / sizeof(uint1_t)); n++)
+ {
+ i = fread(&x, 1, sizeof(x), qvmfile);
+ memcpy(&(w.uint1), &x, sizeof(x)); /* no byte-swapping. */
+ *((word*)(ram + ramSize)) = w;
+ ramSize += sizeof(word);
+ }
+ /* bss segment. */
+ crumb("Allocating .bss %d (%X) bytes\n", qvminfo.bsslen, qvminfo.bsslen);
+ /* huge empty chunk. */
+ ramSize += qvminfo.bsslen;
+
+ hunkFree = hunkSize - ((ramSize * sizeof(uint1_t)) + 4);
+
+ crumb("VM hunk has %d of %d bytes free (RAM = %d B).\n", hunkFree, hunkSize, ramSize);
+ if (ramSize > hunkSize)
+ {
+ throw OutOfMemoryException();
+ return 0;
+ }
+
+ /* set up stack. */
+ {
+ int stacksize = 0x10000;
+ returnStack = ramSize;
+ dataStack = ramSize - (stacksize / 2);
+ RP = returnStack;
+ DP = dataStack;
+ }
+
+ /* set up PC for return-to-termination. */
+ PC = romSize + 1;
+
+ return 1;
+ }
+
+ int VirtualMachine::Call(int address)
+ {
+ word w;
+ int i, argCount = 13;
+
+ /* Set up call. */
+ opPUSH(w);
+ crumb("Starting with PC=%d, DP=%d, RP=%d to %d\n", PC, DP, RP, address);
+ w.int4 = (argCount + 2) * sizeof(word);
+ opENTER(w);
+ i = 8;
+ /**w.int4 = arg0; Marshal(i, w); i += 4;
+ w.int4 = arg1; Marshal(i, w); i += 4;
+ w.int4 = arg2; Marshal(i, w); i += 4;
+ w.int4 = arg3; Marshal(i, w); i += 4;
+ w.int4 = arg4; Marshal(i, w); i += 4;
+ w.int4 = arg5; Marshal(i, w); i += 4;
+ w.int4 = arg6; Marshal(i, w); i += 4;
+ w.int4 = arg7; Marshal(i, w); i += 4;
+ w.int4 = arg8; Marshal(i, w); i += 4;
+ w.int4 = arg9; Marshal(i, w); i += 4;
+ w.int4 = arg10; Marshal(i, w); i += 4;
+ w.int4 = arg11; Marshal(i, w); i += 4;
+ w.int4 = arg12; Marshal(i, w); i += 4;*/
+ w.int4 = address;
+ Push(w);
+ opCALL(w);
+ printf("Upon running PC=%d, DP=%d, RP=%d\n", PC, DP, RP);
+ Run();
+ printf("At finish PC=%d, DP=%d, RP=%d\n", PC, DP, RP);
+ w.int4 = (argCount + 2) * sizeof(word);
+ opLEAVE(w);
+ return 0;
+ }
+
+ int VirtualMachine::Run()
+ {
+ bool running = true;
+ int operation;
+ word parameter;
+ while(running)
+ {
+ cycles++;
+ if(PC > romSize)
+ {
+ running = false;
+ continue;
+ }
+ if (PC < 0)
+ {
+ syscall(PC);
+ continue;
+ }
+ operation = rom[PC].Operation;
+ parameter = rom[PC].Parameter;
+ PC++;
+ (this->*operations[operation])(parameter);
+ }
+ return 1;
+ }
+
+
+
+ int VirtualMachine::syscall(int trap)
+ {
+ int retval;
+ word w;
+
+ retval = 0;
+ switch (trap)
+ {
+ #define TRAPDEF(n, f) case n: retval = trap##f(); break;
+ #include "Traps.inl"
+ #undef TRAPDEF
+ }
+
+ w = Pop();
+ PC = w.int4;
+ w.int4 = retval;
+ Push(w);
+ return 1;
+ }
+
+ #define ARG(n) (Get<int4_t>(RP + ((2 + n) * sizeof(word))))
+
+ #define TRAPDEF(f) int VirtualMachine::trap##f()
+
+ TRAPDEF(Print)
+ {
+ char *text;
+
+ //crumb("SYSCALL Print [%d]\n", ARG(0));
+ text = (char*)(ram) + ARG(0);
+ //crumb("PRINTING [%s]\n", text);
+ printf("%s", text);
+ return 0;
+ }
+
+
+ TRAPDEF(Error)
+ {
+ char *msg;
+
+ msg = (char*)(ram) + ARG(0);
+ printf("%s", msg);
+ PC = romSize + 1;
+ return 0;
+ }
+
+ #define OPDEF(n) &VirtualMachine::op##n,
+ OperationFunction VirtualMachine::operations[] =
+ {
+ #include "OpCodes.inl"
+ };
+ #undef OPDEF
+
+ #define OPDEF(n) int VirtualMachine::op##n(word parameter)
+
+ #define R0 (r[0])
+ #define R1 (r[1])
+ #define R2 (r[2])
+
+
+ OPDEF(UNDEF)
+ {
+ /* Die horribly. */
+ throw RuntimeException();
+ return -1;
+ }
+
+ OPDEF(IGNORE)
+ {
+ /* NOP */
+ throw RuntimeException();
+ return 0;
+ }
+
+ OPDEF(BREAK)
+ {
+ /* Usage never spotted. */
+ /* Die horribly? */
+ throw RuntimeException();
+ return -1;
+ }
+
+ /*
+ Stack on entering...
+
+ no locals: ENTER 8
+ 1 words locals: ENTER 16
+ 2 words locals: ENTER 20
+ 3 words locals: ENTER 24
+ etc.
+
+ address of argument:
+ ADDRFP4 v => OP_LOCAL (16 + currentLocals + currentArgs + v)
+ address of local:
+ ADDRLP4 v => OP_LOCAL (8 + currentArgs + v)
+
+ RP [ ] ??? (oldPC?)
+ [ ] ???
+ [ ] \
+ ... > locals (args marshalling)
+ [ ] /
+ [ ] \
+ ... > locals
+ [ ] / (ADDRLP4 v => OP_LOCAL (8 + currentArgs + v))
+ (oldRP?) [ ] ???
+ [ ] ???
+ [ ] (my args?)
+ ...
+ [ ]
+ */
+
+ OPDEF(ENTER) /* ??? */
+ {
+ while (parameter.int4 > (2 * sizeof(word)))
+ {
+ RPush<int4_t>(0); /* init zero */
+ parameter.int4 -= sizeof(word);
+ }
+ RPush(Pop()); //Program Counter
+ RPush<int4_t>(0); //Unknown
+ return 0;
+ }
+
+ OPDEF(LEAVE) /* ??? */
+ {
+ RPop(); //Unknown
+ parameter.int4 -= sizeof(word);
+ PC = RPop<int4_t>(); //Program counter
+ parameter.int4 -= sizeof(word);
+ while (parameter.int4 > 0)
+ {
+ RPop();
+ parameter.int4 -= sizeof(word);
+ }
+ return 0;
+ }
+
+ OPDEF(CALL) /* Call subroutine. */
+ {
+ R0 = Pop();
+ Push<int4_t>(PC);
+ PC = R0.int4;
+ return 0;
+ }
+
+ OPDEF(PUSH) /* [DP] <- 0; DP++ */
+ {
+ Push(0);
+ return 0;
+ }
+
+ OPDEF(POP) /* DP-- */
+ {
+ Pop();
+ return 0;
+ }
+
+ OPDEF(CONST) /* [DP] <- parm; DP++ */
+ {
+ Push(parameter);
+ return 0;
+ }
+
+ OPDEF(LOCAL) /* [DP] <- [RP-n] */
+ {
+ Push<int4_t>(RP + parameter.int4);
+ return 0;
+ }
+
+ OPDEF(JUMP) /* PC <- [DP] */
+ {
+ PC = Pop<int4_t>();
+ return 0;
+ }
+
+ #define CMP(type, op) \
+ { \
+ R0 = Pop(); \
+ cm = (Pop<type##_t>() op R0.type); \
+ if (cm) \
+ PC = parameter.uint4; \
+ return 0; \
+ }
+
+ OPDEF(EQ) /* if [DP] == [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(int4, ==)
+
+ OPDEF(NE) /* if [DP] == [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(int4, !=)
+
+ OPDEF(LTI) /* if [DP] < [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(int4, <)
+
+ OPDEF(LEI) /* if [DP] <= [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(int4, <=)
+
+ OPDEF(GTI) /* if [DP] > [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(int4, >)
+
+ OPDEF(GEI) /* if [DP] >= [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(int4, >=)
+
+ OPDEF(LTU) /* if [DP] < [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(uint4, <)
+
+ OPDEF(LEU) /* if [DP] <= [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(uint4, <=)
+
+ OPDEF(GTU) /* if [DP] > [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(uint4, >)
+
+ OPDEF(GEU) /* if [DP] >= [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(uint4, >=)
+
+ OPDEF(EQF) /* if [DP] == [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(float4, ==)
+
+ OPDEF(NEF) /* if [DP] != [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(float4, !=)
+
+ OPDEF(LTF) /* if [DP] < [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(float4, <)
+
+ OPDEF(LEF) /* if [DP] <= [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(float4, <=)
+
+ OPDEF(GTF) /* if [DP] > [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(float4, >)
+
+ OPDEF(GEF) /* if [DP] >= [DP-1] then PC <- parm; DP <- DP-2 */
+ CMP(float4, >=)
+
+
+ OPDEF(LOAD1) /* [DP] <- [[DP]] */
+ {
+ Push<uint1_t>(Get<uint1_t>(Pop<uint4_t>()));
+ return 0;
+ }
+
+ OPDEF(LOAD2) /* [DP] <- [[DP]] */
+ {
+ Push<uint2_t>(Get<uint2_t>(Pop<uint4_t>()));
+ return 0;
+ }
+
+ OPDEF(LOAD4) /* [DP] <- [[DP]] */
+ {
+ Push<uint4_t>(Get<uint4_t>(Pop<uint4_t>()));
+ return 0;
+ }
+
+ OPDEF(STORE1) /* [DP-1] <- [DP]; DP <- DP-2 */
+ {
+ Set<uint1_t>(Pop<uint4_t>(), Pop<uint1_t>());
+ return 0;
+ }
+
+ OPDEF(STORE2) /* [DP-1] <- [DP]; DP <- DP-2 */
+ {
+ Set<uint2_t>(Pop<uint4_t>(), Pop<uint2_t>());
+ return 0;
+ }
+
+ OPDEF(STORE4) /* [DP-1] <- [DP]; DP <- DP-2 */
+ {
+ Set<uint4_t>(Pop<uint4_t>(), Pop<uint4_t>());
+ return 0;
+ }
+
+ OPDEF(ARG) /* Marshal TOS to to-call argument list */
+ {
+ Marshal(parameter.int4, Pop());
+ return 0;
+ }
+
+ OPDEF(BLOCK_COPY) /* XXX */
+ {
+ R1 = Pop();
+ R0 = Pop();
+ if(R0.int4 >= 0 && R0.int4 + parameter.int4 < ramSize && R1.int4 >= 0 && R1.int4 + parameter.int4 < ramSize)
+ memcpy(ram + R0.int4, ram + R1.int4, parameter.int4);
+ else
+ throw AccessViolationException();
+ return -1;
+ }
+
+ OPDEF(SEX8) /* Sign-extend 8-bit */
+ {
+ R0 = Pop();
+ if(R0.uint4 & 0x80)
+ R0.uint4 |= 0xFFFFFF80;
+ Push(R0);
+ return 0;
+ }
+
+ OPDEF(SEX16) /* Sign-extend 16-bit */
+ {
+ R0 = Pop();
+ if(R0.uint4 & 0x8000)
+ R0.uint4 |= 0xFFFF8000;
+ Push(R0);
+ return 0;
+ }
+
+ #define UNOP(type, op) \
+ { \
+ Push<type##_t>(op Pop<type##_t>()); \
+ return 0; \
+ }
+
+ #define BINOP(type, op) \
+ { \
+ R0 = Pop(); \
+ Push<type##_t>(Pop<type##_t>() op R0.type); \
+ return 0; \
+ }
+
+ OPDEF(NEGI) /* [DP] <- -[DP] */
+ UNOP(int4, -)
+
+ OPDEF(ADD) /* [DP-1] <- [DP-1] + [DP]; DP <- DP-1 */
+ BINOP(int4, +)
+
+ OPDEF(SUB) /* [DP-1] <- [DP-1] - [DP]; DP <- DP-1 */
+ BINOP(int4, -)
+
+ OPDEF(DIVI) /* [DP-1] <- [DP-1] / [DP]; DP <- DP-1 */
+ BINOP(int4, /)
+
+ OPDEF(DIVU) /* [DP-1] <- [DP-1] / [DP]; DP <- DP-1 */
+ BINOP(uint4, /)
+
+ OPDEF(MODI) /* [DP-1] <- [DP-1] % [DP]; DP <- DP-1 */
+ BINOP(int4, %)
+
+ OPDEF(MODU) /* [DP-1] <- [DP-1] % [DP]; DP <- DP-1 */
+ BINOP(uint4, %)
+
+ OPDEF(MULI) /* [DP-1] <- [DP-1] * [DP]; DP <- DP-1 */
+ BINOP(int4, *)
+
+ OPDEF(MULU) /* [DP-1] <- [DP-1] * [DP]; DP <- OP-1 */
+ BINOP(uint4, *)
+
+ OPDEF(BAND) /* [DP-1] <- [DP-1] & [DP]; DP <- DP-1 */
+ BINOP(uint4, &)
+
+ OPDEF(BOR) /* [DP-1] <- [DP-1] | [DP]; DP <- DP-1 */
+ BINOP(uint4, |)
+
+ OPDEF(BXOR) /* [DP-1] <- [DP-1] ^ [DP]; DP <- DP-1 */
+ BINOP(uint4, ^)
+
+ OPDEF(BCOM) /* [DP] <- ~[DP] */
+ UNOP(uint4, ~)
+
+ OPDEF(LSH) /* [DP-1] <- [DP-1] << [DP]; DP <- DP-1 */
+ BINOP(uint4, <<)
+
+ OPDEF(RSHI) /* [DP-1] <- [DP-1] >> [DP]; DP <- DP-1 */
+ {
+ R1.int4 = Pop<int4_t>();
+ R0.int4 = Pop<int4_t>();
+ #if 0
+ while (R1.int4-- > 0)
+ R0.int4 /= 2;
+ R2 = R0;
+ #else
+ R2.int4 = R0.int4 >> R1.int4;
+ #endif
+ Push(R2);
+ return 0;
+ }
+
+ OPDEF(RSHU) /* [DP-1] <- [DP-1] >> [DP]; DP <- DP-1 */
+ BINOP(uint4, >>)
+
+ OPDEF(NEGF) /* [DP] <- -[DP] */
+ UNOP(float4, -)
+
+ OPDEF(ADDF) /* [DP-1] <- [DP-1] + [DP]; DP <- DP-1 */
+ BINOP(float4, +)
+
+ OPDEF(SUBF) /* [DP-1] <- [DP-1] - [DP]; DP <- DP-1 */
+ BINOP(float4, -)
+
+ OPDEF(DIVF) /* [DP-1] <- [DP-1] / [DP]; DP <- DP-1 */
+ BINOP(float4, /)
+
+ OPDEF(MULF) /* [DP-1] <- [DP-1] / [DP]; DP <- DP-1 */
+ BINOP(float4, *)
+
+ OPDEF(CVIF) /* [DP] <- [DP] */
+ {
+ Push<float4_t>(Pop<int4_t>());
+ return 0;
+ }
+
+ OPDEF(CVFI) /* [DP] <- [DP] */
+ {
+ Push<int4_t>(Pop<float4_t>());
+ return 0;
+ }
+} \ No newline at end of file