[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

readParenExpr ?

[ruiu]

ELF/LinkerScript.cpp

279

Needs comment.

283

Early return.

286–287

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

[evgeny777]

ELF/LinkerScript.cpp

286–287

Because it is initially created as synthetic in addSynthetic()

[ruiu]

ELF/LinkerScript.cpp

286–287

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

[evgeny777]

ELF/LinkerScript.cpp

286–287

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

192

This seems to be dead.

1159–1168

if (skip("ABSOLUTE")) {

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 ForceAbs)
+      : BaseCommand(AssignmentKind), Name(Name), Expression(E),
+        ForceAbsolute(ForceAbs) {}
   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 ForceAbsolute;
   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.

ELF/LinkerScript.cpp

static bool matchConstraints(ArrayRef<InputSectionBase<ELFT> *> Sections,
   });
 }
 
 template <class ELFT>
 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);
       OutCmd->GoesAfter = Ret.empty() ? nullptr : Ret.back();
       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);
     }
   }
 }
 
+template <class ELFT>
+static void finalizeSectionSym(SymbolAssignment *Cmd,
+                               OutputSectionBase<ELFT> *Sec,
+                               typename ELFT::uint Off) {
+  if (auto *Body = cast_or_null<DefinedSynthetic<ELFT>>(Cmd->Sym)) {
+    Symbol *S = Body->symbol();
+    if (Cmd->ForceAbsolute) {
+      replaceBody<DefinedRegular<ELFT>>(S, Cmd->Name,
+                                        static_cast<uint8_t>(S->Visibility));
+      Body->Value = Cmd->Expression(Sec->getVA() + Off);
+    } else {
+      Body->Section = Sec;
+      Body->Value = Cmd->Expression(Sec->getVA() + Off) - Sec->getVA();
+    }
+  }
+}
+
 // 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();
-      }
+      finalizeSectionSym<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;
-      }
+      finalizeSectionSym<ELFT>(AssignCmd, Sec, Off);
     }
   };
 
   AssignSuccessors(nullptr);
   for (InputSection<ELFT> *I : OutSec->Sections) {
     Off = alignTo(Off, I->Alignment);
     I->OutSecOff = Off;
     Off += I->getSize();
case ELF64BEKind:
     return Script<ELF64BE>::X->getHeaderSize();
   default:
     llvm_unreachable("unsupported target");
   }
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   StringRef Op = next();
+  Expr E;
+  bool ForceAbs = false;
   assert(Op == "=" || Op == "+=");
-  Expr E = readExpr();
+  if (peek() == "ABSOLUTE") {
+    next();
+    expect("(");
+    E = readExpr();
+    expect(")");
+    ForceAbs = 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, ForceAbs);
 }
 
 // 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 == "*")

test/ELF/linkerscript/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