Added indexed load/store instructions to vm, assembler and disassembler

This commit is contained in:
Jeremiah Orians 2016-06-11 11:43:01 -04:00
parent 67c0cda3d0
commit e58abb8fb8
No known key found for this signature in database
GPG Key ID: 7457821534D2ACCD
5 changed files with 412 additions and 97 deletions

View File

@ -23,13 +23,13 @@
01 0A ab cd # SUBU.BO a b c d :: a = b - c; d = BORROW? [unsigned]
01 0B ab cd # SUBU.BIO a b c d :: a = b - c - BORROW? d; d = BORROW? [unsigned]
**** long math
**** long math subgroup
01 0C ab cd # MULTIPLY a b c d :: a = MUL c d; b = MULH c d [signed]
01 0D ab cd # MULTIPLYU a b c d :: a = MUL c d; b = MULH c d [unsigned]
01 0E ab cd # DIVIDE a b c d :: a = DIV c d; b = MOD c d [signed]
01 0F ab cd # DIVIDEU a b c d :: a = DIV c d; b = MOD c d [unsigned]
**** Logic
**** Logic subgroup
01 10 ab cd # MUX a b c d :: a = (c & ~b) | (d & b)
01 11 ab cd # NMUX a b c d :: a = (c & b) | (d & ~b)
01 12 ab cd # SORT a b c d :: a = MAX(c, d); b = MIN(c, d) [signed]
@ -116,8 +116,36 @@
05 03 6a bc # ROL a b c :: a = ROL(b, c) [Circular rotate left]
05 03 7a bc # ROR a b c :: a = ROR(b, c) [Circular rotate right]
**** Load group
05 03 8a bc # LOADX a b c :: a = MEM[b+c]
05 03 9a bc # LOADX8 a b c :: a = MEM[b+c] [signed 8bits]
05 03 Aa bc # LOADXU8 a b c :: a = MEM[b+c] [unsigned 8bits]
05 03 Ba bc # LOADX16 a b c :: a = MEM[b+c] [signed 16bits]
05 03 Ca bc # LOADXU16 a b c :: a = MEM[b+c] [unsigned 16bits]
05 03 Da bc # LOADX32 a b c :: a = MEM[b+c] [signed 32bits]
05 03 Ea bc # LOADXU32 a b c :: a = MEM[b+c] [unsigned 32bits]
05 03 Fx xx # Reserved
05 04 0x xx # Reserved
05 04 1x xx # Reserved
05 04 2x xx # Reserved
05 04 3x xx # Reserved
05 04 4x xx # Reserved
05 04 5x xx # Reserved
05 04 6x xx # Reserved
05 04 7x xx # Reserved
**** Store group
05 04 8a bc # STOREX a b c :: MEM[b+c] = a
05 04 9a bc # STOREX8 a b c :: MEM[b+c] = a [8bits]
05 04 Aa bc # STOREX16 a b c :: MEM[b+c] = a [16bits]
05 04 Ba bc # STOREX32 a b c :: MEM[b+c] = a [32bits]
05 04 Cx xx # Reserved
05 04 Dx xx # Reserved
05 04 Ex xx # Reserved
05 04 Fx xx # Reserved
**** Reserved group 2
05 03 8x xx # Reserved
05 05 0x xx # Reserved
...
05 FF Fx xx # Reserved
@ -221,11 +249,11 @@
*** 2OPI Integer store
20 ab ii ii # STORE a b ii :: MEM[b + ii ii] = a
21 ab ii ii # STORE8 a b ii :: MEM[b + ii ii] = a [signed 8bits]
22 ab ii ii # STOREU8 a b ii :: MEM[b + ii ii] = a [unsigned 8bits]
23 ab ii ii # STORE16 a b ii :: MEM[b + ii ii] = a [signed 16bits]
24 ab ii ii # STOREU16 a b ii :: MEM[b + ii ii] = a [unsigned 16bits]
25 ab ii ii # STORE32 a b ii :: MEM[b + ii ii] = a [signed 32bits]
26 ab ii ii # STOREU32 a b ii :: MEM[b + ii ii] = a [unsigned 32bits]
22 ab ii ii # STORE16 a b ii :: MEM[b + ii ii] = a [signed 16bits]
23 ab ii ii # STORE32 a b ii :: MEM[b + ii ii] = a [signed 32bits]
24 ab ii ii # Reserved
25 ab ii ii # Reserved
26 ab ii ii # Reserved
27 ab ii ii # Reserved
28 ab ii ii # Reserved
29 ab ii ii # Reserved

18
asm.c
View File

@ -232,6 +232,17 @@ void assemble(struct Token* p)
setExpression(p, "SR1", "05035", 4);
setExpression(p, "ROL", "05036", 4);
setExpression(p, "ROR", "05037", 4);
setExpression(p, "LOADX", "05038", 4);
setExpression(p, "LOADX8", "05039", 4);
setExpression(p, "LOADXU8", "0503A", 4);
setExpression(p, "LOADX16", "0503B", 4);
setExpression(p, "LOADXU16", "0503C", 4);
setExpression(p, "LOADX32", "0503D", 4);
setExpression(p, "LOADXU32", "0503E", 4);
setExpression(p, "STOREX", "05048", 4);
setExpression(p, "STOREX8", "05049", 4);
setExpression(p, "STOREX16", "0504A", 4);
setExpression(p, "STOREX32", "0504B", 4);
/* 2OP Integer Group */
setExpression(p, "NEG", "090000", 4);
@ -269,11 +280,8 @@ void assemble(struct Token* p)
setExpression(p, "CMPUI", "1F", 4);
setExpression(p, "STORE", "20", 4);
setExpression(p, "STORE8", "21", 4);
setExpression(p, "STOREU8", "22", 4);
setExpression(p, "STORE16", "23", 4);
setExpression(p, "STOREU16", "24", 4);
setExpression(p, "STORE32", "25", 4);
setExpression(p, "STOREU32", "26", 4);
setExpression(p, "STORE16", "22", 4);
setExpression(p, "STORE32", "23", 4);
/* 1OPI Group */
setExpression(p, "JUMP.C", "2C0", 4);

