[ELF] - Linkerscript: implement SIZEOF_HEADERS.

[grimar]

Summary

SIZEOF_HEADERS - Return the size in bytes of the output file’s headers.

It is is a feature used in FreeBsd script, for example.
There is a discussion on PR28688 page about it.

[grimar]

• Added testcase.

[ruiu]

ELF/LinkerScript.cpp

241

I do see why you are doing this, but this is pretty obscure. Do we really have to do this?

[grimar]

ELF/LinkerScript.cpp

241

When SIZE_OF_HEADERS is not used it is convenient behavior to have location counted be shifted automatically. Otherwise users will have to leave space for headers manually which probably not the best experience we can offer.

Or do you mean we should always shift dot here on size of headers ? That means that if script contains SIZE_OF_HEADES there will be some waste of VA space. That does not allow script to control everything also, what I guess can be expected for those who want to set up everything manually.

[ruiu]

ELF/LinkerScript.cpp

241

I think we don't have to do this. If the first linker script line is

. = SIZEOF_HEADERS;

and if . is the same as SIZEOF_HEADERS (it is), the first line is a nop. So it should just work.

[grimar]

• Addressed review comments.

[grimar]

ELF/LinkerScript.cpp

25–1

I hope there will not be scripts with first linke like:

. += SIZEOF_HEADERS;

[ruiu]

LGTM

ELF/LinkerScript.cpp

25–1

Let's see how it works! If it works, it's definitely better.

26

This technique is getting ugly as we have more and more functions to interact with the template class. At some point we probably should use a different technique. But for now it is fine (and probably still preferable.)

[grimar]

ELF/LinkerScript.cpp

26

May be something like I used in first iteration here:
https://reviews.llvm.org/D22759?id=65352 ?

ELF/LinkerScript.h

struct ScriptConfiguration {
   // Used to assign addresses to sections.
   std::vector<std::unique_ptr<BaseCommand>> Commands;
 
   // Used to assign sections to headers.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool HasContents = false;
 
+  bool ManualHeadersSize = false;
+
   llvm::BumpPtrAllocator Alloc;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
   std::vector<StringRef> KeptSections;
 };
 
 extern ScriptConfiguration *ScriptConfig;
public:
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses();
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   bool hasPhdrsCommands();
   uintX_t getOutputSectionSize(StringRef Name);
+  uintX_t getSizeOfHeaders();
 
   std::vector<OutputSectionBase<ELFT> *> *OutputSections;
 
 private:
   std::vector<std::pair<StringRef, const InputSectionDescription *>>
   getSectionMap();
 
   std::vector<InputSectionBase<ELFT> *>

ELF/LinkerScript.cpp

 //===----------------------------------------------------------------------===//
 
 #include "LinkerScript.h"
 #include "Config.h"
 #include "Driver.h"
 #include "InputSection.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "Strings.h"
 #include "Symbols.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
template <class ELFT> void LinkerScript<ELFT>::assignAddresses() {
   // https://sourceware.org/binutils/docs/ld/Orphan-Sections.html#Orphan-Sections.
   for (OutputSectionBase<ELFT> *Sec : Sections) {
     StringRef Name = Sec->getName();
     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 = Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
+  Dot = Opt.ManualHeadersSize ? 0 : getSizeOfHeaders();
   uintX_t MinVA = std::numeric_limits<uintX_t>::max();
   uintX_t ThreadBssOffset = 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) {

 typename ELFT::uint LinkerScript<ELFT>::getOutputSectionSize(StringRef Name) {
   for (OutputSectionBase<ELFT> *Sec : *OutputSections)
     if (Sec->getName() == Name)
       return Sec->getSize();
   error("undefined section " + Name);
   return 0;
 }
 
+template <class ELFT>
+typename ELFT::uint LinkerScript<ELFT>::getSizeOfHeaders() {
+  return Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
+}
+
 // Returns indices of ELF headers containing specific section, identified
 // by Name. Each index is a zero based number of ELF header listed within
 // PHDRS {} script block.
 template <class ELFT>
 std::vector<size_t> LinkerScript<ELFT>::getPhdrIndices(StringRef SectionName) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
     if (!Cmd || Cmd->Name != SectionName)
static uint64_t getSectionSize(StringRef Name) {
   case ELF64BEKind:
     return Script<ELF64BE>::X->getOutputSectionSize(Name);
   default:
     llvm_unreachable("unsupported target");
   }
   return 0;
 }
 
+static uint64_t getSizeOfHeaders() {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    return Script<ELF32LE>::X->getSizeOfHeaders();
+  case ELF32BEKind:
+    return Script<ELF32BE>::X->getSizeOfHeaders();
+  case ELF64LEKind:
+    return Script<ELF64LE>::X->getSizeOfHeaders();
+  case ELF64BEKind:
+    return Script<ELF64BE>::X->getSizeOfHeaders();
+  default:
+    llvm_unreachable("unsupported target");
+  }
+  return 0;
+}
+
 SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
   StringRef Op = next();
   assert(Op == "=" || Op == "+=");
   Expr E = readExpr();
   if (Op == "+=")
     E = [=](uint64_t Dot) { return getSymbolValue(Name, Dot) + E(Dot); };
   return new SymbolAssignment(Name, E);
 }
if (Tok == "DATA_SEGMENT_RELRO_END") {
     return [](uint64_t Dot) { return alignTo(Dot, Target->PageSize); };
   }
   if (Tok == "SIZEOF") {
     expect("(");
     StringRef Name = next();
     expect(")");
     return [=](uint64_t Dot) { return getSectionSize(Name); };
   }
+  if (Tok == "SIZEOF_HEADERS") {
+    Opt.ManualHeadersSize = true;
+    return [=](uint64_t Dot) { return getSizeOfHeaders(); };
+  }
 
   // Parse a symbol name or a number literal.
   uint64_t V = 0;
   if (Tok.getAsInteger(0, V)) {
     if (Tok != "." && !isValidCIdentifier(Tok))
       setError("malformed number: " + Tok);
     return [=](uint64_t Dot) { return getSymbolValue(Tok, Dot); };
   }

test/ELF/linkerscript/linkerscript-sizeofheaders.s

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