[syscall] E: Honour STB_WEAK undefined symbols

[esaurez]

Summary

Teaches the in-process Nanvix dynamic loader to honour the System V ABI's STB_WEAK contract: an undefined weak symbol that cannot be resolved at dynamic-link time resolves to value 0, not to a loader error. This matches every mainstream ELF loader and is a prerequisite for .so files produced by GCC/Clang — the C++ runtime, TLS bootstrap, and many GNU extensions all carry weak refs that may or may not be present at load time.

Why this is required

The current loader rejects any .so containing any undefined weak symbol that no loaded module defines. In practice that breaks:

• libstdc++: emits weak refs to pthread_* (so a static link to a single-threaded program still works), __gmon_start__, and several _ITM_* items. When the consumer of a libstdc++ .so is itself a static binary, none of those are defined anywhere — the spec expects them to fold to 0; we expected them to be resolvable.
• TLS bootstrap: GCC emits weak refs to __cxa_thread_atexit_impl and friends so that the C++ runtime can optionally hook into glibc's per-thread cleanup machinery. On Nanvix there is no glibc, so these stay undefined; the program is designed to fall through, but only if the loader complies with the ABI.
• CPython + numpy: the numpy .so (and most pip-installed wheels) ship weak refs to glibc-isms via libstdc++. These prevented us from running anything beyond pure-Python code on Nanvix and forced the toolchain wrapper to pass -Wl,--allow-shlib-undefined as a workaround, which papered over weak and strong undefined refs alike — defeating the linker's diagnostic value.

After this patch, .sos that exercise any of the above just work, and the toolchain wrapper can stop hiding link-time errors.

What changed

File	Change
src/libs/elf/src/elf32.rs	Add STB_LOCAL / STB_GLOBAL / STB_WEAK constants, ST_BIND_SHIFT, and Elf32Sym::st_bind() accessor.
src/libs/elf/src/relocation.rs	Add typed SymbolBinding enum, Symbol::binding(), Symbol::is_weak(). Unknown bindings fall through to Other so they are never silently treated as weak. Five unit tests cover the helper.
src/libs/syscall/src/dlfcn/syscall/dynlib.rs	(1) In get_symbol_value(), when lookup() == None, return Ok(0) if the referring symbol is SHN_UNDEF and STB_WEAK. Strong undefined refs still error. (2) In query(), skip SHN_UNDEF entries before consulting get_symbol_value() so dladdr() does not report ghost symbols at address 0.

Substituting zero is safe across the relocation types the loader currently implements (R_386_32, R_386_PC32, R_386_JMP_SLOT, R_386_GLOB_DAT): the resulting GOT / PLT entry or in-place 32-bit slot is null, so any code path that actually dereferences the symbol traps deterministically — matching the contract the spec puts on the program (it must null-check before use).

Specification

System V ABI ("gABI"), chapter Symbol Table:

Weak symbols resemble global symbols, but their definitions have lower precedence. [...] Undefined weak symbols do not generate an error if no resolving definition is found at link time, and references take the value zero.

Precedent in mainstream loaders

Every well-known ELF dynamic loader implements this rule. The contract is uniform; only the surrounding code style varies.

• glibc (elf/dl-lookup.c, _dl_lookup_symbol_x): after iterating every scope, if current_value.s == NULL, glibc inspects the reference symbol's binding. If it is STB_WEAK, glibc fills the lookup result with a synthesized sym_val { 0, 0 } and proceeds; otherwise it raises an unresolved-symbol error. The i386 machine-specific reloc handler sysdeps/i386/dl-machine.h writes the resulting zero through R_386_GLOB_DAT / R_386_JMP_SLOT like any other relocation.
• musl (ldso/dynlink.c, find_sym2 and the relocation loop in do_relocs): find_sym2 returns a sentinel with .sym = 0 on lookup failure; the relocation loop then checks ELF_ST_BIND(sym->st_info) == STB_WEAK and skips the error path entirely when the binding is weak.
• FreeBSD rtld-elf (libexec/rtld-elf/rtld.c): find_symdef() returns a sym_zero placeholder for unresolved weak references, populated at rtld startup as a zero-valued symbol. All architecture-specific reloc handlers (reloc.c) treat that placeholder as a normal zero-valued definition.
• Android Bionic (linker/linker_relocate.cpp): lookup_symbol() returns a null sym for unresolved refs, and the relocation loop branches on is_weak. Weak unresolved refs proceed with sym_addr = 0; strong unresolved refs report an error via DL_ERR.

The behaviour we now implement is the intersection of all four: unresolved weak undef → value 0; unresolved strong undef → loader error. Nothing more, nothing less.

Validation

• In-tree unit tests in src/libs/elf/src/relocation.rs::tests cover binding decoding, the Other fallback for unknown bindings, the independence of the binding nibble from the type nibble, and that is_weak() and is_undefined() are orthogonal predicates.

• dlfcn-weak-c regression suite (proposed at [dlfcn] E: Add dlfcn-weak-c tests for STB_WEAK loader semantics posix-tests#1) drives all the observable contract through the public dlfcn API:

  #	Fixture	Reloc	Symbol	Expected
  5	libstrong-missing.so	R_386_JUMP_SLOT	strong_missing	dlopen(RTLD_NOW) fails
  1	libweak-func-resolved.so	R_386_GLOB_DAT	main_callback	resolves to main exe
  2	libweak-func-missing.so	R_386_GLOB_DAT	missing_callback	&fn == NULL
  3	libweak-data-resolved.so	R_386_GLOB_DAT	weak_data	resolves to main exe
  4	libweak-data-missing.so	R_386_GLOB_DAT	missing_weak_data	&data == NULL
  6	libweak-plt-resolved.so	R_386_JUMP_SLOT	main_callback	resolves to main exe
  7	libweak-plt-missing.so	R_386_JUMP_SLOT	missing_plt_callback	dlopen(RTLD_NOW) succeeds (no call)

  Case 5 — the strong-undefined regression guard — runs first and passes both before and after this patch, confirming that strong undef behaviour is unchanged. Cases 1-4 and 6-7 only pass with this patch applied. All 7 pass end-to-end on the Nanvix microvm against this branch.

• CPython 3.12 + numpy 1.26.4 end-to-end: cpython links against libstdc++ (weak pthread_* etc. left unresolved at .so-load time), runs hello.py, then import numpy; numpy.array(...).sum() via dlopen() of the numpy .so family; the test harness prints NUMPY_TEST_OK.

Compatibility

• No public API change. SymbolBinding is new but does not displace any existing helper.
• The pre-existing strong-undef error path is preserved verbatim; only the previously-uniform error is split into "weak undef → 0" and "strong undef → error".
• No change to relocation semantics for resolved symbols.
• dladdr() behaviour improves (no more ghost zero-address symbols from undefined dynsym entries).