Put undefined symbols from shared libraries in the symbol table

[• espindola]

Summary

It looks like that with the recent fixes in behavior for undefined symbol in shared libraries they are more similar to regular undefined symbols than something else.

[ruiu]

LGTM

This change seems pretty good. I didn't notice that just adding undefined symbols simplifies things like this. Can we now implement --no-allow-shlib-undefined easily as well?

ELF/SymbolTable.cpp

297

My preference is to do this in InputFiles.cpp instead of in this file.

[• espindola]

r326242

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   if (errorCount())
     return;
 
   // We want to declare linker script's symbols early,
   // so that we can version them.
   // They also might be exported if referenced by DSOs.
   Script->declareSymbols();
 
-  // Handle undefined symbols in DSOs.
-  if (!Config->Shared)
-    Symtab->scanShlibUndefined<ELFT>();
-
   // Handle the -exclude-libs option.
   if (Args.hasArg(OPT_exclude_libs))
     excludeLibs<ELFT>(Args);
 
   // Create ElfHeader early. We need a dummy section in
   // addReservedSymbols to mark the created symbols as not absolute.
   Out::ElfHeader = make<OutputSection>("", 0, SHF_ALLOC);
   Out::ElfHeader->Size = sizeof(typename ELFT::Ehdr);

ELF/InputFiles.h

public:
   // Returns object file symbols. It is a runtime error to call this
   // function on files of other types.
   ArrayRef<Symbol *> getSymbols() {
     assert(FileKind == BinaryKind || FileKind == ObjKind ||
            FileKind == BitcodeKind);
     return Symbols;
   }
 
-  // Returns undefined symbols of a shared library.
-  // It is a runtime error to call this function on files of other types.
-  const llvm::DenseSet<StringRef> &getUndefinedSymbols() {
-    assert(FileKind == SharedKind);
-    return Undefs;
-  }
-
   // Filename of .a which contained this file. If this file was
   // not in an archive file, it is the empty string. We use this
   // string for creating error messages.
   std::string ArchiveName;
 
   // If this is an architecture-specific file, the following members
   // have ELF type (i.e. ELF{32,64}{LE,BE}) and target machine type.
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint8_t OSABI = 0;
 
   // Cache for toString(). Only toString() should use this member.
   mutable std::string ToStringCache;
 
   std::string getSrcMsg(const Symbol &Sym, InputSectionBase &Sec,
                         uint64_t Offset);
 
 protected:
   InputFile(Kind K, MemoryBufferRef M);
   std::vector<InputSectionBase *> Sections;
   std::vector<Symbol *> Symbols;
