[ELF] Support ABSOLUTE on the right hand side in linkerscripts

[phosek]

Summary

This also requires postponing the assignment the assignment of symbols defined in input linker scripts since those can refer to output sections and in case we don't have a SECTIONS command, we need to wait until all output sections have been created and assigned addresses.

[grimar]

ELF/LinkerScript.cpp

764

That can be shorter:

for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
  if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get()))
    assignSymbol(Cmd);
  else if (auto *Cmd = dyn_cast<AssertCommand>(Base.get()))
    Cmd->Expression();
}

Also name of method doesn't really corresponds to what it do, it also processes AssertCommand, not just
assign symbols.

1839

I think you could just

expect(")");
return E;

test/ELF/linkerscript/absolute.s

8

you don't need to add "requires x86" and to run llvm-mc again.

[ruiu]

Does this compile? I cannot find a definition of processNonSectionCommands function.

[phosek]

Should be fixed now.

[ruiu]

Generally looking good, but this might conflict with https://reviews.llvm.org/D30891. Rafael?

ELF/LinkerScript.cpp

1834

Can you add this at the start of this list? They should be sorted alphabetically. I'll do that later.

1835

You can use readParenExpr.

[ruiu]

LGTM

ELF/LinkerScript.h

public:
   bool ignoreInterpSection();
 
   uint32_t getFiller(StringRef Name);
   void writeDataBytes(StringRef Name, uint8_t *Buf);
   bool hasLMA(StringRef Name);
   bool shouldKeep(InputSectionBase *S);
   void assignOffsets(OutputSectionCommand *Cmd);
   void placeOrphanSections();
+  void processNonSectionCommands();
   void assignAddresses(std::vector<PhdrEntry> &Phdrs);
   bool hasPhdrsCommands();
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(const Twine &Loc, StringRef S) override;
   bool isDefined(StringRef S) override;
   bool isAbsolute(StringRef S) override;
   OutputSection *getSymbolSection(StringRef S) override;
   OutputSection *getOutputSection(const Twine &Loc, StringRef S) override;

ELF/LinkerScript.cpp

void LinkerScript<ELFT>::addSymbol(SymbolAssignment *Cmd) {
 
   // If a symbol was in PROVIDE(), we need to define it only when
   // it is a referenced undefined symbol.
   SymbolBody *B = Symtab<ELFT>::X->find(Cmd->Name);
   if (Cmd->Provide && (!B || B->isDefined()))
     return;
 
   Cmd->Sym = addRegular<ELFT>(Cmd);
-
-  // If there are sections, then let the value be assigned later in
-  // `assignAddresses`.
-  if (!ScriptConfig->HasSections)
-    assignSymbol(Cmd);
 }
 
 bool SymbolAssignment::classof(const BaseCommand *C) {
   return C->Kind == AssignmentKind;
 }
 
 bool OutputSectionCommand::classof(const BaseCommand *C) {
   return C->Kind == OutputSectionKind;
for (unsigned I = 0; I < Opt.Commands.size(); ++I) {
     const std::unique_ptr<BaseCommand> &Base1 = *Iter;
 
     // Handle symbol assignments outside of any output section.
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       addSymbol(Cmd);
       continue;
     }
 
-    if (auto *Cmd = dyn_cast<AssertCommand>(Base1.get())) {
-      // If we don't have SECTIONS then output sections have already been
-      // created by Writer<ELFT>. The LinkerScript<ELFT>::assignAddresses
-      // will not be called, so ASSERT should be evaluated now.
-      if (!Opt.HasSections)
-        Cmd->Expression();
-      continue;
-    }
-
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
       std::vector<InputSectionBase *> V = createInputSectionList(*Cmd);
 
       // The output section name `/DISCARD/' is special.
       // Any input section assigned to it is discarded.
       if (Cmd->Name == "/DISCARD/") {
         discard(V);
         continue;
for (OutputSection *Sec : *OutputSections) {
     }
 
     // Continue from where we found it.
     CmdIndex = (Pos - Opt.Commands.begin()) + 1;
   }
 }
 
 template <class ELFT>
