kit

cfi_unit.c (11353B)

---

 /* test/debug/cfi_unit.c — exercise MCEmitter CFI buffering + the
  * mc_emit_eh_frame producer, then spot-check the resulting .eh_frame
  * section bytes.
  *
  * Covers aa64, rv64, and x64; the rv64 case validates the locked psABI
  * defaults (CFA=sp, RA=ra (DWARF 1), saved s0/ra, callee-saved s2..s11
  * + fs2..fs11) end-to-end, and the x64 case pins the SysV x86-64 DWARF
  * register numbering (which diverges from the hardware encoding). The
  * producer is driven directly via MCEmitter and arch_for_compiler so the
  * test stays independent of the backend lowering pipeline. */
 
 #include <kit/arch.h>
 #include <kit/core.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "arch/arch.h"
 #include "core/core.h"
 #include "core/pool.h"
 #include "debug/dwarf_defs.h"
 #include "lib/kit_unit.h"
 #include "obj/obj.h"
 
 /* One shared test context replaces the per-file heap/diag/counter globals.
  * EXPECT is aliased to CU_EXPECT so the call sites below are unchanged. The
  * original ctx used now = -1, replicated in main() after kit_unit_init. */
 static KitUnit g_u;
 #define EXPECT(cond, ...) CU_EXPECT(&g_u, cond, __VA_ARGS__)
 
 static const Section* sec_by_name(const ObjBuilder* ob, Pool* pool,
                                   const char* name) {
   u32 i, n = obj_section_count(ob);
   for (i = 1; i < n; ++i) {
     const Section* s = obj_section_get(ob, i);
     Slice sn = pool_slice(pool, s->name);
     if (sn.s && strlen(name) == sn.len && memcmp(sn.s, name, sn.len) == 0)
       return s;
   }
   return NULL;
 }
 
 static u32 read_u32le(const u8* p) {
   return (u32)p[0] | ((u32)p[1] << 8) | ((u32)p[2] << 16) | ((u32)p[3] << 24);
 }
 
 /* Decode an unsigned LEB128 from buf starting at *off; advance *off. */
 static u64 dec_uleb(const u8* buf, u32 size, u32* off) {
   u64 v = 0;
   u32 shift = 0;
   while (*off < size) {
     u8 byte = buf[(*off)++];
     v |= (u64)(byte & 0x7fu) << shift;
     if ((byte & 0x80u) == 0) break;
     shift += 7;
   }
   return v;
 }
 
 static i64 dec_sleb(const u8* buf, u32 size, u32* off) {
   i64 v = 0;
   u32 shift = 0;
   u8 byte = 0;
   while (*off < size) {
     byte = buf[(*off)++];
     v |= (i64)(byte & 0x7fu) << shift;
     shift += 7;
     if ((byte & 0x80u) == 0) break;
   }
   if (shift < 64 && (byte & 0x40u)) v |= -((i64)1 << shift);
   return v;
 }
 
 /* ---- driver ---- */
 
 typedef struct CfiExpect {
   KitArchKind arch;
   const char* tag;
   /* CIE expectations */
   u32 expected_return_reg;
   i32 expected_code_align;
   i32 expected_data_align;
   u32 expected_cfa_init_reg;
   i32 expected_cfa_init_offset;
   /* FDE expectations: registers we emit cfi_offset for */
   u32 cfa_reg_after_setup;
   i32 cfa_off_after_setup;
 } CfiExpect;
 
 static void check_arch(const CfiExpect* ex) {
   KitTargetSpec t;
   Compiler* c;
   ObjBuilder* ob;
   ObjSecId text_sec;
   ObjSymId fsym;
   Pool* pool;
   MCEmitter* mc;
   const Section* eh;
   const u8* bytes;
   u8* flat;
   u32 size;
   u32 off;
 
   t = kit_unit_target(ex->arch, KIT_OS_LINUX, KIT_OBJ_ELF);
 
   if (kit_unit_compiler_new(&g_u, t, &c) != KIT_OK || !c) {
     fprintf(stderr, "[%s] compiler_new failed\n", ex->tag);
     g_u.fails++;
     return;
   }
   ob = obj_new(c);
   pool = c->global;
 
   text_sec = obj_section(ob, pool_intern_slice(pool, SLICE_LIT(".text")),
                          SEC_TEXT, SF_EXEC | SF_ALLOC, 4);
   fsym = obj_symbol(ob, pool_intern_slice(pool, SLICE_LIT("f")), SB_GLOBAL,
                     SK_FUNC, text_sec, 0, 16);
 
   mc = mc_new(c, ob);
   EXPECT(mc != NULL, "[%s] mc_new failed", ex->tag);
   if (!mc) {
     kit_compiler_free(c);
     return;
   }
   mc->set_section(mc, text_sec);
   mc_begin_function(mc, fsym, text_sec, 0);
   mc->cfi_startproc(mc);
   /* Write the (placeholder) function body bytes AFTER cfi_startproc so
    * the FDE range captured by cfi_endproc reflects the body size. */
   {
     u8 zeros[16] = {0};
     obj_write(ob, text_sec, zeros, sizeof zeros);
   }
   /* Anchor the directives at pc_offset=0 so the test can predict offsets
    * deterministically (we wrote the bytes before opening the FDE, so
    * cur_pos > func_start). */
   mc->cfi_set_next_pc_offset(mc, 0);
   mc->cfi_def_cfa(mc, ex->cfa_reg_after_setup, ex->cfa_off_after_setup);
   /* Save the return-address register at CFA-8. */
   mc->cfi_set_next_pc_offset(mc, 0);
   mc->cfi_offset(mc, ex->expected_return_reg, -8);
   mc->cfi_endproc(mc);
   mc_end_function(mc);
 
   mc_emit_eh_frame(mc);
 
   eh = sec_by_name(ob, pool, ".eh_frame");
   EXPECT(eh != NULL, "[%s] .eh_frame missing", ex->tag);
   if (!eh) goto cleanup;
   size = buf_pos(&eh->bytes);
   EXPECT(size >= 24, "[%s] .eh_frame too small (%u)", ex->tag, size);
   flat = (u8*)malloc(size);
   buf_flatten(&eh->bytes, flat);
   bytes = flat;
   off = 0;
 
   /* ---- CIE ---- */
   {
     u32 cie_len = read_u32le(bytes + off);
     u32 cie_id;
     u8 ver;
     EXPECT(cie_len + 4 <= size, "[%s] CIE length out of bounds", ex->tag);
     off += 4;
     cie_id = read_u32le(bytes + off);
     off += 4;
     EXPECT(cie_id == 0, "[%s] CIE id != 0 (got %u)", ex->tag, cie_id);
     ver = bytes[off++];
     EXPECT(ver == 1, "[%s] CIE version != 1 (got %u)", ex->tag, ver);
     /* augmentation string "zR" */
     EXPECT(bytes[off] == 'z' && bytes[off + 1] == 'R' && bytes[off + 2] == 0,
            "[%s] augmentation != 'zR'", ex->tag);
     off += 3;
     {
       u64 caf = dec_uleb(bytes, size, &off);
       i64 daf = dec_sleb(bytes, size, &off);
       u64 rar = dec_uleb(bytes, size, &off);
       EXPECT((u32)caf == (u32)ex->expected_code_align,
              "[%s] code_align_factor got %u expected %d", ex->tag, (u32)caf,
              ex->expected_code_align);
       EXPECT((i32)daf == ex->expected_data_align,
              "[%s] data_align_factor got %d expected %d", ex->tag, (i32)daf,
              ex->expected_data_align);
       EXPECT((u32)rar == ex->expected_return_reg,
              "[%s] return_addr_reg got %u expected %u", ex->tag, (u32)rar,
              ex->expected_return_reg);
     }
     {
       u64 aug_len = dec_uleb(bytes, size, &off);
       EXPECT(aug_len == 1, "[%s] CIE aug_data_len != 1", ex->tag);
       EXPECT(bytes[off] == (DW_EH_PE_pcrel | DW_EH_PE_sdata4),
              "[%s] CIE fde_pe != pcrel|sdata4 (got 0x%x)", ex->tag, bytes[off]);
       off += 1;
     }
     /* Initial instructions: DW_CFA_def_cfa init_reg, init_offset */
     EXPECT(bytes[off] == DW_CFA_def_cfa,
            "[%s] CIE initial op != DW_CFA_def_cfa (got 0x%x)", ex->tag,
            bytes[off]);
     off += 1;
     {
       u64 r = dec_uleb(bytes, size, &off);
       u64 o = dec_uleb(bytes, size, &off);
       EXPECT((u32)r == ex->expected_cfa_init_reg,
              "[%s] CIE init CFA reg got %u expected %u", ex->tag, (u32)r,
              ex->expected_cfa_init_reg);
       EXPECT((i32)o == ex->expected_cfa_init_offset,
              "[%s] CIE init CFA off got %d expected %d", ex->tag, (i32)o,
              ex->expected_cfa_init_offset);
     }
     /* Skip any DW_CFA_nop padding to the CIE entry boundary. */
     off = 4 + cie_len;
   }
 
   /* ---- FDE ---- */
   {
     u32 fde_len = read_u32le(bytes + off);
     u32 cie_ptr;
     u32 fde_end;
     EXPECT(fde_len > 0, "[%s] FDE length zero or terminator", ex->tag);
     off += 4;
     fde_end = off + fde_len;
     cie_ptr = read_u32le(bytes + off);
     off += 4;
     EXPECT(cie_ptr != 0, "[%s] FDE CIE_pointer = 0 — would mark this as a CIE",
            ex->tag);
     /* initial_location (4 bytes — patched by reloc, here zero) */
     off += 4;
     {
       u32 range = read_u32le(bytes + off);
       EXPECT(range == 16, "[%s] FDE range got %u expected 16", ex->tag, range);
       off += 4;
     }
     {
       u64 aug_len = dec_uleb(bytes, size, &off);
       EXPECT(aug_len == 0, "[%s] FDE aug_data_len != 0", ex->tag);
     }
     /* Now decode the FDE program. Our directives were emitted at
      * pc_offset=0 with the override, so the first byte should be a
      * DW_CFA_def_cfa (no advance_loc), then DW_CFA_offset of return reg. */
     {
       u8 op = bytes[off++];
       EXPECT(op == DW_CFA_def_cfa,
              "[%s] FDE first op got 0x%x expected def_cfa", ex->tag, op);
       {
         u64 r = dec_uleb(bytes, size, &off);
         u64 o = dec_uleb(bytes, size, &off);
         EXPECT((u32)r == ex->cfa_reg_after_setup,
                "[%s] FDE def_cfa reg got %u expected %u", ex->tag, (u32)r,
                ex->cfa_reg_after_setup);
         EXPECT((i32)o == ex->cfa_off_after_setup,
                "[%s] FDE def_cfa off got %d expected %d", ex->tag, (i32)o,
                ex->cfa_off_after_setup);
       }
     }
     {
       /* DW_CFA_offset (0x80 | reg) when reg < 0x40 and factor >= 0. */
       u8 op = bytes[off++];
       u32 reg = op & 0x3fu;
       EXPECT((op & 0xc0u) == DW_CFA_offset,
              "[%s] FDE second op high bits != DW_CFA_offset (got 0x%x)",
              ex->tag, op);
       EXPECT(reg == ex->expected_return_reg,
              "[%s] FDE offset reg got %u expected %u", ex->tag, reg,
              ex->expected_return_reg);
       {
         u64 fac = dec_uleb(bytes, size, &off);
         /* We passed -8 as the imm and the data align factor is -8, so
          * factored offset should be 1. */
         EXPECT(fac == 1u, "[%s] FDE offset factor got %u expected 1", ex->tag,
                (u32)fac);
       }
     }
     /* Any trailing DW_CFA_nop padding is fine. */
     (void)fde_end;
   }
 
   free(flat);
 
 cleanup:
   /* mc_free is invoked transitively via compiler cleanup. */
   obj_free(ob);
   kit_compiler_free(c);
 }
 
 int main(void) {
   kit_unit_init(&g_u);
   g_u.ctx.now = -1; /* preserve the original ctx.now */
 
   /* aa64: RA=x30 (DWARF 30), code_align=4, data_align=-8, CFA init = sp. */
   {
     CfiExpect ex = {
         .arch = KIT_ARCH_ARM_64,
         .tag = "aa64",
         .expected_return_reg = 30,
         .expected_code_align = 4,
         .expected_data_align = -8,
         .expected_cfa_init_reg = 31,
         .expected_cfa_init_offset = 0,
         /* Pretend we set CFA = x29 + 16 after frame setup. */
         .cfa_reg_after_setup = 29,
         .cfa_off_after_setup = 16,
     };
     check_arch(&ex);
   }
   /* rv64: RA=x1=ra (DWARF 1), code_align=2 (covers C-ext), data_align=-8,
    * CFA init = sp (x2). After setup, CFA = s0 (x8) + 16 (typical fp frame). */
   {
     CfiExpect ex = {
         .arch = KIT_ARCH_RV64,
         .tag = "rv64",
         .expected_return_reg = 1,
         .expected_code_align = 2,
         .expected_data_align = -8,
         .expected_cfa_init_reg = 2,
         .expected_cfa_init_offset = 0,
         .cfa_reg_after_setup = 8,
         .cfa_off_after_setup = 16,
     };
     check_arch(&ex);
   }
   /* x64: RA=rip (DWARF 16), code_align=1, data_align=-8, CFA init = rsp
    * (DWARF 7). After setup, CFA = rbp (DWARF 6) + 16. x64 is the only arch
    * whose DWARF register numbers diverge from the hardware encoding (rbp is
    * HW 5 = DWARF RDI), so this case pins the SysV x86-64 DWARF numbering. */
   {
     CfiExpect ex = {
         .arch = KIT_ARCH_X86_64,
         .tag = "x64",
         .expected_return_reg = 16,
         .expected_code_align = 1,
         .expected_data_align = -8,
         .expected_cfa_init_reg = 7,
         .expected_cfa_init_offset = 8,
         .cfa_reg_after_setup = 6,
         .cfa_off_after_setup = 16,
     };
     check_arch(&ex);
   }
 
   if (g_u.fails) {
     fprintf(stderr, "%d FAILED\n", g_u.fails);
     return 1;
   }
   printf("debug cfi_unit: OK\n");
   return 0;
 }