[ELF] Parse SHT_GNU_verneed and respect versioned undefined symbols in shared objects

[MaskRay]

Summary

An undefined symbol in a shared object can be versioned, like f@v1.
We currently insert f as an Undefined into the symbol table, but we
should insert f@v1 instead.

The string v1 is inferred from SHT_GNU_versym and SHT_GNU_verneed.
This patch implements the functionality.

Failing to do this can cause two issues:

• If a versioned symbol referenced by a shared object is defined in the executable, we will fail to export it.
• If a versioned symbol referenced by a shared object in another object file, --no-allow-shlib-undefined may spuriously report an "undefined reference to " error. See https://bugs.llvm.org/show_bug.cgi?id=44842 (Linking -lfftw3 -lm on Arch Linux can cause undefined reference to __log_finite)

[grimar]

lld/ELF/InputFiles.cpp

1217

in llvm-readobj?

1219

I have a feeling that this method does too much here.

In llvm-readelf we have the following method:

template <class ELFT>
Expected<std::vector<VerNeed>>
ELFDumper<ELFT>::getVersionDependencies(const Elf_Shdr *Sec) const;

One of possible solutions could be to refactor it and move the logic to ELFFile<ELFT> so that
it could be reused from LLD.

Or, if not, then the code here could be simplified a bit, see my comments below.

1226

I think you can use sec->sh_size?

const uint8_t *secEnd = obj.base() + sec->sh_size;

It should be enough to check that we are not going past the end of the section.

1231

>= I think.

1235

What about introducing a helper lambda:

auto checkBuf = [](const uint8_t *Buf, const Twine& Name) {
  if (B < secEnd && uintptr_t(verneedBuf) % sizeof(uint32_t) == 0)
    return true;
  error(... invalid " + Name + " at ... )
  return false;
}

It should simplify the code a bit I guess.

1253

I am not sure such precise diagnostic is needed for LLD. It could be just: "error parsing SHT_GNU_verneed: broken vna_name" or just "error parsing SHT_GNU_verneed" for all errors here. So you'll be able to use a new helper lambda too.

I think it is imprortant that llvm-readelf/llvm-readobj is able to say what is wrong with the object, but probably no need to overcomplicate the code in LLD to report the details. Alternatively, getVersionDependencies code can be moved to ELFFile<ELFT> and reused, as I've mentioned earlier. With that LLD would report detailed errors, but do not do the parsing on its side.

lld/ELF/InputFiles.h

367

It should probably be protected/private.

[psmith]

Just thinking if it would be possible to resolve this without having to read the verneed section of shared objects. I've not checked to see if this would make a simpler implementation though.

If a versioned symbol referenced by a shared object is defined in the executable, we will fail to export it.
If a versioned symbol referenced by a shared object in another object file, --no-allow-shlib-undefined may spuriously report an "undefined reference to " error. See https://bugs.llvm.org/show_bug.cgi?id=44842 (Linking -lfftw3 -lm on Arch Linux can cause undefined reference to __log_finite)

Reading through https://www.akkadia.org/drepper/symbol-versioning I'm not sure if a versioned symbol being defined by the application is in the spirit of the specification. As I understand it when linking an undefined reference the static linker only binds against the default version, this is then recorded as the version needed. I'm trying to work out if there is ever a case where we could create a shared object that could depend on a versioned definition in an executable as we wouldn't have the symbols from the executable when we create the shared library to record the version needed. I guess matching versioned definitions in the application could be used to preempt/intercept a version defined by a shared library, but that is about all I can think of. Do other linker's and dynamic loaders support this use case?

For a versioned symbol referenced by a shared object, that is defined in another shared object in the link, for the purposes of no-allow-shlib-undefined it could be possible with some loss of accuracy, to resolve it as defined if there were any versioned symbol definitions. This would miss the case where the versions don't match, but this would be diagnosed by the Dynamic Loader, however it wouldn't error for a reference to log_finite from a shared library to log_finite@GLIBC_2.15

[MaskRay]

Address comments

[MaskRay]

lld/ELF/InputFiles.cpp

1231

> makes an unlikely but valid situation (vn_cnt==0) work.

1235

The similar diagnostics occur twice. For checkBuf, we will need:

if (!checkBuf(...))
  return false;

The end result will be longer.

1253

I'll keep the parsing logic in LLD but simplify the diagnostics for now.

[MaskRay]

