Don't drop DSO undef references when versym is VER_NDX_LOCAL

Commit 6b8293b changed the early `ver` computation in
SharedFile::parse so that undef symbols use the raw versym instead
of being forced to VER_NDX_GLOBAL. Some BFD ld versions (notably
binutils 2.35 on Debian 11) emit VER_NDX_LOCAL (0) as the versym
for unversioned undefined dynamic symbols, so the subsequent
`if (ver == VER_NDX_LOCAL) continue;` check silently dropped those
undef references. With the DSO's reference invisible to mold, the
matching object-file definition was never marked as exported, and
at runtime the dynamic loader failed with "undefined symbol".

Restore the old behavior: defined symbols with VER_NDX_LOCAL are
still skipped (they aren't really exposed for dynamic linking),
but undef references are always processed.

Also fix the verdef/verneed merge in the same path. vd_ndx and
vna_other share a single versym index space (a producing linker
assigns them from one counter), so a single vector covers both.
read_verdef and read_verneed are folded into one read_version_strings
that populates that shared-index vector directly, replacing the
buggy `append` concatenation.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rui314

src/input-files.cc

@@ -1260,8 +1260,7 @@ void SharedFile<E>::parse(Context<E> &ctx) {
 
   this->symbol_strtab = this->get_string(ctx, symtab_sec->sh_link);
   soname = get_soname(ctx);
-  version_strings = read_verdef(ctx);
-  append(version_strings, read_verneed(ctx));
+  version_strings = read_version_strings(ctx);
 
   // Read a symbol table.
   std::span<ElfSym<E>> esyms = this->template get_data<ElfSym<E>>(ctx, *symtab_sec);
@@ -1271,20 +1270,21 @@ void SharedFile<E>::parse(Context<E> &ctx) {
     vers = this->template get_data<U16<E>>(ctx, *sec);
 
   for (i64 i = symtab_sec->sh_info; i < esyms.size(); i++) {
-    u16 ver;
-    if (vers.empty())
-      ver = VER_NDX_GLOBAL;
-    else
-      ver = vers[i] & ~VERSYM_HIDDEN;
-
-    if (ver == VER_NDX_LOCAL)
+    u16 ver = vers.empty() ? VER_NDX_GLOBAL : (vers[i] & ~VERSYM_HIDDEN);
+
+    // A defined symbol with VER_NDX_LOCAL is bound locally and isn't
+    // really exposed for dynamic linking; skip it. We never skip
+    // undefined references — the dynamic loader doesn't distinguish
+    // local vs global on the undef side, and dropping them would hide
+    // the DSO's reference from us.
+    if (ver == VER_NDX_LOCAL && !esyms[i].is_undef())
       continue;
 
     this->elf_syms2.push_back(esyms[i]);
-    // Defined symbols index into verdef; undefined symbols index into
-    // verneed. We record VER_NDX_GLOBAL for undefined symbols here
-    // because resolve_symbols only consults versyms[] for defined
-    // symbols (see SharedFile::resolve_symbols).
+
+    // resolve_symbols only consults versyms[] for defined symbols
+    // (see SharedFile::resolve_symbols), so VER_NDX_GLOBAL is fine
+    // for undefined entries.
     this->versyms.push_back(esyms[i].is_undef() ? (u16)VER_NDX_GLOBAL : ver);
 
     std::string_view name = this->symbol_strtab.data() + esyms[i].st_name;
@@ -1384,67 +1384,61 @@ std::string_view SharedFile<E>::get_dt_audit(Context<E> &ctx) {
 // If an undefiend symbol `foo` is resolved to a symbol defined by the
 // shared object, it's marked so that it'll be resolved to (`foo`, the
 // default version of the library) at load-time.
+//
+// Reads .gnu.version_d and .gnu.version_r and returns a vector of
+// version names indexed by versym value. The versym index space is
+// shared between the two sections (vd_ndx for defined symbols and
+// vna_other for undefined ones), so a single vector covers both.
 template <typename E>
-std::vector<std::string_view> SharedFile<E>::read_verdef(Context<E> &ctx) {
-  ElfShdr<E> *verdef_sec = this->find_section(SHT_GNU_VERDEF);
-  if (!verdef_sec)
-    return {};
-
-  std::string_view verdef = this->get_string(ctx, *verdef_sec);
-  std::string_view strtab = this->get_string(ctx, verdef_sec->sh_link);
-
+std::vector<std::string_view>
+SharedFile<E>::read_version_strings(Context<E> &ctx) {
   std::vector<std::string_view> vec;
-  u8 *ptr = (u8 *)verdef.data();
 
-  for (;;) {
-    ElfVerdef<E> *ver = (ElfVerdef<E> *)ptr;
-    if (ver->vd_ndx == VER_NDX_UNSPECIFIED)
-      Fatal(ctx) << *this << ": symbol version too large";
+  if (ElfShdr<E> *sec = this->find_section(SHT_GNU_VERDEF)) {
+    std::string_view verdef = this->get_string(ctx, *sec);
+    std::string_view strtab = this->get_string(ctx, sec->sh_link);
+    u8 *ptr = (u8 *)verdef.data();
 
-    if (vec.size() <= ver->vd_ndx)
-      vec.resize(ver->vd_ndx + 1);
+    for (;;) {
+      ElfVerdef<E> *ver = (ElfVerdef<E> *)ptr;
+      if (ver->vd_ndx == VER_NDX_UNSPECIFIED)
+        Fatal(ctx) << *this << ": symbol version too large";
 
-    ElfVerdaux<E> *aux = (ElfVerdaux<E> *)(ptr + ver->vd_aux);
-    vec[ver->vd_ndx] = strtab.data() + aux->vda_name;
-    if (!ver->vd_next)
-      break;
-    ptr += ver->vd_next;
-  }
-  return vec;
-}
+      if (vec.size() <= ver->vd_ndx)
+        vec.resize(ver->vd_ndx + 1);
 
-// Reads .gnu.version_r and returns a vector of version names indexed
-// by vna_other. .gnu.version_r records the versions a shared object
-// needs from the libraries it depends on; the versym of an undefined
-// dynamic symbol indexes into these entries.
-template <typename E>
-std::vector<std::string_view> SharedFile<E>::read_verneed(Context<E> &ctx) {
-  ElfShdr<E> *verneed_sec = this->find_section(SHT_GNU_VERNEED);
-  if (!verneed_sec)
-    return {};
+      ElfVerdaux<E> *aux = (ElfVerdaux<E> *)(ptr + ver->vd_aux);
+      vec[ver->vd_ndx] = strtab.data() + aux->vda_name;
+      if (!ver->vd_next)
+        break;
+      ptr += ver->vd_next;
+    }
+  }
 
-  std::vector<std::string_view> vec;
-  std::string_view verneed = this->get_string(ctx, *verneed_sec);
-  std::string_view strtab = this->get_string(ctx, verneed_sec->sh_link);
-
-  u8 *ptr = (u8 *)verneed.data();
-  for (;;) {
-    ElfVerneed<E> *vn = (ElfVerneed<E> *)ptr;
-    u8 *aux_ptr = ptr + vn->vn_aux;
-    for (i64 i = 0; i < vn->vn_cnt; i++) {
-      ElfVernaux<E> *aux = (ElfVernaux<E> *)aux_ptr;
-      u16 idx = aux->vna_other & ~VERSYM_HIDDEN;
-      if (vec.size() <= idx)
-        vec.resize(idx + 1);
-      vec[idx] = strtab.data() + aux->vna_name;
-      if (!aux->vna_next)
+  if (ElfShdr<E> *sec = this->find_section(SHT_GNU_VERNEED)) {
+    std::string_view verneed = this->get_string(ctx, *sec);
+    std::string_view strtab = this->get_string(ctx, sec->sh_link);
+    u8 *ptr = (u8 *)verneed.data();
+
+    for (;;) {
+      ElfVerneed<E> *vn = (ElfVerneed<E> *)ptr;
+      u8 *aux_ptr = ptr + vn->vn_aux;
+      for (i64 i = 0; i < vn->vn_cnt; i++) {
+        ElfVernaux<E> *aux = (ElfVernaux<E> *)aux_ptr;
+        u16 idx = aux->vna_other & ~VERSYM_HIDDEN;
+        if (vec.size() <= idx)
+          vec.resize(idx + 1);
+        vec[idx] = strtab.data() + aux->vna_name;
+        if (!aux->vna_next)
+          break;
+        aux_ptr += aux->vna_next;
+      }
+      if (!vn->vn_next)
         break;
-      aux_ptr += aux->vna_next;
+      ptr += vn->vn_next;
     }
-    if (!vn->vn_next)
-      break;
-    ptr += vn->vn_next;
   }
+
   return vec;
 }
 

src/mold.h

@@ -1850,8 +1850,7 @@ class SharedFile : public InputFile<E> {
   std::string get_soname(Context<E> &ctx);
   void maybe_override_symbol(Symbol<E> &sym, const ElfSym<E> &esym);
   std::vector<std::string_view> read_dt_needed(Context<E> &ctx);
-  std::vector<std::string_view> read_verdef(Context<E> &ctx);
-  std::vector<std::string_view> read_verneed(Context<E> &ctx);
+  std::vector<std::string_view> read_version_strings(Context<E> &ctx);
 
   std::vector<u16> versyms;
   const ElfShdr<E> *symtab_sec;