ICS PA 2 TRM

--- src/cpu/cpu-exec.c
+++ src/cpu/cpu-exec.c
@@ -19,13 +19,15 @@ const rtlreg_t rzero = 0;
 rtlreg_t tmp_reg[4];

 void device_update();
+void fetch_decode(Decode *s, vaddr_t pc);

-#ifdef CONFIG_DEBUG
-static void debug_hook(vaddr_t pc, const char *asmbuf) {
-  log_write("%s\n", asmbuf);
-  if (g_print_step) { puts(asmbuf); }
-}
+static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
+#ifdef CONFIG_ITRACE_COND
+  if (ITRACE_COND) log_write("%s\n", _this->logbuf);
 #endif
+  if (g_print_step) { IFDEF(CONFIG_ITRACE, puts(_this->logbuf)); }
+  IFDEF(CONFIG_DIFFTEST, difftest_step(_this->pc, dnpc));
+}

 #include <isa-exec.h>

#include <cpu/difftest.h>
#include <isa-all-instr.h>
#include <locale.h>

/* The assembly code of instructions executed is only output to the screen
 * when the number of instructions executed is less than this value.
 * This is useful when you use the `si' command.
 * You can modify this value as you want.
 */
#define MAX_INSTR_TO_PRINT 10

CPU_state cpu = {};
uint64_t g_nr_guest_instr = 0;
static uint64_t g_timer = 0; // unit: us
static bool g_print_step = false;
const rtlreg_t rzero = 0;
rtlreg_t tmp_reg[4];

void device_update();

//
bool check_wp();

#ifdef CONFIG_DEBUG
static void debug_hook(vaddr_t pc, const char *asmbuf) {
  log_write("%s\n", asmbuf);
  if (g_print_step) { puts(asmbuf); }
  if(check_wp()&&nemu_state.state!=NEMU_ABORT&&nemu_state.state!=NEMU_END)
      nemu_state.state=NEMU_STOP;
}
#endif

#include <isa-exec.h>

#include <isa-all-instr.h>
#include <locale.h>

/* The assembly code of instructions executed is only output to the screen
 * when the number of instructions executed is less than this value.
 * This is useful when you use the `si' command.
 * You can modify this value as you want.
 */
#define MAX_INSTR_TO_PRINT 10

CPU_state cpu = {};
uint64_t g_nr_guest_instr = 0;
static uint64_t g_timer = 0; // unit: us
static bool g_print_step = false;
const rtlreg_t rzero = 0;
rtlreg_t tmp_reg[4];

void device_update();
void fetch_decode(Decode *s, vaddr_t pc);

//
bool check_wp();

static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
#ifdef CONFIG_ITRACE_COND
  if (ITRACE_COND) log_write("%s\n", _this->logbuf);
#endif
  if (g_print_step) { IFDEF(CONFIG_ITRACE, puts(_this->logbuf)); }
  IFDEF(CONFIG_DIFFTEST, difftest_step(_this->pc, dnpc));

  if(check_wp()&&nemu_state.state!=NEMU_ABORT&&nemu_state.state!=NEMU_END)
      nemu_state.state=NEMU_STOP;
}


#include <isa-exec.h>

int isa_fetch_decode(Decode *s) {
  s->isa.instr.val = instr_fetch(&s->snpc, 4);
  int idx = table_main(s);
  return idx;
}

word_t paddr_read(paddr_t addr, int len) {
  if (likely(in_pmem(addr))) return pmem_read(addr, len);
  MUXDEF(CONFIG_DEVICE, return mmio_read(addr, len),
    panic("address = " FMT_PADDR " is out of bound of pmem [" FMT_PADDR ", " FMT_PADDR ") at pc = " FMT_WORD,
      addr, CONFIG_MBASE, CONFIG_MBASE + CONFIG_MSIZE, cpu.pc));
}

static inline int table_main(Decode *s) {
  do {
    uint32_t key, mask, shift;
    pattern_decode("??????? ????? ????? ??? ????? 00000 11",
                   (sizeof("??????? ????? ????? ??? ????? 00000 11") - 1), &key,
                   &mask, &shift);
    if (((get_instr(s) >> shift) & mask) == key) {
      {
        decode_I(s, 0);
        return table_load(s);
      };
    }
  } while (0);
  do {
    uint32_t key, mask, shift;
    pattern_decode("??????? ????? ????? ??? ????? 01000 11",
                   (sizeof("??????? ????? ????? ??? ????? 01000 11") - 1), &key,
                   &mask, &shift);
    if (((get_instr(s) >> shift) & mask) == key) {
      {
        decode_S(s, 0);
        return table_store(s);
      };
    }
  } while (0);
  do {
    uint32_t key, mask, shift;
    pattern_decode("??????? ????? ????? ??? ????? 01101 11",
                   (sizeof("??????? ????? ????? ??? ????? 01101 11") - 1), &key,
                   &mask, &shift);
    if (((get_instr(s) >> shift) & mask) == key) {
      {
        decode_U(s, 0);
        return table_lui(s);
      };
    }
  } while (0);
  do {
    uint32_t key, mask, shift;
    pattern_decode("??????? ????? ????? ??? ????? 11010 11",
                   (sizeof("??????? ????? ????? ??? ????? 11010 11") - 1), &key,
                   &mask, &shift);
    if (((get_instr(s) >> shift) & mask) == key) {
      {
        decode_empty(s, 0);
        return table_nemu_trap(s);
      };
    }
  } while (0);
  return table_inv(s);
};

def_THelper(main) {
  def_INSTR_IDTAB("??????? ????? ????? ??? ????? 00000 11", I     , load);
  def_INSTR_IDTAB("??????? ????? ????? ??? ????? 01000 11", S     , store);
  def_INSTR_IDTAB("??????? ????? ????? ??? ????? 01101 11", U     , lui);
  def_INSTR_TAB  ("??????? ????? ????? ??? ????? 11010 11",         nemu_trap);
  return table_inv(s);
};

static void decode_I(Decode *s, int width) {
  decode_op_r(s, (&s->src1), s->isa.instr.i.rs1, 0);
  decode_op_i(s, (&s->src2), s->isa.instr.i.simm11_0, 0);
  decode_op_r(s, (&s->dest), s->isa.instr.i.rd, 1);
}

static inline int table_load(Decode *s) {
  do {
    uint32_t key, mask, shift;
    pattern_decode("??????? ????? ????? 010 ????? ????? ??",
                   (sizeof("??????? ????? ????? 010 ????? ????? ??") - 1), &key,
                   &mask, &shift);
    if (((get_instr(s) >> shift) & mask) == key) {
      {
        decode_empty(s, 0);
        return table_lw(s);
      };
    }
  } while (0);
  return EXEC_ID_inv;
}

static inline void decode_empty(Decode *s, int width) {}

static inline int table_lw(Decode *s) { return EXEC_ID_lw; }

