/* cte.c 粘一些代表性的，不全粘贴 */ 
Context* __am_irq_handle(Context *c) {
  if (user_handler) {
    Event ev = {0};
    switch (c->mcause) {
      case 11: 
        if (c->gpr[17] == -1)  // check a7 value
          ev.event = EVENT_YIELD;
        else 
          ev.event = EVENT_SYSCALL;
        c->mepc += 4;
        break;
      default: ev.event = EVENT_ERROR; break;
    }
    c = user_handler(ev, c);
    assert(c != NULL);
  }

  return c;
}

/* syscall.c 粘一些代表性的，不全粘贴 */ 
void do_syscall(Context *c) {
  uintptr_t a[4];
  a[0] = c->GPR1;
  a[1] = c->GPR2;
  a[2] = c->GPR3;
  a[3] = c->GPR4;
  
  // int i;
  // printf("\n%-10s\t%-10s\t%s\n", "REG_NAME", "HEX_VALUE", "DEC_VALUE");
  // for (i = 0; i < 32; ++i) {
  //   printf("%-10s\t%#010x\t%-12u\n", "", c->gpr[i], c->gpr[i]);
  // }
  // printf("%-10s\t%#010x\t%-12u\n", "mstatus", c->mstatus, c->mstatus);
  // printf("%-10s\t%#010x\t%-12u\n", "mcause", c->mcause, c->mcause);
  // printf("%-10s\t%#010x\t%-12u\n", "mepc", c->mepc, c->mepc);

  switch (a[0]) {
    case SYS_exit: if (SYS_DEBUG) Log("Syscall: exit"); halt(a[1]); break;
    case SYS_yield: if (SYS_DEBUG) Log("Syscall: yield"); yield(); c->GPRx = 0; break;
    case SYS_open: if (SYS_DEBUG) Log("Syscall: open"); c->GPRx = fs_open((char *)a[1], a[2], a[3]); break;
    case SYS_read: if (SYS_DEBUG) Log("Syscall: read"); c->GPRx = fs_read(a[1], (void *)a[2], a[3]); break;
    case SYS_write: if (SYS_DEBUG) Log("Syscall: write"); c->GPRx = fs_write(a[1], (void *)a[2], a[3]); break;
    case SYS_lseek: if (SYS_DEBUG) Log("Syscall: lseek"); c->GPRx = fs_lseek(a[1], a[2], a[3]); break;
    case SYS_close: if (SYS_DEBUG) Log("Syscall: close"); c->GPRx = fs_close(a[1]); break;
    case SYS_brk: if (SYS_DEBUG) Log("Syscall: brk"); c->GPRx = 0; break; // fail return -1
    case SYS_gettimeofday: if (SYS_DEBUG) Log("Syscall: gettimeofday"); c->GPRx = sys_gettimeofday((struct timeval *)a[1], (struct timezone *)a[2]); break;
    default: panic("Unhandled syscall ID = %d", a[0]);
  }

}

/* inst.c 粘一些代表性的，不全粘贴 */ 

  INSTPAT("??????? ????? ????? 001 ????? 11100 11", csrrw  , I, rd? (R(rd) = CSR(imm)) : 0; CSR(imm) = src1);
  INSTPAT("??????? ????? ????? 010 ????? 11100 11", csrrs  , I, R(rd) = CSR(imm); src1? (CSR(imm) |= src1) : 0);
  INSTPAT("0000000 00000 00000 000 00000 11100 11", ecall  , N, s->dnpc = isa_raise_intr(11, s->pc)); // Environment call from M-mode
  INSTPAT("0000000 00001 00000 000 00000 11100 11", ebreak , N, NEMUTRAP(s->pc, R(10))); // R(10) is $a0
  INSTPAT("0011000 00010 00000 000 00000 11100 11", mret   , N, s->dnpc = CSR(0x341)); // Get return address from 0x341

/* fs.c 粘一些代表性的，不全粘贴 */ 

static Finfo file_table[] __attribute__((used)) = {
  [FD_STDIN]  = {"stdin", 0, 0, 0, invalid_read, serial_write},
  [FD_STDOUT] = {"stdout", 0, 0, 0, invalid_read, serial_write},
  [FD_STDERR] = {"stderr", 0, 0, 0, invalid_read, invalid_write},
  [FD_EVENTS] = {"/dev/events", 0, 0, 0, events_read, invalid_write},
  [FD_FB]     = {"/dev/fb", 0, 0, 0, invalid_read, fb_write},
  {"/proc/dispinfo", 0, 0, 0, dispinfo_read, invalid_write },
#include "files.h"
};

void init_fs() {
  // initialize the size of /dev/fb
  AM_GPU_CONFIG_T gpu_config = io_read(AM_GPU_CONFIG);
  int width = gpu_config.width;
  int height = gpu_config.height;
  file_table[FD_FB].size = width * height * sizeof(uint32_t);
}

int fs_open(const char *pathname, int flags, int mode) {
  for (int i = 0; i < sizeof(file_table) / sizeof(file_table[0]); i++) {
    if (strcmp(pathname, file_table[i].name) == 0) {
      file_table[i].open_offset = 0;
      return i;
    }
  }
  assert(0);
  return -1;
}

