opcodes ajoutés

8 pages de ram
vram
réglages de bugs

.gitignore

@@ -3,6 +3,7 @@
 /build/*.cmake
 /build/CMakeCache.txt
 /build/nemu
+compile_commands.json
 /.vscode
 aise.txt
 Makefile

CMakeLists.txt

@@ -12,11 +12,18 @@ set(SRCS
     src/instructions/shift.c
     src/instructions/operations.c
     src/instructions/jmp.c
-    src/syscall/mmu.c
+    src/syscall/bdisp.c
+    src/syscall/text.c
+    src/display.c
     src/instructions/system.c
     src/log.c
 )
+
+find_package(SDL2 REQUIRED)
+include_directories(${SDL2_INCLUDE_DIRS})
+
 add_executable(nemu ${SRCS})
+target_link_libraries(nemu ${SDL2_LIBRARIES})
 include_directories(src)
 install(TARGETS nemu DESTINATION bin)
 set(CMAKE_BUILD_TYPE Debug)

src/cpu.c

@@ -5,6 +5,7 @@
 #include <cpu.h>
 #include <log.h>
 #include <instructions/instructions.h>
+#include <display.h>
 
 uint32_t decode(unsigned char a,unsigned char b,unsigned char c,unsigned char d)
 {
@@ -42,6 +43,11 @@ int cpu_setup_addin(cpu_status_t* status,char* _file){
         status->ram[i] = 0x00;
     }
 
+    status->display = malloc(sizeof(display_t));
+    display_init(status->display);
+    display_clear(status->display);
+    display_update(status->display);
+
 }
 
 int cpu_run(cpu_status_t* status){
@@ -49,7 +55,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){
+    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
         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;
@@ -66,7 +72,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){
+    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
         uint16_t ret;
         //ret = (uint16_t)status->ram[addr-0x08100000];
         ret = status->ram[addr-0x08100000+1];
@@ -91,7 +97,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){
+    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
         uint8_t ret;
         ret = status->ram[addr-0x08100000];
         return ret;
@@ -102,6 +108,11 @@ uint8_t cpu_read8(cpu_status_t* status, uint32_t addr){
         ret = status->rom[addr-0x00300200];
         return ret;
     }
+    else if(addr >=0x01100000 && addr <= 0x01100000+8192){
+        uint8_t ret;
+        ret = status->vram[addr-0x01100000];
+        return ret;
+    }
     else{
         log_mem_read_error(status, addr);
         return 8;
@@ -109,7 +120,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){
+    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
         unsigned char bytes[4];
 
         status->ram[addr-0x08100000] = (data >> 24) & 0xFF;
@@ -120,13 +131,19 @@ void cpu_write32(cpu_status_t* status, uint32_t addr, uint32_t data){
     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;
+        status->vram[addr-0x01100000+2] = (data >> 8) & 0xFF;
+        status->vram[addr-0x01100000+3] = data & 0xFF;
+    }
     else{
         log_mem_write_error(status, addr);
     }
 }
 
-void cpu_write16(cpu_status_t* status, uint16_t addr, uint16_t data){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768){
+void cpu_write16(cpu_status_t* status, uint32_t addr, uint16_t data){
+    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
         memcpy(&status->ram[addr-0x08100000],&data, 2);
     }
     else if(addr >=0x00300200 && addr <= 0x00300200+status->program_size){
@@ -138,12 +155,15 @@ void cpu_write16(cpu_status_t* status, uint16_t addr, uint16_t data){
 }
 
 void cpu_write8(cpu_status_t* status, uint32_t addr, uint8_t data){
-    if(addr >=0x08100000 && addr <= 0x08100000+32768){
+    if(addr >=0x08100000 && addr <= 0x08100000+32768*8){
         status->ram[addr-0x08100000] = data;     
     }
     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;
+    }
     else{
         log_mem_write_error(status, addr);
     }
@@ -157,10 +177,17 @@ int cpu_execute(cpu_status_t* status){
         LO_NIBBLE(cpu_read8(status,status->pc+1))
     };
 
-    printf("pc: %8x pr: %8x r0: %8x r1: %8x r2: %8x r3: %8x r4: %8x r5: %8x r6: %8x r15: %08x\n",
+    /*printf("pc: %8x pr: %8x r0: %8x r1: %8x r2: %8x r3: %8x r4: %8x r5: %8x r6: %8x r15: %08x\n",
         status->pc,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[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,
+        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);
@@ -178,6 +205,8 @@ int cpu_execute(cpu_status_t* status){
 
     else if(nibble[0] == 0b1000 && nibble[1] == 0b0001) instruction_movw_r0_disp_r(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] == 0b0000) instruction_movb_ar_r(status);
     else if(nibble[0] == 0b0010 && nibble[3] == 0b0000) instruction_movb_r_ar(status);
@@ -187,6 +216,7 @@ 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] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b0100) instruction_roctl_r(status);
 
@@ -199,6 +229,8 @@ int cpu_execute(cpu_status_t* status){
     else if(nibble[0] == 0b0011 && nibble[3] == 0b1000) instruction_sub_r_r(status);
     else if(nibble[0] == 0b0110 && nibble[3] == 0b1101) instruction_extuw_r_r(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] == 0b0100 && nibble[2] == 0b0010 && nibble[3] == 0b1011) instruction_jmp_r(status);
     else if(nibble[0] == 0b1011) instruction_bsr_lbl(status);
@@ -224,15 +256,15 @@ int cpu_run_from(cpu_status_t* status, uint32_t addr){
     status->pc = addr;
     int total_error = 0;
     int total_executions = 0;
+
     while (status->pc-0x00300200 < status->program_size){
         if(cpu_execute(status)){
             total_error++;
         }
         total_executions++;
-        /*if(total_executions > 500){
+        if(total_executions > 150000){
             break;
-        }*/
-
+        }
     }
     printf("excution terminated with %d not found opcodes\n",total_error);
     

