[ELF] Linkerscript: Implement LOADADDR

[evgeny777]

Summary

This patch implements LOADADDR() linkerscript function and ability to fetch LMA for section.

[ruiu]

ELF/LinkerScript.cpp

431

Do you need to set an LMA to sections without AT command?

ELF/LinkerScript.h

175

LMA is fine with me as we write VA instead of Va, so please rename this function.

ELF/Writer.cpp

949

What is b in bHasLma?

1003–1004

Why do we have to create a new segment if there's a section with a LMA?

[grimar]

ELF/Writer.cpp

1003

You can write this as:

bHasLma |= Script<ELFT>::X->hasLma(Sec->getName())

[evgeny777]

ELF/LinkerScript.cpp

431

Yes, because LMA and VMA might not be the same, even if there is no AT command for a section. See summary for this patch

ELF/Writer.cpp

1003–1004

There is no straight way to get LMA for section from section header. The header field sh_addr is VMA, not LMA. However tools like objdump and objcopy still can fetch LMA. They are doing this by examining segment table and fetching segment physical address in case segment virtual address matches section VMA. This means that if section LMA doesn't match VMA, it should have separate load segment in order to properly calculate LMA for them.

[evgeny777]

Rebased + addressed review comments

[evgeny777]

Rebased

[ruiu]

ELF/LinkerScript.cpp

431

Please add a comment about that with a reference to the GNU manual.

1270

It may not be a name, so I'd name Tok.

ELF/Writer.cpp

949

HasLMA for the sake of consistency.

1003–1004

Please add a comment about that so that people who read this code can understand why it checks HasLma.

[evgeny777]

Addressed review comments

[evgeny777]

ELF/LinkerScript.cpp

431

This wasn't needed, because setLMAOffset is called in SetAddrs(). See lines 399 - 403

ELF/Writer.cpp

1003–1004

See lines 987-995

[evgeny777]

Rebased

[evgeny777]

Added test case

[evgeny777]

Any comments on this?

[evgeny777]

Diff updated. It turned out, that binutils can fetch LMA for section even if it doesn't start PT_LOAD segment, so
this patch can be simplified.

[grimar]

Sample of use from the wild:
https://searchcode.com/file/51551302/arch/x86_64/kernel/vmlinux.lds.S

test/ELF/linkerscript/loadaddr.s

15

You probably want to check LOADADDR(xxx), where xxx - section that does not exist.

[evgeny777]

test/ELF/linkerscript/loadaddr.s

15

Unfortunately this will not work, because empty sections are not fully supported: empty sections which don't contain symbols are simply ignored. I'm making a patch which addresses this problem.

[grimar]

test/ELF/linkerscript/loadaddr.s

15

I was mean something like I did in my version of that: D24910

## Check that we error out if trying to get load address of
## section that does not exist.
# RUN: echo "SECTIONS { .bar LOADADDR(.zed) : { *(.bar*) } }" > %t.script
# RUN: not ld.lld -o %t1 --script %t.script %t 2>&1 \
# RUN:  | FileCheck -check-prefix=ERR %s
# ERR: undefined section .zed

So there is no .zed section and it is impossible to call LOADADDR(.zed)

[evgeny777]

Addressed review comments

[ruiu]

LGTM

ELF/LinkerScript.h

 class LinkerScriptBase {
 protected:
   ~LinkerScriptBase() = default;
 
 public:
   virtual uint64_t getOutputSectionAddress(StringRef Name) = 0;
   virtual uint64_t getOutputSectionSize(StringRef Name) = 0;
   virtual uint64_t getOutputSectionAlign(StringRef Name) = 0;
+  virtual uint64_t getOutputSectionLMA(StringRef Name) = 0;
   virtual uint64_t getHeaderSize() = 0;
   virtual uint64_t getSymbolValue(StringRef S) = 0;
 };
 
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // Used to create symbol assignments outside SECTIONS command.
   std::vector<std::unique_ptr<SymbolAssignment>> Assignments;
