[ELF] - Linkerscript: implemented FILL command.

[grimar]

Summary

The FILL command is similar to the ‘=fillexp’ output section attribute, but it only affects
the part of the section following the FILL command, rather than the entire section. If both
are used, the FILL command takes precedence.

This is PR30243

[ruiu]

Did you find any uses case of multiple FILL commands in one section definition? It seems to me that it's too complicated. I'd like to handle it as an alias to =<fillexp> feature.

[grimar]

In D24186#532797, @ruiu wrote:

Did you find any uses case of multiple FILL commands in one section definition? It seems to me that it's too complicated. I'd like to handle it as an alias to =<fillexp> feature.

I didn't yet. Not sure that simple alias will work here. FILL command only affects the part of the section following the FILL command. So it would be very different behavior in total even for simple case when single FILL is somewhere at the midde of section.

I leaved a question on PR30243 page, let see if anyone knows the real life use cases for it.

[ruiu]

My point is do you really need that behavior. I suspect not.

[emaste]

I leaved a question on PR30243 page, let see if anyone knows the real life use cases for it.

I'm not aware of any uses for fine-grained control over fill values off hand, but I haven't looked in detail.

[grimar]

So looks we dont need that complexity and trivial D24227 will be commited instead.

ELF/LinkerScript.h

 void readVersionScript(MemoryBufferRef MB);
 
 // This enum is used to implement linker script SECTIONS command.
 // https://sourceware.org/binutils/docs/ld/SECTIONS.html#SECTIONS
 enum SectionsCommandKind {
   AssignmentKind,
   OutputSectionKind,
   InputSectionKind,
-  AssertKind
+  AssertKind,
+  FillKind
 };
 
 struct BaseCommand {
   BaseCommand(int K) : Kind(K) {}
   virtual ~BaseCommand() {}
   int Kind;
 };
 

 };
 
 struct AssertCommand : BaseCommand {
   AssertCommand(Expr E) : BaseCommand(AssertKind), Expression(E) {}
   static bool classof(const BaseCommand *C);
   Expr Expression;
 };
 
+struct FillCommand : BaseCommand {
+  FillCommand() : BaseCommand(FillKind) {}
+  static bool classof(const BaseCommand *C);
+  std::vector<uint8_t> Value;
+  InputSectionData *GoesAfter = nullptr;
+  uint64_t Offset = 0;
+};
+
 struct PhdrsCommand {
   StringRef Name;
   unsigned Type;
   bool HasFilehdr;
   bool HasPhdrs;
   unsigned Flags;
 };
 
public:
   LinkerScript();
   ~LinkerScript();
   void createAssignments();
   void createSections(OutputSectionFactory<ELFT> &Factory);
 
   std::vector<PhdrEntry<ELFT>> createPhdrs();
   bool ignoreInterpSection();
 
-  ArrayRef<uint8_t> getFiller(StringRef Name);
+  std::vector<std::pair<uint64_t, ArrayRef<uint8_t>>>
+  getFillerMap(StringRef Name);
+
   Expr getLma(StringRef Name);
   bool shouldKeep(InputSectionBase<ELFT> *S);
   void assignAddresses();
   int compareSections(StringRef A, StringRef B);
   bool hasPhdrsCommands();
   uintX_t getOutputSectionAddress(StringRef Name);
   uintX_t getOutputSectionSize(StringRef Name);
   uintX_t getHeaderSize();

ELF/LinkerScript.cpp

 bool InputSectionDescription::classof(const BaseCommand *C) {
   return C->Kind == InputSectionKind;
 }
 
 bool AssertCommand::classof(const BaseCommand *C) {
   return C->Kind == AssertKind;
 }
 
+bool FillCommand::classof(const BaseCommand *C) {
+  return C->Kind == FillKind;
+}
+
 template <class ELFT> static bool isDiscarded(InputSectionBase<ELFT> *S) {
   return !S || !S->Live;
 }
 
 template <class ELFT> LinkerScript<ELFT>::LinkerScript() {}
 template <class ELFT> LinkerScript<ELFT>::~LinkerScript() {}
 
 template <class ELFT>
