Support .rodata/.bss section for generation

This commit adds infrastructure for .rodata (read-only data) and .bss
(uninitialized data) sections and implements OP_load_rodata_address for
addressing constants in .rodata. Then, it moves string literals from
.data to .rodata section for better memory protection.

TODO: implement optimizations for global variable initialization with
compile-time constants.

Author: jserv

README.md

@@ -237,7 +237,6 @@ int fib(int n)       def int @fib(int %n)
 
 ## Known Issues
 
-1. The generated ELF lacks .bss and .rodata sections
 2. Full `<stdarg.h>` support is not available. Variadic functions work via direct pointer arithmetic.
    See the `printf` implementation in `lib/c.c` for the supported approach.
 3. The C front-end operates directly on token streams without building a full AST.

src/arm-codegen.c

@@ -98,6 +98,7 @@ void update_elf_offset(ph2_ir_t *ph2_ir)
         elf_offset += 116;
         return;
     case OP_load_data_address:
+    case OP_load_rodata_address:
         elf_offset += 8;
         return;
     case OP_address_of_func:
@@ -190,7 +191,7 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
     func_t *func;
     const int rd = ph2_ir->dest;
     const int rn = ph2_ir->src0;
-    const int rm = ph2_ir->src1;
+    int rm = ph2_ir->src1; /* Not const because OP_trunc modifies it */
     int ofs;
 
     /* Prepare this variable to reuse code for:
@@ -288,6 +289,10 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
         emit(__movw(__AL, rd, ph2_ir->src0 + elf_data_start));
         emit(__movt(__AL, rd, ph2_ir->src0 + elf_data_start));
         return;
+    case OP_load_rodata_address:
+        emit(__movw(__AL, rd, ph2_ir->src0 + elf_rodata_start));
+        emit(__movt(__AL, rd, ph2_ir->src0 + elf_rodata_start));
+        return;
     case OP_address_of_func:
         func = find_func(ph2_ir->func_name);
         ofs = elf_code_start + func->bbs->elf_offset;
@@ -310,7 +315,7 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
         emit(__movt(__AL, __r8, ph2_ir->src1 + 4));
         emit(__add_r(__AL, __sp, __sp, __r8));
         emit(__lw(__AL, __lr, __sp, -4));
-        emit(__blx(__AL, __lr));
+        emit(__bx(__AL, __lr));
         return;
     case OP_add:
         emit(__add_r(__AL, rd, rn, rm));
@@ -450,6 +455,8 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
 void code_generate(void)
 {
     elf_data_start = elf_code_start + elf_offset;
+    elf_rodata_start = elf_data_start + elf_data->size;
+    elf_bss_start = elf_rodata_start + elf_rodata->size;
 
     /* start */
     emit(__movw(__AL, __r8, GLOBAL_FUNC->stack_size));
@@ -477,7 +484,7 @@ void code_generate(void)
     emit(__mov_r(__AL, __r4, __r5));
     emit(__mov_r(__AL, __r5, __r6));
     emit(__svc());
-    emit(__mov_r(__AL, __pc, __lr));
+    emit(__bx(__AL, __lr));
 
     ph2_ir_t *ph2_ir;
     for (ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;

src/defs.h

@@ -261,8 +261,9 @@ typedef enum {
 
     OP_allocat, /* allocate space on stack */
     OP_assign,
-    OP_load_constant,     /* load constant */
-    OP_load_data_address, /* lookup address of a constant in data section */
+    OP_load_constant,       /* load constant */
+    OP_load_data_address,   /* lookup address of a constant in data section */
+    OP_load_rodata_address, /* lookup address of a constant in rodata section */
 
     /* control flow */
     OP_branch,   /* conditional jump */

src/elf.c

@@ -64,8 +64,7 @@ void elf_generate_header(void)
     }
 
     elf32_hdr_t hdr;
-    /*
-     * The following table explains the meaning of each field in the
+    /* The following table explains the meaning of each field in the
      * ELF32 file header.
      *
      * Notice that the following values are hexadecimal.
@@ -134,26 +133,34 @@ void elf_generate_header(void)
     hdr.e_version = 1;                        /* ELF version */
     hdr.e_entry = ELF_START + elf_header_len; /* entry point */
     hdr.e_phoff = 0x34;                       /* program header offset */
-    hdr.e_shoff = elf_header_len + elf_code->size + elf_data->size + 39 +
-                  elf_symtab->size +
-                  elf_strtab->size; /* section header offset */
-    hdr.e_flags = ELF_FLAGS;        /* flags */
-    hdr.e_ehsize[0] = (char) 0x34;  /* header size */
+    /* Section header offset: The section headers come after symtab, strtab, and
+     * shstrtab which are all written as part of elf_section buffer.
+     * shstrtab size = 1 (null) + 10 (.shstrtab\0) + 6 (.text\0) + 6 (.data\0) +
+     *                 8 (.rodata\0) + 5 (.bss\0) + 8 (.symtab\0) + 8
+     * (.strtab\0) = 52
+     */
+    const int shstrtab_size = 52; /* Size of section header string table */
+    hdr.e_shoff = elf_header_len + elf_code->size + elf_data->size +
+                  elf_rodata->size + elf_symtab->size + elf_strtab->size +
+                  shstrtab_size;
+    hdr.e_flags = ELF_FLAGS;       /* flags */
+    hdr.e_ehsize[0] = (char) 0x34; /* header size */
     hdr.e_ehsize[1] = 0;
     hdr.e_phentsize[0] = (char) 0x20; /* program header size */
     hdr.e_phentsize[1] = 0;
     hdr.e_phnum[0] = 1; /* number of program headers */
     hdr.e_phnum[1] = 0;
     hdr.e_shentsize[0] = (char) 0x28; /* section header size */
     hdr.e_shentsize[1] = 0;
-    hdr.e_shnum[0] = 6; /* number of section headers */
+    /* number of section headers: .rodata and .bss included */
+    hdr.e_shnum[0] = 8;
     hdr.e_shnum[1] = 0;
-    hdr.e_shstrndx[0] = 5; /* section index with names */
+    /* section index with names: updated for new sections */
+    hdr.e_shstrndx[0] = 7;
     hdr.e_shstrndx[1] = 0;
     elf_write_blk(elf_header, &hdr, sizeof(elf32_hdr_t));
 
-    /*
-     * Explain the meaning of each field in the ELF32 program header.
+    /* Explain the meaning of each field in the ELF32 program header.
      *
      *    |  Program       |                                                 |
      *  & |  Header bytes  | Explanation                                     |
@@ -176,14 +183,16 @@ void elf_generate_header(void)
      */
     /* program header - code and data combined */
     elf32_phdr_t phdr;
-    phdr.p_type = 1;                                 /* PT_LOAD */
-    phdr.p_offset = elf_header_len;                  /* offset of segment */
-    phdr.p_vaddr = ELF_START + elf_header_len;       /* virtual address */
-    phdr.p_paddr = ELF_START + elf_header_len;       /* physical address */
-    phdr.p_filesz = elf_code->size + elf_data->size; /* size in file */
-    phdr.p_memsz = elf_code->size + elf_data->size;  /* size in memory */
-    phdr.p_flags = 7;                                /* flags */
-    phdr.p_align = 4;                                /* alignment */
+    phdr.p_type = 1;                           /* PT_LOAD */
+    phdr.p_offset = elf_header_len;            /* offset of segment */
+    phdr.p_vaddr = ELF_START + elf_header_len; /* virtual address */
+    phdr.p_paddr = ELF_START + elf_header_len; /* physical address */
+    phdr.p_filesz = elf_code->size + elf_data->size +
+                    elf_rodata->size; /* size in file - includes .rodata */
+    phdr.p_memsz = elf_code->size + elf_data->size + elf_rodata->size +
+                   elf_bss_size; /* size in memory - includes .bss */
+    phdr.p_flags = 7;            /* flags */
+    phdr.p_align = 4;            /* alignment */
     elf_write_blk(elf_header, &phdr, sizeof(elf32_phdr_t));
 }
 
@@ -195,26 +204,39 @@ void elf_generate_sections(void)
         return;
     }
 
+    int section_data_size = 0;
+    int shstrtab_start = 0; /* Track start of shstrtab */
+
     /* symtab section */
     for (int b = 0; b < elf_symtab->size; b++)
         elf_write_byte(elf_section, elf_symtab->elements[b]);
+    section_data_size += elf_symtab->size;
 
     /* strtab section */
     for (int b = 0; b < elf_strtab->size; b++)
         elf_write_byte(elf_section, elf_strtab->elements[b]);
+    section_data_size += elf_strtab->size;
 
-    /* shstr section; len = 39 */
+    /* shstr section - compute size dynamically */
+    shstrtab_start = elf_section->size;
     elf_write_byte(elf_section, 0);
     elf_write_str(elf_section, ".shstrtab");
     elf_write_byte(elf_section, 0);
     elf_write_str(elf_section, ".text");
     elf_write_byte(elf_section, 0);
     elf_write_str(elf_section, ".data");
     elf_write_byte(elf_section, 0);
