[yaml2obj/obj2yaml] - Add support for SHT_GNU_HASH section.

[grimar]

Summary

This adds parsing and dumping support for GNU hash sections.
They are described nicely here: https://blogs.oracle.com/solaris/gnu-hash-elf-sections-v2

Depends on https://reviews.llvm.org/D69558

[jhenderson]

The changes related to the LLVM_YAML_IS_SEQUENCE_VECTOR seems unrelated to the hash table stuff. Could it be a separate prerequisite change?

llvm/include/llvm/ObjectYAML/ELFYAML.h

240

from the -> from a

244

into -> in

249–250

from the -> from a

llvm/lib/ObjectYAML/ELFEmitter.cpp

1059

This reads a bit clunky to me. How about changing the first two sentences to "We write the header first, starting with the hash buckets count."?

1060

but the "NBuckets"

1061

what -> which

1069

I'd expand this comment a bit:

"Write the index of the first symbol in the dynamic symbol table accessible via the hash table."

1073

Just like above -> As above

1074

to put any value to this field -> to set this field to any value

1086

bloom -> Bloom

Perhaps change "Here we write" to "Now write"

1087

What if BloomFilter is None?

1092

Ditto.

1096

Ditto.

llvm/test/tools/obj2yaml/elf-gnu-hash-section.yaml

86–87

it, also -> it. Also,

100

broken, it -> broken: it

124

The examples to me don't specifically seem to be about the HashValues field? Surely this is just testing that the Content size is a multiple of 4?

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

211–213

This case should probably be broken into four (or more) separate cases: 1 tag missing for each of the four different tags in the group. As things stand, you don't show that BloomFilter is required if Header is specified, for example.

227–229

Similar to the above, this case should probably be broken up to show that each of the tags individually can't be used with Content.

248

bloom -> Bloom

[grimar]

• Addressd review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1087

It can't be None here.
See the code in validate() method below: BloomFilter, HashBuckets, HashValues and Header must be provided when there is no Content and must be used together.

1092

Ditto.

1096

Ditto.

llvm/test/tools/obj2yaml/elf-gnu-hash-section.yaml

124

The code in dumpGnuHashSection never checks that
the whole section data size is or isn't a multiple of 4 atm.

After reading the header, Bloom filter and buckets we have a piece of data left in the section.
(I called it "hash values data" in this comment)
It is assumed to contain hash values and hence it's size should be multiple of 4.
Only then I read it as a set of hash values:

ELFDumper<ELFT>::dumpGnuHashSection(const Elf_Shdr *Shdr) {
.....
  S->HashBuckets.emplace(NBuckets);
  for (llvm::yaml::Hex32 &Val : *S->HashBuckets)
    Val = Data.getU32(Cur);

  S->HashValues.emplace((Data.getData().size() - Cur.tell()) / 4);
  for (llvm::yaml::Hex32 &Val : *S->HashValues)
    Val = Data.getU32(Cur);

In theory, on this step if hash values data size is not a multiple of 4, we can read and dump it as a raw data,
but still emit the header, filter and buckets fields. I do not think it worth to do, but this is why I think
this is related to the "HashValues" field.

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

211–213

Ok. This test actually is a bit different, it's intention is to check that either "Content" or "Header", "BloomFilter", "HashBuckets" and "HashBuckets" must be specified. It must have no fields in the section description.

What you describe was supposed to be tested above (--docnums 4 to 7). Though YAMLs there had only a single tag, what probably did not test
the idea you describe properly. I've changed them to have 3 of 4 fields in each YAML. (And this helped to fix a mistype bug :), thanks!)

227–229

Probably no, because here we check the following error message:
'error: "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content"'

If I splitted this case it would be impossible to trigger it, because another message would be shown:
'"Header", "BloomFilter", "HashBuckets" and "HashValues" must be used together'

And for the latter message I am already testing each field separatelly above.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1087

Right, sorry, got my timeline wrong on what methods can get called when.

llvm/test/tools/obj2yaml/elf-gnu-hash-section.yaml

88

"Also the" -> "Also, the"

125

Okay, I think this comment needs rephrasing. How about:

"Check that we use the various properties to dump the data when it has a size that is a multiple of 4, but fallback to..."

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

138

.gnu.hash.no.header?

151

.gnu.hash.no.bloomfilter?

166

.gnu.hash.no.nobuckets?

181

.gnu.hash.no.novalues?

261

This bloom hasn't been changed to Bloom.

[grimar]

• Addressed review comments.

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

138

Right, thanks.

261

Done. Sorry.

[jhenderson]

LGTM.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

struct Data {
   std::vector<LineTable> DebugLines;
 
   bool isEmpty() const;
 };
 
 } // end namespace DWARFYAML
 } // end namespace llvm
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)

llvm/include/llvm/ObjectYAML/ELFYAML.h

 struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
     Hash,
+    GnuHash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags,
     Addrsig
   };
struct HashSection : Section {
   Optional<std::vector<uint32_t>> Bucket;
   Optional<std::vector<uint32_t>> Chain;
 
   HashSection() : Section(SectionKind::Hash) {}
 
   static bool classof(const Section *S) { return S->Kind == SectionKind::Hash; }
 };
 
