ELF: Re-implement -u directly and remove CanKeepUndefined flag.

[pcc]

Summary

The semantics of the -u flag are to load the lazy symbol named by the flag. We
were previously relying on this behavior falling out of symbol resolution
against a synthetic undefined symbol, but that didn't quite give us the
correct behavior, so we needed a flag to mark symbols created with -u so
we could treat them specially in the writer. However, it's simpler and less
error prone to implement the required behavior directly and remove the flag.

This fixes an issue where symbols loaded with -u would receive hidden
visibility even when the definition in an object file had wider visibility.

[ruiu]

LGTM. This is beautiful.

ELF/Driver.cpp

if (S.getAsInteger(0, Config->EntryAddr))
       Config->EntrySym = Symtab.addUndefined(S)->Backref;
   }
 
   for (std::unique_ptr<InputFile> &F : Files)
     Symtab.addFile(std::move(F));
   if (HasError)
     return; // There were duplicate symbols or incompatible files
 
-  for (StringRef S : Config->Undefined)
-    Symtab.addUndefinedOpt(S);
-
+  Symtab.scanUndefinedFlags();
   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);
 }

ELF/SymbolTable.h

public:
   SymbolBody *addUndefinedOpt(StringRef Name);
   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 scanUndefinedFlags();
   void scanShlibUndefined();
   void scanDynamicList();
   void scanVersionScript();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);
   InputFile *findFile(SymbolBody *B);
 
 private:

ELF/SymbolTable.cpp

for (auto &IF : IFs) {
     ObjectFiles.emplace_back(Obj);
   }
 }
 
 // Add an undefined symbol.
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addUndefined(StringRef Name) {
   auto *Sym = new (Alloc)
-      UndefinedElf<ELFT>(Name, STB_GLOBAL, STV_DEFAULT, /*Type*/ 0, false);
-  resolve(Sym);
-  return Sym;
-}
-
-// Add an undefined symbol. Unlike addUndefined, that symbol
-// doesn't have to be resolved, thus "opt" (optional).
-template <class ELFT>
-SymbolBody *SymbolTable<ELFT>::addUndefinedOpt(StringRef Name) {
-  auto *Sym = new (Alloc)
-      UndefinedElf<ELFT>(Name, STB_GLOBAL, STV_HIDDEN, /*Type*/ 0, true);
+      UndefinedElf<ELFT>(Name, STB_GLOBAL, STV_DEFAULT, /*Type*/ 0);
   resolve(Sym);
   return Sym;
 }
 
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
                                                      uint8_t Visibility) {
   // Pass nullptr because absolute symbols have no corresponding input sections.
void SymbolTable<ELFT>::addMemberFile(SymbolBody *Undef, Lazy *L) {
   }
 
   // Fetch a member file that has the definition for L.
   // getMember returns nullptr if the member was already read from the library.
   if (std::unique_ptr<InputFile> File = L->getFile())
     addFile(std::move(File));
 }
 
