[ELF] - Scan lazy linkerscipt symbols early.

[grimar]

Summary

This is PR32026, we have next issue currently:

If script has a symbol assignment, for example PROVIDE(foo = 5)
and that foo is a lazy symbol. Then code that invokes processCommands()...addSymbol(Cmd);
will fetch that archive much later than we expect to see new sections to appear.

We have next code and comment:

void LinkerDriver::link(opt::InputArgList &Args) {
..
  // Now that we have a complete list of input files.
  // Beyond this point, no new files are added.

But that comment becomes not true in that case. We are adding new sections
from that archive for processing foo much later. Also if object where foo lives contains
mergeable section, then code that do splitIntoPieces() is completely skipped,
also this section is not merged into synthetic output section, because we doo that early.

To avoid that, patch implement early scan of assignments.
One of problems is that it does not support symbols definitions inside sections declarations,
like: ".foo : { ...; bar = .; }". It is complicated to implement those because we still need to filter
out sections not matching the constraints, so cant just add such symbols early like I did in this patch for
symbols outside. (Though I am not sure such symbols are really used in real livfe)

I think best way to implement it (if we want) is the next:
As an alternative solution probably we can reimplement handling of mergeable sections
and do not merge them into synthetics early, just like D29223 did.
I think that way later addition of sections and files will not be a problem, we should be
able to invoke merging and splitIntoPieces() from script side when we need it.
That way support of symbols like bar from above should be easy, though that complicates
the implementation of other parts, not sure if we want it now.

[grimar]

• Removed unused include

[grimar]

• Simplified testcase.

[ruiu]

As to this patch, pulling out an object file is not a right thing to do here. A rule of thumb is that you should fetch an object file from an archive only when otherwise the link would fail because of an undefined symbol. This is not the case.

[grimar]

This one incorrect, D30224 was correct way of fixing it.

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
 
   Symtab.addCombinedLTOObject();
   if (ErrorCount)
     return;
 
   for (auto *Arg : Args.filtered(OPT_wrap))
     Symtab.wrap(Arg->getValue());
 
+  Script<ELFT>::X->fetchLazySymbols();
+
   // Now that we have a complete list of input files.
   // Beyond this point, no new files are added.
   // Aggregate all input sections into one place.
   for (elf::ObjectFile<ELFT> *F : Symtab.getObjectFiles())
     for (InputSectionBase<ELFT> *S : F->getSections())
       if (S && S != &InputSection<ELFT>::Discarded)
         Symtab.Sections.push_back(S);
   for (BinaryFile *F : Symtab.getBinaryFiles())

ELF/LinkerScript.h

 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript final : public LinkerScriptBase {
   typedef typename ELFT::uint uintX_t;
 
 public:
   LinkerScript();
   ~LinkerScript();
 
+  void fetchLazySymbols();
   void processCommands(OutputSectionFactory<ELFT> &Factory);
   void addOrphanSections(OutputSectionFactory<ELFT> &Factory);
   void removeEmptyCommands();
   void adjustSectionsBeforeSorting();
   void adjustSectionsAfterSorting();
 
   std::vector<PhdrEntry> createPhdrs();
   bool ignoreInterpSection();

ELF/LinkerScript.cpp

for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     computeInputSections(Cmd);
     for (InputSectionData *S : Cmd->Sections)
       Ret.push_back(static_cast<InputSectionBase<ELFT> *>(S));
   }
 
   return Ret;
 }
 
+// Script can contain assignments to lazy symbols. In that case
+// we should scan such symbols early to fetch objects from archives
+// and create input sections.
+template <class ELFT> void LinkerScript<ELFT>::fetchLazySymbols() {
+  for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
+    if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get()))
+      if (SymbolBody *Sym = Symtab<ELFT>::X->find(Cmd->Name))
+        if (Sym->isLazy())
+          addSymbol(Cmd);
+}
+
 template <class ELFT>
 void LinkerScript<ELFT>::processCommands(OutputSectionFactory<ELFT> &Factory) {
   for (unsigned I = 0; I < Opt.Commands.size(); ++I) {
     auto Iter = Opt.Commands.begin() + I;
     const std::unique_ptr<BaseCommand> &Base1 = *Iter;
 
     // Handle symbol assignments outside of any output section.
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {

test/ELF/linkerscript/Inputs/lazy-symbols.s

+.globl foo
+foo:
+ .long .Linfo_string
+ 
+.section .debug_str,"MS",@progbits,1
+.Linfo_string:
+  .asciz "foo"

test/ELF/linkerscript/lazy-symbols.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/lazy-symbols.s -o %t1
+# RUN: llvm-ar rcs %tar %t1
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t2
+# RUN: echo "foo = 1;" > %t.script
+# RUN: ld.lld %t2 %tar --script %t.script -o %tout
+# RUN: llvm-readobj -symbols %tout | FileCheck %s
+
+# CHECK: Name: foo
+# CHECK-NEXT: Value: 0x1