refactor(symres): drop the dead ResolverCacheEntry.load_base field

cache_entry->load_base was written in three places (cache open, FindFde,
Resolve) and never read -- every path recomputes the precise bias into a
local. The per-resolve store was a dead store mull flagged (cxx_assign_const)
that no test can kill because nothing observes the field. Remove the field,
its find_or_open parameter, and the three writes; the white-box Mut.c test
that passed an incidental load_base arg is updated. With this, the
SymbolResolver mutation suite intersection converges to 0 true survivors.

Author: brightprogrammer

Include/Misra/Sys/SymbolResolver.h

@@ -74,7 +74,6 @@ typedef struct ResolvedSymbol {
 
 typedef struct ResolverCacheEntry {
     Zstr path; // borrowed from ProcMaps.raw
-    u64  load_base;
     Elf  elf;
     // Sidecar debug file found via .gnu_debuglink or .note.gnu.build-id.
     // Populated lazily for stripped binaries that have an installed

Source/Misra/Sys/SymbolResolver.c

@@ -140,7 +140,7 @@ static bool try_open_sidecar(Zstr main_path, const Elf *main, Elf *out, Allocato
 // Cache management
 // ---------------------------------------------------------------------------
 
-static ResolverCacheEntry *resolver_cache_find_or_open(SymbolResolver *self, Zstr path, u64 load_base) {
+static ResolverCacheEntry *resolver_cache_find_or_open(SymbolResolver *self, Zstr path) {
     for (u64 i = 0; i < VecLen(&self->cache); ++i) {
         ResolverCacheEntry *e = VecPtrAt(&self->cache, i);
         if (e->path == path) {
@@ -156,8 +156,7 @@ static ResolverCacheEntry *resolver_cache_find_or_open(SymbolResolver *self, Zst
 
     ResolverCacheEntry entry;
     MemSet(&entry, 0, sizeof(entry));
-    entry.path      = path;
-    entry.load_base = load_base;
+    entry.path = path;
     if (!ElfOpen(&entry.elf, path, self->allocator)) {
         return NULL;
     }
@@ -269,12 +268,11 @@ bool SymbolResolverFindFde(
     if (!entry || !entry->path || entry->path[0] == '\0')
         return false;
 
-    ResolverCacheEntry *cache_entry = resolver_cache_find_or_open(self, entry->path, entry->start - entry->file_offset);
+    ResolverCacheEntry *cache_entry = resolver_cache_find_or_open(self, entry->path);
     if (!cache_entry)
         return false;
     // p_vaddr-space bias (not the file-offset shortcut) -- see resolver_load_bias.
-    u64 load_base          = resolver_load_bias(&cache_entry->elf, entry->start, entry->file_offset, addr);
-    cache_entry->load_base = load_base;
+    u64 load_base = resolver_load_bias(&cache_entry->elf, entry->start, entry->file_offset, addr);
 
     if (!cache_entry->cfi_built) {
         cache_entry->cfi_built = true;
@@ -354,15 +352,14 @@ bool SymbolResolverResolve(SymbolResolver *self, void *runtime_addr, ResolvedSym
         return false;
     }
 
-    ResolverCacheEntry *cache_entry = resolver_cache_find_or_open(self, entry->path, entry->start - entry->file_offset);
+    ResolverCacheEntry *cache_entry = resolver_cache_find_or_open(self, entry->path);
     if (!cache_entry) {
         return false;
     }
     // Correct load bias in p_vaddr space (see resolver_load_bias). Covers
     // PIE / shared objects; for ET_EXEC the first PT_LOAD's p_vaddr already
     // equals the mapping start, so the absolute base still falls out.
-    u64 load_base          = resolver_load_bias(&cache_entry->elf, entry->start, entry->file_offset, addr);
-    cache_entry->load_base = load_base;
+    u64 load_base = resolver_load_bias(&cache_entry->elf, entry->start, entry->file_offset, addr);
 
     out->module_path = entry->path;
     out->module_base = load_base;

Tests/Std/SymbolResolver.Mut.c

@@ -76,13 +76,13 @@ bool test_srmut_cache_zstrcompare_fallback_hits(void) {
     bool ok = (p1 != p2); // genuinely distinct pointers
 
     // Miss -> opens + inserts entry with path == p1.
-    ResolverCacheEntry *e1 = resolver_cache_find_or_open(&res, p1, 0x1000);
+    ResolverCacheEntry *e1 = resolver_cache_find_or_open(&res, p1);
     ok                     = ok && e1 != NULL;
     ok                     = ok && VecLen(&res.cache) == 1;
 
     // Lookup with the OTHER buffer: pointer differs from p1, so only the
     // ZstrCompare fallback can recognise it as the same module.
-    ResolverCacheEntry *e2 = resolver_cache_find_or_open(&res, p2, 0x2000);
+    ResolverCacheEntry *e2 = resolver_cache_find_or_open(&res, p2);
     ok                     = ok && e2 == e1;                // same cached entry reused
     ok                     = ok && VecLen(&res.cache) == 1; // no duplicate open
 
@@ -118,8 +118,7 @@ bool test_srmut_deinit_frees_sidecar(void) {
 
     ResolverCacheEntry entry;
     MemSet(&entry, 0, sizeof(entry));
-    entry.path      = file;
-    entry.load_base = 0x1000;
+    entry.path = file;
 
     bool ok = ElfOpen(&entry.elf, file, ALLOCATOR_OF(&alloc));
     if (ok)