[yaml2obj] - Add a way to describe the custom data that is not part of an output section.

[grimar]

Summary

Currently there is no way to describe the data that is not a part of an output section.
It can be a data used to align sections or to fill the gaps with something,
or another kind of custom data. In this patch I suggest a way to describe it. It looks like that:

Sections:
  - Type:    CustomFiller
    Pattern: "CCDD"
    Size:    4
  - Name:    .bar
    Type:    SHT_PROGBITS
    Content: "FF"

I.e. I've added a kind of synthetic section with a synthetic type "CustomFiller".
In the code it is called a "SyntheticFiller", which is "a synthetic section which
might be used to write the custom data around regular output sections. It does
not present in the sections header table, but it might affect the output file size and
program headers produced. Think about it as about piece of data."

SyntheticFiller currently has a Pattern field and a Size field + an optional Name.
When written, Size of bytes in the output will be filled with a Pattern.
It is possible to reference a named filler it by name from the program headers description,
just like any other normal section.

[grimar]

• Made obj2yaml compilable.

(I haven't run its or another test cases though, I'd like to hear what people think
about such way of describing things first).

[jhenderson]

My initial thought on this was that these padding blocks should be kept separate to sections, so that they don't get confused with sections. However, I realise that unless you started allowing for them (and sections) to be placed at arbitrary offsets, which I expect would be complicated to implement, it would be difficult to place them at the right locations. As such, I think this is the right approach.

I assume the optional Name is to allow them to be referenced by program headers? I wonder if we need to have some way of controlling their offset. For sections, you can use tricks involving AddressAlign and Address, but these don't really make sense for padding blocks. I also don't think an Offset field is a good idea unless we only allow them to be increasing (i.e. if a section appears later in the list with an Offset lower than the end of the previous section, it's an error).

I do think the overall goal of this patch is good. I've had to write a few tests in the past using custom python to write blobs at appropriate places/use llvm-objcopy to remove sections etc, to create the exact object I want. Having this native to yaml2obj would make this easier.

[grimar]

In D69709#1730081, @jhenderson wrote:

I assume the optional Name is to allow them to be referenced by program headers?

Right.

I wonder if we need to have some way of controlling their offset.

Yeah. For initial patch I decided to start from a reasonable minimum, but this approach is expandable and
I've thought about something like "FillUpToOffset" field.
Then we could have:

Sections:
   - Type: CustomFiller
     Pattern: "00"
     FillUpToOffset:    0x100
   - Name: .text
     Type: SHT_PROGBITS
     Address: 0x100

It would then create .text at offset 0x100 with VA = 0x100.

[grimar]

I also don't think an Offset field is a good idea unless we only allow them to be increasing (i.e. if a section appears later in the list with an Offset lower than the end of the previous section, it's an error).

I think it is correct to error out in this case. It should be OK to only allow describing sections in the order they will be written to the output.
Having a error might even help, e.g. when you add a section you can forget that it requires an entry in a section header and that shifts things.

[grimar]

• Just an update for the place I really didn't like.

I am going to wait for another possible feedback and if everything be OK,
will add test cases and update the diff on the next week.

[labath]

I'm "cautiously optimistic" about this patch. :) One of the things I've been missing for a while is the ability to represent elf files which don't have any sections whatsoever (e.g. elf core files), and this seems to open the door for that. I've been thinking about the best way to implement that for a long time, but I haven't thought of this solution -- it's pretty neat. If we expand on this idea to include non-sections in the "Sections" array (which then really becomes just "Content"), then other things become hopefully within reach too. For instance, one can control the placement of program headers with a new kind of a "section", and even maybe create the weird self-referencing PT_PHDR segment.

[MaskRay]

llvm/include/llvm/ObjectYAML/ELFYAML.h

223

Looks like unrelated.

262

Looks like unrelated.

306

Looks like unrelated.

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

SegmentFragment may be a better name. Phdr (program header) looks to me properties that describe the program header, but here this structure describes fragments that make up the segment content.

[MaskRay]

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

The name is inspired by MCFragment, a concept in MC. It has several subclasses such as MCFillFragment, MCPaddingFragment, etc.

We probably should drop the Segment prefix from the name SegmentFragment. This structure can describe fragments of non-segment part as well, e.g. gaps between 2 non-SHF_ALLOC sections.

[grimar]

• Added missing test cases and code (i.e. the patch is now ready for review).
• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

Renamed to Segment. Also, renamed the method: getEntriesForPhdr -> getPhdrSegments.

[MaskRay]

llvm/lib/ObjectYAML/ELFYAML.cpp

1484

I feel that using Sections for Fragments may be confusing because Fragments are not described by the section header table. Does a new field add a lot of complexity? If not, we can add a parallel YAML mapping key Fragments, and use Fragments instead of Sections when there is a need for a Fragment (i.e. when there is non-section data that needs describing).

Opinions? @rupprecht @jhenderson @labath

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

1484

To clarify I understood the idea: do you mean that YAML writers should be able to use both "Sections" and "Fragments", where the latter will be just an alias for "Sections"? I.e to make both below to be valid?

Fragments:
- Section1
- Fragmen1
- Section2

Sections:
- Section1
- Fragmen1
- Section2

With that since they are both optional we will need to add a check that they are not specified at the same time. Also, I guess most of users will just randomly use either "Sections" or "Fragments" because of common copy-paste approach. I'd prefer just to rename "Sections" to something if there are any concerns about the naming.

When I wrote this patch I thought about this question though and came up to thinking about this part of YAML just like about a linker script's "SECTIONS" command. It might contain not only sections, but location counter moving, commands like "ASSERT" e.t.c, but it is still called "SECTIONS" and I probably do not find it confusing.

[jhenderson]

I've not looked at the test yet. I'll get to that later.

llvm/include/llvm/ObjectYAML/ELFYAML.h

150

Maybe SyntheticFill or even just Fill instead of SyntheticFiller? This would better match the linker script directive. Everything in the output is technically Synthetic too...

156

Maybe we should rename this class to something more generic, like Block or Piece or similar? A fill isn't really a section, and calling it that might get a bit confusing. RegularSection could then just be called Section.

210–211

"is a synthetic section which might be used to write the custom data around regular output sections" -> "is a block of data which is placed outside of sections"
"It does not present" -> "It is not present"
Then delete the "Think about it..." sentence.

219

"like normal section" -> "like a section"
Delete "But" and "still"

llvm/include/llvm/ObjectYAML/YAML.h

88–89

"the number of the bytes" -> "the maximum number of bytes"

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

Maybe the fields need renaming, as they aren't necessarily related to the sh_* section header fields? Probably just Offset, Size etc. What does Type mean for a non-section fragment?

204–205

Filler -> Fill (in all cases)

671

It doesn't look like SHeaders is modified. Can this be an ArrayRef?

672

NameToFiller -> NameToFill

693–695

I think you can just simplify this down to the section or filler message always.

Also filler -> fill

1213

Maybe PatternSize would make the below loop a little easier to follow.

1217

Maybe Written?

1220

Maybe a brief comment around here describing what exactly is written would be helpful. The variable renaming might make it superfluous though.

1251

I think it would be simpler to fold these two loops together, and then add one simple if to check whether to add to the DotShStrtab. You could use the Seen set to check for duplicates of both then, rather than needing to do extra look ups in SN2I. I'd also then tweak the error messages so that they say "section/fill" instead of just "section" or "CustomFiller".

llvm/lib/ObjectYAML/ELFYAML.cpp

1138

a one -> one

1142

I'd just call it "Fill".

1359–1361

I think defaulting to a value of '0' for the pattern would be perfectly reasonable if there is no Pattern specified.

1484

I'd keep it as "Sections". This is similar to linker scripts as @grimar says, but also more pragmatic, as I think the fill case is going to be rare, but when it is used, I think they should be mixed in order with the sections, as otherwise the order may be non-obvious.

llvm/lib/ObjectYAML/YAML.cpp

42

I'd get rid of this assert. If we make N mean "the maximum size to write", it implies that less will be written if there is less to write, so the assertion becomes unnecessary.

46

I'm not sure I follow the point of this assert? It probably needs an accompanying message.

[MaskRay]

llvm/include/llvm/ObjectYAML/ELFYAML.h