src/cpu.h

@@ -1,5 +1,6 @@
 #include <stdint.h>
 #include <stdbool.h>
+#include <display.h>
 #pragma once
 
 typedef struct{
@@ -12,14 +13,19 @@ typedef struct{
     uint32_t gbr;
 
     uint8_t* rom;
-    uint8_t ram[32768]; // 0x08100000
-    uint8_t vram[1024];
+    uint8_t ram[32768*8]; // 0x08100000
+    uint8_t vram[8192];
 
     uint32_t program_size;
 
     uint8_t t;
     uint8_t q;
     uint8_t m;
+
+    uint32_t cursor_x;
+    uint32_t cursor_y;
+
+    display_t* display;
 }cpu_status_t;
 
 int cpu_setup_addin(cpu_status_t*, char*);
@@ -32,5 +38,5 @@ uint16_t cpu_read16(cpu_status_t*, uint32_t);
 uint8_t cpu_read8(cpu_status_t*, uint32_t);
 
 void cpu_write32(cpu_status_t* status, uint32_t addr, uint32_t data);
-void cpu_write16(cpu_status_t* status, uint16_t addr, uint16_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

@@ -0,0 +1,36 @@
+#include <display.h>
+
+void display_pixel_on(display_t* display, int x, int y){
+    SDL_SetRenderDrawColor(display->renderer, 70,65,69,255);
+    SDL_Rect rect;
+    rect.h = 3;
+    rect.w = 3;
+    rect.x = x * 3;
+    rect.y = y * 3;
+    SDL_RenderFillRect(display->renderer,&rect);
+}
+
+void display_pixel_off(display_t* display, int x, int y){
+    SDL_SetRenderDrawColor(display->renderer, 179,204,174,255);
+    SDL_Rect rect;
+    rect.h = 3;
+    rect.w = 3;
+    rect.x = x * 3;
+    rect.y = y * 3;
+    SDL_RenderFillRect(display->renderer,&rect);
+}
+
+void display_clear(display_t* display){
+    SDL_SetRenderDrawColor(display->renderer, 179,204,174,255);
+    SDL_RenderClear(display->renderer);
+}
+
+void display_update(display_t* display){
+    SDL_RenderPresent(display->renderer);
+}
+
+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

@@ -0,0 +1,14 @@
+#include <SDL2/SDL.h>
+#pragma once
+
+typedef struct{
+    SDL_Window* window;
+    SDL_Renderer* renderer;
+    SDL_Event event;
+}display_t;
+
+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);

src/instructions/instructions.h

@@ -19,6 +19,8 @@ void instruction_movl_disp_gbr_r0(cpu_status_t*);
 
 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_movb_ar_r(cpu_status_t* status);
 void instruction_movb_r_ar(cpu_status_t* status);
@@ -28,6 +30,7 @@ void instruction_movb_disp_r_r0(cpu_status_t* status);
 void instruction_movb_r0_r_r(cpu_status_t* status);
 void instruction_movb_r_r0_r (cpu_status_t* status);
 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);
 
@@ -40,6 +43,8 @@ void instruction_cmp_hs_r_r(cpu_status_t* status);
 void instruction_sub_r_r(cpu_status_t* status);
 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_jmp_r(cpu_status_t* status);
 void instruction_bsr_lbl(cpu_status_t* status);

src/instructions/mov.c

@@ -8,9 +8,9 @@ void instruction_mov_r_r(cpu_status_t* status) {
 
 void instruction_mov_imm_r(cpu_status_t* status){
     if ((cpu_read8(status,status->pc+1) & 0x80) == 0)
-        status->r[HI_NIBBLE(cpu_read8(status,status->pc))] = (0x000000FF & cpu_read8(status,status->pc+1));
+        status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = (0x000000FF & cpu_read8(status,status->pc+1));
     else
-        status->r[HI_NIBBLE(cpu_read8(status,status->pc))] = (0xFFFFFF00 | cpu_read8(status,status->pc+1));
+        status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = (0xFFFFFF00 | cpu_read8(status,status->pc+1));
 
     status->pc += 2;
 }

src/instructions/movb.c

@@ -72,4 +72,11 @@ void instruction_movb_disp_gbr_r0(cpu_status_t* status){
         status->r[0] |= 0xFFFFFF00;
 
     status->pc += 2;
+}
+
+void instruction_movb_r0_disp_r(cpu_status_t* status){
+    int d = LO_NIBBLE(cpu_read8(status,status->pc+1));
+    long disp = (0x0000000F & (long)d);
+    cpu_write8(status, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))] + disp, status->r[0]);
+    status->pc += 2;
 }

