+ d'opcodes

CMakeLists.txt

@@ -11,12 +11,15 @@ set(SRCS
     src/instructions/movw.c
     src/instructions/shift.c
     src/instructions/operations.c
+    src/instructions/logic.c
     src/instructions/jmp.c
     src/syscall/bdisp.c
     src/syscall/text.c
+    src/syscall/malloc.c
     src/display.c
     src/instructions/system.c
     src/log.c
+    src/memory.c
 )
 
 find_package(SDL2 REQUIRED)

src/cpu.c

@@ -46,8 +46,12 @@ int cpu_setup_addin(cpu_status_t* status,char* _file){
     status->display = malloc(sizeof(display_t));
     display_init(status->display);
     display_clear(status->display);
-    display_update(status->display);
 
+    status->malloc.lo_mem = 0x08100000 + 32768;
+    status->malloc.hi_mem = 0x08100000 + 524288 - 16384;
+    status->malloc.margin = 0x200;
+    status->malloc.allocs = 0;
+    status->malloc.mallocs = malloc(0);
 }
 
 int cpu_run(cpu_status_t* status){
@@ -55,7 +59,7 @@ int cpu_run(cpu_status_t* status){
 }
 
 uint32_t cpu_read32(cpu_status_t* status, uint32_t addr){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
+    if(addr >=0x08100000 && addr <= 0x08100000+524288){
         uint32_t ret;
         ret = decode(status->ram[addr-0x08100000+3], status->ram[addr-0x08100000+2], status->ram[addr-0x08100000+1], status->ram[addr-0x08100000]);
         return ret;
@@ -72,7 +76,7 @@ uint32_t cpu_read32(cpu_status_t* status, uint32_t addr){
 }
 
 uint16_t cpu_read16(cpu_status_t* status, uint32_t addr){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
+    if(addr >=0x08100000 && addr <= 0x08100000+524288){
         uint16_t ret;
         //ret = (uint16_t)status->ram[addr-0x08100000];
         ret = status->ram[addr-0x08100000+1];
@@ -97,7 +101,7 @@ uint16_t cpu_read16(cpu_status_t* status, uint32_t addr){
 }
 
 uint8_t cpu_read8(cpu_status_t* status, uint32_t addr){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
+    if(addr >=0x08100000 && addr <= 0x08100000+524288){
         uint8_t ret;
         ret = status->ram[addr-0x08100000];
         return ret;
@@ -120,7 +124,7 @@ uint8_t cpu_read8(cpu_status_t* status, uint32_t addr){
 }
 
 void cpu_write32(cpu_status_t* status, uint32_t addr, uint32_t data){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
+    if(addr >=0x08100000 && addr <= 0x08100000+524288){
         unsigned char bytes[4];
 
         status->ram[addr-0x08100000] = (data >> 24) & 0xFF;
@@ -128,9 +132,9 @@ void cpu_write32(cpu_status_t* status, uint32_t addr, uint32_t data){
         status->ram[addr-0x08100000+2] = (data >> 8) & 0xFF;
         status->ram[addr-0x08100000+3] = data & 0xFF;
     }
-    else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
+    /*else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
         memcpy(&status->rom[addr-0x00300200], &addr, 4);
-    }
+    }*/
     else if(addr >=0x01100000 && addr <= 0x01100000+8192){
         status->vram[addr-0x01100000] = (data >> 24) & 0xFF;
         status->vram[addr-0x01100000+1] = (data >> 16) & 0xFF;
@@ -143,24 +147,24 @@ void cpu_write32(cpu_status_t* status, uint32_t addr, uint32_t data){
 }
 
 void cpu_write16(cpu_status_t* status, uint32_t addr, uint16_t data){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
+    if(addr >=0x08100000 && addr <= 0x08100000+524288){
         memcpy(&status->ram[addr-0x08100000],&data, 2);
     }
-    else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
+    /*else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
         memcpy(&status->rom[addr-0x00300200], &addr, 2);
-    }
+    }*/
     else{
         log_mem_write_error(status, addr);
     }
 }
 
 void cpu_write8(cpu_status_t* status, uint32_t addr, uint8_t data){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
+    if(addr >=0x08100000 && addr <= 0x08100000+524288){
         status->ram[addr-0x08100000] = data;     
     }
-    else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
+    /*else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
         status->rom[addr-0x00300200] = data;
-    }
+    }*/
     else if(addr >=0x01100000 && addr <= 0x01100000+8192){
         status->vram[addr-0x01100000] = data;
     }
@@ -182,13 +186,13 @@ int cpu_execute(cpu_status_t* status){
         status->r[0],status->r[1],status->r[2],status->r[3],
         status->r[4],status->r[5],status->r[6],status->r[15]
     );*/
-    printf("pc: %8x pr: %8x r0: %8x r1: %8x r2: %8x r3: %8x r4: %8x r5: %8x r6: %8x r7: %8x r8: %8x r9: %8x r15: %08x\n",
-        status->pc,status->pr,
+    /*printf("pc: %8x %02x%02x pr: %8x r0: %8x r1: %8x r2: %8x r3: %8x r4: %8x r5: %8x r6: %8x r7: %8x r8: %8x r9: %8x r15: %08x\n",
+        status->pc,cpu_read8(status,status->pc),cpu_read8(status,status->pc+1), status->pr,
         status->r[0],status->r[1],status->r[2],status->r[3],
         status->r[4],status->r[5],status->r[6],
         status->r[7],status->r[8],status->r[9],
         status->r[15]
-    );
+    );*/
 
     if(nibble[0] == 0b0110 && nibble[3] == 0b0011) instruction_mov_r_r(status);
     else if(nibble[0] == 0b1110) instruction_mov_imm_r(status);
@@ -207,6 +211,7 @@ int cpu_execute(cpu_status_t* status){
     else if(nibble[0] == 0b1000 && nibble[1] == 0b0101) instruction_movw_disp_r_r0(status);
     else if(nibble[0] == 0b1001) instruction_movw_disp_pc_r0(status);
     else if(nibble[0] == 0b0010 && nibble[3] == 0b0001) instruction_movw_r_ar(status);
+    else if(nibble[0] == 0b0110 && nibble[3] == 0b0101) instruction_movw_arp_r(status);
 
     else if(nibble[0] == 0b0110 && nibble[3] == 0b0000) instruction_movb_ar_r(status);
     else if(nibble[0] == 0b0010 && nibble[3] == 0b0000) instruction_movb_r_ar(status);
@@ -216,9 +221,13 @@ int cpu_execute(cpu_status_t* status){
     else if(nibble[0] == 0b0000 && nibble[3] == 0b1100) instruction_movb_r0_r_r(status);
     else if(nibble[0] == 0b0000 && nibble[3] == 0b0100) instruction_movb_r_r0_r(status);
     else if(nibble[0] == 0b1100 && nibble[1] == 0b0100) instruction_movb_disp_gbr_r0(status);
-    else if(nibble[0] == 0b1000 && nibble[1] == 0b0000) instruction_movw_r0_disp_r(status);
+    else if(nibble[0] == 0b1000 && nibble[1] == 0b0000) instruction_movb_r0_disp_r(status);
 
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b0100) instruction_roctl_r(status);
+    else if(nibble[0] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b0001) instruction_shar_r(status);
+    else if(nibble[0] == 0b0100 && nibble[2] == 0b0000 && nibble[3] == 0b1000) instruction_shll2_r(status);
+    else if(nibble[0] == 0b0100 && nibble[2] == 0b0000 && nibble[3] == 0b0001) instruction_shlr_r(status);
+    else if(nibble[0] == 0b0100 && nibble[2] == 0b0000 && nibble[3] == 0b1001) instruction_shlr2_r(status);
 
     else if(nibble[0] == 0b0011 && nibble[3] == 0b0100) instruction_div1_r_r(status);
     else if(nibble[0] == 0b0011 && nibble[3] == 0b1100) instruction_add_r_r(status);
@@ -231,15 +240,20 @@ int cpu_execute(cpu_status_t* status){
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0001 && nibble[3] == 0b0101) instruction_cmp_pl_r(status);
     else if(nibble[0] == 0b1000 && nibble[1] == 0b1000) instruction_cmp_eq_imm_r0(status);
     else if(nibble[0] == 0b0011 && nibble[3] == 0b0110) instruction_cmp_hi_r_r(status);
+    else if(nibble[0] == 0b0011 && nibble[3] == 0b0011) instruction_cmp_ge_r_r(status);
+    else if(nibble[0] == 0b0000 && nibble[3] == 0b0111) instruction_mull_r_r(status);
+    else if(nibble[0] == 0b0011 && nibble[3] == 0b0000) instruction_cmp_eq_r_r(status);
 
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b1011) instruction_jmp_r(status);
     else if(nibble[0] == 0b1011) instruction_bsr_lbl(status);
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0000 && nibble[3] == 0b1011) instruction_jsr_ar(status);
-    else if(nibble[0] == 0b0000 && nibble[2] == 0b0000 && nibble[2] == 0b0000 && nibble[3] == 0b1011) instruction_rts(status);
+    else if(nibble[0] == 0b0000 && nibble[1] == 0b0000 && nibble[2] == 0b0000 && nibble[3] == 0b1011) instruction_rts(status);
+    else if(cpu_read8(status,status->pc) == 0x00 && cpu_read8(status,status->pc+1) == 0x0b) instruction_rts(status);
     else if(nibble[0] == 0b1000 && nibble[1] == 0b1011 ) instruction_bf_lbl(status);
     else if(nibble[0] == 0b1010) instruction_bra_lbl(status);
     else if(nibble[0] == 0b1000 && nibble[1] == 0b1001 ) instruction_bt_lbl(status);
     else if(nibble[0] == 0b1000 && nibble[1] == 0b1101 ) instruction_bts_lbl(status);
+    else if(nibble[0] == 0b1000 && nibble[1] == 0b1111 ) instruction_bfs_lbl(status);
 
     else if(nibble[0] == 0b0000 && nibble[1] == 0b0000 && nibble[2] == 0b0000 && nibble[3] == 0b1001) instruction_nop(status);
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0000 && nibble[3] == 0b0010) instruction_stsl_mash_amr(status);
@@ -247,8 +261,13 @@ int cpu_execute(cpu_status_t* status){
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b0010) instruction_stsl_pr_amr(status);
     else if(nibble[0] == 0b0000 && nibble[1] == 0b0000 && nibble[2] == 0b0000 && nibble[3] == 0b1000) instruction_clrt(status);
     else if(nibble[0] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b0110) instruction_ldsl_arp_pr(status);
+    else if(nibble[0] == 0b0100 && nibble[2] == 0b0001 && nibble[3] == 0b0110) instruction_ldsl_arp_macl(status);
+    else if(nibble[0] == 0b0000 && nibble[2] == 0b0001 && nibble[3] == 0b1010) instruction_sts_macl_r(status);
 
-    else{status->pc += 2; printf("\e[33munkdown opcode, skipping...\e[39m\n");return 1;}
+    else if(nibble[0] == 0b0010 && nibble[3] == 0b1000) instruction_tst_r_r(status);
+    else if(nibble[0] == 0b0010 && nibble[3] == 0b1011) instruction_or_r_r(status);
+
+    else{ printf("\e[33mpc: %8x unkdown opcode, skipping...\e[39m\n",status->pc);status->pc += 2;return 1;}
     return 0;
 }
 
@@ -259,10 +278,11 @@ int cpu_run_from(cpu_status_t* status, uint32_t addr){
 
     while (status->pc-0x00300200 < status->program_size){
         if(cpu_execute(status)){
+            printf("err\n");
             total_error++;
         }
         total_executions++;
-        if(total_executions > 150000){
+        if(total_executions > 100000000){
             break;
         }
     }

src/cpu.h

@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <display.h>
+#include <memory.h>
 #pragma once
 
 typedef struct{
@@ -13,8 +14,8 @@ typedef struct{
     uint32_t gbr;
 
     uint8_t* rom;
-    uint8_t ram[32768*8]; // 0x08100000
-    uint8_t vram[8192];
+    uint8_t ram[524288]; // 0x08100000
+    uint8_t vram[8192]; // 0x01100000
 
     uint32_t program_size;
 
@@ -25,6 +26,8 @@ typedef struct{
     uint32_t cursor_x;
     uint32_t cursor_y;
 
+    malloc_table_t malloc;
+
     display_t* display;
 }cpu_status_t;
 
@@ -37,6 +40,8 @@ uint32_t cpu_read32(cpu_status_t*, uint32_t);
 uint16_t cpu_read16(cpu_status_t*, uint32_t);
 uint8_t cpu_read8(cpu_status_t*, uint32_t);
 
+void display_update(display_t* display, cpu_status_t* status);
+
 void cpu_write32(cpu_status_t* status, uint32_t addr, uint32_t data);
 void cpu_write16(cpu_status_t* status, uint32_t addr, uint16_t data);
 void cpu_write8(cpu_status_t* status, uint32_t addr, uint8_t data);

src/display.c

@@ -1,4 +1,5 @@
 #include <display.h>
+#include <cpu.h>
 
 void display_pixel_on(display_t* display, int x, int y){
     SDL_SetRenderDrawColor(display->renderer, 70,65,69,255);
@@ -24,8 +25,26 @@ void display_clear(display_t* display){
     SDL_SetRenderDrawColor(display->renderer, 179,204,174,255);
     SDL_RenderClear(display->renderer);
 }
+ 
+#define HIGH_BIT(b) ((b & 0x80) >> 7)
 
-void display_update(display_t* display){
+void display_update(display_t* display, cpu_status_t* status){
+    uint8_t screen[8*1024];
+    for(int i=0; i<1024;i++){
+        uint8_t byte = status->vram[i];
+        for(int b=0; b<8;b++){
+            screen[i*8+b] = HIGH_BIT(byte >> b);
+        }
+    }
+    for(int i=0; i<64;i++){
+        for(int b=0; b<128;b++){
+            if(screen[i*128+b] == 1){
+                display_pixel_on(display, b, i);
+            } else {
+                display_pixel_off(display, b, i);
+            }
+        }   
+    }
     SDL_RenderPresent(display->renderer);
 }
 
@@ -33,4 +52,4 @@ void display_init(display_t* display){
     SDL_Init( SDL_INIT_VIDEO );
     display->window = SDL_CreateWindow("nemu", 100, 100, 3*128, 3*64, SDL_WINDOW_SHOWN);
     display->renderer = SDL_CreateRenderer(display->window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
-}
+}

src/display.h

@@ -10,5 +10,4 @@ typedef struct{
 void display_pixel_on(display_t* display, int x, int y);
 void display_pixel_off(display_t* display, int x, int y);
 void display_clear(display_t* display);
-void display_update(display_t* display);
-void display_init(display_t* display);
+void display_init(display_t* display);

src/instructions/instructions.h

@@ -21,6 +21,7 @@ void instruction_movw_r0_disp_r(cpu_status_t* status);
 void instruction_movw_disp_r_r0(cpu_status_t* status);
 void instruction_movw_disp_pc_r0 (cpu_status_t* status);
 void instruction_movw_r_ar(cpu_status_t* status);
+void instruction_movw_arp_r(cpu_status_t* status);
 
 void instruction_movb_ar_r(cpu_status_t* status);
 void instruction_movb_r_ar(cpu_status_t* status);
@@ -33,6 +34,10 @@ void instruction_movb_disp_gbr_r0(cpu_status_t* status);
 void instruction_movb_r0_disp_r(cpu_status_t* status);
 
 void instruction_roctl_r(cpu_status_t* status);
+void instruction_shar_r(cpu_status_t* status);
+void instruction_shll2_r(cpu_status_t* status);
+void instruction_shlr_r(cpu_status_t* status);
+void instruction_shlr2_r(cpu_status_t* status);
 
 void instruction_div1_r_r(cpu_status_t* status);
 void instruction_add_r_r(cpu_status_t* status);
@@ -45,6 +50,9 @@ void instruction_extuw_r_r(cpu_status_t* status);
 void instruction_cmp_pl_r(cpu_status_t* status);
 void instruction_cmp_eq_imm_r0(cpu_status_t* status);
 void instruction_cmp_hi_r_r(cpu_status_t* status);
+void instruction_cmp_ge_r_r(cpu_status_t* status);
+void instruction_mull_r_r(cpu_status_t* status);
+void instruction_cmp_eq_r_r(cpu_status_t* status);
 
 void instruction_jmp_r(cpu_status_t* status);
 void instruction_bsr_lbl(cpu_status_t* status);
@@ -54,6 +62,7 @@ void instruction_bf_lbl(cpu_status_t* status);
 void instruction_bra_lbl(cpu_status_t* status);
 void instruction_bt_lbl(cpu_status_t* status);
 void instruction_bts_lbl(cpu_status_t* status);
+void instruction_bfs_lbl(cpu_status_t* status);
 
 void instruction_nop(cpu_status_t* status);
 void instruction_stsl_mash_amr(cpu_status_t* status);
@@ -61,4 +70,8 @@ void instruction_stsl_macl_amr (cpu_status_t* status);
 void instruction_stsl_pr_amr(cpu_status_t* status);
 void instruction_clrt(cpu_status_t* status);
 void instruction_ldsl_arp_pr(cpu_status_t* status);
+void instruction_ldsl_arp_macl(cpu_status_t* status);
+void instruction_sts_macl_r(cpu_status_t* status);
 
+void instruction_tst_r_r(cpu_status_t* status);
+void instruction_or_r_r(cpu_status_t* status);

src/instructions/jmp.c

@@ -133,8 +133,35 @@ void instruction_bts_lbl(cpu_status_t* status){
     else
         disp = (0xFFFFFF00 | cpu_read8(status,status->pc+1));
 
-    if (status->t == 1)
+    if (status->t == 1){
         status->pc = status->pc + 4 + (disp << 1);
+        printf("\e[34mpc: %8x jump (bt/s) to %08x \e[39m\n", temp, status->pc);
+    }
+        
     else
         status->pc += 4;
-}
+}
+
+void instruction_bfs_lbl(cpu_status_t* status){   
+    int d = cpu_read8(status,status->pc+1);
+    int disp;
+    unsigned int temp;
+    temp = status->pc;
+
+    status->pc += 2;
+    cpu_execute(status);
+    status->pc = temp;
+
+    if ((d & 0x80) == 0)
+        disp = (0x000000FF & d);
+    else
+        disp = (0xFFFFFF00 | d);
+
+    if (status->t == 0){
+        status->pc = status->pc + 4 + (disp << 1);
+        printf("\e[34mpc: %8x jump (bf/s) to %08x \e[39m\n", temp, status->pc);
+    }  
+    else
+        status->pc += 4;
+}
+

src/instructions/logic.c

@@ -0,0 +1,15 @@
+#include <instructions/instructions.h>
+
+void instruction_tst_r_r(cpu_status_t* status){
+    if ((status->r[LO_NIBBLE(cpu_read8(status,status->pc))] & status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]) == 0)
+        status->t = 1;
+    else
+        status->t = 0;
+
+    status->pc += 2;
+}
+
+void instruction_or_r_r(cpu_status_t* status){
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] |= status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))];
+    status->pc += 2;
+}

src/instructions/mov.c

@@ -2,7 +2,7 @@
 #include <instructions/instructions.h>
 
 void instruction_mov_r_r(cpu_status_t* status) {
-    status->r[HI_NIBBLE(cpu_read8(status,status->pc))] = status->r[LO_NIBBLE(cpu_read8(status,status->pc+1))];
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))];
     status->pc += 2;
 }
 

src/instructions/movl.c

@@ -36,18 +36,18 @@ void instruction_movl_r_amr(cpu_status_t* status){
 
 void instruction_movl_disp_r_r(cpu_status_t* status){
     long disp = (0x0000000F & (long)LO_NIBBLE(cpu_read8(status,status->pc+1)));
-    status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] = cpu_read32(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] + (disp << 2));
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = cpu_read32(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] + (disp << 2));
     status->pc += 2;
 }
 
 void instruction_movl_r_disp_r(cpu_status_t* status){
     long disp = (0x0000000F & (long)LO_NIBBLE(cpu_read8(status,status->pc+1)));
-    cpu_write32(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] + (disp << 2), status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]);
+    cpu_write32(status, status->r[LO_NIBBLE(cpu_read8(status,status->pc))] + (disp << 2), status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]);
     status->pc += 2;
 }
 
 void instruction_movl_r0_r_r(cpu_status_t* status){
-    status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] = cpu_read32(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] + status->r[0]);
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = cpu_read32(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] + status->r[0]);
     status->pc += 2;
 }
 

