[ELF] Fix undefined symbol handling in DSO.

[ruiu]

Summary

Currently LLD ignores undefined symbols found in DSOs when linking against
DSO files, if -shared flag is given. Internally, it's achieved by enabling
"useShlibUndefines" flag, which makes the file reader to ignore all undefined
symbols in DSO, so that Resolver don't see any undefined symbols when
handling DSO files.

The above behavior is not compatible with GNU LD.

GNU LD does not also warn on undefined symbols found in DSOs if -shared flag
is given. However, it actually tries to resolve such undefined symbols. As a
result, if an undefined symbol can be resolved by other objects/DSOs appears
later in the same command line, linking output will be different from LLD's
result.

This patch fixes the compatibilty issue. GNU LD seems to just not print
warning messages on undefined symbols if -shared is given. This patch
implements the same behavior.

[atanasyan]

lib/Driver/GnuLdDriver.cpp

178

It's a bit hard to understand that there is no functional changes here and the only code modification is a variable renaming. Maybe move such changes to the separate commit?

test/elf/dynamic-undef.test

23

IMHO we still need to check that --no-allow-shlib-undefined disallows undefined symbols in a shared library and lld returns an error in this case.

[shankarke]

Commented.

[shankarke]

I am having some problem with my browser, with inline comments. and I also think this be converted to 2 patches.

a) to remove the option (use-shlib-undefines)
b) fix --[no]allow-shlib-undefined.

I am not sure the reason we added the option use-shlib-undefines, Bigcheese ?

Rui, can you wait on Bigcheese's review before removing the option use-shlib-undefines ?

