[ELF] Linkerscript: symbol assignments with indentifiers on the right side of expression.

[grimar]

Summary

In symbol assignments symbol may appear on the right-hand side of the expression:
(https://svnweb.freebsd.org/base/head/sys/conf/ldscript.amd64?revision=284870&view=markup#l8)

 /* Read-only sections, merged into text segment: */
kernphys = CONSTANT (MAXPAGESIZE);
 . = kernbase + kernphys + SIZEOF_HEADERS;

Patch implements that.

[ruiu]

ELF/LinkerScript.cpp

776–778

Please do this.

uint64_t static getSymbolValue(StringRef S) {
  switch (Config->EKind) {
  case ELF32LEKind:
    if (SymbolBody *B = Symtab<ELF32LE>::X->find(S))
      return B->getVA<ELF32LE>();
    break;
  case ELF32BEKind:
    ...
  case ELF64LEKind:
    ...
  case ELF64BEKind:
    ...
  }
  error("symbol not found: " + S);
  return 0;
}

[grimar]

• Addressed review comments.
• Improved testcase.

[ruiu]

LGTM

ELF/LinkerScript.cpp

740

uint64_t static -> static uint64_t.

758–759

We don't need this guard.

824

Parse a symbol name or a number literal.

[grimar]

ELF/LinkerScript.cpp

740

Done.

758–759

Removed.

776–778

Done.

824

Fixed.

ELF/Driver.cpp

 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
   elf::Symtab<ELFT>::X = &Symtab;
 
   std::unique_ptr<TargetInfo> TI(createTarget());
   Target = TI.get();
   LinkerScript<ELFT> LS;
   Script<ELFT>::X = &LS;
+  ScriptConfig->ExprBridge = &LS;
 
   Config->Rela = ELFT::Is64Bits || Config->EMachine == EM_X86_64;
   Config->Mips64EL =
       (Config->EMachine == EM_MIPS && Config->EKind == ELF64LEKind);
 
   // Add entry symbol. Note that AMDGPU binaries have no entry points.
   if (Config->Entry.empty() && !Config->Shared && !Config->Relocatable &&
       Config->EMachine != EM_AMDGPU)

ELF/LinkerScript.h

 struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;
   bool HasPhdrs;
   unsigned Flags;
 };
 
+class ExpressionsBridge {
+public:
+  virtual uint64_t getSymbolValue(StringRef Sym) = 0;
+};
+
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // Used to assign addresses to sections.
   std::vector<std::unique_ptr<BaseCommand>> Commands;
 
   // Used to assign sections to headers.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool DoLayout = false;
 
   llvm::BumpPtrAllocator Alloc;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<StringRef> KeptSections;
+
+  ExpressionsBridge *ExprBridge = nullptr;
 };
 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
-template <class ELFT> class LinkerScript {
+template <class ELFT> class LinkerScript : public ExpressionsBridge {
   typedef typename ELFT::uint uintX_t;
 
 public:
   std::vector<OutputSectionBase<ELFT> *>
   createSections(OutputSectionFactory<ELFT> &Factory);
 
   std::vector<PhdrEntry<ELFT>>
   createPhdrs(ArrayRef<OutputSectionBase<ELFT> *> S);
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   bool hasPhdrsCommands();
 
+  uint64_t getSymbolValue(StringRef Sym) override;
+
 private:
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   void dispatchAssignment(SymbolAssignment *Cmd);
 

ELF/LinkerScript.cpp

else
       Cmd->Ignore = Cmd->Provide;
   }
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::hasPhdrsCommands() {
   return !Opt.PhdrsCommands.empty();
 }
 
+template <class ELFT>
+uint64_t LinkerScript<ELFT>::getSymbolValue(StringRef Sym) {
+  if (SymbolBody *B = Symtab<ELFT>::X->find(Sym))
+    return B->getVA<ELFT>();
+  error("malformed number: " + Sym);
+  return 0;
+}
+
 // Returns indices of ELF headers containing specific section, identified
 // by Name. Each index is a zero based number of ELF header listed within
 // PHDRS {} script block.
 template <class ELFT>
 std::vector<size_t> LinkerScript<ELFT>::getPhdrIndices(StringRef SectionName) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
     if (!Cmd || Cmd->Name != SectionName)
SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   Opt.Commands.emplace_back(Cmd);
   return Cmd;
 }
 
 // This is an operator-precedence parser to parse a linker
 // script expression.
 Expr ScriptParser::readExpr() { return readExpr1(readPrimary(), 0); }
 
 // This is a part of the operator-precedence parser. This function
 // assumes that the remaining token stream starts with an operator.
 Expr ScriptParser::readExpr1(Expr Lhs, int MinPrec) {
   while (!atEOF() && !Error) {
     // Read an operator and an expression.
     StringRef Op1 = peek();
     if (Op1 == "?")
       return readTernary(Lhs);
     if (precedence(Op1) < MinPrec)
       break;
     next();
     Expr Rhs = readPrimary();
 
     // Evaluate the remaining part of the expression first if the
     // next operator has greater precedence than the previous one.
     // For example, if we have read "+" and "3", and if the next
     // operator is "*", then we'll evaluate 3 * ... part first.
     while (!atEOF()) {
       StringRef Op2 = peek();
       if (precedence(Op2) <= precedence(Op1))
         break;
       Rhs = readExpr1(Rhs, precedence(Op2));
     }
 
     Lhs = combine(Op1, Lhs, Rhs);
   }
   return Lhs;
 }
 
 uint64_t static getConstant(StringRef S) {
   if (S == "COMMONPAGESIZE" || S == "MAXPAGESIZE")
     return Target->PageSize;
   error("unknown constant: " + S);
   return 0;
 }
 
+uint64_t static getSymbolValue(StringRef S) {
+  return ScriptConfig->ExprBridge->getSymbolValue(S);
+}
+
 Expr ScriptParser::readPrimary() {
   StringRef Tok = next();
 
   if (Tok == ".")
     return [](uint64_t Dot) { return Dot; };
 
   if (Tok == "(") {
     Expr E = readExpr();
Expr ScriptParser::readPrimary() {
   }
   if (Tok == "DATA_SEGMENT_END") {
     expect("(");
     expect(".");
     expect(")");
     return [](uint64_t Dot) { return Dot; };
   }
 
   // Parse a number literal
   uint64_t V = 0;
-  if (Tok.getAsInteger(0, V))
+  if (Tok.getAsInteger(0, V)) {
+    if (!isValidCIdentifier(Tok))
       setError("malformed number: " + Tok);
+    return [=](uint64_t Dot) { return getSymbolValue(Tok); };
+  }
   return [=](uint64_t Dot) { return V; };
 }
 
 Expr ScriptParser::readTernary(Expr Cond) {
   next();
   Expr L = readExpr();
   expect(":");
   Expr R = readExpr();

test/ELF/linkerscript/linkerscript-symbol-assignexpr.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { \
+# RUN:         symbol =  CONSTANT(MAXPAGESIZE); \
+# RUN:         symbol2 = symbol + 0x1234; \
+# RUN:         symbol3 = symbol2; \
+# RUN:       }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -t %t1 | FileCheck %s
+
+# CHECK:      SYMBOL TABLE:
+# CHECK-NEXT: 0000000000000000 *UND* 00000000
+# CHECK-NEXT: 0000000000000120 .text 00000000 _start
+# CHECK-NEXT: 0000000000000121 .text 00000000 foo
+# CHECK-NEXT: 0000000000001000 *ABS* 00000000 symbol
+# CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol2
+# CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol3
+
+.global _start
+_start:
+ nop
+
+.global foo
+foo: