[yaml2obj] - Implement the "Offset" property for the Fill Chunk.

[grimar]

Summary

Similar to a regular section chunk, a Fill should have this property.
This patch implements it.

[MaskRay]

Looks great!

[jhenderson]

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

305

arbitraty -> arbitrary

309

I'm not sure we really need to check the section header table offset, as the position of .bar is sufficient to show the fill impacts the offset calculations.

[grimar]

• Addressed review comments.

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

309

Probably you're right. Not sure why I've added this line.

[jhenderson]

LGTM.

llvm/include/llvm/ObjectYAML/ELFYAML.h

enum class ChunkKind {
     Fill,
     LinkerOptions,
     DependentLibraries,
     CallGraphProfile
   };
 
   ChunkKind Kind;
   StringRef Name;
+  Optional<llvm::yaml::Hex64> Offset;
 
   Chunk(ChunkKind K) : Kind(K) {}
   virtual ~Chunk();
 };
 
 struct Section : public Chunk {
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
   Optional<llvm::yaml::Hex64> Address;
   StringRef Link;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
-  Optional<llvm::yaml::Hex64> Offset;
 
   // Usually sections are not created implicitly, but loaded from YAML.
   // When they are, this flag is used to signal about that.
   bool IsImplicit;
 
   // Holds the original section index.
   unsigned OriginalSecNdx;
 

 
 // Fill is a block of data which is placed outside of sections. It is
 // not present in the sections header table, but it might affect the output file
 // size and program headers produced.
 struct Fill : Chunk {
   Optional<yaml::BinaryRef> Pattern;
   llvm::yaml::Hex64 Size;
 
-  // We have to remember the offset of the fill, because it does not have
-  // a corresponding section header, unlike a section. We might need this
-  // information when writing the output.
-  uint64_t ShOffset;
-
   Fill() : Chunk(ChunkKind::Fill) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
 };
 
 struct StackSizesSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;

llvm/lib/ObjectYAML/ELFEmitter.cpp

 void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   SHeaders.resize(Doc.getSections().size());
 
   size_t SecNdx = -1;
   for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
-    if (auto S = dyn_cast<ELFYAML::Fill>(D.get())) {
-      S->ShOffset = alignToOffset(CBA, /*Align=*/1, /*Offset=*/None);
+    if (ELFYAML::Fill *S = dyn_cast<ELFYAML::Fill>(D.get())) {
+      S->Offset = alignToOffset(CBA, /*Align=*/1, S->Offset);
       writeFill(*S, CBA);
       LocationCounter += S->Size;
       continue;
     }
 
     ++SecNdx;
     ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
     if (SecNdx == 0 && Sec->IsImplicit)
for (const ELFYAML::SectionName &SecName : Phdr.Sections) {
     unsigned Index;
     if (SN2I.lookup(SecName.Section, Index)) {
       const typename ELFT::Shdr &H = SHeaders[Index];
       Ret.push_back({H.sh_offset, H.sh_size, H.sh_type, H.sh_addralign});
       continue;
     }
 
     if (ELFYAML::Fill *Fill = NameToFill.lookup(SecName.Section)) {
-      Ret.push_back({Fill->ShOffset, Fill->Size, llvm::ELF::SHT_PROGBITS,
+      Ret.push_back({*Fill->Offset, Fill->Size, llvm::ELF::SHT_PROGBITS,
                      /*ShAddrAlign=*/1});
       continue;
     }
 
     reportError("unknown section or fill referenced: '" + SecName.Section +
                 "' by program header");
   }
 

llvm/lib/ObjectYAML/ELFYAML.cpp

static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Symbols", Section.Symbols);
 }
 
 static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
   IO.mapOptional("Name", Fill.Name, StringRef());
   IO.mapOptional("Pattern", Fill.Pattern);
+  IO.mapOptional("Offset", Fill.Offset);
   IO.mapRequired("Size", Fill.Size);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Options", Section.Options);
   IO.mapOptional("Content", Section.Content);
 }

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

 Sections:
   - Type:    Fill
     Pattern: ""
     Size:    0
 ProgramHeaders:
   - Type: PT_LOAD
     Sections:
       - Section: fill
+
+## Show that we can use the "Offset" key to set an arbitrary offset for a Fill.
+
+## 0x41 is the minimal possible valid offset for Fill,
+## because the .foo section of size 0x1 is placed at 0x40.
+# RUN: yaml2obj --docnum=11 -DOFFSET=0x41 -o %t11 %s
+# RUN: llvm-readelf --section-headers %t11 | FileCheck %s --check-prefix=OFFSET-MIN
+
+## 0x123 is an arbitrary offset.
+# RUN: yaml2obj --docnum=11 -DOFFSET=0x123 -o %t12 %s
+# RUN: llvm-readelf --section-headers %t12 | FileCheck %s --check-prefix=OFFSET
+
+# OFFSET-MIN:      Section Headers:
+# OFFSET-MIN-NEXT:  [Nr] Name Type     Address          Off    Size
+# OFFSET-MIN-NEXT:  [ 0]      NULL     0000000000000000 000000 000000
+# OFFSET-MIN-NEXT:  [ 1] .foo PROGBITS 0000000000000000 000040 000001
+# OFFSET-MIN-NEXT:  [ 2] .bar PROGBITS 0000000000000000 000042 000001
+
+# OFFSET:      Section Headers:
+# OFFSET-NEXT:  [Nr] Name Type     Address          Off    Size
+# OFFSET-NEXT:  [ 0]      NULL     0000000000000000 000000 000000
+# OFFSET-NEXT:  [ 1] .foo PROGBITS 0000000000000000 000040 000001
+# OFFSET-NEXT:  [ 2] .bar PROGBITS 0000000000000000 000124 000001
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Size: 1
+  - Type:    Fill
+    Pattern: "AA"
+    Size:    0x1
+    Offset:  [[OFFSET]]
+  - Name: .bar
+    Type: SHT_PROGBITS
+    Size: 1
+
+## Show that the "Offset" value can't go backward.
+# RUN: not yaml2obj --docnum=11 -DOFFSET=0x40 2>&1 %s | FileCheck %s --check-prefix=OFFSET-ERR
+
+# OFFSET-ERR: error: the 'Offset' value (0x40) goes backward