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.

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/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 */
@@ -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 */

src/parser.c

@@ -4809,10 +4809,11 @@ void read_func_body(func_t *func)
 }
 
 /* if first token is type */
-void read_global_decl(block_t *block)
+void read_global_decl(block_t *block, bool is_const)
 {
     var_t *var = require_var(block);
     var->is_global = true;
+    var->is_const_qualified = is_const;
 
     /* new function, or variables under parent */
     read_full_var_decl(var, false, false);
@@ -4902,6 +4903,7 @@ void initialize_struct_field(var_t *nv, var_t *v, int offset)
     nv->is_func = false;
     nv->is_global = false;
     nv->is_initialized = false;
+    nv->is_const_qualified = false;
     nv->array_size = 0;
     nv->offset = offset;
     nv->init_val = 0;
@@ -4916,6 +4918,11 @@ void read_global_statement(void)
 {
     char token[MAX_ID_LEN];
     block_t *block = GLOBAL_BLOCK; /* global block */
+    bool is_const = false;
+
+    /* Handle const qualifier */
+    if (lex_accept(T_const))
+        is_const = true;
 
     if (lex_accept(T_struct)) {
         int i = 0, size = 0;
@@ -4931,6 +4938,7 @@ void read_global_statement(void)
             /* one or more declarators */
             var_t *var = require_typed_var(block, decl_type);
             var->is_global = true; /* Global struct variable */
+            var->is_const_qualified = is_const;
             read_partial_var_decl(var, NULL);
             add_insn(block, GLOBAL_FUNC->bbs, OP_allocat, var, NULL, NULL, 0,
                      NULL);
@@ -5228,7 +5236,7 @@ void read_global_statement(void)
             lex_expect(T_semicolon);
         }
     } else if (lex_peek(T_identifier, NULL)) {
-        read_global_decl(block);
+        read_global_decl(block, is_const);
     } else
         error("Syntax error in global statement");
 }

src/reg-alloc.c

@@ -424,7 +424,11 @@ void reg_alloc(void)
                             ? align_size(PTR_SIZE * global_insn->rd->array_size)
                             : align_size(global_insn->rd->array_size *
                                          global_insn->rd->type->size);
-                    elf_data->size += size;
+                    /* Const initialized globals go to .rodata */
+                    if (global_insn->rd->is_const_qualified)
+                        elf_rodata->size += size;
+                    else
+                        elf_data->size += size;
                 } else {
                     int size =
                         global_insn->rd->ptr_level
@@ -460,7 +464,11 @@ void reg_alloc(void)
 
                 /* Track section sizes for ELF generation */
                 if (global_insn->rd->is_initialized) {
-                    elf_data->size += size;
+                    /* Const initialized globals go to .rodata */
+                    if (global_insn->rd->is_const_qualified)
+                        elf_rodata->size += size;
+                    else
+                        elf_data->size += size;
                 } else {
                     elf_bss_size += size;
                 }

tests/driver.sh

@@ -1711,6 +1711,104 @@ int main()
 }
 EOF
 
+# Category: Const Qualifier
+begin_category "Const Qualifier" "Testing const keyword for global variables"
+
+# Basic const global scalar variables
+try_ 42 << EOF
+const int readonly_value = 42;
+int main() {
+    return readonly_value;
+}
+EOF
+
+try_ 100 << EOF
+const int max_size = 100;
+int main() {
+    return max_size;
+}
+EOF
+
+# Multiple const globals
+try_ 42 << EOF
+const int MAGIC_NUMBER = 42;
+const int SPEED_OF_LIGHT = 300000;
+int main() {
+    return MAGIC_NUMBER;
+}
+EOF
+
+# Mixed const and non-const globals
+try_ 85 << EOF
+const int const_val = 42;
+int regular_val = 43;
+int main() {
+    return const_val + regular_val;
+}
+EOF
+
+# Const globals with expressions
+try_ 25 << EOF
+const int base = 5;
+const int multiplier = 5;
+int main() {
+    return base * multiplier;
+}
+EOF
+
+# Const globals with different types
+try_ 65 << EOF
+const char letter = 'A';
+const int number = 0;
+int main() {
+    return letter + number;  /* 'A' = 65, 65 + 0 = 65 */
+}
+EOF
+
+# Verify const globals work with string literals (both in .rodata)
+try_ 0 << EOF
+const int magic_number = 42;
+int main() {
+    char *msg = "String in rodata";
+    /* Verify string literal and const global both work */
+    if (msg[0] != 'S') return 1;
+    if (magic_number != 42) return 2;
+    return 0;
+}
+EOF
+
+# Const globals in arithmetic expressions
+try_ 30 << EOF
+const int x = 10;
+const int y = 20;
+int main() {
+    int result = x + y;
+    return result;
+}
+EOF
+
+# Const globals in conditional expressions
+try_ 1 << EOF
+const int threshold = 50;
+int main() {
+    int value = 60;
+    return value > threshold ? 1 : 0;
+}
+EOF
+
+# Const globals as function parameters (pass by value)
+try_ 100 << EOF
+const int global_const = 50;
+
+int double_value(int x) {
+    return x * 2;
+}
+
+int main() {
+    return double_value(global_const);
+}
+EOF
+
 # Category: Ternary Operator
 begin_category "Ternary Operator" "Testing conditional ?: operator"