+struct GnuHashHeader {
+  // The number of hash buckets.
+  // Not used when dumping the object, but can be used to override
+  // the real number of buckets when emiting an object from the YAML document.
+  Optional<llvm::yaml::Hex32> NBuckets;
+
+  // Index of the first symbol in the dynamic symbol table
+  // included into the hash table.
+  llvm::yaml::Hex32 SymNdx;
+
+  // The number of words in the Bloom filter.
+  // Not used when dumping the object, but can be used to override
+  // the real number of words in the Bloom filter when emiting an object from
+  // the YAML 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(SectionKind::GnuHash) {}
+
+  static bool classof(const Section *S) { return S->Kind == SectionKind::GnuHash; }
+};
+
 struct VernauxEntry {
   uint32_t Hash;
   uint16_t Flags;
   uint16_t Other;
   StringRef Name;
 };
 
 struct VerneedEntry {
struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
   static StringRef 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::DynamicEntry> {
   static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::VerdefEntry> {
   static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
 };
 

llvm/include/llvm/Support/YAMLTraits.h

#define LLVM_YAML_IS_STRING_MAP(_type)                                         \
   namespace llvm {                                                             \
   namespace yaml {                                                             \
   template <>                                                                  \
   struct CustomMappingTraits<std::map<std::string, _type>>                     \
       : public StdMapStringCustomMappingTraitsImpl<_type> {};                  \
   }                                                                            \
   }
 
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex64)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex32)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::yaml::Hex8)
+
 #endif // LLVM_SUPPORT_YAMLTRAITS_H

llvm/lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::StackSizesSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::HashSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::AddrsigSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::GnuHashSection &Section,
+                           ContiguousBlobAccumulator &CBA);
 
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
for (size_t I = 0; I < Doc.Sections.size(); ++I) {
     } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::StackSizesSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::HashSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::AddrsigSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::GnuHashSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else {
       llvm_unreachable("Unknown section type");
     }
 
     // Override the fields if requested.
     if (Sec) {
       if (Sec->ShName)
         SHeader.sh_name = *Sec->ShName;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   for (const ELFYAML::AddrsigSymbol &Sym : *Section.Symbols) {
     uint64_t Val =
         Sym.Name ? toSymbolIndex(*Sym.Name, Section.Name, /*IsDynamic=*/false)
                  : (uint32_t)*Sym.Index;
     SHeader.sh_size += encodeULEB128(Val, OS);
   }
 }
 
+template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
+                                         const ELFYAML::GnuHashSection &Section,
+                                         ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  unsigned Link = 0;
+  if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))
+    SHeader.sh_link = Link;
+
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(OS, Section.Content, None);
+    return;
+  }
+
+  // We write the header first. Here we write hash buckets count. Normally it is
+  // the number of entries in HashBuckets, but "NBuckets" property can be
+  // used to override this field, what is useful for producing broken objects.
+  if (Section.Header->NBuckets)
+    support::endian::write<uint32_t>(OS, *Section.Header->NBuckets,
+                                     ELFT::TargetEndianness);
+  else
+    support::endian::write<uint32_t>(OS, Section.HashBuckets->size(),
+                                     ELFT::TargetEndianness);
+
+  // Write index of the first symbol in the dynamic symbol table.
+  support::endian::write<uint32_t>(OS, Section.Header->SymNdx,
+                                   ELFT::TargetEndianness);
+
+  // Write the number of words in the Bloom filter. Just like above, the
+  // "MaskWords" property can be used to put any value to this field.
+  if (Section.Header->MaskWords)
+    support::endian::write<uint32_t>(OS, *Section.Header->MaskWords,
+                                     ELFT::TargetEndianness);
+  else
+    support::endian::write<uint32_t>(OS, Section.BloomFilter->size(),
+                                     ELFT::TargetEndianness);
+
+  // Write the shift constant used by the Bloom filter.
+  support::endian::write<uint32_t>(OS, Section.Header->Shift2,
+                                   ELFT::TargetEndianness);
+
+  // We've finished writing the header. Here we write the bloom filter.
+  for (llvm::yaml::Hex64 Val : *Section.BloomFilter)
+    support::endian::write<typename ELFT::uint>(OS, Val,
+                                                ELFT::TargetEndianness);
+
+  // Write an array of hash buckets.
+  for (llvm::yaml::Hex32 Val : *Section.HashBuckets)
+    support::endian::write<uint32_t>(OS, Val, ELFT::TargetEndianness);
+
+  // Write an array of hash values.
+  for (llvm::yaml::Hex32 Val : *Section.HashValues)
+    support::endian::write<uint32_t>(OS, Val, ELFT::TargetEndianness);
+
+  SHeader.sh_size = 16 /*Header size*/ +
+                    Section.BloomFilter->size() * sizeof(typename ELFT::uint) +
+                    Section.HashBuckets->size() * 4 +
+                    Section.HashValues->size() * 4;
+}
+
 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
   for (unsigned I = 0, E = Doc.Sections.size(); I != E; ++I) {
     StringRef Name = Doc.Sections[I]->Name;
     if (Name.empty())
       continue;
 
     DotShStrtab.add(ELFYAML::dropUniqueSuffix(Name));
     if (!SN2I.addName(Name, I))

llvm/lib/ObjectYAML/ELFYAML.cpp

 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);
 }
 
+
+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);
if (!IO.outputting())
       Section.reset(new ELFYAML::NoBitsSection());
     sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
     break;
   case ELF::SHT_HASH:
     if (!IO.outputting())
       Section.reset(new ELFYAML::HashSection());
     sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
     break;