size_t fs_read(int fd, void *buf, size_t len) {
  size_t nread = 0;
  if (file_table[fd].read == NULL)
    nread = ramdisk_read(buf, file_table[fd].disk_offset + file_table[fd].open_offset, len);
  else
    nread = file_table[fd].read(buf, file_table[fd].disk_offset + file_table[fd].open_offset, len);
  if (fd != FD_STDIN) {
    file_table[fd].open_offset = file_table[fd].open_offset + nread > file_table[fd].size ? file_table[fd].size : file_table[fd].open_offset + nread;
  }
  return fd >= 0 ? nread : -1;
}

size_t fs_write(int fd, const void *buf, size_t len) {
  size_t nwrite = 0;
  if (file_table[fd].write == NULL)
    nwrite = ramdisk_write(buf, file_table[fd].disk_offset + file_table[fd].open_offset, len);
  else
    nwrite = file_table[fd].write(buf, file_table[fd].disk_offset + file_table[fd].open_offset, len);
  if (fd != FD_STDOUT && fd != FD_STDERR) {
    file_table[fd].open_offset = file_table[fd].open_offset + nwrite > file_table[fd].size ? file_table[fd].size : file_table[fd].open_offset + nwrite;
  }
  return fd >= 0 ? nwrite : -1;
}

size_t fs_lseek(int fd, size_t offset, int whence) {
  switch (whence) {
    case SEEK_SET: file_table[fd].open_offset = offset; break;
    case SEEK_CUR: file_table[fd].open_offset += offset; break;
    case SEEK_END: file_table[fd].open_offset = file_table[fd].size + offset; break;
    default: assert(0);
  }
  if (file_table[fd].open_offset < 0 || file_table[fd].open_offset > file_table[fd].size) {
    Log("fs_lseek: offset out of range");
    return -1;
  }
  return file_table[fd].open_offset >= 0 ? file_table[fd].open_offset : -1;
}

int fs_close(int fd) {
  return 0;
}

/* loader.c 粘一些代表性的，不全粘贴 */ 

static uintptr_t loader(PCB *pcb, const char *filename) {
  int fd = fs_open(filename, 0, 0);
  if (fd == -1) {
      printf("Failed to open file %s\n", filename);
      assert(0);
  }
  Elf_Ehdr ehdr;
  if (fs_read(fd, &ehdr, sizeof(Elf_Ehdr)) == 0) {
      printf("Failed to read ELF header\n");
      assert(0);
  }
  if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0) {
      printf("Not an ELF file\n");
      assert(0);
  }
  if (ehdr.e_machine != EXPECT_TYPE) {
      printf("Not an ELF file of target ISA\n");
      assert(0);
  }
  Elf_Phdr phdr[ehdr.e_phnum];
  fs_lseek(fd, ehdr.e_phoff, SEEK_SET);
  if (fs_read(fd, phdr, ehdr.e_phnum * sizeof(Elf_Phdr)) == 0) {
      printf("Failed to read program headers\n");
      assert(0);
  }
  for (int i = 0; i < ehdr.e_phnum; i++) {
      if (phdr[i].p_type == PT_LOAD) {
          fs_lseek(fd, phdr[i].p_offset, SEEK_SET);
          if (fs_read(fd, (void *)phdr[i].p_vaddr, phdr[i].p_filesz) == 0) {
              printf("Failed to read segment %d\n", i);
              assert(0);
          }
          if (phdr[i].p_filesz < phdr[i].p_memsz) {
              memset((void *)(phdr[i].p_vaddr + phdr[i].p_filesz), 0, phdr[i].p_memsz - phdr[i].p_filesz);
          }
      }
  }
  fs_close(fd);
  return ehdr.e_entry;
}

/* device.c 粘一些代表性的，不全粘贴 */ 

int sys_gettimeofday(struct timeval *tv, struct timezone *tz) {
  uint64_t us = io_read(AM_TIMER_UPTIME).us;
  tv->tv_sec = us / 1000000;
  tv->tv_usec = us % 1000000;
  return 0;
}

size_t serial_write(const void *buf, size_t offset, size_t len) {
  for (int i = 0; i < len; i++) {
    putch(((char *)buf + offset)[i]);
  }
  return len;
}

size_t events_read(void *buf, size_t offset, size_t len) {
  AM_INPUT_KEYBRD_T kb = io_read(AM_INPUT_KEYBRD);
  int nread = snprintf((char*)buf, len, "%s %s\n", kb.keydown ? "kd" : "ku", keyname[kb.keycode]);
  if (kb.keycode == AM_KEY_NONE)
    nread = 0;
  return nread;
}

size_t dispinfo_read(void *buf, size_t offset, size_t len) {
  AM_GPU_CONFIG_T gpu_config = io_read(AM_GPU_CONFIG);
  return snprintf((char *)buf, len, "WIDTH: %d\nHEIGHT: %d\n", gpu_config.width, gpu_config.height);
}