include/lld/ReaderWriter/ELFLinkingContext.h

 
 class TargetHandlerBase {
 public:
   virtual ~TargetHandlerBase() {}
   virtual void registerRelocationNames(Registry &) = 0;
 
   virtual std::unique_ptr<Reader> getObjReader(bool) = 0;
 
-  virtual std::unique_ptr<Reader> getDSOReader(bool) = 0;
+  virtual std::unique_ptr<Reader> getDSOReader() = 0;
 
   virtual std::unique_ptr<Writer> getWriter() = 0;
 };
 
 class ELFLinkingContext : public LinkingContext {
 public:
 
   /// \brief The type of ELF executable that the linker
public:
   virtual bool isLittleEndian() const;
   virtual uint64_t getPageSize() const { return 0x1000; }
   OutputMagic getOutputMagic() const { return _outputMagic; }
   uint16_t getOutputELFType() const { return _outputELFType; }
   uint16_t getOutputMachine() const;
   bool mergeCommonStrings() const { return _mergeCommonStrings; }
   virtual uint64_t getBaseAddress() const { return _baseAddress; }
 
-  /// This controls if undefined atoms need to be created for undefines that are
-  /// present in a SharedLibrary. If this option is set, undefined atoms are
-  /// created for every undefined symbol that are present in the dynamic table
-  /// in the shared library
-  bool useShlibUndefines() const { return _useShlibUndefines; }
-  /// @}
-
   /// \brief Does this relocation belong in the dynamic relocation table?
   ///
   /// This table is evaluated at loadtime by the dynamic loader and is
   /// referenced by the DT_RELA{,ENT,SZ} entries in the dynamic table.
   /// Relocations that return true will be added to the dynamic relocation
   /// table.
   virtual bool isDynamicRelocation(const DefinedAtom &,
                                    const Reference &) const {
public:
 
   TargetHandlerBase *targetHandler() const { return _targetHandler.get(); }
   void addPasses(PassManager &pm) override;
 
   void setTriple(llvm::Triple trip) { _triple = trip; }
   void setNoInhibitExec(bool v) { _noInhibitExec = v; }
   void setIsStaticExecutable(bool v) { _isStaticExecutable = v; }
   void setMergeCommonStrings(bool v) { _mergeCommonStrings = v; }
-  void setUseShlibUndefines(bool use) { _useShlibUndefines = use; }
   void setOutputELFType(uint32_t type) { _outputELFType = type; }
 
   void createInternalFiles(std::vector<std::unique_ptr<File>> &) const override;
 
   /// \brief Set the dynamic linker path
   void setInterpreter(StringRef dynamicLinker) {
     _dynamicLinkerArg = true;
     _dynamicLinkerPath = dynamicLinker;
protected:
   uint16_t _outputELFType; // e.g ET_EXEC
   llvm::Triple _triple;
   std::unique_ptr<TargetHandlerBase> _targetHandler;
   uint64_t _baseAddress;
   bool _isStaticExecutable;
   bool _noInhibitExec;
   bool _mergeCommonStrings;
   bool _runLayoutPass;
-  bool _useShlibUndefines;
   bool _dynamicLinkerArg;
   bool _noAllowDynamicLibraries;
   OutputMagic _outputMagic;
   StringRefVector _inputSearchPaths;
   std::unique_ptr<Writer> _writer;
   StringRef _dynamicLinkerPath;
   StringRefVector _initFunctions;
   StringRefVector _finiFunctions;

include/lld/ReaderWriter/Reader.h

public:
   void addSupportArchives(bool logLoading);
   void addSupportYamlFiles();
   void addSupportNativeObjects();
   void addSupportCOFFObjects(PECOFFLinkingContext &);
   void addSupportCOFFImportLibraries();
   void addSupportWindowsResourceFiles();
   void addSupportMachOObjects(StringRef archName);
   void addSupportELFObjects(bool atomizeStrings, TargetHandlerBase *handler);
-  void addSupportELFDynamicSharedObjects(bool useShlibUndefines,
-                                         TargetHandlerBase *handler);
+  void addSupportELFDynamicSharedObjects(TargetHandlerBase *handler);
 
   /// To convert between kind values and names, the registry walks the list
   /// of registered kind tables. Each table is a zero terminated array of
   /// KindStrings elements.
   struct KindStrings {
     Reference::KindValue  value;
     StringRef             name;
   };

lib/Driver/GnuLdDriver.cpp

std::string ELFFileNode::errStr(error_code errc) {
   }
   return FileNode::errStr(errc);
 }
 
 bool GnuLdDriver::linkELF(int argc, const char *argv[],
                           raw_ostream &diagnostics) {
   BumpPtrAllocator alloc;
   std::tie(argc, argv) = maybeExpandResponseFiles(argc, argv, alloc);
-  std::unique_ptr<ELFLinkingContext> options;
-  if (!parse(argc, argv, options, diagnostics))
+  std::unique_ptr<ELFLinkingContext> opts;
+  if (!parse(argc, argv, opts, diagnostics))
     return false;
-  if (!options)
+  if (!opts)
     return true;
 
   // Register possible input file parsers.
-  options->registry().addSupportELFObjects(options->mergeCommonStrings(),
-                                           options->targetHandler());
-  options->registry().addSupportArchives(options->logInputFiles());
-  options->registry().addSupportYamlFiles();
-  options->registry().addSupportNativeObjects();
-  if (options->allowLinkWithDynamicLibraries())
-    options->registry().addSupportELFDynamicSharedObjects(
-        options->useShlibUndefines(), options->targetHandler());
-  return link(*options, diagnostics);
+  opts->registry().addSupportELFObjects(opts->mergeCommonStrings(),
+                                        opts->targetHandler());
+  opts->registry().addSupportArchives(opts->logInputFiles());
+  opts->registry().addSupportYamlFiles();
+  opts->registry().addSupportNativeObjects();
+  if (opts->allowLinkWithDynamicLibraries())
+    opts->registry().addSupportELFDynamicSharedObjects(opts->targetHandler());
+  return link(*opts, diagnostics);
 }
 
 static llvm::Optional<llvm::Triple::ArchType>
 getArchType(const llvm::Triple &triple, StringRef value) {
   switch (triple.getArch()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     if (value == "elf_i386")
if (llvm::opt::Arg *kind =
 
     case OPT_static:
       ctx->setOutputELFType(llvm::ELF::ET_EXEC);
       ctx->setIsStaticExecutable(true);
       break;
     case OPT_shared:
       ctx->setOutputELFType(llvm::ELF::ET_DYN);
       ctx->setAllowShlibUndefines(true);
-      ctx->setUseShlibUndefines(false);
+      ctx->setPrintRemainingUndefines(false);
+      ctx->setAllowRemainingUndefines(true);
       break;
     }
   }
 
   // Figure out if the output type is nmagic/omagic
   if (llvm::opt::Arg *kind =
           parsedArgs->getLastArg(OPT_nmagic, OPT_omagic, OPT_no_omagic)) {
     switch (kind->getOption().getID()) {
for (auto inputArg : *parsedArgs) {
     case OPT_no_allow_shlib_undefs:
       ctx->setAllowShlibUndefines(false);
       break;
 
     case OPT_allow_shlib_undefs:
       ctx->setAllowShlibUndefines(true);
       break;
 
-    case OPT_use_shlib_undefs:
-      ctx->setUseShlibUndefines(true);
-      break;
-
     case OPT_allow_multiple_definition:
       ctx->setAllowDuplicates(true);
       break;
 
     case OPT_dynamic_linker:
       ctx->setInterpreter(inputArg->getValue());
       break;
 

lib/Driver/GnuLdOptions.td

 def no_allow_shlib_undefs : Flag<["--"], "no-allow-shlib-undefined">,
      HelpText<"Do not allow undefined symbols from dynamic"
               " library when creating executables">,
      Group<grp_resolveropt>;
 def allow_shlib_undefs : Flag<["--"], "allow-shlib-undefined">,
      HelpText<"Allow undefined symbols from dynamic"
              " library when creating executables">,
      Group<grp_resolveropt>;
-def use_shlib_undefs: Flag<["--"], "use-shlib-undefines">,
-    HelpText<"Resolve undefined symbols from dynamic libraries">,
-    Group<grp_resolveropt>;
 def allow_multiple_definition: Flag<["--"], "allow-multiple-definition">,
     HelpText<"Allow multiple definitions">,
     Group<grp_resolveropt>;
 def defsym : Joined<["--"], "defsym=">,
      HelpText<"Create a defined symbol">,
      Group<grp_resolveropt>;
 
 //===----------------------------------------------------------------------===//

lib/ReaderWriter/ELF/DefaultTargetHandler.h

public:
   const TargetRelocationHandler<ELFT> &getRelocationHandler() const {
     llvm_unreachable("Target should provide implementation for function ");
   }
 
   virtual std::unique_ptr<Reader> getObjReader(bool atomizeStrings) {
     return std::unique_ptr<Reader>(new ELFObjectReader(atomizeStrings));
   }
 
-  virtual std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) {
-    return std::unique_ptr<Reader>(new ELFDSOReader(useShlibUndefines));
+  virtual std::unique_ptr<Reader> getDSOReader() {
+    return std::unique_ptr<Reader>(new ELFDSOReader());
   }
 
   virtual std::unique_ptr<Writer> getWriter() = 0;
 };
 
 } // end namespace elf
 } // end namespace lld
 #endif

lib/ReaderWriter/ELF/DynamicFile.h

 
 #include <unordered_map>
 
 namespace lld {
 namespace elf {
 template <class ELFT> class DynamicFile : public SharedLibraryFile {
 public:
   static ErrorOr<std::unique_ptr<DynamicFile>>
-  create(std::unique_ptr<llvm::MemoryBuffer> mb, bool useShlibUndefines);
+  create(std::unique_ptr<llvm::MemoryBuffer> mb);
 
   const atom_collection<DefinedAtom> &defined() const override {
     return _definedAtoms;
   }
 
   const atom_collection<UndefinedAtom> &undefined() const override {
     return _undefinedAtoms;
   }
struct SymAtomPair {
     const SharedLibraryAtom *_atom;
   };
 
   mutable std::unordered_map<StringRef, SymAtomPair> _nameToSym;
 };
 
 template <class ELFT>
 ErrorOr<std::unique_ptr<DynamicFile<ELFT>>>
-DynamicFile<ELFT>::create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                          bool useShlibUndefines) {
+DynamicFile<ELFT>::create(std::unique_ptr<llvm::MemoryBuffer> mb) {
   std::unique_ptr<DynamicFile> file(new DynamicFile(mb->getBufferIdentifier()));
 
   error_code ec;
   file->_objFile.reset(new llvm::object::ELFFile<ELFT>(mb.release(), ec));
 
   if (ec)
     return ec;
 
for (auto i = obj.begin_dynamic_symbols(), e = obj.end_dynamic_symbols();
     if ((ec = name.getError()))
       return ec;
 
     // TODO: Add absolute symbols
     if (i->st_shndx == llvm::ELF::SHN_ABS)
       continue;
 
     if (i->st_shndx == llvm::ELF::SHN_UNDEF) {
-      if (!useShlibUndefines)
-        continue;
       // Create an undefined atom.
       if (!name->empty()) {
         auto *newAtom =
             new (file->_alloc) ELFUndefinedAtom<ELFT>(*file.get(), *name, &*i);
         file->_undefinedAtoms._atoms.push_back(newAtom);
       }
       continue;
     }

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

 };
 
 ELFLinkingContext::ELFLinkingContext(
     llvm::Triple triple, std::unique_ptr<TargetHandlerBase> targetHandler)
     : _outputELFType(elf::ET_EXEC), _triple(triple),
       _targetHandler(std::move(targetHandler)), _baseAddress(0),
       _isStaticExecutable(false), _noInhibitExec(false),
       _mergeCommonStrings(false), _runLayoutPass(true),
-      _useShlibUndefines(true), _dynamicLinkerArg(false),
-      _noAllowDynamicLibraries(false), _outputMagic(OutputMagic::DEFAULT),
-      _sysrootPath("") {}
+      _dynamicLinkerArg(false), _noAllowDynamicLibraries(false),
+      _outputMagic(OutputMagic::DEFAULT), _sysrootPath("") {}
 
 bool ELFLinkingContext::is64Bits() const { return getTriple().isArch64Bit(); }
 
 bool ELFLinkingContext::isLittleEndian() const {
   // TODO: Do this properly. It is not defined purely by arch.
   return true;
 }
 

lib/ReaderWriter/ELF/ELFReader.h

 
 namespace lld {
 namespace elf {
 
 struct DynamicFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
 
   template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            bool useUndefines) {
-    return lld::elf::DynamicFile<ELFT>::create(std::move(mb), useUndefines);
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb) {
+    return lld::elf::DynamicFile<ELFT>::create(std::move(mb));
   }
 };
 
 struct ELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
public:
   }
 
 protected:
   bool _atomizeStrings;
 };
 
 class ELFDSOReader : public Reader {
 public:
-  ELFDSOReader(bool useUndefines) : _useUndefines(useUndefines) {}
+  ELFDSOReader() {}
 
   bool canParse(file_magic magic, StringRef,
                 const MemoryBuffer &) const override {
     return (magic == llvm::sys::fs::file_magic::elf_shared_object);
   }
 
   error_code
   parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
             std::vector<std::unique_ptr<File>> &result) const override {
     std::size_t maxAlignment =
         1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
     auto f = createELF<DynamicFileCreateELFTraits>(
-        llvm::object::getElfArchType(&*mb), maxAlignment, std::move(mb),
-        _useUndefines);
+        llvm::object::getElfArchType(&*mb), maxAlignment, std::move(mb));
     if (error_code ec = f.getError())
       return ec;
     result.push_back(std::move(*f));
     return error_code::success();
   }
-
-protected:
-  bool _useUndefines;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_READER_H

lib/ReaderWriter/ELF/Hexagon/HexagonELFReader.h

 
 namespace lld {
 namespace elf {
 
 struct HexagonDynamicFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
 
   template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            bool useUndefines) {
-    return lld::elf::HexagonDynamicFile<ELFT>::create(std::move(mb),
-                                                      useUndefines);
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb) {
+    return lld::elf::HexagonDynamicFile<ELFT>::create(std::move(mb));
   }
 };
 
 struct HexagonELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
if (error_code ec = f.getError())
       return ec;
     result.push_back(std::move(*f));
     return error_code::success();
   }
 };
 
 class HexagonELFDSOReader : public ELFDSOReader {
 public:
-  HexagonELFDSOReader(bool useUndefines) : ELFDSOReader(useUndefines) {}
+  HexagonELFDSOReader() : ELFDSOReader() {}
 
   error_code
   parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
             std::vector<std::unique_ptr<File>> &result) const override {
     std::size_t maxAlignment =
         1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
     auto f = createELF<HexagonDynamicFileCreateELFTraits>(
-        llvm::object::getElfArchType(&*mb), maxAlignment, std::move(mb),
-        _useUndefines);
+        llvm::object::getElfArchType(&*mb), maxAlignment, std::move(mb));
     if (error_code ec = f.getError())
       return ec;
     result.push_back(std::move(*f));
     return error_code::success();
   }
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_READER_H

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

public:
   HexagonTargetLayout<HexagonELFType> &getTargetLayout() override {
     return *(_hexagonTargetLayout.get());
   }
 
   std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
     return std::unique_ptr<Reader>(new HexagonELFObjectReader(atomizeStrings));
   }
 
-  std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
-    return std::unique_ptr<Reader>(new HexagonELFDSOReader(useShlibUndefines));
+  std::unique_ptr<Reader> getDSOReader() override {
+    return std::unique_ptr<Reader>(new HexagonELFDSOReader());
   }
 
   std::unique_ptr<Writer> getWriter() override;
 
 private:
   llvm::BumpPtrAllocator _alloc;
   static const Registry::KindStrings kindStrings[];
   HexagonLinkingContext &_hexagonLinkingContext;
   std::unique_ptr<HexagonRuntimeFile<HexagonELFType> > _hexagonRuntimeFile;
   std::unique_ptr<HexagonTargetLayout<HexagonELFType>> _hexagonTargetLayout;
   std::unique_ptr<HexagonTargetRelocationHandler> _hexagonRelocationHandler;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/PPC/PPCELFReader.h

 
 namespace lld {
 namespace elf {
 
 struct PPCDynamicFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::SharedLibraryFile>> result_type;
 
   template <class ELFT>
-  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
-                            bool useUndefines) {
-    return lld::elf::PPCDynamicFile<ELFT>::create(std::move(mb), useUndefines);
+  static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb) {
+    return lld::elf::PPCDynamicFile<ELFT>::create(std::move(mb));
   }
 };
 
 struct PPCELFFileCreateELFTraits {
   typedef llvm::ErrorOr<std::unique_ptr<lld::File>> result_type;
 
   template <class ELFT>
   static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
if (!f)
       return f;
     result.push_back(std::move(*f));
     return error_code::success();
   }
 };
 
 class PPCELFDSOReader : public ELFDSOReader {
 public:
-  PPCELFDSOReader(bool useUndefines) : ELFDSOReader(useUndefines) {}
+  PPCELFDSOReader() : ELFDSOReader() {}
 
   virtual error_code
   parseFile(std::unique_ptr<MemoryBuffer> &mb, const class Registry &,
             std::vector<std::unique_ptr<File>> &result) const {
     std::size_t maxAlignment =
         1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
     auto f = createELF<PPCDynamicFileCreateELFTraits>(
-        llvm::object::getElfArchType(&*mb), maxAlignment, std::move(mb),
-        _useUndefines);
+        llvm::object::getElfArchType(&*mb), maxAlignment, std::move(mb));
     if (!f)
       return f;
     result.push_back(std::move(*f));
     return error_code::success();
   }
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_READER_H