+    elf_write_str(elf_section, ".rodata");
+    elf_write_byte(elf_section, 0);
+    elf_write_str(elf_section, ".bss");
+    elf_write_byte(elf_section, 0);
     elf_write_str(elf_section, ".symtab");
     elf_write_byte(elf_section, 0);
     elf_write_str(elf_section, ".strtab");
     elf_write_byte(elf_section, 0);
+    /* Add padding byte for alignment - some tools expect this */
+    elf_write_byte(elf_section, 0);
+    int shstrtab_size = elf_section->size - shstrtab_start;
 
     /* section header table */
     elf32_shdr_t shdr;
@@ -288,22 +310,51 @@ void elf_generate_sections(void)
     elf_write_blk(elf_section, &shdr, sizeof(elf32_shdr_t));
     ofs += elf_data->size;
 
+    /* .rodata */
+    shdr.sh_name = 0x17; /* Offset in shstrtab for ".rodata" */
+    shdr.sh_type = 1;    /* SHT_PROGBITS */
+    shdr.sh_flags = 2;   /* SHF_ALLOC only (read-only) */
+    shdr.sh_addr = elf_code_start + elf_code->size + elf_data->size;
+    shdr.sh_offset = ofs;
+    shdr.sh_size = elf_rodata->size;
+    shdr.sh_link = 0;
+    shdr.sh_info = 0;
+    shdr.sh_addralign = 4;
+    shdr.sh_entsize = 0;
+    elf_write_blk(elf_section, &shdr, sizeof(elf32_shdr_t));
+    ofs += elf_rodata->size;
+
+    /* .bss */
+    shdr.sh_name = 0x1f; /* Offset in shstrtab for ".bss" */
+    shdr.sh_type = 8;    /* SHT_NOBITS */
+    shdr.sh_flags = 3;   /* SHF_ALLOC | SHF_WRITE */
+    shdr.sh_addr =
+        elf_code_start + elf_code->size + elf_data->size + elf_rodata->size;
+    shdr.sh_offset = ofs; /* File offset (not actually used for NOBITS) */
+    shdr.sh_size = elf_bss_size;
+    shdr.sh_link = 0;
+    shdr.sh_info = 0;
+    shdr.sh_addralign = 4;
+    shdr.sh_entsize = 0;
+    elf_write_blk(elf_section, &shdr, sizeof(elf32_shdr_t));
+    /* Note: .bss is not written to file (SHT_NOBITS) */
+
     /* .symtab */
-    shdr.sh_name = 0x17;
+    shdr.sh_name = 0x24; /* Updated offset for ".symtab" */
     shdr.sh_type = 2;
     shdr.sh_flags = 0;
     shdr.sh_addr = 0;
     shdr.sh_offset = ofs;
     shdr.sh_size = elf_symtab->size;
-    shdr.sh_link = 4;
+    shdr.sh_link = 6; /* Link to .strtab (section 6) */
     shdr.sh_info = elf_symbol_index;
     shdr.sh_addralign = 4;
     shdr.sh_entsize = 16;
     elf_write_blk(elf_section, &shdr, sizeof(elf32_shdr_t));
     ofs += elf_symtab->size;
 
     /* .strtab */
-    shdr.sh_name = 0x1f;
+    shdr.sh_name = 0x2c; /* Updated offset for ".strtab" */
     shdr.sh_type = 3;
     shdr.sh_flags = 0;
     shdr.sh_addr = 0;
@@ -322,7 +373,7 @@ void elf_generate_sections(void)
     shdr.sh_flags = 0;
     shdr.sh_addr = 0;
     shdr.sh_offset = ofs;
-    shdr.sh_size = 39;
+    shdr.sh_size = shstrtab_size; /* Computed dynamically */
     shdr.sh_link = 0;
     shdr.sh_info = 0;
     shdr.sh_addralign = 1;