+  case ELF::SHT_GNU_HASH:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::GnuHashSection());
+    sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));
+    break;
   case ELF::SHT_MIPS_ABIFLAGS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     break;
   case ELF::SHT_GNU_verdef:
     if (!IO.outputting())
       Section.reset(new ELFYAML::VerdefSection());
if (const auto *Sec = dyn_cast<ELFYAML::AddrsigSection>(Section.get())) {
 
     for (const ELFYAML::AddrsigSymbol &AS : *Sec->Symbols)
       if (AS.Index && AS.Name)
         return "\"Index\" and \"Name\" cannot be used together when defining a "
                "symbol";
     return {};
   }
 
+  if (const auto *Sec = dyn_cast<ELFYAML::GnuHashSection>(Section.get())) {
+    if (!Sec->Content && !Sec->Header && !Sec->BloomFilter &&
+        !Sec->HashBuckets && !Sec->HashValues)
+      return "either \"Content\" or \"Header\", \"BloomFilter\", "
+             "\"HashBuckets\" and \"HashBuckets\" must be specified";
+
+    if (Sec->Header || Sec->BloomFilter || Sec->HashBuckets ||
+        Sec->HashValues) {
+      if (!Sec->Header || !Sec->BloomFilter || !Sec->HashBuckets ||
+          !Sec->HashBuckets)
+        return "\"Header\", \"BloomFilter\", "
+               "\"HashBuckets\" and \"HashValues\" must be used together";
+      if (Sec->Content)
+        return "\"Header\", \"BloomFilter\", "
+               "\"HashBuckets\" and \"HashValues\" can't be used together with "
+               "\"Content\"";
+      return {};
+    }
+
+    // Only Content is specified.
+    return {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

 
 void MappingTraits<ELFYAML::StackSizeEntry>::mapping(
     IO &IO, ELFYAML::StackSizeEntry &E) {
   assert(IO.getContext() && "The IO context is not initialized");
   IO.mapOptional("Address", E.Address, Hex64(0));
   IO.mapRequired("Size", E.Size);
 }
 
+void MappingTraits<ELFYAML::GnuHashHeader>::mapping(IO &IO,
+                                                    ELFYAML::GnuHashHeader &E) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapOptional("NBuckets", E.NBuckets);
+  IO.mapRequired("SymNdx", E.SymNdx);
+  IO.mapOptional("MaskWords", E.MaskWords);
+  IO.mapRequired("Shift2", E.Shift2);
+}
+
 void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
                                                    ELFYAML::DynamicEntry &Rel) {
   assert(IO.getContext() && "The IO context is not initialized");
 
   IO.mapRequired("Tag", Rel.Tag);
   IO.mapRequired("Value", Rel.Val);
 }
 

llvm/test/ObjectYAML/MachO/DWARF-debug_info.yaml

 #CHECK:             - Value:           0x0000000000000046
 #CHECK:             - Value:           0x0000000100000F50
 #CHECK:             - Value:           0x0000000000000034
 #CHECK:         - AbbrCode:        0x00000002
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0000000100000F50
 #CHECK:             - Value:           0x0000000000000034
 #CHECK:             - Value:           0x0000000000000001
-#CHECK:               BlockData:       
-#CHECK:                 - 0x56
+#CHECK:               BlockData:       [ 0x56 ]
 #CHECK:             - Value:           0x0000000000000076
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000003
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000060
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:         - AbbrCode:        0x00000003
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0000000000000002
-#CHECK:               BlockData:       
-#CHECK:                 - 0x91
-#CHECK:                 - 0x78
+#CHECK:               BlockData:       [ 0x91, 0x78 ]
 #CHECK:             - Value:           0x000000000000007B
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000003
 #CHECK:             - Value:           0x0000000000000060
 #CHECK:         - AbbrCode:        0x00000003
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0000000000000002
-#CHECK:               BlockData:       
-#CHECK:                 - 0x91
-#CHECK:                 - 0x70
+#CHECK:               BlockData:       [ 0x91, 0x70 ]
 #CHECK:             - Value:           0x0000000000000080
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000003
 #CHECK:             - Value:           0x0000000000000067
 #CHECK:         - AbbrCode:        0x00000000
 #CHECK:           Values:          
 #CHECK:         - AbbrCode:        0x00000004
 #CHECK:           Values:          

llvm/test/ObjectYAML/MachO/DWARF2-AddrSize8-FormValues.yaml

 #CHECK:       Version:         2
 #CHECK:       AbbrOffset:      0
 #CHECK:       AddrSize:        8
 #CHECK:       Entries:         
 #CHECK:         - AbbrCode:        0x00000001
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0123456789ABCDEF
 #CHECK:             - Value:           0x000000000000000A
-#CHECK:               BlockData:       
-#CHECK:                 - 0x01
-#CHECK:                 - 0x02
-#CHECK:                 - 0x03
-#CHECK:                 - 0x04
-#CHECK:                 - 0x05
-#CHECK:                 - 0x06
-#CHECK:                 - 0x07
-#CHECK:                 - 0x08
-#CHECK:                 - 0x09
-#CHECK:                 - 0x00
+#CHECK:               BlockData:       [ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+#CHECK:                                  0x08, 0x09, 0x00 ]
 #CHECK:             - Value:           0x000000000000000A
-#CHECK:               BlockData:       
-#CHECK:                 - 0x01
-#CHECK:                 - 0x02
-#CHECK:                 - 0x03
-#CHECK:                 - 0x04
-#CHECK:                 - 0x05
-#CHECK:                 - 0x06
-#CHECK:                 - 0x07
-#CHECK:                 - 0x08
-#CHECK:                 - 0x09
-#CHECK:                 - 0x00
+#CHECK:               BlockData:       [ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+#CHECK:                                  0x08, 0x09, 0x00 ]
 #CHECK:             - Value:           0x000000000000000A
-#CHECK:               BlockData:       
-#CHECK:                 - 0x01
-#CHECK:                 - 0x02
-#CHECK:                 - 0x03
-#CHECK:                 - 0x04
-#CHECK:                 - 0x05
-#CHECK:                 - 0x06
-#CHECK:                 - 0x07
-#CHECK:                 - 0x08
-#CHECK:                 - 0x09
-#CHECK:                 - 0x00
+#CHECK:               BlockData:       [ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+#CHECK:                                  0x08, 0x09, 0x00 ]
 #CHECK:             - Value:           0x000000000000000A
-#CHECK:               BlockData:       
-#CHECK:                 - 0x01
-#CHECK:                 - 0x02
-#CHECK:                 - 0x03
-#CHECK:                 - 0x04
-#CHECK:                 - 0x05
-#CHECK:                 - 0x06
-#CHECK:                 - 0x07
-#CHECK:                 - 0x08
-#CHECK:                 - 0x09
-#CHECK:                 - 0x00
+#CHECK:               BlockData:       [ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+#CHECK:                                  0x08, 0x09, 0x00 ]
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000002345
 #CHECK:             - Value:           0x000000006789ABCD
 #CHECK:             - Value:           0x0011223344556677
 #CHECK:               CStr:            Hello
 #CHECK:             - Value:           0x0000000000000000
 #CHECK:             - Value:           0x0000000012345678
 #CHECK:             - Value:           0x0000000000000001

llvm/test/ObjectYAML/MachO/DWARF5-debug_info.yaml

 #CHECK:             - Value:           0x0000000000000046
 #CHECK:             - Value:           0x0000000100000F50
 #CHECK:             - Value:           0x0000000000000034
 #CHECK:         - AbbrCode:        0x00000002
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0000000100000F50
 #CHECK:             - Value:           0x0000000000000034
 #CHECK:             - Value:           0x0000000000000001
-#CHECK:               BlockData:       
-#CHECK:                 - 0x56
+#CHECK:               BlockData:       [ 0x56 ]
 #CHECK:             - Value:           0x0000000000000076
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000003
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000060
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:         - AbbrCode:        0x00000003
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0000000000000002
-#CHECK:               BlockData:       
-#CHECK:                 - 0x91
-#CHECK:                 - 0x78
+#CHECK:               BlockData:       [ 0x91, 0x78 ]
 #CHECK:             - Value:           0x000000000000007B
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000003
 #CHECK:             - Value:           0x0000000000000060
 #CHECK:         - AbbrCode:        0x00000003
 #CHECK:           Values:          
 #CHECK:             - Value:           0x0000000000000002
-#CHECK:               BlockData:       
-#CHECK:                 - 0x91
-#CHECK:                 - 0x70
+#CHECK:               BlockData:       [ 0x91, 0x70 ]
 #CHECK:             - Value:           0x0000000000000080
 #CHECK:             - Value:           0x0000000000000001
 #CHECK:             - Value:           0x0000000000000003
 #CHECK:             - Value:           0x0000000000000067
 #CHECK:         - AbbrCode:        0x00000000
 #CHECK:           Values:          
 #CHECK:         - AbbrCode:        0x00000004
 #CHECK:           Values:          

llvm/test/ObjectYAML/MachO/bind_opcode.yaml

 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__14coutE
 #CHECK:     - Opcode:          BIND_OPCODE_SET_TYPE_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000000
+#CHECK:       ULEBExtraData:   [ 0x0000000000000000 ]
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__15ctypeIcE2idE
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM

llvm/test/ObjectYAML/MachO/bogus_load_command.yaml

PayloadBytes:
       - 0x0C
 ...
 
 #CHECK:   - cmd:             0xDEADBEEF
 #CHECK:     cmdsize:         32
 #CHECK:     ZeroPadBytes:
 #CHECK:   - cmd:             0xDEADBEEF
 #CHECK:     cmdsize:         24
-#CHECK:     PayloadBytes:
-#CHECK:       - 0x01
-#CHECK:       - 0x02
-#CHECK:       - 0x03
-#CHECK:       - 0x04
-#CHECK:       - 0x05
-#CHECK:       - 0x06
-#CHECK:       - 0x07
-#CHECK:       - 0x08
-#CHECK:       - 0x09
-#CHECK:       - 0x0A
-#CHECK:       - 0x0B
-#CHECK:       - 0x0C
+#CHECK:     PayloadBytes:    [ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+#CHECK:                        0x09, 0x0A, 0x0B, 0x0C, 0x00, 0x00, 0x00, 0x00 ]
 #CHECK-NOT: LinkEditData:

llvm/test/ObjectYAML/MachO/lazy_bind_opcode.yaml

