andrius
/
stage0
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added the Compare and Jump instructions

This commit is contained in:
Jeremiah Orians 2016-06-25 22:47:49 -04:00
parent 5c7119ca36
commit 9df3924351
No known key found for this signature in database
GPG Key ID: 7457821534D2ACCD
5 changed files with 340 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
ISA_HEX_Map.org
View File

@ -344,8 +344,8 @@
| 2C 8a ii ii | JUMP.L a ii ii | LT? a; PC = PC + i ii ii |
| 2C 9a ii ii | JUMP.Z a ii ii | ZERO? a; PC = PC + i ii ii |
| 2C Aa ii ii | JUMP.NZ a ii ii | NZERO? a; PC = PC + i ii ii |
| 2C Bx xx xx | Reserved | |
| 2C Cx xx xx | Reserved | |
| 2C Ba ii ii | JUMP.P | POSITIVE? a; PC = PC + ii ii |
| 2C Ca ii ii | JUMP.NP | NEGATIVE? a; PC = PC + ii ii |
| 2C Dx xx xx | Reserved | |
| 2C Ex xx xx | Reserved | |
| 2C Fx xx xx | Reserved | |
@ -506,6 +506,37 @@ DO NOT USE.
|-------------+----------|
| 43 00 00 00 | Reserved |
| ... | Reserved |
| BF FF FF FF | Reserved |
** CMPJUMP Group
| Hex | Name | Comment |
|-------------+-------------+-------------------------------------|
| C0 ab ii ii | CMPJUMP.G | a > b ? PC = PC + ii ii |
| C1 ab ii ii | CMPJUMP.GE | a >= b ? PC = PC + ii ii |
| C2 ab ii ii | CMPJUMP.E | a == b ? PC = PC + ii ii |
| C3 ab ii ii | CMPJUMP.NE | a != b ? PC = PC + ii ii |
| C4 ab ii ii | CMPJUMP.LE | a <= b ? PC = PC + ii ii |
| C5 ab ii ii | CMPJUMP.L | a < b ? PC = PC + ii ii |
| C6 ab ii ii | Reserved | |
| ... | Reserved | |
| CF ab ii ii | Reserved | |
| D0 ab ii ii | CMPJUMPU.G | a > b ? PC = PC + ii ii (unsigned) |
| D1 ab ii ii | CMPJUMPU.GE | a >= b ? PC = PC + ii ii (unsigned) |
| D2 ab ii ii | Reserved | |
| D3 ab ii ii | Reserved | |
| D4 ab ii ii | CMPJUMPU.LE | a <= b ? PC = PC + ii ii (unsigned) |
| D5 ab ii ii | CMPJUMPU.L | a < b ? PC = PC + ii ii (unsigned) |
| D6 ab ii ii | Reserved | |
| ... | Reserved | |
| DF ab ii ii | Reserved | |
** Reserved Block 2
At this time these instructions only produce a warning; but could do anything.
DO NOT USE.
| Hex | Name |
|-------------+----------|
| E0 00 00 00 | Reserved |
| ... | Reserved |
| FE FF FF FF | Reserved |
** 0OP

12
asm.c
View File

@ -282,6 +282,16 @@ void assemble(struct Token* p)
setExpression(p, "STORE8", "21", 4);
setExpression(p, "STORE16", "22", 4);
setExpression(p, "STORE32", "23", 4);
setExpression(p, "CMPJUMP.G", "C0", 4);
setExpression(p, "CMPJUMP.GE", "C1", 4);
setExpression(p, "CMPJUMP.E", "C2", 4);
setExpression(p, "CMPJUMP.NE", "C3", 4);
setExpression(p, "CMPJUMP.LE", "C4", 4);
setExpression(p, "CMPJUMP.L", "C5", 4);
setExpression(p, "CMPJUMPU.G", "D0", 4);
setExpression(p, "CMPJUMPU.GE", "D1", 4);
setExpression(p, "CMPJUMPU.LE", "D4", 4);
setExpression(p, "CMPJUMPU.L", "D5", 4);
/* 1OPI Group */
setExpression(p, "JUMP.C", "2C0", 4);
@ -295,6 +305,8 @@ void assemble(struct Token* p)
setExpression(p, "JUMP.L", "2C8", 4);
setExpression(p, "JUMP.Z", "2C9", 4);
setExpression(p, "JUMP.NZ", "2CA", 4);
setExpression(p, "JUMP.P", "2CB", 4);
setExpression(p, "JUMP.NP", "2CC", 4);
setExpression(p, "CALLI", "2D0", 4);
setExpression(p, "LOADI", "2D1", 4);
setExpression(p, "LOADUI", "2D2", 4);

