[yaml2obj][ELF] - Simplify the code that performs sections validation.

[grimar]

Summary

This:

1. Changes the return type of MappingTraits<T>>::validate to std::string

instead of StringRef. It allows to create more complex error messages.

2. It introduces std::vector<std::pair<StringRef, bool>> getEntries():

a new virtual method of Section, which is the base class for all sections.
It returns names of special section specific keys (e.g. "Entries") and flags that says if them exist in a YAML.
The code in validate() uses this list of entries descriptions to generalize validation.
This approach was discussed in the D89039 thread.

[MaskRay]

Implements one of approaches discussed in the D89039 thread, which allows to generalize sections validation.

Probably just copy some messages from https://reviews.llvm.org/D89039#inline-828862 to make the description self-contained

In short, this moves a bunch of checks from MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate to *::getEntries

llvm/lib/ObjectYAML/DWARFYAML.cpp

311

Seems inconsistent with {} you use below..

[grimar]

In D89463#2333696, @MaskRay wrote:

Implements one of approaches discussed in the D89039 thread, which allows to generalize sections validation.

Probably just copy some messages from https://reviews.llvm.org/D89039#inline-828862 to make the description self-contained

Will do.

In short, this moves a bunch of checks from MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate to *::getEntries

I'd say that checks are not moved. *::getEntries is a new virtual method of Section, which is the base class for all sections.
It just returns names of special section specific keys (e.g. "Entries") and flags that says if them exist in a YAML.
The code in validate() uses this list of entries descriptions to generalize validation. The validation and error reporting is still performed in validate().

[MaskRay]

LGTM.

[jhenderson]

Just seen you committed it whilst I was mid review. My comments still stand :-)

llvm/include/llvm/ObjectYAML/ELFYAML.h

196–197

198

Maybe rather than a vector of pairs, a StringMap<bool> might be more straightforward. Not sure if order is an issue though.

245

Seems more easily understandable to me. Same throughout.

llvm/lib/ObjectYAML/DWARFYAML.cpp

311

FWIW, I'd prefer "" throuhgout since it's more readable (you don't have to refer to the return type to figure out that it's a string-like thing), but don't feel strongly about it.

llvm/lib/ObjectYAML/ELFYAML.cpp

1440

Traditional LLVM style says to precalculate the size, rather than to do it on each iteration of the loop.

[grimar]

In D89463#2341129, @jhenderson wrote:

Just seen you committed it whilst I was mid review. My comments still stand :-)

Sorry! I'll address them soon.

[grimar]

Post commit comments are addressed in rG3be2b0d1a1e0b94e8586f695e8174f139f7a84d8

llvm/include/llvm/ObjectYAML/ELFYAML.h

198

I think the order might be an issue as we build and then check errors we report. I am not sure anout using map,
as this method is only useful for validate() where we want to iterate over all entries and never to lookup a particular name.
If you really want, I think I can replace it with MapVector<StrinfRef, bool> though.

llvm/lib/ObjectYAML/DWARFYAML.cpp

311

I've switched to using "" in other places too for consistency. Perhaps, for string types it is a more natural empty value than {}.

[RKSimon]

@grimar This appears to be affecting clang-tidy unit tests - please can you take a look?

http://lab.llvm.org:8011/#/builders/109/builds/770
http://lab.llvm.org:8011/#/builders/109/builds/783

[grimar]

In D89463#2341531, @RKSimon wrote:

@grimar This appears to be affecting clang-tidy unit tests - please can you take a look?

http://lab.llvm.org:8011/#/builders/109/builds/770
http://lab.llvm.org:8011/#/builders/109/builds/783

Sorry. Reverting right now.

lld/lib/ReaderWriter/MachO/MachONormalizedFileYAML.cpp

static void mapping(IO &io, NormalizedFile &file) {
     io.mapOptional("page-size",        file.pageSize,       Hex32(4096));
     io.mapOptional("rebasings",        file.rebasingInfo);
     io.mapOptional("bindings",         file.bindingInfo);
     io.mapOptional("weak-bindings",    file.weakBindingInfo);
     io.mapOptional("lazy-bindings",    file.lazyBindingInfo);
     io.mapOptional("exports",          file.exportInfo);
     io.mapOptional("dataInCode",       file.dataInCode);
   }