150

"Fill" looks good.

llvm/lib/ObjectYAML/ELFYAML.cpp

1142

"Fill" looks good.

1484

I like the SECTIONS command analogy :) And I see why you rename the Sections field to Descriptions (output section descriptions) now. I am fine with the simple approach, just asked about the thoughts of alternatives in case people might find it confusing. Since we don't find it confusing, keeping it as-is looks good.

[jhenderson]

llvm/test/tools/yaml2obj/custom-filler.yaml

2 ↗

(On Diff #227855)

Fillers -> Fills (here and everywhere else in this file).

3 ↗

(On Diff #227855)

either "sections, but" or "sections. However," (I marginally prefer the first)

8 ↗

(On Diff #227855)

affects on -> affects

9 ↗

(On Diff #227855)

the "Name" field

17–18 ↗

(On Diff #227855)

Maybe use BASIC-NEXT and test that there are no more entries apart from the expected .shstrtab (in other words, prove that there are no extra section headers for the fills).

20 ↗

(On Diff #227855)

Here and elsewhere in the test, consider using the -j and -N options for od to test the specific area you care about. Also test the offset field, to show that you are definitely checking the right bit.

40–42 ↗

(On Diff #227855)

Maybe worth one last fill at the end?

44 ↗

(On Diff #227855)

and can describe

55 ↗

(On Diff #227855)

Similar comment to above. Show that there are no other sections. Perhaps test e_shnum to achieve this?

58 ↗

(On Diff #227855)

This needs a comment explaining why the 00 is guaranteed to be that (i.e. the .strtab section starts at 0x46 and always has a nul byte at the start).

75 ↗

(On Diff #227855)

affect the

76 ↗

(On Diff #227855)

Maybe change this sentence to "Check that the fill does not affect the p_align field of the segment."

110 ↗

(On Diff #227855)

Flags is unnecessary (here and below).

You probably should have an address specified though, because the section address doesn't match up with the segment address. This is maybe something we should fix in yaml2obj (i.e. segment addresses are derived from contained sections if not specified, and possibly vice versa).

112 ↗

(On Diff #227855)

Maybe worth having a fill before .bar too, to show that they aren't just always placed at the end of a segment or something like that. It would also show that the correct fill can be selected this way (by having different names).

114 ↗

(On Diff #227855)

Nit: nested PT_LOADs are odd. Change this to something else like PT_GNU_RELRO or PT_TLS.

149 ↗

(On Diff #227855)

disallowed to have -> are not allowed to have

233 ↗

(On Diff #227855)

Maybe UNKNOWN-ERR would be clearer

[grimar]

• Addressed review comments.

llvm/include/llvm/ObjectYAML/ELFYAML.h

150

Ok, renamed to "Fill".

156

I've renamed to Chunk. Does it sound OK?

Also I had to rename the enum.

llvm/lib/ObjectYAML/ELFEmitter.cpp

671

Yes. Done.

1251

Ok, done. (I had loops splitted initially because I suppose that fills will be used not often, hence a message saying "section/fill" might raise a question about "what is fill?" when it is not important at all. But I do not expect seeing many errors of that kind anyways).

llvm/lib/ObjectYAML/YAML.cpp

46

After the change to "the maximum size to write" we do not need it probably.

[jhenderson]

llvm/include/llvm/ObjectYAML/ELFYAML.h

156

Chunk sounds good.

196

Might cause some naming ambiguities, so feel free to leave as is, but this can probably be named simply "Fill".

201

like -> unlike (sorry I got that one wrong!)

639–640

Should the parameters here still be called Section?

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

Ping?

1219

with the specified pattern.

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

130

I meant to have two fills in this segment, as well as .bar:

Sections:
  - Section: fill
  - Section: .bar
  - Section: fill2

138

I think it's probably harmless to allow fills to have no Pattern field. This is not significantly different from the case where the Pattern is an empty string.

267

I think this comment needs updating now that there aren't different error messages for where there is a/is no defined fill.

[grimar]

• Addressed review comments.

llvm/include/llvm/ObjectYAML/ELFYAML.h

196

Renamed to Fill, went fine.

639–640

Fixed.

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

Sorry, I've missed this comment somehow.
I've renamed the fields.

What does Type mean for a non-section fragment?

We have the following code when handling program headers:

uint64_t FileOffset = PHeader.p_offset, MemOffset = PHeader.p_offset;
for (const Fragment &F : Fragments) {
  uint64_t End = F.ShOffset + F.ShSize;
  MemOffset = std::max(MemOffset, End);

  if (F.ShType != llvm::ELF::SHT_NOBITS)
    FileOffset = std::max(FileOffset, End);
}

i.e. we handle SHT_NOBITS differently, so I had to intoduce a field to differentiate them.
The ShType was just consistent with other Sh* fields, thats why I added it.
We can have bool IsNobits or alike instead though. What do you prefer?

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

138

Ok.

[jhenderson]

LGTM.

llvm/lib/ObjectYAML/ELFEmitter.cpp

94

Type is fine, I think. Thanks for the explanation.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 };
 
 struct NoteEntry {
   StringRef Name;
   yaml::BinaryRef Desc;
   llvm::yaml::Hex32 Type;
 };
 
-struct Section {
-  enum class SectionKind {
+struct Chunk {
+  enum class ChunkKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
     Note,
     Hash,
     GnuHash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags,
-    Addrsig
+    Addrsig,
+    Fill
   };
-  SectionKind Kind;
+
+  ChunkKind Kind;
   StringRef Name;
+
+  Chunk(ChunkKind K) : Kind(K) {}
+  virtual ~Chunk();
+};
+
+struct Section : public Chunk {
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
   llvm::yaml::Hex64 Address;
   StringRef Link;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
 
   // Usually sections are not created implicitly, but loaded from YAML.
   // When they are, this flag is used to signal about that.
   bool IsImplicit;
 
-  Section(SectionKind Kind, bool IsImplicit = false)
-      : Kind(Kind), IsImplicit(IsImplicit) {}
-  virtual ~Section();
+  Section(ChunkKind Kind, bool IsImplicit = false)
+      : Chunk(Kind), IsImplicit(IsImplicit) {}
+
+  static bool classof(const Chunk *S) { return S->Kind != ChunkKind::Fill; }
 
   // The following members are used to override section fields which is
   // useful for creating invalid objects.
 
   // This can be used to override the offset stored in the sh_name field.
   // It does not affect the name stored in the string table.
   Optional<llvm::yaml::Hex64> ShName;
 
   // This can be used to override the sh_offset field. It does not place the
   // section data at the offset specified.
   Optional<llvm::yaml::Hex64> ShOffset;
 
   // This can be used to override the sh_size field. It does not affect the
   // content written.
   Optional<llvm::yaml::Hex64> ShSize;
 };
 
+// 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;
   Optional<std::vector<StackSizeEntry>> Entries;
 
-  StackSizesSection() : Section(SectionKind::StackSizes) {}
+  StackSizesSection() : Section(ChunkKind::StackSizes) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::StackSizes;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::StackSizes;
   }
 
   static bool nameMatches(StringRef Name) {
     return Name == ".stack_sizes";
   }
 };
 
 struct DynamicSection : Section {
   std::vector<DynamicEntry> Entries;
   Optional<yaml::BinaryRef> Content;
 
-  DynamicSection() : Section(SectionKind::Dynamic) {}
+  DynamicSection() : Section(ChunkKind::Dynamic) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Dynamic;
-  }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
 };
 
 struct RawContentSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
   Optional<llvm::yaml::Hex64> Info;
 
-  RawContentSection() : Section(SectionKind::RawContent) {}
+  RawContentSection() : Section(ChunkKind::RawContent) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::RawContent;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::RawContent;
   }
 };
 
 struct NoBitsSection : Section {
   llvm::yaml::Hex64 Size;
 
-  NoBitsSection() : Section(SectionKind::NoBits) {}
+  NoBitsSection() : Section(ChunkKind::NoBits) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::NoBits;
-  }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
 };
 
 struct NoteSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<ELFYAML::NoteEntry>> Notes;
 
-  NoteSection() : Section(SectionKind::Note) {}
-  static bool classof(const Section *S) { return S->Kind == SectionKind::Note; }
+  NoteSection() : Section(ChunkKind::Note) {}
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
 };
 
 struct HashSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<uint32_t>> Bucket;
   Optional<std::vector<uint32_t>> Chain;
 
-  HashSection() : Section(SectionKind::Hash) {}
+  HashSection() : Section(ChunkKind::Hash) {}
 
-  static bool classof(const Section *S) { return S->Kind == SectionKind::Hash; }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }
 };
 
 struct GnuHashHeader {
   // The number of hash buckets.
   // Not used when dumping the object, but can be used to override
   // the real number of buckets when emiting an object from a YAML document.
   Optional<llvm::yaml::Hex32> NBuckets;
 

 struct GnuHashSection : Section {
   Optional<yaml::BinaryRef> Content;
 
   Optional<GnuHashHeader> Header;
   Optional<std::vector<llvm::yaml::Hex64>> BloomFilter;
   Optional<std::vector<llvm::yaml::Hex32>> HashBuckets;
   Optional<std::vector<llvm::yaml::Hex32>> HashValues;
 
-  GnuHashSection() : Section(SectionKind::GnuHash) {}
+  GnuHashSection() : Section(ChunkKind::GnuHash) {}
 
-  static bool classof(const Section *S) { return S->Kind == SectionKind::GnuHash; }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; }
 };
 
 struct VernauxEntry {
   uint32_t Hash;
   uint16_t Flags;
   uint16_t Other;
   StringRef Name;
 };
 
 struct VerneedEntry {
   uint16_t Version;
   StringRef File;
   std::vector<VernauxEntry> AuxV;
 };
 
 struct VerneedSection : Section {
   std::vector<VerneedEntry> VerneedV;
   llvm::yaml::Hex64 Info;
 
-  VerneedSection() : Section(SectionKind::Verneed) {}
+  VerneedSection() : Section(ChunkKind::Verneed) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Verneed;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::Verneed;
   }
 };
 
 struct AddrsigSymbol {
   AddrsigSymbol(StringRef N) : Name(N), Index(None) {}
   AddrsigSymbol(llvm::yaml::Hex32 Ndx) : Name(None), Index(Ndx) {}
   AddrsigSymbol() : Name(None), Index(None) {}
 
   Optional<StringRef> Name;
   Optional<llvm::yaml::Hex32> Index;
 };
 
 struct AddrsigSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<AddrsigSymbol>> Symbols;
 
-  AddrsigSection() : Section(SectionKind::Addrsig) {}
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Addrsig;
-  }
+  AddrsigSection() : Section(ChunkKind::Addrsig) {}
+
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
 };
 
 struct SymverSection : Section {
   std::vector<uint16_t> Entries;
 
-  SymverSection() : Section(SectionKind::Symver) {}
+  SymverSection() : Section(ChunkKind::Symver) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Symver;
-  }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
 };
 
 struct VerdefEntry {
   uint16_t Version;
   uint16_t Flags;
   uint16_t VersionNdx;
   uint32_t Hash;
   std::vector<StringRef> VerNames;
 };
 
 struct VerdefSection : Section {
   std::vector<VerdefEntry> Entries;
   llvm::yaml::Hex64 Info;
 
-  VerdefSection() : Section(SectionKind::Verdef) {}
+  VerdefSection() : Section(ChunkKind::Verdef) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Verdef;
-  }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
 };
 
 struct Group : Section {
   // Members of a group contain a flag and a list of section indices
   // that are part of the group.
   std::vector<SectionOrType> Members;
   Optional<StringRef> Signature; /* Info */
 
-  Group() : Section(SectionKind::Group) {}
+  Group() : Section(ChunkKind::Group) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Group;
-  }
+  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
 };
 
 struct Relocation {
   llvm::yaml::Hex64 Offset;
   int64_t Addend;
   ELF_REL Type;
   Optional<StringRef> Symbol;
 };
 
 struct RelocationSection : Section {
   std::vector<Relocation> Relocations;
   StringRef RelocatableSec; /* Info */
 
-  RelocationSection() : Section(SectionKind::Relocation) {}
+  RelocationSection() : Section(ChunkKind::Relocation) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::Relocation;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::Relocation;
   }
 };
 
 struct SymtabShndxSection : Section {
   std::vector<uint32_t> Entries;
 
-  SymtabShndxSection() : Section(SectionKind::SymtabShndxSection) {}
+  SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::SymtabShndxSection;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::SymtabShndxSection;
   }
 };
 
 // Represents .MIPS.abiflags section
 struct MipsABIFlags : Section {
   llvm::yaml::Hex16 Version;
   MIPS_ISA ISALevel;
   llvm::yaml::Hex8 ISARevision;
   MIPS_AFL_REG GPRSize;
   MIPS_AFL_REG CPR1Size;
   MIPS_AFL_REG CPR2Size;
   MIPS_ABI_FP FpABI;
   MIPS_AFL_EXT ISAExtension;
   MIPS_AFL_ASE ASEs;
   MIPS_AFL_FLAGS1 Flags1;
   llvm::yaml::Hex32 Flags2;
 
-  MipsABIFlags() : Section(SectionKind::MipsABIFlags) {}
+  MipsABIFlags() : Section(ChunkKind::MipsABIFlags) {}
 
-  static bool classof(const Section *S) {
-    return S->Kind == SectionKind::MipsABIFlags;
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::MipsABIFlags;
   }
 };
 
 struct Object {
   FileHeader Header;
   std::vector<ProgramHeader> ProgramHeaders;
-  std::vector<std::unique_ptr<Section>> Sections;
+
+  // An object might contain output section descriptions as well as
+  // custom data that does not belong to any section.
+  std::vector<std::unique_ptr<Chunk>> Chunks;
+
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
   Optional<std::vector<Symbol>> Symbols;
   std::vector<Symbol> DynamicSymbols;
+
+  std::vector<Section *> getSections() {
+    std::vector<Section *> Ret;
+    for (const std::unique_ptr<Chunk> &Sec : Chunks)
+      if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
+        Ret.push_back(S);
+    return Ret;
+  }
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::AddrsigSymbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
-LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
 

 template <> struct MappingTraits<ELFYAML::AddrsigSymbol> {
   static void mapping(IO &IO, ELFYAML::AddrsigSymbol &Sym);
 };
 
 template <> struct MappingTraits<ELFYAML::Relocation> {
   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 };
 
-template <>
-struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
-  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
-  static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);
+template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
+  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
+  static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Object> {
   static void mapping(IO &IO, ELFYAML::Object &Object);
 };
 
 template <> struct MappingTraits<ELFYAML::SectionOrType> {

llvm/include/llvm/ObjectYAML/YAML.h

public:
   ArrayRef<uint8_t>::size_type binary_size() const {
     if (DataIsHexString)
       return Data.size() / 2;
     return Data.size();
   }
 
   /// Write the contents (regardless of whether it is binary or a
   /// hex string) as binary to the given raw_ostream.
-  void writeAsBinary(raw_ostream &OS) const;
+  /// N can be used to specify the maximum number of bytes.
+  void writeAsBinary(raw_ostream &OS, uint64_t N = UINT64_MAX) const;
 
   /// Write the contents (regardless of whether it is binary or a
   /// hex string) as hex to the given raw_ostream.
   ///
   /// For example, a possible output could be `DEADBEEFCAFEBABE`.
   void writeAsHex(raw_ostream &OS) const;
 };
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

 //===- yaml2elf - Convert YAML to a ELF object file -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// The ELF component of yaml2obj.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/LEB128.h"
