[ELF] Linkerscript: support ABSOLUTE keyword in symbol assignment expression

[evgeny777]

Summary

ABSOLUTE keyword is supported only in symbol assignment expression, i.e

a = ABSOLUTE(.);

In reality it's more complex than that, but full support requires rewriting significant part of script parser.

[grimar]

ELF/LinkerScript.cpp

1163 ↗

(On Diff #70003)

readParenExpr ?

[ruiu]

ELF/LinkerScript.cpp

279 ↗

(On Diff #70003)

Needs comment.

283 ↗

(On Diff #70003)

Early return.

286–287 ↗

(On Diff #70003)

Why do you have to replace a symbol here only when it is an absolute symbol?

[evgeny777]

ELF/LinkerScript.cpp

286–287 ↗

(On Diff #70003)

Because it is initially created as synthetic in addSynthetic()

[ruiu]

ELF/LinkerScript.cpp

286–287 ↗

(On Diff #70003)

Why don't you create that as a DefinedRegular symbol from the beginning?

[evgeny777]

ELF/LinkerScript.cpp

286–287 ↗

(On Diff #70003)

To avoid creating symbol if section is discarded for some reason. Initially all section symbols are created as synthetics with Section pointer set to nullptr. If lld does not create output section those symbols will not be added to symbol table. Not sure, though, if it is right behavior if ABSOLUTE keyword is present

[evgeny777]

Diff updated. Symbols defined in empty regular output sections do not work correctly in current version (you get symbol with invalid section index)
in symtab. I'll make a separate review for this.

[ruiu]

LGTM with a few nits.

ELF/LinkerScript.cpp

189 ↗

(On Diff #70313)

This seems to be dead.

1166–1167 ↗

(On Diff #70313)

if (skip("ABSOLUTE")) {

lld/trunk/ELF/LinkerScript.h

 
 struct BaseCommand {
   BaseCommand(int K) : Kind(K) {}
   virtual ~BaseCommand() {}
   int Kind;
 };
 
 struct SymbolAssignment : BaseCommand {
-  SymbolAssignment(StringRef Name, Expr E)
-      : BaseCommand(AssignmentKind), Name(Name), Expression(E) {}
+  SymbolAssignment(StringRef Name, Expr E, bool IsAbsolute)
+      : BaseCommand(AssignmentKind), Name(Name), Expression(E),
+        IsAbsolute(IsAbsolute) {}
   static bool classof(const BaseCommand *C);
 
   // The LHS of an expression. Name is either a symbol name or ".".
   StringRef Name;
   SymbolBody *Sym = nullptr;
 
   // The RHS of an expression.
   Expr Expression;
 
   // Command attributes for PROVIDE, HIDDEN and PROVIDE_HIDDEN.
   bool Provide = false;
   bool Hidden = false;
+  bool IsAbsolute;
   InputSectionData *GoesAfter = nullptr;
 };
 
 // Linker scripts allow additional constraints to be put on ouput sections.
 // An output section will only be created if all of its input sections are
 // read-only
 // or all of its input sections are read-write by using the keyword ONLY_IF_RO
 // and ONLY_IF_RW respectively.

lld/trunk/ELF/LinkerScript.cpp

 }
 
 template <class ELFT> static void addSynthetic(SymbolAssignment *Cmd) {
   Symbol *Sym = Symtab<ELFT>::X->addSynthetic(
       Cmd->Name, nullptr, 0, Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT);
   Cmd->Sym = Sym->body();
 }
 
+template <class ELFT> static void addSymbol(SymbolAssignment *Cmd) {
+  if (Cmd->IsAbsolute)
+    addRegular<ELFT>(Cmd);
+  else
+    addSynthetic<ELFT>(Cmd);
+}
 // If a symbol was in PROVIDE(), we need to define it only when
 // it is an undefined symbol.
 template <class ELFT> static bool shouldDefine(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
     return false;
   if (!Cmd->Provide)
     return true;
   SymbolBody *B = Symtab<ELFT>::X->find(Cmd->Name);

 std::vector<InputSectionBase<ELFT> *>
 LinkerScript<ELFT>::createInputSectionList(OutputSectionCommand &OutCmd) {
   std::vector<InputSectionBase<ELFT> *> Ret;
   DenseSet<InputSectionBase<ELFT> *> SectionIndex;
 
   for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     if (auto *OutCmd = dyn_cast<SymbolAssignment>(Base.get())) {
       if (shouldDefine<ELFT>(OutCmd))
-        addSynthetic<ELFT>(OutCmd);
+        addSymbol<ELFT>(OutCmd);
       OutCmd->GoesAfter = Ret.empty() ? nullptr : Ret.back();
       continue;
     }
 
     auto *Cmd = cast<InputSectionDescription>(Base.get());
     std::vector<InputSectionBase<ELFT> *> V = getInputSections(Cmd);
     if (!matchConstraints<ELFT>(V, OutCmd.Constraint))
       continue;
for (InputSectionBase<ELFT> *S : F->getSections()) {
       std::tie(OutSec, IsNew) = Factory.create(S, getOutputSectionName(S));
       if (IsNew)
         OutputSections->push_back(OutSec);
       OutSec->addSection(S);
     }
   }
 }
 
+// Sets value of a section-defined symbol. Two kinds of
+// symbols are processed: synthetic symbols, whose value
+// is an offset from beginning of section and regular
+// symbols whose value is absolute.
+template <class ELFT>
+static void assignSectionSymbol(SymbolAssignment *Cmd,
+                                OutputSectionBase<ELFT> *Sec,
+                                typename ELFT::uint Off) {
+  if (!Cmd->Sym)
+    return;
+
+  if (auto *Body = dyn_cast<DefinedSynthetic<ELFT>>(Cmd->Sym)) {
+    Body->Section = Sec;
+    Body->Value = Cmd->Expression(Sec->getVA() + Off) - Sec->getVA();
+    return;
+  }
+  auto *Body = cast<DefinedRegular<ELFT>>(Cmd->Sym);
+  Body->Value = Cmd->Expression(Sec->getVA() + Off);
+}
+
 // Linker script may define start and end symbols for special section types,
 // like .got, .eh_frame_hdr, .eh_frame and others. Those sections are not a list
 // of regular input input sections, therefore our way of defining symbols for
 // regular sections will not work. The approach we use for special section types
 // is not perfect - it handles only start and end symbols.
 template <class ELFT>
 void addStartEndSymbols(OutputSectionCommand *Cmd,
                         OutputSectionBase<ELFT> *Sec) {
   bool Start = true;
   BaseCommand *PrevCmd = nullptr;
 
   for (std::unique_ptr<BaseCommand> &Base : Cmd->Commands) {
     if (auto *AssignCmd = dyn_cast<SymbolAssignment>(Base.get())) {
-      if (auto *Sym = cast_or_null<DefinedSynthetic<ELFT>>(AssignCmd->Sym)) {
-        Sym->Section = Sec;
-        Sym->Value =
-            AssignCmd->Expression(Sec->getVA() + (Start ? 0 : Sec->getSize())) -
-            Sec->getVA();
-      }
+      assignSectionSymbol<ELFT>(AssignCmd, Sec, Start ? 0 : Sec->getSize());
     } else {
       if (!Start && isa<SymbolAssignment>(PrevCmd))
         error("section '" + Sec->getName() +
               "' supports only start and end symbols");
       Start = false;
     }
     PrevCmd = Base.get();
   }
void assignOffsets(OutputSectionCommand *Cmd, OutputSectionBase<ELFT> *Sec) {
   auto AssignSuccessors = [&](InputSectionData *D) {
     for (; ItCmd != Cmd->Commands.end(); ++ItCmd) {
       auto *AssignCmd = dyn_cast<SymbolAssignment>(ItCmd->get());
       if (!AssignCmd)
         continue;
       if (D != AssignCmd->GoesAfter)
         break;
 
-      uintX_t Value = AssignCmd->Expression(Sec->getVA() + Off) - Sec->getVA();
       if (AssignCmd->Name == ".") {
         // Update to location counter means update to section size.
-        Off = Value;
+        Off = AssignCmd->Expression(Sec->getVA() + Off) - Sec->getVA();
         Sec->setSize(Off);
         continue;
       }
-
-      if (DefinedSynthetic<ELFT> *Sym =
-              cast_or_null<DefinedSynthetic<ELFT>>(AssignCmd->Sym)) {
-        Sym->Section = OutSec;
-        Sym->Value = Value;
-      }
+      assignSectionSymbol<ELFT>(AssignCmd, Sec, Off);
     }
   };
 
   AssignSuccessors(nullptr);
   for (InputSection<ELFT> *I : OutSec->Sections) {
     Off = alignTo(Off, I->Alignment);
     I->OutSecOff = Off;
     Off += I->getSize();
private:
   std::vector<uint8_t> readOutputSectionFiller(StringRef Tok);
   std::vector<StringRef> readOutputSectionPhdrs();
   InputSectionDescription *readInputSectionDescription(StringRef Tok);
   Regex readFilePatterns();
   InputSectionDescription *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
   SortKind readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
-  SymbolAssignment *readProvideOrAssignment(StringRef Tok);
+  SymbolAssignment *readProvideOrAssignment(StringRef Tok, bool MakeAbsolute);
   void readSort();
   Expr readAssert();
 
   Expr readExpr();
   Expr readExpr1(Expr Lhs, int MinPrec);
   Expr readPrimary();
   Expr readTernary(Expr Cond);
   Expr readParenExpr();
while (!atEOF()) {
     } else if (Tok == "PHDRS") {
       readPhdrs();
     } else if (Tok == "SEARCH_DIR") {
       readSearchDir();
     } else if (Tok == "SECTIONS") {
       readSections();
     } else if (Tok == "VERSION") {
       readVersion();
-    } else if (SymbolAssignment *Cmd = readProvideOrAssignment(Tok)) {
+    } else if (SymbolAssignment *Cmd = readProvideOrAssignment(Tok, true)) {
       if (Opt.HasContents)
         Opt.Commands.emplace_back(Cmd);
       else
         Opt.Assignments.emplace_back(Cmd);
     } else {
       setError("unknown directive: " + Tok);
     }
   }
void ScriptParser::readSearchDir() {
   expect(")");
 }
 
 void ScriptParser::readSections() {
   Opt.HasContents = true;
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = next();
-    BaseCommand *Cmd = readProvideOrAssignment(Tok);
+    BaseCommand *Cmd = readProvideOrAssignment(Tok, true);
     if (!Cmd) {
       if (Tok == "ASSERT")
         Cmd = new AssertCommand(readAssert());
       else
         Cmd = readOutputSectionDescription(Tok);
     }
     Opt.Commands.emplace_back(Cmd);
   }
ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   if (skip("ONLY_IF_RO"))
     Cmd->Constraint = ConstraintKind::ReadOnly;
   if (skip("ONLY_IF_RW"))
     Cmd->Constraint = ConstraintKind::ReadWrite;
   expect("{");
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
-    if (SymbolAssignment *Assignment = readProvideOrAssignment(Tok))
+    if (SymbolAssignment *Assignment = readProvideOrAssignment(Tok, false))
       Cmd->Commands.emplace_back(Assignment);
     else if (Tok == "FILL")
       Cmd->Filler = readFill();
     else if (Tok == "SORT")
       readSort();
     else if (peek() == "(")
       Cmd->Commands.emplace_back(readInputSectionDescription(Tok));
     else
SymbolAssignment *ScriptParser::readProvideHidden(bool Provide, bool Hidden) {
   SymbolAssignment *Cmd = readAssignment(next());
   Cmd->Provide = Provide;
   Cmd->Hidden = Hidden;
   expect(")");
   expect(";");
   return Cmd;
 }
 
-SymbolAssignment *ScriptParser::readProvideOrAssignment(StringRef Tok) {
+SymbolAssignment *ScriptParser::readProvideOrAssignment(StringRef Tok,
+                                                        bool MakeAbsolute) {
   SymbolAssignment *Cmd = nullptr;
   if (peek() == "=" || peek() == "+=") {
     Cmd = readAssignment(Tok);
     expect(";");
   } else if (Tok == "PROVIDE") {
     Cmd = readProvideHidden(true, false);
   } else if (Tok == "HIDDEN") {
     Cmd = readProvideHidden(false, true);
   } else if (Tok == "PROVIDE_HIDDEN") {
     Cmd = readProvideHidden(true, true);
   }
+  if (Cmd && MakeAbsolute)
+    Cmd->IsAbsolute = true;
   return Cmd;
 }
 
 static uint64_t getSymbolValue(StringRef S, uint64_t Dot) {
   if (S == ".")
     return Dot;
 
   switch (Config->EKind) {
case ELF64BEKind:
     return Script<ELF64BE>::X->getHeaderSize();
   default:
     llvm_unreachable("unsupported target");
   }
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   StringRef Op = next();
+  bool IsAbsolute = false;
+  Expr E;
   assert(Op == "=" || Op == "+=");
-  Expr E = readExpr();
+  if (skip("ABSOLUTE")) {
+    E = readParenExpr();
+    IsAbsolute = true;
+  } else {
+    E = readExpr();
+  }
   if (Op == "+=")
     E = [=](uint64_t Dot) { return getSymbolValue(Name, Dot) + E(Dot); };
-  return new SymbolAssignment(Name, E);
+  return new SymbolAssignment(Name, E, IsAbsolute);
 }
 
 // This is an operator-precedence parser to parse a linker
 // script expression.
 Expr ScriptParser::readExpr() { return readExpr1(readPrimary(), 0); }
 
 static Expr combine(StringRef Op, Expr L, Expr R) {
   if (Op == "*")

lld/trunk/test/ELF/linkerscript/symbols-synthetic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # Simple symbol assignment within input section list. The '.' symbol
 # is not location counter but offset from the beginning of output
 # section .foo
 # RUN: echo "SECTIONS { \
 # RUN:          .foo : { \
 # RUN:              begin_foo = .; \
 # RUN:              PROVIDE(_begin_sec = .); \
 # RUN:              *(.foo) \
 # RUN:              end_foo = .; \
 # RUN:              PROVIDE_HIDDEN(_end_sec = .); \
+# RUN:              PROVIDE(_end_sec_abs = ABSOLUTE(.)); \
 # RUN:              size_foo_1 = SIZEOF(.foo); \
+# RUN:              size_foo_1_abs = ABSOLUTE(SIZEOF(.foo)); \
 # RUN:              . = ALIGN(0x1000); \
 # RUN:              begin_bar = .; \
 # RUN:              *(.bar) \
 # RUN:              end_bar = .; \
 # RUN:              size_foo_2 = SIZEOF(.foo); } \
 # RUN:          size_foo_3 = SIZEOF(.foo); \
 # RUN:          .eh_frame_hdr : { \
 # RUN:             __eh_frame_hdr_start = .; \
-# RUN:             __eh_frame_hdr_start2 = ALIGN(0x10); \
+# RUN:             __eh_frame_hdr_start2 = ABSOLUTE(ALIGN(0x10)); \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             __eh_frame_hdr_end = .; \
-# RUN:             __eh_frame_hdr_end2 = ALIGN(0x10); } \
+# RUN:             __eh_frame_hdr_end2 = ABSOLUTE(ALIGN(0x10)); } \
 # RUN:       }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE %s
 
 # The script below contains symbols in the middle of .eh_frame_hdr section.
 # We don't support this.
 # RUN: echo "SECTIONS { \
 # RUN:          .eh_frame_hdr : { \
 # RUN:             PROVIDE_HIDDEN(_begin_sec = .); \
 # RUN:             __eh_frame_hdr_start = .; \
 # RUN:             *(.eh_frame_hdr) \
-# RUN:             __eh_frame_hdr_end = .; \
+# RUN:             PROVIDE_HIDDEN(_end_sec_abs = ABSOLUTE(.)); \
 # RUN:             *(.eh_frame_hdr) } \
 # RUN:             PROVIDE_HIDDEN(_end_sec = .); \
 # RUN:         }" > %t.script
 # RUN: not ld.lld -o %t1 --eh-frame-hdr --script %t.script %t 2>&1 | FileCheck --check-prefix=ERROR %s
 
 # Check that the following script is processed without errors
 # RUN: echo "SECTIONS { \
 # RUN:          .eh_frame_hdr : { \
 # RUN:             PROVIDE_HIDDEN(_begin_sec = .); \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             *(.eh_frame_hdr) \
+# RUN:             PROVIDE_HIDDEN(_end_sec_abs = ABSOLUTE(.)); \
 # RUN:             PROVIDE_HIDDEN(_end_sec = .); } \
 # RUN:         }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 
 # SIMPLE:      0000000000000160         .foo    00000000 .hidden _end_sec
 # SIMPLE:      0000000000000158         .foo    00000000 _begin_sec
+# SIMPLE-NEXT: 0000000000000160         *ABS*   00000000 _end_sec_abs
 # SIMPLE-NEXT: 0000000000000158         .foo    00000000 begin_foo
 # SIMPLE-NEXT: 0000000000000160         .foo    00000000 end_foo
 # SIMPLE-NEXT: 0000000000000008         .foo    00000000 size_foo_1
+# SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1_abs
 # SIMPLE-NEXT: 0000000000001000         .foo    00000000 begin_bar
 # SIMPLE-NEXT: 0000000000001004         .foo    00000000 end_bar
 # SIMPLE-NEXT: 0000000000000eac         .foo    00000000 size_foo_2
 # SIMPLE-NEXT: 0000000000000eac         *ABS*   00000000 size_foo_3
 # SIMPLE-NEXT: 0000000000001004         .eh_frame_hdr     00000000 __eh_frame_hdr_start
-# SIMPLE-NEXT: 0000000000001010         .eh_frame_hdr     00000000 __eh_frame_hdr_start2
+# SIMPLE-NEXT: 0000000000001010         *ABS*             00000000 __eh_frame_hdr_start2
 # SIMPLE-NEXT: 0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
-# SIMPLE-NEXT: 0000000000001020         .eh_frame_hdr     00000000 __eh_frame_hdr_end2
+# SIMPLE-NEXT: 0000000000001020         *ABS*             00000000 __eh_frame_hdr_end2
 # ERROR: section '.eh_frame_hdr' supports only start and end symbols
 
 .global _start
 _start:
  nop
 
 .section .foo,"a"
  .quad 0
 
 .section .bar,"a"
  .long 0
 
 .section .dah,"ax",@progbits
  .cfi_startproc
  nop
  .cfi_endproc
 
-.global _begin_sec, _end_sec
+.global _begin_sec, _end_sec, _end_sec_abs