Rename I-cache related definitions

Adjust instruction cache related defines and identifiers:
- Rename IC/ic prefix to ICACHE/icache
- Rename VC/vc prefix to VCACHE/vcache

Author: yy214123

riscv.c

@@ -181,9 +181,9 @@ 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)
+static inline void icache_invalidate_all(hart_t *vm)
 {
-    memset(&vm->ic, 0, sizeof(vm->ic));
+    memset(&vm->icache, 0, sizeof(vm->icache));
 }
 
 /* virtual addressing */
@@ -204,7 +204,7 @@ void mmu_invalidate(hart_t *vm)
             vm->cache_store[set].ways[way].n_pages = 0xFFFFFFFF;
         vm->cache_store[set].lru = 0; /* Reset LRU to way 0 */
     }
-    ic_invalidate_all(vm);
+    icache_invalidate_all(vm);
 }
 
 /* Invalidate MMU caches for a specific virtual address range.
@@ -370,29 +370,29 @@ static void mmu_fence(hart_t *vm, uint32_t insn UNUSED)
 static void mmu_fetch(hart_t *vm, uint32_t addr, uint32_t *value)
 {
     /* cache hit */
-    uint32_t idx = (addr >> IC_OFFSET_BITS) & IC_INDEX_MASK;
-    uint32_t tag = addr >> (IC_OFFSET_BITS + IC_INDEX_BITS);
-    icache_block_t *blk = &vm->ic.i_block[idx];
+    uint32_t idx = (addr >> ICACHE_OFFSET_BITS) & ICACHE_INDEX_MASK;
+    uint32_t tag = addr >> (ICACHE_OFFSET_BITS + ICACHE_INDEX_BITS);
+    icache_block_t *blk = &vm->icache.i_block[idx];
 
     if (likely(blk->valid && blk->tag == tag)) {
 #ifdef MMU_CACHE_STATS
         vm->cache_fetch.hits++;
 #endif
-        uint32_t ofs = addr & IC_BLOCK_MASK;
+        uint32_t ofs = addr & ICACHE_BLOCK_MASK;
         *value = *(const uint32_t *) (blk->base + ofs);
         return;
     }
 
     /* search the victim cache */
-    for (int i = 0; i < VC_BLOCKS; i++) {
-        victim_cache_block_t *vblk = &vm->ic.v_block[i];
+    for (int i = 0; i < VCACHE_BLOCKS; i++) {
+        victim_cache_block_t *vblk = &vm->icache.v_block[i];
         if (vblk->valid && vblk->tag == tag) {
             /* victim cache hit, block swap*/
             icache_block_t tmp = *blk;
             *blk = *vblk;
             *vblk = tmp;
 
-            uint32_t ofs = addr & IC_BLOCK_MASK;
+            uint32_t ofs = addr & ICACHE_BLOCK_MASK;
             *value = *(const uint32_t *) (blk->base + ofs);
             return;
         }
@@ -422,7 +422,7 @@ static void mmu_fetch(hart_t *vm, uint32_t addr, uint32_t *value)
         vm->cache_fetch[index].page_addr[(addr >> 2) & MASK(RV_PAGE_SHIFT - 2)];
 
     /* fill into the cache */
-    uint32_t block_off = (addr & RV_PAGE_MASK) & ~IC_BLOCK_MASK;
+    uint32_t block_off = (addr & RV_PAGE_MASK) & ~ICACHE_BLOCK_MASK;
     blk->base = (const uint8_t *) vm->cache_fetch[index].page_addr + block_off;
     blk->tag = tag;
     blk->valid = true;

riscv.h

@@ -86,10 +86,10 @@ typedef struct __vm_internel vm_t;
  * x. Therefore, we use __builtin_ctz(x) (count trailing zeros) to compute these
  * log2 values at compile time.
  */
-#define IC_BLOCKS_SIZE 256
-#define IC_BLOCKS 256
-#define IC_OFFSET_BITS (__builtin_ctz((IC_BLOCKS_SIZE)))
-#define IC_INDEX_BITS (__builtin_ctz((IC_BLOCKS)))
+#define ICACHE_BLOCKS_SIZE 256
+#define ICACHE_BLOCKS 256
+#define ICACHE_OFFSET_BITS (__builtin_ctz((ICACHE_BLOCKS_SIZE)))
+#define ICACHE_INDEX_BITS (__builtin_ctz((ICACHE_BLOCKS)))
 
 /* Define the victim cache.
  *
@@ -98,14 +98,14 @@ typedef struct __vm_internel vm_t;
  * However, the number of blocks is smaller, allowing the VC to store
  * a few recently evicted cache lines to reduce conflict misses.
  */
-#define VC_BLOCK_SIZE IC_BLOCKS_SIZE
-#define VC_BLOCKS 16
+#define VCACHE_BLOCK_SIZE VCACHE_BLOCKS_SIZE
+#define VCACHE_BLOCKS 16
 
 /* For power-of-two sizes, (size - 1) sets all low bits to 1,
  * allowing fast extraction of an address.
  */
-#define IC_INDEX_MASK (IC_BLOCKS - 1)
-#define IC_BLOCK_MASK (IC_BLOCKS_SIZE - 1)
+#define ICACHE_INDEX_MASK (ICACHE_BLOCKS - 1)
+#define ICACHE_BLOCK_MASK (ICACHE_BLOCKS_SIZE - 1)
 #define RV_PAGE_MASK (RV_PAGE_SIZE - 1)
 
 typedef struct {
@@ -117,12 +117,12 @@ typedef struct {
 typedef icache_block_t victim_cache_block_t;
 
 typedef struct {
-    icache_block_t i_block[IC_BLOCKS];
-    victim_cache_block_t v_block[VC_BLOCKS];
+    icache_block_t i_block[ICACHE_BLOCKS];
+    victim_cache_block_t v_block[VCACHE_BLOCKS];
 } icache_t;
 
 struct __hart_internal {
-    icache_t ic;
+    icache_t icache;
     uint32_t x_regs[32];
 
     /* LR reservation virtual address. last bit is 1 if valid */