Implement direct mapped cache for instruction fetch

Extend the existing architecture to cache the last fetched PC instruction,
improving instruction fetch hit rate by approximately 2%.

Also includes clang-format fixes for several expressions.

Author: yy214123

riscv.c

@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <string.h>
 
 #include "common.h"
 #include "device.h"
@@ -180,6 +181,11 @@ static inline uint32_t read_rs2(const hart_t *vm, uint32_t insn)
     return vm->x_regs[decode_rs2(insn)];
 }
 
+static inline void ic_invalidate_all(hart_t *vm)
+{
+    memset(&vm->ic, 0, sizeof(vm->ic));
+}
+
 /* virtual addressing */
 
 void mmu_invalidate(hart_t *vm)
@@ -188,6 +194,7 @@ void mmu_invalidate(hart_t *vm)
     vm->cache_load[0].n_pages = 0xFFFFFFFF;
     vm->cache_load[1].n_pages = 0xFFFFFFFF;
     vm->cache_store.n_pages = 0xFFFFFFFF;
+    ic_invalidate_all(vm);
 }
 
 /* Pre-verify the root page table to minimize page table access during
@@ -301,11 +308,27 @@ static void mmu_fence(hart_t *vm, uint32_t insn UNUSED)
 
 static void mmu_fetch(hart_t *vm, uint32_t addr, uint32_t *value)
 {
-    uint32_t vpn = addr >> RV_PAGE_SHIFT;
-    if (unlikely(vpn != vm->cache_fetch.n_pages)) {
+    /* cache hit */
+    uint32_t idx = (addr >> IC_SHIFT) & IC_INDEX_MASK;
+    uint32_t tag = addr >> (IC_SHIFT + IC_INDEX_BITS);
+    ic_block_t *blk = &vm->ic.block[idx];
+
+    if (likely(blk->valid && blk->tag == tag)) {
 #ifdef MMU_CACHE_STATS
-        vm->cache_fetch.misses++;
+        vm->cache_fetch.hits++;
 #endif
+        uint32_t ofs = addr & IC_BLOCK_MASK;
+        *value = *(const uint32_t *) (blk->base + ofs);
+        return;
+    }
+
+#ifdef MMU_CACHE_STATS
+    vm->cache_fetch.misses++;
+#endif
+
+    /* cache miss, Continue using the original va->pa*/
+    uint32_t vpn = addr >> RV_PAGE_SHIFT;
+    if (unlikely(vpn != vm->cache_fetch.n_pages)) {
         mmu_translate(vm, &addr, (1 << 3), (1 << 6), false, RV_EXC_FETCH_FAULT,
                       RV_EXC_FETCH_PFAULT);
         if (vm->error)
@@ -317,12 +340,14 @@ static void mmu_fetch(hart_t *vm, uint32_t addr, uint32_t *value)
         vm->cache_fetch.n_pages = vpn;
         vm->cache_fetch.page_addr = page_addr;
     }
-#ifdef MMU_CACHE_STATS
-    else {
-        vm->cache_fetch.hits++;
-    }
-#endif
+
     *value = vm->cache_fetch.page_addr[(addr >> 2) & MASK(RV_PAGE_SHIFT - 2)];
+
+    /* fill into the cache */
+    uint32_t block_off = (addr & RV_PAGE_MASK) & ~IC_BLOCK_MASK;
+    blk->base = (const uint8_t *) vm->cache_fetch.page_addr + block_off;
+    blk->tag = addr >> (IC_SHIFT + IC_INDEX_BITS);
+    blk->valid = true;
 }
 
 static void mmu_load(hart_t *vm,

riscv.h

@@ -69,7 +69,26 @@ typedef struct {
 typedef struct __hart_internal hart_t;
 typedef struct __vm_internel vm_t;
 
+#define IC_BLOCKS_SIZE 256
+#define IC_BLOCKS 256
+#define IC_SHIFT (__builtin_ctz((IC_BLOCKS_SIZE)))
+#define IC_INDEX_BITS (__builtin_ctz((IC_BLOCKS)))
+#define IC_INDEX_MASK (IC_BLOCKS - 1)
+#define IC_BLOCK_MASK (IC_BLOCKS_SIZE - 1)
+#define RV_PAGE_MASK (RV_PAGE_SIZE - 1)
+
+typedef struct {
+    uint32_t tag;
+    const uint8_t *base;
+    bool valid;
+} ic_block_t;
+
+typedef struct {
+    ic_block_t block[IC_BLOCKS];
+} ic_t;
+
 struct __hart_internal {
+    ic_t ic;
     uint32_t x_regs[32];
 
     /* LR reservation virtual address. last bit is 1 if valid */