size_t fb_write(const void *buf, size_t offset, size_t len) {
  AM_GPU_CONFIG_T gpu_config = io_read(AM_GPU_CONFIG);
  int width = gpu_config.width;
 
  offset /= 4;
  len /= 4;
 
  int y = offset / width;
  int x = offset % width;
 
  io_write(AM_GPU_FBDRAW, x, y, (void *)buf, len, 1, true);
 
  return len;
}

/* fixdptc.h 粘一些代表性的，不全粘贴 */ 

static inline fixedpt fixedpt_muli(fixedpt A, int B) {
	return A * B;
}

/* Divides a fixedpt number with an integer, returns the result. */
static inline fixedpt fixedpt_divi(fixedpt A, int B) {
	return A / B;
}

/* Multiplies two fixedpt numbers, returns the result. */
static inline fixedpt fixedpt_mul(fixedpt A, fixedpt B) {
	return A * (B >> FIXEDPT_FBITS);
}


/* Divides two fixedpt numbers, returns the result. */
static inline fixedpt fixedpt_div(fixedpt A, fixedpt B) {
	return A / (B >> FIXEDPT_FBITS);
}

static inline fixedpt fixedpt_abs(fixedpt A) {
	return A < 0 ? -A : A;
}

static inline fixedpt fixedpt_floor(fixedpt A) {
	if (fixedpt_fracpart(A) == 0) return A;
	if (A > 0) return A & ~FIXEDPT_FMASK;
	else return (A & ~FIXEDPT_FMASK) - FIXEDPT_ONE;
}

static inline fixedpt fixedpt_ceil(fixedpt A) {
	if (fixedpt_fracpart(A) == 0) return A;
	if (A > 0) return (A & ~FIXEDPT_FMASK) + FIXEDPT_ONE;
	else return A & ~FIXEDPT_FMASK;
}

/* event.c 粘一些代表性的，不全粘贴 */ 

int SDL_PollEvent(SDL_Event *ev) {
  char buf[64];
  if (NDL_PollEvent(buf, sizeof(buf))) {
    char type[8];
    char key[16];
    if (sscanf(buf, "%s %s", type, key) == 2) {
      ev->key.type = (strcmp(type, "kd") == 0) ? SDL_KEYDOWN : SDL_KEYUP;
      for (int i = 0; i < sizeof(keyname) / sizeof(keyname[0]); i++) {
        if (strcmp(key, keyname[i]) == 0) {
          ev->key.keysym.sym = i;
          return 1;
        }
      }
    }
  }
  return 0;
}

int SDL_WaitEvent(SDL_Event *event) {
  int ret;
  while (1) {
    ret = SDL_PollEvent(event);
    if (ret) {
      return ret;
    }
  }
}

/* NDL.c 粘一些代表性的，不全粘贴 */ 

uint32_t NDL_GetTicks() {
  // return the time in milliseconds
  assert(gettimeofday(&tv, NULL) == 0);
  return tv.tv_sec * 1000 + tv.tv_usec / 1000 - start_time;

}

int NDL_PollEvent(char *buf, int len) {
  int fd = open("/dev/events", 0, 0);
  if (fd < 0) return 0;
  int nread = read(fd, buf, len);
  assert(close(fd) == 0);
  return nread > 0 ? 1 : 0;
}

void NDL_OpenCanvas(int *w, int *h) {

  if (getenv("NWM_APP")) {
    int fbctl = 4;
    fbdev = 5;
    screen_w = *w; screen_h = *h;
    char buf[64];
    int len = sprintf(buf, "%d %d", screen_w, screen_h);
    // let NWM resize the window and create the frame buffer
    write(fbctl, buf, len);
    while (1) {
      // 3 = evtdev
      int nread = read(3, buf, sizeof(buf) - 1);
      if (nread <= 0) continue;
      buf[nread] = '\0';
      if (strcmp(buf, "mmap ok") == 0) break;
    }
    close(fbctl);
  }
  else {
    canvas_h = *h == 0 || canvas_h > screen_h ? screen_h : *h;
    canvas_w = *w == 0 || canvas_w > screen_w ? screen_w : *w;
    *h = canvas_h;
    *w = canvas_w;
    canvas_x = (screen_w - canvas_w) / 2;
    canvas_y = (screen_h - canvas_h) / 2;
  }
}

void NDL_DrawRect(uint32_t *pixels, int x, int y, int w, int h) {
  w = w ? w : canvas_w;
  h = h ? h : canvas_h;
  int fd = open("/dev/fb", 0, 0);
  for (int i = 0; i < h && y + i < canvas_h; ++i) {
    lseek(fd, ((y + canvas_y + i) * screen_w + (x + canvas_x)) * sizeof(uint32_t), SEEK_SET);
    write(fd, pixels + i * w,  (w < canvas_w - x ? w : canvas_w - x) * sizeof(uint32_t));
  }
  assert(close(fd) == 0);

}

