Refactor local variable storage

Author: ChAoSUnItY

src/defs.h

@@ -279,6 +279,12 @@ typedef struct use_chain_node {
 typedef struct var var_t;
 typedef struct type type_t;
 
+typedef struct var_list {
+    int capacity;
+    int size;
+    var_t **elements;
+} var_list_t;
+
 struct var {
     char type_name[MAX_TYPE_LEN];
     type_t *type;
@@ -321,21 +327,14 @@ typedef struct func func_t;
 
 /* block definition */
 struct block {
-    var_t locals[MAX_LOCALS];
-    int next_local;
+    var_list_t locals;
     struct block *parent;
     func_t *func;
     macro_t *macro;
     struct block *next;
 };
 
 typedef struct block block_t;
-
-typedef struct {
-    block_t *head;
-    block_t *tail;
-} block_list_t;
-
 typedef struct basic_block basic_block_t;
 
 /* Definition of a growable buffer for a mutable null-terminated string

src/globals.c

@@ -28,8 +28,6 @@ int macro_return_idx;
 
 /* Global objects */
 
-block_list_t BLOCKS;
-
 macro_t *MACROS;
 int macros_idx = 0;
 
@@ -46,6 +44,9 @@ int types_idx = 0;
 
 arena_t *INSN_ARENA;
 
+/* BLOCK_ARENA is responsible for block_t / var_t allocation */
+arena_t *BLOCK_ARENA;
+
 /* BB_ARENA is responsible for basic_block_t / ph2_ir_t allocation */
 arena_t *BB_ARENA;
 
@@ -56,6 +57,7 @@ int ph2_ir_idx = 0;
 
 func_list_t FUNC_LIST;
 func_t *GLOBAL_FUNC;
+block_t *GLOBAL_BLOCK;
 basic_block_t *MAIN_BB;
 int elf_offset = 0;
 
@@ -499,20 +501,14 @@ void set_var_liveout(var_t *var, int end)
 
 block_t *add_block(block_t *parent, func_t *func, macro_t *macro)
 {
-    block_t *blk = malloc(sizeof(block_t));
-
-    if (!BLOCKS.head) {
-        BLOCKS.head = blk;
-        BLOCKS.tail = BLOCKS.head;
-    } else {
-        BLOCKS.tail->next = blk;
-        BLOCKS.tail = blk;
-    }
+    block_t *blk = arena_alloc(BLOCK_ARENA, sizeof(block_t));
 
     blk->parent = parent;
     blk->func = func;
     blk->macro = macro;
-    blk->next_local = 0;
+    blk->locals.capacity = 16;
+    blk->locals.elements =
+        arena_alloc(BLOCK_ARENA, blk->locals.capacity * sizeof(var_t *));
     return blk;
 }
 
@@ -645,9 +641,10 @@ var_t *find_local_var(char *token, block_t *block)
     func_t *func = block->func;
 
     for (; block; block = block->parent) {
-        for (int i = 0; i < block->next_local; i++) {
-            if (!strcmp(block->locals[i].var_name, token))
-                return &block->locals[i];
+        var_list_t *var_list = &block->locals;
+        for (int i = 0; i < var_list->size; i++) {
+            if (!strcmp(var_list->elements[i]->var_name, token))
+                return var_list->elements[i];
         }
     }
 
@@ -662,11 +659,11 @@ var_t *find_local_var(char *token, block_t *block)
 
 var_t *find_global_var(char *token)
 {
-    block_t *block = BLOCKS.head;
+    var_list_t *var_list = &GLOBAL_BLOCK->locals;
 
-    for (int i = 0; i < block->next_local; i++) {
-        if (!strcmp(block->locals[i].var_name, token))
-            return &block->locals[i];
+    for (int i = 0; i < var_list->size; i++) {
+        if (!strcmp(var_list->elements[i]->var_name, token))
+            return var_list->elements[i];
     }
     return NULL;
 }
@@ -970,16 +967,14 @@ void global_init()
 {
     elf_code_start = ELF_START + elf_header_len;
 
-    BLOCKS.head = NULL;
-    BLOCKS.tail = NULL;
-
     MACROS = malloc(MAX_ALIASES * sizeof(macro_t));
-    FUNC_MAP = hashmap_create(DEFAULT_FUNCS_SIZE);
     TYPES = malloc(MAX_TYPES * sizeof(type_t));
+    BLOCK_ARENA = arena_init(DEFAULT_ARENA_SIZE);
     INSN_ARENA = arena_init(DEFAULT_ARENA_SIZE);
     BB_ARENA = arena_init(DEFAULT_ARENA_SIZE);
     PH2_IR_FLATTEN = malloc(MAX_IR_INSTR * sizeof(ph2_ir_t *));
     SOURCE = strbuf_create(MAX_SOURCE);
+    FUNC_MAP = hashmap_create(DEFAULT_FUNCS_SIZE);
     INCLUSION_MAP = hashmap_create(DEFAULT_INCLUSIONS_SIZE);
     ALIASES_MAP = hashmap_create(MAX_ALIASES);
     CONSTANTS_MAP = hashmap_create(MAX_CONSTANTS);
@@ -994,19 +989,14 @@ void global_init()
 
 void global_release()
 {
-    while (BLOCKS.head) {
-        block_t *next = BLOCKS.head->next;
-        printf("%d\n", BLOCKS.head->next_local);
-        free(BLOCKS.head);
-        BLOCKS.head = next;
-    }
     free(MACROS);
-    hashmap_free(FUNC_MAP);
     free(TYPES);
+    arena_free(BLOCK_ARENA);
     arena_free(INSN_ARENA);
     arena_free(BB_ARENA);
     free(PH2_IR_FLATTEN);
     strbuf_free(SOURCE);
+    hashmap_free(FUNC_MAP);
     hashmap_free(INCLUSION_MAP);
     hashmap_free(ALIASES_MAP);
     hashmap_free(CONSTANTS_MAP);

src/parser.c

@@ -38,26 +38,30 @@ char *gen_name_to(char *buf)
 
 var_t *require_var(block_t *blk)
 {
-    if (blk->next_local >= MAX_LOCALS)
-        error("Too many locals");
+    var_list_t *var_list = &blk->locals;
 
-    var_t *var = &blk->locals[blk->next_local++];
+    if (var_list->size >= var_list->capacity) {
+        var_list->capacity *= 2;
+
+        var_t **new_locals = calloc(var_list->capacity, sizeof(var_t *));
+        memcpy(new_locals, var_list->elements,
+               var_list->size * sizeof(var_t *));
+        var_list->elements = new_locals;
+    }
+
+    var_t *var = arena_alloc(BLOCK_ARENA, sizeof(var_t));
+    var_list->elements[var_list->size++] = var;
     var->consumed = -1;
     var->base = var;
     return var;
 }
 
 var_t *require_var_t(block_t *blk, type_t *type)
 {
-    if (blk->next_local >= MAX_LOCALS)
-        error("Too many locals");
-
     if (!type)
         error("Type must not be NULL");
-    
-    var_t *var = &blk->locals[blk->next_local++];
-    var->consumed = -1;
-    var->base = var;
+
+    var_t *var = require_var(blk);
     var->type = type;
     return var;
 }
@@ -1924,7 +1928,7 @@ void eval_ternary_imm(int cond, char *token)
 bool read_global_assignment(char *token)
 {
     var_t *vd, *rs1, *var;
-    block_t *parent = BLOCKS.head;
+    block_t *parent = GLOBAL_BLOCK;
 
     /* global initialization must be constant */
     var = find_global_var(token);
@@ -2648,7 +2652,7 @@ void read_global_decl(block_t *block)
         /* function */
         func_t *func = add_func(var->var_name, false);
         memcpy(&func->return_def, var, sizeof(var_t));
-        block->next_local--;
+        block->locals.size--;
 
         read_parameter_list_decl(func, 0);
 
@@ -2684,7 +2688,7 @@ void read_global_decl(block_t *block)
 void read_global_statement()
 {
     char token[MAX_ID_LEN];
-    block_t *block = BLOCKS.head; /* global block */
+    block_t *block = GLOBAL_BLOCK; /* global block */
 
     if (lex_accept(T_struct)) {
         int i = 0, size = 0;
@@ -2827,8 +2831,8 @@ void parse_internal()
     type->base_type = TYPE_char;
     type->size = 1;
 
-    add_block(NULL, NULL, NULL); /* global block */
-    elf_add_symbol("", 0);       /* undef symbol */
+    GLOBAL_BLOCK = add_block(NULL, NULL, NULL); /* global block */
+    elf_add_symbol("", 0);                      /* undef symbol */
 
     /* architecture defines */
     add_alias(ARCH_PREDEFINED, "1");

src/ssa.c

@@ -566,9 +566,8 @@ bool var_check_in_scope(var_t *var, block_t *block)
     func_t *func = block->func;
 
     while (block) {
-        for (int i = 0; i < block->next_local; i++) {
-            var_t *locals = block->locals;
-            if (var == &locals[i])
+        for (int i = 0; i < block->locals.capacity; i++) {
+            if (var == block->locals.elements[i])
                 return true;
         }
         block = block->parent;