public:
   ~LinkerScript();
   void createAssignments();
   void createSections(OutputSectionFactory<ELFT> &Factory);
 
   std::vector<PhdrEntry<ELFT>> createPhdrs();
   bool ignoreInterpSection();
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
-  Expr getLma(StringRef Name);
+  bool hasLMA(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses();
   int compareSections(StringRef A, StringRef B);
   bool hasPhdrsCommands();
+
   uint64_t getOutputSectionAddress(StringRef Name) override;
   uint64_t getOutputSectionSize(StringRef Name) override;
   uint64_t getOutputSectionAlign(StringRef Name) override;
+  uint64_t getOutputSectionLMA(StringRef Name) override;
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(StringRef S) override;
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
 
 private:
   std::vector<InputSectionBase<ELFT> *>
   getInputSections(const InputSectionDescription *);

ELF/LinkerScript.cpp

for (OutputSectionBase<ELFT> *Sec : *OutputSections) {
     if (getSectionIndex(Name) == INT_MAX)
       Opt.Commands.push_back(llvm::make_unique<OutputSectionCommand>(Name));
   }
 
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = getHeaderSize();
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   uintX_t ThreadBssOffset = 0;
+  uintX_t LMAOff = 0;
+
+  auto SetAddrs = [&](OutputSectionCommand *Cmd, OutputSectionBase<ELFT> *Sec,
+                      uintX_t VA) {
+    Sec->setVA(VA);
+    if (Cmd->LmaExpr)
+      LMAOff = Cmd->LmaExpr(VA) - VA;
+
+    // If neither AT nor AT> is specified for an allocatable section, the linker
+    // will set the LMA such that the difference between VMA and LMA for the
+    // section is the same as the preceding output section in the same region
+    // https://sourceware.org/binutils/docs-2.20/ld/Output-Section-LMA.html
+    Sec->setLMAOffset(LMAOff);
+  };
 
   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);
       }
for (OutputSectionBase<ELFT> *Sec :
          findSections<ELFT>(*Cmd, *OutputSections)) {
 
       if (Cmd->AddrExpr)
         Dot = Cmd->AddrExpr(Dot);
 
       if (Cmd->AlignExpr)
         Sec->updateAlignment(Cmd->AlignExpr(Dot));
 
       if ((Sec->getFlags() & SHF_TLS) && Sec->getType() == SHT_NOBITS) {
         uintX_t TVA = Dot + ThreadBssOffset;
         TVA = alignTo(TVA, Sec->getAlignment());
-        Sec->setVA(TVA);
+        SetAddrs(Cmd, Sec, Dot);
         assignOffsets(Cmd, Sec);
         ThreadBssOffset = TVA - Dot + Sec->getSize();
         continue;
       }
 
       if (!(Sec->getFlags() & SHF_ALLOC)) {
         assignOffsets(Cmd, Sec);
         continue;
       }
 
       Dot = alignTo(Dot, Sec->getAlignment());
-      Sec->setVA(Dot);
+      SetAddrs(Cmd, Sec, Dot);
       assignOffsets(Cmd, Sec);
       MinVA = std::min(MinVA, Dot);
       Dot += Sec->getSize();
     }
   }
 
   // ELF and Program headers need to be right before the first section in
   // memory. Set their addresses accordingly.

 ArrayRef<uint8_t> LinkerScript<ELFT>::getFiller(StringRef Name) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
       if (Cmd->Name == Name)
         return Cmd->Filler;
   return {};
 }
 
