'.' is not absolute

[• rafael]

Summary

With this patch we keep track of the fact that . is a position in the file and therefore not absolute. This allow us to compute relative relocations that involve symbol that are defined in linker scripts with '.'.

This fixes https://llvm.org/bugs/show_bug.cgi?id=30406

There is still more work to track absoluteness over the various expressions, but this should unblock linking the EFI bootloader.

[ruiu]

ELF/LinkerScript.cpp

1190

instead, replace false with []() { return false; }.

ELF/LinkerScript.h

45–46

Instead of T, can we use just uint64_t?

47–48

This function is too thin as a wrapper for Expr(T, std::function<bool()>), so I wouldn't add this.

[ruiu]

LGTM

[phosek]

LGTM

[emaste]

With this change the EFI bootloader links, although it does not work. The UEFI firmware reports "Error reported: Invalid Parameter" when it tries to execute the lld-linked BOOTx64.efi. To be investigated.

[evgeny777]

LGTM

[phosek]

Do you plan to merge this patch? We're still hitting this issue in our build and it'd be great to have this patch in.

[emaste]

This change was committed in rL285641

[• espindola]

285641

ELF/LinkerScript.h

 // ScriptParser::readExpr reads an expression and returns an Expr.
 // Later, we evaluate the expression by calling the function
 // with the value of special context variable ".".
 struct Expr {
   std::function<uint64_t(uint64_t)> Val;
   std::function<bool()> IsAbsolute;
   uint64_t operator()(uint64_t Dot) const { return Val(Dot); }
   operator bool() const { return (bool)Val; }
 
-  template <typename T>
-  Expr(T Val, std::function<bool()> IsAbsolute)
+  Expr(std::function<uint64_t(uint64_t)> Val, std::function<bool()> IsAbsolute)
       : Val(Val), IsAbsolute(IsAbsolute) {}
-  template <typename T> Expr(T Val, bool IsAbsolute) : Val(Val) {
-    this->IsAbsolute = [=]() { return IsAbsolute; };
-  }
-  template <typename T> Expr(T V) : Expr(V, false) {}
+  template <typename T> Expr(T V) : Expr(V, []() { return true; }) {}
   Expr() : Expr(nullptr) {}
 };
 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
 void readLinkerScript(MemoryBufferRef MB);
 
 // Parses a version script.