int NDL_Init(uint32_t flags) {
  if (getenv("NWM_APP")) {
    evtdev = 3;
  }
  int fd = open("/proc/dispinfo", 0, 0);
  char buf[64];
  int nread = read(fd, buf, sizeof(buf) - 1);
  if (nread > 0) {
    buf[nread] = '\0';
    int i = 0;
    while (buf[i] != ':') ++i;
    screen_w = atoi(buf + i + 1);
    ++i;
    while (buf[i] != ':') ++i;
    screen_h = atoi(buf + i + 1);
  }
  else {
    assert(0);
  }

  gettimeofday(&tv, NULL);
  start_time = tv.tv_sec * 1000 + tv.tv_usec / 1000;

  return 0;
}

#define PI 3.14159

#define SQUARE(x) ((x) * (x))

#ifdef DEBUG
    printf("Debug information\n");
#endif

eval(p, q) {
  if (p > q) {
    /* Bad expression */
  }
  else if (p == q) {
    /* Single token.
     * For now this token should be a number.
     * Return the value of the number.
     */
  }
  else if (check_parentheses(p, q) == true) {
    /* The expression is surrounded by a matched pair of parentheses.
     * If that is the case, just throw away the parentheses.
     */
    return eval(p + 1, q - 1);
  }
  else {
    /* We should do more things here. */
  }
}

/* sdb.c 粘一些代表性的，不全粘贴 */ 
static int cmd_x(char* args) {
  /* extract the first argument */
  char* arg = strtok(NULL, " ");

  word_t N;
  vaddr_t EXPR;

  if (arg == NULL) {
    /* no argument is given */
    printf("ERROR: x need two argument: N implies length, EXPR implies expression");
  }
  else {
    /* read the first argument */
    sscanf(arg, "%u", &N);
          
    arg = strtok(NULL, " ");

    if (arg == NULL) {
      /* only one argument is given */
      printf("ERROR: x need two argument: N implies length, EXPR implies expression");
    }
    else {
      bool success;

      EXPR = (vaddr_t)expr(arg, &success);

      if (!success) {
        printf("EXPR is invalid");
        assert(0);
      }
      else {
        int i;
        printf("%-10s\t%-10s\t%s\n", "VADDR", "HEX_VALUE", "DEC_VALUE");
        for (i = 0; i < N; ++i) {
          word_t value = vaddr_read(EXPR, sizeof(word_t));
          printf("%#010x\t%#010x\t%u\n", EXPR, value, value);
          EXPR += sizeof(word_t);
        }
      }
    }
  }

  return 0;
}

/* expr.c 粘一些代表性的，不全粘贴 */ 
static int check_parentheses(int p, int q) {
  // check if the expression is surrounded by a matched pair of parentheses
  if (p > q)
    return -1;
  int cnt = 0, i;
  for (i = p; i <= q; ++i) {
    if (tokens[i].type == '(')
      ++cnt;
    else if (tokens[i].type == ')')
      --cnt;
    if (cnt < 0)
      return 0;
  }
  if (cnt)
    return 0;
  if (tokens[p].type != '(' || tokens[q].type != ')')
    return -1;
  int result = check_parentheses(p + 1, q - 1);
  if (result) /* value is -1 or 1 */
    return 1;
  else
    return -1;
}

static int get_op_level(int op_type) {
  switch (op_type) {
  case TK_OR:
    return 1;
  case TK_AND:
    return 2;
  case TK_EQ: case TK_NEQ:
    return 3;
  case '+': case '-':
    return 4;
  case '*': case '/':
    return 5;
  case TK_NEG: case TK_DEREF: case TK_NOT:
    return 6;
  default:
    printf("ERROR: invalid operator %d (enum index)\n", op_type);
    assert(0);
  }
}

static void find_unary_op() {
  int i;
  for (i = 0; i < nr_token; ++i) {
    if (tokens[i].type == '-' && (i == 0 || is_bin_op(tokens[i - 1].type))) {
      tokens[i].type = TK_NEG;
    }
    else if (tokens[i].type == '*' && (i == 0 || is_bin_op(tokens[i - 1].type))) {
      tokens[i].type = TK_DEREF;
    }
    else if (tokens[i].type == '!' && (i == 0 || is_bin_op(tokens[i - 1].type))) {
      tokens[i].type = TK_NOT;
    }
  }
}

static int eval(int p, int q) {
  if (p > q) {
    /* Bad expression */
    printf("ERROR: bad expression\n");
    assert(0);
  }
  else if (p == q) {
    /* Single token.
     * For now this token should be a number.
     * Return the value of the number.
     */
    long long num;
    if (tokens[p].type == TK_HEX)
      sscanf(tokens[p].str, "%llx", &num);
    else if (tokens[p].type == TK_DEC)
      sscanf(tokens[p].str, "%lld", &num);
    else if (tokens[p].type == TK_REG) {
      bool success = true;
      int result = isa_reg_str2val(tokens[p].str, &success);
      if (!success) {
        printf("ERROR: invalid register %s\n", tokens[p].str);
        assert(0);
      }
      return result;
    }
    else {
      printf("ERROR: invalid token %d (enum index)\n", tokens[p].type);
      assert(0);
    }
    if (num > 0x100000000) {
      printf("WARNING: the input number [%s] is too large", tokens[p].str);
      assert(0);
    }
    return (word_t)num;
  }
  else if (check_parentheses(p, q) == true) {
    /* The expression is surrounded by a matched pair of parentheses.
     * If that is the case, just throw away the parentheses.
     */
    return eval(p + 1, q - 1);
  } else {
    int i, current_priority, op_pos = -1, priority = 0x3f3f3f3f;
    int val1, val2;

    /* Find the position of dominant operator */
    for (i = p; i <= q; ++i) {
      if (tokens[i].type == '(') {
        int cnt = 1;
        while (cnt && i < q) {
          ++i;
          if (tokens[i].type == '(')
            ++cnt;
          else if (tokens[i].type == ')')
            --cnt;
        }
        if (cnt) {
          printf("ERROR: bad expression %d-%d\n", p, q);
          assert(0);
        }
      }else if(is_bin_op(tokens[i].type) || is_unary_op(tokens[i].type)) {
        current_priority = get_op_level(tokens[i].type);
        if (current_priority <= priority) {
          priority = current_priority;
          op_pos = i;
        }
      }
    }

    if (is_unary_op(tokens[op_pos].type)) {
      /* unary operator */
      assert(op_pos == p);
     switch (tokens[op_pos].type) {
     case TK_DEREF:
        return vaddr_read(eval(op_pos + 1, q), 4);
      case TK_NEG:
        return -eval(op_pos + 1, q);
      case TK_NOT:
        return !eval(op_pos + 1, q);
      default:
        printf("ERROR: invalid operator %d (enum index)\n", tokens[op_pos].type);
        assert(0); // impossible
     } 
    }

    val1 = eval(p, op_pos - 1);
    val2 = eval(op_pos + 1, q);

    switch (tokens[op_pos].type) {
      /* TODO: Possible arithmetic overflows are not handled */
    case '+':
      return val1 + val2;
    case '-':
      return val1 - val2;
    case '*':
      return val1 * val2;
    case '/':
      if (!val2)
        printf("ERROR: division by zero\n"), assert(0);
      return val1 / val2;
    case TK_EQ:
      return val1 == val2;
    case TK_NEQ:
      return val1 != val2;
    case TK_AND:
      return val1 && val2;
    case TK_OR:
      return val1 || val2;
    default: assert(0);
    }
  }
}

/* expr.c 粘一些代表性的，不全粘贴 */ 
WP *new_wp() {
  if (free_ == NULL) {
    printf("No enough watchpoints.\n");
    assert(0);
    return NULL;
  }
  WP *wp = free_;
  free_ = free_->next;
  wp->next = head;
  head = wp;
  return wp;
}

void free_wp(WP *wp) {
  if (wp == NULL) {
    return;
  }
  WP *p = head;
  if (p == wp) {
    head = head->next;
    wp->next = free_;
    free_ = wp;
    return;
  }
  while (p->next != NULL) {
    if (p->next == wp) {
      p->next = wp->next;
      wp->next = free_;
      free_ = wp;
      return;
    }
    p = p->next;
  }
}