unsigned get(StringRef Name) const {
     if (lookup(Name, Idx))
       return Idx;
     assert(false && "Expected section not found in index");
     return 0;
   }
   unsigned size() const { return Map.size(); }
 };
 
+namespace {
+struct Fragment {
+  uint64_t Offset;
+  uint64_t Size;
+  uint32_t Type;
+  uint64_t AddrAlign;
+};
+}; // namespace
+
 /// "Single point of truth" for the ELF file construction.
 /// TODO: This class still has a ways to go before it is truly a "single
 /// point of truth".
 template <class ELFT> class ELFState {
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
+
+  std::vector<Fragment>
+  getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
+                   ArrayRef<typename ELFT::Shdr> SHeaders);
+
   void finalizeStrings();
   void writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
                            ContiguousBlobAccumulator &CBA);
void writeSectionContent(Elf_Shdr &SHeader,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::NoteSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::GnuHashSection &Section,
                            ContiguousBlobAccumulator &CBA);
 
+  void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
+
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
 
 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
   return A.size() * sizeof(T);
 }
 
 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
   OS.write((const char *)A.data(), arrayDataSize(A));
 }
 
 template <class T> static void zero(T &Obj) { memset(&Obj, 0, sizeof(Obj)); }
 
 template <class ELFT>
 ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
     : Doc(D), ErrHandler(EH) {
+  std::vector<ELFYAML::Section *> Sections = Doc.getSections();
   StringSet<> DocSections;
-  for (std::unique_ptr<ELFYAML::Section> &D : Doc.Sections)
-    if (!D->Name.empty())
-      DocSections.insert(D->Name);
+  for (const ELFYAML::Section *Sec : Sections)
+    if (!Sec->Name.empty())
+      DocSections.insert(Sec->Name);
 
   // Insert SHT_NULL section implicitly when it is not defined in YAML.
-  if (Doc.Sections.empty() || Doc.Sections.front()->Type != ELF::SHT_NULL)
-    Doc.Sections.insert(
-        Doc.Sections.begin(),
+  if (Sections.empty() || Sections.front()->Type != ELF::SHT_NULL)
+    Doc.Chunks.insert(
+        Doc.Chunks.begin(),
         std::make_unique<ELFYAML::Section>(
-            ELFYAML::Section::SectionKind::RawContent, /*IsImplicit=*/true));
+            ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));
 
   std::vector<StringRef> ImplicitSections;
   if (Doc.Symbols)
     ImplicitSections.push_back(".symtab");
   ImplicitSections.insert(ImplicitSections.end(), {".strtab", ".shstrtab"});
 
   if (!Doc.DynamicSymbols.empty())
     ImplicitSections.insert(ImplicitSections.end(), {".dynsym", ".dynstr"});
 
   // Insert placeholders for implicit sections that are not
   // defined explicitly in YAML.
   for (StringRef SecName : ImplicitSections) {
     if (DocSections.count(SecName))
       continue;
 
-    std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
-        ELFYAML::Section::SectionKind::RawContent, true /*IsImplicit*/);
+    std::unique_ptr<ELFYAML::Chunk> Sec = std::make_unique<ELFYAML::Section>(
+        ELFYAML::Chunk::ChunkKind::RawContent, true /*IsImplicit*/);
     Sec->Name = SecName;