LazyBindOpcodes:
     - Opcode:          BIND_OPCODE_DONE
       Imm:             0
 ...
 
 #CHECK: LinkEditData:    
 #CHECK:   LazyBindOpcodes: 
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000028
+#CHECK:       ULEBExtraData:   [ 0x0000000000000028 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNKSt3__16locale9use_facetERNS0_2idE
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000030
+#CHECK:       ULEBExtraData:   [ 0x0000000000000030 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNKSt3__18ios_base6getlocEv
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000038
+#CHECK:       ULEBExtraData:   [ 0x0000000000000038 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000040
+#CHECK:       ULEBExtraData:   [ 0x0000000000000040 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000048
+#CHECK:       ULEBExtraData:   [ 0x0000000000000048 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000050
+#CHECK:       ULEBExtraData:   [ 0x0000000000000050 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000058
+#CHECK:       ULEBExtraData:   [ 0x0000000000000058 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__16localeD1Ev
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000060
+#CHECK:       ULEBExtraData:   [ 0x0000000000000060 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000068
+#CHECK:       ULEBExtraData:   [ 0x0000000000000068 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__18ios_base5clearEj
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000070
+#CHECK:       ULEBExtraData:   [ 0x0000000000000070 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZSt9terminatev
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000078
+#CHECK:       ULEBExtraData:   [ 0x0000000000000078 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          ___cxa_begin_catch
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000080
+#CHECK:       ULEBExtraData:   [ 0x0000000000000080 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          ___cxa_end_catch
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000088
+#CHECK:       ULEBExtraData:   [ 0x0000000000000088 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             2
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __Unwind_Resume
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000090
+#CHECK:       ULEBExtraData:   [ 0x0000000000000090 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             2
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          _memset
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000098
+#CHECK:       ULEBExtraData:   [ 0x0000000000000098 ]
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             2
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          _strlen
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_DONE
 #CHECK:       Imm:             0

llvm/test/ObjectYAML/MachO/out_of_order_linkedit.yaml

 #CHECK:     export_off:      13016
 #CHECK:     export_size:     48
 #CHECK: LinkEditData:    
 #CHECK:   RebaseOpcodes:   
 #CHECK:     - Opcode:          REBASE_OPCODE_SET_TYPE_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ExtraData:       
-#CHECK:         - 0x0000000000000028
+#CHECK:       ExtraData:       [ 0x0000000000000028 ]
 #CHECK:     - Opcode:          REBASE_OPCODE_DO_REBASE_ULEB_TIMES
 #CHECK:       Imm:             0
-#CHECK:       ExtraData:       
-#CHECK:         - 0x000000000000000F
+#CHECK:       ExtraData:       [ 0x000000000000000F ]
 #CHECK:     - Opcode:          REBASE_OPCODE_DONE
 #CHECK:       Imm:             0
 #CHECK:   BindOpcodes:     
 #CHECK:     - Opcode:          BIND_OPCODE_SET_DYLIB_ORDINAL_IMM
 #CHECK:       Imm:             1
 #CHECK:       Symbol:          ''
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__14coutE
 #CHECK:     - Opcode:          BIND_OPCODE_SET_TYPE_IMM
 #CHECK:       Imm:             1
 #CHECK:       Symbol:          ''
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000000
+#CHECK:       ULEBExtraData:   [ 0x0000000000000000 ]
 #CHECK:       Symbol:          ''
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          ''
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__15ctypeIcE2idE
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND

llvm/test/ObjectYAML/MachO/rebase_opcode.yaml

 ...
 
 #CHECK: LinkEditData:    
 #CHECK:   RebaseOpcodes:   
 #CHECK:     - Opcode:          REBASE_OPCODE_SET_TYPE_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ExtraData:       
-#CHECK:         - 0x0000000000000028
+#CHECK:       ExtraData:       [ 0x0000000000000028 ]
 #CHECK:     - Opcode:          REBASE_OPCODE_DO_REBASE_ULEB_TIMES
 #CHECK:       Imm:             0
-#CHECK:       ExtraData:       
-#CHECK:         - 0x000000000000000F
+#CHECK:       ExtraData:       [ 0x000000000000000F ]
 #CHECK:     - Opcode:          REBASE_OPCODE_DONE
 #CHECK:       Imm:             0

llvm/test/ObjectYAML/MachO/weak_bind_opcode.yaml

 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__14coutE
 #CHECK:     - Opcode:          BIND_OPCODE_SET_TYPE_IMM
 #CHECK:       Imm:             1
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB
 #CHECK:       Imm:             2
-#CHECK:       ULEBExtraData:   
-#CHECK:         - 0x0000000000000000
+#CHECK:       ULEBExtraData:   [ 0x0000000000000000 ]
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
 #CHECK:       Imm:             0
 #CHECK:       Symbol:          __ZNSt3__15ctypeIcE2idE
 #CHECK:     - Opcode:          BIND_OPCODE_DO_BIND
 #CHECK:       Imm:             0
 #CHECK:     - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM

llvm/test/tools/llvm-readobj/elf-section-types.test

Sections:
   - Name: part1
     Type: SHT_LLVM_PART_EHDR
   - Name: .phdrs
     Type: SHT_LLVM_PART_PHDR
   - Name: gnu_attributes
     Type: SHT_GNU_ATTRIBUTES
   - Name: gnu_hash
     Type: SHT_GNU_HASH
+    Content: ""
   - Name: gnu_verdef
     Type: SHT_GNU_verdef
     Info: 0
     Entries:
   - Name: gnu_verneed
     Type: SHT_GNU_verneed
     Info: 0
     Dependencies:

llvm/test/tools/obj2yaml/elf-gnu-hash-section.yaml

