Move block and IRs memory pool to rv

src/emulate.c

@@ -289,17 +289,13 @@ static inline uint32_t hash(size_t k)
     return k;
 }
 
-static void block_translate(riscv_t *rv, block_map_t *map, block_t *block);
 /* allocate a basic block */
-static block_t *block_alloc(riscv_t *rv, block_map_t *map)
+static block_t *block_alloc(riscv_t *rv)
 {
-    block_t *block = mpool_alloc(map->block_mp);
+    block_t *block = mpool_alloc(rv->block_mp);
     assert(block);
     block->n_insn = 0;
     block->predict = NULL;
-
-    /* Initialize remaining part of block_t */
-    block_translate(rv, map, block);
     return block;
 }
 
@@ -608,12 +604,12 @@ FORCE_INLINE bool insn_is_unconditional_branch(uint8_t opcode)
     return false;
 }
 
-static void block_translate(riscv_t *rv, block_map_t *map, block_t *block)
+static void block_translate(riscv_t *rv, block_t *block)
 {
     block->pc_start = block->pc_end = rv->PC;
 
     rv_insn_t *prev_ir = NULL;
-    rv_insn_t *ir = mpool_alloc(map->block_ir_mp);
+    rv_insn_t *ir = mpool_alloc(rv->block_ir_mp);
     block->ir_head = ir;
 
     /* translate the basic block */
@@ -642,7 +638,7 @@ static void block_translate(riscv_t *rv, block_map_t *map, block_t *block)
         if (insn_is_branch(ir->opcode))
             break;
 
-        ir = mpool_alloc(map->block_ir_mp);
+        ir = mpool_alloc(rv->block_ir_mp);
     }
 
     assert(prev_ir);
@@ -725,7 +721,7 @@ FORCE_INLINE void remove_next_nth_ir(riscv_t *rv,
     for (uint8_t i = 0; i < n; i++) {
         rv_insn_t *next = ir->next;
         ir->next = ir->next->next;
-        mpool_free(rv->block_map.block_ir_mp, next);
+        mpool_free(rv->block_ir_mp, next);
     }
     if (!ir->next) {
         block->ir_tail = ir;
@@ -949,12 +945,13 @@ static block_t *block_find_or_translate(riscv_t *rv)
 
     if (!next) {
         if (map->size * 1.25 > map->block_capacity) {
-            block_map_clear(map);
+            block_map_clear(rv);
             prev = NULL;
         }
 
         /* allocate a new block */
-        next = block_alloc(rv, map);
+        next = block_alloc(rv);
+        block_translate(rv, next);
 
         if (!libc_substitute(rv, next)) {
             optimize_constant(rv, next);

src/riscv.c

@@ -20,17 +20,12 @@ static void block_map_init(block_map_t *map, const uint8_t bits)
     map->block_capacity = 1 << bits;
     map->size = 0;
     map->map = calloc(map->block_capacity, sizeof(struct block *));
-
-    map->block_mp = mpool_create(sizeof(block_t) << BLOCK_MAP_CAPACITY_BITS,
-                                 sizeof(block_t));
-    map->block_ir_mp = mpool_create(
-        sizeof(rv_insn_t) << BLOCK_IR_MAP_CAPACITY_BITS, sizeof(rv_insn_t));
 }
 
 /* clear all block in the block map */
-void block_map_clear(block_map_t *map)
+void block_map_clear(riscv_t *rv)
 {
-    assert(map);
+    block_map_t *map = &rv->block_map;
     for (uint32_t i = 0; i < map->block_capacity; i++) {
         block_t *block = map->map[i];
         if (!block)
@@ -41,21 +36,21 @@ void block_map_clear(block_map_t *map)
              idx++, ir = next) {
             free(ir->fuse);
             next = ir->next;
-            mpool_free(map->block_ir_mp, ir);
+            mpool_free(rv->block_ir_mp, ir);
         }
-        mpool_free(map->block_mp, block);
+        mpool_free(rv->block_mp, block);
         map->map[i] = NULL;
     }
     map->size = 0;
 }
 
-static void block_map_destroy(block_map_t *map)
+static void block_map_destroy(riscv_t *rv)
 {
-    block_map_clear(map);
-    free(map->map);
+    block_map_clear(rv);
+    free(rv->block_map.map);
 
-    mpool_destroy(map->block_mp);
-    mpool_destroy(map->block_ir_mp);
+    mpool_destroy(rv->block_mp);
+    mpool_destroy(rv->block_ir_mp);
 }
 
 riscv_user_t rv_userdata(riscv_t *rv)
@@ -118,6 +113,12 @@ riscv_t *rv_create(const riscv_io_t *io,
 
     rv->output_exit_code = output_exit_code;
 
+    /* create block and IRs memory pool */
+    rv->block_mp = mpool_create(sizeof(block_t) << BLOCK_MAP_CAPACITY_BITS,
+                                sizeof(block_t));
+    rv->block_ir_mp = mpool_create(
+        sizeof(rv_insn_t) << BLOCK_IR_MAP_CAPACITY_BITS, sizeof(rv_insn_t));
+
     /* initialize the block map */
     block_map_init(&rv->block_map, 10);
 
@@ -145,7 +146,7 @@ bool rv_enables_to_output_exit_code(riscv_t *rv)
 void rv_delete(riscv_t *rv)
 {
     assert(rv);
-    block_map_destroy(&rv->block_map);
+    block_map_destroy(rv);
     free(rv);
 }
 

src/riscv_private.h

@@ -65,12 +65,10 @@ typedef struct {
     uint32_t block_capacity; /**< max number of entries in the block map */
     uint32_t size;           /**< number of entries currently in the map */
     block_t **map;           /**< block map */
-
-    struct mpool *block_mp, *block_ir_mp;
 } block_map_t;
 
 /* clear all block in the block map */
-void block_map_clear(block_map_t *map);
+void block_map_clear(riscv_t *rv);
 
 struct riscv_internal {
     bool halt; /* indicate whether the core is halted */
@@ -123,7 +121,7 @@ struct riscv_internal {
 
     bool compressed;       /**< current instruction is compressed or not */
     block_map_t block_map; /**< basic block map */
-
+    struct mpool *block_mp, *block_ir_mp;
     /* print exit code on syscall_exit */
     bool output_exit_code;
 };