[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

256

from the -> from a

260

into -> in

265–266

from the -> from a

llvm/lib/ObjectYAML/ELFEmitter.cpp

1066

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."?

1067

but the "NBuckets"

1068

what -> which

1076

I'd expand this comment a bit:

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

1080

Just like above -> As above

1081

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

1093

bloom -> Bloom

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

1094

What if BloomFilter is None?

1099

Ditto.

1103

Ditto.

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

87–88

it, also -> it. Also,

101

broken, it -> broken: it

125

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

212–214

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.

228–230

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.

249

bloom -> Bloom

[grimar]

• Addressd review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1094

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.

1099

Ditto.

1103

Ditto.

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

125

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

212–214

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!)

228–230

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

1094

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/ELFYAML.h

struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
     Note,
     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 a YAML document.
+  Optional<llvm::yaml::Hex32> NBuckets;
+
+  // Index of the first symbol in the dynamic symbol table
+  // included in 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 a 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::NoteEntry> {
   static void mapping(IO &IO, ELFYAML::NoteEntry &N);
 };
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

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::NoteSection &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::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::NoteSection>(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,
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
   for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
     // Write name size.
     if (NE.Name.empty())
       support::endian::write<uint32_t>(OS, 0, ELFT::TargetEndianness);
     else
       support::endian::write<uint32_t>(OS, NE.Name.size() + 1,
                                        ELFT::TargetEndianness);
 
     // Write description size.
     if (NE.Desc.binary_size() == 0)
       support::endian::write<uint32_t>(OS, 0, ELFT::TargetEndianness);
     else
       support::endian::write<uint32_t>(OS, NE.Desc.binary_size(),
                                        ELFT::TargetEndianness);
 
     // Write type.
     support::endian::write<uint32_t>(OS, NE.Type, ELFT::TargetEndianness);
 
     // Write name, null terminator and padding.
     if (!NE.Name.empty()) {
       support::endian::write<uint8_t>(OS, arrayRefFromStringRef(NE.Name),
                                       ELFT::TargetEndianness);
       support::endian::write<uint8_t>(OS, 0, ELFT::TargetEndianness);
       CBA.padToAlignment(4);
     }
 
     // Write description and padding.
     if (NE.Desc.binary_size() != 0) {
       NE.Desc.writeAsBinary(OS);
       CBA.padToAlignment(4);
     }
   }
 
   SHeader.sh_size = OS.tell() - Offset;
 }
 
+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, starting with the hash buckets count. Normally
+  // it is the number of entries in HashBuckets, but the "NBuckets" property can
+  // be used to override this field, which is useful for producing broken
+  // objects.
+  if (Section.Header->NBuckets)
+    support::endian::write<uint32_t>(OS, *Section.Header->NBuckets,
+                                     ELFT::TargetEndianness);
+  else
+    support::endian::write<uint32_t>(OS, Section.HashBuckets->size(),
+                                     ELFT::TargetEndianness);
+
+  // Write the index of the first symbol in the dynamic symbol table accessible
+  // via the hash table.
+  support::endian::write<uint32_t>(OS, Section.Header->SymNdx,
+                                   ELFT::TargetEndianness);
+
+  // Write the number of words in the Bloom filter. As above, the "MaskWords"
+  // property can be used to set this field to any value.
+  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. Now 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::NoteSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Notes", Section.Notes);
 }
 
+
+static void sectionMapping(IO &IO, ELFYAML::GnuHashSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Header", Section.Header);
+  IO.mapOptional("BloomFilter", Section.BloomFilter);
+  IO.mapOptional("HashBuckets", Section.HashBuckets);
+  IO.mapOptional("HashValues", Section.HashValues);
+}
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Info", Section.Info);
if (!IO.outputting())
       Section.reset(new ELFYAML::HashSection());
     sectionMapping(IO, *cast<ELFYAML::HashSection>(Section.get()));
     break;
   case ELF::SHT_NOTE:
     if (!IO.outputting())
       Section.reset(new ELFYAML::NoteSection());
     sectionMapping(IO, *cast<ELFYAML::NoteSection>(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 (NS->Size && NS->Content &&
       return "\"Size\" must be greater than or equal to the content "
              "size";
 
     if (NS->Notes)
       return "\"Notes\" cannot be used with \"Content\" or \"Size\"";
     return {};
   }
 
+  if (const auto *Sec = dyn_cast<ELFYAML::GnuHashSection>(Section.get())) {
+    if (!Sec->Content && !Sec->Header && !Sec->BloomFilter &&
+        !Sec->HashBuckets && !Sec->HashValues)
+      return "either \"Content\" or \"Header\", \"BloomFilter\", "
+             "\"HashBuckets\" and \"HashBuckets\" must be specified";
+
+    if (Sec->Header || Sec->BloomFilter || Sec->HashBuckets ||
+        Sec->HashValues) {
+      if (!Sec->Header || !Sec->BloomFilter || !Sec->HashBuckets ||
+          !Sec->HashValues)
+        return "\"Header\", \"BloomFilter\", "
+               "\"HashBuckets\" and \"HashValues\" must be used together";
+      if (Sec->Content)
+        return "\"Header\", \"BloomFilter\", "
+               "\"HashBuckets\" and \"HashValues\" can't be used together with "
+               "\"Content\"";
+      return {};
+    }
+
+    // Only Content is specified.
+    return {};
+  }
+
   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/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 4: 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 we use the various properties to dump the data when it
+## has a size that is a multiple of 4, 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.no.header
+    Type:  SHT_GNU_HASH
+    BloomFilter: []
+    HashBuckets: []
+    HashValues: []
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.no.bloomfilter
+    Type:  SHT_GNU_HASH
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+    HashBuckets: []
+    HashValues: []
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.no.nobuckets
+    Type:  SHT_GNU_HASH
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+    BloomFilter: []
+    HashValues: []
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .gnu.hash.no.novalues
+    Type:  SHT_GNU_HASH
+    Header:
+      SymNdx: 0x0
+      Shift2: 0x0
+    BloomFilter: []
+    HashBuckets: []
+
+## 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::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::NoteSection *> dumpNoteSection(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);