src/instructions/movw.c

@@ -37,3 +37,15 @@ void instruction_movw_r_ar(cpu_status_t* status){
     status->pc += 2;
 }
 
+void instruction_movw_arp_r(cpu_status_t* status){
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = cpu_read16(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]);
+    if ((status->r[LO_NIBBLE(cpu_read8(status,status->pc))] & 0x8000) == 0)
+        status->r[LO_NIBBLE(cpu_read8(status,status->pc))] &= 0x0000FFFF;
+    else
+        status->r[LO_NIBBLE(cpu_read8(status,status->pc))] |= 0xFFFF0000;
+
+    if (LO_NIBBLE(cpu_read8(status,status->pc)) != HI_NIBBLE(cpu_read8(status,status->pc+1)))
+        status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] += 2;
+
+    status->pc += 2;
+}

src/instructions/operations.c

@@ -118,5 +118,28 @@ void instruction_cmp_hi_r_r(cpu_status_t* status){
     else
         status->t = 0;
 
+    status->pc += 2;
+}
+
+void instruction_cmp_ge_r_r(cpu_status_t* status){
+    if ((long)status->r[LO_NIBBLE(cpu_read8(status,status->pc))] >= (long)status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))])
+        status->t = 1;
+    else
+        status->t = 0;
+
+    status->pc += 2;
+}
+
+void instruction_mull_r_r(cpu_status_t* status){
+    status->macl = status->r[LO_NIBBLE(cpu_read8(status,status->pc))] * status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))];
+    status->pc += 2;
+}
+
+void instruction_cmp_eq_r_r(cpu_status_t* status){
+    if (status->r[LO_NIBBLE(cpu_read8(status,status->pc))] == status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))])
+        status->t = 1;
+    else
+        status->t = 0;
+
     status->pc += 2;
 }

