ELF2: Implement --as-needed.

[ruiu]

Summary

This patch adds AsNeeded and IsUsed bool fields to SharedFile. AsNeeded bit
is set if the DSO is enclosed with --as-needed and --no-as-needed. IsUsed
bit is off by default. When we adds a symbol to the symbol table for dynamic
linking, we set its SharedFile's IsUsed bit.

If AsNeeded is set but IsUsed is not set, we don't want to write that
file's SO name to DT_NEEDED field.

[• rafael]

ELF/Writer.cpp

207

I don't think this correctly handles weak symbols.

It should not set the bit if the symbol is only used to satisfy a weak undefined. For that it looks like you need to fetch the original SymbolBody, not the replacement.

test/elf2/as-needed.s

9

Please also add a test for the weak undefined case.

[ruiu]

Did you mean this?

[• rafael]

LGTM with an additional testcase showing the handling of weak undefined symbols.

[Eugene.Zelenko]

Committed in r249998.

ELF/Config.h

struct Configuration {
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> SearchPaths;
   bool AllowMultipleDefinition;
+  bool AsNeeded = false;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool NoInhibitExec;
   bool NoUndefined;
   bool Shared;

ELF/Driver.cpp

if (WholeArchive) {
       auto File = make_unique<ArchiveFile>(MBRef);
       for (MemoryBufferRef &MB : File->getMembers())
         Files.push_back(createELFFile<ObjectFile>(MB));
       OwningArchives.emplace_back(std::move(File));
       return;
     }
     Files.push_back(make_unique<ArchiveFile>(MBRef));
     return;
-  case file_magic::elf_shared_object:
-    Files.push_back(createELFFile<SharedFile>(MBRef));
+  case file_magic::elf_shared_object: {
+    std::unique_ptr<ELFFileBase> File = createELFFile<SharedFile>(MBRef);
+    cast<SharedFileBase>(File.get())->AsNeeded = Config->AsNeeded;
+    Files.push_back(std::move(File));
     return;
+  }
   default:
     Files.push_back(createELFFile<ObjectFile>(MBRef));
   }
 }
 
 static StringRef
 getString(opt::InputArgList &Args, unsigned Key, StringRef Default = "") {
   if (auto *Arg = Args.getLastArg(Key))
for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_l:
       addFile(searchLibrary(Arg->getValue()));
       break;
     case OPT_INPUT:
     case OPT_script:
       addFile(Arg->getValue());
       break;
+    case OPT_as_needed:
+      Config->AsNeeded = true;
+      break;
+    case OPT_no_as_needed:
+      Config->AsNeeded = false;
+      break;
     case OPT_Bstatic:
       Config->Static = true;
       break;
     case OPT_Bdynamic:
       Config->Static = false;
       break;
     case OPT_whole_archive:
       WholeArchive = true;

ELF/InputFiles.h

public:
   void parse(llvm::DenseSet<StringRef> &Comdats) override;
 
   ArrayRef<InputSection<ELFT> *> getSections() const { return Sections; }
 
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) const {
     uint32_t FirstNonLocal = this->Symtab->sh_info;
     if (SymbolIndex < FirstNonLocal)
       return nullptr;
-    return SymbolBodies[SymbolIndex - FirstNonLocal]->repl();
+    return SymbolBodies[SymbolIndex - FirstNonLocal];
   }
 
   Elf_Sym_Range getLocalSymbols();
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
   ArrayRef<Elf_Word> getSymbolTableShndx() const { return SymtabSHNDX; };
 
 private:

 
 public:
   SharedFileBase(ELFKind EKind, MemoryBufferRef M)
       : ELFFileBase(SharedKind, EKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == SharedKind; }
   StringRef getSoName() const { return SoName; }
   virtual void parseSoName() = 0;
   virtual void parse() = 0;
+
+  // Used for --as-needed
+  bool AsNeeded = false;
+  bool IsUsed = false;
+  bool isNeeded() const { return !AsNeeded || IsUsed; }
 };
 
 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;
 