/* inst.c 粘一些代表性的，不全粘贴 */ 
INSTPAT_START();
  INSTPAT("0000000 ????? ????? 000 ????? 01100 11", add    , R, R(rd) = (int32_t)((int32_t)src1 + (int32_t)src2));
  INSTPAT("0000001 ????? ????? 000 ????? 01100 11", mul    , R, R(rd) = (int32_t)((int64_t)(int32_t)src1 * (int64_t)(int32_t)src2));
  INSTPAT("0000001 ????? ????? 001 ????? 01100 11", mulh   , R, R(rd) = (int32_t)(((int64_t)(int32_t)src1 * (int64_t)(int32_t)src2) >> 32));
  INSTPAT("0000001 ????? ????? 010 ????? 01100 11", mulhsu , R, R(rd) = ((int64_t)(int32_t)src1 * (uint64_t)(uint32_t)src2) >> 32);
  INSTPAT("0000001 ????? ????? 011 ????? 01100 11", mulhu  , R, R(rd) = (uint32_t)(((uint64_t)(uint32_t)src1 * (uint64_t)(uint32_t)src2) >> 32));
  INSTPAT("0100000 ????? ????? 000 ????? 01100 11", sub    , R, R(rd) = src1 - src2);
  INSTPAT("0000000 ????? ????? 010 ????? 01100 11", slt    , R, R(rd) = (int32_t)src1 < (int32_t)src2);
  INSTPAT("0000000 ????? ????? 011 ????? 01100 11", sltu   , R, R(rd) = (uint32_t)src1 < (uint32_t)src2);
  INSTPAT("0000000 ????? ????? 100 ????? 01100 11", xor    , R, R(rd) = src1 ^ src2);
  INSTPAT("0000001 ????? ????? 100 ????? 01100 11", div    , R, R(rd) = src2 ? (src1 == (1 << 31) && src2 == -1) ? (1 << 31) : (int32_t)((int32_t)src1 / (int32_t)src2) : -1);
  INSTPAT("0000001 ????? ????? 101 ????? 01100 11", divu   , R, R(rd) = src2 ? (uint32_t)((uint32_t)src1 / (uint32_t)src2) : (uint32_t)((1ll << 32) - 1));
  INSTPAT("0000000 ????? ????? 001 ????? 01100 11", sll    , R, R(rd) = (uint32_t)src1 << BITS(src2, 4, 0));
  INSTPAT("0000000 ????? ????? 101 ????? 01100 11", srl    , R, R(rd) = (uint32_t)src1 >> BITS(src2, 4, 0));
  INSTPAT("0100000 ????? ????? 101 ????? 01100 11", sra    , R, R(rd) = (int32_t)src1 >> BITS(src2, 4, 0));
  INSTPAT("0000000 ????? ????? 110 ????? 01100 11", or     , R, R(rd) = src1 | src2);
  INSTPAT("0000001 ????? ????? 110 ????? 01100 11", rem    , R, R(rd) = src2 ? (src1 == (1 << 31) && src2 == -1) ? 0 : (int32_t)src1 % (int32_t)src2 : src1);
  INSTPAT("0000001 ????? ????? 111 ????? 01100 11", remu   , R, R(rd) = src2 ? (uint32_t)src1 % (uint32_t)src2 : src1);
  INSTPAT("0000000 ????? ????? 111 ????? 01100 11", and    , R, R(rd) = src1 & src2);

  INSTPAT("??????? ????? ????? 000 ????? 00000 11", lb     , I, R(rd) = SEXT(Mr((uint32_t)((int32_t)src1 + (int32_t)imm), 1), 8));
  INSTPAT("??????? ????? ????? 001 ????? 00000 11", lh     , I, R(rd) = SEXT(Mr((uint32_t)((int32_t)src1 + (int32_t)imm), 2), 16));
  INSTPAT("??????? ????? ????? 010 ????? 00000 11", lw     , I, R(rd) = SEXT(Mr((uint32_t)((int32_t)src1 + (int32_t)imm), 4), 32));
  INSTPAT("??????? ????? ????? 100 ????? 00000 11", lbu    , I, R(rd) = Mr((uint32_t)((int32_t)src1 + (int32_t)imm), 1));
  INSTPAT("??????? ????? ????? 101 ????? 00000 11", lhu    , I, R(rd) = Mr((uint32_t)((int32_t)src1 + (int32_t)imm), 2));
  INSTPAT("??????? ????? ????? 000 ????? 00100 11", addi   , I, R(rd) = (int32_t)((int32_t)src1 + (int32_t)imm));  // mv
  INSTPAT("??????? ????? ????? 010 ????? 00100 11", slti   , I, R(rd) = (int32_t)src1 < (int32_t)imm);
  INSTPAT("??????? ????? ????? 011 ????? 00100 11", sltiu  , I, R(rd) = (uint32_t)src1 < (uint32_t)imm);
  INSTPAT("??????? ????? ????? 100 ????? 00100 11", xori   , I, R(rd) = src1 ^ imm);
  INSTPAT("000000? ????? ????? 001 ????? 00100 11", slli   , I, R(rd) = (uint32_t)src1 << BITS(imm, 4, 0));
  INSTPAT("000000? ????? ????? 101 ????? 00100 11", srli   , I, R(rd) = (uint32_t)src1 >> BITS(imm, 4, 0));
  INSTPAT("010000? ????? ????? 101 ????? 00100 11", srai   , I, R(rd) = (int32_t)src1 >> BITS(imm, 4, 0));
  INSTPAT("??????? ????? ????? 110 ????? 00100 11", ori    , I, R(rd) = src1 | imm);
  INSTPAT("??????? ????? ????? 111 ????? 00100 11", andi   , I, R(rd) = src1 & imm);
  // INSTPAT("??????? ????? ????? 000 ????? 00011 11", fence  , I, R(rd) = src1 & imm);
  INSTPAT("??????? ????? ????? 000 ????? 11001 11", jalr   , I, R(rd) = s->snpc; s->dnpc = (uint32_t)((int32_t)src1 + (int32_t)imm) & -2ull; check_jalr(rd, imm, s)); // ret

  INSTPAT("??????? ????? ????? 000 ????? 01000 11", sb     , S, Mw((uint32_t)((int32_t)src1 + (int32_t)imm), 1, src2));
  INSTPAT("??????? ????? ????? 001 ????? 01000 11", sh     , S, Mw((uint32_t)((int32_t)src1 + (int32_t)imm), 2, src2));
  INSTPAT("??????? ????? ????? 010 ????? 01000 11", sw     , S, Mw((uint32_t)((int32_t)src1 + (int32_t)imm), 4, src2));

  INSTPAT("??????? ????? ????? 000 ????? 11000 11", beq    , B, s->dnpc = src1 == src2 ? (uint32_t)((int32_t)s->pc + (int32_t)imm) : s->dnpc);
  INSTPAT("??????? ????? ????? 001 ????? 11000 11", bne    , B, s->dnpc = src1 != src2 ? (uint32_t)((int32_t)s->pc + (int32_t)imm) : s->dnpc);
  INSTPAT("??????? ????? ????? 100 ????? 11000 11", blt    , B, s->dnpc = (int32_t)src1 < (int32_t)src2 ? (uint32_t)((int32_t)s->pc + (int32_t)imm) : s->dnpc);
  INSTPAT("??????? ????? ????? 101 ????? 11000 11", bge    , B, s->dnpc = (int32_t)src1 >= (int32_t)src2 ? (uint32_t)((int32_t)s->pc + (int32_t)imm) : s->dnpc);
  INSTPAT("??????? ????? ????? 110 ????? 11000 11", bltu   , B, s->dnpc = (uint32_t)src1 < (uint32_t)src2 ? (uint32_t)((int32_t)s->pc + (int32_t)imm) : s->dnpc);
  INSTPAT("??????? ????? ????? 111 ????? 11000 11", bgeu   , B, s->dnpc = (uint32_t)src1 >= (uint32_t)src2 ? (uint32_t)((int32_t)s->pc + (int32_t)imm) : s->dnpc);

  INSTPAT("??????? ????? ????? ??? ????? 00101 11", auipc  , U, R(rd) = s->pc + imm);
  INSTPAT("??????? ????? ????? ??? ????? 01101 11", lui    , U, R(rd) = imm);

  INSTPAT("??????? ????? ????? ??? ????? 11011 11", jal    , J, R(rd) = s->snpc; s->dnpc = s->pc + imm; check_jal(s));


  INSTPAT("0000000 00001 00000 000 00000 11100 11", ebreak , N, NEMUTRAP(s->pc, R(10))); // R(10) is $a0
  INSTPAT("??????? ????? ????? ??? ????? ????? ??", inv    , N, INV(s->pc));