+## Check how obj2yaml produces SHT_GNU_HASH section descriptions.
+
+## Check that obj2yaml uses "Header", "BloomFilter", "HashBuckets" and "HashValues"
+## tags to describe a SHT_GNU_HASH section when it has content of a correct size.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=FIELDS
+
+# FIELDS:      - Name:   .gnu.hash
+# FIELDS-NEXT:     Type:   SHT_GNU_HASH
+# FIELDS-NEXT:     Flags:  [ SHF_ALLOC ]
+# FIELDS-NEXT:     Header:
+# FIELDS-NEXT:       SymNdx: 0x00000001
+# FIELDS-NEXT:       Shift2: 0x00000002
+# FIELDS-NEXT:     BloomFilter: [ 0x0000000000000003, 0x0000000000000004 ]
+# FIELDS-NEXT:     HashBuckets: [ 0x00000005, 0x00000006, 0x00000007 ]
+# FIELDS-NEXT:     HashValues:  [ 0x00000008, 0x00000009, 0x0000000A, 0x0000000B ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Flags: [ SHF_ALLOC ]
+    Header:
+      SymNdx: 0x1
+      Shift2: 0x2
+    BloomFilter: [0x3, 0x4]
+    HashBuckets: [0x5, 0x6, 0x7]
+    HashValues:  [0x8, 0x9, 0xA, 0xB]
+
+## Check how we handle broken cases.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
+
+# INVALID:      - Name:        .gnu.hash.tooshort
+# INVALID-NEXT:   Type:        SHT_GNU_HASH
+# INVALID-NEXT:   Flags:       [ SHF_ALLOC ]
+# INVALID-NEXT:   Content:     112233445566778899AABBCCDDEEFF
+# INVALID-NEXT: - Name:        .gnu.hash.empty
+# INVALID-NEXT:   Type:        SHT_GNU_HASH
+# INVALID-NEXT:   Flags:       [ SHF_ALLOC ]
+# INVALID-NEXT:   Header:
+# INVALID-NEXT:     SymNdx:      0x00000000
+# INVALID-NEXT:     Shift2:      0x00000000
+# INVALID-NEXT:   BloomFilter: [ ]
+# INVALID-NEXT:   HashBuckets: [ ]
+# INVALID-NEXT:   HashValues:  [ ]
+# INVALID-NEXT: - Name:        .gnu.hash.broken.maskwords
+# INVALID-NEXT:   Type:        SHT_GNU_HASH
+# INVALID-NEXT:   Content:     '00000000000000000100000000000000'
+# INVALID-NEXT: - Name:        .gnu.hash.broken.nbuckets
+# INVALID-NEXT:   Type:        SHT_GNU_HASH
+# INVALID-NEXT:   Content:     '01000000000000000000000000000000'
+# INVALID-NEXT: - Name:        .gnu.hash.hashvalues.ok
+# INVALID-NEXT:   Type:        SHT_GNU_HASH
+# INVALID-NEXT:   Header:
+# INVALID-NEXT:     SymNdx:      0x00000000
+# INVALID-NEXT:     Shift2:      0x00000000
+# INVALID-NEXT:   BloomFilter: [ ]
+# INVALID-NEXT:   HashBuckets: [ ]
+# INVALID-NEXT:   HashValues:  [ 0x00000000 ]
+# INVALID-NEXT: - Name:        .gnu.hash.hashvalues.fail
+# INVALID-NEXT:   Type:        SHT_GNU_HASH
+# INVALID-NEXT:   Content:     '000000000000000000000000000000000000000000'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+## Case 1: Content is less than 16 bytes.
+  - Name:   .gnu.hash.tooshort
+    Type:   SHT_GNU_HASH
+    Flags:  [ SHF_ALLOC ]
+    Content: "112233445566778899AABBCCDDEEFF"
+## Case2: Check how we handle a fully empty hash section.
+## It is almost technically valid, but uncommon. Modern linkers
+## create at least one entry in bloom filter if they want to disable it,
+## also the dynamic symbol table has a null entry and having SymNdx = 0
+## here is at least strange.
+  - Name:  .gnu.hash.empty
+    Type:  SHT_GNU_HASH
+    Flags: [ SHF_ALLOC ]
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+      MaskWords: 0x0
+      NBuckets:  0x0
+    BloomFilter: []
+    HashBuckets: []
+    HashValues:  []
+## Case 3: MaskWords field is broken, it says that the number of entries
+## in the bloom filter is 1, but the bloom filter is empty.
+  - Name:  .gnu.hash.broken.maskwords
+    Type:  SHT_GNU_HASH
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+      MaskWords: 0x1
+      NBuckets:  0x0
+    BloomFilter: []
+    HashBuckets: []
+    HashValues:  []
+## Case 3: NBuckets field is broken, it says that the number of entries
+## in the hash buckets is 1, but it is empty.
+  - Name:  .gnu.hash.broken.nbuckets
+    Type:  SHT_GNU_HASH
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+      MaskWords: 0x0
+      NBuckets:  0x1
+    BloomFilter: []
+    HashBuckets: []
+    HashValues:  []
+## Case 5: Check that when hash values data size contains a set of 4 byte words,
+## we use the "HashValues" property to dump it, but fallback to dumping the whole
+## section using the "Content" property otherwise.
+  - Name:  .gnu.hash.hashvalues.ok
+    Type:  SHT_GNU_HASH
+    Content: "0000000000000000000000000000000000000000"
+  - Name:  .gnu.hash.hashvalues.fail
+    Type:  SHT_GNU_HASH
+    Content: "000000000000000000000000000000000000000000"

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