ELF/LinkerScript.cpp

 template <class ELFT>
 void LinkerScript<ELFT>::processCommands(OutputSectionFactory<ELFT> &Factory) {
 
   for (unsigned I = 0; I < Opt.Commands.size(); ++I) {
     auto Iter = Opt.Commands.begin() + I;
     const std::unique_ptr<BaseCommand> &Base1 = *Iter;
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       if (shouldDefine<ELFT>(Cmd))
-        addRegular<ELFT>(Cmd);
+        addSymbol<ELFT>(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(0);
void LinkerScript<ELFT>::assignAddresses(std::vector<PhdrEntry<ELFT>> &Phdrs) {
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = 0;
 
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       if (Cmd->Name == ".") {
         Dot = Cmd->Expression(Dot);
       } else if (Cmd->Sym) {
-        cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value = Cmd->Expression(Dot);
+        assignSectionSymbol(Cmd, CurOutSec ? CurOutSec : (*OutputSections)[0],
+                            Dot);
       }
       continue;
     }
 
     if (auto *Cmd = dyn_cast<AssertCommand>(Base.get())) {
       Cmd->Expression(Dot);
       continue;
     }
void ScriptParser::readSearchDir() {
   expect(")");
 }
 
 void ScriptParser::readSections() {
   Opt.HasSections = true;
   expect("{");
   while (!Error && !consume("}")) {
     StringRef Tok = next();
-    BaseCommand *Cmd = readProvideOrAssignment(Tok, true);
+    BaseCommand *Cmd = readProvideOrAssignment(Tok, false);
     if (!Cmd) {
       if (Tok == "ASSERT")
         Cmd = new AssertCommand(readAssert());
       else
         Cmd = readOutputSectionDescription(Tok);
     }
     Opt.Commands.emplace_back(Cmd);
   }
Expr ScriptParser::readPrimary() {
   if (Tok == "ASSERT")
     return readAssert();
   if (Tok == "ALIGN") {
     Expr E = readParenExpr();
     return [=](uint64_t Dot) { return alignTo(Dot, E(Dot)); };
   }
   if (Tok == "CONSTANT") {
     StringRef Name = readParenLiteral();
-    return {[=](uint64_t Dot) { return getConstant(Name); }, true};
+    return [=](uint64_t Dot) { return getConstant(Name); };
   }
   if (Tok == "DEFINED") {
     expect("(");
     StringRef Tok = next();
     expect(")");
     return [=](uint64_t Dot) { return ScriptBase->isDefined(Tok) ? 1 : 0; };
   }
   if (Tok == "SEGMENT_START") {
if (Tok == "DATA_SEGMENT_RELRO_END") {
     readExpr();
     expect(",");
     readExpr();
     expect(")");
     return [](uint64_t Dot) { return alignTo(Dot, Target->PageSize); };
   }
   if (Tok == "SIZEOF") {
     StringRef Name = readParenLiteral();
-    return {
-        [=](uint64_t Dot) { return ScriptBase->getOutputSectionSize(Name); },
-        true};
+    return [=](uint64_t Dot) { return ScriptBase->getOutputSectionSize(Name); };
   }
   if (Tok == "ALIGNOF") {
     StringRef Name = readParenLiteral();
-    return {
-        [=](uint64_t Dot) { return ScriptBase->getOutputSectionAlign(Name); },
-        true};
+    return
+        [=](uint64_t Dot) { return ScriptBase->getOutputSectionAlign(Name); };
   }
   if (Tok == "SIZEOF_HEADERS")
-    return {[=](uint64_t Dot) { return ScriptBase->getHeaderSize(); }, true};
+    return [=](uint64_t Dot) { return ScriptBase->getHeaderSize(); };
 
   // Tok is a literal number.
   uint64_t V;
   if (readInteger(Tok, V))
-    return {[=](uint64_t Dot) { return V; }, true};
+    return [=](uint64_t Dot) { return V; };
 
   // Tok is a symbol name.
   if (Tok != "." && !isValidCIdentifier(Tok))
     setError("malformed number: " + Tok);
   return {[=](uint64_t Dot) { return getSymbolValue(Tok, Dot); },
           [=]() { return isAbsolute(Tok); }};
 }
 

test/ELF/linkerscript/dot-is-not-abs.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+
+# RUN: echo "SECTIONS { .text : { *(.text) } \
+# RUN:                  foo = .; \
+# RUN:                  .bar : { *(.bar) } }" > %t1.script
+# RUN: ld.lld -o %t1 --script %t1.script %t.o -shared
+# RUN: llvm-readobj -t -s -section-data %t1 | FileCheck %s
+
+.hidden foo
+.long foo - .
+
+.section .bar, "a"
+.long 0
+
+# The symbol foo is defined as a position in the file. This means that it is
+# not absolute and it is possible to compute the distance from foo to some other
+# position in the file. The symbol is not really in any output section, but
+# ELF has no magic constant for not absolute, but not in any section.
+# Fortunately the value of a symbol in a non relocatable file is a virtual
+# address, so the section can be arbitrary.
+
+# CHECK:      Section {
+# CHECK:        Index:
+# CHECK:        Name: .text
+# CHECK-NEXT:   Type: SHT_PROGBITS
+# CHECK-NEXT:   Flags [
+# CHECK-NEXT:     SHF_ALLOC
+# CHECK-NEXT:     SHF_EXECINSTR
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Address: 0x0
+# CHECK-NEXT:   Offset:
+# CHECK-NEXT:   Size: 4
+# CHECK-NEXT:   Link:
+# CHECK-NEXT:   Info:
+# CHECK-NEXT:   AddressAlignment:
+# CHECK-NEXT:   EntrySize:
+# CHECK-NEXT:   SectionData (
+# CHECK-NEXT:     0000: 04000000 |
+# CHECK-NEXT:   )
+# CHECK-NEXT: }
+
+# CHECK:      Symbol {
+# CHECK:        Name: foo
+# CHECK-NEXT:   Value: 0x4
+# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Binding: Local
+# CHECK-NEXT:   Type: None
+# CHECK-NEXT:   Other [
+# CHECK-NEXT:     STV_HIDDEN
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Section: .text
+# CHECK-NEXT: }

test/ELF/linkerscript/symbol-conflict.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { . = SIZEOF_HEADERS; .text : {*(.text.*)} end = .;}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
-# CHECK: 00000000000000e9         *ABS*    00000000 end
+# CHECK: 00000000000000e9         .text    00000000 end
 
 .global _start
 _start:
  nop

test/ELF/linkerscript/symbols.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # Simple symbol assignment. Should raise conflict in case we
 # have duplicates in any input section, but currently simply
 # replaces the value.
 # RUN: echo "SECTIONS {.text : {*(.text.*)} text_end = .;}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=SIMPLE %s
-# SIMPLE:                               *ABS*    00000000 text_end
+# SIMPLE:                               .text    00000000 text_end
 
 # The symbol is not referenced. Don't provide it.
 # RUN: echo "SECTIONS { PROVIDE(newsym = 1);}" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=PROVIDE1 %s
 # PROVIDE1-NOT: 0000000000000001         *ABS*    00000000 newsym
 
 # The symbol is not referenced. Don't provide it.