LinkerScript<ELFT>::createInputSectionList(OutputSectionCommand &OutCmd) {
 
   for (const std::unique_ptr<BaseCommand> &Base : OutCmd.Commands) {
     if (auto *OutCmd = dyn_cast<SymbolAssignment>(Base.get())) {
       if (shouldDefine<ELFT>(OutCmd))
         addSynthetic<ELFT>(OutCmd);
       OutCmd->GoesAfter = Ret.empty() ? nullptr : Ret.back();
       continue;
     }
+    if (auto *OutCmd = dyn_cast<FillCommand>(Base.get())) {
+      OutCmd->GoesAfter = Ret.empty() ? nullptr : Ret.back();
+      continue;
+    }
+
+    if (isa<FillCommand>(Base.get()))
+      continue;
 
     auto *Cmd = cast<InputSectionDescription>(Base.get());
     std::vector<InputSectionBase<ELFT> *> V = getInputSections(Cmd);
     if (!matchConstraints<ELFT>(V, OutCmd.Constraint))
       continue;
     if (Cmd->SortInner)
       std::stable_sort(V.begin(), V.end(), getComparator<ELFT>(Cmd->SortInner));
     if (Cmd->SortOuter)
if (auto *AssignCmd = dyn_cast<SymbolAssignment>(Base.get())) {
               "' supports only start and end symbols");
       Start = false;
     }
     PrevCmd = Base.get();
   }
 }
 
 template <class ELFT>
+static bool isGoesAfter(BaseCommand *Cmd, InputSectionData *D) {
+  if (auto *AssignCmd = dyn_cast<SymbolAssignment>(Cmd))
+    return AssignCmd->GoesAfter == D;
+  return cast<FillCommand>(Cmd)->GoesAfter == D;
+}
+
+template <class ELFT>
 void assignOffsets(OutputSectionCommand *Cmd, OutputSectionBase<ELFT> *Sec) {
   auto *OutSec = dyn_cast<OutputSection<ELFT>>(Sec);
   if (!OutSec) {
     Sec->assignOffsets();
     // This section is not regular output section. However linker script may
     // have defined start/end symbols for it. This case is handled below.
     addStartEndSymbols(Cmd, Sec);
     return;
   }
   typedef typename ELFT::uint uintX_t;
   uintX_t Off = 0;
   auto ItCmd = Cmd->Commands.begin();
 
   // Assigns values to all symbols following the given
   // input section 'D' in output section 'Sec'. When symbols
   // are in the beginning of output section the value of 'D'
   // is nullptr.
   auto AssignSuccessors = [&](InputSectionData *D) {
     for (; ItCmd != Cmd->Commands.end(); ++ItCmd) {
-      auto *AssignCmd = dyn_cast<SymbolAssignment>(ItCmd->get());
-      if (!AssignCmd)
+      BaseCommand *Cmd = ItCmd->get();
+      if (!isa<SymbolAssignment>(Cmd) && !isa<FillCommand>(Cmd))
         continue;
-      if (D != AssignCmd->GoesAfter)
+      if (!isGoesAfter<ELFT>(Cmd, D))
         break;
 
+      if (auto *FillCmd = dyn_cast<FillCommand>(Cmd)) {
+        FillCmd->Offset = Off;
+        continue;
+      }
+
+      auto *AssignCmd = cast<SymbolAssignment>(Cmd);
       uintX_t Value = AssignCmd->Expression(Sec->getVA() + Off) - Sec->getVA();
       if (AssignCmd->Name == ".") {
         // Update to location counter means update to section size.
         Off = Value;
         Sec->setSize(Off);
         continue;
       }
 
template <class ELFT> bool LinkerScript<ELFT>::ignoreInterpSection() {
   // and PT_INTERP isn't listed.
   return !Opt.PhdrsCommands.empty() &&
          llvm::find_if(Opt.PhdrsCommands, [](const PhdrsCommand &Cmd) {
            return Cmd.Type == PT_INTERP;
          }) == Opt.PhdrsCommands.end();
 }
 
 template <class ELFT>
-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;
+std::vector<std::pair<uint64_t, ArrayRef<uint8_t>>>
+LinkerScript<ELFT>::getFillerMap(StringRef Name) {
+  std::vector<std::pair<uint64_t, ArrayRef<uint8_t>>> Ret;
+  for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands)
+    if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
+      if (Cmd->Name != Name)
+        continue;
+      for (const std::unique_ptr<BaseCommand> &Base2 : Cmd->Commands)
+        if (auto *Cmd = dyn_cast<FillCommand>(Base2.get()))
+          Ret.push_back({Cmd->Offset, Cmd->Value});
+
+      if (!Ret.empty())
+        return Ret;
+      if (Cmd->Filler.empty())
+        return {};
+      return {{0, Cmd->Filler}};
+    }
+
   return {};
 }
 
 template <class ELFT> Expr LinkerScript<ELFT>::getLma(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;
private:
   void readOutputFormat();
   void readPhdrs();
   void readSearchDir();
   void readSections();
   void readVersion();
   void readVersionScriptCommand();
 
   SymbolAssignment *readAssignment(StringRef Name);
+  FillCommand *readFill();
   OutputSectionCommand *readOutputSectionDescription(StringRef OutSec);
+  std::vector<uint8_t> readSectionFiller(StringRef Tok);
   std::vector<uint8_t> readOutputSectionFiller();
   std::vector<StringRef> readOutputSectionPhdrs();
   InputSectionDescription *readInputSectionDescription(StringRef Tok);
   std::vector<StringRef> readInputFilePatterns();
   InputSectionDescription *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
   SortKind readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   if (skip("ONLY_IF_RW"))
     Cmd->Constraint = ConstraintKind::ReadWrite;
   expect("{");
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (SymbolAssignment *Assignment = readProvideOrAssignment(Tok))
       Cmd->Commands.emplace_back(Assignment);
+    else if (Tok == "FILL")
+      Cmd->Commands.emplace_back(readFill());
     else if (Tok == "SORT")
       readSort();
     else if (peek() == "(")
       Cmd->Commands.emplace_back(readInputSectionDescription(Tok));
     else
       setError("unknown command " + Tok);
   }
   Cmd->Phdrs = readOutputSectionPhdrs();
   Cmd->Filler = readOutputSectionFiller();
   return Cmd;
 }
 
 // Read "=<number>" where <number> is an octal/decimal/hexadecimal number.
 // https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
 //
 // ld.gold is not fully compatible with ld.bfd. ld.bfd handles
 // hexstrings as blobs of arbitrary sizes, while ld.gold handles them
 // as 32-bit big-endian values. We will do the same as ld.gold does
 // because it's simpler than what ld.bfd does.