+## Check how yaml2obj produces SHT_GNU_HASH sections.
+
+## Check we can describe a SHT_GNU_HASH section using the "Content" tag.
+## Check we set sh_link to index of the .dynsym by default.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=CONTENT
+
+# CONTENT:      Name: .gnu.hash
+# CONTENT-NEXT: Type: SHT_GNU_HASH
+# CONTENT-NEXT: Flags [
+# CONTENT-NEXT: ]
+# CONTENT-NEXT: Address: 0x0
+# CONTENT-NEXT: Offset: 0x40
+# CONTENT-NEXT: Size: 3
+# CONTENT-NEXT: Link: 4
+# CONTENT-NEXT: Info: 0
+# CONTENT-NEXT: AddressAlignment: 0
+# CONTENT-NEXT: EntrySize: 0
+# CONTENT-NEXT: SectionData (
+# CONTENT-NEXT:   0000: 001122 |
+# CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Content: "001122"
+## Used to trigger .dynsym creation.
+DynamicSymbols:
+  - Name:    foo
+    Binding: STB_GLOBAL
+
+## Check we can use "Header", "BloomFilter", "HashBuckets" and "HashValues" keys to describe
+## the hash section. Check we can set sh_link to any arbitrary value. Check both ELFCLASS32 and 64 bit output.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=CONTENT32
+# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=CONTENT64
+
+# CONTENT32:      Name: .gnu.hash
+# CONTENT32-NEXT: Type: SHT_GNU_HASH
+# CONTENT32-NEXT: Flags [
+# CONTENT32-NEXT:   SHF_ALLOC
+# CONTENT32-NEXT: ]
+# CONTENT32-NEXT: Address: 0x0
+# CONTENT32-NEXT: Offset: 0x34
+# CONTENT32-NEXT: Size: 52
+# CONTENT32-NEXT: Link: 254
+# CONTENT32-NEXT: Info: 0
+# CONTENT32-NEXT: AddressAlignment: 0
+# CONTENT32-NEXT: EntrySize: 0
+# CONTENT32-NEXT: SectionData (
+# CONTENT32-NEXT:   0000: 03000000 01000000 02000000 02000000 |
+# CONTENT32-NEXT:   0010: 03000000 04000000 05000000 06000000 |
+# CONTENT32-NEXT:   0020: 07000000 08000000 09000000 0A000000 |
+# CONTENT32-NEXT:   0030: 0B000000                            |
+# CONTENT32-NEXT: )
+
+# CONTENT64:      Name: .gnu.hash
+# CONTENT64-NEXT: Type: SHT_GNU_HASH
+# CONTENT64-NEXT: Flags [
+# CONTENT64-NEXT:   SHF_ALLOC
+# CONTENT64-NEXT: ]
+# CONTENT64-NEXT: Address: 0x0
+# CONTENT64-NEXT: Offset: 0x40
+# CONTENT64-NEXT: Size: 60
+# CONTENT64-NEXT: Link: 254
+# CONTENT64-NEXT: Info: 0
+# CONTENT64-NEXT: AddressAlignment: 0
+# CONTENT64-NEXT: EntrySize: 0
+# CONTENT64-NEXT: SectionData (
+# CONTENT64-NEXT:   0000: 03000000 01000000 02000000 02000000 |
+# CONTENT64-NEXT:   0010: 03000000 00000000 04000000 00000000 |
+# CONTENT64-NEXT:   0020: 05000000 06000000 07000000 08000000 |
+# CONTENT64-NEXT:   0030: 09000000 0A000000 0B000000          |
+# CONTENT64-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Flags: [ SHF_ALLOC ]
+    Header:
+      SymNdx: 0x1
+      Shift2: 0x2
+    BloomFilter: [0x3, 0x4]
+    HashBuckets: [0x5, 0x6, 0x7]
+    HashValues:  [0x8, 0x9, 0xA, 0xB]
+    Link: 0xFE
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Flags: [ SHF_ALLOC ]
+    Header:
+      SymNdx: 0x1
+      Shift2: 0x2
+    BloomFilter: [0x3, 0x4]
+    HashBuckets: [0x5, 0x6, 0x7]
+    HashValues:  [0x8, 0x9, 0xA, 0xB]
+    Link: 0xFE
+
+## Check we only can use "Header", "BloomFilter", "HashBuckets" and "HashValues" together.
+
+# RUN: not yaml2obj --docnum=4 %s -o %t4 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: not yaml2obj --docnum=5 %s -o %t5 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: not yaml2obj --docnum=6 %s -o %t6 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: not yaml2obj --docnum=7 %s -o %t7 2>&1 | FileCheck %s --check-prefix=ERR
+
+# ERR: error: "Header", "BloomFilter", "HashBuckets" and "HashValues" must be used together
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.only.header
+    Type:  SHT_GNU_HASH
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.only.bloomfilter
+    Type:  SHT_GNU_HASH
+    BloomFilter: []
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.only.hashbuckets
+    Type:  SHT_GNU_HASH
+    HashBuckets: []
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.only.hashvalues
+    Type:  SHT_GNU_HASH
+    HashValues: []
+
+## Check that "SymNdx" and "Shift2" fields are mandatory when we specify the "Header".
+
+# RUN: not yaml2obj --docnum=8 %s -o %t8 2>&1 | FileCheck %s --check-prefix=ERR2
+# ERR2: error: missing required key 'SymNdx'
+
+# RUN: not yaml2obj --docnum=9 %s -o %t9 2>&1 | FileCheck %s --check-prefix=ERR3
+# ERR3: error: missing required key 'Shift2'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Header:
+      Shift2: 0x0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_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
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+
+## Test that "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content".
+
+# 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"
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Content: ""
+    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
+## using the "NBuckets" and "Shift2" keys.
+
+# RUN: yaml2obj --docnum=12 %s -o %t12
+# RUN: llvm-readobj --sections --section-data %t12 | FileCheck %s --check-prefix=OVERRIDE-CONTENT
+
+# OVERRIDE-CONTENT:      Name: .gnu.hash
+# OVERRIDE-CONTENT:      SectionData (
+# OVERRIDE-CONTENT-NEXT:   0000: 01000000 02000000 03000000 04000000  |
+# OVERRIDE-CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+Sections:
+  - Name:  .gnu.hash
+    Type:  SHT_GNU_HASH
+    Header:
+      NBuckets:  0x1
+      SymNdx:    0x2
+      MaskWords: 0x3
+      Shift2:    0x4
+    BloomFilter: []
+    HashBuckets: []
+    HashValues:  []

