[ELF] - Linkerscript: implemented SIZEOF(section)

[grimar]

Summary

SIZEOF(section)
Return the size in bytes of the named section, if that section has been allocated.

SIZEOF(section) often used in scripts. Few examples from the wild:
https://github.com/chipKIT32/pic32-Arduino-USB-Bootloader-original/blob/master/boot-linkerscript.ld
https://github.com/devkitPro/buildscripts/blob/master/dkarm-eabi/crtls/gba_cart.ld

Patch implements it.

[ruiu]

ELF/LinkerScript.h

161

I don't think it's beautiful as you are holding a pointer to a factory just to get sizes of sections. Factory is too powerful to be here.

LinkerScript creates output sections. Why don't you save it instead?

Also, as I described in https://reviews.llvm.org/D22740, this is yet another example that you are accessing something other than Dot to evaluate expressions. I do not see a reason to handle Dot as a special case. If you like to pass all variables as parameters, why don't you pass it as a Expr's parameter?

[grimar]

ELF/LinkerScript.h

161

I thought that holding factory can help to simplify. We can get rid of arguments in methods in some pending patches and use this factory member instead.
LinkerScript creates some output sections, but that is the same what factory knows already, so I supposed it it better to reuse it than save what we created.
Anyways I just realized that factory is not enough either. I need to get somehow all sections including those which are added in addPredefinedSections(). So I guess I need to store Writer::OutputSections pointer instead. I`ll think what can be done here tomorrow.

[grimar]

ELF/LinkerScript.h

161

I do not see a reason to handle Dot as a special case.

I think Dot is a bit different and special. For example D22683 has calculateSymbolValue() which relies on ability to pass any value as Dot.
Main problem of Dot is that it is a value that always changes. I do not really feel it is a some config attribute, it's behavior more like a temporarily variable. I suggest to land few more LS things and return to idea to do something with Dot when it will be more clear how it's using can be simplified.

[grimar]

• Do not store Factory, store a pointer to output sections list instead.

[ruiu]

LGTM

ELF/LinkerScript.cpp

950

I started to really like the way how we handle expressions using lambdas. It's short, versatile and easy-to-write.

[grimar]

ELF/LinkerScript.cpp

950

Yes, it is very nice looking I think !

ELF/LinkerScript.h

 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 
 public:
-  std::vector<OutputSectionBase<ELFT> *>
-  createSections(OutputSectionFactory<ELFT> &Factory);
+  void createSections(std::vector<OutputSectionBase<ELFT> *> *Out,
+                      OutputSectionFactory<ELFT> &Factory);
 
   std::vector<PhdrEntry<ELFT>>
   createPhdrs(ArrayRef<OutputSectionBase<ELFT> *> S);
 
   ArrayRef<uint8_t> getFiller(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses(ArrayRef<OutputSectionBase<ELFT> *> S);
   int compareSections(StringRef A, StringRef B);
   void addScriptedSymbols();
   bool hasPhdrsCommands();
+  uintX_t getOutputSectionSize(StringRef Name);
 
 private:
   std::vector<std::pair<StringRef, const InputSectionDescription *>>
   getSectionMap();
 
   std::vector<InputSectionBase<ELFT> *>
   getInputSections(const InputSectionDescription *);
 
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
-  std::vector<OutputSectionBase<ELFT> *>
-  filter(std::vector<OutputSectionBase<ELFT> *> &Sections);
+  void filter();
 
   int getSectionIndex(StringRef Name);
   std::vector<size_t> getPhdrIndices(StringRef SectionName);
   size_t getPhdrIndex(StringRef PhdrName);
   void dispatchAssignment(SymbolAssignment *Cmd);
 
+  std::vector<OutputSectionBase<ELFT> *> *OutputSections;
   uintX_t Dot;
 };
 
 // Variable template is a C++14 feature, so we can't template
 // a global variable. Use a struct to workaround.
 template <class ELFT> struct Script { static LinkerScript<ELFT> *X; };
 template <class ELFT> LinkerScript<ELFT> *Script<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/LinkerScript.cpp

LinkerScript<ELFT>::getInputSections(const InputSectionDescription *I) {
 
   if ((llvm::find(Patterns, "COMMON") != Patterns.end()))
     Ret.push_back(CommonInputSection<ELFT>::X);
 
   return Ret;
 }
 
 template <class ELFT>
-std::vector<OutputSectionBase<ELFT> *>
-LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
-  std::vector<OutputSectionBase<ELFT> *> Ret;
+void LinkerScript<ELFT>::createSections(
+    std::vector<OutputSectionBase<ELFT> *> *Out,
+    OutputSectionFactory<ELFT> &Factory) {
+  OutputSections = Out;
 
   // Add input section to output section. If there is no output section yet,
   // then create it and add to output section list.
   auto Add = [&](InputSectionBase<ELFT> *C, StringRef Name) {
     OutputSectionBase<ELFT> *Sec;
     bool IsNew;
     std::tie(Sec, IsNew) = Factory.create(C, Name);
     if (IsNew)
-      Ret.push_back(Sec);
+      OutputSections->push_back(Sec);
     Sec->addSection(C);
   };
 
   for (auto &P : getSectionMap()) {
     StringRef OutputName = P.first;
     const InputSectionDescription *I = P.second;
     for (InputSectionBase<ELFT> *S : getInputSections(I)) {
       if (OutputName == "/DISCARD/") {
void LinkerScript<ELFT>::createSections(
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
        Symtab<ELFT>::X->getObjectFiles())
     for (InputSectionBase<ELFT> *S : F->getSections())
       if (!isDiscarded(S) && !S->OutSec)
         Add(S, getOutputSectionName(S));
 
   // Remove from the output all the sections which did not meet
   // the optional constraints.
-  return filter(Ret);
+  filter();
 }
 
 // Process ONLY_IF_RO and ONLY_IF_RW.
-template <class ELFT>
-std::vector<OutputSectionBase<ELFT> *>
-LinkerScript<ELFT>::filter(std::vector<OutputSectionBase<ELFT> *> &Sections) {
+template <class ELFT> void LinkerScript<ELFT>::filter() {
   // In this loop, we remove output sections if they don't satisfy
   // requested properties.
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get());
     if (!Cmd || Cmd->Name == "/DISCARD/")
       continue;
 
     if (Cmd->Constraint == ConstraintKind::NoConstraint)
       continue;
 
-    auto It = llvm::find_if(Sections, [&](OutputSectionBase<ELFT> *S) {
+    auto It = llvm::find_if(*OutputSections, [&](OutputSectionBase<ELFT> *S) {
       return S->getName() == Cmd->Name;
     });
-    if (It == Sections.end())
+    if (It == OutputSections->end())
       continue;
 
     OutputSectionBase<ELFT> *Sec = *It;
     bool Writable = (Sec->getFlags() & SHF_WRITE);
     bool RO = (Cmd->Constraint == ConstraintKind::ReadOnly);
     bool RW = (Cmd->Constraint == ConstraintKind::ReadWrite);
 
     if ((RO && Writable) || (RW && !Writable))
-      Sections.erase(It);
+      OutputSections->erase(It);
   }
-  return Sections;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::assignAddresses(
     ArrayRef<OutputSectionBase<ELFT> *> Sections) {
   // Orphan sections are sections present in the input files which
   // are not explicitly placed into the output file by the linker script.
   // We place orphan sections at end of file.
for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     Cmd->Sym = Sym->body();
   }
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::hasPhdrsCommands() {
   return !Opt.PhdrsCommands.empty();
 }
 
+template <class ELFT>
+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;
+}
+
 // 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)
case ELF64BEKind:
     break;
   default:
     llvm_unreachable("unsupported target");
   }
   error("symbol not found: " + S);
   return 0;
 }
 
+static uint64_t getSectionSize(StringRef Name) {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    return Script<ELF32LE>::X->getOutputSectionSize(Name);
+  case ELF32BEKind:
+    return Script<ELF32BE>::X->getOutputSectionSize(Name);
+  case ELF64LEKind:
+    return Script<ELF64LE>::X->getOutputSectionSize(Name);
+  case ELF64BEKind:
+    return Script<ELF64BE>::X->getOutputSectionSize(Name);
+  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); };
   auto *Cmd = new SymbolAssignment(Name, E);
   Opt.Commands.emplace_back(Cmd);
Expr ScriptParser::readPrimary() {
   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(")");
+    return [=](uint64_t Dot) { return getSectionSize(Name); };
+  }
 
   // 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); };
   }

ELF/Writer.cpp

public:
   Writer(SymbolTable<ELFT> &S) : Symtab(S) {}
   void run();
 
 private:
   typedef PhdrEntry<ELFT> Phdr;
 
   void copyLocalSymbols();
   void addReservedSymbols();
-  std::vector<OutputSectionBase<ELFT> *> createSections();
+  void createSections();
   void forEachRelSec(
       std::function<void(InputSectionBase<ELFT> &, const typename ELFT::Shdr &)>
           Fn);
   void finalizeSections();
   void addPredefinedSections();
   bool needsGot();
 
   std::vector<Phdr> createPhdrs();

 template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   addReservedSymbols();
 
   CommonInputSection<ELFT> Common(getCommonSymbols<ELFT>());
   CommonInputSection<ELFT>::X = &Common;
 
-  OutputSections = ScriptConfig->HasContents
-                       ? Script<ELFT>::X->createSections(Factory)
-                       : createSections();
+  if (ScriptConfig->HasContents)
+    Script<ELFT>::X->createSections(&OutputSections, Factory);
+  else
+    createSections();
+
   finalizeSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
     Phdrs = Script<ELFT>::X->hasPhdrsCommands()
for (InputSectionBase<ELFT> *C : F->getSections()) {
       }
       if (auto *S = dyn_cast<EhInputSection<ELFT>>(C))
         if (S->RelocSection)
           Fn(*S, *S->RelocSection);
     }
   }
 }
 
-template <class ELFT>
-std::vector<OutputSectionBase<ELFT> *> Writer<ELFT>::createSections() {
-  std::vector<OutputSectionBase<ELFT> *> Result;
-
+template <class ELFT> void Writer<ELFT>::createSections() {
   for (const std::unique_ptr<elf::ObjectFile<ELFT>> &F :
        Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
       if (isDiscarded(C)) {
         reportDiscarded(C);
         continue;
       }
       OutputSectionBase<ELFT> *Sec;
       bool IsNew;
       std::tie(Sec, IsNew) = Factory.create(C, getOutputSectionName(C));
       if (IsNew)
-        Result.push_back(Sec);
+        OutputSections.push_back(Sec);
       Sec->addSection(C);
     }
   }
-  return Result;
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // Create output sections for input object file sections.
   std::vector<OutputSectionBase<ELFT> *> RegularSections = OutputSections;
 
   // If we have a .opd section (used under PPC64 for function descriptors),

test/ELF/linkerscript/linkerscript-sizeof.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { \
+# RUN:   .aaa         : { *(.aaa) } \
+# RUN:   .bbb         : { *(.bbb) } \
+# RUN:   .ccc         : { *(.ccc) } \
+# RUN:   _aaa = SIZEOF(.aaa); \
+# RUN:   _bbb = SIZEOF(.bbb); \
+# RUN:   _ccc = SIZEOF(.ccc); \
+# RUN: }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -t -section-headers %t1 | FileCheck %s
+# CHECK:      Sections:
+# CHECK-NEXT:  Idx Name          Size      Address          Type
+# CHECK-NEXT:    0               00000000 0000000000000000
+# CHECK-NEXT:    1 .aaa          00000008 0000000000000120 DATA
+# CHECK-NEXT:    2 .bbb          00000010 0000000000000128 DATA
+# CHECK-NEXT:    3 .ccc          00000018 0000000000000138 DATA
+# CHECK:      SYMBOL TABLE:
+# CHECK-NEXT:  0000000000000000 *UND* 00000000
+# CHECK-NEXT:  0000000000000150 .text 00000000 _start
+# CHECK-NEXT:  0000000000000008 *ABS* 00000000 _aaa
+# CHECK-NEXT:  0000000000000010 *ABS* 00000000 _bbb
+# CHECK-NEXT:  0000000000000018 *ABS* 00000000 _ccc
+
+## Check that we error out if trying to get size of
+## section that does not exist.
+# RUN: echo "SECTIONS { \
+# RUN:   .aaa         : { *(.aaa) } \
+# RUN:   .bbb         : { *(.bbb) } \
+# RUN:   .ccc         : { *(.ccc) } \
+# RUN:   _aaa = SIZEOF(.foo); \
+# RUN: }" > %t.script
+# RUN: not ld.lld -o %t1 --script %t.script %t 2>&1 \
+# RUN:  | FileCheck -check-prefix=ERR %s
+# ERR: undefined section .foo
+
+.global _start
+_start:
+ nop
+
+.section .aaa,"a"
+ .quad 0
+
+.section .bbb,"a"
+ .quad 0
+ .quad 0
+
+.section .ccc,"a"
+ .quad 0
+ .quad 0
+ .quad 0