-    Doc.Sections.push_back(std::move(Sec));
+    Doc.Chunks.push_back(std::move(Sec));
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS) {
   using namespace llvm::ELF;
 
   Elf_Ehdr Header;
Header.e_shentsize =
       Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
   // Immediately following the ELF header and program headers.
   // Align the start of the section header and write the ELF header.
   uint64_t SHOff;
   CBA.getOSAndAlignedOffset(SHOff, sizeof(typename ELFT::uint));
   Header.e_shoff =
       Doc.Header.SHOff ? typename ELFT::uint(*Doc.Header.SHOff) : SHOff;
   Header.e_shnum =
-      Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.Sections.size();
+      Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.getSections().size();
   Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
                                           : SN2I.get(".shstrtab");
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
StringRef llvm::ELFYAML::dropUniqueSuffix(StringRef S) {
   return S.substr(0, SuffixPos);
 }
 
 template <class ELFT>
 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.Sections.size());
+  SHeaders.resize(Doc.getSections().size());
 
-  for (size_t I = 0; I < Doc.Sections.size(); ++I) {
-    ELFYAML::Section *Sec = Doc.Sections[I].get();
-    if (I == 0 && Sec->IsImplicit)
+  size_t SecNdx = -1;
+  for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
+    if (auto S = dyn_cast<ELFYAML::Fill>(D.get())) {
+      writeFill(*S, CBA);
+      continue;
+    }
+
+    ++SecNdx;
+    ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
+    if (SecNdx == 0 && Sec->IsImplicit)
       continue;
 
     // We have a few sections like string or symbol tables that are usually
     // added implicitly to the end. However, if they are explicitly specified
     // in the YAML, we need to write them here. This ensures the file offset
     // remains correct.
-    Elf_Shdr &SHeader = SHeaders[I];
+    Elf_Shdr &SHeader = SHeaders[SecNdx];
     if (initImplicitHeader(CBA, SHeader, Sec->Name,
                            Sec->IsImplicit ? nullptr : Sec))
       continue;
 
     assert(Sec && "It can't be null unless it is an implicit section. But all "
                   "implicit sections should already have been handled above.");
 
     SHeader.sh_name =
         DotShStrtab.getOffset(ELFYAML::dropUniqueSuffix(Sec->Name));
     SHeader.sh_type = Sec->Type;
     if (Sec->Flags)
       SHeader.sh_flags = *Sec->Flags;
     SHeader.sh_addr = Sec->Address;
     SHeader.sh_addralign = Sec->AddressAlign;
 
     if (!Sec->Link.empty())
       SHeader.sh_link = toSectionIndex(Sec->Link, Sec->Name);
 
-    if (I == 0) {
+    if (SecNdx == 0) {
       if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
         // We do not write any content for special SHN_UNDEF section.
         if (RawSec->Size)
           SHeader.sh_size = *RawSec->Size;
         if (RawSec->Info)
           SHeader.sh_info = *RawSec->Info;
       }
       if (Sec->EntSize)

 }
 
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
 
 template <class ELFT>
-void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
-                                            std::vector<Elf_Shdr> &SHeaders) {
-  uint32_t PhdrIdx = 0;
-  for (auto &YamlPhdr : Doc.ProgramHeaders) {
-    Elf_Phdr &PHeader = PHeaders[PhdrIdx++];
+std::vector<Fragment>
+ELFState<ELFT>::getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
+                                 ArrayRef<typename ELFT::Shdr> SHeaders) {
+  DenseMap<StringRef, ELFYAML::Fill *> NameToFill;
+  for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks)
+    if (auto S = dyn_cast<ELFYAML::Fill>(D.get()))
+      NameToFill[S->Name] = S;
 
-    std::vector<Elf_Shdr *> Sections;
-    for (const ELFYAML::SectionName &SecName : YamlPhdr.Sections) {
-      unsigned Index;
-      if (!SN2I.lookup(SecName.Section, Index)) {
-        reportError("unknown section referenced: '" + SecName.Section +
-                    "' by program header");
-        continue;
-      }
-      Sections.push_back(&SHeaders[Index]);
-    }
+  std::vector<Fragment> Ret;
+  for (const ELFYAML::SectionName &SecName : Phdr.Sections) {
+    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});
+
+    if (ELFYAML::Fill *Fill = NameToFill.lookup(SecName.Section)) {
+      Ret.push_back({Fill->ShOffset, Fill->Size, llvm::ELF::SHT_PROGBITS,
+                     /*ShAddrAlign=*/1});
+      continue;
+    }
+
+    reportError("unknown section or fill referenced: '" + SecName.Section +
+                "' by program header");
+  }
+
+  return Ret;
 
