sas2026/tinyriscv
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renamed hart to core

Browse Source
This commit is contained in:
inixyz
2023-10-25 13:22:07 +03:00
parent e72c620600
commit 43d5e8dbfc
2 changed files with 47 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/main.c
View File

@@ -66,7 +66,7 @@ void help(const char* message){
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void regdump(const tinyriscv_hart* hart){ void regdump(const tinyriscv_core* core){
printf("\n"); printf("\n");
printf(" ABI Reg Hex │ ABI Reg Hex \n"); printf(" ABI Reg Hex │ ABI Reg Hex \n");
printf(" ───────────────────┼───────────────────\n"); printf(" ───────────────────┼───────────────────\n");
@@ -85,8 +85,8 @@ void regdump(const tinyriscv_hart* hart){
printf(i < 10 ? " x%d " : " x%d", i); printf(i < 10 ? " x%d " : " x%d", i);
set_fg_color(RESET); set_fg_color(RESET);
if(hart->x[i]) set_fg_color(BRIGHT_GREEN); if(core->x[i]) set_fg_color(BRIGHT_GREEN);
printf(" %-8x", hart->x[i]); printf(" %-8x", core->x[i]);
set_fg_color(RESET); set_fg_color(RESET);
printf(i % 2 ? " \n" : " │"); printf(i % 2 ? " \n" : " │");
@@ -95,8 +95,8 @@ void regdump(const tinyriscv_hart* hart){
printf(" pc "); printf(" pc ");
set_fg_color(BRIGHT_YELLOW); set_fg_color(BRIGHT_YELLOW);
printf(" x32"); printf(" x32");
if(hart->pc) set_fg_color(BRIGHT_GREEN); if(core->pc) set_fg_color(BRIGHT_GREEN);
printf(" %-8x", hart->pc); printf(" %-8x", core->pc);
set_fg_color(RESET); set_fg_color(RESET);
printf(" │\n\n"); printf(" │\n\n");
@@ -104,9 +104,9 @@ void regdump(const tinyriscv_hart* hart){
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void memdump(const tinyriscv_hart* hart, uint32_t addr){ void memdump(const tinyriscv_core* core, uint32_t addr){
addr -= tinyriscv_MEM_OFFSET; addr -= tinyriscv_MEM_OFFSET;
if(addr + 256 > hart->mem_size) help("memdump: Address out of memory range."); if(addr + 256 > core->mem_size) help("memdump: Address out of memory range.");
printf("\n"); printf("\n");
printf(" Address Memory ASCII\n "); printf(" Address Memory ASCII\n ");
@@ -119,12 +119,12 @@ void memdump(const tinyriscv_hart* hart, uint32_t addr){
set_fg_color(RESET); set_fg_color(RESET);
for(uint32_t i = addr; i < addr + 16; i++){ for(uint32_t i = addr; i < addr + 16; i++){
set_fg_color(hart->mem[i] ? BRIGHT_WHITE : BRIGHT_BLACK); set_fg_color(core->mem[i] ? BRIGHT_WHITE : BRIGHT_BLACK);
printf("%.2x ", hart->mem[i]); printf("%.2x ", core->mem[i]);
} }
for(uint32_t i = addr; i < addr + 16; i++){ for(uint32_t i = addr; i < addr + 16; i++){
const char c = hart->mem[i]; const char c = core->mem[i];
const unsigned int visible = c > 31 && c < 255 && c != 127; const unsigned int visible = c > 31 && c < 255 && c != 127;
set_fg_color(visible ? BRIGHT_WHITE : BRIGHT_BLACK); set_fg_color(visible ? BRIGHT_WHITE : BRIGHT_BLACK);
printf("%c", visible ? c : '.'); printf("%c", visible ? c : '.');
@@ -139,7 +139,7 @@ void memdump(const tinyriscv_hart* hart, uint32_t addr){
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void load_mem_from_file(tinyriscv_hart* hart, const char* file_path){ void load_mem_from_file(tinyriscv_core* core, const char* file_path){
FILE* file = fopen(file_path, "rb"); FILE* file = fopen(file_path, "rb");
if(!file){ if(!file){
perror("ERROR: Can't open file"); perror("ERROR: Can't open file");
@@ -150,13 +150,13 @@ void load_mem_from_file(tinyriscv_hart* hart, const char* file_path){
const unsigned int file_size = ftell(file); const unsigned int file_size = ftell(file);
rewind(file); rewind(file);
if(file_size > hart->mem_size){ if(file_size > core->mem_size){
printf("ERROR: [file] is bigger than allocated memory."); printf("ERROR: [file] is bigger than allocated memory.");
fclose(file); fclose(file);
exit(-1); exit(-1);
} }
fread(hart->mem, 1, file_size, file); fread(core->mem, 1, file_size, file);
fclose(file); fclose(file);
} }
@@ -195,34 +195,34 @@ int main(int argc, char** argv){
} }
} }
tinyriscv_hart hart; tinyriscv_core core;
hart.mem = calloc(hart.mem_size = mem_size, 1); core.mem = calloc(core.mem_size = mem_size, 1);
//load program into memory //load program into memory
load_mem_from_file(&hart, file_path); load_mem_from_file(&core, file_path);
//program execution //program execution
tinyriscv_init(&hart); tinyriscv_init(&core);
if(do_debug){ if(do_debug){
while(tinyriscv_valid_step(&hart)){ while(tinyriscv_valid_step(&core)){
clear_screen(); clear_screen();
if(do_regdump) regdump(&hart); if(do_regdump) regdump(&core);
if(do_memdump) memdump(&hart, dump_addr); if(do_memdump) memdump(&core, dump_addr);
printf("\nPress enter to step.\n"); printf("\nPress enter to step.\n");
while(getch() != 10); while(getch() != 10);
tinyriscv_step(&hart); tinyriscv_step(&core);
} }
} }
else while(tinyriscv_valid_step(&hart)) tinyriscv_step(&hart); else while(tinyriscv_valid_step(&core)) tinyriscv_step(&core);
if(do_regdump) regdump(&hart); if(do_regdump) regdump(&core);
if(do_memdump) memdump(&hart, dump_addr); if(do_memdump) memdump(&core, dump_addr);
//cleanup //cleanup
free(hart.mem); free(core.mem);
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////

44
src/tinyriscv.h
View File

@@ -10,7 +10,7 @@ typedef uint32_t u32; typedef int32_t i32;
typedef struct{ typedef struct{
u32 x[32], pc, mem_size; u32 x[32], pc, mem_size;
u8* mem; u8* mem;
}tinyriscv_hart; }tinyriscv_core;
const u32 tinyriscv_MEM_OFFSET = 0x80000000; const u32 tinyriscv_MEM_OFFSET = 0x80000000;
@@ -108,25 +108,25 @@ inline void tinyriscv_R_type(const u8 funct3, const u8 funct7, u32* x,
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void tinyriscv_init(tinyriscv_hart* hart){ void tinyriscv_init(tinyriscv_core* core){
hart->x[2] = tinyriscv_MEM_OFFSET + hart->mem_size; core->x[2] = tinyriscv_MEM_OFFSET + core->mem_size;
hart->pc = tinyriscv_MEM_OFFSET; core->pc = tinyriscv_MEM_OFFSET;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
u8 tinyriscv_valid_step(const tinyriscv_hart* hart){ u8 tinyriscv_valid_step(const tinyriscv_core* core){
if(!MEM(32, hart->mem, hart->pc)) return 0; if(!MEM(32, core->mem, core->pc)) return 0;
if(hart->pc >= hart->mem_size + tinyriscv_MEM_OFFSET) return 0; if(core->pc >= core->mem_size + tinyriscv_MEM_OFFSET) return 0;
return 1; return 1;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void tinyriscv_step(tinyriscv_hart* hart){ void tinyriscv_step(tinyriscv_core* core){
//fetch //fetch
const u32 inst = MEM(32, hart->mem, hart->pc); const u32 inst = MEM(32, core->mem, core->pc);
hart->pc += 4; core->pc += 4;
//decode //decode
#define opcode (inst & 0x7f) #define opcode (inst & 0x7f)
@@ -145,45 +145,45 @@ void tinyriscv_step(tinyriscv_hart* hart){
(inst >> 9 & 0x800) | (inst >> 20 & 0x7fe)) (inst >> 9 & 0x800) | (inst >> 20 & 0x7fe))
//execute //execute
hart->x[0] = 0; core->x[0] = 0;
switch(opcode){ switch(opcode){
case /*LUI*/ 0x37: case /*LUI*/ 0x37:
hart->x[rd] = inst & 0xfffff000; core->x[rd] = inst & 0xfffff000;
break; break;
case /*AUIPC*/ 0x17: case /*AUIPC*/ 0x17:
hart->x[rd] = hart->pc - 4 + (inst & 0xfffff000); core->x[rd] = core->pc - 4 + (inst & 0xfffff000);
break; break;
case /*JAL*/ 0x6f: case /*JAL*/ 0x6f:
hart->x[rd] = hart->pc; hart->pc += imm_j - 4; core->x[rd] = core->pc; core->pc += imm_j - 4;
break; break;
case /*JALR*/ 0x67: case /*JALR*/ 0x67:
const u32 ret_addr = hart->pc; const u32 ret_addr = core->pc;
hart->pc = (hart->x[rs1] + (i32)imm_i) & 0xfffffffe; core->pc = (core->x[rs1] + (i32)imm_i) & 0xfffffffe;
hart->x[rd] = ret_addr; core->x[rd] = ret_addr;
break; break;
case /*B-type*/ 0x63: case /*B-type*/ 0x63:
tinyriscv_B_type(funct3, hart->x, &hart->pc, rs1, rs2, imm_b); tinyriscv_B_type(funct3, core->x, &core->pc, rs1, rs2, imm_b);
break; break;
case /*L-type*/ 0x03: case /*L-type*/ 0x03:
tinyriscv_L_type(funct3, hart->x, hart->mem, rd, rs1, imm_i); tinyriscv_L_type(funct3, core->x, core->mem, rd, rs1, imm_i);
break; break;
case /*S-type*/ 0x23: case /*S-type*/ 0x23:
tinyriscv_S_type(funct3, hart->x, hart->mem, rs1, rs2, imm_s); tinyriscv_S_type(funct3, core->x, core->mem, rs1, rs2, imm_s);
break; break;
case /*I-type*/ 0x13: case /*I-type*/ 0x13:
tinyriscv_I_type(funct3, funct7, hart->x, rd, rs1, imm_i, rs2); tinyriscv_I_type(funct3, funct7, core->x, rd, rs1, imm_i, rs2);
break; break;
case /*R-type*/ 0x33: case /*R-type*/ 0x33:
tinyriscv_R_type(funct3, funct7, hart->x, rd, rs1, rs2); tinyriscv_R_type(funct3, funct7, core->x, rd, rs1, rs2);
break; break;
} }
} }