engine,rv64: remove unused code

src/engine/rv64/init.c

@@ -12,6 +12,7 @@ void (*backend_exec)(uint64_t n) = NULL;
 
 void backend_exec_code(uint64_t pc, int nr_instr);
 void guest_setregs(const CPU_state *cpu);
+void spill_init();
 
 static void init_rv64_interpreter() {
   char so_file[256];
@@ -86,4 +87,5 @@ void init_engine() {
   backend_exec_code(riscv64_PMEM_BASE, 100);
   guest_setregs(&cpu);
   init_rv64_reg();
+  spill_init();
 }

src/engine/rv64/isa/mips32.c

@@ -41,14 +41,7 @@ int rtlreg_is_spm(DecodeExecState *s, const rtlreg_t* dest) {
 uint32_t rtlreg2rvidx(DecodeExecState *s, const rtlreg_t* dest) {
   uint32_t varidx = rtlreg2varidx(s, dest);
   if (!(varidx & SPMIDX_MASK)) return varidx;
-
-  uint32_t spmidx = varidx;
-  uint32_t rvidx = spmidx2rvidx(spmidx);
-  // if `dest` is already mapped, just return the corresponding rvidx
-  if (rvidx) return rvidx;
-
-  // if `dest` is not mapped, spill out one tmp_reg and remap
-  return spill_out_and_remap(s, spmidx);
+  assert(0);
 }
 
 void guest_getregs(CPU_state *mips32) {

src/engine/rv64/rv64-backend/exec.c

 #include <isa/riscv64.h>
 #include "../tran.h"
-#include "../spill.h"
 
 #define RV64_EXEC_PC (riscv64_PMEM_BASE + BBL_MAX_SIZE) // skip bbl
 
@@ -38,9 +37,5 @@ vaddr_t rv64_exec_trans_buffer(void *buf, int nr_instr, int npc_type) {
     backend_getregs(&r);
   }
 
-#ifdef REG_SPILLING
-  tmp_regs_reset();
-#endif
-
   return r.gpr[tmp0]._64;
 }

src/engine/rv64/rv64-backend/rtl-basic.c

@@ -7,9 +7,6 @@ void rv64_relop(uint32_t relop, uint32_t idx_dest, uint32_t idx_src1, uint32_t i
 uint32_t rtlreg2rvidx(DecodeExecState *s, const rtlreg_t* dest);
 uint32_t dest2rvidx(DecodeExecState *s, const rtlreg_t* dest);
 uint32_t src2rvidx(DecodeExecState *s, const rtlreg_t* src);
-#ifdef REG_SPILLING
-uint32_t rtlreg2varidx(DecodeExecState *s, const rtlreg_t* dest);
-#endif
 
 static inline void rv64_zextw(uint32_t rd, uint32_t rs) {
   // mask32 is set during initialization
@@ -59,7 +56,6 @@ static inline void load_imm_no_opt(uint32_t r, const sword_t imm) {
 
 /* RTL basic instructions */
 
-#ifdef REG_SPILLING
 #define make_rtl_compute_reg(rtl_name, rv64_name) \
   make_rtl(rtl_name, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) { \
     uint32_t ret = rtlreg2rvidx_pair(s, src1, true, src2, true); \
@@ -68,15 +64,6 @@ static inline void load_imm_no_opt(uint32_t r, const sword_t imm) {
     uint32_t dest_rvidx = dest2rvidx(s, dest); \
     concat(rv64_, rv64_name) (dest_rvidx, src1_rvidx, src2_rvidx); \
   }
-#else
-#define make_rtl_compute_reg(rtl_name, rv64_name) \
-  make_rtl(rtl_name, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) { \
-    uint32_t dest_rvidx = rtlreg2rvidx(s, dest); \
-    uint32_t src1_rvidx = rtlreg2rvidx(s, src1); \
-    uint32_t src2_rvidx = rtlreg2rvidx(s, src2); \
-    concat(rv64_, rv64_name) (dest_rvidx, src1_rvidx, src2_rvidx); \
-  }
-#endif
 
 #define make_rtl_compute_imm(rtl_name, rv64_name) \
   make_rtl(rtl_name, rtlreg_t* dest, const rtlreg_t* src1, const sword_t imm) { \
@@ -131,7 +118,6 @@ make_rtl_compute_imm(shri, srliw)
 make_rtl_compute_imm(sari, sraiw)
 #endif
 
-#ifdef REG_SPILLING
 make_rtl(setrelop, uint32_t relop, rtlreg_t *dest, const rtlreg_t *src1, const rtlreg_t *src2) {
   uint32_t ret = rtlreg2rvidx_pair(s, src1, true, src2, true);
   uint32_t src1_rvidx = ret >> 16;
@@ -139,14 +125,6 @@ make_rtl(setrelop, uint32_t relop, rtlreg_t *dest, const rtlreg_t *src1, const r
   uint32_t dest_rvidx = dest2rvidx(s, dest);
   rv64_relop(relop, dest_rvidx, src1_rvidx, src2_rvidx);
 }
-#else
-make_rtl(setrelop, uint32_t relop, rtlreg_t *dest, const rtlreg_t *src1, const rtlreg_t *src2) {
-  uint32_t dest_rvidx = rtlreg2rvidx(s, dest);
-  uint32_t src1_rvidx = rtlreg2rvidx(s, src1);
-  uint32_t src2_rvidx = rtlreg2rvidx(s, src2);
-  rv64_relop(relop, dest_rvidx, src1_rvidx, src2_rvidx);
-}
-#endif
 
 make_rtl(setrelopi, uint32_t relop, rtlreg_t *dest, const rtlreg_t *src1, const sword_t imm) {
   int big_imm = load_imm_big(tmp0, imm);
@@ -181,7 +159,6 @@ make_rtl_compute_reg(idiv_r, remw)
 # define rv64_imul_hi(c, a, b) TODO()
 #else
 
-#ifdef REG_SPILLING
 make_rtl(mul_hi, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) {
   uint32_t ret = rtlreg2rvidx_pair(s, src1, true, src2, true);
   uint32_t src1_rvidx = ret >> 16;
@@ -203,33 +180,12 @@ make_rtl(imul_hi, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) {
   rv64_mul(dest_rvidx, src1_rvidx, src2_rvidx);
   rv64_srai(dest_rvidx, dest_rvidx, 32);
 }
-#else
-make_rtl(mul_hi, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) {
-  uint32_t idx_dest = rtlreg2rvidx(s, dest);
-  uint32_t idx_src1 = rtlreg2rvidx(s, src1);
-  uint32_t idx_src2 = rtlreg2rvidx(s, src2);
-  rv64_zextw(idx_src1, idx_src1);
-  rv64_zextw(idx_src2, idx_src2);
-  rv64_mul(idx_dest, idx_src1, idx_src2);
-  rv64_srai(idx_dest, idx_dest, 32);
-}
-
-make_rtl(imul_hi, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) {
-  uint32_t idx_dest = rtlreg2rvidx(s, dest);
-  uint32_t idx_src1 = rtlreg2rvidx(s, src1);
-  uint32_t idx_src2 = rtlreg2rvidx(s, src2);
-  rv64_sextw(idx_src1, idx_src1);
-  rv64_sextw(idx_src2, idx_src2);
-  rv64_mul(idx_dest, idx_src1, idx_src2);
-  rv64_srai(idx_dest, idx_dest, 32);
-}
-#endif
 #endif
 
 make_rtl(div64_q, rtlreg_t* dest,
     const rtlreg_t* src1_hi, const rtlreg_t* src1_lo, const rtlreg_t* src2) {
-#ifdef REG_SPILLING
-  panic("If reg-spilling enabled, you should not use div64 rtl!\n");
+#ifndef __ISA_x86__
+  panic("only used in x86\n");
 #endif
   uint32_t idx_dest = rtlreg2rvidx(s, dest);
   uint32_t idx_src1_hi = rtlreg2rvidx(s, src1_hi);
@@ -245,8 +201,8 @@ make_rtl(div64_q, rtlreg_t* dest,
 
 make_rtl(div64_r, rtlreg_t* dest,
     const rtlreg_t* src1_hi, const rtlreg_t* src1_lo, const rtlreg_t* src2) {
-#ifdef REG_SPILLING
-  panic("If reg-spilling enabled, you should not use div64 rtl!\n");
+#ifndef __ISA_x86__
+  panic("only used in x86\n");
 #endif
   uint32_t idx_dest = rtlreg2rvidx(s, dest);
   uint32_t idx_src1_hi = rtlreg2rvidx(s, src1_hi);
@@ -262,8 +218,8 @@ make_rtl(div64_r, rtlreg_t* dest,
 
 make_rtl(idiv64_q, rtlreg_t* dest,
     const rtlreg_t* src1_hi, const rtlreg_t* src1_lo, const rtlreg_t* src2) {
-#ifdef REG_SPILLING
-  panic("If reg-spilling enabled, you should not use div64 rtl!\n");
+#ifndef __ISA_x86__
+  panic("only used in x86\n");
 #endif
   uint32_t idx_dest = rtlreg2rvidx(s, dest);
   uint32_t idx_src1_hi = rtlreg2rvidx(s, src1_hi);
@@ -279,8 +235,8 @@ make_rtl(idiv64_q, rtlreg_t* dest,
 
 make_rtl(idiv64_r, rtlreg_t* dest,
     const rtlreg_t* src1_hi, const rtlreg_t* src1_lo, const rtlreg_t* src2) {
-#ifdef REG_SPILLING
-  panic("If reg-spilling enabled, you should not use div64 rtl!\n");
+#ifndef __ISA_x86__
+  panic("only used in x86\n");
 #endif
   uint32_t idx_dest = rtlreg2rvidx(s, dest);
   uint32_t idx_src1_hi = rtlreg2rvidx(s, src1_hi);
@@ -348,7 +304,7 @@ make_rtl(sm, const rtlreg_t* addr, const sword_t imm, const rtlreg_t* src1, int
 
 make_rtl(host_lm, rtlreg_t* dest, const void *addr, int len) {
 #ifndef __ISA_x86__
-  panic("should not reach here");
+  panic("only used in x86\n");
 #endif
 
   uint32_t idx_dest = rtlreg2rvidx(s, dest);
@@ -375,7 +331,7 @@ make_rtl(host_lm, rtlreg_t* dest, const void *addr, int len) {
 
 make_rtl(host_sm, void *addr, const rtlreg_t *src1, int len) {
 #ifndef __ISA_x86__
-  panic("should not reach here");
+  panic("only used in x86\n");
 #endif
 
   uint32_t idx_src1 = rtlreg2rvidx(s, src1);

src/engine/rv64/spill.c

@@ -6,22 +6,20 @@
 typedef struct {
   uint32_t rvidx;
   uint32_t spmidx;
-  bool used, dirty;
+  bool dirty;
 } Tmp_reg;
 static Tmp_reg tmp_regs[TMP_REG_NUM];
 
-void tmp_regs_init() {
+void spill_init() {
   assert(TMP_REG_NUM == 2);
   tmp_regs[0].rvidx = TMP_REG_1;
   tmp_regs[1].rvidx = TMP_REG_2;
 }
 
-void tmp_regs_reset() {
+void spill_reset() {
   tmp_regs[0].spmidx = 0;
-  tmp_regs[0].used = 0;
   tmp_regs[0].dirty = 0;
   tmp_regs[1].spmidx = 0;
-  tmp_regs[1].used = 0;
   tmp_regs[1].dirty = 0;
 }
 
@@ -42,7 +40,6 @@ int rvidx2tmpidx(uint32_t rvidx) {
 uint32_t spmidx2rvidx(uint32_t spmidx) {
   int tmpidx = spmidx2tmpidx(spmidx);
   if (tmpidx == -1) return 0;
-  tmp_regs[tmpidx].used = 1;
   return tmp_regs[tmpidx].rvidx;
 }
 
@@ -66,28 +63,12 @@ void spill_writeback_all() {  // can be 0/1/2 inst
   }
 }
 
-void spill_flush(uint32_t spmidx) {
-  for (int i = 0; i < TMP_REG_NUM; i++) {
-    if (tmp_regs[i].spmidx == spmidx) {
-      tmp_regs[i].used = 0;
-      return;
-    }
-  }
-}
-
-void spill_flush_all() {
-  for (int i = 0; i < TMP_REG_NUM; i++) {
-    tmp_regs[i].used = 0;
-  }
-}
-
 // replace tmp_regs[tmpidx] with spmidx
 void spill_replace(uint32_t tmpidx, uint32_t spmidx, int load_val) {
   spill_writeback(tmpidx);
   if (load_val) spm(lw, tmp_regs[tmpidx].rvidx, 4 * (spmidx & ~SPMIDX_MASK));
 
   tmp_regs[tmpidx].spmidx = spmidx;
-  tmp_regs[tmpidx].used = 1;
   tmp_regs[tmpidx].dirty = false;
 }
 
@@ -157,28 +138,6 @@ uint32_t rtlreg2rvidx_pair(DecodeExecState *s,
   return (src1_varidx << 16) | src2_varidx;
 }
 
-uint32_t spill_out_and_remap(DecodeExecState *s, uint32_t spmidx) {
-  int tmpidx;
-  for (tmpidx = 0; tmpidx < TMP_REG_NUM; tmpidx ++) {
-    if (tmp_regs[tmpidx].used == 0) break;
-  }
-  Assert(tmpidx < TMP_REG_NUM, "no clean tmp_regs!\nalready used:%u %u, req: %u\n",
-      tmp_regs[0].spmidx, tmp_regs[1].spmidx, spmidx);
-
-  spill_writeback(tmpidx);
-  spm(lw, tmp_regs[tmpidx].rvidx, 4 * (spmidx & ~SPMIDX_MASK));
-
-  tmp_regs[tmpidx].spmidx = spmidx;
-  tmp_regs[tmpidx].used = 1;
-  tmp_regs[tmpidx].dirty = false;
-
-  return tmp_regs[tmpidx].rvidx;
-}
-
-void spill_set_spmidx(uint32_t tmpidx, uint32_t new_spmidx) {
-  tmp_regs[tmpidx].spmidx = new_spmidx;
-}
-
 void spill_set_dirty(uint32_t tmpidx) {
   tmp_regs[tmpidx].dirty = true;
 }

src/engine/rv64/spill.h

@@ -8,13 +8,8 @@
 // default is $26, $27, which has low perf loss
 #define TMP_REG_1     26
 #define TMP_REG_2     27
-
 #define TMP_REG_NUM 2
-#define TMPIDX_CNT 9
-#define TMP_REG_MAX 233
 
-void tmp_regs_init();
-void tmp_regs_reset();
 uint32_t spmidx2rvidx(uint32_t);
 uint32_t spill_out_and_remap(DecodeExecState*, uint32_t);
 void spill_flush(uint32_t);

src/engine/rv64/tran.c

@@ -4,7 +4,6 @@
 #include <isa.h>
 #include <monitor/difftest.h>
 #include "tran.h"
-#include "spill.h"
 
 #define TOP_N 10
 //#define DUMP_RV64
@@ -18,6 +17,7 @@ static void clear_trans_buffer() { trans_buffer_index = 0; }
 void asm_print(vaddr_t ori_pc, int instr_len, bool print_flag);
 vaddr_t rv64_exec_trans_buffer(void *buf, int nr_instr, int npc_type);
 void guest_getregs(CPU_state *cpu);
+void spill_reset();
 
 typedef struct TB {
   vaddr_t pc;
@@ -88,9 +88,6 @@ void write_ins(uint32_t ins) {
 }
 
 void mainloop() {
-#ifdef REG_SPILLING
-  tmp_regs_init();
-#endif
   nemu_state.state = NEMU_RUNNING;
   uint64_t total_instr = 0;
   while (1) {
@@ -98,15 +95,13 @@ void mainloop() {
     TB *tb = find_tb(tb_start);
     if (tb == NULL) {
       clear_trans_buffer();
+      spill_reset();
       tran_next_pc = NEXT_PC_SEQ;
       int guest_nr_instr = 0;
       while (1) {
         __attribute__((unused)) vaddr_t ori_pc = cpu.pc;
         __attribute__((unused)) vaddr_t seq_pc = isa_exec_once();
         guest_nr_instr ++;
-#ifdef REG_SPILLING
-        spill_flush_all();
-#endif
 
         if (nemu_state.state != NEMU_RUNNING) tran_next_pc = NEXT_PC_END;