In D80059#2041478, @psmith wrote:

Just thinking if it would be possible to resolve this without having to read the verneed section of shared objects. I've not checked to see if this would make a simpler implementation though.

Thanks for raising the point. We indeed should think whether there are simpler ways to achieve something. See below, I think we need to have parseVerneed.

If a versioned symbol referenced by a shared object is defined in the executable, we will fail to export it.
If a versioned symbol referenced by a shared object in another object file, --no-allow-shlib-undefined may spuriously report an "undefined reference to " error. See https://bugs.llvm.org/show_bug.cgi?id=44842 (Linking -lfftw3 -lm on Arch Linux can cause undefined reference to __log_finite)

Reading through https://www.akkadia.org/drepper/symbol-versioning I'm not sure if a versioned symbol being defined by the application is in the spirit of the specification. As I understand it when linking an undefined reference the static linker only binds against the default version, this is then recorded as the version needed. I'm trying to work out if there is ever a case where we could create a shared object that could depend on a versioned definition in an executable as we wouldn't have the symbols from the executable when we create the shared library to record the version needed. I guess matching versioned definitions in the application could be used to preempt/intercept a version defined by a shared library, but that is about all I can think of. Do other linker's and dynamic loaders support this use case?

GNU ld exports the preempted symbol and respects -y. We don't currently have the diagnostics (resolveShared does not check Symbol::traced):

echo 'v1 { f; };' > a.ver
echo '.globl f_v1; .symver f_v1,f@v1; f_v1: g:' | as - -o a.o
ld.bfd -shared --version-script a.ver a.o -o a.so
ld.bfd --version-script a.ver a.o a.so -o a.so -y f@v1
# ld.bfd: a.o: definition of f@v1
# ld.bfd: a.so: reference to f@v1   ## we don't have this line
# ld.bfd: warning: cannot find entry symbol _start; defaulting to 0000000000401000

I have checked that the approach is similar to gold's.

For a versioned symbol referenced by a shared object, that is defined in another shared object in the link, for the purposes of no-allow-shlib-undefined it could be possible with some loss of accuracy, to resolve it as defined if there were any versioned symbol definitions. This would miss the case where the versions don't match, but this would be diagnosed by the Dynamic Loader, however it wouldn't error for a reference to log_finite from a shared library to log_finite@GLIBC_2.15

As the patch shows, the SHT_GNU_verneed parsing complexity is surmountable and we can get three things: (1) proper preemption semantics (arguably preemption may not be the desire of the application but the behavior matches GNU ld and gold) (2) proper --no-allow-shlib-undefined (3) making -y __log_finite@GLIBC_2.15 work in a separate change. So I am in favor of doing it.

[MaskRay]

Rename verneed-shared-undefined.s to verneed-shared.s

[MaskRay]

Rebase after D80143

[grimar]

lld/ELF/InputFiles.cpp

1217

It was not addressed. It doesn't read right to me:
"...but do not implement sophisticated error checking in llvm-readobj because..."

I guess you have meant "checking in LLD" or "checking like in llvm-readobj".

1225

This looks a bit cleaner probably:

ArrayRef<uint8_t> data =
    CHECK(obj.template getSectionContentsAsArray<uint8_t>(sec), this);
const uint8_t *verneedBuf = data.begin();

And then you can just inline bufEnd as data.end() I think. See below.

1228

sh_offset for ELF64 is packed<uint>, which is std::conditional_t<Is64, uint64_t, uint32_t>, i.e. it is uint64_t,
so I think size_t is not a right thing here.

1235

I also do not think it is important to use error() for invalid objects. In many places
LLD calls fatal(). Then you can simplify the code. E.g (I've not checked it):

  ArrayRef<uint8_t> data =
      CHECK(obj.template getSectionContentsAsArray<uint8_t>(sec), this);
  const uint8_t *verneedBuf = data.begin();

  auto checkBuf = [&](uint8_t *buf, size_t size, size_t align) {
    if (buf + size > data.end() || uintptr_t(buf) % align != 0)
      fatal(toString(this) + ": unable to parse SHT_GNU_verneed");
    return buf;
  };

  for (unsigned i = 0; i != sec->sh_info; ++i) {
    auto *vn = reinterpret_cast<const typename ELFT::Verneed *>(
        checkBuf(verneedBuf, sizeof(typename ELFT::Verneed), sizeof(uint32_t)));
    const uint8_t *vernauxBuf = verneedBuf + vn->vn_aux;
    for (unsigned j = 0; j != vn->vn_cnt; ++j) {
      auto *aux = reinterpret_cast<const typename ELFT::Vernaux *>(checkBuf(
          vernauxBuf, sizeof(typename ELFT::Vernaux), sizeof(uint32_t)));
      uint16_t version = aux->vna_other & VERSYM_VERSION;
      if (version >= verneeds.size())
        verneeds.resize(version + 1);
      if (aux->vna_name >= this->stringTable.size())
        fatal(toString(this) + ": unable to parse SHT_GNU_verneed");
      verneeds[version] = aux->vna_name;
      vernauxBuf += aux->vna_next;
    }
    verneedBuf += vn->vn_next;
  }
  return verneeds;
}