llvm/tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RawContentSection *>
   dumpContentSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymtabShndxSection *>
   dumpSymtabShndxSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::HashSection *> dumpHashSection(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::GnuHashSection *> dumpGnuHashSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
   Expected<ELFYAML::StackSizesSection *>
   dumpStackSizesSection(const Elf_Shdr *Shdr);
 
for (const Elf_Shdr &Sec : Sections) {
     }
     case ELF::SHT_HASH: {
       Expected<ELFYAML::HashSection *> SecOrErr = dumpHashSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
+    case ELF::SHT_GNU_HASH: {
+      Expected<ELFYAML::GnuHashSection *> SecOrErr = dumpGnuHashSection(&Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      Y->Sections.emplace_back(*SecOrErr);
+      break;
+    }
     case ELF::SHT_GNU_verdef: {
       Expected<ELFYAML::VerdefSection *> SecOrErr = dumpVerdefSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_versym: {
for (uint32_t &V : *S->Chain)
     V = Data.getU32(Cur);
 
   if (Cur)
     return S.release();
   llvm_unreachable("entries were not read correctly");
 }
 
 template <class ELFT>
+Expected<ELFYAML::GnuHashSection *>
+ELFDumper<ELFT>::dumpGnuHashSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::GnuHashSection>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  auto ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+
+  unsigned AddrSize = ELFT::Is64Bits ? 8 : 4;
+  ArrayRef<uint8_t> Content = *ContentOrErr;
+  DataExtractor Data(Content, Obj.isLE(), AddrSize);
+
+  ELFYAML::GnuHashHeader Header;
+  DataExtractor::Cursor Cur(0);
+  uint32_t NBuckets = Data.getU32(Cur);
+  Header.SymNdx = Data.getU32(Cur);
+  uint32_t MaskWords = Data.getU32(Cur);
+  Header.Shift2 = Data.getU32(Cur);
+
+  // Set just the raw binary content if we were unable to read the header
+  // or when the section data is truncated or malformed.
+  uint64_t Size = Data.getData().size() - Cur.tell();
+  if (!Cur || (Size < MaskWords * AddrSize + NBuckets * 4) ||
+      (Size % 4 != 0)) {
+    consumeError(Cur.takeError());
+    S->Content = yaml::BinaryRef(Content);
+    return S.release();
+  }
+
+  S->Header = Header;
+
+  S->BloomFilter.emplace(MaskWords);
+  for (llvm::yaml::Hex64 &Val : *S->BloomFilter)
+    Val = Data.getAddress(Cur);
+
+  S->HashBuckets.emplace(NBuckets);
+  for (llvm::yaml::Hex32 &Val : *S->HashBuckets)
+    Val = Data.getU32(Cur);
+
+  S->HashValues.emplace((Data.getData().size() - Cur.tell()) / 4);
+  for (llvm::yaml::Hex32 &Val : *S->HashValues)
+    Val = Data.getU32(Cur);
+
+  if (Cur)
+    return S.release();
+  llvm_unreachable("GnuHashSection was not read correctly");
+}
+
+template <class ELFT>
 Expected<ELFYAML::VerdefSection *>
 ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
 
   auto S = std::make_unique<ELFYAML::VerdefSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);

llvm/unittests/Support/YAMLIOTest.cpp

TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 //
 // Test error handling reading built-in Hex8 type
 //
-LLVM_YAML_IS_SEQUENCE_VECTOR(Hex8)
 TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
   std::vector<Hex8> seq;
   Input yin("---\n"
             "- 0x12\n"
             "- 0xFE\n"
             "- 0x123\n"
             "...\n",
             /*Ctxt=*/nullptr,
TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 //
 // Test error handling reading built-in Hex32 type
 //
-LLVM_YAML_IS_SEQUENCE_VECTOR(Hex32)
 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
   std::vector<Hex32> seq;
   Input yin("---\n"
             "- 0x0012\n"
             "- 0xFEFF0000\n"
             "- 0x1234556789\n"
             "...\n",
             /*Ctxt=*/nullptr,
             suppressErrorMessages);
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 //
 // Test error handling reading built-in Hex64 type
 //
-LLVM_YAML_IS_SEQUENCE_VECTOR(Hex64)
 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
   std::vector<Hex64> seq;
   Input yin("---\n"
             "- 0x0012\n"
             "- 0xFFEEDDCCBBAA9988\n"
             "- 0x12345567890ABCDEF0\n"
             "...\n",
             /*Ctxt=*/nullptr,