void check_jal(Decode *s) {
  if (elf_loaded) {
    const char *func_name = find_symbol(s->dnpc);
    if (func_name != NULL) {
        call_depth++;
        log_write("F\t%#010x\t%*sCall to %s @ %#010x\n", s->pc, call_depth * 2, "", func_name, s->dnpc);
    }
  }
}

void check_jalr(word_t rd, word_t imm, Decode *s) {
  uint32_t i = s->isa.inst;
  int rs1 = BITS(i, 19, 15);
  if (elf_loaded) {
    if (rd == 0 && rs1 == 1 && imm == 0) {
        // Function return
        const char *func_name = find_symbol(s->pc);
        if (func_name != NULL) {
            log_write("F\t%#010x\t%*sReturn from %s\n", s->pc, call_depth * 2, "", func_name);
        }
        if (call_depth > 0) call_depth--;
    }
    else {
        // Indirect function call
        const char *func_name = find_symbol(s->dnpc);
        if (func_name != NULL) {
            call_depth++;
            log_write("F\t%#010x\t%*sIndirect call to %s @ %#010x\n", s->pc, call_depth * 2, "", func_name, s->dnpc);
        }
    }
  }
}

/* stdio.c 粘一些代表性的，不全粘贴 */ 

int vsprintf(char *out, const char *fmt, va_list ap) {
    char* buf = out;
    int total_len = 0;

    while (*fmt != '\0') {
        if (*fmt != '%') {
            *buf++ = *fmt++;
            total_len++;
        } else {
            fmt++;
            // Parse flags
            int flags = 0;
            int width = 0;
            int precision = -1;
            // int length = 0;
            int specifier = 0;

            while (*fmt == '-' || *fmt == '+' || *fmt == ' ' || *fmt == '#' || *fmt == '0') {
                switch (*fmt) {
                    case '#': flags |= 0x02; break; // Hash
                    case '+': flags |= 0x04; break; // Plus sign
                    case ' ': flags |= 0x08; break; // Space
                    case '-': flags |= 0x10; break; // Left align
                    case '0': flags |= 0x20; break; // Zero padding
                }
                fmt++;
            }

            // Parse width
            if (*fmt == '*') {
                width = va_arg(ap, int);
                fmt++;
            } else {
                while (*fmt >= '0' && *fmt <= '9') {
                    width = width * 10 + (*fmt++ - '0');
                }
            }

            // Parse precision
            if (*fmt == '.') {
                fmt++;
                precision = 0;
                if (*fmt == '*') {
                    precision = va_arg(ap, int);
                    fmt++;
                } else {
                    while (*fmt >= '0' && *fmt <= '9') {
                        precision = precision * 10 + (*fmt++ - '0');
                    }
                }
            }

            // // Parse length modifier
            // if (*fmt == 'h' || *fmt == 'l') {
            //     length = *fmt++;
            // }

            // Parse specifier
            specifier = *fmt++;

            // Handle specifier
            if (specifier == 'd' || specifier == 'i') {
                int value = va_arg(ap, int);
                char temp[65];
                int len = int_to_str(value, temp, 10, 0, width, precision > 0 ? precision : 0, flags);
                for (int i = 0; i < len; i++) {
                    *buf++ = temp[i];
                }
                total_len += len;
            } else if (specifier == 'o') {
                unsigned int value = va_arg(ap, unsigned int);
                char temp[65];
                int len = int_to_str(value, temp, 8, 1, width, precision > 0 ? precision : 0, flags);
                for (int i = 0; i < len; i++) {
                    *buf++ = temp[i];
                }
                total_len += len;
            } else if (specifier == 'u') {
                unsigned int value = va_arg(ap, unsigned int);
                char temp[65];
                int len = int_to_str(value, temp, 10, 1, width, precision > 0 ? precision : 0, flags);
                for (int i = 0; i < len; i++) {
                    *buf++ = temp[i];
                }
                total_len += len;
            } else if (specifier == 'x' || specifier == 'X') {
                unsigned int value = va_arg(ap, unsigned int);
                char temp[65];
                if (specifier == 'X') flags |= 0x01; // Uppercase
                int len = int_to_str(value, temp, 16, 1, width, precision > 0 ? precision : 0, flags);
                for (int i = 0; i < len; i++) {
                    *buf++ = temp[i];
                }
                total_len += len;
            } else if (specifier == 'c') {
                char c = (char)va_arg(ap, int);
                *buf++ = c;
                total_len++;
            } else if (specifier == 's') {
                char *str = va_arg(ap, char*);
                int len = precision >= 0 ? precision : strlen(str);
                if (width > len && !(flags & 0x10)) { // Right align
                    for (int i = 0; i < width - len; i++) {
                        *buf++ = ' ';
                        total_len++;
                    }
                }
                for (int i = 0; i < len && str[i] != '\0'; i++) {
                    *buf++ = str[i];
                    total_len++;
                }
                if (width > len && (flags & 0x10)) { // Left align
                    for (int i = 0; i < width - len; i++) {
                        *buf++ = ' ';
                        total_len++;
                    }
                }
            } else if (specifier == 'p') {
                void *ptr = va_arg(ap, void*);
                unsigned long value = (unsigned long)ptr;
                char temp[65];
                flags |= 0x02; // Force '0x'
                int len = int_to_str(value, temp, 16, 1, width, precision > 0 ? precision : 0, flags);
                for (int i = 0; i < len; i++) {
                    *buf++ = temp[i];
                }
                total_len += len;
            } else if (specifier == 'f' || specifier == 'F' || specifier == 'e' || specifier == 'E' || specifier == 'g' || specifier == 'G') {
                assert(0);
                // double value = va_arg(args, double);
                // char temp[320];
                // int len = double_to_str(value, temp, precision >= 0 ? precision : 6, specifier, flags, width);
                // for (int i = 0; i < len; i++) {
                //     /*buf++ = temp[i];
                // }
                // total_len += len;
            } else if (specifier == '%') {
                *buf++ = '%';
                total_len++;
            } else if (specifier == 'n') {
                int *ptr = va_arg(ap, int*);
                *ptr = total_len;
            } else {
                // Invalid specifier
                assert(0);
            }
        }
    }

    *buf = '\0';
    return buf - out;
}

