[yaml2obj/obj2yaml] - Add support of 'Size' and 'Content' keys for all sections.

[grimar]

Summary

Many sections either do not have a support of Size/Content or support just a
one of them, e.g only Content.

Section is the base class for sections. This patch adds Content and Size members
to it and removes similar members from derived classes. This allows to cleanup and
generalize the code and adds a support of these keys for all sections (SHT_MIPS_ABIFLAGS
is a only exception, it requires an unrelated specific changes to be done additionally).

I had to update/add many tests to test the new functionality properly.

[jhenderson]

Given this change, there's a lot of duplicated code across the various section varieties. There are two common patterns I see:

1. Writing using the Content/Size and setting the sh_size field accordingly.
2. Validating that the Content/Size usage doesn't conflict with special entry lists (e.g. explicit relocations/notes etc).

I think we can do better on both counts. For the first, I'd have a generic write method that checks to see if the base Section has a Size/Content field set, and if so, use that, return true if it did, false if not, so that the section-specific code knows whether to continue doing its thing.

For the second point, maybe we could have a templated method that takes the Entries as a templated parameter, as well as the other fields, and does the validation that way. It probably would need to take a string that indicates the name of the field.

On both points, if we can find a way for it to automatically happen without needing to explicitly call the new functions in multiple places, that would be even better, but I don't think that's all that important.

What do you think?

[grimar]

In D89039#2320874, @jhenderson wrote:

Given this change, there's a lot of duplicated code across the various section varieties. There are two common patterns I see:

Yeah, I've sure noticed both of them too. Wanted to do something in a follow-up(s) with it.

1. Writing using the Content/Size and setting the sh_size field accordingly.
2. Validating that the Content/Size usage doesn't conflict with special entry lists (e.g. explicit relocations/notes etc).

I think we can do better on both counts. For the first, I'd have a generic write method that checks to see if the base Section has a Size/Content field set, and if so, use that, return true if it did, false if not, so that the section-specific code knows whether to continue doing its thing.

There is a problem here. Our section writing code has the following structure often:

1. Set fields.
2. Handle Content/Size if any.
3. Handle Entries or other things if any.

E.g:

SHeader.sh_info = Section.Info;

if (Section.Content || Section.Size) {
  SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
  return;
}

if (!Section.VerneedV)
  return;

uint64_t AuxCnt = 0;
for (size_t I = 0; I < Section.VerneedV->size(); ++I) {

We can replace the (2) with something, e.g:

  SHeader.sh_info = Section.Info;

  if (handleSizeAndContent(Section, SHeader)
    return;
...

But it still will be a piece of code in the middle of each writeSectionContent method I think. I'd do it separatelly if you think it worth doing (it hides just a bit of logic).

For the second point, maybe we could have a templated method that takes the Entries as a templated parameter, as well as the other fields, and does the validation that way. It probably would need to take a string that indicates the name of the field.

Yes, I thought about something like this too. Except that I think it is possible to have a non-template lambda probably. Again, It looks like an independent follow-up cleanup?

[jhenderson]

I'm not sure either are independent clean-ups, personally. It seems like doing it right the first time is the way forward here, because it avoids having to duplicate a load of code in new places - it provides an easy way to extend the functionality for the cases that didn't have it before. If you really want to split it up, I'd do it first, and make use of it in the cases that don't have the functionality at all, and then migrate the other places over to using the new functions.

[grimar]

In D89039#2320986, @jhenderson wrote:

I'm not sure either are independent clean-ups, personally. It seems like doing it right the first time is the way forward here, because it avoids having to duplicate a load of code in new places - it provides an easy way to extend the functionality for the cases that didn't have it before.

To perform a good cleanup I'll probably need to change the existent messages reported for sections that are not touched by this patch.
E.g, I'd like to rework the following to:

1. Be consistent with "Section size must be greater than or equal to the content size" message reported for other sections.
2. Allow case when neither Entries, Content, not Size is specified.

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";

  // 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 {};
}

Such cleanup is indeed unrelated to the change perfomed by this patch.

You can say that we can leave the StackSizesSection alone and do it for other sections, but
the more important problem probably is that validate() returns StringRef currently:
StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(

I guess the right way would be to use StringSaver (or, perhaps, to use std::string), but this is out of scope of this patch again.
This is not a trivial cleanup, so I think it should be done after (if should be).

If you really want to split it up, I'd do it first, and make use of it in the cases that don't have the functionality at all, and then migrate the other places over to using the new functions.

Before this patch many sections did not support Content and Size together. There is almost nothing to cleanup there.

[grimar]

In D89039#2320874, @jhenderson wrote:

Given this change, there's a lot of duplicated code across the various section varieties. There are two common patterns I see:

1. Writing using the Content/Size and setting the sh_size field accordingly.

Now I am experimienting with this point. At this moment I am pretty sure that the patch I am working on
should be a follow-up for this one, because the approach I am experimenting with assumes that all of sections supports both "Content" and "Size",
what just was not true before this patch.

Let me finish and post a patch, I hope it might convince you that this clean-up is also better to be done on top.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1308

Maybe am early return instead to be more consistent with other sections?

1634

Perhaps that? I feel like this line and the earlier sh_entsize should match.

llvm/lib/ObjectYAML/ELFYAML.cpp

1426–1430

I'm struggling to follow why this bit has been added. Could you clarify please?

1444–1445

These sort of checks can probably be deleted in a separate patch. I think defaulting to an empty section when nothing is specified makes sense.

1519–1521

I've been thinking, and I think there might be a way to avoid duplicating this sort of logic for each section with a specific set of entries or similar fields.

1. Add a class that acts as a parent class for all Entry kinds (e.g. Options in this case). It would have a Name field (or virtual function to retrieve it).
2. Entry subclasses would set the Name/implement getName to say e.g. "Options", and would define the relevant data structure (presumably a vector) to contain the actual entries.
3. In the Section class, have a getEntries method, which is implemented in the Section subclasses, with a default return of an empty vector<vector<Entry>*>. Having a vector of vector pointers would allow for more than one Entry kind per subclass (e.g. for hash tables).
4. In the Section subclasses that have Entries (or equivalents), define getEntries to point to their own vector(s) of Entries.
5. Call getEntries around about here, and report if any of the vectors returned are non-empty when Content or Size is specified.

This pattern might even be expandable to do the writing etc of the entries in a generic way, but that's probably not necessary. What do you think?

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

71

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1634

Honestly I'd slightly prefer to keep uintX_t, because we write 2 uintX_t when do CBA.write right above.

llvm/lib/ObjectYAML/ELFYAML.cpp

1426–1430

It was not added, but moved. Fill is special, because it is not a Section, but a Chunk.
This is the only non-Section type that can be in the Sections list in a YAML, so I am handling it first
to be able to do const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get()); below.

1444–1445

Right. That was my plan.

Also, I think, there is no need to handle Size and Content separatelly and mention the .stack_sizes in messages (we report an exact error place anyways currently).

1519–1521

Honestly, I am not sure. This probably needs an experiment to say how it will look like.
The problems/concerns I see:

1. validate returns StringRef currently. To build a error message we will probably need to switch to std::string.

Alternatively, perhaps it is might be OK to have a static StringSaver local variable.

2. It adds some complexity, but the benefit is not that large. I probably would prefer a bit simpler approach (without adding a base class for all Entry kinds etc). E.g. we could probably add

a virtual std::vector<StringRef> getEntriesNames() = 0 to Sections class. This method could return an empty
vector when there are no entries and names of existent ones otherwise.

Then we should be able to do something like this:

std::vector<StringRef> Entries = Sec.getEntriesNames();
if ((Sec.Content || Sec.Size) && !Entries .empty())
      return buildContentSizeVsEntriesErrorMessage(Entries);

Such approach needs only a one (and usually trivial) method per section type and probably nothing else. Given that this change
is probably only usefull to simplify/reduce the code in validate(), I think it is might be enough.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1634

Could you change the line setting sh_entsize then to match? (i.e. sh_entsize = 2 * sizeof(uintX_t))

llvm/lib/ObjectYAML/ELFYAML.cpp

1519–1521

Yes, it sounds like it might be. Worth an experiment to see if your suggestion looks good (I think it sounds okay to me). You could probably have getEntriesNames() return an empty vector by default, if there are any cases that don't have any entries ever. Not sure if there are though...!

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

211

Same applies in many places.

268

Same applies in many places.

llvm/test/tools/yaml2obj/ELF/comdat.yaml

1–2 ↗

(On Diff #297543)

Same elsewhere.

Also, maybe this should be called group.yaml, since COMDATs are just one style of groups.

70 ↗

(On Diff #297543)

Same elsewhere

llvm/test/tools/yaml2obj/ELF/nobits.yaml

11

I don't think you need to check the .strtab line. It has no relevance to the test.

29

Would be nice to have the section name in this message, if available.

llvm/test/tools/yaml2obj/ELF/sht-symtab-shndx.yaml

147

Probably worth a comment saying why we need to have content in the symbol table. Also, can we just have a Symbols: tag?

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1634

Done.

llvm/lib/ObjectYAML/ELFYAML.cpp

1519–1521

I'll try to implement this, but at first I believe the following cleanup should be done (I've briefly mentioned it earlier):
there are few sections, e.g. StackSizesSection, HashSection, AddrsigSection, NoteSection, GnuHashSection,
that don't support being just empty:

if (!NS->Content && !NS->Size && !NS->Notes)
  return "one of \"Content\", \"Size\" or \"Notes\" must be "
         "specified";

To generalize error reporting properly, we should allow them to be first.

llvm/test/tools/yaml2obj/ELF/nobits.yaml

29

Not possible to create craft a message on the fly atm, because validate returns StringRef:

StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate

Though we report an exact place and reveal the section name currently already:

# command output:
YAML:17:5: error: SHT_NOBITS section cannot have "Content"
  - Name:    .nobits
    ^
yaml2obj: error: failed to parse YAML input: invalid argument

llvm/test/tools/yaml2obj/ELF/sht-symtab-shndx.yaml

147

Also, can we just have a Symbols: tag?

I don't think so. The following will not work:

Symbols:
  [[SYM1=- Name: foo]]
  [[SYM2=- Name: bar]]

because for the last case we need to create an empty (size == 0, or at least size < size of a one symbol) .symtab
It is needed to pass llvm-readelf validation:

uint64_t Syms = SymTable.sh_size / sizeof(Elf_Sym);
if (V.size() != Syms)
  return createError("SHT_SYMTAB_SHNDX has " + Twine(V.size()) +
                     " entries, but the symbol table associated has " +
                     Twine(Syms));

[jhenderson]

Looks good, once remaining typos/grammar errors fixed.

llvm/lib/ObjectYAML/ELFYAML.cpp

1519–1521

Yes, of course.

llvm/test/tools/yaml2obj/ELF/nobits.yaml

30

Actually, here it should be "neither ... nor ..." - for two cases that sounds fine to me. I wouldn't use neither/nor for the case where there are 3 or more possibilities.

llvm/test/tools/yaml2obj/ELF/sht-symtab-shndx.yaml

148

llvm/test/tools/yaml2obj/ELF/versym-section.yaml

154

llvm/include/llvm/ObjectYAML/ELFYAML.h

 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<yaml::BinaryRef> Content;
+  Optional<llvm::yaml::Hex64> Size;
+
   // 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;
 
   Section(ChunkKind Kind, bool IsImplicit = false)
struct Fill : Chunk {
   llvm::yaml::Hex64 Size;
 
   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(ChunkKind::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;
+  Optional<std::vector<DynamicEntry>> Entries;
 
   DynamicSection() : Section(ChunkKind::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(ChunkKind::RawContent) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::RawContent;
   }
 
   // Is used when a content is read as an array of bytes.
   Optional<std::vector<uint8_t>> ContentBuf;
 };
 
 struct NoBitsSection : Section {
-  llvm::yaml::Hex64 Size;
-
   NoBitsSection() : Section(ChunkKind::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(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;
 
   // The following members are used to override section fields.
   // This is useful for creating invalid objects.
   Optional<llvm::yaml::Hex64> NBucket;
   Optional<llvm::yaml::Hex64> NChain;
 
struct GnuHashHeader {
   // document.
   Optional<llvm::yaml::Hex32> MaskWords;
 
   // A shift constant used by the Bloom filter.
   llvm::yaml::Hex32 Shift2;
 };
 
 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(ChunkKind::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 {
-  Optional<yaml::BinaryRef> Content;
   Optional<std::vector<VerneedEntry>> VerneedV;
   llvm::yaml::Hex64 Info;
 
   VerneedSection() : Section(ChunkKind::Verneed) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Verneed;
   }
 };
 
 struct AddrsigSection : Section {
-  Optional<yaml::BinaryRef> Content;
-  Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<YAMLFlowString>> Symbols;
 
   AddrsigSection() : Section(ChunkKind::Addrsig) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
 };
 
 struct LinkerOption {
   StringRef Key;
   StringRef Value;
 };
 
 struct LinkerOptionsSection : Section {
   Optional<std::vector<LinkerOption>> Options;
-  Optional<yaml::BinaryRef> Content;
 
   LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::LinkerOptions;
   }
 };
 
 struct DependentLibrariesSection : Section {
   Optional<std::vector<YAMLFlowString>> Libs;
-  Optional<yaml::BinaryRef> Content;
 
   DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::DependentLibraries;
   }
 };
 
 // Represents the call graph profile section entry.
 struct CallGraphEntry {
   // The symbol of the source of the edge.
   StringRef From;
   // The symbol index of the destination of the edge.
   StringRef To;
   // The weight of the edge.
   uint64_t Weight;
 };
 
 struct CallGraphProfileSection : Section {
   Optional<std::vector<CallGraphEntry>> Entries;
-  Optional<yaml::BinaryRef> Content;
 
   CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::CallGraphProfile;
   }
 };
 
 struct SymverSection : Section {
-  std::vector<uint16_t> Entries;
+  Optional<std::vector<uint16_t>> Entries;
 
   SymverSection() : Section(ChunkKind::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 {
   Optional<std::vector<VerdefEntry>> Entries;
-  Optional<yaml::BinaryRef> Content;
 
   llvm::yaml::Hex64 Info;
 
   VerdefSection() : Section(ChunkKind::Verdef) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
 };
 
 struct GroupSection : 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<std::vector<SectionOrType>> Members;
   Optional<StringRef> Signature; /* Info */
 
   GroupSection() : Section(ChunkKind::Group) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
 };
 
 struct Relocation {
   llvm::yaml::Hex64 Offset;
   YAMLIntUInt Addend;
   ELF_REL Type;
   Optional<StringRef> Symbol;
 };
 
 struct RelocationSection : Section {
-  std::vector<Relocation> Relocations;
+  Optional<std::vector<Relocation>> Relocations;
   StringRef RelocatableSec; /* Info */
 
   RelocationSection() : Section(ChunkKind::Relocation) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Relocation;
   }
 };
 
 struct RelrSection : Section {
   Optional<std::vector<llvm::yaml::Hex64>> Entries;
-  Optional<yaml::BinaryRef> Content;
 
   RelrSection() : Section(ChunkKind::Relr) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Relr;
   }
 };
 
 struct SymtabShndxSection : Section {
-  std::vector<uint32_t> Entries;
+  Optional<std::vector<uint32_t>> Entries;
 
   SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::SymtabShndxSection;
   }
 };
 
 struct ARMIndexTableEntry {
   llvm::yaml::Hex32 Offset;
   llvm::yaml::Hex32 Value;
 };
 
 struct ARMIndexTableSection : Section {
   Optional<std::vector<ARMIndexTableEntry>> Entries;
-  Optional<yaml::BinaryRef> Content;
-  Optional<llvm::yaml::Hex64> Size;
 
   ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::ARMIndexTable;
   }
 };
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::NoBitsSection &S,
                                          ContiguousBlobAccumulator &CBA) {
   // SHT_NOBITS sections do not have any content to write.
   SHeader.sh_entsize = 0;
-  SHeader.sh_size = S.Size;
+
+  if (!S.Size)
+    return;
+
+  SHeader.sh_size = *S.Size;
 
   // When a nobits section is followed by a non-nobits section or fill
   // in the same segment, we allocate the file space for it. This behavior
   // matches linkers.
   if (shouldAllocateFileSpace(Doc.ProgramHeaders, S))
-    CBA.writeZeros(S.Size);
+    CBA.writeZeros(*S.Size);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
   SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
 
assert((Section.Type == llvm::ELF::SHT_REL ||
           Section.Type == llvm::ELF::SHT_RELA) &&
          "Section type is not SHT_REL nor SHT_RELA");
 
   bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
-  SHeader.sh_size = (IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel)) *
-                    Section.Relocations.size();
 
   // For relocation section set link to .symtab by default.
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.RelocatableSec.empty())
     SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
 