src/instructions/shift.c

@@ -20,4 +20,49 @@ void instruction_roctl_r(cpu_status_t* status){
         status->t = 0;
 
     status->pc += 2;
+}
+
+void instruction_shar_r(cpu_status_t* status){
+    long temp;
+
+    if ((status->r[LO_NIBBLE(cpu_read8(status,status->pc))] & 0x00000001) == 0)
+        status->t = 0;
+    else
+        status->t = 1;
+
+    if ((status->r[LO_NIBBLE(cpu_read8(status,status->pc))] & 0x80000000) == 0)
+        temp = 0;
+    else
+        temp = 1;
+
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] >>= 1;
+
+    if (temp == 1)
+        status->r[LO_NIBBLE(cpu_read8(status,status->pc))] |= 0x80000000;
+    else
+        status->r[LO_NIBBLE(cpu_read8(status,status->pc))] &= 0x7FFFFFFF;
+
+    status->pc += 2;
+}
+
+void instruction_shll2_r(cpu_status_t* status){
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] <<= 2;
+    status->pc += 2;
+}
+
+void instruction_shlr_r(cpu_status_t* status){
+    if ((status->r[LO_NIBBLE(cpu_read8(status,status->pc))] & 0x00000001) == 0)
+        status->t = 0;
+    else
+        status->t = 1;
+
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] >>= 1;
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] &= 0x7FFFFFFF;
+    status->pc += 2;
+}
+
+void instruction_shlr2_r(cpu_status_t* status){
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] >>= 2;
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] &= 0x3FFFFFFF;
+    status->pc += 2;
 }