@@ -333,14 +384,17 @@ void elf_generate_sections(void)
 void elf_align(void)
 {
     /* Check for null pointers to prevent crashes */
-    if (!elf_data || !elf_symtab || !elf_strtab) {
+    if (!elf_data || !elf_rodata || !elf_symtab || !elf_strtab) {
         error("ELF buffers not initialized for alignment");
         return;
     }
 
     while (elf_data->size & 3)
         elf_write_byte(elf_data, 0);
 
+    while (elf_rodata->size & 3)
+        elf_write_byte(elf_rodata, 0);
+
     while (elf_symtab->size & 3)
         elf_write_byte(elf_symtab, 0);
 
@@ -387,6 +441,9 @@ void elf_generate(const char *outfile)
         fputc(elf_code->elements[i], fp);
     for (int i = 0; i < elf_data->size; i++)
         fputc(elf_data->elements[i], fp);
+    for (int i = 0; i < elf_rodata->size; i++)
+        fputc(elf_rodata->elements[i], fp);
+    /* Note: .bss is not written to file (SHT_NOBITS) */
     for (int i = 0; i < elf_section->size; i++)
         fputc(elf_section->elements[i], fp);
     fclose(fp);

src/globals.c

@@ -93,13 +93,17 @@ hashmap_t *INCLUSION_MAP;
 /* ELF sections */
 strbuf_t *elf_code;
 strbuf_t *elf_data;
+strbuf_t *elf_rodata;
 strbuf_t *elf_header;
 strbuf_t *elf_symtab;
 strbuf_t *elf_strtab;
 strbuf_t *elf_section;
 int elf_header_len = 0x54; /* ELF fixed: 0x34 + 1 * 0x20 */
 int elf_code_start;
 int elf_data_start;
+int elf_rodata_start;
+int elf_bss_start;
+int elf_bss_size;
 
 /* Create a new arena block with given capacity.
  * @capacity: The capacity of the arena block. Must be positive.
@@ -1227,10 +1231,12 @@ void global_init(void)
 
     elf_code = strbuf_create(MAX_CODE);
     elf_data = strbuf_create(MAX_DATA);
+    elf_rodata = strbuf_create(MAX_DATA);
     elf_header = strbuf_create(MAX_HEADER);
     elf_symtab = strbuf_create(MAX_SYMTAB);
     elf_strtab = strbuf_create(MAX_STRTAB);
     elf_section = strbuf_create(MAX_SECTION);
+    elf_bss_size = 0;
 }
 
 /* Forward declaration for lexer cleanup */
@@ -1350,6 +1356,7 @@ void global_release(void)
     strbuf_free(SOURCE);
     strbuf_free(elf_code);
     strbuf_free(elf_data);
+    strbuf_free(elf_rodata);
     strbuf_free(elf_header);
     strbuf_free(elf_symtab);
     strbuf_free(elf_strtab);
@@ -1452,6 +1459,11 @@ void dump_bb_insn(func_t *func, basic_block_t *bb, bool *at_func_start)
             /* offset from .data section */
             printf("%%%s = .data (%d)", rd->var_name, rd->init_val);
             break;
+        case OP_load_rodata_address:
+            print_indent(1);
+            /* offset from .rodata section */
+            printf("%%%s = .rodata (%d)", rd->var_name, rd->init_val);
+            break;
         case OP_address_of:
             print_indent(1);
             printf("%%%s = &(%%%s)", rd->var_name, rs1->var_name);

src/parser.c

@@ -132,9 +132,10 @@ void read_expr(block_t *parent, basic_block_t **bb);
 
 int write_symbol(const char *data)
 {
-    const int start_len = elf_data->size;
-    elf_write_str(elf_data, data);
-    elf_write_byte(elf_data, 0);
+    /* Write string literals to .rodata section instead of .data */
+    const int start_len = elf_rodata->size;
+    elf_write_str(elf_rodata, data);
+    elf_write_byte(elf_rodata, 0);
     return start_len;
 }
 
@@ -1381,7 +1382,8 @@ void read_literal_param(block_t *parent, basic_block_t *bb)
     gen_name_to(vd->var_name);
     vd->init_val = index;
     opstack_push(vd);
-    add_insn(parent, bb, OP_load_data_address, vd, NULL, NULL, 0, NULL);
+    /* String literals are now in .rodata section */
+    add_insn(parent, bb, OP_load_rodata_address, vd, NULL, NULL, 0, NULL);
 }
 
 void read_numeric_param(block_t *parent, basic_block_t *bb, bool is_neg)
@@ -3655,9 +3657,9 @@ bool read_global_assignment(char *token)
     if (var) {
         if (lex_peek(T_string, NULL)) {
             /* String literal global initialization:
-             * Current implementation stores strings inline rather than in
-             * '.rodata'. Pointer vs array semantics handled by assignment logic
-             * below. mutate the size of var here.
+             * String literals are now stored in .rodata section.
+             * TODO: Full support for global pointer initialization with
+             * rodata addresses requires compile-time address resolution.
              */
             read_literal_param(parent, bb);
             rs1 = opstack_pop();

src/peephole.c

@@ -34,6 +34,7 @@ bool is_fusible_insn(ph2_ir_t *ph2_ir)
     case OP_load:   /* Memory operations */
     case OP_global_load:
     case OP_load_data_address:
+    case OP_load_rodata_address:
         return true;
     default:
         return false;