From cc5219c8fa8965ee0f3d21a002ab35adb4200640 Mon Sep 17 00:00:00 2001 From: Jeremiah Orians Date: Sun, 12 Jun 2016 09:02:00 -0400 Subject: [PATCH] We will deal with tests later as idea needs to be explored before integration --- vm.c | 290 +++++++++++++++++++++++++++++++++++++++++++--- vm.h | 271 ------------------------------------------- vm_instructions.c | 138 +++++++++++++++++++++- vm_tests.c | 20 ---- 4 files changed, 412 insertions(+), 307 deletions(-) delete mode 100644 vm_tests.c diff --git a/vm.c b/vm.c index cc6b463..5fb5310 100644 --- a/vm.c +++ b/vm.c @@ -1,8 +1,278 @@ -#include "vm_instructions.c" +#include "vm.h" #define DEBUG true - uint32_t performance_counter; +/* Prototypes for functions in vm_instructions.c*/ +void vm_FOPEN(struct lilith* vm); +void vm_FCLOSE(struct lilith* vm); +void vm_FSEEK(struct lilith* vm); +void vm_REWIND(struct lilith* vm); +void vm_FGETC(struct lilith* vm); +void vm_FPUTC(struct lilith* vm); +void ADD_CI(struct lilith* vm, struct Instruction* c); +void ADD_CO(struct lilith* vm, struct Instruction* c); +void ADD_CIO(struct lilith* vm, struct Instruction* c); +void ADDU_CI(struct lilith* vm, struct Instruction* c); +void ADDU_CO(struct lilith* vm, struct Instruction* c); +void ADDU_CIO(struct lilith* vm, struct Instruction* c); +void SUB_BI(struct lilith* vm, struct Instruction* c); +void SUB_BO(struct lilith* vm, struct Instruction* c); +void SUB_BIO(struct lilith* vm, struct Instruction* c); +void SUBU_BI(struct lilith* vm, struct Instruction* c); +void SUBU_BO(struct lilith* vm, struct Instruction* c); +void SUBU_BIO(struct lilith* vm, struct Instruction* c); +void MULTIPLY(struct lilith* vm, struct Instruction* c); +void MULTIPLYU(struct lilith* vm, struct Instruction* c); +void DIVIDE(struct lilith* vm, struct Instruction* c); +void DIVIDEU(struct lilith* vm, struct Instruction* c); +void MUX(struct lilith* vm, struct Instruction* c); +void NMUX(struct lilith* vm, struct Instruction* c); +void SORT(struct lilith* vm, struct Instruction* c); +void SORTU(struct lilith* vm, struct Instruction* c); +void ADD(struct lilith* vm, struct Instruction* c); +void ADDU(struct lilith* vm, struct Instruction* c); +void SUB(struct lilith* vm, struct Instruction* c); +void SUBU(struct lilith* vm, struct Instruction* c); +void CMP(struct lilith* vm, struct Instruction* c); +void CMPU(struct lilith* vm, struct Instruction* c); +void MUL(struct lilith* vm, struct Instruction* c); +void MULH(struct lilith* vm, struct Instruction* c); +void MULU(struct lilith* vm, struct Instruction* c); +void MULUH(struct lilith* vm, struct Instruction* c); +void DIV(struct lilith* vm, struct Instruction* c); +void MOD(struct lilith* vm, struct Instruction* c); +void DIVU(struct lilith* vm, struct Instruction* c); +void MODU(struct lilith* vm, struct Instruction* c); +void MAX(struct lilith* vm, struct Instruction* c); +void MAXU(struct lilith* vm, struct Instruction* c); +void MIN(struct lilith* vm, struct Instruction* c); +void MINU(struct lilith* vm, struct Instruction* c); +void PACK(struct lilith* vm, struct Instruction* c); +void UNPACK(struct lilith* vm, struct Instruction* c); +void PACK8_CO(struct lilith* vm, struct Instruction* c); +void PACK8U_CO(struct lilith* vm, struct Instruction* c); +void PACK16_CO(struct lilith* vm, struct Instruction* c); +void PACK16U_CO(struct lilith* vm, struct Instruction* c); +void PACK32_CO(struct lilith* vm, struct Instruction* c); +void PACK32U_CO(struct lilith* vm, struct Instruction* c); +void AND(struct lilith* vm, struct Instruction* c); +void OR(struct lilith* vm, struct Instruction* c); +void XOR(struct lilith* vm, struct Instruction* c); +void NAND(struct lilith* vm, struct Instruction* c); +void NOR(struct lilith* vm, struct Instruction* c); +void XNOR(struct lilith* vm, struct Instruction* c); +void MPQ(struct lilith* vm, struct Instruction* c); +void LPQ(struct lilith* vm, struct Instruction* c); +void CPQ(struct lilith* vm, struct Instruction* c); +void BPQ(struct lilith* vm, struct Instruction* c); +void SAL(struct lilith* vm, struct Instruction* c); +void SAR(struct lilith* vm, struct Instruction* c); +void SL0(struct lilith* vm, struct Instruction* c); +void SR0(struct lilith* vm, struct Instruction* c); +void SL1(struct lilith* vm, struct Instruction* c); +void SR1(struct lilith* vm, struct Instruction* c); +void ROL(struct lilith* vm, struct Instruction* c); +void ROR(struct lilith* vm, struct Instruction* c); +void LOADX(struct lilith* vm, struct Instruction* c); +void LOADX8(struct lilith* vm, struct Instruction* c); +void LOADXU8(struct lilith* vm, struct Instruction* c); +void LOADX16(struct lilith* vm, struct Instruction* c); +void LOADXU16(struct lilith* vm, struct Instruction* c); +void LOADX32(struct lilith* vm, struct Instruction* c); +void LOADXU32(struct lilith* vm, struct Instruction* c); +void STOREX(struct lilith* vm, struct Instruction* c); +void STOREX8(struct lilith* vm, struct Instruction* c); +void STOREX16(struct lilith* vm, struct Instruction* c); +void STOREX32(struct lilith* vm, struct Instruction* c); +void NEG(struct lilith* vm, struct Instruction* c); +void ABS(struct lilith* vm, struct Instruction* c); +void NABS(struct lilith* vm, struct Instruction* c); +void SWAP(struct lilith* vm, struct Instruction* c); +void COPY(struct lilith* vm, struct Instruction* c); +void MOVE(struct lilith* vm, struct Instruction* c); +void BRANCH(struct lilith* vm, struct Instruction* c); +void CALL(struct lilith* vm, struct Instruction* c); +void READPC(struct lilith* vm, struct Instruction* c); +void READSCID(struct lilith* vm, struct Instruction* c); +void FALSE(struct lilith* vm, struct Instruction* c); +void TRUE(struct lilith* vm, struct Instruction* c); +void JSR_COROUTINE(struct lilith* vm, struct Instruction* c); +void RET(struct lilith* vm, struct Instruction* c); +void PUSHPC(struct lilith* vm, struct Instruction* c); +void POPPC(struct lilith* vm, struct Instruction* c); +void ADDI(struct lilith* vm, struct Instruction* c); +void ADDUI(struct lilith* vm, struct Instruction* c); +void SUBI(struct lilith* vm, struct Instruction* c); +void SUBUI(struct lilith* vm, struct Instruction* c); +void CMPI(struct lilith* vm, struct Instruction* c); +void LOAD(struct lilith* vm, struct Instruction* c); +void LOAD8(struct lilith* vm, struct Instruction* c); +void LOADU8(struct lilith* vm, struct Instruction* c); +void LOAD16(struct lilith* vm, struct Instruction* c); +void LOADU16(struct lilith* vm, struct Instruction* c); +void LOAD32(struct lilith* vm, struct Instruction* c); +void LOADU32(struct lilith* vm, struct Instruction* c); +void CMPUI(struct lilith* vm, struct Instruction* c); +void STORE(struct lilith* vm, struct Instruction* c); +void STORE8(struct lilith* vm, struct Instruction* c); +void STORE16(struct lilith* vm, struct Instruction* c); +void STORE32(struct lilith* vm, struct Instruction* c); +void JUMP_C(struct lilith* vm, struct Instruction* c); +void JUMP_B(struct lilith* vm, struct Instruction* c); +void JUMP_O(struct lilith* vm, struct Instruction* c); +void JUMP_G(struct lilith* vm, struct Instruction* c); +void JUMP_GE(struct lilith* vm, struct Instruction* c); +void JUMP_E(struct lilith* vm, struct Instruction* c); +void JUMP_NE(struct lilith* vm, struct Instruction* c); +void JUMP_LE(struct lilith* vm, struct Instruction* c); +void JUMP_L(struct lilith* vm, struct Instruction* c); +void JUMP_Z(struct lilith* vm, struct Instruction* c); +void JUMP_NZ(struct lilith* vm, struct Instruction* c); +void CALLI(struct lilith* vm, struct Instruction* c); +void LOADI(struct lilith* vm, struct Instruction* c); +void LOADUI(struct lilith* vm, struct Instruction* c); +void SALI(struct lilith* vm, struct Instruction* c); +void SARI(struct lilith* vm, struct Instruction* c); +void SL0I(struct lilith* vm, struct Instruction* c); +void SR0I(struct lilith* vm, struct Instruction* c); +void SL1I(struct lilith* vm, struct Instruction* c); +void SR1I(struct lilith* vm, struct Instruction* c); +void JUMP(struct lilith* vm, struct Instruction* c); + +/* Allocate and intialize memory/state */ +struct lilith* create_vm(size_t size) +{ + struct lilith* vm; + vm = calloc(1, sizeof(struct lilith)); + vm->memory = calloc(size, sizeof(uint8_t)); + vm->halted = false; + vm->exception = false; + return vm; +} + +/* Free up the memory we previously allocated */ +void destroy_vm(struct lilith* vm) +{ + free(vm->memory); + free(vm); +} + +/* Deal with 4OP */ +void decode_4OP(struct Instruction* c) +{ + c->raw_XOP = c->raw1; + c->XOP[0] = c->operation[2]; + c->XOP[1] = c->operation[3]; + c->raw_Immediate = 0; + c->reg0 = c->raw2/16; + c->reg1 = c->raw2%16; + c->reg2 = c->raw3/16; + c->reg3 = c->raw3%16; +} + +/* Deal with 3OP */ +void decode_3OP(struct Instruction* c) +{ + c->raw_XOP = c->raw1*0x10 + c->raw2/16; + c->XOP[0] = c->operation[2]; + c->XOP[1] = c->operation[3]; + c->XOP[2] = c->operation[4]; + c->raw_Immediate = 0; + c->reg0 = c->raw2%16; + c->reg1 = c->raw3/16; + c->reg2 = c->raw3%16; +} + +/* Deal with 2OP */ +void decode_2OP(struct Instruction* c) +{ + c->raw_XOP = c->raw1*0x100 + c->raw2; + c->XOP[0] = c->operation[2]; + c->XOP[1] = c->operation[3]; + c->XOP[2] = c->operation[4]; + c->XOP[3] = c->operation[5]; + c->raw_Immediate = 0; + c->reg0 = c->raw3/16; + c->reg1 = c->raw3%16; +} + +/* Deal with 1OP */ +void decode_1OP(struct Instruction* c) +{ + c->raw_XOP = c->raw1*0x1000 + c->raw2*0x10 + c->raw3/16; + c->XOP[0] = c->operation[2]; + c->XOP[1] = c->operation[3]; + c->XOP[2] = c->operation[4]; + c->XOP[3] = c->operation[5]; + c->XOP[4] = c->operation[6]; + c->raw_Immediate = 0; + c->reg0 = c->raw3%16; +} + +/* Deal with 2OPI */ +void decode_2OPI(struct Instruction* c) +{ + c->raw_Immediate = c->raw2*0x100 + c->raw3; + c->Immediate[0] = c->operation[4]; + c->Immediate[1] = c->operation[5]; + c->Immediate[2] = c->operation[6]; + c->Immediate[3] = c->operation[7]; + c->reg0 = c->raw1/16; + c->reg1 = c->raw1%16; +} + +/* Deal with 1OPI */ +void decode_1OPI(struct Instruction* c) +{ + c->raw_Immediate = c->raw2*0x100 + c->raw3; + c->Immediate[0] = c->operation[4]; + c->Immediate[1] = c->operation[5]; + c->Immediate[2] = c->operation[6]; + c->Immediate[3] = c->operation[7]; + c->HAL_CODE = 0; + c->raw_XOP = c->raw1/16; + c->XOP[0] = c->operation[2]; + c->reg0 = c->raw1%16; +} +/* Deal with 0OPI */ +void decode_0OPI(struct Instruction* c) +{ + c->raw_Immediate = c->raw2*0x100 + c->raw3; + c->Immediate[0] = c->operation[4]; + c->Immediate[1] = c->operation[5]; + c->Immediate[2] = c->operation[6]; + c->Immediate[3] = c->operation[7]; + c->HAL_CODE = 0; + c->raw_XOP = c->raw1; + c->XOP[0] = c->operation[2]; + c->XOP[1] = c->operation[3]; +} + +/* Deal with Halcode */ +void decode_HALCODE(struct Instruction* c) +{ + c->HAL_CODE = c->raw1*0x10000 + c->raw2*0x100 + c->raw3; +} + +/* Useful unpacking functions */ +void unpack_byte(uint8_t a, char* c) +{ + char table[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46}; + c[0] = table[a / 16]; + c[1] = table[a % 16]; +} + +/* Unpack the full instruction */ +void unpack_instruction(struct Instruction* c) +{ + unpack_byte(c->raw0, &(c->operation[0])); + unpack_byte(c->raw1, &(c->operation[2])); + unpack_byte(c->raw2, &(c->operation[4])); + unpack_byte(c->raw3, &(c->operation[6])); + c->opcode[0] = c->operation[0]; + c->opcode[1] = c->operation[1]; +} + /* Load program tape into Memory */ void load_program(struct lilith* vm, char **argv) { @@ -823,8 +1093,6 @@ bool eval_3OP_Int(struct lilith* vm, struct Instruction* c) /* Process 2OP Integer instructions */ bool eval_2OP_Int(struct lilith* vm, struct Instruction* c) { - int32_t tmp1 = (int32_t)(vm->reg[c->reg1]); - uint32_t utmp1 = vm->reg[c->reg1]; #ifdef DEBUG char Name[20] = "ILLEGAL_2OP"; #endif @@ -917,6 +1185,7 @@ bool eval_1OP_Int(struct lilith* vm, struct Instruction* c) #ifdef DEBUG char Name[20] = "ILLEGAL_1OP"; #endif + switch(c->raw_XOP) { case 0x00000: /* READPC */ @@ -1173,21 +1442,10 @@ bool eval_2OPI_Int(struct lilith* vm, struct Instruction* c) /* Process 1OPI Integer instructions */ bool eval_Integer_1OPI(struct lilith* vm, struct Instruction* c) { - bool C, B, O, GT, EQ, LT; - uint32_t tmp; #ifdef DEBUG char Name[20] = "ILLEGAL_1OPI"; #endif - tmp = vm->reg[c->reg0]; - - C = tmp & Carry; - B = tmp & Borrow; - O = tmp & Overflow; - GT = tmp & GreaterThan; - EQ = tmp & EQual; - LT = tmp & LessThan; - /* 0x2C */ switch(c->raw_XOP) { @@ -1303,6 +1561,7 @@ bool eval_branch_1OPI(struct lilith* vm, struct Instruction* c) #ifdef DEBUG char Name[20] = "ILLEGAL_1OPI"; #endif + switch(c->raw_XOP) { case 0x0: /* CALLI */ @@ -1400,6 +1659,7 @@ bool eval_Integer_0OPI(struct lilith* vm, struct Instruction* c) #ifdef DEBUG char Name[20] = "ILLEGAL_0OPI"; #endif + switch(c->raw_XOP) { case 0x00: /* JUMP */ diff --git a/vm.h b/vm.h index 58f6733..563aaf5 100644 --- a/vm.h +++ b/vm.h @@ -32,274 +32,3 @@ struct Instruction uint8_t reg3; bool invalid; }; - -/* Condition Codes */ -enum condition -{ -Carry = (1 << 5), -Borrow = (1 << 4), -Overflow = (1 << 3), -GreaterThan = (1 << 2), -EQual = (1 << 1), -LessThan = 1 -}; - -/* Allocate and intialize memory/state */ -struct lilith* create_vm(size_t size) -{ - struct lilith* vm; - vm = calloc(1, sizeof(struct lilith)); - vm->memory = calloc(size, sizeof(uint8_t)); - vm->halted = false; - vm->exception = false; - return vm; -} - -/* Free up the memory we previously allocated */ -void destroy_vm(struct lilith* vm) -{ - free(vm->memory); - free(vm); -} - -/* Deal with 4OP */ -void decode_4OP(struct Instruction* c) -{ - c->raw_XOP = c->raw1; - c->XOP[0] = c->operation[2]; - c->XOP[1] = c->operation[3]; - c->raw_Immediate = 0; - c->reg0 = c->raw2/16; - c->reg1 = c->raw2%16; - c->reg2 = c->raw3/16; - c->reg3 = c->raw3%16; -} - -/* Deal with 3OP */ -void decode_3OP(struct Instruction* c) -{ - c->raw_XOP = c->raw1*0x10 + c->raw2/16; - c->XOP[0] = c->operation[2]; - c->XOP[1] = c->operation[3]; - c->XOP[2] = c->operation[4]; - c->raw_Immediate = 0; - c->reg0 = c->raw2%16; - c->reg1 = c->raw3/16; - c->reg2 = c->raw3%16; -} - -/* Deal with 2OP */ -void decode_2OP(struct Instruction* c) -{ - c->raw_XOP = c->raw1*0x100 + c->raw2; - c->XOP[0] = c->operation[2]; - c->XOP[1] = c->operation[3]; - c->XOP[2] = c->operation[4]; - c->XOP[3] = c->operation[5]; - c->raw_Immediate = 0; - c->reg0 = c->raw3/16; - c->reg1 = c->raw3%16; -} - -/* Deal with 1OP */ -void decode_1OP(struct Instruction* c) -{ - c->raw_XOP = c->raw1*0x1000 + c->raw2*0x10 + c->raw3/16; - c->XOP[0] = c->operation[2]; - c->XOP[1] = c->operation[3]; - c->XOP[2] = c->operation[4]; - c->XOP[3] = c->operation[5]; - c->XOP[4] = c->operation[6]; - c->raw_Immediate = 0; - c->reg0 = c->raw3%16; -} - -/* Deal with 2OPI */ -void decode_2OPI(struct Instruction* c) -{ - c->raw_Immediate = c->raw2*0x100 + c->raw3; - c->Immediate[0] = c->operation[4]; - c->Immediate[1] = c->operation[5]; - c->Immediate[2] = c->operation[6]; - c->Immediate[3] = c->operation[7]; - c->reg0 = c->raw1/16; - c->reg1 = c->raw1%16; -} - -/* Deal with 1OPI */ -void decode_1OPI(struct Instruction* c) -{ - c->raw_Immediate = c->raw2*0x100 + c->raw3; - c->Immediate[0] = c->operation[4]; - c->Immediate[1] = c->operation[5]; - c->Immediate[2] = c->operation[6]; - c->Immediate[3] = c->operation[7]; - c->HAL_CODE = 0; - c->raw_XOP = c->raw1/16; - c->XOP[0] = c->operation[2]; - c->reg0 = c->raw1%16; -} -/* Deal with 0OPI */ -void decode_0OPI(struct Instruction* c) -{ - c->raw_Immediate = c->raw2*0x100 + c->raw3; - c->Immediate[0] = c->operation[4]; - c->Immediate[1] = c->operation[5]; - c->Immediate[2] = c->operation[6]; - c->Immediate[3] = c->operation[7]; - c->HAL_CODE = 0; - c->raw_XOP = c->raw1; - c->XOP[0] = c->operation[2]; - c->XOP[1] = c->operation[3]; -} - -/* Deal with Halcode */ -void decode_HALCODE(struct Instruction* c) -{ - c->HAL_CODE = c->raw1*0x10000 + c->raw2*0x100 + c->raw3; -} - -/* Useful unpacking functions */ -void unpack_byte(uint8_t a, char* c) -{ - char table[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46}; - c[0] = table[a / 16]; - c[1] = table[a % 16]; -} - -/* Unpack the full instruction */ -void unpack_instruction(struct Instruction* c) -{ - unpack_byte(c->raw0, &(c->operation[0])); - unpack_byte(c->raw1, &(c->operation[2])); - unpack_byte(c->raw2, &(c->operation[4])); - unpack_byte(c->raw3, &(c->operation[6])); - c->opcode[0] = c->operation[0]; - c->opcode[1] = c->operation[1]; -} - -/* Correctly write out bytes on little endian hardware */ -void writeout_Reg(struct lilith* vm, uint32_t p, uint32_t value) -{ - uint8_t raw0, raw1, raw2, raw3; - uint32_t tmp = value; - raw3 = tmp%0x100; - tmp = tmp/0x100; - raw2 = tmp%0x100; - tmp = tmp/0x100; - raw1 = tmp%0x100; - tmp = tmp/0x100; - raw0 = tmp%0x100; - - vm->memory[p] = raw0; - vm->memory[p + 1] = raw1; - vm->memory[p + 2] = raw2; - vm->memory[p + 3] = raw3; -} - -/* Allow the use of native data format for Register operations */ -uint32_t readin_Reg(struct lilith* vm, uint32_t p) -{ - uint8_t raw0, raw1, raw2, raw3; - uint32_t sum; - raw0 = vm->memory[p]; - raw1 = vm->memory[p + 1]; - raw2 = vm->memory[p + 2]; - raw3 = vm->memory[p + 3]; - - sum = raw0*0x1000000 + - raw1*0x10000 + - raw2*0x100 + - raw3; - - return sum; -} - -/* Unify byte write functionality */ -void writeout_byte(struct lilith* vm, uint32_t p, uint32_t value) -{ - vm->memory[p] = (uint8_t)(value%0x100); -} - -/* Unify byte read functionality*/ -uint32_t readin_byte(struct lilith* vm, uint32_t p, bool Signed) -{ - if(Signed) - { - int32_t raw0; - raw0 = (int8_t)(vm->memory[p]); - return (uint32_t)(raw0); - } - - return (uint32_t)(vm->memory[p]); -} - -/* Unify doublebyte write functionality */ -void writeout_doublebyte(struct lilith* vm, uint32_t p, uint32_t value) -{ - uint8_t uraw0, uraw1; - uint32_t utmp = value; - utmp = utmp%0x10000; - uraw1 = utmp%0x100; - utmp = utmp/0x100; - uraw0 = utmp%0x100; - - vm->memory[p] = uraw0; - vm->memory[p + 1] = uraw1; -} - -/* Unify doublebyte read functionality*/ -uint32_t readin_doublebyte(struct lilith* vm, uint32_t p, bool Signed) -{ - if(Signed) - { - int8_t raw0, raw1; - int32_t sum; - raw0 = vm->memory[p]; - raw1 = vm->memory[p + 1]; - - sum = raw0*0x100 + raw1; - return (uint32_t)(sum); - } - - uint8_t uraw0, uraw1; - uint32_t usum; - uraw0 = vm->memory[p]; - uraw1 = vm->memory[p + 1]; - - usum = uraw0*0x100 + uraw1; - return usum; -} - -/* Determine the result of bit shifting */ -uint32_t shift_register(uint32_t source, uint32_t amount, bool left, bool zero) -{ - uint32_t tmp = source; - - if(left) - { - while( amount > 0 ) - { - tmp = tmp * 2; - amount = amount - 1; - if(!zero) - { - tmp = tmp + 1; - } - } - } - else - { - while( amount > 0 ) - { - tmp = tmp / 2; - amount = amount - 1; - if(!zero) - { - tmp = tmp | (1 << 31); - } - } - } - - return tmp; -} diff --git a/vm_instructions.c b/vm_instructions.c index b79e514..c627d4a 100644 --- a/vm_instructions.c +++ b/vm_instructions.c @@ -2,6 +2,132 @@ FILE* tape_01; FILE* tape_02; +/* Correctly write out bytes on little endian hardware */ +void writeout_Reg(struct lilith* vm, uint32_t p, uint32_t value) +{ + uint8_t raw0, raw1, raw2, raw3; + uint32_t tmp = value; + raw3 = tmp%0x100; + tmp = tmp/0x100; + raw2 = tmp%0x100; + tmp = tmp/0x100; + raw1 = tmp%0x100; + tmp = tmp/0x100; + raw0 = tmp%0x100; + + vm->memory[p] = raw0; + vm->memory[p + 1] = raw1; + vm->memory[p + 2] = raw2; + vm->memory[p + 3] = raw3; +} + +/* Allow the use of native data format for Register operations */ +uint32_t readin_Reg(struct lilith* vm, uint32_t p) +{ + uint8_t raw0, raw1, raw2, raw3; + uint32_t sum; + raw0 = vm->memory[p]; + raw1 = vm->memory[p + 1]; + raw2 = vm->memory[p + 2]; + raw3 = vm->memory[p + 3]; + + sum = raw0*0x1000000 + + raw1*0x10000 + + raw2*0x100 + + raw3; + + return sum; +} + +/* Unify byte write functionality */ +void writeout_byte(struct lilith* vm, uint32_t p, uint32_t value) +{ + vm->memory[p] = (uint8_t)(value%0x100); +} + +/* Unify byte read functionality*/ +uint32_t readin_byte(struct lilith* vm, uint32_t p, bool Signed) +{ + if(Signed) + { + int32_t raw0; + raw0 = (int8_t)(vm->memory[p]); + return (uint32_t)(raw0); + } + + return (uint32_t)(vm->memory[p]); +} + +/* Unify doublebyte write functionality */ +void writeout_doublebyte(struct lilith* vm, uint32_t p, uint32_t value) +{ + uint8_t uraw0, uraw1; + uint32_t utmp = value; + utmp = utmp%0x10000; + uraw1 = utmp%0x100; + utmp = utmp/0x100; + uraw0 = utmp%0x100; + + vm->memory[p] = uraw0; + vm->memory[p + 1] = uraw1; +} + +/* Unify doublebyte read functionality*/ +uint32_t readin_doublebyte(struct lilith* vm, uint32_t p, bool Signed) +{ + if(Signed) + { + int8_t raw0, raw1; + int32_t sum; + raw0 = vm->memory[p]; + raw1 = vm->memory[p + 1]; + + sum = raw0*0x100 + raw1; + return (uint32_t)(sum); + } + + uint8_t uraw0, uraw1; + uint32_t usum; + uraw0 = vm->memory[p]; + uraw1 = vm->memory[p + 1]; + + usum = uraw0*0x100 + uraw1; + return usum; +} + +/* Determine the result of bit shifting */ +uint32_t shift_register(uint32_t source, uint32_t amount, bool left, bool zero) +{ + uint32_t tmp = source; + + if(left) + { + while( amount > 0 ) + { + tmp = tmp * 2; + amount = amount - 1; + if(!zero) + { + tmp = tmp + 1; + } + } + } + else + { + while( amount > 0 ) + { + tmp = tmp / 2; + amount = amount - 1; + if(!zero) + { + tmp = tmp | (1 << 31); + } + } + } + + return tmp; +} + void vm_FOPEN(struct lilith* vm) { if(0x00001100 == vm->reg[0]) @@ -96,6 +222,17 @@ void vm_FPUTC(struct lilith* vm) } } +/* Condition Codes */ +enum condition +{ +Carry = (1 << 5), +Borrow = (1 << 4), +Overflow = (1 << 3), +GreaterThan = (1 << 2), +EQual = (1 << 1), +LessThan = 1 +}; + bool Carry_bit_set(uint32_t a) { return a & Carry; @@ -1379,7 +1516,6 @@ void LOADUI(struct lilith* vm, struct Instruction* c) vm->reg[c->reg0] = c->raw_Immediate; } - void SALI(struct lilith* vm, struct Instruction* c) { vm->reg[c->reg0] = vm->reg[c->reg0] << c->raw_Immediate; diff --git a/vm_tests.c b/vm_tests.c deleted file mode 100644 index 3a1d8bc..0000000 --- a/vm_tests.c +++ /dev/null @@ -1,20 +0,0 @@ -#include "vm_instructions.c" - -int main(int argc, char **argv) -{ - /* Make sure we have a program tape to run */ - if (argc < 2) - { - fprintf(stderr, "Usage: %s $FileName\nWhere $FileName is the name of the paper tape of the program being run\n", argv[0]); - return EXIT_FAILURE; - } - - /* Perform all the essential stages in order */ - struct lilith* vm; - vm = create_vm(1 << 20); - struct Instruction* c = calloc(1, sizeof(struct Instruction)); - - destroy_vm(vm); - free(c); - return EXIT_SUCCESS; -}