View File

@ -189,7 +189,7 @@ void decode_Integer_4OP(struct Instruction* c)
break;
}
}
fprintf(stdout, "%s reg%o reg%o reg%o reg%o\t", Name, c->reg0, c->reg1, c->reg2, c->reg3);
fprintf(stdout, "%s reg%u reg%u reg%u reg%u\t", Name, c->reg0, c->reg1, c->reg2, c->reg3);
fprintf(stdout, "# %s\n", c->operation);
}
@ -430,13 +430,68 @@ void decode_Integer_3OP(struct Instruction* c)
strncpy(Name, "ROR", 19);
break;
}
case 0x038: /* LOADX */
{
strncpy(Name, "LOADX", 19);
break;
}
case 0x039: /* LOADX8 */
{
strncpy(Name, "LOADX8", 19);
break;
}
case 0x03A: /* LOADXU8 */
{
strncpy(Name, "LOADXU8", 19);
break;
}
case 0x03B: /* LOADX16 */
{
strncpy(Name, "LOADX16", 19);
break;
}
case 0x03C: /* LOADXU16 */
{
strncpy(Name, "LOADXU16", 19);
break;
}
case 0x03D: /* LOADX32 */
{
strncpy(Name, "LOADX32", 19);
break;
}
case 0x03E: /* LOADXU32 */
{
strncpy(Name, "LOADXU32", 19);
break;
}
case 0x048: /* STOREX */
{
strncpy(Name, "STOREX", 19);
break;
}
case 0x049: /* STOREX8 */
{
strncpy(Name, "STOREX8", 19);
break;
}
case 0x04A: /* STOREX16 */
{
strncpy(Name, "STOREX16", 19);
break;
}
case 0x04B: /* STOREX32 */
{
strncpy(Name, "STOREX32", 19);
break;
}
default: /* Unknown 3OP*/
{
break;
}
}
fprintf(stdout, "%s reg%o reg%o reg%o\t", Name, c->reg0, c->reg1, c->reg2);
fprintf(stdout, "%s reg%u reg%u reg%u\t", Name, c->reg0, c->reg1, c->reg2);
fprintf(stdout, "# %s\n", c->operation);
}
@ -503,7 +558,7 @@ void decode_Integer_2OP(struct Instruction* c)
}
}
fprintf(stdout, "%s reg%o reg%o\t", Name, c->reg0, c->reg1);
fprintf(stdout, "%s reg%u reg%u\t", Name, c->reg0, c->reg1);
fprintf(stdout, "# %s\n", c->operation);
}
@ -570,7 +625,7 @@ void decode_1OP(struct Instruction* c)
}
}
fprintf(stdout, "%s reg%o\t", Name, c->reg0);
fprintf(stdout, "%s reg%u\t", Name, c->reg0);
fprintf(stdout, "# %s\n", c->operation);
}
@ -706,38 +761,23 @@ void decode_Integer_2OPI(struct Instruction* c)
strncpy(Name, "STORE8", 19);
break;
}
case 0x22: /* STOREU8 */
{
strncpy(Name, "STOREU8", 19);
break;
}
case 0x23: /* STORE16 */
case 0x22: /* STORE16 */
{
strncpy(Name, "STORE16", 19);
break;
}
case 0x24: /* STOREU16 */
{
strncpy(Name, "STOREU16", 19);
break;
}
case 0x25: /* STORE32 */
case 0x23: /* STORE32 */
{
strncpy(Name, "STORE32", 19);
break;
}
case 0x26: /* STOREU32 */
{
strncpy(Name, "STOREU32", 19);
break;
}
default: /* Unknown 2OPI*/
{
break;
}
}
fprintf(stdout, "%s reg%o reg%o 0x%x\t", Name, c->reg0, c->reg1, c->raw_Immediate);
fprintf(stdout, "%s reg%u reg%u 0x%x\t", Name, c->reg0, c->reg1, c->raw_Immediate);
fprintf(stdout, "# %s\n", c->operation);
}
@ -820,7 +860,7 @@ void decode_1OPI(struct Instruction* c)
}
}
fprintf(stdout, "%s reg%o %d\t", Name, c->reg0, c->raw_Immediate);
fprintf(stdout, "%s reg%u %d\t", Name, c->reg0, c->raw_Immediate);
fprintf(stdout, "# %s\n", c->operation);
}
@ -893,7 +933,7 @@ void decode_Branch_1OPI(struct Instruction* c)
}
}
fprintf(stdout, "%s reg%o %d\t", Name, c->reg0, c->raw_Immediate);
fprintf(stdout, "%s reg%u %d\t", Name, c->reg0, c->raw_Immediate);
fprintf(stdout, "# %s\n", c->operation);
}

300
vm.c

File diff suppressed because it is too large Load Diff

59
vm.h
View File

@ -200,7 +200,8 @@ void writeout_Reg(struct lilith* vm, uint32_t p, uint32_t value)
/* 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, sum;
uint8_t raw0, raw1, raw2, raw3;
uint32_t sum;
raw0 = vm->memory[p];
raw1 = vm->memory[p + 1];
raw2 = vm->memory[p + 2];
@ -214,6 +215,62 @@ uint32_t readin_Reg(struct lilith* vm, uint32_t p)
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)
{