ELF2: Fix BSD's __progname symbol issue.

[ruiu]

Summary

BSD's DSO files have undefined symbol "__progname" which is defined in crt1.o.
On that system, both user programs and system shared libraries depend on each
other. We need to put symbols defined by user programs which are referenced
by shared libraries to user program's .dynsym.

[ruiu]

Why COPY relocation is related to this?

[ruiu]

I was trying to write the comment concretely to help readers understand the
problem, but that may read that the issue would be limited to __progname.
I'll update the comment. Thank you for the advice.

[ruiu]

Update a comment.

[emaste]

With this change I'm able to link a Hello world on FreeBSD.

[ruiu]

Rebased on HEAD

[• rafael]

LGTM with a nit.

test/elf2/progname.s

9

Don't include the numerical value (58). It is not stable.

[emaste]

Committed in rL250176

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
 
   for (auto *Arg : Args.filtered(OPT_undefined))
     Symtab.addUndefinedOpt(Arg->getValue());
 
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
   // Write the result to the file.
+  Symtab.finalize();
   writeResult<ELFT>(&Symtab);
 }

ELF/InputFiles.h

 
 template <class ELFT>
 class SharedFile : public SharedFileBase, public ELFData<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
 
   std::vector<SharedSymbol<ELFT>> SymbolBodies;
+  std::vector<StringRef> Undefs;
 
 public:
   using ELFData<ELFT>::getEMachine;
   llvm::MutableArrayRef<SharedSymbol<ELFT>> getSharedSymbols() {
     return SymbolBodies;
   }
 
+  llvm::ArrayRef<StringRef> getUndefinedSymbols() { return Undefs; }
+
   static bool classof(const InputFile *F) {
     return F->kind() == SharedKind &&
            cast<ELFFileBase>(F)->getELFKind() == getStaticELFKind<ELFT>();
   }
 
   explicit SharedFile(MemoryBufferRef M);
 
   void parseSoName() override;

ELF/InputFiles.cpp

template <class ELFT> void SharedFile<ELFT>::parseSoName() {
   }
 }
 
 template <class ELFT> void SharedFile<ELFT>::parse() {
   Elf_Sym_Range Syms = this->getNonLocalSymbols();
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms) {
-    if (Sym.isUndefined())
-      continue;
-
     ErrorOr<StringRef> NameOrErr = Sym.getName(this->StringTable);
     error(NameOrErr.getError());
     StringRef Name = *NameOrErr;
 
+    if (Sym.isUndefined())
+      Undefs.push_back(Name);
+    else
       SymbolBodies.emplace_back(this, Name, Sym);
   }
 }
 
 namespace lld {
 namespace elf2 {
 
 template class elf2::ObjectFile<llvm::object::ELF32LE>;
 template class elf2::ObjectFile<llvm::object::ELF32BE>;

ELF/SymbolTable.h

const std::vector<std::unique_ptr<SharedFile<ELFT>>> &getSharedFiles() const {
     return SharedFiles;
   }
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
   void addSyntheticSym(StringRef Name, OutputSection<ELFT> &Section,
                        typename llvm::object::ELFFile<ELFT>::uintX_t Value);
   void addIgnoredSym(StringRef Name);
+  void finalize();
 
 private:
   Symbol *insert(SymbolBody *New);
   void addELFFile(ELFFileBase *File);
   void addLazy(Lazy *New);
   void addMemberFile(Lazy *Body);
   void init(uint16_t EMachine);
   void resolve(SymbolBody *Body);
+  SymbolBody *find(StringRef Name);
   void reportConflict(const Twine &Message, const SymbolBody &Old,
                       const SymbolBody &New, bool Warning);
 
   std::vector<std::unique_ptr<InputFile>> ArchiveFiles;
 
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64

ELF/SymbolTable.cpp

if (!Sym) {
     Sym = new (Alloc) Symbol(New);
     New->setBackref(Sym);
     return Sym;
   }
   New->setBackref(Sym);
   return Sym;
 }
 
+template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
+  auto It = Symtab.find(Name);
+  if (It == Symtab.end())
+    return nullptr;
+  return It->second->Body;
+}
+
 template <class ELFT> void SymbolTable<ELFT>::addLazy(Lazy *New) {
   Symbol *Sym = insert(New);
   if (Sym->Body == New)
     return;
   SymbolBody *Existing = Sym->Body;
   if (Existing->isDefined() || Existing->isLazy())
     return;
   Sym->Body = New;
template <class ELFT> void SymbolTable<ELFT>::addMemberFile(Lazy *Body) {
 
   // getMember returns nullptr if the member was already read from the library.
   if (!File)
     return;
 
   addFile(std::move(File));
 }
 
+template <class ELFT> void SymbolTable<ELFT>::finalize() {
+  // This code 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.
+  for (std::unique_ptr<SharedFile<ELFT>> &File : SharedFiles)
+    for (StringRef U : File->getUndefinedSymbols())
+      if (SymbolBody *Sym = find(U))
+        if (Sym->isDefined())
+          Sym->setUsedInDynamicReloc();
+}
+
 template class lld::elf2::SymbolTable<ELF32LE>;
 template class lld::elf2::SymbolTable<ELF32BE>;
 template class lld::elf2::SymbolTable<ELF64LE>;
 template class lld::elf2::SymbolTable<ELF64BE>;

test/elf2/progname.s

+// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %t.o
+// RUN: echo '.global __progname' > %t2.s
+// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %t2.s -o %t2.o
+// RUN: ld.lld2 -shared %t2.o -o %t2.so
+// RUN: ld.lld2 -o %t %t.o %t2.so
+// RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
+
+// CHECK:      Name:     __progname@ (58)
+// CHECK-NEXT: Value:    0x11000
+// CHECK-NEXT: Size:     0
+// CHECK-NEXT: Binding:  Global (0x1)
+// CHECK-NEXT: Type:     None (0x0)
+// CHECK-NEXT: Other:    0
+// CHECK-NEXT: Section:  .text (0x4)
+// CHECK-NEXT: }
+
+.global _start, __progname
+_start:
+__progname:
+  nop