-template <class ELFT> Expr LinkerScript<ELFT>::getLma(StringRef Name) {
+template <class ELFT> bool LinkerScript<ELFT>::hasLMA(StringRef Name) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
       if (Cmd->LmaExpr && Cmd->Name == Name)
-        return Cmd->LmaExpr;
-  return {};
+        return true;
+  return false;
 }
 
 // Returns the index of the given section name in linker script
 // SECTIONS commands. Sections are laid out as the same order as they
 // were in the script. If a given name did not appear in the script,
 // it returns INT_MAX, so that it will be laid out at end of file.
 template <class ELFT> int LinkerScript<ELFT>::getSectionIndex(StringRef Name) {
   int I = 0;
uint64_t LinkerScript<ELFT>::getOutputSectionAddress(StringRef Name) {
   for (OutputSectionBase<ELFT> *Sec : *OutputSections)
     if (Sec->getName() == Name)
       return Sec->getVA();
   error("undefined section " + Name);
   return 0;
 }
 
 template <class ELFT>
+uint64_t LinkerScript<ELFT>::getOutputSectionLMA(StringRef Name) {
+  for (OutputSectionBase<ELFT> *Sec : *OutputSections)
+    if (Sec->getName() == Name)
+      return Sec->getLMA();
+  error("undefined section " + Name);
+  return 0;
+}
+
+template <class ELFT>
 uint64_t LinkerScript<ELFT>::getOutputSectionSize(StringRef Name) {
   for (OutputSectionBase<ELFT> *Sec : *OutputSections)
     if (Sec->getName() == Name)
       return Sec->getSize();
   error("undefined section " + Name);
   return 0;
 }
 
private:
   SortKind readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
   SymbolAssignment *readProvideOrAssignment(StringRef Tok, bool MakeAbsolute);
   void readSort();
   Expr readAssert();
 
   Expr readExpr();
   Expr readExpr1(Expr Lhs, int MinPrec);
+  StringRef readParenLiteral();
   Expr readPrimary();
   Expr readTernary(Expr Cond);
   Expr readParenExpr();
 
   // For parsing version script.
   void readExtern(std::vector<SymbolVersion> *Globals);
   void readVersionDeclaration(StringRef VerStr);
   void readGlobal(StringRef VerStr);
if (Tok.endswith_lower("K")) {
     Tok = Tok.drop_back();
   }
   if (Tok.getAsInteger(10, Result))
     return false;
   Result *= Suffix;
   return true;
 }
 