-  llvm::DenseSet<StringRef> Undefs;
 
 private:
   const Kind FileKind;
 };
 
 template <typename ELFT> class ELFFileBase : public InputFile {
 public:
   typedef typename ELFT::Shdr Elf_Shdr;

ELF/InputFiles.cpp

if (Versym) {
       VersymIndex = Versym->vs_index;
       ++Versym;
     }
     bool Hidden = VersymIndex & VERSYM_HIDDEN;
     VersymIndex = VersymIndex & ~VERSYM_HIDDEN;
 
     StringRef Name = CHECK(Sym.getName(this->StringTable), this);
     if (Sym.isUndefined()) {
-      this->Undefs.insert(Name);
+      Symtab->addUndefined<ELFT>(Name, Sym.getBinding(), Sym.st_other,
+                                 Sym.getType(),
+                                 /*CanOmitFromDynSym=*/false, this);
       continue;
     }
 
     if (Sym.getBinding() == STB_LOCAL) {
       warn("found local symbol '" + Name +
            "' in global part of symbol table in file " + toString(this));
       continue;
     }

ELF/LinkerScript.cpp

static bool shouldDefineSym(SymbolAssignment *Cmd) {
   if (!Cmd->Provide)
     return true;
 
   // If a symbol was in PROVIDE(), we need to define it only
   // when it is a referenced undefined symbol.
   Symbol *B = Symtab->find(Cmd->Name);
   if (B && !B->isDefined())
     return true;
-  // It might also be referenced by a DSO.
-  for (InputFile *F : SharedFiles)
-    if (F->getUndefinedSymbols().count(Cmd->Name))
-      return true;
   return false;
 }
 
 // This function is called from processSectionCommands,
 // while we are fixing the output section layout.
 void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   if (!shouldDefineSym(Cmd))
     return;

ELF/SymbolTable.h

Symbol *addCommon(StringRef Name, uint64_t Size, uint32_t Alignment,
                     InputFile &File);
 
   std::pair<Symbol *, bool> insert(StringRef Name);
   std::pair<Symbol *, bool> insert(StringRef Name, uint8_t Type,
                                    uint8_t Visibility, bool CanOmitFromDynSym,
                                    InputFile *File);
 
   template <class ELFT> void fetchIfLazy(StringRef Name);
-  template <class ELFT> void scanShlibUndefined();
   void scanVersionScript();
 
   Symbol *find(StringRef Name);
 
   void trace(StringRef Name);
 
   void handleDynamicList();
 

ELF/SymbolTable.cpp

 Symbol *SymbolTable::addUndefined(StringRef Name, uint8_t Binding,
                                   uint8_t StOther, uint8_t Type,
                                   bool CanOmitFromDynSym, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   uint8_t Visibility = getVisibility(StOther);
   std::tie(S, WasInserted) =
       insert(Name, Type, Visibility, CanOmitFromDynSym, File);
+  if (File && File->kind() == InputFile::SharedKind)
+    S->ExportDynamic = true;
   // An undefined symbol with non default visibility must be satisfied
   // in the same DSO.
   if (WasInserted || (isa<SharedSymbol>(S) && Visibility != STV_DEFAULT)) {
     replaceSymbol<Undefined>(S, File, Name, Binding, StOther, Type);
     return S;
   }
   if (S->isShared() || S->isLazy() || (S->isUndefined() && Binding != STB_WEAK))
     S->Binding = Binding;
if (Symbol *B = find(Name)) {
     // even if it is a bitcode symbol.
     B->IsUsedInRegularObj = true;
     if (auto *L = dyn_cast<Lazy>(B))
       if (InputFile *File = L->fetch())
         addFile<ELFT>(File);
   }
 }
 
-// This function takes care of the case in which shared libraries depend on
-// the user program (not the other way, which is usual). Shared libraries
-// may have undefined symbols, expecting that the user program provides
-// the definitions for them. An example is BSD's __progname symbol.
-// We need to put such symbols to the main program's .dynsym so that
-// shared libraries can find them.
-// Except this, we ignore undefined symbols in DSOs.
-template <class ELFT> void SymbolTable::scanShlibUndefined() {
-  for (InputFile *F : SharedFiles) {
-    for (StringRef U : F->getUndefinedSymbols()) {
-      Symbol *Sym = find(U);
-      if (!Sym)
-        continue;
-      if (auto *L = dyn_cast<Lazy>(Sym))
-        if (InputFile *File = L->fetch())
-          addFile<ELFT>(File);
-
-      if (Sym->isDefined())
-        Sym->ExportDynamic = true;
-    }
-  }
-}
-
 // Initialize DemangledSyms with a map from demangled symbols to symbol
 // objects. Used to handle "extern C++" directive in version scripts.
 //
 // The map will contain all demangled symbols. That can be very large,
 // and in LLD we generally want to avoid do anything for each symbol.
 // Then, why are we doing this? Here's why.
 //
 // Users can use "extern C++ {}" directive to match against demangled

 template void SymbolTable::addShared<ELF64BE>(StringRef, SharedFile<ELF64BE> &,
                                               const typename ELF64BE::Sym &,
                                               uint32_t Alignment, uint32_t);
 
 template void SymbolTable::fetchIfLazy<ELF32LE>(StringRef);
 template void SymbolTable::fetchIfLazy<ELF32BE>(StringRef);
 template void SymbolTable::fetchIfLazy<ELF64LE>(StringRef);
 template void SymbolTable::fetchIfLazy<ELF64BE>(StringRef);
-
-template void SymbolTable::scanShlibUndefined<ELF32LE>();
-template void SymbolTable::scanShlibUndefined<ELF32BE>();
-template void SymbolTable::scanShlibUndefined<ELF64LE>();
-template void SymbolTable::scanShlibUndefined<ELF64BE>();

test/ELF/trace-symbols.s

 # ARCHIVED2FOO: trace-symbols.s.tmp2.a(trace-symbols.s.tmp2): definition of foo
 
 # RUN: ld.lld -y bar %t %t1.so %t2.so -o %t3 | \
 # RUN:   FileCheck -check-prefix=SHLIBDBAR %s
 # SHLIBDBAR: trace-symbols.s.tmp2.so: shared definition of bar
 
 # RUN: ld.lld -y foo -y bar %t %t1.so %t2.so -o %t3 | \
 # RUN:   FileCheck -check-prefix=SHLIBRBAR %s
-# SHLIBRBAR-NOT: trace-symbols.s.tmp1.so: reference to bar
+# SHLIBRBAR: trace-symbols.s.tmp1.so: reference to bar
 
 # RUN: ld.lld -y foo -y bar %t -u bar --start-lib %t1 %t2 --end-lib -o %t3 | \
 # RUN:   FileCheck -check-prefix=STARTLIB %s
 # STARTLIB: trace-symbols.s.tmp1: reference to bar
 
 .hidden hsymbol
 .globl  _start
 .type _start, @function
 _start:
 call foo