ELF/InputFiles.cpp

template <class ELFT> void SharedFile<ELFT>::parse() {
   for (const Elf_Sym &Sym : Syms) {
     if (Sym.isUndefined())
       continue;
 
     ErrorOr<StringRef> NameOrErr = Sym.getName(this->StringTable);
     error(NameOrErr.getError());
     StringRef Name = *NameOrErr;
 
-    SymbolBodies.emplace_back(Name, Sym);
+    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/InputSection.cpp

for (const RelType &RI : Rels) {
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File.getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       const Elf_Sym *Sym = File.getObj().getRelocationSymbol(&RI, SymTab);
       if (!Sym)
         continue;
       SymVA = getLocalSymVA(Sym, File);
     } else {
-      SymbolBody &Body = *File.getSymbolBody(SymIndex);
+      SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
       SymVA = getSymVA<ELFT>(Body);
       if (Target->relocNeedsPlt(Type, Body)) {
         SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
         Type = Target->getPCRelReloc();
       } else if (Target->relocNeedsGot(Type, Body)) {
         SymVA = Out<ELFT>::Got->getEntryAddr(Body);
         Type = Target->getGotRefReloc();
       } else if (Target->relocPointsToGot(Type)) {

ELF/LinkerScript.cpp

if (S.startswith("/")) {
     if (Path.empty())
       error("Unable to find " + S);
     Driver->addFile(Saver.save(Path));
   }
 }
 
 void LinkerScript::readAsNeeded() {
   expect("(");
+  bool Orig = Config->AsNeeded;
+  Config->AsNeeded = true;
   for (;;) {
     StringRef Tok = next();
     if (Tok == ")")
-      return;
+      break;
     addFile(Tok);
   }
+  Config->AsNeeded = Orig;
 }
 
 void LinkerScript::readEntry() {
   // -e <symbol> takes predecence over ENTRY(<symbol>).
   expect("(");
   StringRef Tok = next();
   if (Config->Entry.empty())
     Config->Entry = Tok;

ELF/Options.td

 include "llvm/Option/OptParser.td"
 
 def Bdynamic: Flag<["-"], "Bdynamic">,
   HelpText<"Link against shared libraries">;
 
 def Bstatic: Flag<["-"], "Bstatic">,
   HelpText<"Do not link against shared libraries">;
 
 def L : Joined<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Directory to search for libraries">;
 
 def allow_multiple_definition: Flag<["--"], "allow-multiple-definition">,
   HelpText<"Allow multiple definitions">;
 
 def allow_shlib_undefined : Flag<["--", "-"], "allow-shlib-undefined">;
 
+def as_needed : Flag<["--"], "as-needed">;
+
 def disable_new_dtags : Flag<["--"], "disable-new-dtags">,
   HelpText<"Disable new dynamic tags">;
 
 def discard_all : Flag<["-"], "discard-all">,
   HelpText<"Delete all local symbols">;
 
 def discard_locals : Flag<["-"], "discard-locals">,
   HelpText<"Delete temporary local symbols">;

 def l : Joined<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
 def m : Separate<["-"], "m">,
   HelpText<"Set target emulation">;
 
 def no_allow_shlib_undefined : Flag<["--"], "no-allow-shlib-undefined">;
 
+def no_as_needed : Flag<["--"], "no-as-needed">;
+
 def no_whole_archive : Flag<["--"], "no-whole-archive">,
   HelpText<"Restores the default behavior of loading archive members">;
 
 def noinhibit_exec : Flag<["--"], "noinhibit-exec">,
   HelpText<"Retain the executable output file whenever it is still usable">;
 
 def no_undefined : Flag<["--"], "no-undefined">,
   HelpText<"Report unresolved symbols even if the linker is creating a shared library">;

 def alias_rpath_rpath : Joined<["-"], "rpath=">, Alias<rpath>;
 def alias_soname_h : Separate<["-"], "h">, Alias<soname>;
 def alias_soname_soname : Separate<["-"], "soname">, Alias<soname>;
 def alias_script_T : Separate<["-"], "T">, Alias<script>;
 def alias_undefined_u : Separate<["-"], "u">, Alias<undefined>;
 
 // Options listed below are silently ignored now.
 def O3 : Flag<["-"], "O3">;
-def as_needed : Flag<["--"], "as-needed">;
 def build_id : Flag<["--"], "build-id">;
 def eh_frame_hdr : Flag<["--"], "eh-frame-hdr">;
 def end_group : Flag<["--"], "end-group">;
 def gc_sections : Flag<["--"], "gc-sections">;
 def hash_style : Joined<["--"], "hash-style=">;
 def no_add_needed : Flag<["--"], "no-add-needed">;
-def no_as_needed : Flag<["--"], "no-as-needed">;
 def no_fatal_warnings : Flag<["--"], "no-fatal-warnings">;
 def start_group : Flag<["--"], "start-group">;
 def strip_all : Flag<["--"], "strip-all">;
 def version_script : Separate<["--"], "version-script">;

ELF/OutputSections.cpp

for (const DynamicReloc<ELFT> &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rel *>(Buf);
     Buf += EntrySize;
 
     const InputSection<ELFT> &C = Rel.C;
     const Elf_Rel &RI = Rel.RI;
     OutputSection<ELFT> *OutSec = C.getOutputSection();
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
     const ObjectFile<ELFT> &File = *C.getFile();
-    const SymbolBody *Body = File.getSymbolBody(SymIndex);
+    SymbolBody *Body = File.getSymbolBody(SymIndex);
     const ELFFile<ELFT> &Obj = File.getObj();
+    if (Body)
+      Body = Body->repl();
 
     uint32_t Type = RI.getType(IsMips64EL);
 
     bool CanBePreempted = canBePreempted(Body);
     uintX_t Addend = 0;
     if (!CanBePreempted) {
       if (IsRela) {
         if (Body)
template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (PreInitArraySec)
     NumEntries += 2;
   if (InitArraySec)
     NumEntries += 2;
   if (FiniArraySec)
     NumEntries += 2;
 
   for (const std::unique_ptr<SharedFile<ELFT>> &F : SymTab.getSharedFiles()) {
+    if (!F->isNeeded())
+      continue;
     Out<ELFT>::DynStrTab->add(F->getSoName());
     ++NumEntries;
   }
 
   if (Symbol *S = SymTab.getSymbols().lookup(Config->Init))
     InitSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
   if (Symbol *S = SymTab.getSymbols().lookup(Config->Fini))
     FiniSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
auto WriteArray = [&](int32_t T1, int32_t T2,
     WritePtr(T1, Sec->getVA());
     WriteVal(T2, Sec->getSize());
   };
   WriteArray(DT_PREINIT_ARRAY, DT_PREINIT_ARRAYSZ, PreInitArraySec);
   WriteArray(DT_INIT_ARRAY, DT_INIT_ARRAYSZ, InitArraySec);
   WriteArray(DT_FINI_ARRAY, DT_FINI_ARRAYSZ, FiniArraySec);
 
   for (const std::unique_ptr<SharedFile<ELFT>> &F : SymTab.getSharedFiles())
+    if (F->isNeeded())
       WriteVal(DT_NEEDED, Out<ELFT>::DynStrTab->getFileOff(F->getSoName()));
 
   if (InitSym)
     WritePtr(DT_INIT, getSymVA<ELFT>(*InitSym));
   if (FiniSym)
     WritePtr(DT_FINI, getSymVA<ELFT>(*FiniSym));
 
   if (Config->ZNow)
     WriteVal(DT_FLAGS_1, DF_1_NOW);

ELF/Symbols.h

 namespace lld {
 namespace elf2 {
 
 class ArchiveFile;
 class InputFile;
 class SymbolBody;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
+template <class ELFT> class SharedFile;
 
 // Initializes global objects defined in this file.
 // Called at the beginning of main().
 void initSymbols();
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.
 // The resolver updates SymbolBody pointers as it resolves symbols.
template <class ELFT> class SharedSymbol : public Defined<ELFT> {
   typedef Defined<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::SharedKind;
   }
 
-  SharedSymbol(StringRef Name, const Elf_Sym &Sym)
-      : Defined<ELFT>(Base::SharedKind, Name, Sym) {}
+  SharedSymbol(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym)
+      : Defined<ELFT>(Base::SharedKind, Name, Sym), File(F) {}
+
+  SharedFile<ELFT> *File;
 };
 
 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol. If the resolver finds both Undefined and Lazy for
 // the same name, it will ask the Lazy to load a file.
 class Lazy : public SymbolBody {

ELF/Writer.cpp

void Writer<ELFT>::scanRelocs(
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   const ObjectFile<ELFT> &File = *C.getFile();
   bool IsMips64EL = File.getObj().isMips64EL();
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     uint32_t Type = RI.getType(IsMips64EL);
+
+    // Set "used" bit for --as-needed.
+    if (Body && Body->isUndefined() && !Body->isWeak())
+      if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
+        S->File->IsUsed = true;
+
+    if (Body)
+      Body = Body->repl();
     if (Body) {
       if (Target->relocNeedsPlt(Type, *Body)) {
         if (Body->isInPlt())
           continue;
         Out<ELFT>::Plt->addEntry(Body);
       }
       if (Target->relocNeedsGot(Type, *Body)) {
         if (Body->isInGot())
           continue;
         Out<ELFT>::Got->addEntry(Body);
       }
     }
-    if (canBePreempted(Body)) {
+
+    bool CBP = canBePreempted(Body);
+    if (!CBP && (!Config->Shared || Target->isRelRelative(Type)))
+      continue;
+    if (CBP)
       Body->setUsedInDynamicReloc();
-      Out<ELFT>::RelaDyn->addReloc({C, RI});
-    } else if (Config->Shared && !Target->isRelRelative(Type)) {
-      Out<ELFT>::RelaDyn->addReloc({C, RI});
-    }
   }
 }
 
 template <class ELFT>
 void Writer<ELFT>::scanRelocs(const InputSection<ELFT> &C) {
   ObjectFile<ELFT> *File = C.getFile();
   ELFFile<ELFT> &EObj = File->getObj();
 
   if (!(C.getSectionHdr()->sh_flags & SHF_ALLOC))
     return;
 
   for (const Elf_Shdr *RelSec : C.RelocSections) {

test/elf2/Inputs/shared2.s

+.global bar2
+.type bar2, @function
+bar2:
+
+.global zed2
+zed2:

test/elf2/as-needed.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %p/Inputs/shared.s -o %t2.o
+// RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %p/Inputs/shared2.s -o %t3.o
+// RUN: ld.lld2 -shared %t2.o -soname shared1 -o %t2.so
+// RUN: ld.lld2 -shared %t3.o -soname shared2 -o %t3.so
+
+// RUN: ld.lld2 %t.o %t2.so %t3.so -o %t2
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
+
+// RUN: ld.lld2 --as-needed %t.o %t2.so %t3.so -o %t2
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck -check-prefix=CHECK2 %s
+
+// RUN: ld.lld2 --as-needed %t.o %t2.so --no-as-needed %t3.so -o %t2
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
+
+// RUN: echo "GROUP(" %t2.so %t3.so ")" > %t.script
+// RUN: ld.lld2 %t.o %t.script -o %t2
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
+
+// RUN: echo "GROUP(AS_NEEDED(" %t2.so %t3.so "))" > %t.script
+// RUN: ld.lld2 %t.o %t.script -o %t2
+// RUN: llvm-readobj -dynamic-table %t2 | FileCheck -check-prefix=CHECK2 %s
+
+// CHECK: NEEDED SharedLibrary (shared1)
+// CHECK: NEEDED SharedLibrary (shared2)
+
+// CHECK2:     NEEDED SharedLibrary (shared1)
+// CHECK2-NOT: NEEDED SharedLibrary (shared2)
+
+.global _start
+_start:
+.long bar
+.long zed