-  static StringRef validate(IO &io, NormalizedFile &file) {
-    return StringRef();
-  }
+  static std::string validate(IO &io, NormalizedFile &file) { return {}; }
 };
 
 } // namespace llvm
 } // namespace yaml
 
 
 namespace lld {
 namespace mach_o {

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 template <typename EntryType>
 struct MappingTraits<DWARFYAML::ListTable<EntryType>> {
   static void mapping(IO &IO, DWARFYAML::ListTable<EntryType> &ListTable);
 };
 
 template <typename EntryType>
 struct MappingTraits<DWARFYAML::ListEntries<EntryType>> {
   static void mapping(IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries);
-  static StringRef validate(IO &IO,
+  static std::string validate(IO &IO,
                               DWARFYAML::ListEntries<EntryType> &ListEntries);
 };
 
 template <> struct MappingTraits<DWARFYAML::RnglistEntry> {
   static void mapping(IO &IO, DWARFYAML::RnglistEntry &RnglistEntry);
 };
 
 template <> struct MappingTraits<DWARFYAML::LoclistEntry> {
   static void mapping(IO &IO, DWARFYAML::LoclistEntry &LoclistEntry);

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct Section : public Chunk {
   // Holds the original section index.
   unsigned OriginalSecNdx;
 
   Section(ChunkKind Kind, bool IsImplicit = false)
       : Chunk(Kind), IsImplicit(IsImplicit) {}
 
   static bool classof(const Chunk *S) { return S->Kind != ChunkKind::Fill; }
 
+  // Some derived sections might have own special entries. This method returns
+  // vector of <entry name, is used> pairs. It is used for sections validation.
+  virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
+    return {};
+  };
+
   // The following members are used to override section fields which is
   // useful for creating invalid objects.
 
   // This can be used to override the offset stored in the sh_name field.
   // It does not affect the name stored in the string table.
   Optional<llvm::yaml::Hex64> ShName;
 
   // This can be used to override the sh_offset field. It does not place the
struct Fill : Chunk {
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
 };
 
 struct StackSizesSection : Section {
   Optional<std::vector<StackSizeEntry>> Entries;
 
   StackSizesSection() : Section(ChunkKind::StackSizes) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::StackSizes;
   }
 
   static bool nameMatches(StringRef Name) {
     return Name == ".stack_sizes";
   }
 };
 
 struct DynamicSection : Section {
   Optional<std::vector<DynamicEntry>> Entries;
 
   DynamicSection() : Section(ChunkKind::Dynamic) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
 };
 
 struct RawContentSection : Section {
   Optional<llvm::yaml::Hex64> Info;
 
   RawContentSection() : Section(ChunkKind::RawContent) {}
 
struct NoBitsSection : Section {
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
 };
 
 struct NoteSection : Section {
   Optional<std::vector<ELFYAML::NoteEntry>> Notes;
 
   NoteSection() : Section(ChunkKind::Note) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Notes", !!Notes}};
+  };
+
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
 };
 
 struct HashSection : Section {
   Optional<std::vector<uint32_t>> Bucket;
   Optional<std::vector<uint32_t>> Chain;
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Bucket", !!Bucket}, {"Chain", !!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;
 
   HashSection() : Section(ChunkKind::Hash) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }

 struct GnuHashSection : Section {
   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) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Header", !!Header},
+            {"BloomFilter", !!BloomFilter},
+            {"HashBuckets", !!HashBuckets},
+            {"HashValues", !!HashValues}};
+  };
+
   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<std::vector<VerneedEntry>> VerneedV;
   llvm::yaml::Hex64 Info;
 
   VerneedSection() : Section(ChunkKind::Verneed) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Dependencies", !!VerneedV}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Verneed;
   }
 };
 
 struct AddrsigSection : Section {
   Optional<std::vector<YAMLFlowString>> Symbols;
 
   AddrsigSection() : Section(ChunkKind::Addrsig) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Symbols", !!Symbols}};
+  };
+
   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;
 
   LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Options", !!Options}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::LinkerOptions;
   }
 };
 
 struct DependentLibrariesSection : Section {
   Optional<std::vector<YAMLFlowString>> Libs;
 
   DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Libraries", !!Libs}};
+  };
+
   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;
 
   CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::CallGraphProfile;
   }
 };
 
 struct SymverSection : Section {
   Optional<std::vector<uint16_t>> Entries;
 
   SymverSection() : Section(ChunkKind::Symver) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   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;
 
   llvm::yaml::Hex64 Info;
 
   VerdefSection() : Section(ChunkKind::Verdef) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   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.
   Optional<std::vector<SectionOrType>> Members;
   Optional<StringRef> Signature; /* Info */
 
   GroupSection() : Section(ChunkKind::Group) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Members", !!Members}};
+  };
+
   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 {
   Optional<std::vector<Relocation>> Relocations;
   StringRef RelocatableSec; /* Info */
 
   RelocationSection() : Section(ChunkKind::Relocation) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Relocations", !!Relocations}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Relocation;
   }
 };
 
 struct RelrSection : Section {
   Optional<std::vector<llvm::yaml::Hex64>> Entries;
 
   RelrSection() : Section(ChunkKind::Relr) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::Relr;
   }
 };
 
 struct SymtabShndxSection : Section {
   Optional<std::vector<uint32_t>> Entries;
 
   SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   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;
 
   ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
 
+  std::vector<std::pair<StringRef, bool>> getEntries() const override {
+    return {{"Entries", !!Entries}};
+  };
+
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::ARMIndexTable;
   }
 };
 
 // Represents .MIPS.abiflags section
 struct MipsABIFlags : Section {
   llvm::yaml::Hex16 Version;

 
 template <>
 struct MappingTraits<ELFYAML::FileHeader> {
   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 };
 
 template <> struct MappingTraits<ELFYAML::SectionHeaderTable> {
   static void mapping(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
-  static StringRef validate(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
+  static std::string validate(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
 };
 
 template <> struct MappingTraits<ELFYAML::SectionHeader> {
   static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
 };
 
 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
-  static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
+  static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
 };
 
 template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
   static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
   static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);

 };
 
 template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
   static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
 };
 
 template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
   static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