+template <class ELFT>
+void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
+                                            std::vector<Elf_Shdr> &SHeaders) {
+  uint32_t PhdrIdx = 0;
+  for (auto &YamlPhdr : Doc.ProgramHeaders) {
+    Elf_Phdr &PHeader = PHeaders[PhdrIdx++];
+    std::vector<Fragment> Fragments = getPhdrFragments(YamlPhdr, SHeaders);
+
     if (YamlPhdr.Offset) {
       PHeader.p_offset = *YamlPhdr.Offset;
     } else {
       if (YamlPhdr.Sections.size())
         PHeader.p_offset = UINT32_MAX;
       else
         PHeader.p_offset = 0;
 
       // Find the minimum offset for the program header.
-      for (Elf_Shdr *SHeader : Sections)
-        PHeader.p_offset = std::min(PHeader.p_offset, SHeader->sh_offset);
+      for (const Fragment &F : Fragments)
+        PHeader.p_offset = std::min((uint64_t)PHeader.p_offset, F.Offset);
     }
 
     // Find the maximum offset of the end of a section in order to set p_filesz
     // and p_memsz. When setting p_filesz, trailing SHT_NOBITS sections are not
     // counted.
     uint64_t FileOffset = PHeader.p_offset, MemOffset = PHeader.p_offset;
-    for (Elf_Shdr *SHeader : Sections) {
-      uint64_t End = SHeader->sh_offset + SHeader->sh_size;
+    for (const Fragment &F : Fragments) {
+      uint64_t End = F.Offset + F.Size;
       MemOffset = std::max(MemOffset, End);
 
-      if (SHeader->sh_type != llvm::ELF::SHT_NOBITS)
+      if (F.Type != llvm::ELF::SHT_NOBITS)
         FileOffset = std::max(FileOffset, End);
     }
 
     // Set the file size and the memory size if not set explicitly.
     PHeader.p_filesz = YamlPhdr.FileSize ? uint64_t(*YamlPhdr.FileSize)
                                          : FileOffset - PHeader.p_offset;
     PHeader.p_memsz = YamlPhdr.MemSize ? uint64_t(*YamlPhdr.MemSize)
                                        : MemOffset - PHeader.p_offset;
 
     if (YamlPhdr.Align) {
       PHeader.p_align = *YamlPhdr.Align;
     } else {
       // Set the alignment of the segment to be the maximum alignment of the
       // sections so that by default the segment has a valid and sensible
       // alignment.
       PHeader.p_align = 1;
-      for (Elf_Shdr *SHeader : Sections)
-        PHeader.p_align = std::max(PHeader.p_align, SHeader->sh_addralign);
+      for (const Fragment &F : Fragments)
+        PHeader.p_align = std::max((uint64_t)PHeader.p_align, F.AddrAlign);
     }
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
for (llvm::yaml::Hex32 Val : *Section.HashValues)
     support::endian::write<uint32_t>(OS, Val, ELFT::TargetEndianness);
 
   SHeader.sh_size = 16 /*Header size*/ +
                     Section.BloomFilter->size() * sizeof(typename ELFT::uint) +
                     Section.HashBuckets->size() * 4 +
                     Section.HashValues->size() * 4;
 }
 
+template <class ELFT>
+void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
+                               ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS = CBA.getOSAndAlignedOffset(Fill.ShOffset, /*Align=*/1);
+
+  size_t PatternSize = Fill.Pattern ? Fill.Pattern->binary_size() : 0;
+  if (!PatternSize) {
+    OS.write_zeros(Fill.Size);
+    return;
+  }
+
+  // Fill the content with the specified pattern.
+  uint64_t Written = 0;
+  for (; Written + PatternSize <= Fill.Size; Written += PatternSize)
+    Fill.Pattern->writeAsBinary(OS);
+  Fill.Pattern->writeAsBinary(OS, Fill.Size - Written);
+}
+
 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
-  for (unsigned I = 0, E = Doc.Sections.size(); I != E; ++I) {
-    StringRef Name = Doc.Sections[I]->Name;
-    if (Name.empty())
+  size_t SecNdx = -1;
+  StringSet<> Seen;
+  for (size_t I = 0; I < Doc.Chunks.size(); ++I) {
+    const std::unique_ptr<ELFYAML::Chunk> &C = Doc.Chunks[I];
+    bool IsSection = isa<ELFYAML::Section>(C.get());
+    if (IsSection)
+      ++SecNdx;
+
+    if (C->Name.empty())
       continue;
 
-    DotShStrtab.add(ELFYAML::dropUniqueSuffix(Name));
-    if (!SN2I.addName(Name, I))
-      reportError("repeated section name: '" + Name +
-                  "' at YAML section number " + Twine(I));
+    if (!Seen.insert(C->Name).second)
+      reportError("repeated section/fill name: '" + C->Name +
+                  "' at YAML section/fill number " + Twine(I));
+    if (!IsSection || HasError)
+      continue;
+
+    if (!SN2I.addName(C->Name, SecNdx))
+      llvm_unreachable("buildSectionIndex() failed");
+    DotShStrtab.add(ELFYAML::dropUniqueSuffix(C->Name));
   }
 
   DotShStrtab.finalize();
 }
 
 template <class ELFT> void ELFState<ELFT>::buildSymbolIndexes() {
   auto Build = [this](ArrayRef<ELFYAML::Symbol> V, NameToIdxMap &Map) {
     for (size_t I = 0, S = V.size(); I < S; ++I) {
       const ELFYAML::Symbol &Sym = V[I];
       if (!Sym.Name.empty() && !Map.addName(Sym.Name, I + 1))
         reportError("repeated symbol name: '" + Sym.Name + "'");
     }
template <class ELFT> void ELFState<ELFT>::finalizeStrings() {
   DotStrtab.finalize();
 
   // Add the dynamic symbol names to .dynstr section.
   for (const ELFYAML::Symbol &Sym : Doc.DynamicSymbols)
     DotDynstr.add(ELFYAML::dropUniqueSuffix(Sym.Name));
 
   // SHT_GNU_verdef and SHT_GNU_verneed sections might also
   // add strings to .dynstr section.
-  for (const std::unique_ptr<ELFYAML::Section> &Sec : Doc.Sections) {
-    if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
+  for (const ELFYAML::Chunk *Sec : Doc.getSections()) {
+    if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
       for (const ELFYAML::VerneedEntry &VE : VerNeed->VerneedV) {
         DotDynstr.add(VE.File);
         for (const ELFYAML::VernauxEntry &Aux : VE.AuxV)
           DotDynstr.add(Aux.Name);
       }
-    } else if (auto VerDef = dyn_cast<ELFYAML::VerdefSection>(Sec.get())) {
+    } else if (auto VerDef = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
       for (const ELFYAML::VerdefEntry &E : VerDef->Entries)
         for (StringRef Name : E.VerNames)
           DotDynstr.add(Name);
     }
   }
 
   DotDynstr.finalize();
 }
 
 template <class ELFT>
 bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                               yaml::ErrorHandler EH) {
   ELFState<ELFT> State(Doc, EH);
 
   // Finalize .strtab and .dynstr sections. We do that early because want to
   // finalize the string table builders before writing the content of the
   // sections that might want to use them.
   State.finalizeStrings();
 
   State.buildSectionIndex();
+  if (State.HasError)
+    return false;
+
   State.buildSymbolIndexes();
 
   std::vector<Elf_Phdr> PHeaders;
   State.initProgramHeaders(PHeaders);
 
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.
   const size_t SectionContentBeginOffset =

llvm/lib/ObjectYAML/ELFYAML.cpp

 #include "llvm/Support/MipsABIFlags.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/WithColor.h"
 #include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
-ELFYAML::Section::~Section() = default;
+ELFYAML::Chunk::~Chunk() = default;
 
 namespace yaml {
 
 void ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(
     IO &IO, ELFYAML::ELF_ET &Value) {
 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(ET_NONE);
   ECase(ET_REL);

 
 static void sectionMapping(IO &IO, ELFYAML::AddrsigSection &Section) {
   commonSectionMapping(IO, 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.mapRequired("Size", Fill.Size);
+}
+
 void MappingTraits<ELFYAML::SectionOrType>::mapping(
     IO &IO, ELFYAML::SectionOrType &sectionOrType) {
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
 void MappingTraits<ELFYAML::SectionName>::mapping(
     IO &IO, ELFYAML::SectionName &sectionName) {
   IO.mapRequired("Section", sectionName.Section);
static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
   IO.mapOptional("CPR1Size", Section.CPR1Size,
                  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
   IO.mapOptional("CPR2Size", Section.CPR2Size,
                  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
   IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
   IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
 }
 
-void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping(
-    IO &IO, std::unique_ptr<ELFYAML::Section> &Section) {
-  ELFYAML::ELF_SHT sectionType;
-  if (IO.outputting())
-    sectionType = Section->Type;
-  else
-    IO.mapRequired("Type", sectionType);
+void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(
+    IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
+  ELFYAML::ELF_SHT Type;
+  if (IO.outputting()) {
+    Type = cast<ELFYAML::Section>(Section.get())->Type;
+  } else {
+    // When the Type string does not have a "SHT_" prefix, we know it is not a
+    // description of a regular ELF output section. Currently, we have one
+    // special type named "Fill". See comments for Fill.
+    StringRef StrType;
+    IO.mapRequired("Type", StrType);
+    if (StrType == "Fill") {
+      Section.reset(new ELFYAML::Fill());
+      fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
+      return;
+    }
+
+    IO.mapRequired("Type", Type);
+  }
 
-  switch (sectionType) {
+  switch (Type) {
   case ELF::SHT_DYNAMIC:
     if (!IO.outputting())
       Section.reset(new ELFYAML::DynamicSection());
     sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
     break;
   case ELF::SHT_REL:
   case ELF::SHT_RELA:
     if (!IO.outputting())
default:
 
     if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
       sectionMapping(IO, *S);
     else
       sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
   }
 }
 
-StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
-    IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
+StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
+    IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
   if (const auto *RawSection =
-          dyn_cast<ELFYAML::RawContentSection>(Section.get())) {
+          dyn_cast<ELFYAML::RawContentSection>(C.get())) {
     if (RawSection->Size && RawSection->Content &&
         (uint64_t)(*RawSection->Size) < RawSection->Content->binary_size())
       return "Section size must be greater than or equal to the content size";
     return {};
   }
 
-  if (const auto *SS = dyn_cast<ELFYAML::StackSizesSection>(Section.get())) {
+  if (const auto *SS = dyn_cast<ELFYAML::StackSizesSection>(C.get())) {
     if (!SS->Entries && !SS->Content && !SS->Size)
       return ".stack_sizes: one of Content, Entries and Size must be specified";
 
     if (SS->Size && SS->Content &&
         (uint64_t)(*SS->Size) < SS->Content->binary_size())
       return ".stack_sizes: Size must be greater than or equal to the content "
              "size";
 
     // We accept Content, Size or both together when there are no Entries.
     if (!SS->Entries)
       return {};
 
     if (SS->Size)
       return ".stack_sizes: Size and Entries cannot be used together";
     if (SS->Content)
       return ".stack_sizes: Content and Entries cannot be used together";
     return {};
   }
 
-  if (const auto *HS = dyn_cast<ELFYAML::HashSection>(Section.get())) {
+  if (const auto *HS = dyn_cast<ELFYAML::HashSection>(C.get())) {
     if (!HS->Content && !HS->Bucket && !HS->Chain && !HS->Size)
       return "one of \"Content\", \"Size\", \"Bucket\" or \"Chain\" must be "
              "specified";
 
     if (HS->Content || HS->Size) {
       if (HS->Size && HS->Content &&
           (uint64_t)*HS->Size < HS->Content->binary_size())
         return "\"Size\" must be greater than or equal to the content "
                "size";
 
       if (HS->Bucket)
         return "\"Bucket\" cannot be used with \"Content\" or \"Size\"";
       if (HS->Chain)
         return "\"Chain\" cannot be used with \"Content\" or \"Size\"";
       return {};
     }
 
     if ((HS->Bucket && !HS->Chain) || (!HS->Bucket && HS->Chain))
       return "\"Bucket\" and \"Chain\" must be used together";
     return {};
   }
 
-  if (const auto *Sec = dyn_cast<ELFYAML::AddrsigSection>(Section.get())) {
+  if (const auto *Sec = dyn_cast<ELFYAML::AddrsigSection>(C.get())) {
     if (!Sec->Symbols && !Sec->Content && !Sec->Size)
       return "one of \"Content\", \"Size\" or \"Symbols\" must be specified";
 
     if (Sec->Content || Sec->Size) {
       if (Sec->Size && Sec->Content &&
           (uint64_t)*Sec->Size < Sec->Content->binary_size())
         return "\"Size\" must be greater than or equal to the content "
                "size";
 
       if (Sec->Symbols)
         return "\"Symbols\" cannot be used with \"Content\" or \"Size\"";
       return {};
     }
 
     if (!Sec->Symbols)
       return {};
 
     for (const ELFYAML::AddrsigSymbol &AS : *Sec->Symbols)
       if (AS.Index && AS.Name)
         return "\"Index\" and \"Name\" cannot be used together when defining a "
                "symbol";
     return {};
   }
 
-  if (const auto *NS = dyn_cast<ELFYAML::NoteSection>(Section.get())) {
+  if (const auto *NS = dyn_cast<ELFYAML::NoteSection>(C.get())) {
     if (!NS->Content && !NS->Size && !NS->Notes)
       return "one of \"Content\", \"Size\" or \"Notes\" must be "
              "specified";
 
     if (!NS->Content && !NS->Size)
       return {};
 
     if (NS->Size && NS->Content &&
         (uint64_t)*NS->Size < NS->Content->binary_size())
       return "\"Size\" must be greater than or equal to the content "
              "size";
 
     if (NS->Notes)
       return "\"Notes\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
-  if (const auto *Sec = dyn_cast<ELFYAML::GnuHashSection>(Section.get())) {
+  if (const auto *Sec = dyn_cast<ELFYAML::GnuHashSection>(C.get())) {
     if (!Sec->Content && !Sec->Header && !Sec->BloomFilter &&
         !Sec->HashBuckets && !Sec->HashValues)
       return "either \"Content\" or \"Header\", \"BloomFilter\", "
              "\"HashBuckets\" and \"HashBuckets\" must be specified";
 
     if (Sec->Header || Sec->BloomFilter || Sec->HashBuckets ||
         Sec->HashValues) {
       if (!Sec->Header || !Sec->BloomFilter || !Sec->HashBuckets ||
           !Sec->HashValues)
         return "\"Header\", \"BloomFilter\", "
                "\"HashBuckets\" and \"HashValues\" must be used together";
       if (Sec->Content)
         return "\"Header\", \"BloomFilter\", "
                "\"HashBuckets\" and \"HashValues\" can't be used together with "
                "\"Content\"";
       return {};
     }
 
     // Only Content is specified.
     return {};
   }
 
+  if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
+    if (!F->Pattern)
+      return {};
+    if (F->Pattern->binary_size() != 0 && !F->Size)
+      return "\"Size\" can't be 0 when \"Pattern\" is not empty";
+    return {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

 }
 
 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
-  IO.mapOptional("Sections", Object.Sections);
+  IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.setContext(nullptr);
 }
 
 void MappingTraits<ELFYAML::AddrsigSymbol>::mapping(IO &IO, ELFYAML::AddrsigSymbol &Sym) {
   assert(IO.getContext() && "The IO context is not initialized");
   IO.mapOptional("Name", Sym.Name);

llvm/lib/ObjectYAML/YAML.cpp

StringRef yaml::ScalarTraits<yaml::BinaryRef>::input(StringRef Scalar, void *,
   // (e.g. a caret pointing to the offending character).
   for (unsigned I = 0, N = Scalar.size(); I != N; ++I)
     if (!llvm::isHexDigit(Scalar[I]))
       return "BinaryRef hex string must contain only hex digits.";
   Val = yaml::BinaryRef(Scalar);
   return {};
 }
 
-void yaml::BinaryRef::writeAsBinary(raw_ostream &OS) const {
+void yaml::BinaryRef::writeAsBinary(raw_ostream &OS, uint64_t N) const {
   if (!DataIsHexString) {
-    OS.write((const char *)Data.data(), Data.size());
+    OS.write((const char *)Data.data(), std::min(N, Data.size()));
     return;
   }
-  for (unsigned I = 0, N = Data.size(); I != N; I += 2) {
-    uint8_t Byte = llvm::hexDigitValue(Data[I]);
+
+  for (uint64_t I = 0, E = std::min(N, Data.size() / 2); I != E; ++I) {
+    uint8_t Byte = llvm::hexDigitValue(Data[I * 2]);
     Byte <<= 4;
-    Byte |= llvm::hexDigitValue(Data[I + 1]);
+    Byte |= llvm::hexDigitValue(Data[I * 2 + 1]);
     OS.write(Byte);
   }
 }
 
 void yaml::BinaryRef::writeAsHex(raw_ostream &OS) const {
   if (binary_size() == 0)
     return;
   if (DataIsHexString) {
     OS.write((const char *)Data.data(), Data.size());
     return;
   }
   for (uint8_t Byte : Data)
     OS << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
 }

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

+## Here we check that we are able to define sections with a type of "Fill".
+## Fills are custom pieces of data that can be placed anywhere just like normal
+## output sections, but they are not real output sections and you'll never see them in
+## the section headers.
+
+## Check we can create named and unnamed fills and use "Pattern" and "Size" fields
+## to describe the data emitted.
+## Check the data emitted and how it affects regular sections offsets.
+## Check that the "Name" field is optional for fills.
+## Check that "Size" can be greater than or equal to the pattern data size.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readelf --sections --headers %t1 | FileCheck %s --check-prefix=BASIC
+
+# BASIC:        Number of section headers: 5
+# BASIC:        Section Headers:
+# BASIC-NEXT:   [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
+# BASIC-NEXT:   [ 0]           NULL     0000000000000000 000000 000000 00     0   0  0
+# BASIC-NEXT:   [ 1] .foo      PROGBITS 0000000000000000 000043 000002 00     0   0  0
+# BASIC-NEXT:   [ 2] .bar      PROGBITS 0000000000000000 000049 000001 00     0   0  0
+# BASIC-NEXT:   [ 3] .strtab   STRTAB   0000000000000000 00004b 000001 00     0   0  1
+# BASIC-NEXT:   [ 4] .shstrtab STRTAB   0000000000000000 00004c 00001d 00     0   0  1
+
+## The fill we dump starts at (offset of .foo - 3), which is (0x43 - 3) = 0x40.
+# RUN: od -t x1 -v -j 0x40 -N 11 %t1 | FileCheck %s --ignore-case --check-prefix=DATA
+# DATA: aa bb aa 11 22 cc dd cc dd ff ee
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Pattern: "AABB"
+    Size:    0x3
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Content: "1122"
+  - Type:    Fill
+    Name:    unusedName
+    Pattern: "CCDD"
+    Size:    4
+  - Name:    .bar
+    Type:    SHT_PROGBITS
+    Content: "FF"
+  - Type:    Fill
+    Pattern: "EE"
+    Size:    1
+
+## Check we can have no explicit regular sections in the YAML description, and can
+## describe the content with the use of fills only.
+## Check that "Size" can be less than the pattern data size.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readelf --sections --headers %t2 | FileCheck %s --check-prefix=NOSECTIONS
+
+## The fill we dump starts at (offset of .strtab - 3 - 2), which is (0x45 - 5) = 0x40.
+# RUN: od -t x1 -v -j 0x40 -N 6 %t2 | FileCheck %s --ignore-case --check-prefix=NOSECTIONS-DATA
+
+# NOSECTIONS:      Number of section headers: 3
+# NOSECTIONS:      Section Headers:
+# NOSECTIONS-NEXT:  [Nr] Name      Type   Address          Off    Size   ES Flg Lk Inf Al
+# NOSECTIONS-NEXT:  [ 0]           NULL   0000000000000000 000000 000000 00     0   0  0
+# NOSECTIONS-NEXT:  [ 1] .strtab   STRTAB 0000000000000000 000045 000001 00     0   0  1
+# NOSECTIONS-NEXT:  [ 2] .shstrtab STRTAB 0000000000000000 000046 000013 00     0   0  1
+
+## .strtab that follows fills starts at 0x46 and always has a null character at the begining.
+# NOSECTIONS-DATA: aa bb cc dd ee 00
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Pattern: "AABBCCFF"
+    Size:    0x3
+  - Type:    Fill
+    Pattern: "DDEEFF"
+    Size:    0x2
+
+## Check we can use named fills when describing program headers.
+## Check that fills consume the file size and therefore affect the p_filesz fields of segments.
+## Check that the fill does not affect the p_align field of the segment.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readelf --sections --program-headers %t3 | FileCheck %s --check-prefix=PHDR
+
+# PHDR: [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf  Al
+# PHDR: [ 0]           NULL     0000000000000000 000000 000000 00      0   0  0
+# PHDR: [ 1] .bar      PROGBITS 0000000000000100 0000c0 000005 00      0   0  2
+# PHDR: [ 2] .strtab   STRTAB   0000000000000000 00010a 000001 00      0   0  1
+# PHDR: [ 3] .shstrtab STRTAB   0000000000000000 00010b 000018 00      0   0  1
+
+# PHDR: Program Headers:
+# PHDR:   Type      Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# PHDR:   LOAD      0x0000b0 0x0000000000000100 0x0000000000000100 0x00005a 0x00005a     0x2
+# PHDR:   GNU_RELRO 0x0000c5 0x0000000000000105 0x0000000000000105 0x000045 0x000045     0x1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Name:    fill1
+    Pattern: ""
+    Size:    0x10
+  - Name:         .bar
+    Type:         SHT_PROGBITS
+    Size:         0x5
+    Address:      0x100
+    AddressAlign: 2
+  - Type:    Fill
+    Name:    fill2
+    Pattern: ""
+    Size:    0x45
+ProgramHeaders:
+  - Type:  PT_LOAD
+    VAddr: 0x100
+    PAddr: 0x100
+    Sections:
+      - Section: fill1
+      - Section: .bar
+      - Section: fill2
+  - Type:  PT_GNU_RELRO
+    VAddr: 0x105
+    PAddr: 0x105
+    Sections:
+      - Section: fill2
+
+## Check that the "Pattern" field is not mandatory.
+# RUN: yaml2obj --docnum=4 2>&1 -o %t4 %s
+# RUN: llvm-readelf --sections %t4 | FileCheck %s --check-prefix=NOPATTERN
+
+## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40.
+# RUN: od -t x1 -v -j 0x40 -N 5 %t4 | FileCheck %s --ignore-case --check-prefix=NOPATTERN-DATA
+
+# NOPATTERN: [Nr] Name    Type   Address          Off
+# NOPATTERN: [ 1] .strtab STRTAB 0000000000000000 000045
+
+# NOPATTERN-DATA: aa 00 00 00 bb
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Size:    0x1
+    Pattern: "AA"
+  - Type: Fill
+    Size: 0x3
+  - Type:    Fill
+    Size:    0x1
+    Pattern: "BB"
+
+## Check that the "Size" field is mandatory.
+# RUN: not yaml2obj --docnum=5 2>&1 %s | FileCheck %s --check-prefix=NOSIZE
+
+## NOSIZE: error: missing required key 'Size'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Pattern: "00"
+
+## Check that fills are not allowed to have duplicate names.
+# RUN: not yaml2obj --docnum=6 2>&1 %s | FileCheck %s --check-prefix=UNIQUE-NAME
+
+# UNIQUE-NAME: error: repeated section/fill name: 'foo' at YAML section/fill number 2
+# UNIQUE-NAME: error: repeated section/fill name: 'foo' at YAML section/fill number 3
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Name:    foo
+    Pattern: "00"
+    Size:    1
+  - Type:    Fill
+    Name:    foo
+    Pattern: "00"
+    Size:    1
+  - Name: foo
+    Type: SHT_PROGBITS
+
+## Check that "Pattern" can be empty, when "Size" is zero.
+# RUN: yaml2obj --docnum=7 2>&1 %s -o %t7
+# RUN: llvm-readelf --sections %t7 | FileCheck %s --check-prefix=NOOP
+
+# NOOP: [Nr] Name  Type     Address          Off
+# NOOP: [ 1] begin PROGBITS 0000000000000000 000040
+# NOOP: [ 2] end   PROGBITS 0000000000000000 000041
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: begin
+    Type: SHT_PROGBITS
+    Size: 1
+  - Type:    Fill
+    Pattern: ""
+    Size:    0
+  - Name: end
+    Type: SHT_PROGBITS
+    Size: 1
+
+## Check that we can have an empty "Pattern", but have non-zero "Size".
+## In this case we emit Size number of zeroes to the output.
+
+# RUN: yaml2obj --docnum=8 2>&1 -o %t8 %s
+# RUN: llvm-readelf --sections %t8 | FileCheck %s --check-prefix=EMPTY-PATTERN
+
+## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40.
+# RUN: od -t x1 -v -j 0x40 -N 5 %t8 | FileCheck %s --ignore-case --check-prefix=EMPTY-PATTERN-DATA
+
+# EMPTY-PATTERN:      Section Headers:
+# EMPTY-PATTERN-NEXT:  [Nr] Name    Type   Address          Off    Size   ES Flg Lk Inf Al
+# EMPTY-PATTERN-NEXT:  [ 0]         NULL   0000000000000000 000000 000000 00     0   0  0
+# EMPTY-PATTERN-NEXT:  [ 1] .strtab STRTAB 0000000000000000 000045 000001 00     0   0  1
+
+# EMPTY-PATTERN-DATA: aa 00 00 00 bb
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Pattern: "AA"
+    Size:    0x1
+  - Type:    Fill
+    Size:    3
+    Pattern: ""
+  - Type:    Fill
+    Pattern: "BB"
+    Size:    0x1
+
+## Check that "Size" can't be 0, when "Pattern" is not empty.
+# RUN: not yaml2obj --docnum=9 2>&1 %s | FileCheck %s --check-prefix=ZERO-SIZE-ERR
+
+# ZERO-SIZE-ERR: error: "Size" can't be 0 when "Pattern" is not empty
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Pattern: "00"
+    Size:    0
+
+## Check we report an error when a program header references
+## an unknown section or fill and have at least one Fill defined.
+
+# RUN: not yaml2obj --docnum=10 2>&1 %s | FileCheck %s --check-prefix=UNKNOWN-ERR
+# UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by program header
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Type:    Fill
+    Pattern: ""
+    Size:    0
+ProgramHeaders:
+  - Type: PT_LOAD
+    Sections:
+      - Section: fill

llvm/test/tools/yaml2obj/duplicate-section-names.test

- Name: '.foo [1]'
     Type: SHT_PROGBITS
   - Name: .foo2
     Type: SHT_PROGBITS
 
 ## Check that yaml2obj reports an error in case we have
 ## sections with equal names and suffixes.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=CASE2
-# CASE2: error: repeated section name: '.foo [1]' at YAML section number 2
-# CASE2: error: repeated section name: '.foo [1]' at YAML section number 3
+# CASE2: error: repeated section/fill name: '.foo [1]' at YAML section/fill number 2
+# CASE2: error: repeated section/fill name: '.foo [1]' at YAML section/fill number 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: '.foo [1]'
     Type: SHT_PROGBITS
   - Name: '.foo [1]'
     Type: SHT_PROGBITS
   - Name: '.foo [1]'
     Type: SHT_PROGBITS
 
 ## Check that yaml2obj reports an error in case we have
 ## symbols without suffixes in the names and their
 ## names are equal.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=CASE3
-# CASE3: error: repeated section name: '.foo' at YAML section number 2
+# CASE3: error: repeated section/fill name: '.foo' at YAML section/fill number 2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/test/tools/yaml2obj/program-header.yaml

 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_GNU_RELRO (0x6474E552)
 #CHECK:       }
 #CHECK-NEXT:]
 
 ## Check we do not allow referencing sections that do not exist.
 # RUN: not yaml2obj --docnum=2 %s -o %t 2>&1 | FileCheck %s --check-prefix=ERR
 
-# ERR: error: unknown section referenced: '.foo' by program header
-# ERR: error: unknown section referenced: '.bar' by program header
+# ERR: error: unknown section or fill referenced: '.foo' by program header
+# ERR: error: unknown section or fill referenced: '.bar' by program header
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 ProgramHeaders:
   - Type: PT_LOAD
     Sections:
       - Section: .foo
       - Section: .bar

llvm/tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
   Expected<ELFYAML::StackSizesSection *>
   dumpStackSizesSection(const Elf_Shdr *Shdr);
 
-  Expected<ELFYAML::Section *> dumpSpecialSection(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::Chunk *> dumpSpecialSection(const Elf_Shdr *Shdr);
 
 public:
   ELFDumper(const object::ELFFile<ELFT> &O);
   Expected<ELFYAML::Object *> dump();
 };
 
 }
 
if (Error E = dumpSymbols(DynSymTab, Y->DynamicSymbols))
       return std::move(E);
 
   for (const Elf_Shdr &Sec : Sections) {
     switch (Sec.sh_type) {
     case ELF::SHT_DYNAMIC: {
       Expected<ELFYAML::DynamicSection *> SecOrErr = dumpDynamicSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_STRTAB:
     case ELF::SHT_SYMTAB:
     case ELF::SHT_DYNSYM:
       // Do not dump these sections.
       break;
     case ELF::SHT_SYMTAB_SHNDX: {
       Expected<ELFYAML::SymtabShndxSection *> SecOrErr =
           dumpSymtabShndxSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_REL:
     case ELF::SHT_RELA: {
       Expected<ELFYAML::RelocationSection *> SecOrErr = dumpRelocSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GROUP: {
       Expected<ELFYAML::Group *> GroupOrErr = dumpGroup(&Sec);
       if (!GroupOrErr)
         return GroupOrErr.takeError();
-      Y->Sections.emplace_back(*GroupOrErr);
+      Y->Chunks.emplace_back(*GroupOrErr);
       break;
     }
     case ELF::SHT_MIPS_ABIFLAGS: {
       Expected<ELFYAML::MipsABIFlags *> SecOrErr = dumpMipsABIFlags(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_NOBITS: {
       Expected<ELFYAML::NoBitsSection *> SecOrErr = dumpNoBitsSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_NOTE: {
       Expected<ELFYAML::NoteSection *> SecOrErr = dumpNoteSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_HASH: {
       Expected<ELFYAML::HashSection *> SecOrErr = dumpHashSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_HASH: {
       Expected<ELFYAML::GnuHashSection *> SecOrErr = dumpGnuHashSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_verdef: {
       Expected<ELFYAML::VerdefSection *> SecOrErr = dumpVerdefSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_versym: {
       Expected<ELFYAML::SymverSection *> SecOrErr = dumpSymverSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_verneed: {
       Expected<ELFYAML::VerneedSection *> SecOrErr = dumpVerneedSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_LLVM_ADDRSIG: {
       Expected<ELFYAML::AddrsigSection *> SecOrErr = dumpAddrsigSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_NULL: {
       // We only dump the SHT_NULL section at index 0 when it
       // has at least one non-null field, because yaml2obj
       // normally creates the zero section at index 0 implicitly.
       if (&Sec == &Sections[0]) {
         const uint8_t *Begin = reinterpret_cast<const uint8_t *>(&Sec);
         const uint8_t *End = Begin + sizeof(Elf_Shdr);
         if (std::find_if(Begin, End, [](uint8_t V) { return V != 0; }) == End)
           break;
       }
       LLVM_FALLTHROUGH;
     }
     default: {
       // Recognize some special SHT_PROGBITS sections by name.
       if (Sec.sh_type == ELF::SHT_PROGBITS) {
-        Expected<ELFYAML::Section *> SpecialSecOrErr = dumpSpecialSection(&Sec);
+        Expected<ELFYAML::Chunk *> SpecialSecOrErr = dumpSpecialSection(&Sec);
         if (!SpecialSecOrErr)
           return SpecialSecOrErr.takeError();
         if (*SpecialSecOrErr) {
-          Y->Sections.emplace_back(*SpecialSecOrErr);
+          Y->Chunks.emplace_back(*SpecialSecOrErr);
           break;
         }
       }
 
       Expected<ELFYAML::RawContentSection *> SecOrErr =
           dumpContentSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
-      Y->Sections.emplace_back(*SecOrErr);
+      Y->Chunks.emplace_back(*SecOrErr);
     }
     }
   }
 
   return Y.release();
 }
 
 template <class ELFT>
if (!NameOrErr)
       return NameOrErr.takeError();
     S.Link = NameOrErr.get();
   }
 
   return Error::success();
 }
 
 template <class ELFT>
-Expected<ELFYAML::Section *>
+Expected<ELFYAML::Chunk *>
 ELFDumper<ELFT>::dumpSpecialSection(const Elf_Shdr *Shdr) {
   auto NameOrErr = getUniquedSectionName(Shdr);
   if (!NameOrErr)
     return NameOrErr.takeError();
 
   if (ELFYAML::StackSizesSection::nameMatches(*NameOrErr))
     return dumpStackSizesSection(Shdr);
   return nullptr;