int sprintf(char *out, const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    int total_len = vsprintf(out, fmt, args);
    va_end(args);
    return total_len;
}

int snprintf(char *out, size_t n, const char *fmt, ...) {
  panic("Not implemented");
}

int vsnprintf(char *out, size_t n, const char *fmt, va_list ap) {
  panic("Not implemented");
}

static int int_to_str(int value, char *buffer, int base, int is_unsigned, int width, int precision, int flags) {
    char temp[65];
    int i = 0;
    unsigned int uvalue = value;
    int is_negative = 0;

    if (!is_unsigned && value < 0) {
        is_negative = 1;
        uvalue = -value;
    }

    if (uvalue == 0) {
        temp[i++] = '0';
    } else {
        while (uvalue != 0) {
            int digit = uvalue % base;
            if (digit < 10) {
                temp[i++] = digit + '0';
            } else {
                if (flags & 0x01) { // Uppercase for X
                    temp[i++] = digit - 10 + 'A';
                } else {
                    temp[i++] = digit - 10 + 'a';
                }
            }
            uvalue /= base;
        }
    }

    // Handle precision
    while (i < precision) {
        temp[i++] = '0';
    }

    // Add prefix for '#' flag
    if (flags & 0x02) {
        if (base == 8 && temp[i-1] != '0') {
            temp[i++] = '0';
        } else if (base == 16) {
            temp[i++] = flags & 0x01 ? 'X' : 'x';
            temp[i++] = '0';
        }
        else {
          assert(0);
        }
    }

    int len = i;
    // Handle zero-padding and width
    int padding = width - len - 1; // 1-width for the sign

    if (padding > 0 && (flags & 0x20) && !(flags & 0x10)) { // Right align
      while (padding-- > 0) {
          temp[i++] = '0';
      }
    }

    if (is_negative) {
        temp[i++] = '-';
    } else if (flags & 0x04) { // '+' flag
        temp[i++] = '+';
    } else if (flags & 0x08) { // ' ' flag
        temp[i++] = ' ';
    }

    if (padding > 0 && !(flags & 0x20) && !(flags & 0x10)) { // Right align
      while (padding-- > 0) {
          temp[i++] = ' ';
      }
    }

    reverse_str(temp, i);

    // Copy to buffer
    for (int j = 0; j < i; j++) {
        *buffer++ = temp[j];
    }

    // Right padding if left align
    if (padding > 0 && (flags & 0x10)) {
        while (padding-- > 0) {
            *buffer++ = ' ';
        }
    }

    return i;
}