+void LinkerScript<ELFT>::processNonSectionCommands() {
+  for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
+    if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get()))
+      assignSymbol(Cmd);
+    else if (auto *Cmd = dyn_cast<AssertCommand>(Base.get()))
+      Cmd->Expression();
+  }
+}
+
+template <class ELFT>
 void LinkerScript<ELFT>::assignAddresses(std::vector<PhdrEntry> &Phdrs) {
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = 0;
   switchTo(Aether);
 
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       assignSymbol(Cmd);
       continue;
     }
 
SymbolAssignment *ScriptParser::readProvideOrAssignment(StringRef Tok) {
   } else if (Tok == "PROVIDE_HIDDEN") {
     Cmd = readProvideHidden(true, true);
   }
   return Cmd;
 }
 
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   StringRef Op = next();
-  Expr E;
   assert(Op == "=" || Op == "+=");
-  if (consume("ABSOLUTE")) {
-    E = readExpr();
-    E.IsAbsolute = [] { return true; };
-  } else {
-    E = readExpr();
-  }
+  Expr E = readExpr();
   if (Op == "+=") {
     std::string Loc = getCurrentLocation();
     E = [=] { return ScriptBase->getSymbolValue(Loc, Name) + E(); };
   }
   return new SymbolAssignment(Name, E, getCurrentLocation());
 }
 
 // This is an operator-precedence parser to parse a linker
Expr ScriptParser::readPrimary() {
   }
   if (Tok == "-") {
     Expr E = readPrimary();
     return [=] { return -E(); };
   }
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
+  if (Tok == "ABSOLUTE") {
+    Expr E = readParenExpr();
+    E.IsAbsolute = [] { return true; };
+    return E;
+  }
   if (Tok == "ADDR") {
     StringRef Name = readParenLiteral();
     return {[=] { return ScriptBase->getOutputSection(Location, Name)->Addr; },
             [=] { return false; },
             [=] { return ScriptBase->getOutputSection(Location, Name); }};
   }
   if (Tok == "LOADADDR") {
     StringRef Name = readParenLiteral();
Expr ScriptParser::readPrimary() {
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
     return
         [=] { return ScriptBase->getOutputSection(Location, Name)->Alignment; };
   }
   if (Tok == "SIZEOF_HEADERS")
     return [=] { return ScriptBase->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))
     setError("malformed number: " + Tok);
   return {[=] { return ScriptBase->getSymbolValue(Location, Tok); },
           [=] { return ScriptBase->isAbsolute(Tok); },
           [=] { return ScriptBase->getSymbolSection(Tok); }};
 }
 

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
     if (ScriptConfig->HasSections) {
       Script<ELFT>::X->assignAddresses(Phdrs);
     } else {
       fixSectionAlignments();
       assignAddresses();
+      Script<ELFT>::X->processNonSectionCommands();
     }
 
     // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
     // 0 sized region. This has to be done late since only after assignAddresses
     // we know the size of the sections.
     removeEmptyPTLoad();
 
     if (!Config->OFormatBinary)

test/ELF/linkerscript/absolute.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { foo = ABSOLUTE(.) + 1; };" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-readobj --symbols %t | FileCheck %s
 
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: echo "PROVIDE(foo = 1 + ABSOLUTE(ADDR(.text)));" > %t.script
+# RUN: ld.lld -o %t --script %t.script %t.o
+# RUN: llvm-readobj --symbols %t | FileCheck --check-prefix=CHECK-RHS %s
+
 # CHECK:        Name: foo
 # CHECK-NEXT:   Value:
 # CHECK-NEXT:   Size:
 # CHECK-NEXT:   Binding:
 # CHECK-NEXT:   Type:
 # CHECK-NEXT:   Other:
 # CHECK-NEXT:   Section: Absolute
 # CHECK-NEXT: }
 
+# CHECK-RHS:        Name: foo
+# CHECK-RHS-NEXT:   Value: 0x201001
+# CHECK-RHS-NEXT:   Size:
+# CHECK-RHS-NEXT:   Binding:
+# CHECK-RHS-NEXT:   Type:
+# CHECK-RHS-NEXT:   Other:
+# CHECK-RHS-NEXT:   Section: Absolute
+# CHECK-RHS-NEXT: }
+
 .text
 .globl _start
 _start:
+ nop
+
+.global foo