-  static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
+  static std::string validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Object> {
   static void mapping(IO &IO, ELFYAML::Object &Object);
 };
 
 template <> struct MappingTraits<ELFYAML::SectionOrType> {

llvm/include/llvm/ObjectYAML/MachOYAML.h

 };
 
 template <> struct MappingTraits<MachOYAML::Relocation> {
   static void mapping(IO &IO, MachOYAML::Relocation &R);
 };
 
 template <> struct MappingTraits<MachOYAML::Section> {
   static void mapping(IO &IO, MachOYAML::Section &Section);
-  static StringRef validate(IO &io, MachOYAML::Section &Section);
+  static std::string validate(IO &io, MachOYAML::Section &Section);
 };
 
 template <> struct MappingTraits<MachOYAML::NListEntry> {
   static void mapping(IO &IO, MachOYAML::NListEntry &NListEntry);
 };
 
 template <> struct MappingTraits<MachO::build_tool_version> {
   static void mapping(IO &IO, MachO::build_tool_version &tool);

llvm/include/llvm/ObjectYAML/MinidumpYAML.h

static StringRef input(StringRef Scalar, void *,
                          MinidumpYAML::BlockStringRef &Text) {
     Text = Scalar;
     return "";
   }
 };
 
 template <> struct MappingTraits<std::unique_ptr<MinidumpYAML::Stream>> {
   static void mapping(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
-  static StringRef validate(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
+  static std::string validate(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
 };
 
 template <> struct MappingContextTraits<minidump::MemoryDescriptor, BinaryRef> {
   static void mapping(IO &IO, minidump::MemoryDescriptor &Memory,
                       BinaryRef &Content);
 };
 
 } // namespace yaml

llvm/include/llvm/Support/YAMLTraits.h

 ///         io.mapOptional("age",  s.age);
 ///       }
 ///     };
 template<class T>
 struct MappingTraits {
   // Must provide:
   // static void mapping(IO &io, T &fields);
   // Optionally may provide:
-  // static StringRef validate(IO &io, T &fields);
+  // static std::string validate(IO &io, T &fields);
   //
   // The optional flow flag will cause generated YAML to use a flow mapping
   // (e.g. { a: 0, b: 1 }):
   // static const bool flow = true;
 };
 
 /// This class is similar to MappingTraits<T> but allows you to pass in
 /// additional context for each map operation.  For example:
 ///
 ///     struct MappingContextTraits<MyStruct, MyContext> {
 ///       static void mapping(IO &io, MyStruct &s, MyContext &c) {
 ///         io.mapRequired("name", s.name);
 ///         io.mapRequired("size", s.size);
 ///         io.mapOptional("age",  s.age);
 ///         ++c.TimesMapped;
 ///       }
 ///     };
 template <class T, class Context> struct MappingContextTraits {
   // Must provide:
   // static void mapping(IO &io, T &fields, Context &Ctx);
   // Optionally may provide:
-  // static StringRef validate(IO &io, T &fields, Context &Ctx);
+  // static std::string validate(IO &io, T &fields, Context &Ctx);
   //
   // The optional flow flag will cause generated YAML to use a flow mapping
   // (e.g. { a: 0, b: 1 }):
   // static const bool flow = true;
 };
 
 /// This class should be specialized by any integral type that converts
 /// to/from a YAML scalar where there is a one-to-one mapping between
template <class T> struct has_MappingTraits<T, EmptyContext> {
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
 };
 
 // Test if MappingContextTraits<T>::validate() is defined on type T.
 template <class T, class Context> struct has_MappingValidateTraits {
-  using Signature_validate = StringRef (*)(class IO &, T &, Context &);
+  using Signature_validate = std::string (*)(class IO &, T &, Context &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate>*);
 
   template <typename U>
   static double test(...);
 
   static bool const value =
       (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
 };
 
 // Test if MappingTraits<T>::validate() is defined on type T.
 template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
-  using Signature_validate = StringRef (*)(class IO &, T &);
+  using Signature_validate = std::string (*)(class IO &, T &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate> *);
 
   template <typename U> static double test(...);
 
   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
 };

 template <typename T, typename Context>
 std::enable_if_t<validatedMappingTraits<T, Context>::value, void>
 yamlize(IO &io, T &Val, bool, Context &Ctx) {
   if (has_FlowTraits<MappingTraits<T>>::value)
     io.beginFlowMapping();
   else
     io.beginMapping();
   if (io.outputting()) {
-    StringRef Err = MappingTraits<T>::validate(io, Val);
+    std::string Err = MappingTraits<T>::validate(io, Val);
     if (!Err.empty()) {
       errs() << Err << "\n";
       assert(Err.empty() && "invalid struct trying to be written as yaml");
     }
   }
   detail::doMapping(io, Val, Ctx);
   if (!io.outputting()) {
-    StringRef Err = MappingTraits<T>::validate(io, Val);
+    std::string Err = MappingTraits<T>::validate(io, Val);
     if (!Err.empty())
       io.setError(Err);
   }
   if (has_FlowTraits<MappingTraits<T>>::value)
     io.endFlowMapping();
   else
     io.endMapping();
 }

llvm/lib/ObjectYAML/DWARFYAML.cpp

 template <typename EntryType>
 void MappingTraits<DWARFYAML::ListEntries<EntryType>>::mapping(
     IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries) {
   IO.mapOptional("Entries", ListEntries.Entries);
   IO.mapOptional("Content", ListEntries.Content);
 }
 
 template <typename EntryType>
-StringRef MappingTraits<DWARFYAML::ListEntries<EntryType>>::validate(
+std::string MappingTraits<DWARFYAML::ListEntries<EntryType>>::validate(
     IO &IO, DWARFYAML::ListEntries<EntryType> &ListEntries) {
   if (ListEntries.Entries && ListEntries.Content)
     return "Entries and Content can't be used together";
-  return StringRef();
+  return "";
 }
 
 template <typename EntryType>
 void MappingTraits<DWARFYAML::ListTable<EntryType>>::mapping(
     IO &IO, DWARFYAML::ListTable<EntryType> &ListTable) {
   IO.mapOptional("Format", ListTable.Format, dwarf::DWARF32);
   IO.mapOptional("Length", ListTable.Length);
   IO.mapOptional("Version", ListTable.Version, 5);

llvm/lib/ObjectYAML/ELFYAML.cpp

 
 void MappingTraits<ELFYAML::SectionHeaderTable>::mapping(
     IO &IO, ELFYAML::SectionHeaderTable &SectionHeader) {
   IO.mapOptional("Sections", SectionHeader.Sections);
   IO.mapOptional("Excluded", SectionHeader.Excluded);
   IO.mapOptional("NoHeaders", SectionHeader.NoHeaders);
 }
 
-StringRef MappingTraits<ELFYAML::SectionHeaderTable>::validate(
+std::string MappingTraits<ELFYAML::SectionHeaderTable>::validate(
     IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable) {
   if (SecHdrTable.NoHeaders && (SecHdrTable.Sections || SecHdrTable.Excluded))
     return "NoHeaders can't be used together with Sections/Excluded";
   if (!SecHdrTable.NoHeaders && !SecHdrTable.Sections && !SecHdrTable.Excluded)
     return "SectionHeaderTable can't be empty. Use 'NoHeaders' key to drop the "
            "section header table";
-  return StringRef();
+  return {};
 }
 
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
   IO.mapRequired("Class", FileHdr.Class);
   IO.mapRequired("Data", FileHdr.Data);
   IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
   IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
   // platforms, it can contain bit fields and regular values, or even sometimes a
   // crazy mix of them (see comments for NormalizedOther). Because of this, we
   // need special handling.
   MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
                                                                 Symbol.Other);
   IO.mapOptional("Other", Keys->Other);
 }
 
-StringRef MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
+std::string MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
                                                      ELFYAML::Symbol &Symbol) {
   if (Symbol.Index && Symbol.Section.data())
     return "Index and Section cannot both be specified for Symbol";
-  return StringRef();
+  return {};
 }
 
 static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
   IO.mapOptional("Name", Section.Name, StringRef());
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Flags", Section.Flags);
   IO.mapOptional("Address", Section.Address);
   IO.mapOptional("Link", Section.Link, StringRef());
default:
 
     if (auto S = dyn_cast<ELFYAML::RawContentSection>(Section.get()))
       sectionMapping(IO, *S);
     else
       sectionMapping(IO, *cast<ELFYAML::StackSizesSection>(Section.get()));
   }
 }
 
-StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
+std::string MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
   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())
     return "Section size must be greater than or equal to the content 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->Content || SS->Size) && SS->Entries)
-      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
-    return {};
-  }
-
-  if (const auto *HS = dyn_cast<ELFYAML::HashSection>(C.get())) {
-    if ((HS->Content || HS->Size) && (HS->Bucket || HS->Chain))
-      return "\"Bucket\" and \"Chain\" cannot be used with \"Content\" or "
-             "\"Size\"";
-    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->Content || Sec->Size) && Sec->Symbols)
-      return "\"Symbols\" cannot be used with \"Content\" or \"Size\"";
-    return {};
-  }
-
-  if (const auto *NS = dyn_cast<ELFYAML::NoteSection>(C.get())) {
-    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())) {
-    const bool HasSpecialFields =
-        Sec->Header || Sec->BloomFilter || Sec->HashBuckets || Sec->HashValues;
-    if (HasSpecialFields && (Sec->Content || Sec->Size))
-      return "\"Header\", \"BloomFilter\", "
-             "\"HashBuckets\" and \"HashValues\" can't be used together with "
-             "\"Content\" or \"Size\"";
-
-    if (HasSpecialFields && (!Sec->Header || !Sec->BloomFilter ||
-                             !Sec->HashBuckets || !Sec->HashValues))
-      return "\"Header\", \"BloomFilter\", "
-             "\"HashBuckets\" and \"HashValues\" must be used together";
-    return {};
-  }
-
-  if (const auto *Sec = dyn_cast<ELFYAML::LinkerOptionsSection>(C.get())) {
-    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->Content || Sec->Size) && Sec->Libs)
-      return "\"Libraries\" cannot be used with \"Content\" or \"Size\"";
-    return {};
-  }
-
-  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 *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 *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->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->Content || CGP->Size) && CGP->Entries)
-      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
-    return {};
+  auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {
+    std::string Msg;
+    for (size_t I = 0; I < EntV.size(); ++I) {
+      StringRef Name = EntV[I].first;
+      if (I == 0) {
+        Msg = "\"" + Name.str() + "\"";
+        continue;
       }
-
-  if (const auto *IT = dyn_cast<ELFYAML::ARMIndexTableSection>(C.get())) {
-    if ((IT->Content || IT->Size) && IT->Entries)
-      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
-    return {};
+      if (I != EntV.size() - 1)
+        Msg += ", \"" + Name.str() + "\"";
+      else
+        Msg += " and \"" + Name.str() + "\"";
     }
+    return Msg;
+  };
 
-  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 {};
-  }
+  std::vector<std::pair<StringRef, bool>> Entries = Sec.getEntries();
+  const size_t NumUsedEntries = llvm::count_if(
+      Entries, [](const std::pair<StringRef, bool> &P) { return P.second; });
+
+  if ((Sec.Size || Sec.Content) && NumUsedEntries > 0)
+    return BuildErrPrefix(Entries) +
+           " cannot be used with \"Content\" or \"Size\"";
 
