[ELF] Allow references to reserved symbols in linker scripts

[phosek]

Summary

This requires collectign all symbols referenced in the linker script and adding them to symbol table as undefined symbol.

[ruiu]

It's not obvious what you are fixing with this patch. Can you describe a little?

[phosek]

In D31147#706917, @ruiu wrote:

It's not obvious what you are fixing with this patch. Can you describe a little?

Yes, we'd like to be able to reference reserved symbols from input linker scripts, e.g. PROVIDE_HIDDEN(newsym = __ehdr_start) (where __ehdr_start could be any other reserved symbol like __edata_start__). This currently fails with __ehdr_start being reported as undefined symbol. This is something that both GNU linker handle fine. One use case for this feature is an alternative solution to D26133.

[ruiu]

ELF/LinkerScript.cpp

1884 ↗

(On Diff #92369)

You want to add this to Config->Undefined instead of your own new array.

Please add a comment saying that some special symbols (such as __ehdr_start) are defined only when there are undefined symbols for them, so we add undefined symbols to trigger that logic.

[phosek]

ELF/LinkerScript.cpp

1884 ↗

(On Diff #92369)

I tried as the initial solution, the problem is that the logic for processing Config->Undefined currently only handles Lazy files; it checks if the symbol is defined in any of the input Lazy files and if so it loads it in. However, the reserved symbols are not defined in any input file.

I think the best solution would be to introduce a new InputFile subclass for representing input linker scripts (which is what they really are). It'd require some changes, e.g. we'd have to stop using a single global LinkerScript instance for all linker scripts, instead each input script will have to have its own. I can try to implement that solution if that would be fine with you?

[ruiu]

ELF/LinkerScript.cpp

1884 ↗

(On Diff #92369)

That sounds too much. I don't think linker scripts are input files but in my view they are rather extended command line options. I prefer this patch over the proposed solution.

By the way, instead of defining LinkerScript<ELFT>::addUndefined, you can do something like this in the driver.

for (StringRef Sym : Script->Opt.UndefinedSymbols)
  Symtab.addUndefined(Sym);

[ruiu]

LGTM

lld/trunk/ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   Symtab.scanUndefinedFlags();
   Symtab.scanShlibUndefined();
   Symtab.scanVersionScript();
 
   Symtab.addCombinedLTOObject();
   if (ErrorCount)
     return;
 
+  // Some symbols (such as __ehdr_start) are defined lazily only when there
+  // are undefined symbols for them, so we add these to trigger that logic.
+  for (StringRef Sym : Script->Opt.UndefinedSymbols)
+    Symtab.addUndefined(Sym);
+
   for (auto *Arg : Args.filtered(OPT_wrap))
     Symtab.wrap(Arg->getValue());
 
   // 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 *S : F->getSections())

lld/trunk/ELF/LinkerScript.h

struct ScriptConfiguration {
   bool HasSections = false;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<InputSectionDescription *> KeptSections;
 
   // A map from memory region name to a memory region descriptor.
   llvm::DenseMap<llvm::StringRef, MemoryRegion> MemoryRegions;
+
+  // A list of undefined symbols referenced by the script.
+  std::vector<llvm::StringRef> UndefinedSymbols;
 };
 
 class LinkerScript {
 protected:
   void assignSymbol(SymbolAssignment *Cmd, bool InSec = false);
   void computeInputSections(InputSectionDescription *);
   void setDot(Expr E, const Twine &Loc, bool InSec = false);
 

lld/trunk/ELF/LinkerScript.cpp

 }
 
 ExprValue LinkerScript::getSymbolValue(const Twine &Loc, StringRef S) {
   if (S == ".")
     return {CurOutSec, Dot - CurOutSec->Addr};
   if (SymbolBody *B = findSymbol(S)) {
     if (auto *D = dyn_cast<DefinedRegular>(B))
       return {D->Section, D->Value};
-    auto *C = cast<DefinedCommon>(B);
+    if (auto *C = dyn_cast<DefinedCommon>(B))
       return {InX::Common, C->Offset};
   }
   error(Loc + ": symbol not found: " + S);
   return 0;
 }
 
 bool LinkerScript::isDefined(StringRef S) { return findSymbol(S) != nullptr; }
 
 // Returns indices of ELF headers containing specific section, identified
if (Tok == "SIZEOF_HEADERS")
     return [=] { return elf::getHeaderSize(); };
 
   // Tok is a literal number.
   uint64_t V;
   if (readInteger(Tok, V))
     return [=] { return V; };
 
   // Tok is a symbol name.
-  if (Tok != "." && !isValidCIdentifier(Tok))
+  if (Tok != ".") {
+    if (!isValidCIdentifier(Tok))
       setError("malformed number: " + Tok);
+    Script->Opt.UndefinedSymbols.push_back(Tok);
+  }
   return [=] { return Script->getSymbolValue(Location, Tok); };
 }
 
 Expr ScriptParser::readTernary(Expr Cond) {
   Expr L = readExpr();
   expect(":");
   Expr R = readExpr();
   return [=] { return Cond().getValue() ? L() : R(); };

lld/trunk/test/ELF/linkerscript/symbol-reserved.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "PROVIDE_HIDDEN(newsym = __ehdr_start + 5);" > %t.script
+# RUN: ld.lld -o %t1 %t.script %t
+# RUN: llvm-objdump -t %t1 | FileCheck %s
+
+# CHECK: 0000000000200005 .text 00000000 .hidden newsym
+
+# RUN: ld.lld -o %t1.so %t.script %t -shared
+# RUN: llvm-objdump -t %t1.so | FileCheck --check-prefix=SHARED %s
+
+# SHARED: 0000000000000005 .dynsym 00000000 .hidden newsym
+
+.global _start
+_start:
+  lea newsym(%rip),%rax