src/instructions/system.c

@@ -33,4 +33,15 @@ void instruction_ldsl_arp_pr(cpu_status_t* status){
     status->pr = cpu_read32(status, status->r[LO_NIBBLE(cpu_read8(status,status->pc))]);
     status->r[LO_NIBBLE(cpu_read8(status,status->pc))] += 4;
     status->pc += 2;
+}
+
+void instruction_ldsl_arp_macl(cpu_status_t* status){
+    status->macl = cpu_read32(status,status->r[LO_NIBBLE(cpu_read8(status,status->pc))]);
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] += 4;
+    status->pc += 2;
+}
+
+void instruction_sts_macl_r(cpu_status_t* status){
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = status->macl;
+    status->pc += 2;
 }

src/main.c

@@ -16,7 +16,7 @@ int main(int argc, char **argv){
     cpu_status_t* status;
     status = malloc(sizeof(cpu_status_t)); 
     cpu_setup_addin(status, argv[1]);
-    status->r[15] = 0x08100200;
+    status->r[15] = 0x08100000 + 524288 - 32768/4;
     printf("(ram read test) 0x08100000: %8x\n",cpu_read32(status,0x08100000));
     cpu_write32(status,0x08100004, 0x00560000);
     printf("(ram write test) 0x00560000 at 0x08100004. result: %8x\n", cpu_read32(status,0x08100004));

src/memory.c

@@ -0,0 +1 @@
+#include <memory.h>

src/memory.h

@@ -0,0 +1,16 @@
+#include <stdint.h>
+#pragma once
+
+typedef struct{
+    uint32_t size;
+    uint32_t addr;
+} malloc_info_t;
+
+typedef struct{
+    int allocs;
+    malloc_info_t* mallocs;
+
+    uint32_t lo_mem;
+    uint32_t hi_mem;
+    uint32_t margin;
+} malloc_table_t;

src/syscall.c

@@ -3,10 +3,12 @@
 
 int syscall_handle(cpu_status_t* status, uint32_t origin){
     uint32_t id = status->r[0];
-    printf("\e[32mpc: %8x syscall %8x\e[39m\n", origin, status->r[0]);
+    printf("\e[32mpc: %8x syscall %8x\e[39m\n", origin, (uint32_t)status->r[0]);
     if(id == 0x3fa) NULL;
     if(id == 0x144) syscall_bdisp_allclr_ddvram(status);
     if(id == 0x807) syscall_locate(status);
-    
+    if(id == 0x808) syscall_print(status);
+    if(id == 0x135) syscall_get_vram_address(status);
+    if(id == 0xacd) syscall_malloc(status);
     status->pc = status->pr;
 }

src/syscall.h

@@ -5,5 +5,9 @@
 int syscall_handle(cpu_status_t* status, uint32_t origin);
 
 void syscall_bdisp_allclr_ddvram(cpu_status_t* status);
+void syscall_get_vram_address(cpu_status_t* status);
 
-void syscall_locate(cpu_status_t* status);
+void syscall_locate(cpu_status_t* status);
+void syscall_print(cpu_status_t* status);
+
+void syscall_malloc(cpu_status_t* status);

src/syscall/bdisp.c

@@ -4,4 +4,8 @@ void syscall_bdisp_allclr_ddvram(cpu_status_t* status){
     for(int i=0; i< 1024;i++){
         status->vram[i] = 0;
     }
+}
+
+void syscall_get_vram_address(cpu_status_t* status){
+    status->r[0]=0x01100000;
 }

src/syscall/malloc.c

@@ -0,0 +1,26 @@
+#include <syscall.h>
+
+void syscall_malloc(cpu_status_t* status){
+    printf("\e[32mmalloc %ul bytes\e[39m\n", status->r[4]);
+
+    uint32_t size = status->r[4];
+    if(status->malloc.allocs == 0){
+        status->r[0] = status->malloc.lo_mem;
+    }
+    else{
+        int addr = status->malloc.lo_mem;
+        int hi = 0;
+        int hi_id = 0;
+        for(int i=0; i < status->malloc.allocs; i++){
+            if(status->malloc.mallocs[i].addr > hi){
+                hi = status->malloc.mallocs[i].addr;
+                hi_id = i;
+            }
+        }
+        addr = hi + status->malloc.mallocs[hi_id].size + status->malloc.margin;
+        status->r[0] = addr; 
+    }
+    status->malloc.allocs++;
+    status->malloc.mallocs = realloc(status->malloc.mallocs, status->malloc.allocs * sizeof(malloc_info_t));
+    status->malloc.mallocs[status->malloc.allocs - 1] = (malloc_info_t){size,status->r[0]};
+}

src/syscall/text.c

@@ -1,9 +1,27 @@
 #include <syscall.h>
+#include <display.h>
+#include <math.h>
 
 void syscall_locate(cpu_status_t* status){
     int x = status->r[4];
     int y = status->r[5];
 
     status->cursor_x = (x-1)*6;
-    status->cursor_y = (y-1)*6;
+    status->cursor_y = (y-1)*8;
+}
+
+void syscall_print(cpu_status_t* status){
+    int i = 0;
+    while(1){
+        int c = cpu_read8(status, status->r[4]+i);
+        printf("%c",c);
+        int e = floor((status->cursor_y*128+status->cursor_x+i*6)/8);
+        status->vram[e] = 0b10000000;
+        i++;
+        if(c == 0x00){
+            printf("\n");
+            break;
+        }
+    }
+    display_update(status->display, status);
 }