lib/ReaderWriter/ELF/Reader.cpp

void Registry::addSupportELFObjects(bool atomizeStrings,
 
   // Tell registry about the ELF object file parser.
   add(std::move(handler->getObjReader(atomizeStrings)));
 
   // Tell registry about the relocation name to number mapping for this arch.
   handler->registerRelocationNames(*this);
 }
 
-void Registry::addSupportELFDynamicSharedObjects(bool useShlibUndefines,
-                                                 TargetHandlerBase *handler) {
+void Registry::addSupportELFDynamicSharedObjects(TargetHandlerBase *handler) {
   // Tell registry about the ELF dynamic shared library file parser.
-  add(handler->getDSOReader(useShlibUndefines));
+  add(handler->getDSOReader());
 }
 
 } // end namespace lld

lib/ReaderWriter/ELF/TargetHandler.h

public:
 
   /// Determine how relocations need to be applied.
   virtual const TargetRelocationHandler<ELFT> &getRelocationHandler() const = 0;
 
   /// How does the target deal with reading input files.
   virtual std::unique_ptr<Reader> getObjReader(bool) = 0;
 
   /// How does the target deal with reading dynamic libraries.
-  virtual std::unique_ptr<Reader> getDSOReader(bool) = 0;
+  virtual std::unique_ptr<Reader> getDSOReader() = 0;
 
   /// How does the target deal with writing ELF output.
   virtual std::unique_ptr<Writer> getWriter() = 0;
 
 private:
   ELFLinkingContext &_context;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