-  for (const auto &Rel : Section.Relocations) {
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+    return;
+  }
+
+  if (!Section.Relocations)
+    return;
+
+  for (const ELFYAML::Relocation &Rel : *Section.Relocations) {
     unsigned SymIdx = Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name,
                                                  Section.Link == ".dynsym")
                                  : 0;
     if (IsRela) {
       Elf_Rela REntry;
       zero(REntry);
       REntry.r_offset = Rel.Offset;
       REntry.r_addend = Rel.Addend;
       REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
       CBA.write((const char *)&REntry, sizeof(REntry));
     } else {
       Elf_Rel REntry;
       zero(REntry);
       REntry.r_offset = Rel.Offset;
       REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
       CBA.write((const char *)&REntry, sizeof(REntry));
     }
   }
+
+  SHeader.sh_size = (IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel)) *
+                    Section.Relocations->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::RelrSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   SHeader.sh_entsize =
       Section.EntSize ? uint64_t(*Section.EntSize) : sizeof(Elf_Relr);
 
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   if (!Section.Entries)
     return;
 
   for (llvm::yaml::Hex64 E : *Section.Entries) {
     if (!ELFT::Is64Bits && E > UINT32_MAX)
       reportError(Section.Name + ": the value is too large for 32-bits: 0x" +
                   Twine::utohexstr(E));
     CBA.write<uintX_t>(E, ELFT::TargetEndianness);
   }
 
   SHeader.sh_size = sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::SymtabShndxSection &Shndx,
     ContiguousBlobAccumulator &CBA) {
-  for (uint32_t E : Shndx.Entries)
-    CBA.write<uint32_t>(E, ELFT::TargetEndianness);
-
   SHeader.sh_entsize = Shndx.EntSize ? (uint64_t)*Shndx.EntSize : 4;
-  SHeader.sh_size = Shndx.Entries.size() * SHeader.sh_entsize;
+
+  if (Shndx.Content || Shndx.Size) {
+    SHeader.sh_size = writeContent(CBA, Shndx.Content, Shndx.Size);
+    return;
+  }
+
+  if (!Shndx.Entries)
+    return;
+
+  for (uint32_t E : *Shndx.Entries)
+    CBA.write<uint32_t>(E, ELFT::TargetEndianness);
+  SHeader.sh_size = Shndx.Entries->size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GroupSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_GROUP &&
          "Section type is not SHT_GROUP");
 
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   SHeader.sh_entsize = 4;
-  SHeader.sh_size = SHeader.sh_entsize * Section.Members.size();
 
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
 
-  for (const ELFYAML::SectionOrType &Member : Section.Members) {
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+    return;
+  }
+
+  if (!Section.Members)
+    return;
+
+  for (const ELFYAML::SectionOrType &Member : *Section.Members) {
     unsigned int SectionIndex = 0;
     if (Member.sectionNameOrType == "GRP_COMDAT")
       SectionIndex = llvm::ELF::GRP_COMDAT;
     else
       SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
     CBA.write<uint32_t>(SectionIndex, ELFT::TargetEndianness);
   }
+  SHeader.sh_size = SHeader.sh_entsize * Section.Members->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::SymverSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  for (uint16_t Version : Section.Entries)
-    CBA.write<uint16_t>(Version, ELFT::TargetEndianness);
-
   SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