+StringRef ScriptParser::readParenLiteral() {
+  expect("(");
+  StringRef Tok = next();
+  expect(")");
+  return Tok;
+}
+
 Expr ScriptParser::readPrimary() {
   if (peek() == "(")
     return readParenExpr();
 
   StringRef Tok = next();
 
   if (Tok == "~") {
     Expr E = readPrimary();
     return [=](uint64_t Dot) { return ~E(Dot); };
   }
   if (Tok == "-") {
     Expr E = readPrimary();
     return [=](uint64_t Dot) { return -E(Dot); };
   }
 
   // Built-in functions are parsed here.
   // https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
   if (Tok == "ADDR") {
-    expect("(");
-    StringRef Name = next();
-    expect(")");
+    StringRef Name = readParenLiteral();
     return
         [=](uint64_t Dot) { return ScriptBase->getOutputSectionAddress(Name); };
   }
+  if (Tok == "LOADADDR") {
+    StringRef Name = readParenLiteral();
+    return [=](uint64_t Dot) { return ScriptBase->getOutputSectionLMA(Name); };
+  }
   if (Tok == "ASSERT")
     return readAssert();
   if (Tok == "ALIGN") {
     Expr E = readParenExpr();
     return [=](uint64_t Dot) { return alignTo(Dot, E(Dot)); };
   }
   if (Tok == "CONSTANT") {
-    expect("(");
-    StringRef Tok = next();
-    expect(")");
-    return [=](uint64_t Dot) { return getConstant(Tok); };
+    StringRef Name = readParenLiteral();
+    return [=](uint64_t Dot) { return getConstant(Name); };
   }
   if (Tok == "SEGMENT_START") {
     expect("(");
     next();
     expect(",");
     uint64_t Val;
     next().getAsInteger(0, Val);
     expect(")");
if (Tok == "DATA_SEGMENT_RELRO_END") {
     expect("(");
     next();
     expect(",");
     readExpr();
     expect(")");
     return [](uint64_t Dot) { return alignTo(Dot, Target->PageSize); };
   }
   if (Tok == "SIZEOF") {
-    expect("(");
-    StringRef Name = next();
-    expect(")");
+    StringRef Name = readParenLiteral();
     return [=](uint64_t Dot) { return ScriptBase->getOutputSectionSize(Name); };
   }
   if (Tok == "ALIGNOF") {
-    expect("(");
-    StringRef Name = next();
-    expect(")");
+    StringRef Name = readParenLiteral();
     return
         [=](uint64_t Dot) { return ScriptBase->getOutputSectionAlign(Name); };
   }
   if (Tok == "SIZEOF_HEADERS")
     return [=](uint64_t Dot) { return ScriptBase->getHeaderSize(); };
 
   // Tok is a literal number.
   uint64_t V;

ELF/OutputSections.h

enum Kind {
     VersDef,
     VersNeed,
     VersTable
   };
 
   OutputSectionBase(StringRef Name, uint32_t Type, uintX_t Flags);
   void setVA(uintX_t VA) { Header.sh_addr = VA; }
   uintX_t getVA() const { return Header.sh_addr; }
+  void setLMAOffset(uintX_t LMAOff) { LMAOffset = LMAOff; }
+  uintX_t getLMA() const { return Header.sh_addr + LMAOffset; }
   void setFileOffset(uintX_t Off) { Header.sh_offset = Off; }
   void setSHName(unsigned Val) { Header.sh_name = Val; }
   void writeHeaderTo(Elf_Shdr *SHdr);
   StringRef getName() { return Name; }
 
   virtual void addSection(InputSectionBase<ELFT> *C) {}
   virtual Kind getKind() const { return Base; }
   static bool classof(const OutputSectionBase<ELFT> *B) {
public:
   virtual void finalizePieces() {}
   virtual void assignOffsets() {}
   virtual void writeTo(uint8_t *Buf) {}
   virtual ~OutputSectionBase() = default;
 
 protected:
   StringRef Name;
   Elf_Shdr Header;
+  uintX_t LMAOffset = 0;
 };
 
 template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();

ELF/Writer.cpp

template <class ELFT> static bool needsPtLoad(OutputSectionBase<ELFT> *Sec) {
   return true;
 }
 
 // Decide which program headers to create and which sections to include in each
 // one.
 template <class ELFT>
 std::vector<PhdrEntry<ELFT>> Writer<ELFT>::createPhdrs() {
   std::vector<Phdr> Ret;
-
+  bool HasLMA = false;
   auto AddHdr = [&](unsigned Type, unsigned Flags) -> Phdr * {
     Ret.emplace_back(Type, Flags);
     return &Ret.back();
   };
 
   // The first phdr entry is PT_PHDR which describes the program header itself.
   Phdr &Hdr = *AddHdr(PT_PHDR, PF_R);
   Hdr.add(Out<ELFT>::ProgramHeaders);
for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     // and put all TLS sections inside for futher use when
     // assign addresses.
     if (Sec->getFlags() & SHF_TLS)
       TlsHdr.add(Sec);
 
     if (!needsPtLoad(Sec))
       continue;
 
+    // GNU objdump and objcopy are calculating section LMA by comparing
+    // segment virtual address with section virtual address and taking
+    // segment physical address if they do match. This means that in
+    // general every section for which LMA != VMA requires segment to
+    // be created for it. Here we can't be determined that section VMA
+    // is different from LMA because assignAddresses() has not been
+    // called yet, but this is very likely to happen if any previously
+    // seen section has AT specification.
+    HasLMA = HasLMA || Script<ELFT>::X->hasLMA(Sec->getName());
+
     // Segments are contiguous memory regions that has the same attributes
     // (e.g. executable or writable). There is one phdr for each segment.
     // Therefore, we need to create a new phdr when the next section has
     // different flags or is loaded at a discontiguous address using AT linker
     // script command.
     uintX_t NewFlags = Sec->getPhdrFlags();
-    if (Script<ELFT>::X->getLma(Sec->getName()) || Flags != NewFlags) {
+    if (HasLMA || Flags != NewFlags) {
       Load = AddHdr(PT_LOAD, NewFlags);
       Flags = NewFlags;
     }
 
     Load->add(Sec);
 
     if (isRelroSection(Sec))
       RelRo.add(Sec);
     if (Sec->getType() == SHT_NOTE)
for (Phdr &P : Phdrs) {
     OutputSectionBase<ELFT> *Last = P.Last;
     if (First) {
       H.p_filesz = Last->getFileOff() - First->getFileOff();
       if (Last->getType() != SHT_NOBITS)
         H.p_filesz += Last->getSize();
       H.p_memsz = Last->getVA() + Last->getSize() - First->getVA();
       H.p_offset = First->getFileOff();
       H.p_vaddr = First->getVA();
+      if (!P.HasLMA)
+        H.p_paddr = First->getLMA();
     }
     if (H.p_type == PT_LOAD)
       H.p_align = Target->PageSize;
     else if (H.p_type == PT_GNU_RELRO)
       H.p_align = 1;
 
-    if (!P.HasLMA) {
-    // The p_paddr field can be set using linker script AT command.
-    // By default, it is the same value as p_vaddr.
-      H.p_paddr = H.p_vaddr;
-      if (H.p_type == PT_LOAD && First)
-        if (Expr LmaExpr = Script<ELFT>::X->getLma(First->getName()))
-          H.p_paddr = LmaExpr(H.p_vaddr);
-    }
-
     // The TLS pointer goes after PT_TLS. At least glibc will align it,
     // so round up the size to make sure the offsets are correct.
     if (H.p_type == PT_TLS) {
       Out<ELFT>::TlsPhdr = &H;
       if (H.p_memsz)
         H.p_memsz = alignTo(H.p_memsz, H.p_align);
     }
   }

test/ELF/linkerscript/at.s

 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_LOAD
 # CHECK-NEXT:     Offset: 0x1000
 # CHECK-NEXT:     VirtualAddress: 0x1000
 # CHECK-NEXT:     PhysicalAddress: 0x2000
-# CHECK-NEXT:     FileSize: 16
-# CHECK-NEXT:     MemSize: 16
+# CHECK-NEXT:     FileSize: 8
+# CHECK-NEXT:     MemSize: 8
 # CHECK-NEXT:     Flags [
 # CHECK-NEXT:       PF_R
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_LOAD (0x1)
+# CHECK-NEXT:     Offset: 0x1008
+# CHECK-NEXT:     VirtualAddress: 0x1008
+# CHECK-NEXT:     PhysicalAddress: 0x2008
+# CHECK-NEXT:     FileSize: 8
+# CHECK-NEXT:     MemSize: 8
+# CHECK-NEXT:     Flags [ (0x4)
+# CHECK-NEXT:       PF_R (0x4)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment:
+# CHECK-NEXT:   }
+# CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_LOAD
 # CHECK-NEXT:     Offset: 0x1010
 # CHECK-NEXT:     VirtualAddress: 0x1010
 # CHECK-NEXT:     PhysicalAddress: 0x3000
 # CHECK-NEXT:     FileSize: 8
 # CHECK-NEXT:     MemSize: 8
 # CHECK-NEXT:     Flags [
 # CHECK-NEXT:       PF_R

 # CHECK-NEXT:       PF_R
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment: 4096
 # CHECK-NEXT:   }
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_LOAD
 # CHECK-NEXT:     Offset: 0x1020
 # CHECK-NEXT:     VirtualAddress: 0x1020
-# CHECK-NEXT:     PhysicalAddress: 0x1020
+# CHECK-NEXT:     PhysicalAddress: 0x4008
 # CHECK-NEXT:     FileSize: 1
 # CHECK-NEXT:     MemSize: 1
 # CHECK-NEXT:     Flags [
 # CHECK-NEXT:       PF_R
 # CHECK-NEXT:       PF_X
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment: 4096
 # CHECK-NEXT:   }

test/ELF/linkerscript/loadaddr.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS { \
+# RUN:  . = 0x1000; \
+# RUN:  .aaa : AT(0x2000) { *(.aaa) } \
+# RUN:  .bbb : { *(.bbb) } \
+# RUN:  .ccc : AT(0x3000) { *(.ccc) } \
+# RUN:  .ddd : AT(0x4000) { *(.ddd) } \
+# RUN:  .text : { *(.text) } \
+# RUN:  aaa_lma = LOADADDR(.aaa);  \
+# RUN:  bbb_lma = LOADADDR(.bbb);  \
+# RUN:  ccc_lma = LOADADDR(.ccc);  \
+# RUN:  ddd_lma = LOADADDR(.ddd);  \
+# RUN:  txt_lma = LOADADDR(.text); \
+# RUN: }" > %t.script
+# RUN: ld.lld %t --script %t.script -o %t2
+# RUN: llvm-objdump -t %t2 | FileCheck %s
+
+# CHECK:      0000000000002000         *ABS*     00000000 aaa_lma
+# CHECK-NEXT: 0000000000002008         *ABS*     00000000 bbb_lma
+# CHECK-NEXT: 0000000000003000         *ABS*     00000000 ccc_lma
+# CHECK-NEXT: 0000000000004000         *ABS*     00000000 ddd_lma
+# CHECK-NEXT: 0000000000004008         *ABS*     00000000 txt_lma
+
+.global _start
+_start:
+ nop
+
+.section .aaa, "a"
+.quad 0
+
+.section .bbb, "a"
+.quad 0
+
+.section .ccc, "a"
+.quad 0
+
+.section .ddd, "a"
+.quad 0