-std::vector<uint8_t> ScriptParser::readOutputSectionFiller() {
-  if (!peek().startswith("="))
-    return {};
-
-  StringRef Tok = next();
+std::vector<uint8_t> ScriptParser::readSectionFiller(StringRef Tok) {
   uint32_t V;
-  if (Tok.substr(1).getAsInteger(0, V)) {
+  if (Tok.getAsInteger(0, V)) {
     setError("invalid filler expression: " + Tok);
     return {};
   }
   return {uint8_t(V >> 24), uint8_t(V >> 16), uint8_t(V >> 8), uint8_t(V)};
 }
 
+std::vector<uint8_t> ScriptParser::readOutputSectionFiller() {
+  if (!peek().startswith("="))
+    return {};
+  return readSectionFiller(next().drop_front());
+}
+
 SymbolAssignment *ScriptParser::readProvideHidden(bool Provide, bool Hidden) {
   expect("(");
   SymbolAssignment *Cmd = readAssignment(next());
   Cmd->Provide = Provide;
   Cmd->Hidden = Hidden;
   expect(")");
   expect(";");
   return Cmd;
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);
 }
 
+FillCommand *ScriptParser::readFill() {
+  FillCommand *Cmd = new FillCommand();
+  expect("(");
+  Cmd->Value = readSectionFiller(next());
+  expect(")");
+  expect(";");
+  return Cmd;
+}
+
 // This is an operator-precedence parser to parse a linker
 // script expression.
 Expr ScriptParser::readExpr() { return readExpr1(readPrimary(), 0); }
 
 static Expr combine(StringRef Op, Expr L, Expr R) {
   if (Op == "*")
     return [=](uint64_t Dot) { return L(Dot) * R(Dot); };
   if (Op == "/") {

ELF/OutputSections.cpp

 
 static void fill(uint8_t *Buf, size_t Size, ArrayRef<uint8_t> A) {
   size_t I = 0;
   for (; I + A.size() < Size; I += A.size())
     memcpy(Buf + I, A.data(), A.size());
   memcpy(Buf + I, A.data(), Size - I);
 }
 
+static void fillMap(uint8_t *Buf, size_t Size,
+                    ArrayRef<std::pair<uint64_t, ArrayRef<uint8_t>>> A) {
+  for (size_t I = 0, E = A.size(); I < E; ++I) {
+    size_t Offset = A[I].first;
+    ArrayRef<uint8_t> Filler = A[I].second;
+    if (I != E - 1) {
+      size_t NextOffset = A[I + 1].first;
+      size_t S = NextOffset - Offset;
+      fill(Buf + Offset, S, Filler);
+      continue;
+    }
+    fill(Buf + Offset, Size - Offset, Filler);
+  }
+}
+
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
-  ArrayRef<uint8_t> Filler = Script<ELFT>::X->getFiller(this->Name);
+  std::vector<std::pair<uint64_t, ArrayRef<uint8_t>>> Filler =
+      Script<ELFT>::X->getFillerMap(this->Name);
   if (!Filler.empty())
-    fill(Buf, this->getSize(), Filler);
+    fillMap(Buf, this->getSize(), Filler);
+
   if (Config->Threads) {
     parallel_for_each(Sections.begin(), Sections.end(),
                       [=](InputSection<ELFT> *C) { C->writeTo(Buf); });
   } else {
     for (InputSection<ELFT> *C : Sections)
       C->writeTo(Buf);
   }
 }

test/ELF/linkerscript/linkerscript-fill.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: echo "SECTIONS {     \
+# RUN:  .out : {            \
+# RUN:   FILL(0x11111111);  \
+# RUN:   *(.aaa)            \
+# RUN:   . += 4;            \
+# RUN:   *(.bbb)            \
+# RUN:   . += 4;            \
+# RUN:   FILL(0x22222222);  \
+# RUN:   . += 4;            \
+# RUN:  }                   \
+# RUN: }; " > %t.script
+# RUN: ld.lld -o %t --script %t.script %t.o
+# RUN: llvm-objdump -s %t | FileCheck %s
+
+# CHECK:      Contents of section .out:
+# CHECK-NEXT: 0120 aa111111 11bb1111 11112222 2222
+
+## If both FILL and ‘=fillexp’ are used then
+## that FILL command takes precedence.
+# RUN: echo "SECTIONS {     \
+# RUN:  .out : {            \
+# RUN:   FILL(0x11111111);  \
+# RUN:   *(.aaa)            \
+# RUN:   . += 4;            \
+# RUN:   *(.bbb)            \
+# RUN:   . += 4;            \
+# RUN:   FILL(0x22222222);  \
+# RUN:   . += 4;            \
+# RUN:  }=0x99887766        \
+# RUN: }; " > %t2.script
+# RUN: ld.lld -o %t2 --script %t2.script %t.o
+# RUN: llvm-objdump -s %t2 | FileCheck %s
+
+.text
+.globl _start
+_start:
+
+.section .aaa, "a"
+.align 1
+.byte 0xAA
+
+.section .bbb, "a"
+.align 1
+.byte 0xBB

test/ELF/linkerscript/linkerscript-sections-padding.s

 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -s %t.out | FileCheck -check-prefix=DEC %s
 # DEC: 0120  66000309 00000309 00000309 00000309
 
 ## Invalid hex value:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x99XX }" > %t.script
 # RUN: not ld.lld -o %t.out --script %t.script %t 2>&1 \
 # RUN:   | FileCheck --check-prefix=ERR2 %s
-# ERR2: invalid filler expression: =0x99XX
+# ERR2: invalid filler expression: 0x99XX
 
 .section        .mysec.1,"a"
 .align  16
 .byte   0x66
 
 .section        .mysec.2,"a"
 .align  16
 .byte   0x66
 
 .globl _start
 _start:
  nop