61
disasm.c
View File

@ -771,6 +771,56 @@ void decode_Integer_2OPI(struct Instruction* c)
strncpy(Name, "STORE32", 19);
break;
}
case 0xC0: /* CMPJUMP.G */
{
strncpy(Name, "CMPJUMP.G", 19);
break;
}
case 0xC1: /* CMPJUMP.GE */
{
strncpy(Name, "CMPJUMP.GE", 19);
break;
}
case 0xC2: /* CMPJUMP.E */
{
strncpy(Name, "CMPJUMP.E", 19);
break;
}
case 0xC3: /* CMPJUMP.NE */
{
strncpy(Name, "CMPJUMP.NE", 19);
break;
}
case 0xC4: /* CMPJUMP.LE */
{
strncpy(Name, "CMPJUMP.LE", 19);
break;
}
case 0xC5: /* CMPJUMP.L */
{
strncpy(Name, "CMPJUMP.L", 19);
break;
}
case 0xD0: /* CMPJUMPU.G */
{
strncpy(Name, "CMPJUMPU.G", 19);
break;
}
case 0xD1: /* CMPJUMPU.GE */
{
strncpy(Name, "CMPJUMPU.GE", 19);
break;
}
case 0xD4: /* CMPJUMPU.LE */
{
strncpy(Name, "CMPJUMPU.LE", 19);
break;
}
case 0xD5: /* CMPJUMPU.L */
{
strncpy(Name, "CMPJUMPU.L", 19);
break;
}
default: /* Unknown 2OPI*/
{
break;
@ -854,6 +904,16 @@ void decode_1OPI(struct Instruction* c)
strncpy(Name, "JUMP.NZ", 19);
break;
}
case 0xB: /* JUMP.P */
{
strncpy(Name, "JUMP.P", 19);
break;
}
case 0xC: /* JUMP.NP */
{
strncpy(Name, "JUMP.NP", 19);
break;
}
default: /* Unknown 1OPI*/
{
break;
@ -1161,6 +1221,7 @@ void eval_instruction(struct Instruction* c)
break;
}
case 0x0E ... 0x2B: /* Core 2OPI */
case 0xC0 ... 0xDF:
{
decode_Integer_2OPI(c);
break;

122
vm.c
View File

@ -150,6 +150,18 @@ void STORER8(struct lilith* vm, struct Instruction* c);
void STORER16(struct lilith* vm, struct Instruction* c);
void STORER32(struct lilith* vm, struct Instruction* c);
void JUMP(struct lilith* vm, struct Instruction* c);
void JUMP_P(struct lilith* vm, struct Instruction* c);
void JUMP_NP(struct lilith* vm, struct Instruction* c);
void CMPJUMP_G(struct lilith* vm, struct Instruction* c);
void CMPJUMP_GE(struct lilith* vm, struct Instruction* c);
void CMPJUMP_E(struct lilith* vm, struct Instruction* c);
void CMPJUMP_NE(struct lilith* vm, struct Instruction* c);
void CMPJUMP_LE(struct lilith* vm, struct Instruction* c);
void CMPJUMP_L(struct lilith* vm, struct Instruction* c);
void CMPJUMPU_G(struct lilith* vm, struct Instruction* c);
void CMPJUMPU_GE(struct lilith* vm, struct Instruction* c);
void CMPJUMPU_LE(struct lilith* vm, struct Instruction* c);
void CMPJUMPU_L(struct lilith* vm, struct Instruction* c);
/* Allocate and intialize memory/state */
struct lilith* create_vm(size_t size)
@ -1297,6 +1309,7 @@ bool eval_2OPI_Int(struct lilith* vm, struct Instruction* c)
#endif
/* 0x0E ... 0x2B */
/* 0xC0 ... 0xDF */
switch(c->raw0)
{
case 0x0E: /* ADDI */
@ -1452,6 +1465,96 @@ bool eval_2OPI_Int(struct lilith* vm, struct Instruction* c)
STORE32(vm, c);
break;
}
case 0xC0: /* CMPJUMP.G */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMP.G", 19);
#endif
CMPJUMP_G(vm, c);
break;
}
case 0xC1: /* CMPJUMP.GE */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMP.GE", 19);
#endif
CMPJUMP_GE(vm, c);
break;
}
case 0xC2: /* CMPJUMP.E */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMP.E", 19);
#endif
CMPJUMP_E(vm, c);
break;
}
case 0xC3: /* CMPJUMP.NE */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMP.NE", 19);
#endif
CMPJUMP_NE(vm, c);
break;
}
case 0xC4: /* CMPJUMP.LE */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMP.LE", 19);
#endif
CMPJUMP_LE(vm, c);
break;
}
case 0xC5: /* CMPJUMP.L */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMP.L", 19);
#endif
CMPJUMP_L(vm, c);
break;
}
case 0xD0: /* CMPJUMPU.G */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMPU.G", 19);
#endif
CMPJUMPU_G(vm, c);
break;
}
case 0xD1: /* CMPJUMPU.GE */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMPU.GE", 19);
#endif
CMPJUMPU_GE(vm, c);
break;
}
case 0xD4: /* CMPJUMPU.LE */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMPU.LE", 19);
#endif
CMPJUMPU_LE(vm, c);
break;
}
case 0xD5: /* CMPJUMPU.L */
{
#ifdef DEBUG
strncpy(Name, "CMPJUMPU.L", 19);
#endif
CMPJUMPU_L(vm, c);
break;
}
default: return true;
}
#ifdef DEBUG
@ -1569,6 +1672,24 @@ bool eval_Integer_1OPI(struct lilith* vm, struct Instruction* c)
JUMP_NZ(vm, c);
break;
}
case 0xB: /* JUMP.P */
{
#ifdef DEBUG
strncpy(Name, "JUMP.P", 19);
#endif
JUMP_P(vm, c);
break;
}
case 0xC: /* JUMP.NP */
{
#ifdef DEBUG
strncpy(Name, "JUMP.NP", 19);
#endif
JUMP_NP(vm, c);
break;
}
default: return true;
}
#ifdef DEBUG
@ -1884,6 +2005,7 @@ void eval_instruction(struct lilith* vm, struct Instruction* current)
break;
}
case 0x0E ... 0x2B: /* Integer 2OPI */
case 0xC0 ... 0xDF:
{
decode_2OPI(current);
invalid = eval_2OPI_Int(vm, current);

112
vm_instructions.c
View File

@ -1616,3 +1616,115 @@ void JUMP(struct lilith* vm, struct Instruction* c)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
void JUMP_P(struct lilith* vm, struct Instruction* c)
{
int32_t tmp1;
tmp1 = (int32_t)(vm->reg[c->reg0]);
if(0 <= tmp1)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void JUMP_NP(struct lilith* vm, struct Instruction* c)
{
int32_t tmp1;
tmp1 = (int32_t)(vm->reg[c->reg0]);
if(0 > tmp1)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMP_G(struct lilith* vm, struct Instruction* c)
{
int32_t tmp1, tmp2;
tmp1 = (int32_t)(vm->reg[c->reg0]);
tmp2 = (int32_t)(vm->reg[c->reg1]);
if(tmp1 > tmp2)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMP_GE(struct lilith* vm, struct Instruction* c)
{
int32_t tmp1, tmp2;
tmp1 = (int32_t)(vm->reg[c->reg0]);
tmp2 = (int32_t)(vm->reg[c->reg1]);
if(tmp1 >= tmp2)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMP_E(struct lilith* vm, struct Instruction* c)
{
if((vm->reg[c->reg0]) == (vm->reg[c->reg1]))
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMP_NE(struct lilith* vm, struct Instruction* c)
{
if((vm->reg[c->reg0]) != (vm->reg[c->reg1]))
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMP_LE(struct lilith* vm, struct Instruction* c)
{
int32_t tmp1, tmp2;
tmp1 = (int32_t)(vm->reg[c->reg0]);
tmp2 = (int32_t)(vm->reg[c->reg1]);
if(tmp1 <= tmp2)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMP_L(struct lilith* vm, struct Instruction* c)
{
int32_t tmp1, tmp2;
tmp1 = (int32_t)(vm->reg[c->reg0]);
tmp2 = (int32_t)(vm->reg[c->reg1]);
if(tmp1 < tmp2)
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMPU_G(struct lilith* vm, struct Instruction* c)
{
if((vm->reg[c->reg0]) > (vm->reg[c->reg1]))
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMPU_GE(struct lilith* vm, struct Instruction* c)
{
if((vm->reg[c->reg0]) >= (vm->reg[c->reg1]))
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMPU_LE(struct lilith* vm, struct Instruction* c)
{
if((vm->reg[c->reg0]) <= (vm->reg[c->reg1]))
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}
void CMPJUMPU_L(struct lilith* vm, struct Instruction* c)
{
if((vm->reg[c->reg0]) < (vm->reg[c->reg1]))
{
vm->ip = vm->ip + c->raw_Immediate - 4;
}
}