#include "riscv.h" #include "debug.h" #include "print.h" #include "stdio.h" #include "stdlib.h" #include "errno.h" #include "string.h" #include "../main.h" #define device_write(riscv,addr,value) \ for (int i = 0;i < riscv->device_num;i++) {\ if (riscv->device_list[i] && riscv->device_list[i]->write) {\ if(addr>=riscv->device_list[i]->addr && addrdevice_list[i]->addr+riscv->device_list[i]->size) {\ riscv->device_list[i]->write(addr, value);\ return;\ }\ }\ } #define device_read(riscv,addr,ret) \ for (int i = 0;i < riscv->device_num;i++) {\ if (riscv->device_list[i] && riscv->device_list[i]->read) {\ if(addr>=riscv->device_list[i]->addr && addrdevice_list[i]->addr+riscv->device_list[i]->size) {\ ret=riscv->device_list[i]->read(addr);\ return ret;\ }\ }\ } int riscv_print(riscv_t* riscv) { printf("x0(zero): %08x\n", riscv->zero); printf("x1(ra): %08x\n", riscv->ra); printf("x2(sp): %08x\n", riscv->sp); printf("x3(gp): %08x\n", riscv->gp); printf("x4(tp): %08x\n", riscv->tp); printf("x5(t0): %08x\n", riscv->t0); printf("x6(t1): %08x\n", riscv->t1); printf("x7(t2): %08x\n", riscv->t2); printf("x8(s0|fp): %08x\n", riscv->fp); printf("x9(s1): %08x\n", riscv->s1); printf("x10(a0): %08x\n", riscv->a0); printf("x11(a1): %08x\n", riscv->a1); printf("x12(a2): %08x\n", riscv->a2); printf("x13(a3): %08x\n", riscv->a3); printf("x14(a4): %08x\n", riscv->a4); printf("x15(a5): %08x\n", riscv->a5); printf("x16(a6): %08x\n", riscv->a6); printf("x17(a7): %08x\n", riscv->a7); printf("x18(s2): %08x\n", riscv->s2); printf("x19(s3): %08x\n", riscv->s3); printf("x20(s4): %08x\n", riscv->s4); printf("x21(s5): %08x\n", riscv->s5); printf("x22(s6): %08x\n", riscv->s6); printf("x23(s7): %08x\n", riscv->s7); printf("x24(s8): %08x\n", riscv->s8); printf("x25(s9): %08x\n", riscv->s9); printf("x26(s10): %08x\n", riscv->s10); printf("x27(s11): %08x\n", riscv->s11); printf("x28(t3): %08x\n", riscv->t3); printf("x29(t4): %08x\n", riscv->t4); printf("x30(t5): %08x\n", riscv->t5); printf("x31(t6): %08x\n", riscv->t6); return 0; } void mem_w_write(riscv_t * riscv, uint32_t addr, uint32_t value) { if (addr >= MEM_ADDR_BASE && addr < MEM_ADDR_BASE + MEM_SIZE) { mem_wr(addr) = value; } else { device_write(riscv, addr, value); } } void mem_wh_write(riscv_t* riscv, uint32_t addr, uint16_t value) { if (addr >= MEM_ADDR_BASE && addr < MEM_ADDR_BASE + MEM_SIZE) { mem_wrh(addr) = value; } else { device_write(riscv, addr, value); } } void mem_wb_write(riscv_t* riscv, uint32_t addr, uint8_t value) { if (addr >= MEM_ADDR_BASE && addr < MEM_ADDR_BASE + MEM_SIZE) { mem_wrb(addr) = value; } else { device_write(riscv, addr, value); } } uint32_t mem_w_read(riscv_t* riscv, uint32_t addr) { uint32_t ret = 0xaaaaaaaa; if (addr >= MEM_ADDR_BASE && addr < MEM_ADDR_BASE + MEM_SIZE) { ret = mem_wr(addr); } else if (addr>=riscv->rom_addr_base && addrrom_addr_base+riscv->rom_size){ ret = rom_wr(addr); } else { device_read(riscv, addr, ret); } return ret; } uint16_t mem_wh_read(riscv_t* riscv, uint32_t addr) { uint16_t ret = 0xaaaa; if (addr >= MEM_ADDR_BASE && addr < MEM_ADDR_BASE + MEM_SIZE) { ret = mem_wrh(addr); } else if (addr>=riscv->rom_addr_base && addrrom_addr_base+riscv->rom_size){ ret = rom_wrh(addr); } else { device_read(riscv, addr, ret); } return ret; } uint8_t mem_wb_read(riscv_t* riscv, uint32_t addr) { uint8_t ret = 0xaa; // printf("read addr=%08x\n", addr); if (addr >= MEM_ADDR_BASE && addr < MEM_ADDR_BASE + MEM_SIZE) { ret = mem_wrb(addr); } else if (addr>=riscv->rom_addr_base && addrrom_addr_base+riscv->rom_size){ ret = rom_wrb(addr); } else { device_read(riscv, addr, ret); } return ret; } void ins_add(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] + riscv->reg[rs2]; } void ins_addi(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] + imm; } void ins_addiw(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] + imm; } void ins_addw(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] + riscv->reg[rs2]; } void ins_and(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] & riscv->reg[rs2]; } void ins_andi(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] & imm; } // 设置pc指针高位地址 void ins_auipc(riscv_t* riscv, int imm, int rd) { riscv->reg[rd] = riscv->pc + imm; } void ins_beq(riscv_t* riscv, int rs2, int rs1, int imm) { if (riscv->reg[rs1] == riscv->reg[rs2]) { riscv->pc += imm; } } void ins_bge(riscv_t* riscv, int rs2, int rs1, int imm) { if ((int)riscv->reg[rs1] >= (int)riscv->reg[rs2]) { riscv->pc += imm; } } void ins_bgeu(riscv_t* riscv, int rs2, int rs1, int imm) { if (riscv->reg[rs1] >= riscv->reg[rs2]) { riscv->pc += imm; } } void ins_blt(riscv_t* riscv, int rs2, int rs1, int imm) { if ((int)riscv->reg[rs1] < (int)riscv->reg[rs2]) { riscv->pc += imm; } } void ins_bltu(riscv_t* riscv, int rs2, int rs1, int imm) { if (riscv->reg[rs1] < riscv->reg[rs2]) { riscv->pc += imm; } } void ins_bne(riscv_t* riscv, int rs2, int rs1, int imm) { // printf("bne %d %d imm=%08x\n", rs2, rs1, imm); if (riscv->reg[rs1] != riscv->reg[rs2]) { riscv->pc += imm; } } // 读后清除 void ins_csrrc(riscv_t* riscv, int rs1, int rd, int csr) { uint32_t t = riscv->csrs[csr]; riscv->csrs[csr] = riscv->csrs[csr] & ~riscv->reg[rs1]; riscv->reg[rd] = t; } void ins_csrrs(riscv_t* riscv, int rs1, int rd, int csr) { uint32_t t = riscv->csrs[csr]; riscv->csrs[csr] = riscv->csrs[csr] | riscv->reg[rs1]; riscv->reg[rd] = t; } void ins_csrrw(riscv_t* riscv, int rs1, int rd, int csr) { uint32_t t = riscv->csrs[csr]; riscv->csrs[csr] = riscv->reg[rs1]; riscv->reg[rd] = t; } void ins_csrrci(riscv_t* riscv, int imm, int rd, int csr) { uint32_t t = riscv->csrs[csr]; riscv->csrs[csr] = riscv->csrs[csr] & ~imm; riscv->reg[rd] = t; } void ins_csrrsi(riscv_t* riscv, int imm, int rd, int csr) { uint32_t t = riscv->csrs[csr]; riscv->csrs[csr] = riscv->csrs[csr] | imm; riscv->reg[rd] = t; } void ins_csrrwi(riscv_t* riscv, int imm, int rd, int csr) { uint32_t t = riscv->csrs[csr]; riscv->csrs[csr] = imm; riscv->reg[rd] = t; } void ins_ecall(riscv_t* riscv) { printf("ecall\n"); } void ins_ebreak(riscv_t* riscv) { printf("ebreak\n"); } void ins_jal(riscv_t* riscv, int imm, int rd) { riscv->reg[rd] = riscv->pc + 4; riscv->pc += imm; } void ins_jalr(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t t; t = riscv->pc + 4; riscv->pc = (riscv->reg[rs1] + imm) & (~1); riscv->reg[rd] = t; } void ins_lb(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t addr = riscv->reg[rs1] + imm; // printf("lb %08x,imm=%d\n",addr,imm); uint32_t r=mem_wb_read(riscv, addr); if(r&(0x80)){ r|=0xffffff00; } riscv->reg[rd] = r; } void ins_lbu(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t addr = riscv->reg[rs1] + imm; // printf("lbu %08x,imm=%d\n",addr,imm); riscv->reg[rd] = mem_wb_read(riscv, addr); } void ins_lh(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t addr = riscv->reg[rs1] + imm; // printf("lh %08x,imm=%d\n",addr,imm); uint32_t r=mem_wh_read(riscv, addr); if(r&(0x8000)){ r|=0xffff0000; } riscv->reg[rd] = r; } void ins_lhu(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t addr = riscv->reg[rs1] + imm; // printf("lhu %08x,imm=%d\n",addr,imm); riscv->reg[rd] = mem_wh_read(riscv, addr); } void ins_lw(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t addr = riscv->reg[rs1] + imm; // printf("lw %08x,imm=%d\n",addr,imm); riscv->reg[rd] = (int)mem_w_read(riscv, addr); } void ins_lwu(riscv_t* riscv, int rs1, int imm, int rd) { uint32_t addr = riscv->reg[rs1] + imm; // printf("lwu %08x,imm=%d\n",addr,imm); riscv->reg[rd] = mem_w_read(riscv, addr); } void ins_lui(riscv_t* riscv, int imm, int rd) { riscv->reg[rd] = imm; } void ins_mret(riscv_t* riscv) { riscv->pc = riscv->csrs[0x305]; printf("mret\n"); } void ins_or(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] | riscv->reg[rs2]; } void ins_ori(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] | imm; } void ins_sb(riscv_t* riscv, int rs2, int rs1, int imm) { uint32_t addr = riscv->reg[rs1] + imm; // printf("sb %08x,imm=%d\n",addr,imm); mem_wb_write(riscv, addr, riscv->reg[rs2]); } void ins_sh(riscv_t* riscv, int rs2, int rs1, int imm) { uint32_t addr = riscv->reg[rs1] + imm; // printf("sh %08x,imm=%d\n",addr,imm); mem_wh_write(riscv, addr, riscv->reg[rs2]); } void ins_sw(riscv_t* riscv, int rs2, int rs1, int imm) { uint32_t addr = riscv->reg[rs1] + imm; // printf("sw %08x,imm=%d\n",addr,imm); mem_w_write(riscv, addr, riscv->reg[rs2]); } void ins_sll(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] << riscv->reg[rs2]; } void ins_slli(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] << imm; } void ins_slliw(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] << imm; } void ins_sllw(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] << riscv->reg[rs2]; } void ins_slt(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] < (int)riscv->reg[rs2]; } void ins_slti(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] < imm; } void ins_sltiu(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] < (uint32_t)imm; } void ins_sltu(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] < riscv->reg[rs2]; } void ins_sra(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] >> riscv->reg[rs2]; } void ins_srai(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] >> imm; } void ins_sraiw(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] >> imm; } void ins_sraw(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = (int)riscv->reg[rs1] >> riscv->reg[rs2]; } void ins_srl(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] >> riscv->reg[rs2]; } void ins_srli(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] >> imm; } void ins_srliw(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] >> imm; } void ins_srlw(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] >> riscv->reg[rs2]; } void ins_sub(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] - riscv->reg[rs2]; } void ins_subw(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] - riscv->reg[rs2]; } void ins_wfi(riscv_t* riscv) { printf("wfi\n"); } void ins_xor(riscv_t* riscv, int rs2, int rs1, int rd) { riscv->reg[rd] = riscv->reg[rs1] ^ riscv->reg[rs2]; } void ins_xori(riscv_t* riscv, int rs1, int imm, int rd) { riscv->reg[rd] = riscv->reg[rs1] ^ imm; } // 解析指令 int riscv_decode(riscv_t* riscv, uint32_t ins) { int imm = 0; int rs1 = (ins >> 15) & 0x1f; int rs2 = (ins >> 20) & 0x1f; int rd = (ins >> 7) & 0x1f; int funct3 = (ins >> 12) & 0x7; int funct7 = (ins >> 25) & 0x7f; int opcode = ins & 0x7f; switch (opcode) { // U-type case opcode_lui: imm_u_type(ins, imm); ins_lui(riscv, imm, rd); break; case opcode_auipc: imm_u_type(ins, imm); ins_auipc(riscv, imm, rd); break; // J-type case opcode_jal: imm_j_type(ins, imm); ins_jal(riscv, imm, rd); break; case opcode_jalr: // I-type imm_i_type(ins, imm); ins_jalr(riscv, rs1, imm, rd); break; case opcode_beq: imm_b_type(ins, imm); switch(funct3) { case 0x0: ins_beq(riscv, rs2, rs1, imm); break; case 0x1: ins_bne(riscv, rs2, rs1, imm); break; case 0x4: ins_blt(riscv, rs2, rs1, imm); break; case 0x5: ins_bge(riscv, rs2, rs1, imm); break; case 0x6: ins_bltu(riscv, rs2, rs1, imm); break; case 0x7: ins_bgeu(riscv, rs2, rs1, imm); break; default: break; } break; case opcode_lb: imm_i_type(ins, imm); switch (funct3) { case 0x0: ins_lb(riscv, rs1, imm, rd); break; case 0x1: ins_lh(riscv, rs1, imm, rd); break; case 0x2: ins_lw(riscv, rs1, imm, rd); break; case 0x4: ins_lbu(riscv, rs1, imm, rd); break; case 0x5: ins_lhu(riscv, rs1, imm, rd); break; default: break; } break; case opcode_sb: imm_s_type(ins, imm); switch (funct3) { case 0x0: ins_sb(riscv, rs2, rs1, imm); break; case 0x1: ins_sh(riscv, rs2, rs1, imm); break; case 0x2: ins_sw(riscv, rs2, rs1, imm); break; default: break; } break; case opcode_addi: imm_i_type(ins,imm); switch (funct3) { case 0x0: ins_addi(riscv, rs1, imm, rd); break; case 0x2: ins_slti(riscv, rs1, imm, rd); break; case 0x3: ins_sltiu(riscv, rs1, imm, rd); break; case 0x4: ins_xori(riscv, rs1, imm, rd); break; case 0x6: ins_ori(riscv, rs1, imm, rd); break; case 0x7: ins_andi(riscv, rs1, imm, rd); break; case 0x1: imm = imm&0x1f; ins_slli(riscv, rs1, imm, rd); break; case 0x5: imm = imm&0x1f; if(funct7 == 0x20){ ins_srai(riscv, rs1, imm, rd); }else{ ins_srli(riscv, rs1, imm, rd); } break; default: break; } break; case opcode_add: switch (funct3) { case 0x0: if(funct7 == 0x20){ ins_sub(riscv, rs2, rs1, rd); }else{ ins_add(riscv, rs2, rs1, rd); } break; case 0x1: ins_sll(riscv, rs2, rs1, rd); break; case 0x2: ins_slt(riscv, rs2, rs1, rd); break; case 0x3: ins_sltu(riscv, rs2, rs1, rd); break; case 0x4: ins_xor(riscv, rs2, rs1, rd); break; case 0x5: if (funct7 == 0x20) { ins_sra(riscv, rs2, rs1, rd); }else{ ins_srl(riscv, rs2, rs1, rd); } break; case 0x6: ins_or(riscv, rs2, rs1, rd); break; case 0x7: ins_and(riscv, rs2, rs1, rd); break; default: break; } break; case opcode_ecall: imm_csr(ins,imm); switch (funct3) { case 0x0: ins_ebreak(riscv); break; case 0x1: ins_csrrw(riscv, rs1, rd, imm); break; case 0x2: ins_csrrs(riscv, rs1, rd, imm); break; case 0x3: ins_csrrc(riscv, rs1, rd, imm); break; case 0x5: // rs1 保存的是zimm 值 ins_csrrwi(riscv, rs1, rd, imm); break; case 0x6: ins_csrrsi(riscv, rs1, rd, imm); break; case 0x7: ins_csrrci(riscv, rs1, rd, imm); break; default: break; } break; default: break; } return 0; } // 注册外设 int riscv_register_device(riscv_t* riscv, const device_t* device) { if (riscv->device_num >= DEVICE_MAX_NUM) { printf("riscv register device failed, device num out of range\n"); return -1; } // printf("device: base_addr=%08x, size=%08x\n", device->addr, device->size); riscv->device_list[riscv->device_num] = device; riscv->device_num++; return 0; } int riscv_init(riscv_t* riscv, uint32_t* rom, uint32_t rom_addr_base, uint32_t rom_size) { riscv->rom = rom; riscv->rom_size = rom_size; riscv->rom_addr_base = rom_addr_base; riscv->pc = riscv->rom_addr_base; return 0; } int riscv_run(riscv_t* riscv) { int ret = 0; uint32_t pc; while (1) { if(riscv->pc >= riscv->rom_addr_base + riscv->rom_size || riscv->pc < riscv->rom_addr_base){ printf("riscv run out of rom pc=%08x\n",riscv->pc); break; } uint32_t instr = riscv->rom[(riscv->pc-riscv->rom_addr_base) >> 2]; // printf("pc: %08x instr: %08x\n", riscv->pc, instr); pc = riscv->pc; ret = riscv_decode(riscv, instr); riscv->zero = 0; // 如果指令修改了pc,则以修改后的为准,如果pc未被修改,则继续执行下一条指令 if (riscv->pc == pc) { riscv->pc += 4; } // riscv_print(riscv); if(ret){ break; } } printf("riscv run end\n"); return 0; } long get_file_size(FILE *stream) { long file_size = -1; long cur_offset = ftell(stream); // 获取当前偏移位置 if (cur_offset == -1) { printf("ftell failed :%s\n", strerror(errno)); return -1; } if (fseek(stream, 0, SEEK_END) != 0) { // 移动文件指针到文件末尾 printf("fseek failed: %s\n", strerror(errno)); return -1; } file_size = ftell(stream); // 获取此时偏移值,即文件大小 if (file_size == -1) { printf("ftell failed :%s\n", strerror(errno)); } if (fseek(stream, cur_offset, SEEK_SET) != 0) { // 将文件指针恢复初始位置 printf("fseek failed: %s\n", strerror(errno)); return -1; } return file_size; } riscv_t riscv = { 0 }; int thread_fun(void* t) { int argc; char** argv; argc = get_argv(&argv); char *bin_name="riscv.bin"; if(argc>1){ bin_name=argv[1]; } printf("riscv start\n"); FILE *file=fopen(bin_name, "rb" ); if(file==NULL) { printf("open file %s error\n",bin_name); return -1; } riscv.rom_size = get_file_size(file); printf("rom size: %d\n", riscv.rom_size); riscv.rom = calloc((riscv.rom_size + 3) / 4, 4); fread(riscv.rom, 1, riscv.rom_size, file); fclose(file); riscv_register_device(&riscv, print_dev()); riscv_init(&riscv, riscv.rom, 0x80000000, riscv.rom_size); riscv_run(&riscv); return 0; }