+// Process undefined (-u) flags by loading lazy symbols named by those flags.
+template <class ELFT>
+void SymbolTable<ELFT>::scanUndefinedFlags() {
+  for (StringRef S : Config->Undefined)
+    if (SymbolBody *Sym = find(S))
+      if (auto *L = dyn_cast<Lazy>(Sym))
+        if (std::unique_ptr<InputFile> File = L->getFile())
+          addFile(std::move(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<ELFT>::scanShlibUndefined() {

ELF/Symbols.h

public:
   // LTO, but we could add the feature to ELF. It would be similar to
   // MachO's .weak_def_can_be_hidden.
   unsigned CanOmitFromDynSym : 1;
 
   // True if the linker has to generate a copy relocation for this shared
   // symbol or if the symbol should point to its plt entry.
   unsigned NeedsCopyOrPltAddr : 1;
 
-  unsigned CanKeepUndefined : 1;
-
   // The following fields have the same meaning as the ELF symbol attributes.
   uint8_t Type;    // symbol type
   uint8_t Binding; // symbol binding
   uint8_t StOther; // st_other field value
 
   bool isSection() const { return Type == llvm::ELF::STT_SECTION; }
   bool isTls() const { return Type == llvm::ELF::STT_TLS; }
   bool isFunc() const { return Type == llvm::ELF::STT_FUNC; }

 
 template <class ELFT> class UndefinedElf : public SymbolBody {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Sym Elf_Sym;
 
 public:
   UndefinedElf(StringRef N, const Elf_Sym &Sym);
   UndefinedElf(const Elf_Sym &Sym);
-  UndefinedElf(StringRef Name, uint8_t Binding, uint8_t StOther, uint8_t Type,
-               bool CanKeepUndefined);
-
-  bool canKeepUndefined() const { return CanKeepUndefined; }
+  UndefinedElf(StringRef Name, uint8_t Binding, uint8_t StOther, uint8_t Type);
 
   uintX_t Size;
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::UndefinedElfKind;
   }
 };
 

ELF/Symbols.cpp

SymbolBody::SymbolBody(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther,
                        uint8_t Type)
     : SymbolKind(K), Type(Type), Binding(Binding), StOther(StOther),
       Name({Name.data(), Name.size()}) {
   assert(!isLocal());
   init();
 }
 
 void SymbolBody::init() {
-  CanKeepUndefined = false;
   NeedsCopyOrPltAddr = false;
   CanOmitFromDynSym = false;
 }
 
 // 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())

 template <typename ELFT>
 UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym)
     : SymbolBody(SymbolBody::UndefinedElfKind, N, Sym.getBinding(),
                  Sym.st_other, Sym.getType()),
       Size(Sym.st_size) {}
 
 template <typename ELFT>
 UndefinedElf<ELFT>::UndefinedElf(StringRef Name, uint8_t Binding,
-                                 uint8_t StOther, uint8_t Type,
-                                 bool CanKeepUndefined)
-    : SymbolBody(SymbolBody::UndefinedElfKind, Name, Binding, StOther, Type) {
-  this->CanKeepUndefined = CanKeepUndefined;
-}
+                                 uint8_t StOther, uint8_t Type)
+    : SymbolBody(SymbolBody::UndefinedElfKind, Name, Binding, StOther, Type) {}
 
 template <typename ELFT>
 UndefinedElf<ELFT>::UndefinedElf(const Elf_Sym &Sym)
     : SymbolBody(SymbolBody::UndefinedElfKind, Sym.st_name, Sym.st_other,
                  Sym.getType()),
       Size(Sym.st_size) {
   assert(Sym.getBinding() == STB_LOCAL);
 }

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSections() {
   for (Symbol *S : Symtab.getSymbols()) {
     SymbolBody *Body = S->Body;
 
     // Set "used" bit for --as-needed.
     if (S->IsUsedInRegularObj && !S->isWeak())
       if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(Body))
         SS->File->IsUsed = true;
 
-    if (Body->isUndefined() && !S->isWeak()) {
-      auto *U = dyn_cast<UndefinedElf<ELFT>>(Body);
-      if (!U || !U->canKeepUndefined())
-        reportUndefined<ELFT>(Symtab, Body);
-    }
+    if (Body->isUndefined() && !S->isWeak())
 
     if (auto *C = dyn_cast<DefinedCommon>(Body))
       CommonSymbols.push_back(C);
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
       Out<ELFT>::SymTab->addSymbol(Body);

test/ELF/undefined-opt.s

 # shouldn't show up in the dynamic table.
 # RUN: ld.lld -shared -o %t4 %t.o %tar.a -u unknown
 # RUN: llvm-readobj --dyn-symbols %t4 | \
 # RUN:     FileCheck --check-prefix=UNK-UNDEFINED-SO %s
 # UNK-UNDEFINED-SO: DynamicSymbols [
 # UNK-UNDEFINED-SO-NOT:     Name: unknown
 # UNK-UNDEFINED-SO: ]
 
+# Added undefined symbols should appear in the dynamic table if necessary.
+# RUN: ld.lld -shared -o %t5 %t.o -u export
+# RUN: llvm-readobj --dyn-symbols %t5 | \
+# RUN:     FileCheck --check-prefix=EXPORT-SO %s
+# EXPORT-SO: DynamicSymbols [
+# EXPORT-SO:   Name: export
+# EXPORT-SO: ]
+
 .globl _start;
 _start:
+
+.globl export
+export: