Implement const qualifier for global variables

This extends existing .rodata section support to handle const-qualified
globals. Now, const initialized variables are placed in read-only memory
section instead of writable .data section.

Add const pointer type support for function param

- Parse const qualifiers in function parameter declarations
- Fix operator precedence for pointer dereference expressions (*a + *b)
- Add safety checks for SSA subscript access to prevent crashes
- Fix ARM codegen to properly set stack frame size in return insts
- Add comprehensive test coverage with 15 const pointer test cases

This enables functions to accept const-qualified pointer parameters
(e.g., const int *ptr) following C standard semantics.

Improve const qualifier support

- Updated function parameters to use const where appropriate
- Modified hashmap functions to accept const char* keys
- Fixed string interning to handle const strings properly
- Added const to arena_strdup and arena_memdup functions
- Updated ELF generation functions to use const parameters

Author: jserv

src/defs.h

@@ -179,6 +179,7 @@ typedef enum {
     T_break,
     T_default,
     T_continue,
+    T_const, /* const qualifier */
     /* C pre-processor directives */
     T_cppd_include,
     T_cppd_define,
@@ -353,8 +354,9 @@ struct var {
     int ptr_level;
     bool is_func;
     bool is_global;
-    bool is_initialized; /* true if global variable has initialization */
-    bool address_taken;  /* true if variable address was taken (&var) */
+    bool is_initialized;     /* true if global variable has initialization */
+    bool is_const_qualified; /* true if variable has const qualifier */
+    bool address_taken;      /* true if variable address was taken (&var) */
     int array_size;
     int array_dim1, array_dim2; /* first/second dimension size for 2D arrays */
     int offset;   /* offset from stack or frame, index 0 is reserved */

src/elf.c

@@ -13,7 +13,7 @@
 
 int elf_symbol_index;
 
-void elf_write_str(strbuf_t *elf_array, char *vals)
+void elf_write_str(strbuf_t *elf_array, const char *vals)
 {
     /*
      * Note that strbuf_puts() does not push the null character.
@@ -391,7 +391,7 @@ void elf_align(void)
         elf_write_byte(elf_strtab, 0);
 }
 
-void elf_add_symbol(char *symbol, int pc)
+void elf_add_symbol(const char *symbol, int pc)
 {
     /* Check for null pointers to prevent crashes */
     if (!symbol || !elf_symtab || !elf_strtab) {
@@ -409,7 +409,7 @@ void elf_add_symbol(char *symbol, int pc)
     elf_symbol_index++;
 }
 
-void elf_generate(char *outfile)
+void elf_generate(const char *outfile)
 {
     elf_align();
     elf_generate_header();

src/globals.c

@@ -14,7 +14,7 @@
 #include "defs.h"
 
 /* Forward declaration for string interning */
-char *intern_string(char *str);
+char *intern_string(const char *str);
 
 /* Lexer */
 char token_str[MAX_TOKEN_LEN];
@@ -285,7 +285,7 @@ void *arena_realloc(arena_t *arena, char *oldptr, int oldsz, int newsz)
  *
  * Return: Pointer to the duplicated string stored in the arena.
  */
-char *arena_strdup(arena_t *arena, char *str)
+char *arena_strdup(arena_t *arena, const char *str)
 {
     int n = strlen(str);
     char *dup = arena_alloc(arena, n + 1);
@@ -303,7 +303,7 @@ char *arena_strdup(arena_t *arena, char *str)
  *
  * Return: The pointer to the duplicated memory stored in the arena.
  */
-void *arena_memdup(arena_t *arena, void *data, int size)
+void *arena_memdup(arena_t *arena, const void *data, int size)
 {
     return memcpy(arena_alloc(arena, size), data, size);
 }
@@ -371,7 +371,7 @@ void arena_free(arena_t *arena)
  *
  * Return: The usable hashmap index.
  */
-int hashmap_hash_index(int size, char *key)
+int hashmap_hash_index(int size, const char *key)
 {
     int hash = 0x811c9dc5, mask;
 
@@ -431,7 +431,7 @@ hashmap_t *hashmap_create(int cap)
  *
  * Return: The pointer of created node.
  */
-hashmap_node_t *hashmap_node_new(char *key, void *val)
+hashmap_node_t *hashmap_node_new(const char *key, void *val)
 {
     if (!key)
         return NULL;
@@ -506,7 +506,7 @@ void hashmap_rehash(hashmap_t *map)
  * @val: The value pointer. May be NULL. This value's lifetime is held by
  * hashmap.
  */
-void hashmap_put(hashmap_t *map, char *key, void *val)
+void hashmap_put(hashmap_t *map, const char *key, void *val)
 {
     if (!map)
         return;
@@ -536,7 +536,7 @@ void hashmap_put(hashmap_t *map, char *key, void *val)
  * Return: The look up result, if the key-value pair entry exists, then returns
  * address of itself, NULL otherwise.
  */
-hashmap_node_t *hashmap_get_node(hashmap_t *map, char *key)
+hashmap_node_t *hashmap_get_node(hashmap_t *map, const char *key)
 {
     if (!map)
         return NULL;
@@ -557,7 +557,7 @@ hashmap_node_t *hashmap_get_node(hashmap_t *map, char *key)
  * Return: The look up result, if the key-value pair entry exists, then returns
  * its value's address, NULL otherwise.
  */
-void *hashmap_get(hashmap_t *map, char *key)
+void *hashmap_get(hashmap_t *map, const char *key)
 {
     hashmap_node_t *node = hashmap_get_node(map, key);
     return node ? node->val : NULL;
@@ -570,7 +570,7 @@ void *hashmap_get(hashmap_t *map, char *key)
  * Return: The look up result, if the key-value pair entry exists, then returns
  * true, false otherwise.
  */
-bool hashmap_contains(hashmap_t *map, char *key)
+bool hashmap_contains(hashmap_t *map, const char *key)
 {
     return hashmap_get_node(map, key);
 }
@@ -601,7 +601,7 @@ bool hard_mul_div = false;
  *
  * Return: The pointer to the type, or NULL if not found.
  */
-type_t *find_type(char *type_name, int flag)
+type_t *find_type(const char *type_name, int flag)
 {
     for (int i = 0; i < types_idx; i++) {
         if (TYPES[i].base_type == TYPE_struct ||
@@ -672,7 +672,7 @@ block_t *add_block(block_t *parent, func_t *func, macro_t *macro)
     return blk;
 }
 
-void add_alias(char *alias, char *value)
+void add_alias(const char *alias, const char *value)
 {
     alias_t *al = hashmap_get(ALIASES_MAP, alias);
     if (!al) {
@@ -689,15 +689,15 @@ void add_alias(char *alias, char *value)
     al->disabled = false;
 }
 
-char *find_alias(char alias[])
+char *find_alias(const char alias[])
 {
     alias_t *al = hashmap_get(ALIASES_MAP, alias);
     if (al && !al->disabled)
         return al->value;
     return NULL;
 }
 
-bool remove_alias(char *alias)
+bool remove_alias(const char *alias)
 {
     alias_t *al = hashmap_get(ALIASES_MAP, alias);
     if (al && !al->disabled) {
@@ -724,15 +724,15 @@ macro_t *add_macro(char *name)
     return ma;
 }
 
-macro_t *find_macro(char *name)
+macro_t *find_macro(const char *name)
 {
     macro_t *ma = hashmap_get(MACROS_MAP, name);
     if (ma && !ma->disabled)
         return ma;
     return NULL;
 }
 
-bool remove_macro(char *name)
+bool remove_macro(const char *name)
 {
     macro_t *ma = hashmap_get(MACROS_MAP, name);
     if (ma) {
@@ -749,7 +749,7 @@ string_pool_t *string_pool;
 string_literal_pool_t *string_literal_pool;
 
 /* Safe string interning that works with self-hosting */
-char *intern_string(char *str)
+char *intern_string(const char *str)
 {
     char *existing;
     char *interned;
@@ -761,7 +761,7 @@ char *intern_string(char *str)
 
     /* Safety: can't intern before initialization */
     if (!GENERAL_ARENA || !string_pool)
-        return str;
+        return (char *) str;
 
     /* Check if already interned */
     existing = hashmap_get(string_pool->strings, str);
@@ -778,7 +778,7 @@ char *intern_string(char *str)
     return interned;
 }
 
-int find_macro_param_src_idx(char *name, block_t *parent)
+int find_macro_param_src_idx(const char *name, block_t *parent)
 {
     macro_t *macro = parent->macro;
 
@@ -811,7 +811,7 @@ type_t *add_named_type(char *name)
     return type;
 }
 
-void add_constant(char alias[], int value)
+void add_constant(const char alias[], int value)
 {
     constant_t *constant = arena_alloc_constant();
     if (!constant) {
@@ -825,12 +825,12 @@ void add_constant(char alias[], int value)
     hashmap_put(CONSTANTS_MAP, alias, constant);
 }
 
-constant_t *find_constant(char alias[])
+constant_t *find_constant(const char alias[])
 {
     return hashmap_get(CONSTANTS_MAP, alias);
 }
 
-var_t *find_member(char token[], type_t *type)
+var_t *find_member(const char token[], type_t *type)
 {
     /* If it is a forwardly declared alias of a structure, switch to the base
      * structure type.
@@ -845,7 +845,7 @@ var_t *find_member(char token[], type_t *type)
     return NULL;
 }
 
-var_t *find_local_var(char *token, block_t *block)
+var_t *find_local_var(const char *token, block_t *block)
 {
     func_t *func = block->func;
 
@@ -866,7 +866,7 @@ var_t *find_local_var(char *token, block_t *block)
     return NULL;
 }
 
-var_t *find_global_var(char *token)
+var_t *find_global_var(const char *token)
 {
     var_list_t *var_list = &GLOBAL_BLOCK->locals;
 
@@ -877,7 +877,7 @@ var_t *find_global_var(char *token)
     return NULL;
 }
 
-var_t *find_var(char *token, block_t *parent)
+var_t *find_var(const char *token, block_t *parent)
 {
     var_t *var = find_local_var(token, parent);
     if (!var)
@@ -915,7 +915,7 @@ int size_var(var_t *var)
  *
  * Return: A pointer to the function.
  */
-func_t *add_func(char *func_name, bool synthesize)
+func_t *add_func(const char *func_name, bool synthesize)
 {
     func_t *func = hashmap_get(FUNC_MAP, func_name);
 
@@ -947,7 +947,7 @@ func_t *add_func(char *func_name, bool synthesize)
  *
  * Return: A pointer to the function if exists, NULL otherwise.
  */
-func_t *find_func(char *func_name)
+func_t *find_func(const char *func_name)
 {
     return hashmap_get(FUNC_MAP, func_name);
 }
@@ -1164,7 +1164,7 @@ bool strbuf_putc(strbuf_t *src, char value)
     return true;
 }
 
-bool strbuf_puts(strbuf_t *src, char *value)
+bool strbuf_puts(strbuf_t *src, const char *value)
 {
     int len = strlen(value);
 

src/lexer.c

@@ -12,7 +12,7 @@
 
 /* Hash table constants */
 #define NUM_DIRECTIVES 11
-#define NUM_KEYWORDS 16
+#define NUM_KEYWORDS 17
 
 /* Token mapping structure for elegant initialization */
 typedef struct {
@@ -86,6 +86,7 @@ void lex_init_keywords()
         {"default", T_default},
         {"continue", T_continue},
         {"union", T_union},
+        {"const", T_const},
     };
 
     /* hashmap insertion */
@@ -96,7 +97,7 @@ void lex_init_keywords()
 }
 
 /* Hash table lookup for preprocessor directives */
-token_t lookup_directive(char *token)
+token_t lookup_directive(const char *token)
 {
     if (!DIRECTIVE_MAP)
         lex_init_directives();
@@ -109,7 +110,7 @@ token_t lookup_directive(char *token)
 }
 
 /* Hash table lookup for C keywords */
-token_t lookup_keyword(char *token)
+token_t lookup_keyword(const char *token)
 {
     if (!KEYWORD_MAP)
         lex_init_keywords();
@@ -787,13 +788,15 @@ token_t lex_token_impl(bool aliasing)
                 keyword = T_case;
             break;
 
-        case 5: /* 5-letter keywords: while, break, union */
+        case 5: /* 5-letter keywords: while, break, union, const */
             if (token_str[0] == 'w' && !memcmp(token_str, "while", 5))
                 keyword = T_while;
             else if (token_str[0] == 'b' && !memcmp(token_str, "break", 5))
                 keyword = T_break;
             else if (token_str[0] == 'u' && !memcmp(token_str, "union", 5))
                 keyword = T_union;
+            else if (token_str[0] == 'c' && !memcmp(token_str, "const", 5))
+                keyword = T_const;
             break;
 
         case 6: /* 6-letter keywords: return, struct, switch, sizeof */