[ELF] Linkerscript: support [ AT ( address ) ] in PHDRS

[evgeny777]

Summary

This patch enables processing scripts like this:

PHDRS {
    myload PT_LOAD AT(0x1000) ;
}

[ruiu]

LGTM

ELF/Writer.cpp

1171 ↗

(On Diff #70686)

It needs comment.

// p_paddr can be set using linker script AT command.
// By default, it is the same value as p_vaddr.

lld/trunk/ELF/LinkerScript.h

 };
 
 struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;
   bool HasPhdrs;
   unsigned Flags;
+  Expr LMAExpr;
 };
 
 class LinkerScriptBase {
 protected:
   ~LinkerScriptBase() = default;
 
 public:
   virtual uint64_t getOutputSectionAddress(StringRef Name) = 0;

lld/trunk/ELF/LinkerScript.cpp

std::vector<PhdrEntry<ELFT>> LinkerScript<ELFT>::createPhdrs() {
   for (const PhdrsCommand &Cmd : Opt.PhdrsCommands) {
     Ret.emplace_back(Cmd.Type, Cmd.Flags == UINT_MAX ? PF_R : Cmd.Flags);
     PhdrEntry<ELFT> &Phdr = Ret.back();
 
     if (Cmd.HasFilehdr)
       Phdr.add(Out<ELFT>::ElfHeader);
     if (Cmd.HasPhdrs)
       Phdr.add(Out<ELFT>::ProgramHeaders);
+
+    if (Cmd.LMAExpr) {
+      Phdr.H.p_paddr = Cmd.LMAExpr(0);
+      Phdr.HasLMA = true;
+    }
   }
 
   // Add output sections to program headers.
   PhdrEntry<ELFT> *Load = nullptr;
   uintX_t Flags = PF_R;
   for (OutputSectionBase<ELFT> *Sec : *OutputSections) {
     if (!(Sec->getFlags() & SHF_ALLOC))
       break;
void ScriptParser::readOutputFormat() {
   next();
   expect(")");
 }
 
 void ScriptParser::readPhdrs() {
   expect("{");
   while (!Error && !skip("}")) {
     StringRef Tok = next();
-    Opt.PhdrsCommands.push_back({Tok, PT_NULL, false, false, UINT_MAX});
+    Opt.PhdrsCommands.push_back(
+        {Tok, PT_NULL, false, false, UINT_MAX, nullptr});
     PhdrsCommand &PhdrCmd = Opt.PhdrsCommands.back();
 
     PhdrCmd.Type = readPhdrType();
     do {
       Tok = next();
       if (Tok == ";")
         break;
       if (Tok == "FILEHDR")
         PhdrCmd.HasFilehdr = true;
       else if (Tok == "PHDRS")
         PhdrCmd.HasPhdrs = true;
+      else if (Tok == "AT")
+        PhdrCmd.LMAExpr = readParenExpr();
       else if (Tok == "FLAGS") {
         expect("(");
         // Passing 0 for the value of dot is a bit of a hack. It means that
         // we accept expressions like ".|1".
         PhdrCmd.Flags = readExpr()(0);
         expect(")");
       } else
         setError("unexpected header attribute: " + Tok);

lld/trunk/ELF/Writer.h

 template<class ELFT>
 struct PhdrEntry {
   PhdrEntry(unsigned Type, unsigned Flags);
   void add(OutputSectionBase<ELFT> *Sec);
 
   typename ELFT::Phdr H = {};
   OutputSectionBase<ELFT> *First = nullptr;
   OutputSectionBase<ELFT> *Last = nullptr;
+  bool HasLMA = false;
 };
 
 template <class ELFT>
 llvm::StringRef getOutputSectionName(InputSectionBase<ELFT> *S);
 
 template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 }
 }
 
 #endif

lld/trunk/ELF/Writer.cpp

if (First) {
       H.p_offset = First->getFileOff();
       H.p_vaddr = First->getVA();
     }
     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);
     }

lld/trunk/test/ELF/linkerscript/phdrs.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "PHDRS {all PT_LOAD FILEHDR PHDRS ;} \
 # RUN:       SECTIONS { \
 # RUN:           . = 0x10000200; \
 # RUN:           .text : {*(.text*)} :all \
 # RUN:           .foo : {*(.foo.*)} :all \
 # RUN:           .data : {*(.data.*)} :all}" > %t.script
-
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-readobj -program-headers %t1 | FileCheck %s
+
+## Check the AT(expr)
+# RUN: echo "PHDRS {all PT_LOAD FILEHDR PHDRS AT(0x500 + 0x500) ;} \
+# RUN:       SECTIONS { \
+# RUN:           . = 0x10000200; \
+# RUN:           .text : {*(.text*)} :all \
+# RUN:           .foo : {*(.foo.*)} :all \
+# RUN:           .data : {*(.data.*)} :all}" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-readobj -program-headers %t1 | FileCheck --check-prefix=AT %s
+
 # CHECK:     ProgramHeaders [
 # CHECK-NEXT:  ProgramHeader {
 # CHECK-NEXT:    Type: PT_LOAD (0x1)
 # CHECK-NEXT:    Offset: 0x0
 # CHECK-NEXT:    VirtualAddress: 0x10000000
 # CHECK-NEXT:    PhysicalAddress: 0x10000000
 # CHECK-NEXT:    FileSize: 521
 # CHECK-NEXT:    MemSize: 521
 # CHECK-NEXT:    Flags [ (0x7)
 # CHECK-NEXT:      PF_R (0x4)
 # CHECK-NEXT:      PF_W (0x2)
 # CHECK-NEXT:      PF_X (0x1)
 # CHECK-NEXT:    ]
 
+# AT:       ProgramHeaders [
+# AT-NEXT:    ProgramHeader {
+# AT-NEXT:      Type: PT_LOAD (0x1)
+# AT-NEXT:      Offset: 0x0
+# AT-NEXT:      VirtualAddress: 0x10000000
+# AT-NEXT:      PhysicalAddress: 0xA00
+# AT-NEXT:      FileSize: 521
+# AT-NEXT:      MemSize: 521
+# AT-NEXT:      Flags [ (0x7)
+# AT-NEXT:        PF_R (0x4)
+# AT-NEXT:        PF_W (0x2)
+# AT-NEXT:        PF_X (0x1)
+# AT-NEXT:      ]
+
 .global _start
 _start:
  nop
 
 .section .foo.1,"a"
 foo1:
  .long 0
 
 .section .foo.2,"aw"
 foo2:
  .long 0