test/elf/dynamic-undef.test

 #
 # This test creates a executable and tests the options that are used to
 # to create an executable and a shared library
 #
 # This test will fail because there are unresolved symbols from the shared
 # library and we are not passing --allow-shlib-undefined
 RUN: not lld -flavor gnu -target x86_64-linux %p/Inputs/tls.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 -o %t -e main 2> %t1
 RUN: FileCheck -check-prefix=EXEC %s < %t1
+
 # This test will pass because of --allow-shlib-undefined
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/tls.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 -o %t -e main --allow-shlib-undefined
+
 # Test creation of shared library, this should pass because we are using
 # shared option and by default, dynamic library wouldn't create undefined atoms
 # from the input shared library
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/tls.x86-64 \
 RUN:   %p/Inputs/shared.so-x86-64 -o %t -e main -shared
-# Test creation of shared library, this should fail because we are using
-# shared option setting the options to use the shared library undefines to
-# create undefined atoms from the input shared library
-RUN: not lld -flavor gnu -target x86_64-linux %p/Inputs/tls.x86-64 \
-RUN:   %p/Inputs/shared.so-x86-64 -o %t -e main -shared \
-RUN: --use-shlib-undefines --no-allow-shlib-undefined  2> %t2
-RUN: FileCheck -check-prefix=SHLIB %s < %t2
 
 EXEC: Undefined symbol: {{[-_A-Za-z0-9.\\/:]+}}shared.so-x86-64: puts
 SHLIB: Undefined symbol: {{[-_A-Za-z0-9.\\/:]+}}shared.so-x86-64: puts
 EXEC-NOT: Undefined symbol: {{[-_A-Za-z0-9.\\/:]+}}shared.so-x86-64: weakfoo
 SHLIB-NOT: Undefined symbol: {{[-_A-Za-z0-9.\\/:]+}}shared.so-x86-64: weakfoo