src/instructions/movl.c

@@ -15,7 +15,8 @@ void instruction_movl_ar_r(cpu_status_t* status) {
 }
 
 void instruction_movl_r_ar(cpu_status_t* status) {
-    cpu_write32(status, LO_NIBBLE(cpu_read8(status,status->pc)), HI_NIBBLE(cpu_read8(status,status->pc+1)));
+    cpu_write32(status, status->r[LO_NIBBLE(cpu_read8(status,status->pc))], status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]);
+    //printf("@%8x <- %8x\n", LO_NIBBLE(cpu_read8(status,status->pc)),HI_NIBBLE(cpu_read8(status,status->pc+1)));
     status->pc += 2;
 }
 
@@ -28,7 +29,7 @@ void instruction_movl_arp_r(cpu_status_t* status){
 }
 
 void instruction_movl_r_amr(cpu_status_t* status){
-    cpu_write32(status, LO_NIBBLE(cpu_read8(status,status->pc))-4, HI_NIBBLE(cpu_read8(status,status->pc+1)));
+    cpu_write32(status, status->r[LO_NIBBLE(cpu_read8(status,status->pc))]-4, status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]);
     status->r[LO_NIBBLE(cpu_read8(status,status->pc))] -= 4;
     status->pc += 2;
 }

src/instructions/movw.c

@@ -17,4 +17,23 @@ void instruction_movw_disp_r_r0(cpu_status_t* status){
         status->r[0] |= 0xFFFF0000;
 
     status->pc += 2;
-}
+}
+
+void instruction_movw_disp_pc_r0 (cpu_status_t* status){
+    int d = cpu_read8(status,status->pc+1);
+    unsigned int disp = (0x000000FF & d);
+    status->r[LO_NIBBLE(cpu_read8(status,status->pc))] = cpu_read16(status,status->pc + 4 + (disp << 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;
+
+    status->pc += 2;
+}
+
+void instruction_movw_r_ar(cpu_status_t* status){
+    cpu_write16(status, status->r[LO_NIBBLE(cpu_read8(status,status->pc))], status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))]);
+    //printf("%d -> @%d\n", HI_NIBBLE(cpu_read8(status,status->pc+1)), LO_NIBBLE(cpu_read8(status,status->pc)));
+    status->pc += 2;
+}
+

src/instructions/operations.c

@@ -92,5 +92,31 @@ void instruction_cmp_pl_r(cpu_status_t* status){
     else
         status->t = 0;
 
+    status->pc += 2;
+}
+
+void instruction_cmp_eq_imm_r0(cpu_status_t* status){
+    long imm;
+    int i = cpu_read8(status,status->pc+1);
+
+    if ((i & 0x80) == 0)
+        imm = (0x000000FF & (long)i);
+    else
+        imm = (0xFFFFFF00 | (long)i);
+
+    if (status->r[0] == imm)
+        status->t = 1;
+    else
+        status->t = 0;
+
+    status->pc += 2;
+}
+
+void instruction_cmp_hi_r_r(cpu_status_t* status){
+    if ((unsigned long)status->r[LO_NIBBLE(cpu_read8(status,status->pc))] > (unsigned long)status->r[HI_NIBBLE(cpu_read8(status,status->pc+1))])
+        status->t = 1;
+    else
+        status->t = 0;
+
     status->pc += 2;
 }

src/main.c

@@ -3,6 +3,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <cpu.h>
+#include <display.h>
 
 int main(int argc, char **argv){
     if(argc < 2){

src/syscall.c

@@ -2,6 +2,11 @@
 #include <stdio.h>
 
 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]);
+    if(id == 0x3fa) NULL;
+    if(id == 0x144) syscall_bdisp_allclr_ddvram(status);
+    if(id == 0x807) syscall_locate(status);
+    
     status->pc = status->pr;
 }

src/syscall.h

@@ -2,4 +2,8 @@
 #include <instructions/instructions.h>
 #pragma once
 
-int syscall_handle(cpu_status_t* status, uint32_t origin);
+int syscall_handle(cpu_status_t* status, uint32_t origin);
+
+void syscall_bdisp_allclr_ddvram(cpu_status_t* status);
+
+void syscall_locate(cpu_status_t* status);

src/syscall/bdisp.c

@@ -0,0 +1,7 @@
+#include <syscall.h>
+
+void syscall_bdisp_allclr_ddvram(cpu_status_t* status){
+    for(int i=0; i< 1024;i++){
+        status->vram[i] = 0;
+    }
+}

src/syscall/mmu.c

@@ -1,4 +0,0 @@
-#include <syscall.h>
-void syscall_hmem_set_mmu(){
-    
-}

src/syscall/text.c

@@ -0,0 +1,9 @@
+#include <syscall.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;
+}