void fetch_decode(Decode *s, vaddr_t pc) {
  s->pc = pc;
  s->snpc = pc;
  int idx = isa_fetch_decode(s);
  s->dnpc = s->snpc;
  s->EHelper = g_exec_table[idx];
  ...

static void fetch_decode_exec_updatepc(Decode *s) {
  fetch_decode(s, cpu.pc);
  s->EHelper(s);
  cpu.pc = s->dnpc;
}

#define INSTR_LIST(f) f(lui) f(lw) f(sw) f(inv) f(nemu_trap)

// `INSTR_LIST` is defined at src/isa/$ISA/include/isa-all-instr.h
#define def_EXEC_ID(name) concat(EXEC_ID_, name),
#define def_all_EXEC_ID() enum { MAP(INSTR_LIST, def_EXEC_ID) TOTAL_INSTR }

enum { EXEC_ID_lui, EXEC_ID_lw, EXEC_ID_sw, EXEC_ID_inv, EXEC_ID_nemu_trap, TOTAL_INSTR }

// --- prototype of table helpers ---
#define def_THelper(name) static inline int concat(table_, name) (Decode *s)
#define def_THelper_body(name) def_THelper(name) { return concat(EXEC_ID_, name); }
#define def_all_THelper() MAP(INSTR_LIST, def_THelper_body)

#define FILL_EXEC_TABLE(name) [concat(EXEC_ID_, name)] = concat(exec_, name),
static const void* g_exec_table[TOTAL_INSTR] = {
  MAP(INSTR_LIST, FILL_EXEC_TABLE)
};

static inline void exec_lui(Decode *s) {
  rtl_li(s, ((&s->dest)->preg), (&s->src1)->imm);
}

static inline void exec_lw(Decode *s) {
  rtl_lm(s, ((&s->dest)->preg), ((&s->src1)->preg), (&s->src2)->imm, 4);
}

static inline void exec_sw(Decode *s) {
  rtl_sm(s, ((&s->dest)->preg), ((&s->src1)->preg), (&s->src2)->imm, 4);
}

static inline void exec_inv(Decode *s) {
  rtl_hostcall(s, HOSTCALL_INV, ((void *)0), ((void *)0), ((void *)0), 0);
}

static inline void exec_nemu_trap(Decode *s) {
  rtl_hostcall(s, HOSTCALL_EXIT, ((void *)0), &(cpu.gpr[check_reg_idx(10)]._32),
               ((void *)0), 0);
}

static const void *g_exec_table[TOTAL_INSTR] = {
    [EXEC_ID_lui] = exec_lui,
    [EXEC_ID_lw] = exec_lw,
    [EXEC_ID_sw] = exec_sw,
    [EXEC_ID_inv] = exec_inv,
    [EXEC_ID_nemu_trap] = exec_nemu_trap,
};

static void fetch_decode_exec_updatepc(Decode *s) {
  fetch_decode(s, cpu.pc);
  s->EHelper(s);
  cpu.pc = s->dnpc;
}

void fetch_decode(Decode *s, vaddr_t pc) {
  s->pc = pc;
  s->snpc = pc;
  int idx = isa_fetch_decode(s);
  s->dnpc = s->snpc;
  s->EHelper = g_exec_table[idx];
  ...

100: jmp 102
101: add
102: xor

typedef MUXDEF(CONFIG_ISA64, uint64_t, uint32_t) word_t;

typedef word_t rtlreg_t;

typedef struct {
  struct {
    rtlreg_t _32;
  } gpr[32];

  vaddr_t pc;
} riscv32_CPU_state;

#define s0    (&tmp_reg[0])
#define s1    (&tmp_reg[1])
#define s2    (&tmp_reg[2])
#define t0    (&tmp_reg[3])
#define rz (&rzero)

#define def_rtl(name, ...) void concat(rtl_, name)(Decode *s, __VA_ARGS__)

#define def_rtl_compute_reg(name) \
  static inline def_rtl(name, rtlreg_t* dest, const rtlreg_t* src1, const rtlreg_t* src2) { \
    *dest = concat(c_, name) (*src1, *src2); \
  }

#define def_rtl_compute_imm(name) \
  static inline def_rtl(name ## i, rtlreg_t* dest, const rtlreg_t* src1, const sword_t imm) { \
    *dest = concat(c_, name) (*src1, imm); \
  }

#define def_rtl_compute_reg_imm(name) \
  def_rtl_compute_reg(name) \
  def_rtl_compute_imm(name) \

def_rtl_compute_reg_imm(add)

#define c_add(a, b) ((a) + (b))

static inline def_rtl(setrelop, uint32_t relop, rtlreg_t *dest,
    const rtlreg_t *src1, const rtlreg_t *src2) {
  *dest = interpret_relop(relop, *src1, *src2);
}

static inline def_rtl(setrelopi, uint32_t relop, rtlreg_t *dest,
    const rtlreg_t *src1, sword_t imm) {
  *dest = interpret_relop(relop, *src1, imm);
}

static inline def_rtl(li, rtlreg_t* dest, const rtlreg_t imm) {
  rtl_addi(s, dest, rz, imm);
}

static inline def_rtl(mv, rtlreg_t* dest, const rtlreg_t *src1) {
  rtl_addi(s, dest, src1, 0);
}

def_EHelper(lui) {
  rtl_li(s, ddest, id_src1->imm);
}

#include "../instr/compute.h"
#include "../instr/ldst.h"
#include "../instr/special.h"

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests$ make ARCH=riscv32-nemu ALL=dummy run

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests$ riscv64-linux-gnu-objdump -d dummy.o

dummy.o:     file format elf32-littleriscv


Disassembly of section .text.startup.main:

00000000 <main>:
   0:  00000513            li  a0,0
   4:  00008067            ret

Disassembly of section .text:

80000000 <_start>:
80000000:   00000413            li  s0,0
80000004:   00009117            auipc   sp,0x9
80000008:   ffc10113            addi    sp,sp,-4 # 80009000 <_end>
8000000c:   00c000ef            jal ra,80000018 <_trm_init>

80000010 <main>:
80000010:   00000513            li  a0,0
80000014:   00008067            ret

80000018 <_trm_init>:
80000018:   80000537            lui a0,0x80000
8000001c:   ff010113            addi    sp,sp,-16
80000020:   03850513            addi    a0,a0,56 # 80000038 <_end+0xffff7038>
80000024:   00112623            sw  ra,12(sp)
80000028:   fe9ff0ef            jal ra,80000010 <main>
8000002c:   00050513            mv  a0,a0
80000030:   0000006b            0x6b
80000034:   0000006f            j   80000034 <_trm_init+0x1c>

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nemu$ ./build/riscv32-nemu-interpreter --log=/home/vgalaxy/ics2021/nemu/build/nemu-log.txt ../am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.bin

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nemu$ gdb ./build/riscv32-nemu-interpreter

(gdb) run --log=/home/vgalaxy/ics2021/nemu/build/nemu-log.txt ../am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.bin

li  rd, immediate
x[rd] = immediate

def_INSTR_IDTAB("??????? ????? ????? ??? ????? 00100 11", U     , li);

def_EHelper(li) {
  rtl_li(s, ddest, id_src1->imm);
}

auipc  rd, immediate
x[rd] = pc + sext(immediate[31:12] << 12)

static def_DHelper(U) {
  decode_op_i(s, id_src1, s->isa.instr.u.imm31_12 << 12, true);
  decode_op_r(s, id_dest, s->isa.instr.u.rd, true);
}

def_INSTR_IDTAB("??????? ????? ????? ??? ????? 00101 11", U     , auipc);

def_EHelper(auipc) {
  rtl_addi(s, ddest, &s->pc, id_src1->imm);
}

addi  rd, rs1, immediate
x[rd] = x[rs1] + sext(immediate)

static void decode_I(Decode *s, int width) {
  decode_op_r(s, (&s->src1), s->isa.instr.i.rs1, 0);
  decode_op_i(s, (&s->src2), s->isa.instr.i.simm11_0, 0);
  decode_op_r(s, (&s->dest), s->isa.instr.i.rd, 1);
}

def_EHelper(addi) {
  rtl_addi(s, ddest, dsrc1, id_src2->imm);
}

def_THelper(rii) {
  def_INSTR_TAB("??????? ????? ????? 000 ????? ????? ??", addi);
  return EXEC_ID_inv;
}

def_THelper(main) {
  ...
  def_INSTR_IDTAB("??????? ????? ????? ??? ????? 00100 11", I     , rii); // register-immediate instructions

jal  rd, offset
x[rd] = pc+4; pc += sext(offset)

def_INSTR_IDTAB("??????? ????? ????? ??? ????? 11011 11", J     , jal);

static def_DHelper(J) {
  word_t simm = (s->isa.instr.j.simm20 << 20) | (s->isa.instr.j.imm10_1 << 1)
      | (s->isa.instr.j.imm11 << 11) | (s->isa.instr.j.imm19_12 << 12);
  decode_op_i(s, id_src1, simm, true);
  decode_op_r(s, id_dest, s->isa.instr.j.rd, true);
}

    struct {
      uint32_t opcode1_0 : 2;
      uint32_t opcode6_2 : 5;
      uint32_t rd        : 5;
      uint32_t imm19_12  : 8;
      uint32_t imm11     : 1;
      uint32_t imm10_1   :10;
      uint32_t simm20    : 1;
    } j;

def_EHelper(jal) {
  rtl_addi(s, ddest, &s->pc, 4);
  rtl_li(s, &s->dnpc, id_src1->imm + s->pc);
}

(nemu) x 1 0x80008ffc
0x80008ffc  80000010

jalr  rd, offset(rs1)
t=pc+4; pc=(x[rs1]+sext(offset))&~1; x[rd]=t

def_EHelper(jalr) {
  sword_t t = s->pc + 4;
  sword_t pc = (id_src2->imm + *dsrc1) & ~1;
  rtl_li(s, &s->dnpc, pc);
  rtl_li(s, ddest, t);
}

def_INSTR_IDTAB("??????? ????? ????? 000 ????? 11001 11", I     , jalr);

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000030
[src/cpu/cpu-exec.c:55 statistic] host time spent = 52 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 13
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 250,000 instr/s

AM = TRM + IOE + CTE + VME + MPE

(在 NEMU 中) 实现硬件功能 -> (在 AM 中) 提供运行时环境 -> (在 APP 层) 运行程序

void halt(int code) {
  nemu_trap(code);

  // should not reach here
  while (1);
}

#if defined(__ISA_X86__)
# define nemu_trap(code) asm volatile (".byte 0xd6" : :"a"(code))
#elif defined(__ISA_MIPS32__)
# define nemu_trap(code) asm volatile ("move $v0, %0; .word 0xf0000000" : :"r"(code))
#elif defined(__ISA_RISCV32__) || defined(__ISA_RISCV64__)
# define nemu_trap(code) asm volatile("mv a0, %0; .word 0x0000006b" : :"r"(code))
#elif
# error unsupported ISA __ISA__
#endif

mv a0, %0; .word 0x0000006b

def_EHelper(nemu_trap) {
  rtl_hostcall(s, HOSTCALL_EXIT, NULL, &gpr(10), NULL, 0); // gpr(10) is $a0
}

def_rtl(hostcall, uint32_t id, rtlreg_t *dest, const rtlreg_t *src1,
    const rtlreg_t *src2, word_t imm) {
  switch (id) {
    case HOSTCALL_EXIT:
      difftest_skip_ref();
      set_nemu_state(NEMU_END, s->pc, *src1);
      break;
    case HOSTCALL_INV: invalid_instr(s->pc); break;
#ifdef CONFIG_HAS_PORT_IO
    case HOSTCALL_PIO: {
      int width = imm & 0xf;
      bool is_in = ((imm & ~0xf) != 0);
      if (is_in) *dest = pio_read(*src1, width);
      else pio_write(*dest, width, *src1);
      break;
    }
#endif
    default: panic("Unsupport hostcall ID = %d", id); break;
  }
}

void set_nemu_state(int state, vaddr_t pc, int halt_ret) {
  nemu_state.state = state;
  nemu_state.halt_pc = pc;
  nemu_state.halt_ret = halt_ret;
}

_start:
  mv s0, zero
  la sp, _stack_pointer
  jal _trm_init

void _trm_init() {
  int ret = main(mainargs);
  halt(ret);
}

add.c           fib.c         max.c           quick-sort.c    sum.c
add-longlong.c  goldbach.c    min3.c          recursion.c     switch.c
bit.c           hello-str.c   mov-c.c         select-sort.c   to-lower-case.c
bubble-sort.c   if-else.c     movsx.c         shift.c         unalign.c
div.c           leap-year.c   mul-longlong.c  shuixianhua.c   wanshu.c
dummy.c         load-store.c  pascal.c        string.c
fact.c          matrix-mul.c  prime.c         sub-longlong.c

Disassembly of section .text:

80000000 <_start>:
80000000:   00000413            li  s0,0
80000004:   00009117            auipc   sp,0x9
80000008:   ffc10113            addi    sp,sp,-4 # 80009000 <_end>
8000000c:   0fc000ef            jal ra,80000108 <_trm_init>

80000010 <check>:
80000010:   00050463            beqz    a0,80000018 <check+0x8>
80000014:   00008067            ret
80000018:   ff010113            addi    sp,sp,-16
8000001c:   00100513            li  a0,1
80000020:   00112623            sw  ra,12(sp)
80000024:   0d8000ef            jal ra,800000fc <halt>

80000028 <main>:
80000028:   fd010113            addi    sp,sp,-48
8000002c:   01312e23            sw  s3,28(sp)
80000030:   01412c23            sw  s4,24(sp)
80000034:   01512a23            sw  s5,20(sp)
80000038:   80000a37            lui s4,0x80000
8000003c:   80000ab7            lui s5,0x80000
80000040:   800009b7            lui s3,0x80000
80000044:   01612823            sw  s6,16(sp)
80000048:   01712623            sw  s7,12(sp)
8000004c:   01812423            sw  s8,8(sp)
80000050:   02112623            sw  ra,44(sp)
80000054:   22ca0c13            addi    s8,s4,556 # 8000022c <_end+0xffff722c>
80000058:   02812423            sw  s0,40(sp)
8000005c:   02912223            sw  s1,36(sp)
80000060:   03212023            sw  s2,32(sp)
80000064:   12ca8a93            addi    s5,s5,300 # 8000012c <_end+0xffff712c>
80000068:   22ca0a13            addi    s4,s4,556
8000006c:   00000b13            li  s6,0
80000070:   24c98993            addi    s3,s3,588 # 8000024c <_end+0xffff724c>
80000074:   04000b93            li  s7,64
80000078:   000a2903            lw  s2,0(s4)
8000007c:   000a8493            mv  s1,s5
80000080:   000c0413            mv  s0,s8
80000084:   00042503            lw  a0,0(s0)
80000088:   0004a783            lw  a5,0(s1)
8000008c:   00440413            addi    s0,s0,4
80000090:   00a90533            add a0,s2,a0
80000094:   40f50533            sub a0,a0,a5
80000098:   00153513            seqz    a0,a0
8000009c:   f75ff0ef            jal ra,80000010 <check>
800000a0:   00448493            addi    s1,s1,4
800000a4:   fe8990e3            bne s3,s0,80000084 <main+0x5c>
800000a8:   00100513            li  a0,1
800000ac:   008b0b13            addi    s6,s6,8
800000b0:   f61ff0ef            jal ra,80000010 <check>
800000b4:   004a0a13            addi    s4,s4,4
800000b8:   020a8a93            addi    s5,s5,32
800000bc:   fb7b1ee3            bne s6,s7,80000078 <main+0x50>
800000c0:   00100513            li  a0,1
800000c4:   f4dff0ef            jal ra,80000010 <check>
800000c8:   02c12083            lw  ra,44(sp)
800000cc:   02812403            lw  s0,40(sp)
800000d0:   02412483            lw  s1,36(sp)
800000d4:   02012903            lw  s2,32(sp)
800000d8:   01c12983            lw  s3,28(sp)
800000dc:   01812a03            lw  s4,24(sp)
800000e0:   01412a83            lw  s5,20(sp)
800000e4:   01012b03            lw  s6,16(sp)
800000e8:   00c12b83            lw  s7,12(sp)
800000ec:   00812c03            lw  s8,8(sp)
800000f0:   00000513            li  a0,0
800000f4:   03010113            addi    sp,sp,48
800000f8:   00008067            ret

800000fc <halt>:
800000fc:   00050513            mv  a0,a0
80000100:   0000006b            0x6b
80000104:   0000006f            j   80000104 <halt+0x8>

80000108 <_trm_init>:
80000108:   80000537            lui a0,0x80000
8000010c:   ff010113            addi    sp,sp,-16
80000110:   12850513            addi    a0,a0,296 # 80000128 <_end+0xffff7128>
80000114:   00112623            sw  ra,12(sp)
80000118:   f11ff0ef            jal ra,80000028 <main>
8000011c:   00050513            mv  a0,a0
80000120:   0000006b            0x6b
80000124:   0000006f            j   80000124 <_trm_init+0x1c>

int main() {
    int i, j, ans_idx = 0;
    for(i = 0; i < NR_DATA; i ++) {
        for(j = 0; j < NR_DATA; j ++) {
            check(add(test_data[i], test_data[j]) == ans[ans_idx ++]);
        }
        check(j == NR_DATA);
    }

    check(i == NR_DATA);

    return 0;
}

__attribute__((noinline))
void check(bool cond) {
  if (!cond) halt(1);
}

add  rd, rs1, rs2
x[rd] = x[rs1] + x[rs2]

static def_DHelper(R) {
  decode_op_r(s, id_src1, s->isa.instr.r.rs1, false);
  decode_op_r(s, id_src2, s->isa.instr.r.rs2, false);
  decode_op_r(s, id_dest, s->isa.instr.r.rd, true);
}

def_THelper(rri) {
  def_INSTR_TAB("0000000 ????? ????? 000 ????? ????? ??", add);
  def_INSTR_TAB("0100000 ????? ????? 000 ????? ????? ??", sub);
  return EXEC_ID_inv;
}

def_THelper(main) {
  ...
  def_INSTR_IDTAB("??????? ????? ????? ??? ????? 01100 11", R     , rri); // register-register instructions

    struct {
      uint32_t opcode1_0 : 2;
      uint32_t opcode6_2 : 5;
      uint32_t rd        : 5;
      uint32_t funct3    : 3;
      uint32_t rs1       : 5;
      uint32_t rs2       : 5;
      uint32_t funct7    : 7;
    } r;

def_EHelper(add) {
  rtl_add(s, ddest, dsrc1, dsrc2);
}

def_EHelper(sub) {
  rtl_sub(s, ddest, dsrc1, dsrc2);
}

seqz  rd, rs1
x[rd]=(x[rs1]==0)

sltiu  rd, rs1, immediate
x[rd]=(x[rs1]<𝑢 sext(immediate))

def_THelper(rii) {
  def_INSTR_TAB("??????? ????? ????? 000 ????? ????? ??", addi);
  def_INSTR_TAB("??????? ????? ????? 011 ????? ????? ??", sltiu);
  return EXEC_ID_inv;
}

def_EHelper(sltiu) {
  rtl_setrelopi(s, RELOP_LTU, ddest, dsrc1, id_src2->imm);
}

static inline def_rtl(setrelopi, uint32_t relop, rtlreg_t *dest,
    const rtlreg_t *src1, sword_t imm) {
  *dest = interpret_relop(relop, *src1, imm);
}

static inline bool interpret_relop(uint32_t relop, const rtlreg_t src1, const rtlreg_t src2) {
  switch (relop) {
    case RELOP_FALSE: return false;
    case RELOP_TRUE: return true;
    case RELOP_EQ: return src1 == src2;
    case RELOP_NE: return src1 != src2;
    case RELOP_LT: return (sword_t)src1 <  (sword_t)src2;
    case RELOP_LE: return (sword_t)src1 <= (sword_t)src2;
    case RELOP_GT: return (sword_t)src1 >  (sword_t)src2;
    case RELOP_GE: return (sword_t)src1 >= (sword_t)src2;
    case RELOP_LTU: return src1 < src2;
    case RELOP_LEU: return src1 <= src2;
    case RELOP_GTU: return src1 > src2;
    case RELOP_GEU: return src1 >= src2;
    default: panic("unsupport relop = %d", relop);
  }
}

beqz  rs1, offset
if (rs1 == 0) pc += sext(offset)

beq  rs1, rs2, offset
if (rs1 == rs2) pc += sext(offset)

static def_DHelper(B) {
  decode_op_r(s, id_src1, s->isa.instr.b.rs1, false);
  sword_t simm = (s->isa.instr.b.simm12 << 12) | (s->isa.instr.b.imm4_1 << 1)
      | (s->isa.instr.b.imm10_5 << 5) | (s->isa.instr.b.imm11 << 11);
  decode_op_i(s, id_src2, simm, false);
  decode_op_r(s, id_dest, s->isa.instr.b.rs2, false);
}

def_THelper(cbi) {
  def_INSTR_TAB("??????? ????? ????? 000 ????? ????? ??", beq);
  return EXEC_ID_inv;
}

def_THelper(main) {
  ...
  def_INSTR_IDTAB("??????? ????? ????? ??? ????? 11000 11", B     , cbi); // conditional-branch instructions

    struct {
      uint32_t opcode1_0 : 2;
      uint32_t opcode6_2 : 5;
      uint32_t imm11     : 1;
      uint32_t imm4_1    : 4;
      uint32_t funct3    : 3;
      uint32_t rs1       : 5;
      uint32_t rs2       : 5;
      uint32_t imm10_5   : 6;
      int32_t  simm12    : 1;
    } b;

def_EHelper(beq) {
  rtl_jrelop(s, RELOP_EQ, dsrc1, ddest, id_src2->imm + s->pc);
}

static inline def_rtl(j, vaddr_t target) {
  s->dnpc = target;
}

static inline def_rtl(jr, rtlreg_t *target) {
  s->dnpc = *target;
}

static inline def_rtl(jrelop, uint32_t relop,
    const rtlreg_t *src1, const rtlreg_t *src2, vaddr_t target) {
  bool is_jmp = interpret_relop(relop, *src1, *src2);
  rtl_j(s, (is_jmp ? target : s->snpc));
}

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000120
[src/cpu/cpu-exec.c:55 statistic] host time spent = 1,331 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 840
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 631,104 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800000c4
[src/cpu/cpu-exec.c:55 statistic] host time spent = 802 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 526
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 655,860 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000124
[src/cpu/cpu-exec.c:55 statistic] host time spent = 1,417 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 868
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 612,561 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800003d0
[src/cpu/cpu-exec.c:55 statistic] host time spent = 4,943 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 3,174
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 642,120 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x8000009c
[src/cpu/cpu-exec.c:55 statistic] host time spent = 935 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 528
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 564,705 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000138
[src/cpu/cpu-exec.c:55 statistic] host time spent = 1,902 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,262
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 663,512 instr/s

rem  rd, rs1, rs2                                           x[rd]=x[rs1]% 𝑠 x[rs2]

#define c_divu_q(a, b) ((a) / (b))
#define c_divu_r(a, b)  ((a) % (b))
#define c_divs_q(a, b) ((sword_t)(a) / (sword_t)(b))
#define c_divs_r(a, b)  ((sword_t)(a) % (sword_t)(b))

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000118
[src/cpu/cpu-exec.c:55 statistic] host time spent = 2,636 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,367
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 518,588 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000170
[src/cpu/cpu-exec.c:55 statistic] host time spent = 1,601 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,042
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 650,843 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x8000026c
[src/cpu/cpu-exec.c:55 statistic] host time spent = 6,938 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 4,545
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 655,087 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800000e4
[src/cpu/cpu-exec.c:55 statistic] host time spent = 369 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 228
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 617,886 instr/s

lbu  rd, offset(rs1)
x[rd] = M[x[rs1] + sext(offset)][7:0]

def_EHelper(lb) {
  rtl_lms(s, ddest, dsrc1, id_src2->imm, 1);
}

def_EHelper(lh) {
  rtl_lms(s, ddest, dsrc1, id_src2->imm, 2);
}

def_EHelper(lbu) {
  rtl_lm(s, ddest, dsrc1, id_src2->imm, 1);
}

def_EHelper(lhu) {
  rtl_lm(s, ddest, dsrc1, id_src2->imm, 2);
}

static inline def_rtl(lm, rtlreg_t *dest, const rtlreg_t* addr, word_t offset, int len) {
  *dest = vaddr_read(*addr + offset, len);
}

static inline def_rtl(lms, rtlreg_t *dest, const rtlreg_t* addr, word_t offset, int len) {
  word_t val = vaddr_read(*addr + offset, len);
  switch (len) {
    case 4: *dest = (sword_t)(int32_t)val; return;
    case 1: *dest = (sword_t)( int8_t)val; return;
    case 2: *dest = (sword_t)(int16_t)val; return;
    IFDEF(CONFIG_ISA64, case 8: *dest = (sword_t)(int64_t)val; return);
    IFDEF(CONFIG_RT_CHECK, default: assert(0));
  }
}

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000220
[src/cpu/cpu-exec.c:55 statistic] host time spent = 579 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 314
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 542,314 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000124
[src/cpu/cpu-exec.c:55 statistic] host time spent = 149 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 79
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 530,201 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000158
[src/cpu/cpu-exec.c:55 statistic] host time spent = 4,600 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 2,854
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 620,434 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800000d8
[src/cpu/cpu-exec.c:55 statistic] host time spent = 3,260 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 2,002
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 614,110 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x8000013c
[src/cpu/cpu-exec.c:55 statistic] host time spent = 4,322 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 2,796
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 646,922 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x8000010c
[src/cpu/cpu-exec.c:55 statistic] host time spent = 495 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 291
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 587,878 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800001c8
[src/cpu/cpu-exec.c:55 statistic] host time spent = 238 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 128
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 537,815 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x8000013c
[src/cpu/cpu-exec.c:55 statistic] host time spent = 549 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 322
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 586,520 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000148
[src/cpu/cpu-exec.c:55 statistic] host time spent = 293 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 172
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 587,030 instr/s

mul  rd, rs1, rs2
x[rd]=x[rs1]×x[rs2]

def_EHelper(mul) {
  rtl_mulu_lo(s, ddest, dsrc1, dsrc2);
}

def_EHelper(mulh) {
  rtl_muls_hi(s, ddest, dsrc1, dsrc2);
}

def_EHelper(mulhu) {
  rtl_mulu_hi(s, ddest, dsrc1, dsrc2);
}

#define c_mulu_lo(a, b) ((a) * (b))
#define c_mulu_hi(a, b) (((uint64_t)(a) * (uint64_t)(b)) >> 32)
#define c_muls_hi(a, b) (((int64_t)(sword_t)(a) * (int64_t)(sword_t)(b)) >> 32)

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000118
[src/cpu/cpu-exec.c:55 statistic] host time spent = 1,383 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 865
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 625,451 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800000dc
[src/cpu/cpu-exec.c:55 statistic] host time spent = 2,571 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,693
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 658,498 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000160
[src/cpu/cpu-exec.c:55 statistic] host time spent = 440 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 261
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 593,181 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x8000011c
[src/cpu/cpu-exec.c:55 statistic] host time spent = 9,092 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 6,064
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 666,959 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000104
[src/cpu/cpu-exec.c:55 statistic] host time spent = 4,029 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 2,679
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 664,929 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800001e8
[src/cpu/cpu-exec.c:55 statistic] host time spent = 643 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 371
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 576,982 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000120
[src/cpu/cpu-exec.c:55 statistic] host time spent = 5,072 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 3,191
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 629,140 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000110
[src/cpu/cpu-exec.c:55 statistic] host time spent = 787 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 476
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 604,828 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000158
[src/cpu/cpu-exec.c:55 statistic] host time spent = 20,039 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 8,960
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 447,128 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x800000dc
[src/cpu/cpu-exec.c:55 statistic] host time spent = 8,374 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 5,209
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 622,044 instr/s

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000138
[src/cpu/cpu-exec.c:55 statistic] host time spent = 1,866 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,262
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 676,312 instr/s

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests$ make -n ARCH=riscv32-nemu ALL=add run
/bin/echo -e "NAME = add\nSRCS = tests/add.c\nLIBS += klib\ninclude ${AM_HOME}/Makefile" > Makefile.add
if make -s -f Makefile.add ARCH=riscv32-nemu run; then \
  printf "[%14s] \033[1;32mPASS!\033[0m\n" add >> .result; \
else \
  printf "[%14s] \033[1;31mFAIL!\033[0m\n" add >> .result; \
fi
rm -f Makefile.add
echo "" add
cat .result
rm .result

.PHONY: all run clean latest $(ALL)

RESULT = .result
$(shell > $(RESULT))

COLOR_RED   = \033[1;31m
COLOR_GREEN = \033[1;32m
COLOR_NONE  = \033[0m

ALL = $(basename $(notdir $(shell find tests/. -name "*.c")))

all: $(addprefix Makefile., $(ALL))
    @echo "" $(ALL)

$(ALL): %: Makefile.%

Makefile.%: tests/%.c latest
    @/bin/echo -e "NAME = $*\nSRCS = $<\nLIBS += klib\ninclude $${AM_HOME}/Makefile" > $@
    @if make -s -f $@ ARCH=$(ARCH) $(MAKECMDGOALS); then \
        printf "[%14s] $(COLOR_GREEN)PASS!$(COLOR_NONE)\n" $* >> $(RESULT); \
    else \
        printf "[%14s] $(COLOR_RED)FAIL!$(COLOR_NONE)\n" $* >> $(RESULT); \
    fi
    -@rm -f Makefile.$*

run: all
    @cat $(RESULT)
    @rm $(RESULT)

clean:
    rm -rf Makefile.* build/

latest:

void *memset( void *dest, int ch, size_t count );

void *memset(void *s, int c, size_t n) {
  const unsigned char uc=c;
  unsigned char *us=(unsigned char *)s;
  for(;n>0;++us,--n)
      *us=uc;
  return s;
}

void* memcpy( void *dest, const void *src, size_t count );

void *memcpy(void *s1, const void *s2, size_t n) {
  unsigned char *us1=(unsigned char *)s1;
  const unsigned char *us2=(const unsigned char *)s2;
  for(;n>0;++us1,++us2,--n)
      *us1=*us2;
  return s1;
}

int memcmp( const void* lhs, const void* rhs, size_t count );

int memcmp(const void *s1, const void *s2, size_t n) {
  const unsigned char* us1=(const unsigned char*)s1;
  const unsigned char* us2=(const unsigned char*)s2;
  for(;n>0;++us1,++us2,--n)
      if(*us1!=*us2)
          return (*us1<*us2)?-1:1;
  return 0;
}

void* memmove( void* dest, const void* src, size_t count );

size_t strlen( const char *str );

size_t strlen(const char *s) {
  const char *sc;
  for(sc=s;*sc!='\0';++sc);
  return (sc-s);
}

size_t strnlen(const char *s, size_t n) {
  const char *sc;
  for(sc=s;n>0&&*sc!='\0';++sc,--n);
  return (sc-s);
}

char *strcpy( char *dest, const char *src );

char *strcpy(char *dst, const char *src) {
    return memcpy (dst, src, strlen (src) + 1);
}

char *strncpy( char *dest, const char *src, size_t count );

char *strncpy(char *dst, const char *src, size_t n) {
  size_t size = strnlen (src, n);
  if (size != n)
    memset (dst + size, '\0', n - size);
  return memcpy (dst, src, size);
}

char *strcat( char *dest, const char *src );

char *strcat(char *dst, const char *src) {
  strcpy (dst + strlen (dst), src);
  return dst;
}

int strcmp( const char *lhs, const char *rhs );

int strcmp(const char *p1, const char *p2) {
  const unsigned char *s1 = (const unsigned char *) p1;
  const unsigned char *s2 = (const unsigned char *) p2;
  unsigned char c1, c2;

  do
    {
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0')
    return c1 - c2;
    }
  while (c1 == c2);

  return c1 - c2;
}

int strncmp( const char *lhs, const char *rhs, size_t count );

int strncmp(const char *s1, const char *s2, size_t n) {
  unsigned char c1 = '\0';
  unsigned char c2 = '\0';

  if (n >= 4)
    {
      size_t n4 = n >> 2;
      do
    {
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0' || c1 != c2)
        return c1 - c2;
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0' || c1 != c2)
        return c1 - c2;
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0' || c1 != c2)
        return c1 - c2;
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0' || c1 != c2)
        return c1 - c2;
    } while (--n4 > 0);
      n &= 3;
    }

  while (n > 0)
    {
      c1 = (unsigned char) *s1++;
      c2 = (unsigned char) *s2++;
      if (c1 == '\0' || c1 != c2)
    return c1 - c2;
      n--;
    }

  return c1 - c2;
}

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000148
[src/cpu/cpu-exec.c:55 statistic] host time spent = 2,404 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,510
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 628,119 instr/s

int sprintf(char *out, const char *fmt, ...) {
  va_list ap;
  int ret;

  va_start(ap, fmt);
  ret = vsprintf(out, fmt, ap);
  va_end(ap);

  if (index >= BUF_SIZE) panic("sprintf buffer overflow!!!");

  return ret;
}

int vsprintf( char *buffer, const char *format, va_list vlist );

static int index;

int vsprintf(char *out, const char *fmt, va_list ap) {
    char *cur=(char *)fmt;

    memset(out,'\0',BUF_SIZE);
    index = 0;

    while(*cur!='\0'){
        if(*cur=='%'){
            cur++;
            switch(*cur){
                case 's':
                    sprint_s(out,va_arg(ap,char *));
                    break;
                case 'd':
                    sprint_d(out,va_arg(ap,int));
                    break;
                case 'c':
                    sprint_c(out,va_arg(ap,int));
                    break;
                default:
                    out[index++]='%';
                    out[index++]=*cur;
                    break;
            }
        }else{
            out[index++]=*cur;
        }
        cur++;
    }

    return index;
}

[src/cpu/cpu-exec.c:122 cpu_exec] nemu: HIT GOOD TRAP at pc = 0x80000108
[src/cpu/cpu-exec.c:55 statistic] host time spent = 2,662 us
[src/cpu/cpu-exec.c:56 statistic] total guest instructions = 1,762
[src/cpu/cpu-exec.c:57 statistic] simulation frequency = 661,908 instr/s

static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
#ifdef CONFIG_ITRACE_COND
  if (ITRACE_COND) log_write("%s\n", _this->logbuf);
#endif
  if (g_print_step) { IFDEF(CONFIG_ITRACE, puts(_this->logbuf)); }
  IFDEF(CONFIG_DIFFTEST, difftest_step(_this->pc, dnpc));

  ...
}

config ITRACE
  depends on TRACE && TARGET_NATIVE_ELF && ENGINE_INTERPRETER
  bool "Enable instruction tracer"
  default y

config ITRACE_COND
  depends on ITRACE
  string "Only trace instructions when the condition is true"
  default "true"

#ifdef CONFIG_ITRACE
  char *p = s->logbuf;
  p += snprintf(p, sizeof(s->logbuf), FMT_WORD ":", s->pc);
  int ilen = s->snpc - s->pc;
  int i;
  uint8_t *instr = (uint8_t *)&s->isa.instr.val;
  for (i = 0; i < ilen; i ++) {
    p += snprintf(p, 4, " %02x", instr[i]);
  }
  int ilen_max = MUXDEF(CONFIG_ISA_x86, 8, 4);
  int space_len = ilen_max - ilen;
  if (space_len < 0) space_len = 0;
  space_len = space_len * 3 + 1;
  memset(p, ' ', space_len);
  p += space_len;

  void disassemble(char *str, int size, uint64_t pc, uint8_t *code, int nbyte);
  disassemble(p, s->logbuf + sizeof(s->logbuf) - p,
      MUXDEF(CONFIG_ISA_x86, s->snpc, s->pc), (uint8_t *)&s->isa.instr.val, ilen);
#endif

// ring buffer
#define MAX_INSTR_RING_BUFFER 20
static char ring_buffer[MAX_INSTR_RING_BUFFER][128];
static int ring_buffer_index = -1;

typedef struct Decode {
  vaddr_t pc;
  vaddr_t snpc; // static next pc
  vaddr_t dnpc; // dynamic next pc
  void (*EHelper)(struct Decode *);
  Operand dest, src1, src2;
  ISADecodeInfo isa;
  IFDEF(CONFIG_ITRACE, char logbuf[128]);
} Decode;

static void trace_and_difftest(Decode *_this, vaddr_t dnpc) {
#ifdef CONFIG_ITRACE_COND
  if (ITRACE_COND) log_write("%s\n", _this->logbuf);
#endif
  if (g_print_step) { IFDEF(CONFIG_ITRACE, puts(_this->logbuf)); }
  IFDEF(CONFIG_DIFFTEST, difftest_step(_this->pc, dnpc));


  if (check_wp() && nemu_state.state != NEMU_ABORT
          && nemu_state.state != NEMU_END)
      nemu_state.state = NEMU_STOP;

  if (ring_buffer_index >= MAX_INSTR_RING_BUFFER)
      ring_buffer_index = -1;
  strcpy(ring_buffer[++ring_buffer_index], _this->logbuf);
}

static void ring_buffer_display() {
    printf("----------------------------iringbuf----------------------------\n");
    for(int i = 0; i < MAX_INSTR_RING_BUFFER; ++i) {
        if (i == ring_buffer_index)
            printf("  -->  %s\n", ring_buffer[i]);
        else
            printf("       %s\n", ring_buffer[i]);
    }
    printf("----------------------------iringbuf----------------------------\n");
}

----------------------------iringbuf----------------------------
       0x80000000: 13 04 00 00 mv  s0, zero
       0x80000004: 17 91 00 00 auipc  sp, 9
       0x80000008: 13 01 c1 ff addi  sp, sp, -4
  -->  0x8000000c: ef 00 c0 00 jal  12
















----------------------------iringbuf----------------------------

config MTRACE
  depends on TRACE && TARGET_NATIVE_ELF && ENGINE_INTERPRETER
  bool "Enable memory tracer"
  default y

word_t paddr_read(paddr_t addr, int len) {
  if (likely(in_pmem(addr))) {
      word_t res = pmem_read(addr, len);
      IFDEF(CONFIG_MTRACE, Log("address = " FMT_PADDR " read " FMT_PADDR " at pc = " FMT_WORD, addr, res, cpu.pc));
      return res;
  }
  MUXDEF(CONFIG_DEVICE, return mmio_read(addr, len),
    panic("address = " FMT_PADDR " is out of bound of pmem [" FMT_PADDR ", " FMT_PADDR ") at pc = " FMT_WORD,
      addr, CONFIG_MBASE, CONFIG_MBASE + CONFIG_MSIZE, cpu.pc));
}

void paddr_write(paddr_t addr, int len, word_t data) {
  if (likely(in_pmem(addr))) {
      pmem_write(addr, len, data);
      IFDEF(CONFIG_MTRACE, Log("address = " FMT_PADDR " write " FMT_PADDR " at pc = " FMT_WORD, addr, data, cpu.pc));
      return;
  }
  MUXDEF(CONFIG_DEVICE, mmio_write(addr, len, data),
    panic("address = " FMT_PADDR " is out of bound of pmem [" FMT_PADDR ", " FMT_PADDR ") at pc = " FMT_WORD,
      addr, CONFIG_MBASE, CONFIG_MBASE + CONFIG_MSIZE, cpu.pc));
}

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .text             PROGBITS        80000000 001000 000128 00  AX  0   0  4
  [ 2] .srodata.mainargs PROGBITS        80000128 001128 000001 00   A  0   0  4
  [ 3] .data.ans         PROGBITS        8000012c 00112c 000100 00  WA  0   0  4
  [ 4] .data.test_data   PROGBITS        8000022c 00122c 000020 00  WA  0   0  4
  [ 5] .comment          PROGBITS        00000000 00124c 000025 01  MS  0   0  1
  [ 6] .symtab           SYMTAB          00000000 001274 0001c0 10      7   9  4
  [ 7] .strtab           STRTAB          00000000 001434 00009b 00      0   0  1
  [ 8] .shstrtab         STRTAB          00000000 0014cf 000056 00      0   0  1

Symbol table '.symtab' contains 28 entries:
   Num:    Value  Size Type    Bind   Vis      Ndx Name
     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND
     1: 80000000     0 SECTION LOCAL  DEFAULT    1
     2: 80000128     0 SECTION LOCAL  DEFAULT    2
     3: 8000012c     0 SECTION LOCAL  DEFAULT    3
     4: 8000022c     0 SECTION LOCAL  DEFAULT    4
     5: 00000000     0 SECTION LOCAL  DEFAULT    5
     6: 00000000     0 FILE    LOCAL  DEFAULT  ABS add.c
     7: 00000000     0 FILE    LOCAL  DEFAULT  ABS trm.c
     8: 80000128     1 OBJECT  LOCAL  DEFAULT    2 mainargs
     9: 80000108    32 FUNC    GLOBAL DEFAULT    1 _trm_init
    10: 80009000     0 NOTYPE  GLOBAL DEFAULT    4 _stack_pointer
    11: 80000128     0 NOTYPE  GLOBAL DEFAULT    1 _etext
    12: 80000000     0 NOTYPE  GLOBAL DEFAULT  ABS _pmem_start
    13: 8000024c     0 NOTYPE  GLOBAL DEFAULT    4 _bss_start
    14: 80000129     0 NOTYPE  GLOBAL DEFAULT    2 edata
    15: 80009000     0 NOTYPE  GLOBAL DEFAULT    4 _heap_start
    16: 80001000     0 NOTYPE  GLOBAL DEFAULT    4 _stack_top
    17: 80009000     0 NOTYPE  GLOBAL DEFAULT    4 end
    18: 80000010    24 FUNC    GLOBAL DEFAULT    1 check
    19: 80000128     0 NOTYPE  GLOBAL DEFAULT    1 etext
    20: 80000000     0 FUNC    GLOBAL DEFAULT    1 _start
    21: 00000000     0 NOTYPE  GLOBAL DEFAULT  ABS _entry_offset
    22: 80000028   212 FUNC    GLOBAL DEFAULT    1 main
    23: 80000129     0 NOTYPE  GLOBAL DEFAULT    2 _data
    24: 8000012c   256 OBJECT  GLOBAL DEFAULT    3 ans
    25: 80009000     0 NOTYPE  GLOBAL DEFAULT    4 _end
    26: 800000fc    12 FUNC    GLOBAL DEFAULT    1 halt
    27: 8000022c    32 OBJECT  GLOBAL DEFAULT    4 test_data

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ riscv64-linux-gnu-readelf -x6 add-riscv32-nemu.elf

Hex dump of section '.symtab':
  0x00000000 00000000 00000000 00000000 00000000 ................
  0x00000010 00000000 00000080 00000000 03000100 ................
  0x00000020 00000000 28010080 00000000 03000200 ....(...........
  0x00000030 00000000 2c010080 00000000 03000300 ....,...........
  0x00000040 00000000 2c020080 00000000 03000400 ....,...........
  0x00000050 00000000 00000000 00000000 03000500 ................
  0x00000060 01000000 00000000 00000000 0400f1ff ................
  0x00000070 07000000 00000000 00000000 0400f1ff ................
  0x00000080 0d000000 28010080 01000000 01000200 ....(...........
  0x00000090 16000000 08010080 20000000 12000100 ........ .......
  0x000000a0 20000000 00900080 00000000 10000400  ...............
  0x000000b0 2f000000 28010080 00000000 10000100 /...(...........
  0x000000c0 36000000 00000080 00000000 1000f1ff 6...............
  0x000000d0 42000000 4c020080 00000000 10000400 B...L...........
  0x000000e0 4d000000 29010080 00000000 10000200 M...)...........
  0x000000f0 53000000 00900080 00000000 10000400 S...............
  0x00000100 5f000000 00100080 00000000 10000400 _...............
  0x00000110 88000000 00900080 00000000 10000400 ................
  0x00000120 6a000000 10000080 18000000 12000100 j...............
  0x00000130 30000000 28010080 00000000 10000100 0...(...........
  0x00000140 3b000000 00000080 00000000 12000100 ;...............
  0x00000150 70000000 00000000 00000000 1000f1ff p...............
  0x00000160 7e000000 28000080 d4000000 12000100 ~...(...........
  0x00000170 95000000 29010080 00000000 10000200 ....)...........
  0x00000180 83000000 2c010080 00010000 11000300 ....,...........
  0x00000190 87000000 00900080 00000000 10000400 ................
  0x000001a0 8c000000 fc000080 0c000000 12000100 ................
  0x000001b0 91000000 2c020080 20000000 11000400 ....,... .......

  0x00000090 16000000 08010080 20000000 12000100
  0x000000c0 36000000 00000080 00000000 1000f1ff

   Num:    Value  Size Type    Bind   Vis      Ndx Name
     9: 80000108    32 FUNC    GLOBAL DEFAULT    1 _trm_init
    12: 80000000     0 NOTYPE  GLOBAL DEFAULT  ABS _pmem_start

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ riscv64-linux-gnu-readelf -x7 add-riscv32-nemu.elf

Hex dump of section '.strtab':
  0x00000000 00616464 2e630074 726d2e63 006d6169 .add.c.trm.c.mai
  0x00000010 6e617267 73005f74 726d5f69 6e697400 nargs._trm_init.
  0x00000020 5f737461 636b5f70 6f696e74 6572005f _stack_pointer._
  0x00000030 65746578 74005f70 6d656d5f 73746172 etext._pmem_star
  0x00000040 74005f62 73735f73 74617274 00656461 t._bss_start.eda
  0x00000050 7461005f 68656170 5f737461 7274005f ta._heap_start._
  0x00000060 73746163 6b5f746f 70006368 65636b00 stack_top.check.
  0x00000070 5f656e74 72795f6f 66667365 74006d61 _entry_offset.ma
  0x00000080 696e0061 6e73005f 656e6400 68616c74 in.ans._end.halt
  0x00000090 00746573 745f6461 746100            .test_data.

ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
  Class:                             ELF32
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           RISC-V
  Version:                           0x1
  Entry point address:               0x80000000
  Start of program headers:          52 (bytes into file)
  Start of section headers:          5416 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         2
  Size of section headers:           40 (bytes)
  Number of section headers:         9
  Section header string table index: 8

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -n 52
0000000 457f 464c 0101 0001 0000 0000 0000 0000
0000010 0002 00f3 0001 0000 0000 8000 0034 0000
0000020 1528 0000 0000 0000 0034 0020 0002 0028
0000030 0009 0008
0000034

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5416 -n 40
0001528 0000 0000 0000 0000 0000 0000 0000 0000
*
0001548 0000 0000 0000 0000
0001550
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5456 -n 40
0001550 001b 0000 0001 0000 0006 0000 0000 8000
0001560 1000 0000 0128 0000 0000 0000 0000 0000
0001570 0004 0000 0000 0000
0001578
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5496 -n 40
0001578 0021 0000 0001 0000 0002 0000 0128 8000
0001588 1128 0000 0001 0000 0000 0000 0000 0000
0001598 0004 0000 0000 0000
00015a0
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5536 -n 40
00015a0 0033 0000 0001 0000 0003 0000 012c 8000
00015b0 112c 0000 0100 0000 0000 0000 0000 0000
00015c0 0004 0000 0000 0000
00015c8
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5576 -n 40
00015c8 003d 0000 0001 0000 0003 0000 022c 8000
00015d8 122c 0000 0020 0000 0000 0000 0000 0000
00015e8 0004 0000 0000 0000
00015f0
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5616 -n 40
00015f0 004d 0000 0001 0000 0030 0000 0000 0000
0001600 124c 0000 0025 0000 0000 0000 0000 0000
0001610 0001 0000 0001 0000
0001618
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5656 -n 40
0001618 0001 0000 0002 0000 0000 0000 0000 0000
0001628 1274 0000 01c0 0000 0007 0000 0009 0000
0001638 0004 0000 0010 0000
0001640
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5696 -n 40
0001640 0009 0000 0003 0000 0000 0000 0000 0000
0001650 1434 0000 009b 0000 0000 0000 0000 0000
0001660 0001 0000 0000 0000
0001668
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5736 -n 40
0001668 0011 0000 0003 0000 0000 0000 0000 0000
0001678 14cf 0000 0056 0000 0000 0000 0000 0000
0001688 0001 0000 0000 0000
0001690

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5656 -n 40
0001618 0001 0000 0002 0000 0000 0000 0000 0000
0001628 1274 0000 01c0 0000 0007 0000 0009 0000
0001638 0004 0000 0010 0000
0001640
vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 5696 -n 40
0001640 0009 0000 0003 0000 0000 0000 0000 0000
0001650 1434 0000 009b 0000 0000 0000 0000 0000
0001660 0001 0000 0000 0000
0001668

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests/build$ hexdump add-riscv32-nemu.elf -s 0x1274 -n 0x1c0
0001274 0000 0000 0000 0000 0000 0000 0000 0000
0001284 0000 0000 0000 8000 0000 0000 0003 0001
0001294 0000 0000 0128 8000 0000 0000 0003 0002
00012a4 0000 0000 012c 8000 0000 0000 0003 0003
00012b4 0000 0000 022c 8000 0000 0000 0003 0004
00012c4 0000 0000 0000 0000 0000 0000 0003 0005
00012d4 0001 0000 0000 0000 0000 0000 0004 fff1
00012e4 0007 0000 0000 0000 0000 0000 0004 fff1
00012f4 000d 0000 0128 8000 0001 0000 0001 0002
0001304 0016 0000 0108 8000 0020 0000 0012 0001
0001314 0020 0000 9000 8000 0000 0000 0010 0004
0001324 002f 0000 0128 8000 0000 0000 0010 0001
0001334 0036 0000 0000 8000 0000 0000 0010 fff1
0001344 0042 0000 024c 8000 0000 0000 0010 0004
0001354 004d 0000 0129 8000 0000 0000 0010 0002
0001364 0053 0000 9000 8000 0000 0000 0010 0004
0001374 005f 0000 1000 8000 0000 0000 0010 0004
0001384 0088 0000 9000 8000 0000 0000 0010 0004
0001394 006a 0000 0010 8000 0018 0000 0012 0001
00013a4 0030 0000 0128 8000 0000 0000 0010 0001
00013b4 003b 0000 0000 8000 0000 0000 0012 0001
00013c4 0070 0000 0000 0000 0000 0000 0010 fff1
00013d4 007e 0000 0028 8000 00d4 0000 0012 0001
00013e4 0095 0000 0129 8000 0000 0000 0010 0002
00013f4 0083 0000 012c 8000 0100 0000 0011 0003
0001404 0087 0000 9000 8000 0000 0000 0010 0004
0001414 008c 0000 00fc 8000 000c 0000 0012 0001
0001424 0091 0000 022c 8000 0020 0000 0011 0004
0001434

#ifndef __ELF_H__
#define __ELF_H__

typedef struct {
    vaddr_t value;
    uint32_t size;
    uint32_t string_index;
    char name[256];
} elf_func_symbol;

extern elf_func_symbol func_symbol[128];
extern uint32_t func_symbol_number;

#endif

elf_func_symbol func_symbol[128];
uint32_t func_symbol_number;

static void load_elf_and_parse() {
    if (elf_file == NULL) {
        Log("No ELF file is given.");
        return;
    }

    FILE *fp = fopen(elf_file, "rb");
    Assert(fp, "Can not open '%s'", elf_file);

    fseek(fp, 0, SEEK_END);
    long size = ftell(fp);

    Log("The ELF file is %s, size = %ld", elf_file, size);

    uint8_t *elf = malloc(size * sizeof(uint8_t));
    fseek(fp, 0, SEEK_SET);
    int ret = fread(elf, size, 1, fp);
    assert(ret == 1);
    fclose(fp);

    // for (long i = 0; i < size; ) {
    //   printf("%2x ", elf[i]);
    //   if (++i % 16 == 0) printf("\n");
    // }
    // printf("\n");

    uint32_t sector_header_index = 0;
    uint32_t sector_header_length = 0; // the size of one section
    uint32_t sector_header_number = 0;

    for (uint32_t i = 35; i >= 32; --i)
        sector_header_index = sector_header_index * 256 + elf[i];
    // printf("%2d\n", sector_header_index);

    for (uint32_t i = 47; i >= 46; --i)
        sector_header_length = sector_header_length * 256 + elf[i];

    for (uint32_t i = 49; i >= 48; --i)
        sector_header_number = sector_header_number * 256 + elf[i];

    uint32_t symbol_table_index = 0;
    uint32_t symbol_table_size  = 0;
    uint32_t string_table_index = 0;
    uint32_t string_table_size  = 0;

    for (uint32_t i = 0; i < sector_header_number; ++i) {
        uint32_t type = 0;
        type = type * 256 + elf[sector_header_index + i * sector_header_length + 5];
        type = type * 256 + elf[sector_header_index + i * sector_header_length + 4];

        if (type == 2) {
            symbol_table_index = symbol_table_index * 256 + elf[sector_header_index + i * sector_header_length + 19];
            symbol_table_index = symbol_table_index * 256 + elf[sector_header_index + i * sector_header_length + 18];
            symbol_table_index = symbol_table_index * 256 + elf[sector_header_index + i * sector_header_length + 17];
            symbol_table_index = symbol_table_index * 256 + elf[sector_header_index + i * sector_header_length + 16];

            symbol_table_size = symbol_table_size * 256 + elf[sector_header_index + i * sector_header_length + 23];
            symbol_table_size = symbol_table_size * 256 + elf[sector_header_index + i * sector_header_length + 22];
            symbol_table_size = symbol_table_size * 256 + elf[sector_header_index + i * sector_header_length + 21];
            symbol_table_size = symbol_table_size * 256 + elf[sector_header_index + i * sector_header_length + 20];
        } else if (type == 3) {
            string_table_index = string_table_index * 256 + elf[sector_header_index + i * sector_header_length + 19];
            string_table_index = string_table_index * 256 + elf[sector_header_index + i * sector_header_length + 18];
            string_table_index = string_table_index * 256 + elf[sector_header_index + i * sector_header_length + 17];
            string_table_index = string_table_index * 256 + elf[sector_header_index + i * sector_header_length + 16];

            string_table_size  = string_table_size * 256 + elf[sector_header_index + i * sector_header_length + 23];
            string_table_size  = string_table_size * 256 + elf[sector_header_index + i * sector_header_length + 22];
            string_table_size  = string_table_size * 256 + elf[sector_header_index + i * sector_header_length + 21];
            string_table_size  = string_table_size * 256 + elf[sector_header_index + i * sector_header_length + 20];
        }

        if (symbol_table_index && string_table_index) // assume
            break;
    }

    // printf("%d %d %d %d\n", symbol_table_index, symbol_table_size, string_table_index, string_table_size);

    func_symbol_number = 0;
    for (uint32_t i = 0; i < symbol_table_size / 16; ++i) {
        if ((elf[symbol_table_index + i * 16 + 12] & 0x0f) == 2) {
            vaddr_t value = 0;
            uint32_t size = 0;
            uint32_t string_index = 0;

            string_index = string_index * 256 + elf[symbol_table_index + i * 16 + 3];
            string_index = string_index * 256 + elf[symbol_table_index + i * 16 + 2];
            string_index = string_index * 256 + elf[symbol_table_index + i * 16 + 1];
            string_index = string_index * 256 + elf[symbol_table_index + i * 16 + 0];

            value = value * 256 + elf[symbol_table_index + i * 16 + 7];
            value = value * 256 + elf[symbol_table_index + i * 16 + 6];
            value = value * 256 + elf[symbol_table_index + i * 16 + 5];
            value = value * 256 + elf[symbol_table_index + i * 16 + 4];

            size = size * 256 + elf[symbol_table_index + i * 16 + 11];
            size = size * 256 + elf[symbol_table_index + i * 16 + 10];
            size = size * 256 + elf[symbol_table_index + i * 16 + 9];
            size = size * 256 + elf[symbol_table_index + i * 16 + 8];

            func_symbol[func_symbol_number].value = value;
            func_symbol[func_symbol_number].size = size;
            func_symbol[func_symbol_number].string_index = string_index;

            func_symbol_number++;
            if (func_symbol_number >= 128) {
                Log("Function symbol storage limit exceeded.");
                break;
            }

            // printf("%x %x %x\n", value, size, string_index);
        }
    }

    for (uint32_t i = 0; i < func_symbol_number; ++i) {
        uint32_t string_index_st = func_symbol[i].string_index;
        uint32_t string_index_ed = string_index_st;
        while(elf[string_table_index + string_index_ed])
            string_index_ed++;
        if (string_index_ed - string_index_st + 1 > 256)
            panic("Function name is too long");
        strncpy(func_symbol[i].name, (const char *)&elf[string_table_index + string_index_st], string_index_ed - string_index_st + 1);
        Assert(func_symbol[i].name[string_index_ed - string_index_st + 1] == '\0', "The string does not terminate with a zero character.");

        // printf("%d %s\n", string_index_ed - string_index_st + 1, func_symbol[i].name);
    }

    free(elf);
    return;
}

#ifdef CONFIG_FTRACE
  #include <elf.h>

  // unsigned int depth = 0;

  const char *get_func_name(vaddr_t addr) {
      for (uint32_t i = 0; i < func_symbol_number; ++i) {
          if (func_symbol[i].value <= addr && addr < func_symbol[i].value + func_symbol[i].size)
              return func_symbol[i].name;
      }
      return NULL;
  }
#endif


def_EHelper(jal) {
#ifdef CONFIG_FTRACE
  vaddr_t now_pc = s->pc;
  rtlreg_t next_pc = id_src1->imm + s->pc;
  const char *name =  get_func_name(next_pc);
  if (name != NULL)
    printf(FMT_PADDR ": call [%s@" FMT_PADDR "]\n", now_pc, name, next_pc);
  else
    printf(FMT_PADDR ": call [???@" FMT_PADDR "]\n", now_pc, next_pc);
#endif

  rtl_addi(s, ddest, &s->pc, 4);
  rtl_li(s, &s->dnpc, id_src1->imm + s->pc);
}

def_EHelper(jalr) {
  vaddr_t t = s->pc + 4;
  vaddr_t next_pc = (id_src2->imm + *dsrc1) & ~1;

#ifdef CONFIG_FTRACE
  vaddr_t now_pc = s->pc;
  if(s->isa.instr.i.rs1 == 1 && s->isa.instr.i.rd == 0) {
    const char *name = get_func_name(now_pc);
    if (name != NULL)
      printf(FMT_PADDR ": ret  [%s]\n", now_pc, name);
    else
      printf(FMT_PADDR ": ret  [???]\n", now_pc);
  } else {
    const char *name = get_func_name(next_pc);
    if (name != NULL)
      printf(FMT_PADDR ": call [%s@" FMT_PADDR "]\n", now_pc, name, next_pc);
    else
      printf(FMT_PADDR ": call [???@" FMT_PADDR "]\n", now_pc, next_pc);
  }
#endif

  rtl_li(s, &s->dnpc, next_pc);
  rtl_li(s, ddest, t);
}

vgalaxy@vgalaxy-VirtualBox:~/ics2021/nemu$ ./build/riscv32-nemu-interpreter --log=/home/vgalaxy/ics2021/nemu/build/nemu-log.txt --elf=../am-kernels/tests/cpu-tests/build/add-riscv32-nemu.elf ../am-kernels/tests/cpu-tests/build/add-riscv32-nemu.bin

run --log=/home/vgalaxy/ics2021/nemu/build/nemu-log.txt --elf=../am-kernels/tests/cpu-tests/build/add-riscv32-nemu.elf ../am-kernels/tests/cpu-tests/build/add-riscv32-nemu.bin

Watchpoint 2: func_symbol

Old value =
    {{value = 2147484244, size = 32, string_index = 28, name = "_trm_init", '\000' <repeats 246 times>}, {value = 2147483912, size = 168, string_index = 116, name = "f3", '\000' <repeats 253 times>}, {value = 2147484080, size = 24, string_index = 119, name = "check", '\000' <repeats 250 times>}, {value = 2147483812, size = 100, string_index = 125, name = "f2", '\000' <repeats 253 times>}, {value = 2147483648, size = 0, string_index = 65, name = "_start", '\000' <repeats 249 times>}, {value = 2147484104, size = 128, string_index = 142, name = "main", '\000' <repeats 251 times>}, {value = 2147483664, size = 76, string_index = 147, name = "f0", '\000' <repeats 253 times>}, {value = 2147483740, size = 72, string_index = 165, name = "f1", '\000' <repeats 253 times>}, {value = 2147484232, size = 12, string_index = 173, name = "halt", '\000' <repeats 251 times>}, {value = 0, size = 0, string_index = 0, name = '\000' <repeats 255 times>} <repeats 119 times>}
New value =
    {{value = 741695776, size = 808859168, string_index = 28, name = "_trm_init", '\000' <repeats 246 times>}, {value = 2147483912, size = 168, string_index = 116, name = "f3", '\000' <repeats 253 times>}, {value = 2147484080, size = 24, string_index = 119, name = "check", '\000' <repeats 250 times>}, {value = 2147483812, size = 100, string_index = 125, name = "f2", '\000' <repeats 253 times>}, {value = 2147483648, size = 0, string_index = 65, name = "_start", '\000' <repeats 249 times>}, {value = 2147484104, size = 128, string_index = 142, name = "main", '\000' <repeats 251 times>}, {value = 2147483664, size = 76, string_index = 147, name = "f0", '\000' <repeats 253 times>}, {value = 2147483740, size = 72, string_index = 165, name = "f1", '\000' <repeats 253 times>}, {value = 2147484232, size = 12, string_index = 173, name = "halt", '\000' <repeats 251 times>}, {value = 0, size = 0, string_index = 0, name = '\000' <repeats 255 times>} <repeats 119 times>}
__strcpy_avx2 () at ../sysdeps/x86_64/multiarch/strcpy-avx2.S:613
613  ../sysdeps/x86_64/multiarch/strcpy-avx2.S: No such file or directory.

(gdb) bt
#0  __strcpy_avx2 () at ../sysdeps/x86_64/multiarch/strcpy-avx2.S:50
#1  0x00007ffff2b4efbb in _nc_first_db () from /lib/x86_64-linux-gnu/libtinfo.so.6
#2  0x00007ffff2b57e37 in _nc_read_entry2 () from /lib/x86_64-linux-gnu/libtinfo.so.6
#3  0x00007ffff2b51cb6 in ?? () from /lib/x86_64-linux-gnu/libtinfo.so.6
#4  0x00007ffff2b52067 in _nc_setupterm () from /lib/x86_64-linux-gnu/libtinfo.so.6
#5  0x00007ffff2b525ea in tgetent_sp () from /lib/x86_64-linux-gnu/libtinfo.so.6
#6  0x00007ffff7f92485 in _rl_init_terminal_io ()
   from /lib/x86_64-linux-gnu/libreadline.so.8
#7  0x00007ffff7f74410 in rl_initialize () from /lib/x86_64-linux-gnu/libreadline.so.8
#8  0x00007ffff7f746d5 in readline () from /lib/x86_64-linux-gnu/libreadline.so.8
#9  0x000055555555c354 in rl_gets () at src/monitor/sdb/sdb.c:29
#10 sdb_mainloop () at src/monitor/sdb/sdb.c:189
#11 0x000055555555d3bb in engine_start () at src/engine/interpreter/init.c:10
#12 0x0000555555558f14 in main (argc=<optimized out>, argv=<optimized out>)
    at src/nemu-main.c:21

  bool is_init = false;
  static elf_func_symbol local_func_symbol[128];

  void init_func_symbol() {
      for (uint32_t i = 0; i < func_symbol_number; ++i) {
          local_func_symbol[i] = func_symbol[i];
      }

      is_init = true;
  }

int f0(int, int);
int f1(int, int);
int f2(int, int);
int f3(int, int);

int (*func[])(int, int) = {
  f0, f1, f2, f3,
};

int rec = 0, lvl = 0;

int f0(int n, int l) {
  if (l > lvl) lvl = l;
  rec ++;
  return n <= 0 ? 1 : func[3](n / 3, l + 1);
};

int f1(int n, int l) {
  if (l > lvl) lvl = l;
  rec ++;
  return n <= 0 ? 1 : func[0](n - 1, l + 1);
};

int f2(int n, int l) {
  if (l > lvl) lvl = l;
  rec ++;
  return n <= 0 ? 1 : func[1](n, l + 1) + 9;
};

int f3(int n, int l) {
  if (l > lvl) lvl = l;
  rec ++;
  return n <= 0 ? 1 : func[2](n / 2, l + 1) * 3 + func[2](n / 2, l + 1) * 2;
};

0x8000000c: call   [_trm_init@0x80000254]
0x80000264: call     [main@0x800001c8]
0x800001ec: call       [f0@0x80000010]
0x80000050: call         [f3@0x80000108]
0x8000016c: call           [f2@0x800000a4]
0x800000f0: call             [f1@0x8000005c]
0x80000098: call               [f0@0x80000010]
0x80000050: call                 [f3@0x80000108]
0x8000016c: call                   [f2@0x800000a4]
0x800000f0: call                     [f1@0x8000005c]
0x80000098: call                       [f0@0x80000010]
0x80000050: call                         [f3@0x80000108]
0x8000016c: call                           [f2@0x800000a4]
0x800000f0: call                             [f1@0x8000005c]
0x80000098: call                               [f0@0x80000010]
0x80000050: call                                 [f3@0x80000108]
0x8000016c: call                                   [f2@0x800000a4]
0x800000f0: call                                     [f1@0x8000005c]
0x80000098: call                                       [f0@0x80000010]
0x80000050: call                                         [f3@0x80000108]
0x8000016c: call                                           [f2@0x800000a4]
0x800000f0: call                                             [f1@0x8000005c]
0x80000098: call                                               [f0@0x80000010]
0x80000058: ret                                                [f0]
0x80000100: ret                                              [f2]
0x80000180: call                                             [f2@0x800000a4]
0x800000f0: call                                               [f1@0x8000005c]
0x80000098: call                                                 [f0@0x80000010]
0x80000058: ret                                                  [f0]
0x80000100: ret                                                [f2]
0x800001a8: ret                                              [f3]
0x80000100: ret                                            [f2]

#define __NATIVE_USE_KLIB__

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/klib-tests$ tree
.
├── build
│   ├── klibtest-native
│   └── native
│       └── src
│           ├── main.d
│           ├── main.o
│           └── tests
│               ├── test_memset.d
│               └── test_memset.o
├── include
│   └── klibtest.h
├── Makefile
└── src
    ├── main.c
    └── tests
        └── test_memset.c

7 directories, 9 files

#ifndef __KLIBUNIT_H__
#define __KLIBUNIT_H__

#include <am.h>
#include <klib.h>
#include <klib-macros.h>

extern void (*entry)();

#define CASE(id, entry_, ...) \
  case id: { \
    void entry_(); \
    entry = entry_; \
    __VA_ARGS__; \
    entry_(); \
    break; \
  }

#endif

NAME = klibtest
SRCS = $(shell find src/ -name "*.[cS]")
include $(AM_HOME)/Makefile

#include <klibtest.h>

void (*entry)() = NULL; // mp entry

static const char *tests[256] = {
    ['H'] = "display this help message",
    ['a'] = "test_memset",
};

int main(const char *args) {
  switch (args[0]) {
    CASE('a', test_memset);
    case 'H':
    default:
      printf("Usage: make run mainargs=*\n");
      for (int ch = 0; ch < 256; ch++) {
        if (tests[ch]) {
          printf("  %c: %s\n", ch, tests[ch]);
        }
      }
  }
  return 0;
}

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/klib-tests$ make ARCH=native run mainargs=a

#if !defined(__ISA_NATIVE__) || !defined(__NATIVE_USE_KLIB__)

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/klib-tests$ gdb ../../../nemu/build/riscv32-nemu-interpreter
(gdb) watch head
Hardware watchpoint 1: head
(gdb) run --log=/home/vgalaxy/ics2021/nemu/build/nemu-log.txt ./build/klibtest-riscv32-nemu.bin

Breakpoint 1, __memset_avx2_unaligned () at ../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S:98

#include <klibtest.h>

#define N 32
uint8_t data[N];

void reset() {
  int i;
  for (i = 0; i < N; i ++) {
    data[i] = i + 1;
  }
}

// 检查 [l,r) 区间中的值是否依次为 val, val + 1, val + 2...
void check_seq(int l, int r, int val) {
  int i;
  for (i = l; i < r; i ++) {
    assert(data[i] == val + i - l);
  }
}

// 检查 [l,r) 区间中的值是否均为 val
void check_eq(int l, int r, int val) {
  int i;
  for (i = l; i < r; i ++) {
    assert(data[i] == val);
  }
}

void test_memset() {
  int l, r;
  for (l = 0; l < N; l ++) {
    for (r = l + 1; r <= N; r ++) {
      reset();
      uint8_t val = (l + r) / 2;
      memset(data + l, val, r - l);
      check_seq(0, l, 1);
      check_eq(l, r, val);
      check_seq(r, N, r + 1);
    }
  }
}

void test_memcpy() {
  int l, r;
  for (l = 0; l < N; l ++) {
    for (r = l + 1; r < N; r ++) {
      reset();
      int seq = (r - l) / 2;
      if (r + seq >= N)
          continue;
      memcpy(data + r, data + l, seq);
      check_seq(l, l + seq, l + 1);
      check_seq(r, r + seq, l + 1);
    }
  }
}

static void reset() {
  int i;
  for (i = 0; i < N; i ++) {
    data[i] = 0;
  }
}

void test_strlen() {
    reset();
    for (int i = 0; i < N - 1; ++i) {
        size_t before = strlen(data);
        strcat(data, "a");
        size_t after = strlen(data);
        assert(after - before == 1);
    }
}

static void reset() {
  int i;
  for (i = 0; i < N; i ++) {
    data[i] = 0;
  }
}

void test_memcmp() {
    reset();
    for (int i = 0; i < N - 1; ++i) {
        assert(memcmp(data, strcat(data, "a"), i + 1) == 0);
    }
}

#include <klibtest.h>

__attribute__((noinline))
static void check(bool cond) {
  if (!cond) halt(1);
}

static char buf[1024];

void test_sprintf() {
    int res = sprintf(buf, "%s", "Hello world!\n");
    check(res == 13);
    check(strcmp(buf, "Hello world!\n") == 0);

    res = sprintf(buf, "%d + %d = %d\n", 1, 1, 2);
    check(res == 10);
    check(strcmp(buf, "1 + 1 = 2\n") == 0);

    res = sprintf(buf, "%d + %d = %d\n", 2, 10, 12);
    check(res == 12);
    check(strcmp(buf, "2 + 10 = 12\n") == 0);
}

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/klib-tests$ /home/vgalaxy/ics2021/nemu/build/riscv32-nemu-interpreter -l /home/vgalaxy/ics2021/am-kernels/tests/klib-tests/build/nemu-log.txt -e /home/vgalaxy/ics2021/am-kernels/tests/klib-tests/build/klibtest-riscv32-nemu.elf /home/vgalaxy/ics2021/am-kernels/tests/klib-tests/build/klibtest-riscv32-nemu.bin

// 在 DUT host memory 的 `buf` 和 REF guest memory 的 `dest` 之间拷贝 `n` 字节，
// `direction` 指定拷贝的方向，`DIFFTEST_TO_DUT` 表示往 DUT 拷贝，`DIFFTEST_TO_REF` 表示往 REF 拷贝
void difftest_memcpy(paddr_t addr, void *buf, size_t n, bool direction);
// `direction` 为 `DIFFTEST_TO_DUT` 时，获取 REF 的寄存器状态到 `dut`;
// `direction` 为 `DIFFTEST_TO_REF` 时，设置 REF 的寄存器状态为 `dut`;
void difftest_regcpy(void *dut, bool direction);
// 让 REF 执行 `n` 条指令
void difftest_exec(uint64_t n);
// 初始化 REF 的 DiffTest 功能
void difftest_init();

struct diff_context_t {
  word_t gpr[32];
  word_t pc;
};

typedef struct {
  struct {
    rtlreg_t _32;
  } gpr[32];

  vaddr_t pc;
} riscv32_CPU_state;

bool isa_difftest_checkregs(CPU_state *ref_r, vaddr_t pc) {
    for (int i = 0; i < 32; ++i) {
        if (ref_r->gpr[i]._32 != cpu.gpr[i]._32) {
            Log("At %s -> REF: " FMT_WORD ", DUT: " FMT_WORD, reg_name(i, 0), ref_r->gpr[i]._32, cpu.gpr[i]._32);
            return false;
        }
    }
    if (ref_r->pc != cpu.pc) {
        Log("At pc -> REF: " FMT_WORD ", DUT: " FMT_WORD, ref_r->pc, cpu.pc);
        return false;
    }
    return true;
}

Makefile:349: warning: overriding recipe for target 'disasm.o'
Makefile:349: warning: ignoring old recipe for target 'disasm.o'
make[4]: Circular libcustomext.so <- libcustomext.so dependency dropped.
make[4]: Circular libsoftfloat.so <- libsoftfloat.so dependency dropped.

--diff=/home/vgalaxy/ics2021/nemu/tools/spike-diff/build/riscv32-spike-so

vgalaxy@vgalaxy-VirtualBox:~/ics2021/am-kernels/tests/cpu-tests$ make ARCH=riscv32-nemu ALL=add run
...
[src/cpu/cpu-exec.c:145 cpu_exec] nemu: ABORT at pc = 0x80000000