-  SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
+
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+    return;
+  }
+
+  if (!Section.Entries)
+    return;
+
+  for (uint16_t Version : *Section.Entries)
+    CBA.write<uint16_t>(Version, ELFT::TargetEndianness);
+  SHeader.sh_size = Section.Entries->size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::StackSizesSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
     CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(E.Size);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   if (!Section.Options)
     return;
 
   for (const ELFYAML::LinkerOption &LO : *Section.Options) {
     CBA.write(LO.Key.data(), LO.Key.size());
     CBA.write('\0');
     CBA.write(LO.Value.data(), LO.Value.size());
     CBA.write('\0');
     SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::DependentLibrariesSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   if (!Section.Libs)
     return;
 
   for (StringRef Lib : *Section.Libs) {
     CBA.write(Lib.data(), Lib.size());
void ELFState<ELFT>::writeSectionContent(
   else
     SHeader.sh_entsize = 16;
 
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::CallGraphEntry &E : *Section.Entries) {
     unsigned From = toSymbolIndex(E.From, Section.Name, /*IsDynamic=*/false);

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerdefSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
 
   SHeader.sh_info = Section.Info;
 
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   if (!Section.Entries)
     return;
 
   uint64_t AuxCnt = 0;
   for (size_t I = 0; I < Section.Entries->size(); ++I) {

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerneedSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verneed Elf_Verneed;
   typedef typename ELFT::Vernaux Elf_Vernaux;
 
   SHeader.sh_info = Section.Info;
 
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   if (!Section.VerneedV)
     return;
 
   uint64_t AuxCnt = 0;
   for (size_t I = 0; I < Section.VerneedV->size(); ++I) {

 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::DynamicSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
          "Section type is not SHT_DYNAMIC");
 
-  if (!Section.Entries.empty() && Section.Content)
-    reportError("cannot specify both raw content and explicit entries "
-                "for dynamic section '" +
-                Section.Name + "'");
-
-  if (Section.Content)
-    SHeader.sh_size = Section.Content->binary_size();
-  else
-    SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries.size();
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
-    SHeader.sh_entsize = sizeof(Elf_Dyn);
+    SHeader.sh_entsize = 2 * sizeof(uintX_t);
+
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+    return;
+  }
+
+  if (!Section.Entries)
+    return;
 
-  for (const ELFYAML::DynamicEntry &DE : Section.Entries) {
+  for (const ELFYAML::DynamicEntry &DE : *Section.Entries) {
     CBA.write<uintX_t>(DE.Tag, ELFT::TargetEndianness);
     CBA.write<uintX_t>(DE.Val, ELFT::TargetEndianness);
   }
-  if (Section.Content)
-    CBA.writeAsBinary(*Section.Content);
+  SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::AddrsigSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GnuHashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
       SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
-  if (Section.Content) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
     return;
   }
 
   // We write the header first, starting with the hash buckets count. Normally
   // it is the number of entries in HashBuckets, but the "NBuckets" property can
   // be used to override this field, which is useful for producing broken
   // objects.
   if (Section.Header->NBuckets)

llvm/lib/ObjectYAML/ELFYAML.cpp

static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Flags", Section.Flags);
   IO.mapOptional("Address", Section.Address);
   IO.mapOptional("Link", Section.Link, StringRef());
   IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
   IO.mapOptional("EntSize", Section.EntSize);
   IO.mapOptional("Offset", Section.Offset);
 
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Size", Section.Size);
+
   // obj2yaml does not dump these fields. They are expected to be empty when we
   // are producing YAML, because yaml2obj sets appropriate values for them
   // automatically when they are not explicitly defined.
   assert(!IO.outputting() ||
          (!Section.ShOffset.hasValue() && !Section.ShSize.hasValue() &&
           !Section.ShName.hasValue() && !Section.ShFlags.hasValue() &&
           !Section.ShType.hasValue()));
   IO.mapOptional("ShName", Section.ShName);
   IO.mapOptional("ShOffset", Section.ShOffset);
   IO.mapOptional("ShSize", Section.ShSize);
   IO.mapOptional("ShFlags", Section.ShFlags);
   IO.mapOptional("ShType", Section.ShType);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Entries", Section.Entries);
-  IO.mapOptional("Content", Section.Content);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Content", Section.Content);
 
   // We also support reading a content as array of bytes using the ContentArray
   // key. obj2yaml never prints this field.
   assert(!IO.outputting() || !Section.ContentBuf.hasValue());
   IO.mapOptional("ContentArray", Section.ContentBuf);
   if (Section.ContentBuf) {
     if (Section.Content)
       IO.setError("Content and ContentArray can't be used together");
     Section.Content = yaml::BinaryRef(*Section.ContentBuf);
   }
 
-  IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Info", Section.Info);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Content", Section.Content);
-  IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Entries", Section.Entries);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Bucket", Section.Bucket);
   IO.mapOptional("Chain", Section.Chain);
-  IO.mapOptional("Size", Section.Size);
 
   // obj2yaml does not dump these fields. They can be used to override nchain
   // and nbucket values for creating broken sections.
   assert(!IO.outputting() ||
          (!Section.NBucket.hasValue() && !Section.NChain.hasValue()));
   IO.mapOptional("NChain", Section.NChain);
   IO.mapOptional("NBucket", Section.NBucket);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::NoteSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Content", Section.Content);
-  IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Notes", Section.Notes);
 }
 
 
 static void sectionMapping(IO &IO, ELFYAML::GnuHashSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Header", Section.Header);
   IO.mapOptional("BloomFilter", Section.BloomFilter);
   IO.mapOptional("HashBuckets", Section.HashBuckets);
   IO.mapOptional("HashValues", Section.HashValues);
 }
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Info", Section.Info);
   IO.mapOptional("Entries", Section.Entries);
-  IO.mapOptional("Content", Section.Content);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::SymverSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapRequired("Entries", Section.Entries);
+  IO.mapOptional("Entries", Section.Entries);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Info", Section.Info);
   IO.mapOptional("Dependencies", Section.VerneedV);
-  IO.mapOptional("Content", Section.Content);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Info", Section.RelocatableSec, StringRef());
   IO.mapOptional("Relocations", Section.Relocations);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::RelrSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Entries", Section.Entries);
-  IO.mapOptional("Content", Section.Content);
 }
 
 static void groupSectionMapping(IO &IO, ELFYAML::GroupSection &Group) {
   commonSectionMapping(IO, Group);
   IO.mapOptional("Info", Group.Signature);
-  IO.mapRequired("Members", Group.Members);
+  IO.mapOptional("Members", Group.Members);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::SymtabShndxSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapRequired("Entries", Section.Entries);
+  IO.mapOptional("Entries", Section.Entries);
 }
 
 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.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);
 }
 
 static void sectionMapping(IO &IO,
                            ELFYAML::DependentLibrariesSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Libraries", Section.Libs);
-  IO.mapOptional("Content", Section.Content);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::CallGraphProfileSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Entries", Section.Entries);
-  IO.mapOptional("Content", Section.Content);
 }
 
 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::ARMIndexTableSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Content", Section.Content);
-  IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Entries", Section.Entries);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Version", Section.Version, Hex16(0));
   IO.mapRequired("ISA", Section.ISALevel);
   IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
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::Chunk>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
-  if (const auto *RawSection = 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";
+  if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
+    if (F->Pattern && F->Pattern->binary_size() != 0 && !F->Size)
+      return "\"Size\" can't be 0 when \"Pattern\" is not empty";
+    return {};
+  }
+
+  const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
+  if (Sec.Size && Sec.Content &&
+      (uint64_t)(*Sec.Size) < Sec.Content->binary_size())
+
+  if (const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(C.get())) {
     if (RawSection->Flags && RawSection->ShFlags)
       return "ShFlags and Flags cannot be used together";
     return {};
   }
 
   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>(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>(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->Content || Sec->Size) && Sec->Symbols)
 
-    if (!Sec->Symbols)
-      return {};
-    return {};
-  }
-
   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)
+    if ((NS->Content || NS->Size) && NS->Notes)
       return "\"Notes\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
   if (const auto *Sec = dyn_cast<ELFYAML::GnuHashSection>(C.get())) {
-    if (!Sec->Content && !Sec->Header && !Sec->BloomFilter &&
+    if (!Sec->Content && !Sec->Size && !Sec->Header && !Sec->BloomFilter &&
         !Sec->HashBuckets && !Sec->HashValues)
-      return "either \"Content\" or \"Header\", \"BloomFilter\", "
+      return "either \"Content\", \"Size\" 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)
+      if (Sec->Content || Sec->Size)
         return "\"Header\", \"BloomFilter\", "
                "\"HashBuckets\" and \"HashValues\" can't be used together with "
-               "\"Content\"";
+               "\"Content\" or \"Size\"";
       return {};
     }
 
     // Only Content is specified.
     return {};
   }
 
   if (const auto *Sec = dyn_cast<ELFYAML::LinkerOptionsSection>(C.get())) {
-    if (Sec->Options && Sec->Content)
-      return "\"Options\" and \"Content\" can't be used together";
+    if ((Sec->Content || Sec->Size) && Sec->Options)
+      return "\"Options\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
   if (const auto *Sec = dyn_cast<ELFYAML::DependentLibrariesSection>(C.get())) {
-    if (Sec->Libs && Sec->Content)
-      return "SHT_LLVM_DEPENDENT_LIBRARIES: \"Libraries\" and \"Content\" "
-             "can't "
-             "be used together";
+    if ((Sec->Content || Sec->Size) && Sec->Libs)
+      return "\"Libraries\" cannot be used with \"Content\" or \"Size\"";
     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";
+  if (const auto *VD = dyn_cast<ELFYAML::VerdefSection>(C.get())) {
+    if ((VD->Content || VD->Size) && VD->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
-  if (const auto *VD = dyn_cast<ELFYAML::VerdefSection>(C.get())) {
-    if (VD->Entries && VD->Content)
-      return "SHT_GNU_verdef: \"Entries\" and \"Content\" can't be used "
-             "together";
+  if (const auto *VN = dyn_cast<ELFYAML::VerneedSection>(C.get())) {
+    if ((VN->Content || VN->Size) && VN->VerneedV)
+      return "\"Dependencies\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
-  if (const auto *VD = dyn_cast<ELFYAML::VerneedSection>(C.get())) {
-    if (VD->VerneedV && VD->Content)
-      return "SHT_GNU_verneed: \"Dependencies\" and \"Content\" can't be used "
-             "together";
+  if (const auto *SV = dyn_cast<ELFYAML::SymverSection>(C.get())) {
+    if ((SV->Content || SV->Size) && SV->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
   if (const auto *RS = dyn_cast<ELFYAML::RelrSection>(C.get())) {
-    if (RS->Entries && RS->Content)
-      return "\"Entries\" and \"Content\" can't be used together";
+    if ((RS->Content || RS->Size) && RS->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
   if (const auto *CGP = dyn_cast<ELFYAML::CallGraphProfileSection>(C.get())) {
-    if (CGP->Entries && CGP->Content)
-      return "\"Entries\" and \"Content\" can't be used together";
+    if ((CGP->Content || CGP->Size) && CGP->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
   if (const auto *IT = dyn_cast<ELFYAML::ARMIndexTableSection>(C.get())) {
-    if (IT->Content || IT->Size) {
-      if (IT->Size && IT->Content &&
-          (uint64_t)*IT->Size < IT->Content->binary_size())
-        return "\"Size\" must be greater than or equal to the content "
-               "size";
+    if ((IT->Content || IT->Size) && IT->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
+    return {};
+  }
+
+  if (const auto *RS = dyn_cast<ELFYAML::RelocationSection>(C.get())) {
+    if ((RS->Content || RS->Size) && RS->Relocations)
+      return "\"Relocations\" cannot be used with \"Content\" or \"Size\"";
+    return {};
+  }
+
+  if (const auto *SS = dyn_cast<ELFYAML::SymtabShndxSection>(C.get())) {
+    if ((SS->Content || SS->Size) && SS->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
+    return {};
+  }
+
+  if (const auto *GS = dyn_cast<ELFYAML::GroupSection>(C.get())) {
+    if ((GS->Content || GS->Size) && GS->Members)
+      return "\"Members\" cannot be used with \"Content\" or \"Size\"";
+    return {};
+  }
+
+  if (const auto *NB = dyn_cast<ELFYAML::NoBitsSection>(C.get())) {
+    if (NB->Content)
+      return "SHT_NOBITS section cannot have \"Content\"";
+    return {};
+  }
 
-      if (IT->Entries)
-        return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
-      return {};
-    }
+  if (const auto *DS = dyn_cast<ELFYAML::DynamicSection>(C.get())) {
+    if ((DS->Content || DS->Size) && DS->Entries)
 
+  if (const auto *MF = dyn_cast<ELFYAML::MipsABIFlags>(C.get())) {
+    if (MF->Content)
+      return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "
+             "sections";
+    if (MF->Size)
+      return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";
     return {};
   }
 
   return {};
 }
 
 namespace {
 

llvm/test/tools/yaml2obj/ELF/arm-exidx-section.yaml

Sections:
   - Name:         .ARM.exidx
     Type:         SHT_ARM_EXIDX
     Flags:        [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
     Address:      0x1122
     Link:         0x3344
     AddressAlign: 0x55
     EntSize:      0x66
 
-## Check we can't use "Entries" key together with "Content" or "Size" keys.
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
 
 # RUN: not yaml2obj --docnum=3 -DSIZE=0 -DENT="[]" %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
 # RUN: not yaml2obj --docnum=3 -DCONTENT="'00'" -DENT="[]" %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
 
 # ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_ARM
 Sections:
   - Name:    .ARM.exidx
     Type:    SHT_ARM_EXIDX
     Size:    [[SIZE=<none>]]
     Content: [[CONTENT=<none>]]
     Entries: [[ENT=<none>]]
 
-## Check we can use "Content" key with "Size" key when the size is greater
+## Check we can use the "Content" key with the "Size" key when the size is greater
 ## than or equal to the content size.
 
 # RUN: not yaml2obj --docnum=3 -DCONTENT="'00'" -DSIZE=0 %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
 
-# CONTENT-SIZE-ERR: error: "Size" must be greater than or equal to the content size
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
 
 # RUN: yaml2obj --docnum=3 -DCONTENT="'00'" -DSIZE=1 %s -o %t.cont.size.eq.o
 # RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
 # RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00"
 
 # RUN: yaml2obj --docnum=3 -DCONTENT="'00'" -DSIZE=2 %s -o %t.cont.size.gr.o
 # RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
 # RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0000"

llvm/test/tools/yaml2obj/ELF/call-graph-profile-section.yaml

Entries:
       - From:   2
         To:     1
         Weight: 98
 Symbols:
   - Name: foo
   - Name: bar
 
 ## Check we can set arbitrary sh_link and sh_entsize values.
-## Check we can specify neither "Content" nor "Entries" tags.
+## Check we can specify none of "Content", "Entries", and "Size" tags.
 # RUN: yaml2obj --docnum=2 %s -o %t.link
 # RUN: llvm-readelf --sections %t.link | FileCheck %s --check-prefix=LINK
 
 # LINK: [Nr] Name      Type                    Address          Off    Size   ES Flg Lk
 # LINK: [ 1] .llvm.foo LLVM_CALL_GRAPH_PROFILE 0000000000000000 000040 000000 00     0
 # LINK: [ 2] .llvm.bar LLVM_CALL_GRAPH_PROFILE 0000000000000000 000040 000000 ff     255
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .llvm.foo
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Link:    0x0
     EntSize: 0
   - Name:    .llvm.bar
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Link:    0xFF
     EntSize: 0xFF
 
-## Check we can't specify both "Content" and "Entries" tags.
-# RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=BOTH
-# BOTH: error: "Entries" and "Content" can't be used together
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name:    .llvm.foo
-    Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-    Content: ""
-    Entries: []
-
 ## Check we can refer to symbols by name.
-# RUN: yaml2obj --docnum=4 %s -o %t.sym
+# RUN: yaml2obj --docnum=3 %s -o %t.sym
 # RUN: llvm-readobj --cg-profile %t.sym | FileCheck %s --check-prefix=SYMBOL-NAMES
 
 # SYMBOL-NAMES:      CGProfile [
 # SYMBOL-NAMES-NEXT:   CGProfileEntry {
 # SYMBOL-NAMES-NEXT:     From: foo (1)
 # SYMBOL-NAMES-NEXT:     To: bar (2)
 # SYMBOL-NAMES-NEXT:     Weight: 10
 # SYMBOL-NAMES-NEXT:   }
## Case 2: Test we can refer to symbols with suffixes.
         To:     'foo (1)'
         Weight: 30
 Symbols:
   - Name: foo
   - Name: bar
   - Name: 'foo (1)'
 
 ## Check we can describe SHT_LLVM_CALL_GRAPH_PROFILE sections using the "Content" tag.
-# RUN: yaml2obj --docnum=5 %s -o %t.content
+# RUN: yaml2obj --docnum=4 %s -o %t.content
 # RUN: llvm-readobj --sections --section-data %t.content | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Name: .llvm.call-graph-profile
 # CONTENT:      SectionData (
 # CONTENT-NEXT:   0000: 11223344 |
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .llvm.call-graph-profile
     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
     Content: "11223344"
 
 ## Check we can't reference unknown symbols by name.
+# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=UNKNOWN-NAME
 # RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=UNKNOWN-NAME
-# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=UNKNOWN-NAME
 # UNKNOWN-NAME: error: unknown symbol referenced: 'bar' by YAML section '.llvm.call-graph-profile'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
## The first symbol is unknown, but the second is valid.
     Entries:
       - From:   bar
         To:     foo
         Weight: 10
 Symbols:
   - Name: foo
 
 ## Check we can specify arbitrary symbol indexes for an SHT_LLVM_CALL_GRAPH_PROFILE section entry.
-# RUN: yaml2obj --docnum=8 %s -o %t.unk
+# RUN: yaml2obj --docnum=7 %s -o %t.unk
 # RUN: llvm-readobj --sections --section-data %t.unk | FileCheck %s --check-prefix=UNKNOWN-INDEX
 
 # UNKNOWN-INDEX:      Name: .llvm.call-graph-profile
 # UNKNOWN-INDEX:      SectionData (
 # UNKNOWN-INDEX-NEXT:   0000: 01000000 02000000 03000000 00000000 |
 # UNKNOWN-INDEX-NEXT: )
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .llvm.call-graph-profile
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Entries:
       - From:   1
         To:     2
         Weight: 3
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=8 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .llvm.foo
+    Type:    SHT_LLVM_CALL_GRAPH_PROFILE
+    Link:    0x1
+    EntSize: 0x2
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Entries: [[ENTRIES=<none>]]
+
+# RUN: yaml2obj --docnum=8 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj --docnum=8 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .llvm.foo
+# CHECK-CONTENT-NEXT: Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# CHECK-CONTENT-NEXT: Flags [
+# CHECK-CONTENT-NEXT: ]
+# CHECK-CONTENT-NEXT: Address:
+# CHECK-CONTENT-NEXT: Offset:
+# CHECK-CONTENT-NEXT: Size:
+# CHECK-CONTENT-NEXT: Link: 1
+# CHECK-CONTENT-NEXT: Info:
+# CHECK-CONTENT-NEXT: AddressAlignment:
+# CHECK-CONTENT-NEXT: EntrySize: 2
+# CHECK-CONTENT-NEXT: SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=8 -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=8 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=8 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+# RUN: not yaml2obj --docnum=8 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+
+# ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"

llvm/test/tools/yaml2obj/ELF/dynamic-section-raw-content.yaml

-## Show that yaml2obj can handle a dynamic section with raw content instead of
-## entries. Also show that it rejects raw content when entries are also provided.
+## Check how "Content", "Size" and "Entries" keys can be used to
+## describe a content for relocations sections.
 
-# RUN: yaml2obj --docnum=1 %s -o %t1
-# RUN: llvm-readobj -x .dynamic --sections %t1 | FileCheck %s --check-prefix=RAW
+## Check we can use the "Content" key alone.
 
-# RAW:      Name: .dynamic
-# RAW-NEXT: Type: SHT_DYNAMIC
-# RAW-NEXT: Flags [
-# RAW-NEXT: ]
-# RAW-NEXT: Address:
-# RAW-NEXT: Offset:
-# RAW-NEXT: Size: 16
+# RUN: yaml2obj -DCONTENT="01234567" %s -o %t1.content
+# RUN: llvm-readobj --sections --section-data %t1.content | \
+# RUN:   FileCheck %s --check-prefix=RAW -DDATA="01234567"
 
-# RAW:      Hex dump of section '.dynamic':
-# RAW-NEXT: 0x00000000 01234567 89012345 67890000 00000000 {{.*}}
+# RAW:      Name: .dynamic
+# RAW:      EntrySize:
+# RAW-SAME:            255{{$}}
+# RAW:      SectionData (
+# RAW-NEXT:   0000: [[DATA]] |
+# RAW-NEXT: )
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name: .dynamic
-    Type: SHT_DYNAMIC
-    Content: "01234567890123456789000000000000"
+  - Name:    .dynamic
+    Type:    SHT_DYNAMIC
+    EntSize: 0xff
+    Content: [[CONTENT=<none>]]
+    Size:    [[SIZE=<none>]]
+    Entries: [[ENTRIES=<none>]]
 
-# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ERR
+## Check we can use the "Size" key alone.
 
-# ERR: cannot specify both raw content and explicit entries for dynamic section '.dynamic1'
-# ERR: cannot specify both raw content and explicit entries for dynamic section '.dynamic2'
+# RUN: yaml2obj -DSIZE=3 %s -o %t1.size
+# RUN: llvm-readobj --sections --section-data %t1.size | \
+# RUN:   FileCheck %s --check-prefix=RAW -DDATA="000000"
 
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_EXEC
-Sections:
-  - Name:    .dynamic1
-    Type:    SHT_DYNAMIC
-    Content: "0123456789"
-    Entries:
-      - Tag:   DT_STRSZ
-        Value: 0
-  - Name:    .dynamic2
-    Type:    SHT_DYNAMIC
-    Content: "0123456789"
-    Entries:
-      - Tag:   DT_STRSZ
-        Value: 0
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+# RUN: yaml2obj -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=RAW -DDATA="0011"
+
+# RUN: yaml2obj -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=RAW -DDATA="001100"
+
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENT-ERR
+# RUN: not yaml2obj -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENT-ERR
+
+# ENT-ERR: error: "Entries" cannot be used with "Content" or "Size"
+
+## Check we create an empty section when none of "Size", "Content" or "Entries" are specified.
+
+# RUN: yaml2obj %s -o %t.empty.o
+# RUN: llvm-readelf --sections --section-data %t.empty.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-SEC
+
+# EMPTY-SEC: [Nr] Name     Type    Address          Off    Size
+# EMPTY-SEC: [ 1] .dynamic DYNAMIC 0000000000000000 000040 000000

llvm/test/tools/yaml2obj/ELF/gnu-hash-section.yaml

- Name:  .gnu.hash
     Header:
       SymNdx: 0x0
 
 ## Either "Content" or "Header", "BloomFilter", "HashBuckets" and "HashBuckets" must be
 ## specified when declaring a SHT_GNU_HASH section.
 
 # RUN: not yaml2obj --docnum=10 %s -o %t10 2>&1 | FileCheck %s --check-prefix=NOKEYS
 
-# NOKEYS: error: either "Content" or "Header", "BloomFilter", "HashBuckets" and "HashBuckets" must be specified
+# NOKEYS: error: either "Content", "Size" or "Header", "BloomFilter", "HashBuckets" and "HashBuckets" must be specified
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
 
-## Test that "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content".
+## Test that "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with the "Content" or "Size"
 
-# RUN: not yaml2obj --docnum=11 %s -o %t11 2>&1 | FileCheck %s --check-prefix=TOGETHER
-
-# TOGETHER: error: "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content"
+# RUN: not yaml2obj --docnum=11 -DCONTENT="" %s 2>&1 | FileCheck %s --check-prefix=TOGETHER
+# RUN: not yaml2obj --docnum=11 -DSIZE=0 %s 2>&1 | FileCheck %s --check-prefix=TOGETHER
+# TOGETHER: error: "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
-  - Name:  .gnu.hash
-    Type:  SHT_GNU_HASH
-    Content: ""
+  - Name:    .gnu.hash
+    Type:    SHT_GNU_HASH
+    Content: [[CONTENT=<none>]]
+    Size:    [[SIZE=<none>]]
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: []
     HashBuckets: []
     HashValues:  []
 
 ## Test we can override the number of buckets and the number of words in the Bloom filter
- Name:  .gnu.hash
     Header:
       NBuckets:  0x1
       SymNdx:    0x2
       MaskWords: 0x3
       Shift2:    0x4
     BloomFilter: []
     HashBuckets: []
     HashValues:  []
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=13 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .gnu.hash
+    Type:    SHT_GNU_HASH
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+
+# RUN: yaml2obj --docnum=13 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj --docnum=13 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .gnu.hash
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=13 -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=13 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"

llvm/test/tools/yaml2obj/ELF/group.yaml

+## Check how the "Content", "Size" and "Members" keys can be used to
+## describe the content for group sections.
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .group
+    Type:    SHT_GROUP
+    Link:    0x1
+    Info:    0x2
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Members: [[MEMBERS=<none>]]
+
+# RUN: yaml2obj -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .group
+# CHECK-CONTENT-NEXT: Type: SHT_GROUP
+# CHECK-CONTENT-NEXT: Flags [
+# CHECK-CONTENT-NEXT: ]
+# CHECK-CONTENT-NEXT: Address:
+# CHECK-CONTENT-NEXT: Offset:
+# CHECK-CONTENT-NEXT: Size:
+# CHECK-CONTENT-NEXT: Link: 1
+# CHECK-CONTENT-NEXT: Info: 2
+# CHECK-CONTENT-NEXT: AddressAlignment:
+# CHECK-CONTENT-NEXT: EntrySize: 4
+# CHECK-CONTENT-NEXT: SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Members" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj -DSIZE=0 -DMEMBERS="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=MEMBERS-ERR
+# RUN: not yaml2obj -DCONTENT="'00'" -DMEMBERS="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=MEMBERS-ERR
+
+# MEMBERS-ERR: error: "Members" cannot be used with "Content" or "Size"
+
+## Check we create an empty section when none of "Size", "Content" or "Members" are specified.
+
+# RUN: yaml2obj %s -o %t.empty.o
+# RUN: llvm-readelf --sections --section-data %t.empty.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-SEC
+
+# EMPTY-SEC: [Nr] Name   Type  Address          Off    Size
+# EMPTY-SEC: [ 1] .group GROUP 0000000000000000 000040 000000

llvm/test/tools/yaml2obj/ELF/hash-section.yaml

- Name: .hash
     Size: 0x5
     Content: "112233"
 
 ## Check that when "Size" and "Content" are used together, the size
 ## must be greater than or equal to the content size.
 
 # RUN: not yaml2obj --docnum=11 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
-# SIZE-CONTENT-ERR: error: "Size" must be greater than or equal to the content size
+# SIZE-CONTENT-ERR: error: Section size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name: .hash

llvm/test/tools/yaml2obj/ELF/linker-options.yaml

 ## Check we are able to produce a valid SHT_LLVM_LINKER_OPTIONS
 ## section from its description.
 
-## Check we can use either "Options" or "Content" to describe the data.
+## Check we can use "Options", "Size" and "Content" alone to describe the data.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --string-dump .linker-options1 --sections --section-data %t1 \
 # RUN:   | FileCheck %s --check-prefix=OPTIONS
 
 # OPTIONS:        Name: .linker-options1
 # OPTIONS-NEXT:   Type: SHT_LLVM_LINKER_OPTIONS
 # OPTIONS-NEXT:   Flags [
 # OPTIONS-NEXT:   ]
 # OPTIONS-NEXT:   Address: 0x0
 # OPTIONS-NEXT:   Offset: 0x40
 # OPTIONS-NEXT:   Size: 34
 # OPTIONS-NEXT:   Link: 0
 # OPTIONS-NEXT:   Info: 0
 # OPTIONS-NEXT:   AddressAlignment: 0
 # OPTIONS-NEXT:   EntrySize: 0
 
 # OPTIONS:      Name: .linker-options2
 # OPTIONS-NEXT: Type: SHT_LLVM_LINKER_OPTIONS
 # OPTIONS:      SectionData (
 # OPTIONS-NEXT:   0000: 00112233 |
 # OPTIONS-NEXT: )
 
+# OPTIONS:      Name: .linker-options3
+# OPTIONS-NEXT: Type: SHT_LLVM_LINKER_OPTIONS
+# OPTIONS:      SectionData (
+# OPTIONS-NEXT:   0000: 00000000 |
+# OPTIONS-NEXT: )
+
 # OPTIONS:      String dump of section '.linker-options1':
 # OPTIONS-NEXT: [     0] option 0
 # OPTIONS-NEXT: [     9] value 0
 # OPTIONS-NEXT: [    11] option 1
 # OPTIONS-NEXT: [    1a] value 1
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .linker-options1
     Type: SHT_LLVM_LINKER_OPTIONS
     Options:
       - Name:  option 0
         Value: value 0
       - Name:  option 1
         Value: value 1
   - Name: .linker-options2
     Type: SHT_LLVM_LINKER_OPTIONS
     Content: "00112233"
+  - Name: .linker-options3
+    Type: SHT_LLVM_LINKER_OPTIONS
+    Size: 4
 
 ## Check that "Value" and "Name" fields are mandatory when using "Options" key.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=NOVALUE
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=NONAME
 
 # NOVALUE: error: missing required key 'Value'
 # NONAME: error: missing required key 'Name'
FileHeader:
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .linker-options
     Type: SHT_LLVM_LINKER_OPTIONS
     Options:
       - Value: value
 
-## Check we can't use both "Options" and "Content" together.
+## Check we can't use "Options" or "Size" keys together with the "Content" key.
 
-# RUN: not yaml2obj %s --docnum=4 2>&1 | FileCheck %s --check-prefix=BOTH
+# RUN: not yaml2obj %s -DOPTIONS="[]" -DCONTENT="''" --docnum=4 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=TOGETHER
 
-# BOTH: error: "Options" and "Content" can't be used together
+# RUN: not yaml2obj %s -DOPTIONS="[]" -DSIZE="0" --docnum=4 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=TOGETHER
+
+# TOGETHER: error: "Options" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
-  - Name: .linker-options
-    Type: SHT_LLVM_LINKER_OPTIONS
-    Options:
-      - Name:  name
-        Value: value
-    Content: "00112233"
+  - Name:    .linker-options
+    Type:    SHT_LLVM_LINKER_OPTIONS
+    Options: [[OPTIONS=<none>]]
+    Content: [[CONTENT=<none>]]
+    Size:    [[SIZE=<none>]]
 
-## Check we can omit both "Options" and "Content". This produces an empty section.
+## Check we can omit "Options", "Content" and "Size" keys. This produces an empty section.
 
-# RUN: yaml2obj %s --docnum=5 2>&1 -o %t5
+# RUN: yaml2obj %s --docnum=4 2>&1 -o %t5
 # RUN: llvm-readelf --sections %t5 | FileCheck %s --check-prefix=NONE
 
 # NONE: [Nr] Name            Type                Address          Off    Size
 # NONE: [ 1] .linker-options LLVM_LINKER_OPTIONS 0000000000000000 000040 000000
 
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_REL
-Sections:
-  - Name: .linker-options
-    Type: SHT_LLVM_LINKER_OPTIONS
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=4 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+# RUN: yaml2obj --docnum=4 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# CHECK-CONTENT:      Name: .linker-options (1)
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+# RUN: yaml2obj --docnum=4 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"

llvm/test/tools/yaml2obj/ELF/llvm-addrsig-section.yaml

- Name: .llvm_addrsig_sizeeq
     Size: 0x3
     Content: "112233"
 
 ## Check that when "Size" and "Content" are used together, the size
 ## must be greater than or equal to the content size.
 
 # RUN: not yaml2obj --docnum=11 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
-# SIZE-CONTENT-ERR: error: "Size" must be greater than or equal to the content size
+# SIZE-CONTENT-ERR: error: Section size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name: .llvm_addrsig

llvm/test/tools/yaml2obj/ELF/llvm-deplibs-section.yaml

 ## Check how yaml2obj produces SHT_LLVM_DEPENDENT_LIBRARIES sections.
 
 ## Check we can describe SHT_LLVM_DEPENDENT_LIBRARIES using
-## "Libraries" and "Content" properies.
+## "Libraries", "Size" and "Content" properies.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=LIBRARIES
 
 # LIBRARIES:      Name: .deplibs.lib
 # LIBRARIES-NEXT: Type: SHT_LLVM_DEPENDENT_LIBRARIES (0x6FFF4C04)
 # LIBRARIES-NEXT: Flags [ (0x0)
 # LIBRARIES-NEXT: ]

 # LIBRARIES-NEXT: Link: 0
 # LIBRARIES-NEXT: Info: 0
 # LIBRARIES-NEXT: AddressAlignment: 0
 # LIBRARIES-NEXT: EntrySize: 0
 # LIBRARIES-NEXT: SectionData (
 # LIBRARIES-NEXT:   0000: 112233
 # LIBRARIES-NEXT: )
 
+# LIBRARIES:      Name: .deplibs.size
+# LIBRARIES-NEXT: Type: SHT_LLVM_DEPENDENT_LIBRARIES
+# LIBRARIES-NEXT: Flags [ (0x0)
+# LIBRARIES-NEXT: ]
+# LIBRARIES-NEXT: Address: 0x0
+# LIBRARIES-NEXT: Offset: 0x4F
+# LIBRARIES-NEXT: Size: 3
+# LIBRARIES-NEXT: Link: 0
+# LIBRARIES-NEXT: Info: 0
+# LIBRARIES-NEXT: AddressAlignment: 0
+# LIBRARIES-NEXT: EntrySize: 0
+# LIBRARIES-NEXT: SectionData (
+# LIBRARIES-NEXT:   0000: 000000 |
+# LIBRARIES-NEXT: )
+
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:      .deplibs.lib
     Type:      SHT_LLVM_DEPENDENT_LIBRARIES
     Libraries: [ foo, bar, foo ]
   - Name:    .deplibs.content
     Type:    SHT_LLVM_DEPENDENT_LIBRARIES
     Content: "112233"
+  - Name: .deplibs.size
+    Type: SHT_LLVM_DEPENDENT_LIBRARIES
+    Size: 0x3
 
-## Check we report an error when "Libraries" and "Content" are used together.
+## Check we report an error when "Libraries" and "Content"/"Size" keys are used together.
 
-# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=LIBS-CONTENT
+# RUN: not yaml2obj --docnum=2 -DCONTENT="FF" -DLIBS="[]" %s 2>&1 | FileCheck %s --check-prefix=LIBS-ERR
+# RUN: not yaml2obj --docnum=2 -DSIZE=0 -DLIBS="[]" %s 2>&1 | FileCheck %s --check-prefix=LIBS-ERR
 
-# LIBS-CONTENT: error: SHT_LLVM_DEPENDENT_LIBRARIES: "Libraries" and "Content" can't be used together
+# LIBS-ERR: error: "Libraries" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:      .deplibs
     Type:      SHT_LLVM_DEPENDENT_LIBRARIES
-    Content:   "FF"
-    Libraries: [ foo ]
+    Content:   [[CONTENT=<none>]]
+    Size:      [[SIZE=<none>]]
+    Libraries: [[LIBS=<none>]]
 
-## Check we create an empty section when neither "Libraries" nor "Content" are specified.
+## Check we create an empty section when none of "Libraries", "Size" or "Content" are specified.
 
-# RUN: yaml2obj --docnum=3 %s -o %t3
-# RUN: llvm-readelf --sections %t3 | FileCheck %s --check-prefix=NOPROPS
+# RUN: yaml2obj --docnum=2 %s -o %t2.empty
+# RUN: llvm-readelf --sections %t2.empty | FileCheck %s --check-prefix=EMPTY
 
-# NOPROPS: [Nr] Name     Type                     Address          Off    Size
-# NOPROPS: [ 1] .deplibs LLVM_DEPENDENT_LIBRARIES 0000000000000000 000040 000000
- 
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_REL
-Sections:
-  - Name: .deplibs
-    Type: SHT_LLVM_DEPENDENT_LIBRARIES
+# EMPTY: [Nr] Name     Type                     Address          Off    Size
+# EMPTY: [ 1] .deplibs LLVM_DEPENDENT_LIBRARIES 0000000000000000 000040 000000
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=2 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+# RUN: yaml2obj --docnum=2 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj --docnum=2 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .deplibs
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )

llvm/test/tools/yaml2obj/ELF/mips-abi-flags.yaml

- Name:         .MIPS.abiflags
     ISAExtension: EXT_OCTEON3
     ASEs:         [ DSP, DSPR2, VIRT ]
     FpABI:        FP_DOUBLE
     GPRSize:      REG_64
     CPR1Size:     REG_64
     CPR2Size:     REG_NONE
     Flags1:       [ ODDSPREG ]
     Flags2:       0x0
+    Content:     [[CONTENT=<none>]]
+    Size:        [[SIZE=<none>]]
 
 ## Check we don't recognize the SHT_MIPS_ABIFLAGS section for non-MIPS targets.
 
 # RUN: not yaml2obj %s -DMACHINE=EM_NONE 2>&1 | FileCheck %s --check-prefix=ERR
 
 # ERR:      error: invalid hex32 number
 # ERR-NEXT: Type: SHT_MIPS_ABIFLAGS
+
+## Document we don't support the "Content" key yet.
+
+# RUN: not yaml2obj %s -DCONTENT="'00'" 2>&1 | FileCheck %s --check-prefix=ERR-CONTENT
+
+# ERR-CONTENT: error: "Content" key is not implemented for SHT_MIPS_ABIFLAGS section
+
+## Document we don't support the "Size" key yet.
+
+# RUN: not yaml2obj %s -DSIZE=0 2>&1 | FileCheck %s --check-prefix=ERR-SIZE
+
+# ERR-SIZE: error: "Size" key is not implemented for SHT_MIPS_ABIFLAGS section

llvm/test/tools/yaml2obj/ELF/nobits.yaml

+## Check how SHT_NOBITS sections are created.
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readelf --sections --section-data %t.size.o | FileCheck %s
+
+# CHECK: [Nr] Name    Type   Address          Off    Size   ES Flg Lk Inf Al
+# CHECK: [ 1] .nobits NOBITS 0000000000000000 000040 000003 00      0   0  0
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .nobits
+    Type:    SHT_NOBITS
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+
+## Check we can't use the "Content" key.
+
+# RUN: not yaml2obj -DCONTENT="'112233'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-ERR
+
+# CONTENT-ERR: error: SHT_NOBITS section cannot have "Content"
+
+## Check we create an empty section when neither of "Size" nor "Content" are specified.
+
+# RUN: yaml2obj %s -o %t.empty.o
+# RUN: llvm-readelf --sections --section-data %t.empty.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-SEC
+
+# EMPTY-SEC: [Nr] Name    Type   Address          Off    Size
+# EMPTY-SEC: [ 1] .nobits NOBITS 0000000000000000 000040 000000

llvm/test/tools/yaml2obj/ELF/note-section.yaml

- Name:    .note.sizeeq
     Type:    SHT_NOTE
     Size:    0x3
     Content: "112233"
 
 ## Check that when "Size" and "Content" are used together, the size
 ## must be greater than or equal to the content size.
 
 # RUN: not yaml2obj --docnum=13 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
-# SIZE-CONTENT-ERR: error: "Size" must be greater than or equal to the content size
+# SIZE-CONTENT-ERR: error: Section size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .note

llvm/test/tools/yaml2obj/ELF/reloc-sec.yaml

+## Check how "Content", "Size" and "Entries" keys can be used to
+## describe a content for relocations sections.
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:        .rela
+    Type:        SHT_RELA
+    Link:        0x1
+    Info:        0x2
+    EntSize:     0x3
+    Size:        [[SIZE=<none>]]
+    Content:     [[CONTENT=<none>]]
+    Relocations: [[RELS=<none>]]
+
+# RUN: yaml2obj -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .rela
+# CHECK-CONTENT-NEXT: Type: SHT_RELA
+# CHECK-CONTENT-NEXT: Flags [
+# CHECK-CONTENT-NEXT: ]
+# CHECK-CONTENT-NEXT: Address:
+# CHECK-CONTENT-NEXT: Offset:
+# CHECK-CONTENT-NEXT: Size:
+# CHECK-CONTENT-NEXT: Link: 1
+# CHECK-CONTENT-NEXT: Info: 2
+# CHECK-CONTENT-NEXT: AddressAlignment:
+# CHECK-CONTENT-NEXT: EntrySize: 3
+# CHECK-CONTENT-NEXT: SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Relocations" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj -DSIZE=0 -DRELS="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=REL-ERR
+# RUN: not yaml2obj -DCONTENT="'00'" -DRELS="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=REL-ERR
+
+# REL-ERR: error: "Relocations" cannot be used with "Content" or "Size"
+
+## Check we create an empty section when none of "Size", "Content" or "Relocations" are specified.
+
+# RUN: yaml2obj %s -o %t.empty.o
+# RUN: llvm-readelf --sections --section-data %t.empty.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-SEC
+
+# EMPTY-SEC: [Nr] Name  Type Address          Off    Size
+# EMPTY-SEC: [ 1] .rela RELA 0000000000000000 000040 000000

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

-## Test how we create SHT_RELR sections.
-
-## Test that the content of SHT_RELR sections for 64-bit little endian targets is correct.
-# RUN: yaml2obj --docnum=1 -D ENCODE=LSB %s -o %t.le64
-# RUN: llvm-readobj --sections --section-data %t.le64 | FileCheck %s --check-prefix=LE64
-
-# LE64:      Name: .relr.dyn
-# LE64-NEXT: Type: SHT_RELR
-# LE64-NEXT: Flags [
-# LE64-NEXT:   SHF_ALLOC
-# LE64-NEXT: ]
-# LE64-NEXT: Address: 0x0
-# LE64-NEXT: Offset: 0x40
-# LE64-NEXT: Size: 32
-# LE64-NEXT: Link: 0
-# LE64-NEXT: Info: 0
-# LE64-NEXT: AddressAlignment: 0
-# LE64-NEXT: EntrySize: 8
-# LE64-NEXT: SectionData (
-# LE64-NEXT:   0000: DDCCBBAA 00000000 2211FFEE 00000000
-# LE64-NEXT:   0010: 66554433 00000010 AA998877 00000010
-# LE64-NEXT: )
-
-## Test that the content of SHT_RELR sections for 64-bit big endian targets is correct.
-# RUN: yaml2obj --docnum=1 -D ENCODE=MSB %s -o %t.be64
-# RUN: llvm-readobj --sections --section-data %t.be64 | FileCheck %s --check-prefix=BE64
-
-# BE64:      Name: .relr.dyn
-# BE64:      SectionData (
-# BE64-NEXT:   0000: 00000000 AABBCCDD 00000000 EEFF1122
-# BE64-NEXT:   0010: 10000000 33445566 10000000 778899AA
-# BE64-NEXT: )
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2[[ENCODE]]
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-## Set an arbitrary flag to demonstrate flags are set when requested.
-    Flags:   [ SHF_ALLOC ]
-    Entries: [ 0x00000000AABBCCDD, 0x00000000EEFF1122,
-               0x1000000033445566, 0x10000000778899AA ]
-
-## Test that the content of SHT_RELR sections for 32-bit little endian targets is correct.
-# RUN: yaml2obj --docnum=2 -D ENCODE=LSB %s -o %t.le32
-# RUN: llvm-readobj --sections --section-data %t.le32 | FileCheck %s --check-prefix=LE32
-
-# LE32:      Name: .relr.dyn
-# LE32-NEXT: Type: SHT_RELR
-# LE32-NEXT: Flags [
-# LE32-NEXT:   SHF_ALLOC
-# LE32-NEXT: ]
-# LE32-NEXT: Address: 0x0
-# LE32-NEXT: Offset: 0x34
-# LE32-NEXT: Size: 16
-# LE32-NEXT: Link: 0
-# LE32-NEXT: Info: 0
-# LE32-NEXT: AddressAlignment: 0
-# LE32-NEXT: EntrySize: 4
-# LE32-NEXT: SectionData (
-# LE32-NEXT:   0000: DDCCBBAA BBAAFFEE BBAAFFEE BCAAFFEE
-# LE32-NEXT: )
-
-## Test that the content of SHT_RELR sections for 32-bit big endian targets is correct.
-# RUN: yaml2obj --docnum=2 -D ENCODE=MSB %s -o %t.be32
-# RUN: llvm-readobj --sections --section-data %t.be32 | FileCheck %s --check-prefix=BE32
-
-# BE32:      Name: .relr.dyn
-# BE32:      SectionData (
-# BE32-NEXT:   0000: AABBCCDD EEFFAABB EEFFAABB EEFFAABC  |
-# BE32-NEXT: )
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS32
-  Data:  ELFDATA2[[ENCODE]]
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-## Set an arbitrary flag to demonstrate flags are set when requested.
-    Flags:   [ SHF_ALLOC ]
-    Entries: [ 0xAABBCCDD, 0xEEFFAABB,
-               0xEEFFAABB, 0xEEFFAABC ]
-
-## Test we can use "Content" to describe SHT_RELR section.
-# RUN: yaml2obj --docnum=3 %s -o %t.content
-# RUN: llvm-readobj --sections --section-data %t.content | FileCheck %s --check-prefix=CONTENT
-
-# CONTENT:      Name: .relr.dyn
-# CONTENT:      SectionData (
-# CONTENT-NEXT:   0000: 112233 |
-# CONTENT-NEXT: )
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS32
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-    Content: "112233"
-
-## Check we are able to set an arbitrary sh_entsize.
-# RUN: yaml2obj --docnum=4 %s -o %t.entsize
-# RUN: llvm-readelf --sections %t.entsize | FileCheck %s --check-prefix=ENTSIZE
-
-# ENTSIZE: [Nr] Name      Type Address  Off    Size   ES
-# ENTSIZE: [ 1] .relr.dyn RELR 00000000 000034 000001 34
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS32
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-    EntSize: 0x34
-    Content: "12"
-
-## Test we can't use 64-bit offsets/bitmaps when creating a 32-bit object.
-# RUN: yaml2obj --docnum=5 %s -o %t.nottoolarge
-# RUN: llvm-readobj --sections --section-data %t.nottoolarge | FileCheck %s --check-prefix=NOT-TOO-LARGE
-
-# NOT-TOO-LARGE:      Name: .relr.dyn
-# NOT-TOO-LARGE:      SectionData (
-# NOT-TOO-LARGE-NEXT:   0000: FFFFFFFF
-# NOT-TOO-LARGE-NEXT: )
-
-# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=TOO-LARGE
-# TOO-LARGE: error: .relr.dyn: the value is too large for 32-bits: 0x100000000
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS32
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-    Entries: [ 0x00000000FFFFFFFF ]
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS32
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-    Entries: [ 0x0000000100000000 ]
-
-## Test we can't specify "Entries" and "Content" properties at the same time.
-# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=BOTH
-
-# BOTH: error: "Entries" and "Content" can't be used together
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS32
-  Data:  ELFDATA2LSB
-  Type:  ET_DYN
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-    Entries: [ 0x0 ]
-    Content: "00"
+## Test how we create SHT_RELR sections.
+
+## Test that the content of SHT_RELR sections for 64-bit little endian targets is correct.
+# RUN: yaml2obj --docnum=1 -D ENCODE=LSB %s -o %t.le64
+# RUN: llvm-readobj --sections --section-data %t.le64 | FileCheck %s --check-prefix=LE64
+
+# LE64:      Name: .relr.dyn
+# LE64-NEXT: Type: SHT_RELR
+# LE64-NEXT: Flags [
+# LE64-NEXT:   SHF_ALLOC
+# LE64-NEXT: ]
+# LE64-NEXT: Address: 0x0
+# LE64-NEXT: Offset: 0x40
+# LE64-NEXT: Size: 32
+# LE64-NEXT: Link: 0
+# LE64-NEXT: Info: 0
+# LE64-NEXT: AddressAlignment: 0
+# LE64-NEXT: EntrySize: 8
+# LE64-NEXT: SectionData (
+# LE64-NEXT:   0000: DDCCBBAA 00000000 2211FFEE 00000000
+# LE64-NEXT:   0010: 66554433 00000010 AA998877 00000010
+# LE64-NEXT: )
+
+## Test that the content of SHT_RELR sections for 64-bit big endian targets is correct.
+# RUN: yaml2obj --docnum=1 -D ENCODE=MSB %s -o %t.be64
+# RUN: llvm-readobj --sections --section-data %t.be64 | FileCheck %s --check-prefix=BE64
+
+# BE64:      Name: .relr.dyn
+# BE64:      SectionData (
+# BE64-NEXT:   0000: 00000000 AABBCCDD 00000000 EEFF1122
+# BE64-NEXT:   0010: 10000000 33445566 10000000 778899AA
+# BE64-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2[[ENCODE]]
+  Type:  ET_DYN
+Sections:
+  - Name:    .relr.dyn
+    Type:    SHT_RELR
+## Set an arbitrary flag to demonstrate flags are set when requested.
+    Flags:   [ SHF_ALLOC ]
+    Entries: [ 0x00000000AABBCCDD, 0x00000000EEFF1122,
+               0x1000000033445566, 0x10000000778899AA ]
+
+## Test that the content of SHT_RELR sections for 32-bit little endian targets is correct.
+# RUN: yaml2obj --docnum=2 -D ENCODE=LSB %s -o %t.le32
+# RUN: llvm-readobj --sections --section-data %t.le32 | FileCheck %s --check-prefix=LE32
+
+# LE32:      Name: .relr.dyn
+# LE32-NEXT: Type: SHT_RELR
+# LE32-NEXT: Flags [
+# LE32-NEXT:   SHF_ALLOC
+# LE32-NEXT: ]
+# LE32-NEXT: Address: 0x0
+# LE32-NEXT: Offset: 0x34
+# LE32-NEXT: Size: 16
+# LE32-NEXT: Link: 0
+# LE32-NEXT: Info: 0
+# LE32-NEXT: AddressAlignment: 0
+# LE32-NEXT: EntrySize: 4
+# LE32-NEXT: SectionData (
+# LE32-NEXT:   0000: DDCCBBAA BBAAFFEE BBAAFFEE BCAAFFEE
+# LE32-NEXT: )
+
+## Test that the content of SHT_RELR sections for 32-bit big endian targets is correct.
+# RUN: yaml2obj --docnum=2 -D ENCODE=MSB %s -o %t.be32
+# RUN: llvm-readobj --sections --section-data %t.be32 | FileCheck %s --check-prefix=BE32
+
+# BE32:      Name: .relr.dyn
+# BE32:      SectionData (
+# BE32-NEXT:   0000: AABBCCDD EEFFAABB EEFFAABB EEFFAABC  |
+# BE32-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS32
+  Data:  ELFDATA2[[ENCODE]]
+  Type:  ET_DYN
+Sections:
+  - Name:    .relr.dyn
+    Type:    SHT_RELR
+## Set an arbitrary flag to demonstrate flags are set when requested.
+    Flags:   [ SHF_ALLOC ]
+    Entries: [ 0xAABBCCDD, 0xEEFFAABB,
+               0xEEFFAABB, 0xEEFFAABC ]
+
+## Check we are able to set an arbitrary sh_entsize.
+# RUN: yaml2obj --docnum=3 %s -o %t.entsize
+# RUN: llvm-readelf --sections %t.entsize | FileCheck %s --check-prefix=ENTSIZE
+
+# ENTSIZE: [Nr] Name      Type Address  Off    Size   ES
+# ENTSIZE: [ 1] .relr.dyn RELR 00000000 000034 000001 34
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS32
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .relr.dyn
+    Type:    SHT_RELR
+    EntSize: 0x34
+    Content: "12"
+
+## Test we can't use 64-bit offsets/bitmaps when creating a 32-bit object.
+# RUN: yaml2obj --docnum=4 %s -o %t.nottoolarge
+# RUN: llvm-readobj --sections --section-data %t.nottoolarge | FileCheck %s --check-prefix=NOT-TOO-LARGE
+
+# NOT-TOO-LARGE:      Name: .relr.dyn
+# NOT-TOO-LARGE:      SectionData (
+# NOT-TOO-LARGE-NEXT:   0000: FFFFFFFF
+# NOT-TOO-LARGE-NEXT: )
+
+# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=TOO-LARGE
+# TOO-LARGE: error: .relr.dyn: the value is too large for 32-bits: 0x100000000
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS32
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .relr.dyn
+    Type:    SHT_RELR
+    Entries: [ 0x00000000FFFFFFFF ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS32
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .relr.dyn
+    Type:    SHT_RELR
+    Entries: [ 0x0000000100000000 ]
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=6 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .relr.dyn
+    Type:    SHT_RELR
+    EntSize: 0xff
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Entries: [[ENTRIES=<none>]]
+
+# RUN: yaml2obj --docnum=6 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj --docnum=6 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .relr.dyn
+# CHECK-CONTENT-NEXT: Type: SHT_RELR
+# CHECK-CONTENT-NEXT: Flags [
+# CHECK-CONTENT-NEXT: ]
+# CHECK-CONTENT-NEXT: Address:
+# CHECK-CONTENT-NEXT: Offset:
+# CHECK-CONTENT-NEXT: Size:
+# CHECK-CONTENT-NEXT: Link:
+# CHECK-CONTENT-NEXT: Info:
+# CHECK-CONTENT-NEXT: AddressAlignment:
+# CHECK-CONTENT-NEXT: EntrySize: 255
+# CHECK-CONTENT-NEXT: SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=6 -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=6 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=6 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+# RUN: not yaml2obj --docnum=6 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+
+# ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"
+
+## Check we create an empty section when none of "Size", "Content" or "Entries" are specified.
+
+# RUN: yaml2obj %s --docnum=6 -o %t.empty.o
+# RUN: llvm-readelf --sections --section-data %t.empty.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-SEC
+
+# EMPTY-SEC: [Nr] Name      Type Address          Off    Size
+# EMPTY-SEC: [ 1] .relr.dyn RELR 0000000000000000 000040 000000

llvm/test/tools/yaml2obj/ELF/sht-symtab-shndx.yaml

FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:    .symtab_shndx
     Type:    SHT_SYMTAB_SHNDX
     Entries: [ 0 ]
     EntSize: 2
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=6 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .symtab_shndx
+    Type:    SHT_SYMTAB_SHNDX
+    Link:    .symtab
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Entries: [[ENTRIES=<none>]]
+  - Name: .symtab
+    Type: SHT_SYMTAB
+## llvm-readobj validates that SHT_SYMTAB_SHNDX section has the same number
+## of entries that the symbol table associated has.
+    Size: [[SYMTAB=0x24]]
+
+# RUN: yaml2obj --docnum=6 -DSIZE=4 -DCONTENT="'00112233'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00112233"
+
+# RUN: yaml2obj --docnum=6 -DSIZE=8 -DSYMTAB=0x36 -DCONTENT="'00112233'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00112233 00000000"
+
+# CHECK-CONTENT:      Name: .symtab_shndx
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=6 -DSIZE=4 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=6 -DCONTENT="'11223344'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="11223344"
+
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=6 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+# RUN: not yaml2obj --docnum=6 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+
+# ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"
+
+## Check we create an empty section when none of "Size", "Entries" or "Content" are specified.
+
+# RUN: yaml2obj --docnum=6 -DSYMTAB=0x0 %s -o %t.empty
+# RUN: llvm-readelf --sections %t.empty | FileCheck %s --check-prefix=EMPTY
+
+# EMPTY: [Nr] Name          Type                   Address          Off    Size
+# EMPTY: [ 1] .symtab_shndx SYMTAB SECTION INDICES 0000000000000000 000040 000000

llvm/test/tools/yaml2obj/ELF/stack-sizes.yaml

 Sections:
   - Name: .stack_sizes
     Type: SHT_PROGBITS
     Size: 0x5
     Content: "112233"
 
 # RUN: not yaml2obj --docnum=10 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
-# SIZE-CONTENT-ERR: error: .stack_sizes: Size must be greater than or equal to the content size
+# SIZE-CONTENT-ERR: error: Section size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name: .stack_sizes

llvm/test/tools/yaml2obj/ELF/verdef-section.yaml

FileHeader:
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:  .gnu.version_d
     Type:  SHT_GNU_verdef
     Flags: [ SHF_ALLOC ]
     Info:  0x0000000000000001
 
-## Check we can't use both "Entries" and "Content" together.
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
 
-# RUN: not yaml2obj --docnum=4 %s -o %t4 2>&1 | FileCheck %s --check-prefix=BOTH
+# RUN: not yaml2obj --docnum=4 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
 
-# BOTH: error: SHT_GNU_verdef: "Entries" and "Content" can't be used together
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .gnu.version_d
     Type:    SHT_GNU_verdef
-    Flags:   [ SHF_ALLOC ]
-    Info:    0x0000000000000001
-    Content: "112233"
-    Entries:
-      - Version:    0
-        Flags:      0
-        VersionNdx: 0
-        Hash:       0
-        Names:
-          - foo
+    Info:    0x1
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Entries: [[ENTRIES=<none>]]
+
+# RUN: yaml2obj --docnum=4 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj --docnum=4 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .gnu.version_d
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=4 -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=4 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=4 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+# RUN: not yaml2obj --docnum=4 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+
+# ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"

llvm/test/tools/yaml2obj/ELF/verneed-section.yaml

Dependencies:
           - Name:            v3
             Hash:            1939
             Flags:           12
             Other:           2
 DynamicSymbols:
   - Name:    f1
     Binding: STB_GLOBAL
 
-## Check we can use "Content" to describe the content.
+## Check we can omit "Content", "Size" and "Dependencies" fields to
+## produce an empty SHT_GNU_verneed section.
 
-# RUN: yaml2obj --docnum=2 %s -o %t2
-# RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=CONTENT
-
-# CONTENT:      Name: .gnu.version_r
-# CONTENT-NEXT: Type: SHT_GNU_verneed
-# CONTENT-NEXT: Flags [ (0x2)
-# CONTENT-NEXT:   SHF_ALLOC (0x2)
-# CONTENT-NEXT: ]
-# CONTENT-NEXT: Address: 0x0
-# CONTENT-NEXT: Offset: 0x40
-# CONTENT-NEXT: Size: 3
-# CONTENT-NEXT: Link: 0
-# CONTENT-NEXT: Info: 1
-# CONTENT-NEXT: AddressAlignment: 0
-# CONTENT-NEXT: EntrySize: 0
-# CONTENT-NEXT: SectionData (
-# CONTENT-NEXT:   0000: 112233
-# CONTENT-NEXT: )
-
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_EXEC
-Sections:
-  - Name:    .gnu.version_r
-    Type:    SHT_GNU_verneed
-    Flags:   [ SHF_ALLOC ]
-    Info:    0x1
-    Content: "112233"
-
-## Check we can omit "Content" and "Dependencies" fields to produce an empty SHT_GNU_verneed section.
-
-# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: yaml2obj --docnum=2 %s -o %t3
 # RUN: llvm-readelf --sections %t3 | FileCheck %s --check-prefix=NO-PROPS
 
 # NO-PROPS: [Nr] Name           Type    Address          Off    Size
 # NO-PROPS: [ 1] .gnu.version_r VERNEED 0000000000000000 000040 000000
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:  .gnu.version_r
     Type:  SHT_GNU_verneed
     Flags: [ SHF_ALLOC ]
     Info:  0x0
+    Size:         [[SIZE=<none>]]
+    Content:      [[CONTENT=<none>]]
+    Dependencies: [[DEPS=<none>]]
 
-## Check we can't use both "Dependencies" and "Content" together.
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
 
-# RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=BOTH
+# RUN: not yaml2obj --docnum=2 -DCONTENT="'00'" -DSIZE=0 %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
 
-# BOTH: error: SHT_GNU_verneed: "Dependencies" and "Content" can't be used together
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
 
---- !ELF
-FileHeader:
-  Class: ELFCLASS64
-  Data:  ELFDATA2LSB
-  Type:  ET_EXEC
-Sections:
-  - Name:         .gnu.version_r
-    Type:         SHT_GNU_verneed
-    Flags:        [ SHF_ALLOC ]
-    Info:         0x0
-    Content:      ""
-    Dependencies: []
+# RUN: yaml2obj --docnum=2 -DCONTENT="'00'" -DSIZE=1 %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00"
+
+# RUN: yaml2obj --docnum=2 -DCONTENT="'00'" -DSIZE=2 %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0000"
+
+# CHECK-CONTENT:      Name: .gnu.version_r
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=2 -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=2 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Dependencies" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=2 -DSIZE=0 -DDEPS="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=DEPS-ERR
+# RUN: not yaml2obj --docnum=2 -DCONTENT="'00'" -DDEPS="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=DEPS-ERR
+
+# DEPS-ERR: error: "Dependencies" cannot be used with "Content" or "Size"

llvm/test/tools/yaml2obj/ELF/versym-section.yaml

FileHeader:
   Data:  ELFDATA2LSB
   OSABI: ELFOSABI_FREEBSD
   Type:  ET_DYN
 Sections:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     EntSize: 0x0000000000000003
     Entries: [ ]
+
+## Check we can use the "Content" key with the "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=3 -DSIZE=1 -DCONTENT="'0011'" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: Section size must be greater than or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name:    .gnu.version
+    Type:    SHT_GNU_versym
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Entries: [[ENTRIES=<none>]]
+
+# RUN: yaml2obj --docnum=3 -DSIZE=2 -DCONTENT="'0011'" %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0011"
+
+# RUN: yaml2obj --docnum=3 -DSIZE=3 -DCONTENT="'0011'" %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="001100"
+
+# CHECK-CONTENT:      Name: .gnu.version
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use the "Size" key alone to create the section.
+
+# RUN: yaml2obj --docnum=3 -DSIZE=3 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="000000"
+
+## Check we can use the "Content" key alone to create the section.
+
+# RUN: yaml2obj --docnum=3 -DCONTENT="'112233'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="112233"
+
+## Check we can't use the "Entries" key together with the "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=3 -DSIZE=0 -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+# RUN: not yaml2obj --docnum=3 -DCONTENT="'00'" -DENTRIES="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+
+# ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"

llvm/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::DynamicSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(*Shdr);
   if (!DynTagsOrErr)
     return DynTagsOrErr.takeError();
 
+  S->Entries.emplace();
   for (const Elf_Dyn &Dyn : *DynTagsOrErr)
-    S->Entries.push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()});
+    S->Entries->push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()});
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::RelocationSection *>
 ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::RelocationSection>();
   if (auto E = dumpCommonRelocationSection(Shdr, *S))
     return std::move(E);
 
   auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
   if (!SymTabOrErr)
     return SymTabOrErr.takeError();
-  const Elf_Shdr *SymTab = *SymTabOrErr;
+
+  if (Shdr->sh_size != 0)
+    S->Relocations.emplace();
 
   if (Shdr->sh_type == ELF::SHT_REL) {
     auto Rels = Obj.rels(*Shdr);
     if (!Rels)
       return Rels.takeError();
     for (const Elf_Rel &Rel : *Rels) {
       ELFYAML::Relocation R;
-      if (Error E = dumpRelocation(&Rel, SymTab, R))
+      if (Error E = dumpRelocation(&Rel, *SymTabOrErr, R))
         return std::move(E);
-      S->Relocations.push_back(R);
+      S->Relocations->push_back(R);
     }
   } else {
     auto Rels = Obj.relas(*Shdr);
     if (!Rels)
       return Rels.takeError();
     for (const Elf_Rela &Rel : *Rels) {
       ELFYAML::Relocation R;
-      if (Error E = dumpRelocation(&Rel, SymTab, R))
+      if (Error E = dumpRelocation(&Rel, *SymTabOrErr, R))
         return std::move(E);
       R.Addend = Rel.r_addend;
-      S->Relocations.push_back(R);
+      S->Relocations->push_back(R);
     }
   }
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::RelrSection *>

 ELFDumper<ELFT>::dumpSymtabShndxSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::SymtabShndxSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto EntriesOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(*Shdr);
   if (!EntriesOrErr)
     return EntriesOrErr.takeError();
+
+  S->Entries.emplace();
   for (const Elf_Word &E : *EntriesOrErr)
-    S->Entries.push_back(E);
+    S->Entries->push_back(E);
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::NoBitsSection *>
 ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::NoBitsSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
-  S->Size = Shdr->sh_size;
-
+  if (Shdr->sh_size)
+    S->Size = static_cast<llvm::yaml::Hex64>(Shdr->sh_size);
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::NoteSection *>
 ELFDumper<ELFT>::dumpNoteSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::NoteSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
 
   auto S = std::make_unique<ELFYAML::SymverSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(*Shdr);
   if (!VersionsOrErr)
     return VersionsOrErr.takeError();
+
+  S->Entries.emplace();
   for (const Elf_Half &E : *VersionsOrErr)
-    S->Entries.push_back(E);
+    S->Entries->push_back(E);
 
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::VerneedSection *>
 ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
   typedef typename ELFT::Verneed Elf_Verneed;
ELFDumper<ELFT>::dumpGroupSection(const Elf_Shdr *Shdr) {
   if (!SymbolName)
     return SymbolName.takeError();
   S->Signature = *SymbolName;
 
   auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(*Shdr);
   if (!MembersOrErr)
     return MembersOrErr.takeError();
 
+  S->Members.emplace();
   for (Elf_Word Member : *MembersOrErr) {
     if (Member == llvm::ELF::GRP_COMDAT) {
-      S->Members.push_back({"GRP_COMDAT"});
+      S->Members->push_back({"GRP_COMDAT"});
       continue;
     }
 
     auto SHdrOrErr = Obj.getSection(Member);
     if (!SHdrOrErr)
       return SHdrOrErr.takeError();
     auto NameOrErr = getUniquedSectionName(*SHdrOrErr);
     if (!NameOrErr)
       return NameOrErr.takeError();
-    S->Members.push_back({*NameOrErr});
+    S->Members->push_back({*NameOrErr});
   }
   return S.release();
 }
 
 template <class ELFT>
 Expected<ELFYAML::ARMIndexTableSection *>
 ELFDumper<ELFT>::dumpARMIndexTableSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::ARMIndexTableSection>();