ELF: Implement basic support for --version-script.

[pcc]

Summary

This patch only implements support for version scripts of the form:

{ [ global: symbol1; symbol2; [...]; symbolN; ] local: *; };

No wildcards are supported, other than for the local entry. Symbol versioning
is also not supported.

It works by introducing a new Symbol flag which tracks whether a symbol
appears in the global section of a version script.

This patch also simplifies the logic in SymbolBody::isPreemptible(), and
teaches it to handle the case where symbols with default visibility in DSOs
do not appear in the dynamic symbol table because of a version script.

Fixes PR27482.

[pcc]

• Remove an unused #include.

[ruiu]

LGTM. This is looking nice. A few minor comments below.

ELF/Config.h

15 ↗

(On Diff #54701)

You are not using this.

ELF/Driver.cpp

149–157 ↗

(On Diff #54701)

I'd inline these functions.

ELF/SymbolListFile.cpp

83–95 ↗

(On Diff #54701)

I think this is slightly more readable.

if (peek() == "global:") {
  next();
  while (!Error) {
    Config->VersionScriptGlobals.push_back(next());
    expect(";");
    if (peek() == "local:")
      break;
  }
}
expect("local:");

lld/trunk/ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_lld_library(lldELF
   Driver.cpp
   DriverUtils.cpp
-  DynamicList.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MarkLive.cpp
   OutputSections.cpp
   ScriptParser.cpp
+  SymbolListFile.cpp
   SymbolTable.cpp
   Symbols.cpp
   Target.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Analysis

lld/trunk/ELF/Config.h

struct Configuration {
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> DynamicList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
+  std::vector<llvm::StringRef> VersionScriptGlobals;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool Demangle = true;
   bool DisableVerify;
   bool DiscardAll;
   bool DiscardValueNames;
struct Configuration {
   bool Shared;
   bool Static = false;
   bool StripAll;
   bool StripDebug;
   bool SysvHash = true;
   bool Threads;
   bool Trace;
   bool Verbose;
+  bool VersionScript;
   bool WarnCommon;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;

lld/trunk/ELF/Driver.h

public:
   void main(ArrayRef<const char *> Args);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
 
 private:
   std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef MB);
   llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
   void readConfigs(llvm::opt::InputArgList &Args);
-  void readDynamicList(StringRef Path);
   void createFiles(llvm::opt::InputArgList &Args);
   template <class ELFT> void link(llvm::opt::InputArgList &Args);
 
   // True if we are in --whole-archive and --no-whole-archive.
   bool WholeArchive = false;
 
   // True if we are in --start-lib and --end-lib.
   bool InLib = false;

lld/trunk/ELF/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
-#include "DynamicList.h"
 #include "Error.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "LinkerScript.h"
+#include "SymbolListFile.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Driver/Driver.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
Optional<MemoryBufferRef> LinkerDriver::readFile(StringRef Path) {
   if (HasError)
     return None;
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take MB ownership
   return MBRef;
 }
 
-void LinkerDriver::readDynamicList(StringRef Path) {
-  if (Optional<MemoryBufferRef> Buffer = readFile(Path))
-    parseDynamicList(*Buffer);
-}
-
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   std::string Path = searchLibrary(Name);
   if (Path.empty())
     error("unable to find library -l" + Name);
   else
     addFile(Path);
 }
if (auto *Arg = Args.getLastArg(OPT_build_id_eq)) {
     } else
       error("unknown --build-id style: " + S);
   }
 
   for (auto *Arg : Args.filtered(OPT_undefined))
     Config->Undefined.push_back(Arg->getValue());
 
   if (Args.hasArg(OPT_dynamic_list))
-    readDynamicList(getString(Args, OPT_dynamic_list));
+    if (Optional<MemoryBufferRef> Buffer =
+            readFile(getString(Args, OPT_dynamic_list)))
+      parseDynamicList(*Buffer);
 
   for (auto *Arg : Args.filtered(OPT_export_dynamic_symbol))
     Config->DynamicList.push_back(Arg->getValue());
+
+  Config->VersionScript = Args.hasArg(OPT_version_script);
+  if (Config->VersionScript)
+    if (Optional<MemoryBufferRef> Buffer =
+            readFile(getString(Args, OPT_version_script)))
+      parseVersionScript(*Buffer);
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_l:
       addLibrary(Arg->getValue());
       break;
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   if (HasError)
     return; // There were duplicate symbols or incompatible files
 
   for (StringRef S : Config->Undefined)
     Symtab.addUndefinedOpt(S);
 
   Symtab.scanShlibUndefined();
   Symtab.scanDynamicList();
+  Symtab.scanVersionScript();
 
   Symtab.addCombinedLtoObject();
 
   for (auto *Arg : Args.filtered(OPT_wrap))
     Symtab.wrap(Arg->getValue());
 
   // Write the result to the file.
   if (Config->GcSections)
     markLive<ELFT>(&Symtab);
   if (Config->ICF)
     doIcf<ELFT>(&Symtab);
   writeResult<ELFT>(&Symtab);
 }

lld/trunk/ELF/DynamicList.h

-//===- DynamicList.h --------------------------------------------*- C++ -*-===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_ELF_DYNAMIC_LIST_H
-#define LLD_ELF_DYNAMIC_LIST_H
-
-#include "lld/Core/LLVM.h"
-#include "llvm/Support/MemoryBuffer.h"
-
-namespace lld {
-namespace elf {
-
-void parseDynamicList(MemoryBufferRef MB);
-
-} // namespace elf
-} // namespace lld
-
-#endif

lld/trunk/ELF/DynamicList.cpp

-//===- LinkerScript.cpp ---------------------------------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains the parser/evaluator of the linker script.
-// It does not construct an AST but consume linker script directives directly.
-// Results are written to Driver or Config object.
-//
-//===----------------------------------------------------------------------===//
-
-#include "DynamicList.h"
-#include "Config.h"
-#include "ScriptParser.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
-
-using namespace llvm;
-using namespace lld;
-using namespace lld::elf;
-
-// Parse the --dynamic-list argument.  A dynamic list is in the form
-//
-//  { symbol1; symbol2; [...]; symbolN };
-//
-// Multiple groups can be defined in the same file and they are merged
-// in only one definition.
-
-class DynamicListParser final : public ScriptParserBase {
-public:
-  DynamicListParser(StringRef S) : ScriptParserBase(S) {}
-
-  void run() override;
-
-private:
-  void readGroup();
-};
-
-// Parse the default group definition using C language symbol name.
-void DynamicListParser::readGroup() {
-  expect("{");
-  while (!Error) {
-    Config->DynamicList.push_back(next());
-    expect(";");
-    if (peek() == "}") {
-      next();
-      break;
-    }
-  }
-  expect(";");
-}
-
-void DynamicListParser::run() {
-  while (!atEOF())
-    readGroup();
-}
-
-void elf::parseDynamicList(MemoryBufferRef MB) {
-  DynamicListParser(MB.getBuffer()).run();
-}

lld/trunk/ELF/Options.td

 def undefined : Joined<["--"], "undefined=">,
   HelpText<"Force undefined symbol during linking">;
 
 def verbose : Flag<["--"], "verbose">;
 
 def version : Flag<["--", "-"], "version">,
   HelpText<"Display the version number">;
 
+def version_script : Separate<["--", "-"], "version-script">,
+  HelpText<"Read a version script">;
+
 def warn_common : Flag<["--", "-"], "warn-common">,
   HelpText<"Warn about duplicate common symbols">;
 
 def whole_archive : Flag<["--", "-"], "whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
 def wrap : Separate<["--", "-"], "wrap">, MetaVarName<"<symbol>">,
   HelpText<"Use wrapper functions for symbol">;

 def no_copy_dt_needed_entries : Flag<["--"], "no-copy-dt-needed-entries">,
                                 Alias<no_add_needed>;
 def no_dynamic_linker : Flag<["--"], "no-dynamic-linker">;
 def no_fatal_warnings : Flag<["--"], "no-fatal-warnings">;
 def no_warn_common : Flag<["--", "-"], "no-warn-common">;
 def no_warn_mismatch : Flag<["--"], "no-warn-mismatch">;
 def rpath_link : Separate<["--", "-"], "rpath-link">;
 def rpath_link_eq : Joined<["--", "-"], "rpath-link=">;
-def version_script : Separate<["--"], "version-script">;
 def warn_execstack : Flag<["--"], "warn-execstack">;
 def warn_shared_textrel : Flag<["--"], "warn-shared-textrel">;
 def G : Separate<["-"], "G">;
 
 // Aliases for ignored options
 def alias_version_script_version_script : Joined<["--"], "version-script=">, Alias<version_script>;
 
 // LTO-related options.
 def lto_no_discard_value_names : Flag<["-"], "lto-no-discard-value-names">;
 def lto_jobs : Joined<["--"], "lto-jobs=">,
   HelpText<"Number of threads to run codegen">;
 def disable_verify : Flag<["-"], "disable-verify">;
 def mllvm : Separate<["-"], "mllvm">;
 def save_temps : Flag<["-"], "save-temps">;

lld/trunk/ELF/SymbolListFile.h

+//===- SymbolListFile.h -----------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_ELF_SYMBOL_LIST_FILE_H
+#define LLD_ELF_SYMBOL_LIST_FILE_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace lld {
+namespace elf {
+
+void parseDynamicList(MemoryBufferRef MB);
+void parseVersionScript(MemoryBufferRef MB);
+
+} // namespace elf
+} // namespace lld
+
+#endif

lld/trunk/ELF/SymbolListFile.cpp

+//===- SymbolListFile.cpp -------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the parser/evaluator of the linker script.
+// It does not construct an AST but consume linker script directives directly.
+// Results are written to Driver or Config object.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SymbolListFile.h"
+#include "Config.h"
+#include "ScriptParser.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+
+using namespace llvm;
+using namespace lld;
+using namespace lld::elf;
+
+// Parse the --dynamic-list argument.  A dynamic list is in the form
+//
+//  { symbol1; symbol2; [...]; symbolN };
+//
+// Multiple groups can be defined in the same file and they are merged
+// in only one definition.
+
+class DynamicListParser final : public ScriptParserBase {
+public:
+  DynamicListParser(StringRef S) : ScriptParserBase(S) {}
+
+  void run() override;
+
+private:
+  void readGroup();
+};
+
+// Parse the default group definition using C language symbol name.
+void DynamicListParser::readGroup() {
+  expect("{");
+  while (!Error) {
+    Config->DynamicList.push_back(next());
+    expect(";");
+    if (peek() == "}") {
+      next();
+      break;
+    }
+  }
+  expect(";");
+}
+
+void DynamicListParser::run() {
+  while (!atEOF())
+    readGroup();
+}
+
+void elf::parseDynamicList(MemoryBufferRef MB) {
+  DynamicListParser(MB.getBuffer()).run();
+}
+
+// Parse the --version-script argument. We currently only accept the following
+// version script syntax:
+//
+//  { [ global: symbol1; symbol2; [...]; symbolN; ] local: *; };
+//
+// No wildcards are supported, other than for the local entry. Symbol versioning
+// is also not supported.
+
+class VersionScriptParser final : public ScriptParserBase {
+public:
+  VersionScriptParser(StringRef S) : ScriptParserBase(S) {}
+
+  void run() override;
+};
+
+void VersionScriptParser::run() {
+  expect("{");
+  if (peek() == "global:") {
+    next();
+    while (!Error) {
+      Config->VersionScriptGlobals.push_back(next());
+      expect(";");
+      if (peek() == "local:")
+        break;
+    }
+  }
+  expect("local:");
+  expect("*");
+  expect(";");
+  expect("}");
+  expect(";");
+  if (!atEOF())
+    setError("expected EOF");
+}
+
+void elf::parseVersionScript(MemoryBufferRef MB) {
+  VersionScriptParser(MB.getBuffer()).run();
+}

lld/trunk/ELF/SymbolTable.h

DefinedRegular<ELFT> *addAbsolute(StringRef Name,
                                     uint8_t Visibility = llvm::ELF::STV_HIDDEN);
   SymbolBody *addSynthetic(StringRef Name, OutputSectionBase<ELFT> &Section,
                            uintX_t Value);
   DefinedRegular<ELFT> *addIgnored(StringRef Name,
                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
   void scanShlibUndefined();
   void scanDynamicList();
+  void scanVersionScript();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);
   InputFile *findFile(SymbolBody *B);
 
 private:
   Symbol *insert(SymbolBody *New);
   void addLazy(Lazy *New);
   void addMemberFile(SymbolBody *Undef, Lazy *L);

lld/trunk/ELF/SymbolTable.cpp

 
 // Find an existing symbol or create and insert a new one.
 template <class ELFT> Symbol *SymbolTable<ELFT>::insert(SymbolBody *New) {
   StringRef Name = New->getName();
   unsigned NumSyms = SymVector.size();
   auto P = Symtab.insert(std::make_pair(Name, NumSyms));
   Symbol *Sym;
   if (P.second) {
-    Sym = new (Alloc) Symbol{New, STV_DEFAULT, false, false};
+    Sym = new (Alloc) Symbol;
+    Sym->Body = New;
+    Sym->Visibility = STV_DEFAULT;
+    Sym->IsUsedInRegularObj = false;
+    Sym->ExportDynamic = false;
+    Sym->VersionScriptGlobal = !Config->VersionScript;
     SymVector.push_back(Sym);
   } else {
     Sym = SymVector[P.first->second];
   }
   New->Backref = Sym;
 
   // Merge in the new symbol's visibility. DSO symbols do not affect visibility
   // in the output.

 // This function process the dynamic list option by marking all the symbols
 // to be exported in the dynamic table.
 template <class ELFT> void SymbolTable<ELFT>::scanDynamicList() {
   for (StringRef S : Config->DynamicList)
     if (SymbolBody *B = find(S))
       B->Backref->ExportDynamic = true;
 }
 
+// This function processes the --version-script option by marking all global
+// symbols with the VersionScriptGlobal flag, which acts as a filter on the
+// dynamic symbol table.
+template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
+  for (StringRef S : Config->VersionScriptGlobals)
+    if (SymbolBody *B = find(S))
+      B->Backref->VersionScriptGlobal = true;
+}
+
 template class elf::SymbolTable<ELF32LE>;
 template class elf::SymbolTable<ELF32BE>;
 template class elf::SymbolTable<ELF64LE>;
 template class elf::SymbolTable<ELF64BE>;

lld/trunk/ELF/Symbols.h

struct Symbol {
   unsigned IsUsedInRegularObj : 1;
 
   // If this flag is true and the symbol has protected or default visibility, it
   // will appear in .dynsym. This flag is set by interposable DSO symbols in
   // executables, by most symbols in DSOs and executables built with
   // --export-dynamic, and by dynamic lists.
   unsigned ExportDynamic : 1;
 
+  // This flag acts as an additional filter on the dynamic symbol list. It is
+  // set if there is no version script, or if the symbol appears in the global
+  // section of the version script.
+  unsigned VersionScriptGlobal : 1;
+
   bool includeInDynsym() const;
 };
 
 // The base class for real symbol classes.
 class SymbolBody {
   void init();
 
 public:

lld/trunk/ELF/Symbols.cpp

 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
 bool SymbolBody::isPreemptible() const {
   if (isLocal())
     return false;
 
+  // Shared symbols resolve to the definition in the DSO.
   if (isShared())
     return true;
 
-  if (Backref->Visibility != STV_DEFAULT)
+  // That's all that can be preempted in a non-DSO.
+  if (!Config->Shared)
     return false;
 
-  if (isUndefined()) {
-    if (!isWeak())
-      return true;
-
-    // Ideally the static linker should see a definition for every symbol, but
-    // shared object are normally allowed to have undefined references that the
-    // static linker never sees a definition for.
-    if (Config->Shared)
-      return true;
+  // Undefined symbols in DSOs can only be preempted if they are strong.
+  // Weak symbols just resolve to zero.
+  if (isUndefined())
+    return !isWeak();
 
-    // Otherwise, just resolve to 0.
-    return false;
-  }
-
-  if (!Config->Shared)
-    return false;
+  // -Bsymbolic means that not even default visibility symbols can be preempted.
   if (Config->Bsymbolic || (Config->BsymbolicFunctions && isFunc()))
     return false;
-  return true;
+
+  // Only default visibility symbols that appear in the dynamic symbol table can
+  // be preempted.
+  return Backref->Visibility == STV_DEFAULT && Backref->includeInDynsym();
 }
 
 template <class ELFT>
 typename ELFT::uint SymbolBody::getVA(typename ELFT::uint Addend) const {
   typename ELFT::uint OutVA = getSymVA<ELFT>(*this, Addend);
   return OutVA + Addend;
 }
 
#else
   free(Buf);
   return S;
 #endif
 }
 
 bool Symbol::includeInDynsym() const {
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return false;
-  return ExportDynamic || Body->isShared();
+  return (ExportDynamic && VersionScriptGlobal) || Body->isShared();
 }
 
 template uint32_t SymbolBody::template getVA<ELF32LE>(uint32_t) const;
 template uint32_t SymbolBody::template getVA<ELF32BE>(uint32_t) const;
 template uint64_t SymbolBody::template getVA<ELF64LE>(uint64_t) const;
 template uint64_t SymbolBody::template getVA<ELF64BE>(uint64_t) const;
 
 template uint32_t SymbolBody::template getGotVA<ELF32LE>() const;

lld/trunk/test/ELF/lto/internalize-version-script.ll

+; REQUIRES: x86
+; RUN: llvm-as %s -o %t.o
+; RUN: echo "{ global: foo; local: *; };" > %t.script
+; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -shared --version-script %t.script -save-temps
+; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+
+target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @foo() {
+  ret void
+}
+
+define void @bar() {
+  ret void
+}
+
+; Check that foo is not internalized.
+; CHECK: define void @foo()
+
+; Check that bar is correctly internalized.
+; CHECK: define internal void @bar()

lld/trunk/test/ELF/no-inhibit-exec.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o %t2
 # RUN: ld.lld %t --noinhibit-exec -o %t2
 # RUN: llvm-objdump -d %t2 | FileCheck %s
 # REQUIRES: x86
 
 # CHECK: Disassembly of section .text:
 # CHECK-NEXT: _start
-# CHECK-NEXT: 11000:   e8 00 00 00 00  callq   0
+# CHECK-NEXT: 11000:   e8 fb ef fe ff callq -69637
 
 # next code will not link without noinhibit-exec flag
 # because of undefined symbol _bar
 .globl _start;
 _start:
   call _bar

lld/trunk/test/ELF/version-script.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
+# RUN: ld.lld -shared %t2.o -soname shared -o %t2.so
+
+# RUN: echo "{ global: foo1; foo3; local: *; };" > %t.script
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld --version-script %t.script -shared %t.o %t2.so -o %t.so
+# RUN: llvm-readobj -dyn-symbols %t.so | FileCheck --check-prefix=DSO %s
+
+# RUN: echo "{ local: *; };" > %t3.script
+# RUN: ld.lld --version-script %t3.script -shared %t.o %t2.so -o %t3.so
+# RUN: llvm-readobj -dyn-symbols %t3.so | FileCheck --check-prefix=DSO2 %s
+
+# --version-script filters --dynamic-list.
+# RUN: echo "{ foo1; foo2; };" > %t.list
+# RUN: ld.lld --version-script %t.script --dynamic-list %t.list %t.o %t2.so -o %t
+# RUN: llvm-readobj -dyn-symbols %t | FileCheck --check-prefix=EXE %s
+
+# DSO:      DynamicSymbols [
+# DSO-NEXT:   Symbol {
+# DSO-NEXT:     Name: @ (0)
+# DSO-NEXT:     Value: 0x0
+# DSO-NEXT:     Size: 0
+# DSO-NEXT:     Binding: Local (0x0)
+# DSO-NEXT:     Type: None (0x0)
+# DSO-NEXT:     Other: 0
+# DSO-NEXT:     Section: Undefined (0x0)
+# DSO-NEXT:   }
+# DSO-NEXT:   Symbol {
+# DSO-NEXT:     Name: bar@ (1)
+# DSO-NEXT:     Value: 0x0
+# DSO-NEXT:     Size: 0
+# DSO-NEXT:     Binding: Global (0x1)
+# DSO-NEXT:     Type: Function (0x2)
+# DSO-NEXT:     Other: 0
+# DSO-NEXT:     Section: Undefined (0x0)
+# DSO-NEXT:   }
+# DSO-NEXT:   Symbol {
+# DSO-NEXT:     Name: foo1@ (5)
+# DSO-NEXT:     Value: 0x1000
+# DSO-NEXT:     Size: 0
+# DSO-NEXT:     Binding: Global (0x1)
+# DSO-NEXT:     Type: None (0x0)
+# DSO-NEXT:     Other: 0
+# DSO-NEXT:     Section: .text (0x5)
+# DSO-NEXT:   }
+# DSO-NEXT:   Symbol {
+# DSO-NEXT:     Name: foo3@ (10)
+# DSO-NEXT:     Value: 0x1007
+# DSO-NEXT:     Size: 0
+# DSO-NEXT:     Binding: Global (0x1)
+# DSO-NEXT:     Type: None (0x0)
+# DSO-NEXT:     Other: 0
+# DSO-NEXT:     Section: .text (0x5)
+# DSO-NEXT:   }
+# DSO-NEXT: ]
+
+# DSO2:      DynamicSymbols [
+# DSO2-NEXT:   Symbol {
+# DSO2-NEXT:     Name: @ (0)
+# DSO2-NEXT:     Value: 0x0
+# DSO2-NEXT:     Size: 0
+# DSO2-NEXT:     Binding: Local (0x0)
+# DSO2-NEXT:     Type: None (0x0)
+# DSO2-NEXT:     Other: 0
+# DSO2-NEXT:     Section: Undefined (0x0)
+# DSO2-NEXT:   }
+# DSO2-NEXT:   Symbol {
+# DSO2-NEXT:     Name: bar@ (1)
+# DSO2-NEXT:     Value: 0x0
+# DSO2-NEXT:     Size: 0
+# DSO2-NEXT:     Binding: Global (0x1)
+# DSO2-NEXT:     Type: Function (0x2)
+# DSO2-NEXT:     Other: 0
+# DSO2-NEXT:     Section: Undefined (0x0)
+# DSO2-NEXT:   }
+# DSO2-NEXT: ]
+
+# EXE:      DynamicSymbols [
+# EXE-NEXT:   Symbol {
+# EXE-NEXT:     Name: @ (0)
+# EXE-NEXT:     Value: 0x0
+# EXE-NEXT:     Size: 0
+# EXE-NEXT:     Binding: Local (0x0)
+# EXE-NEXT:     Type: None (0x0)
+# EXE-NEXT:     Other: 0
+# EXE-NEXT:     Section: Undefined (0x0)
+# EXE-NEXT:   }
+# EXE-NEXT:   Symbol {
+# EXE-NEXT:     Name: bar@ (1)
+# EXE-NEXT:     Value: 0x0
+# EXE-NEXT:     Size: 0
+# EXE-NEXT:     Binding: Global (0x1)
+# EXE-NEXT:     Type: Function (0x2)
+# EXE-NEXT:     Other: 0
+# EXE-NEXT:     Section: Undefined (0x0)
+# EXE-NEXT:   }
+# EXE-NEXT:   Symbol {
+# EXE-NEXT:     Name: foo1@ (5)
+# EXE-NEXT:     Value: 0x11000
+# EXE-NEXT:     Size: 0
+# EXE-NEXT:     Binding: Global (0x1)
+# EXE-NEXT:     Type: None (0x0)
+# EXE-NEXT:     Other: 0
+# EXE-NEXT:     Section: .text (0x5)
+# EXE-NEXT:   }
+# EXE-NEXT: ]
+
+.globl foo1
+foo1:
+  call bar@PLT
+  ret
+
+.globl foo2
+foo2:
+  ret
+
+.globl foo3
+foo3:
+  call foo2@PLT
+  ret
+
+.globl _start
+_start:
+  ret