-  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 (NumUsedEntries > 0 && Entries.size() != NumUsedEntries)
+    return BuildErrPrefix(Entries) + " must be used together";
 
-  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\"";
+  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 *NB = dyn_cast<ELFYAML::NoBitsSection>(C.get())) {
     if (NB->Content)
       return "SHT_NOBITS section cannot have \"Content\"";
     return {};
   }
 
-  if (const auto *DS = dyn_cast<ELFYAML::DynamicSection>(C.get())) {
-    if ((DS->Content || DS->Size) && DS->Entries)
-      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
-    return {};
-  }
-
   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 {};
   }

llvm/lib/ObjectYAML/MachOYAML.cpp

void MappingTraits<MachOYAML::Section>::mapping(IO &IO,
   IO.mapRequired("flags", Section.flags);
   IO.mapRequired("reserved1", Section.reserved1);
   IO.mapRequired("reserved2", Section.reserved2);
   IO.mapOptional("reserved3", Section.reserved3);
   IO.mapOptional("content", Section.content);
   IO.mapOptional("relocations", Section.relocations);
 }
 
-StringRef
+std::string
 MappingTraits<MachOYAML::Section>::validate(IO &IO,
                                             MachOYAML::Section &Section) {
   if (Section.content && Section.size < Section.content->binary_size())
     return "Section size must be greater than or equal to the content size";
   return {};
 }
 
 void MappingTraits<MachO::build_tool_version>::mapping(

llvm/lib/ObjectYAML/MinidumpYAML.cpp

void yaml::MappingTraits<ModuleListStream::entry_type>::mapping(
   mapOptionalHex(IO, "Reserved1", M.Entry.Reserved1, 0);
 }
 
 static void streamMapping(yaml::IO &IO, RawContentStream &Stream) {
   IO.mapOptional("Content", Stream.Content);
   IO.mapOptional("Size", Stream.Size, Stream.Content.binary_size());
 }
 
-static StringRef streamValidate(RawContentStream &Stream) {
+static std::string streamValidate(RawContentStream &Stream) {
   if (Stream.Size.value < Stream.Content.binary_size())
     return "Stream size must be greater or equal to the content size";
   return "";
 }
 
 void yaml::MappingTraits<MemoryListStream::entry_type>::mapping(
     IO &IO, MemoryListStream::entry_type &Range) {
   MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
case MinidumpYAML::Stream::StreamKind::TextContent:
     streamMapping(IO, llvm::cast<TextContentStream>(*S));
     break;
   case MinidumpYAML::Stream::StreamKind::ThreadList:
     streamMapping(IO, llvm::cast<ThreadListStream>(*S));
     break;
   }
 }
 
-StringRef yaml::MappingTraits<std::unique_ptr<Stream>>::validate(
+std::string yaml::MappingTraits<std::unique_ptr<Stream>>::validate(
     yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
   switch (S->Kind) {
   case MinidumpYAML::Stream::StreamKind::RawContent:
     return streamValidate(cast<RawContentStream>(*S));
   case MinidumpYAML::Stream::StreamKind::Exception:
   case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
   case MinidumpYAML::Stream::StreamKind::MemoryList:
   case MinidumpYAML::Stream::StreamKind::ModuleList:

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

 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
 
 ## Test that "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with the "Content" or "Size"
 
 # 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"
+# TOGETHER: error: "Header", "BloomFilter", "HashBuckets" and "HashValues" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .gnu.hash

llvm/unittests/Support/YAMLIOTest.cpp

 
 namespace llvm {
 namespace yaml {
   template <>
   struct MappingTraits<MyValidation> {
     static void mapping(IO &io, MyValidation &d) {
         io.mapRequired("value", d.value);
     }
-    static StringRef validate(IO &io, MyValidation &d) {
+    static std::string validate(IO &io, MyValidation &d) {
         if (d.value < 0)
           return "negative value";
-        return StringRef();
+        return {};
     }
   };
  }
 }
 
 
 //
 // Test that validate() is called and complains about the negative value.