lld/ELF/Symbols.cpp

717 ↗

(On Diff #264937)

unrelated

[MaskRay]

Address comments

lld/ELF/InputFiles.cpp

1235

Changed error to fatal. This saves 6 lines. A helper checkBuf may still be a bit unnecessary I think. I do want to give a bit more contex (Vernaux parsing error instead of Verneed parsing error).

[grimar]

lld/ELF/InputFiles.cpp

1225

You've missed this one?
Using of getSectionContentsAsArray has benefits:

It would check the sh_offset/sh_size early and might provide a better error message:

ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
...
  uintX_t Offset = Sec->sh_offset;
  uintX_t Size = Sec->sh_size;

...
  if (std::numeric_limits<uintX_t>::max() - Offset < Size)
    return createError("section " + getSecIndexForError(this, Sec) +
                       " has a sh_offset (0x" + Twine::utohexstr(Offset) +
                       ") + sh_size (0x" + Twine::utohexstr(Size) +
                       ") that cannot be represented");
  if (Offset + Size > Buf.size())
    return createError("section " + getSecIndexForError(this, Sec) +
                       " has a sh_offset (0x" + Twine::utohexstr(Offset) +
                       ") + sh_size (0x" + Twine::utohexstr(Size) +
                       ") that is greater than the file size (0x" +
                       Twine::utohexstr(Buf.size()) + ")");

It also hides the calculations done here like obj.base() + sec->sh_offset and
obj.base() + std::min<uint64_t>(sec->sh_offset + sec->sh_size, obj.getBufSize());,
what is good.

[grimar]

lld/ELF/InputFiles.cpp

1225

Ah, and you can actually getSectionContents:

template <class ELFT>
Expected<ArrayRef<uint8_t>>
ELFFile<ELFT>::getSectionContents(const Elf_Shdr *Sec) const {
  return getSectionContentsAsArray<uint8_t>(Sec);
}

[MaskRay]

Use llvm::object::ELFFile::getSectionContents

[grimar]

lld/ELF/InputFiles.cpp

1226

This doesn't look right to me:

1. obj.getSectionContents(sec) returns Expected<ArrayRef<uint8_t>> and you do not handle an error,

the code will fail with LLVM_ENABLE_ABI_BREAKING_CHECKS. Do we have a test for this case?

2. Not sure why you return no entries. This invocation might fail when sh_size or sh_offset is broken.

Shouldn't we call fatal() too?

[MaskRay]

Address comments

lld/ELF/InputFiles.cpp

1226

Sorry, missed this. The first test (ShOffset: 0xFFFFFFFF) tested this scenario. It will indeed break LLVM_ENABLE_ABI_BREAKING_CHECKS` builds (which I can't test now because of some unrelated llvm-tblgen problems)

[grimar]

LGTM, thanks!

lld/ELF/InputFiles.cpp

1226

nit: you probably might want to use CHECK as it often used in LLD:
(looks shorter, and I think will provide exactly the same error output)

ArrayRef<uint8_t> data = CHECK(obj.getSectionContents(sec), this);

[MaskRay]

Use CHECK(...)

lld/ELF/InputFiles.h

public:
   static unsigned vernauxNum;
 
   std::vector<StringRef> dtNeeded;
   std::string soName;
 
   static bool classof(const InputFile *f) { return f->kind() == SharedKind; }
 
   template <typename ELFT> void parse();
 
   // Used for --no-allow-shlib-undefined.
   bool allNeededIsKnown;
 
   // Used for --as-needed
   bool isNeeded;
+
+private:
+  template <typename ELFT>
+  std::vector<uint32_t> parseVerneed(const llvm::object::ELFFile<ELFT> &obj,
+                                     const typename ELFT::Shdr *sec);
 };
 
 class BinaryFile : public InputFile {
 public:
   explicit BinaryFile(MemoryBufferRef m) : InputFile(BinaryKind, m) {}
   static bool classof(const InputFile *f) { return f->kind() == BinaryKind; }
   void parse();
 };

lld/ELF/InputFiles.cpp

for (unsigned i = 0; i != verdefCount; ++i) {
     verdef += curVerdef->vd_next;
     unsigned verdefIndex = curVerdef->vd_ndx;
     verdefs.resize(verdefIndex + 1);
     verdefs[verdefIndex] = curVerdef;
   }
   return verdefs;
 }
 
+// Parse SHT_GNU_verneed to properly set the name of a versioned undefined
+// symbol. We detect fatal issues which would cause vulnerabilities, but do not
+// implement sophisticated error checking like in llvm-readobj because the value
+// of such diagnostics is low.
+template <typename ELFT>
+std::vector<uint32_t> SharedFile::parseVerneed(const ELFFile<ELFT> &obj,
+                                               const typename ELFT::Shdr *sec) {
+  if (!sec)
+    return {};
+  std::vector<uint32_t> verneeds;
+  auto dataOrErr = obj.getSectionContents(sec);
+  if (!dataOrErr)
+    fatal(toString(this) + ": " + toString(dataOrErr.takeError()));
+
+  ArrayRef<uint8_t> data = *dataOrErr;
+  const uint8_t *verneedBuf = data.begin();
+  for (unsigned i = 0; i != sec->sh_info; ++i) {
+    if (verneedBuf + sizeof(typename ELFT::Verneed) > data.end() ||
+        uintptr_t(verneedBuf) % sizeof(uint32_t) != 0)
+      fatal(toString(this) + " has an invalid Verneed");
+    auto *vn = reinterpret_cast<const typename ELFT::Verneed *>(verneedBuf);
+    const uint8_t *vernauxBuf = verneedBuf + vn->vn_aux;
+    for (unsigned j = 0; j != vn->vn_cnt; ++j) {
+      if (vernauxBuf + sizeof(typename ELFT::Vernaux) > data.end() ||
+          uintptr_t(vernauxBuf) % sizeof(uint32_t) != 0)
+        fatal(toString(this) + " has an invalid Vernaux");
+      auto *aux = reinterpret_cast<const typename ELFT::Vernaux *>(vernauxBuf);
+      if (aux->vna_name >= this->stringTable.size())
+        fatal(toString(this) + " has a Vernaux with an invalid vna_name");
+      uint16_t version = aux->vna_other & VERSYM_VERSION;
+      if (version >= verneeds.size())
+        verneeds.resize(version + 1);
+      verneeds[version] = aux->vna_name;
+      vernauxBuf += aux->vna_next;
+    }
+    verneedBuf += vn->vn_next;
+  }
+  return verneeds;
+}
+
 // We do not usually care about alignments of data in shared object
 // files because the loader takes care of it. However, if we promote a
 // DSO symbol to point to .bss due to copy relocation, we need to keep
 // the original alignment requirements. We infer it in this function.
 template <typename ELFT>
 static uint64_t getAlignment(ArrayRef<typename ELFT::Shdr> sections,
                              const typename ELFT::Sym &sym) {
   uint64_t ret = UINT64_MAX;
template <class ELFT> void SharedFile::parse() {
   using Elf_Versym = typename ELFT::Versym;
 
   ArrayRef<Elf_Dyn> dynamicTags;
   const ELFFile<ELFT> obj = this->getObj<ELFT>();
   ArrayRef<Elf_Shdr> sections = CHECK(obj.sections(), this);
 
   const Elf_Shdr *versymSec = nullptr;
   const Elf_Shdr *verdefSec = nullptr;
+  const Elf_Shdr *verneedSec = nullptr;
 
   // Search for .dynsym, .dynamic, .symtab, .gnu.version and .gnu.version_d.
   for (const Elf_Shdr &sec : sections) {
     switch (sec.sh_type) {
     default:
       continue;
     case SHT_DYNAMIC:
       dynamicTags =
           CHECK(obj.template getSectionContentsAsArray<Elf_Dyn>(&sec), this);
       break;
     case SHT_GNU_versym:
       versymSec = &sec;
       break;
     case SHT_GNU_verdef:
       verdefSec = &sec;
       break;
+    case SHT_GNU_verneed:
+      verneedSec = &sec;
+      break;
     }
   }
 
   if (versymSec && numELFSyms == 0) {
     error("SHT_GNU_versym should be associated with symbol table");
     return;
   }
 
template <class ELFT> void SharedFile::parse() {
   // the dependency list.
   it->second->isNeeded |= isNeeded;
   if (!wasInserted)
     return;
 
   sharedFiles.push_back(this);
 
   verdefs = parseVerdefs<ELFT>(obj.base(), verdefSec);
+  std::vector<uint32_t> verneeds = parseVerneed<ELFT>(obj, verneedSec);
 
   // Parse ".gnu.version" section which is a parallel array for the symbol
   // table. If a given file doesn't have a ".gnu.version" section, we use
   // VER_NDX_GLOBAL.
   size_t size = numELFSyms - firstGlobal;
-  std::vector<uint32_t> versyms(size, VER_NDX_GLOBAL);
+  std::vector<uint16_t> versyms(size, VER_NDX_GLOBAL);
   if (versymSec) {
     ArrayRef<Elf_Versym> versym =
         CHECK(obj.template getSectionContentsAsArray<Elf_Versym>(versymSec),
               this)
             .slice(firstGlobal);
     for (size_t i = 0; i < size; ++i)
       versyms[i] = versym[i].vs_index;
   }
for (size_t i = 0; i < syms.size(); ++i) {
     // symbol, that's a violation of the spec.
     StringRef name = CHECK(sym.getName(this->stringTable), this);
     if (sym.getBinding() == STB_LOCAL) {
       warn("found local symbol '" + name +
            "' in global part of symbol table in file " + toString(this));
       continue;
     }
 
+    uint16_t idx = versyms[i] & ~VERSYM_HIDDEN;
     if (sym.isUndefined()) {
+      // For unversioned undefined symbols, VER_NDX_GLOBAL makes more sense but
+      // as of binutils 2.34, GNU ld produces VER_NDX_LOCAL.
+      if (idx != VER_NDX_LOCAL && idx != VER_NDX_GLOBAL) {
+        if (idx >= verneeds.size()) {
+          error("corrupt input file: version need index " + Twine(idx) +
+                " for symbol " + name + " is out of bounds\n>>> defined in " +
+                toString(this));
+          continue;
+        }
+        StringRef verName = this->stringTable.data() + verneeds[idx];
+        versionedNameBuffer.clear();
+        name =
+            saver.save((name + "@" + verName).toStringRef(versionedNameBuffer));
+      }
       Symbol *s = symtab->addSymbol(
           Undefined{this, name, sym.getBinding(), sym.st_other, sym.getType()});
       s->exportDynamic = true;
       continue;
     }
 
     // MIPS BFD linker puts _gp_disp symbol into DSO files and incorrectly
     // assigns VER_NDX_LOCAL to this section global symbol. Here is a
     // workaround for this bug.
-    uint32_t idx = versyms[i] & ~VERSYM_HIDDEN;
     if (config->emachine == EM_MIPS && idx == VER_NDX_LOCAL &&
         name == "_gp_disp")
       continue;
 
     uint32_t alignment = getAlignment<ELFT>(sections, sym);
     if (!(versyms[i] & VERSYM_HIDDEN)) {
       symtab->addSymbol(SharedSymbol{*this, name, sym.getBinding(),
                                      sym.st_other, sym.getType(), sym.st_value,

lld/test/ELF/invalid/verneed-shared.yaml

+## REQUIRES: x86
+## Test that we can parse SHT_GNU_verneed in a shared object and report certain errors.
+
+# RUN: echo '.globl _start; _start:' | llvm-mc -filetype=obj -triple=x86_64 - -o %t.o
+
+## sh_offset(SHT_GNU_verneed) is out of bounds.
+# RUN: yaml2obj --docnum=1 %s -o %t1.so
+# RUN: not ld.lld %t.o %t1.so -o /dev/null 2>&1 | FileCheck --check-prefix=SHOFFSET %s
+# SHOFFSET: error: {{.*}}.so: section [index 1] has a sh_offset (0xffffffff) + sh_size (0x0) that is greater than the file size (0x228)
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.version_r
+    Type:  SHT_GNU_verneed
+    Flags: [ SHF_ALLOC ]
+    ShOffset: 0xFFFFFFFF
+
+## A Verneed entry is misaligned (not a multiple of 4).
+# RUN: yaml2obj --docnum=2 %s -o %t2.so
+# RUN: not ld.lld %t.o %t2.so -o /dev/null 2>&1 | FileCheck --check-prefix=VN-MISALIGNED %s
+# VN-MISALIGNED: {{.*}}.so has an invalid Verneed
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type: Fill
+    Size: 0x1
+  - Name:  .gnu.version_r
+    Type:  SHT_GNU_verneed
+    Flags: [ SHF_ALLOC ]
+    Info:  1
+    Link:  .dynstr
+    Dependencies:
+      - Version: 1
+        File:    foo
+        Entries:
+          - Name:  'foo'
+            Hash:  0
+            Flags: 0
+            Other: 0
+DynamicSymbols:
+  - Name: foo
+
+## vn_aux points to a place outside of the file.
+# RUN: yaml2obj --docnum=3 -D VERNEED=0100010001000000040200000000000000000000 %s -o %t3.so
+# RUN: not ld.lld %t.o %t3.so -o /dev/null 2>&1 | FileCheck --check-prefix=AUX-OOB %s
+# AUX-OOB: {{.*}}.so has an invalid Vernaux
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.version_r
+    Type:  SHT_GNU_verneed
+    Flags: [ SHF_ALLOC ]
+    Info:  1
+    Link:  .dynstr
+    Content: "[[VERNEED]]"
+DynamicSymbols:
+  - Name: foo
+
+## vn_aux is misaligned.
+# RUN: yaml2obj --docnum=3 -D VERNEED=0100010001000000110000000000000000000000 %s -o %t4.so
+# RUN: not ld.lld %t.o %t4.so -o /dev/null 2>&1 | FileCheck --check-prefix=AUX-MISALIGNED %s
+# AUX-MISALIGNED: {{.*}}.so has an invalid Vernaux
+
+## vna_name is out of bounds.
+# RUN: yaml2obj --docnum=3 -D VERNEED=010001000000000010000000000000009107000000000000ff00000000000000 %s -o %t5.so
+# RUN: not ld.lld %t.o %t5.so -o /dev/null 2>&1 | FileCheck --check-prefix=NAME-OOB %s
+# NAME-OOB: {{.*}}.so has a Vernaux with an invalid vna_name

lld/test/ELF/verneed-shared.s

+# REQUIRES: x86
+# RUN: echo 'v1 { f; }; v2 { g; };' > %t.ver
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: ld.lld -shared --version-script %t.ver %t.o -o %t.so
+
+# RUN: ld.lld --version-script %t.ver %t.o %t.so -o /dev/null -y f@v1 | \
+# RUN:   FileCheck --check-prefix=TRACE %s --implicit-check-not=f@v1
+
+## TRACE:      {{.*}}.o: definition of f@v1
+## TRACE-NEXT: {{.*}}.so: shared definition of f@v1
+
+# RUN: echo '.symver f,f@v1; .symver g,g@v2; call f; call g' | \
+# RUN:   llvm-mc -filetype=obj -triple=x86_64 - -o %t1.o
+# RUN: ld.lld -shared %t1.o %t.so -o %t1.so
+
+## Test that we can parse SHT_GNU_verneed to know that the undefined symbols in
+## %t1.so are called 'f@v1' and 'g@v2', which can be satisfied by the executable.
+## We will thus export the symbols.
+# RUN: ld.lld -pie %t.o %t1.so -o %t
+# RUN: llvm-nm -D %t | FileCheck --check-prefix=NM %s
+
+# NM: T f
+# NM: T g
+
+## The default is --no-allow-shlib-undefined.
+## Don't error because undefined symbols in %t1.so are satisfied by %t.so
+# RUN: llvm-mc -filetype=obj -triple=x86_64 /dev/null -o %t2.o
+# RUN: ld.lld %t2.o %t1.so %t.so -y f@v1 -o /dev/null | FileCheck %s
+
+# CHECK:      {{.*}}1.so: reference to f@v1
+# CHECK-NEXT: {{.*}}.so: shared definition of f@v1
+
+.globl f_v1, g_v2
+.symver f_v1,f@v1
+.symver g_v2,g@v2
+f_v1:
+g_v2: