[yaml2obj/obj2yaml] - Add support for SHT_HASH sections.

[grimar]

Summary

SHT_HASH specification is:
http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#hash

In short the format is the following: it has 2 uint32 fields in its header: nbucket and nchain followed
by (nbucket + nchain) uint32 values.

This patch allows dumping and parsing such sections.

[MaskRay]

SHT_HASH specification is: https://docs.oracle.com/cd/E23824_01/html/819-0690/chapter6-48031.html

Use the official one: http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#hash

tools/obj2yaml/elf2yaml.cpp

645

ELFT::Is64Bits ? 8 : 4

AddressSize is not used. A dummy 0 works as well.

646

Use getU32(Cur)

653

S->Bucket.emplace(NBucket);
for (uint32_t &V : *S->Bucket)
  V = Data.getU32(Cur);

663

if LLVM_ENABLE_ABI_BREAKING_CHECKS && !LLVM_ENABLE_ASSERTIONS, this will fail.

Add !Cur outside.

[jhenderson]

lib/ObjectYAML/ELFEmitter.cpp

824–825

Could it be possible to specify a custom sh_link value?

827

As with the stack sizes sections, it would be good if a user can specify the size explicitly.

841

Maybe rather than "4" here, this should be something like sizeof(Elf32_Word)?

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

26

"A non-empty hash table:"

35

fallbacks -> falls back
using "Content" -> using the "Content"

75

grater -> greater

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

3

desctibe -> describe
"a SHT_HASH section using the "Content" tag"

38

desctibe SHT_HASH -> describe a SHT_HASH section

65

What about "Content" and "Chain"?

69

I'd quote the names of the tags in the error messages (like you do in the comment above).

115

or -> nor

(use "or" with "either" and "nor" with "neither" to be strictly correct)

tools/obj2yaml/elf2yaml.cpp

648

4 -> sizeof (Elf32_Word)?

[grimar]

• Addressed review comments.

lib/ObjectYAML/ELFEmitter.cpp

824–825

I prepared a follow-up for this: D68214

827

I prepared a follow-up for this: D68216

841

I wouldn't do that. Spec says: "A hash table consists of Elf32_Word or Elf64_Word objects that provide for symbol table access."
I.e. we could use sizeof(typename ELFT::Word) here, but given that sizeof(Elf32_Word) == sizeof(Elf64_Word) == 4, what is the profit?
It does not make the code cleaner or more readable, using 4 instead looks much simpler.
For the same reason I used support::endian::write<uint32_t> instead of possible support::endian::write<typename ELFT::Word>

FWIW in LLD we do the same sometimes: https://github.com/llvm-mirror/lld/blob/master/ELF/SyntheticSections.cpp#L2421.

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

65

Seems I've forgot about this combination. Added a test.

69

Done.

tools/obj2yaml/elf2yaml.cpp

648

See my comment about this above.

663

I also used llvm_unreachable. It should be impossible to have any errors here.

[jhenderson]

LGTM, with a couple of minor points.

lib/ObjectYAML/ELFYAML.cpp

1214

and -> or

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

4

Missing trailing full stop.

[davezarzycki]

What platform was this tested on? This seems to be failing on my Fedora 31 x86_64 box:

FAIL: LLVM :: tools/obj2yaml/elf-hash-section.yaml (49646 of 58398)
******************** TEST 'LLVM :: tools/obj2yaml/elf-hash-section.yaml' FAILED ********************
Script:
--
: 'RUN: at line 7';   /tmp/_update_lc/t/bin/yaml2obj --docnum=1 /home/dave/s/lp/llvm/test/tools/obj2yaml/elf-hash-section.yaml -o /tmp/_update_lc/t/test/tools/obj2yaml/Output/elf-hash-section.yaml.tmp1
: 'RUN: at line 8';   /tmp/_update_lc/t/bin/obj2yaml /tmp/_update_lc/t/test/tools/obj2yaml/Output/elf-hash-section.yaml.tmp1 | /tmp/_update_lc/t/bin/FileCheck /home/dave/s/lp/llvm/test/tools/obj2yaml/elf-hash-section.yaml --check-prefix=CHAIN-BUCKET
: 'RUN: at line 38';   /tmp/_update_lc/t/bin/yaml2obj --docnum=2 /home/dave/s/lp/llvm/test/tools/obj2yaml/elf-hash-section.yaml -o /tmp/_update_lc/t/test/tools/obj2yaml/Output/elf-hash-section.yaml.tmp2
: 'RUN: at line 39';   /tmp/_update_lc/t/bin/obj2yaml /tmp/_update_lc/t/test/tools/obj2yaml/Output/elf-hash-section.yaml.tmp2 | /tmp/_update_lc/t/bin/FileCheck /home/dave/s/lp/llvm/test/tools/obj2yaml/elf-hash-section.yaml --check-prefix=CONTENT
--
Exit Code: 2

Command Output (stderr):
--
Program aborted due to an unhandled Error:
Error value was Success. (Note: Success values must still be checked prior to being destroyed).
Stack dump:
0.	Program arguments: /tmp/_update_lc/t/bin/obj2yaml /tmp/_update_lc/t/test/tools/obj2yaml/Output/elf-hash-section.yaml.tmp2 
 #0 0x000000000079e77f llvm::sys::PrintStackTrace(llvm::raw_ostream&) (/tmp/_update_lc/t/bin/obj2yaml+0x79e77f)
 #1 0x000000000079cd28 llvm::sys::RunSignalHandlers() (/tmp/_update_lc/t/bin/obj2yaml+0x79cd28)
 #2 0x000000000079ed41 SignalHandler(int) (/tmp/_update_lc/t/bin/obj2yaml+0x79ed41)
 #3 0x00007ffff7fa8b20 __restore_rt (/lib64/libpthread.so.0+0x14b20)
 #4 0x00007ffff618a625 raise (/lib64/libc.so.6+0x3c625)
 #5 0x00007ffff61738d9 abort (/lib64/libc.so.6+0x258d9)
 #6 0x0000000000766c56 llvm::Error::fatalUncheckedError() const (/tmp/_update_lc/t/bin/obj2yaml+0x766c56)
 #7 0x00000000005bfcaf (anonymous namespace)::ELFDumper<llvm::object::ELFType<(llvm::support::endianness)1, false> >::dump() (/tmp/_update_lc/t/bin/obj2yaml+0x5bfcaf)
 #8 0x00000000005b9e54 elf2yaml(llvm::raw_ostream&, llvm::object::ObjectFile const&) (/tmp/_update_lc/t/bin/obj2yaml+0x5b9e54)
 #9 0x00000000005b00a3 main (/tmp/_update_lc/t/bin/obj2yaml+0x5b00a3)
#10 0x00007ffff61751a3 __libc_start_main (/lib64/libc.so.6+0x271a3)
#11 0x00000000005aface _start (/tmp/_update_lc/t/bin/obj2yaml+0x5aface)
FileCheck error: '-' is empty.
FileCheck command line:  /tmp/_update_lc/t/bin/FileCheck /home/dave/s/lp/llvm/test/tools/obj2yaml/elf-hash-section.yaml --check-prefix=CONTENT

--

********************
Testing Time: 110.38s
********************
Failing Tests (1):
    LLVM :: tools/obj2yaml/elf-hash-section.yaml

  Expected Passes    : 42883
  Expected Failures  : 100
  Unsupported Tests  : 15414
  Unexpected Failures: 1

include/llvm/ObjectYAML/ELFYAML.h

 
 struct Section {
   enum class SectionKind {
     Dynamic,
     Group,
     RawContent,
     Relocation,
     NoBits,
+    Hash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags
   };
   SectionKind Kind;
struct NoBitsSection : Section {
 
   NoBitsSection() : Section(SectionKind::NoBits) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::NoBits;
   }
 };
 
+struct HashSection : Section {
+  Optional<yaml::BinaryRef> Content;
+  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 VernauxEntry {
   uint32_t Hash;
   uint16_t Flags;
   uint16_t Other;
   StringRef Name;
 };
 
 struct VerneedEntry {

lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::StackSizesSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::HashSection &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
 
if (I == 0) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymverSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } 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);  
+      writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::HashSection>(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(
   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
     support::endian::write<uintX_t>(OS, E.Address, ELFT::TargetEndianness);
     SHeader.sh_size += sizeof(uintX_t) + encodeULEB128(E.Size, OS);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
+                                         const ELFYAML::HashSection &Section,
+                                         ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  unsigned Link = 0;
+  if (SN2I.lookup(".dynsym", Link))
+    SHeader.sh_link = Link;
+
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(OS, Section.Content, None);
+    return;
+  }
+
+  support::endian::write<uint32_t>(OS, Section.Bucket->size(),
+                                   ELFT::TargetEndianness);
+  support::endian::write<uint32_t>(OS, Section.Chain->size(),
+                                   ELFT::TargetEndianness);
+  for (uint32_t Val : *Section.Bucket)
+    support::endian::write<uint32_t>(OS, Val, ELFT::TargetEndianness);
+  for (uint32_t Val : *Section.Chain)
+    support::endian::write<uint32_t>(OS, Val, ELFT::TargetEndianness);
+
+  SHeader.sh_size = (2 + Section.Bucket->size() + Section.Chain->size()) * 4;
+}
+
+template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerdefSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   uint64_t AuxCnt = 0;

lib/ObjectYAML/ELFYAML.cpp

 
 static void sectionMapping(IO &IO, ELFYAML::StackSizesSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
   IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Entries", Section.Entries);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Bucket", Section.Bucket);
+  IO.mapOptional("Chain", Section.Chain);
+}
+
 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::Group());
     groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
     break;
   case ELF::SHT_NOBITS:
     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_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 (!SS->Entries)
       return {};
 
     if (SS->Size)
       return ".stack_sizes: Size and Entries cannot be used together";
     if (SS->Content)
       return ".stack_sizes: Content and Entries cannot be used together";
     return {};
   }
+
+  if (const auto *HS = dyn_cast<ELFYAML::HashSection>(Section.get())) {
+    if (!HS->Content && !HS->Bucket && !HS->Chain)
+      return "one of Content, Bucket and Chain must be specified";
+
+    if (HS->Content) {
+      if (HS->Bucket)
+        return "Content and Bucket cannot be used together";
+      if (HS->Chain)
+        return "Content and Chain cannot be used together";
+      return {};
+    }
+
+    if ((HS->Bucket && !HS->Chain) || (!HS->Bucket && HS->Chain))
+      return "Bucket and Chain must be used together";
+    return {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

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

 Sections:
   - Name: progbits
     Type: SHT_PROGBITS
   - Name: rela
     Type: SHT_RELA
     Info: progbits
   - Name: hash
     Type: SHT_HASH
+    Content: ''
   - Name: dynamic
     Type: SHT_DYNAMIC
   - Name: note
     Type: SHT_NOTE
   - Name: nobits
     Type: SHT_NOBITS
   - Name: rel
     Type: SHT_REL

test/tools/llvm-size/elf-sysv.test

- Name:    .symtab
     ShSize:  0x18
     Address: 0x40000
   - Name:    .rela
     Type:    SHT_RELA
     ShSize:  0x20
     Address: 0x20000
   - Name:    .hash
     Type:    SHT_HASH
+    Content: ''
     ShSize:  0x40
     Address: 0x10000
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     ShSize:  0x80
     Address: 0x8000
   - Name:    .note
     Type:    SHT_NOTE

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

+## Check how obj2yaml produces SHT_HASH section descriptions.
+
+## Check that obj2yaml uses "Bucket" and "Chain" tags to describe
+## a SHT_HASH section when it has content of a correct size.
+## I.e. data size == 4 * (2 + nbucket + nchain).
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CHAIN-BUCKET
+
+# CHAIN-BUCKET:      - Name:  .hash1
+# CHAIN-BUCKET-NEXT:  Type:   SHT_HASH
+# CHAIN-BUCKET-NEXT:  Bucket: [ 3 ]
+# CHAIN-BUCKET-NEXT:  Chain:  [ 4, 5 ]
+# CHAIN-BUCKET:      - Name:  .hash2
+# CHAIN-BUCKET-NEXT:  Type:   SHT_HASH
+# CHAIN-BUCKET-NEXT:  Bucket: [  ]
+# CHAIN-BUCKET-NEXT:  Chain:  [  ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+## Case 1: A regular case sample: nbucket == 1, nchain == 2. 
+  - Name:    .hash1
+    Type:    SHT_HASH
+    Content: '0100000002000000030000000400000005000000'
+## Case 2: An empty hash table: nbucket == 0, nchain == 0.
+  - Name:    .hash2
+    Type:    SHT_HASH
+    Content: '0000000000000000'
+
+## Check that obj2yaml fallbacks to using "Content" tag when
+## hash sections are broken.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=CONTENT
+
+# CONTENT:      - Name:    .empty_hash
+# CONTENT-NEXT:   Type:    SHT_HASH
+# CONTENT-NEXT:   Content: ''
+# CONTENT-NEXT: - Name:    .invalid_header
+# CONTENT-NEXT:   Type:    SHT_HASH
+# CONTENT-NEXT:   Content: '00'
+# CONTENT-NEXT: - Name:    .truncated
+# CONTENT-NEXT:   Type:    SHT_HASH
+# CONTENT-NEXT:   Content: '01000000020000000300000004000000'
+# CONTENT-NEXT: - Name:    .oversized
+# CONTENT-NEXT:   Type:    SHT_HASH
+# CONTENT-NEXT:   Content: '0100000002000000030000000400000000'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+## Case 1: section has no data.
+  - Name:    .empty_hash
+    Type:    SHT_HASH
+    Content: ''
+## Case 2: section size is less than 2 * 4.
+  - Name:    .invalid_header
+    Type:    SHT_HASH
+    Content: '00'
+## Case 3: nbucket == 1, nchain == 2.
+##         Section size is less than (2 * nbucket + nchain) * 4.
+  - Name:    .truncated
+    Type:    SHT_HASH
+    Content: '01000000020000000300000004000000'
+## Case 4: nbucket == 1, nchain == 2.
+##         Section size is grater than (2 * nbucket + nchain) * 4.
+  - Name:    .oversized
+    Type:    SHT_HASH
+    Content: '0100000002000000030000000400000000'

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

+## Check how yaml2obj produces SHT_HASH sections.
+
+## Check we can desctibe SHT_HASH using "Content" tag.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=CONTENT
+
+# CONTENT:      Name: .hash
+# CONTENT-NEXT: Type: SHT_HASH
+# CONTENT-NEXT: Flags [
+# CONTENT-NEXT: ]
+# CONTENT-NEXT: Address: 0x0
+# CONTENT-NEXT: Offset: 0x44
+# CONTENT-NEXT: Size: 20
+# CONTENT-NEXT: Link: 1
+# CONTENT-NEXT: Info: 0
+# CONTENT-NEXT: AddressAlignment: 0
+# CONTENT-NEXT: EntrySize: 0
+# CONTENT-NEXT: SectionData (
+# CONTENT-NEXT:   0000: 01000000 02000000 03000000 04000000
+# CONTENT-NEXT:   0010: 05000000
+# CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+## SHT_HASH is linked to dynamic symbol table by default.
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+  - Name:    .hash
+    Type:    SHT_HASH
+    Content: '0100000002000000030000000400000005000000'
+
+## Check we can desctibe SHT_HASH using "Bucket" and "Chain" tags.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=BUCKET-CHAIN
+
+# BUCKET-CHAIN:      Name: .hash
+# BUCKET-CHAIN:      Size:
+# BUCKET-CHAIN-SAME: 28
+# BUCKET-CHAIN:      Link:
+# BUCKET-CHAIN-SAME: 0
+# BUCKET-CHAIN:      SectionData (
+# BUCKET-CHAIN-NEXT:   0000: 02000000 03000000 01000000 02000000  |
+# BUCKET-CHAIN-NEXT:   0010: 03000000 04000000 05000000           |
+# BUCKET-CHAIN-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:   .hash
+    Type:   SHT_HASH
+    Bucket: [ 1, 2 ]
+    Chain:  [ 3, 4, 5 ]
+
+## Check we can't use "Content" and "Bucket" tags together.
+
+# RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-BUCKET
+
+# CONTENT-BUCKET: error: Content and Bucket cannot be used together
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:   .hash
+    Type:   SHT_HASH
+    Bucket: [ 1 ]
+    Content: '00'
+
+## Check we can't use "Bucket" without "Chain".
+
+# RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=NO-BUCKET-OR-CHAIN
+
+# NO-BUCKET-OR-CHAIN: error: Bucket and Chain must be used together
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:   .hash
+    Type:   SHT_HASH
+    Bucket: [ 1 ]
+
+## Check we can't use "Chain" without "Bucket".
+
+# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=NO-BUCKET-OR-CHAIN
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .hash
+    Type:  SHT_HASH
+    Chain: [ 1 ]
+
+## Check we report an error if neither "Bucket", "Chain" or "Content" were set.
+
+# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
+
+# NO-TAGS: error: one of Content, Bucket and Chain must be specified
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_386
+Sections:
+  - Name:  .hash
+    Type:  SHT_HASH

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::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_NOBITS: {
       Expected<ELFYAML::NoBitsSection *> SecOrErr = dumpNoBitsSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
+    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_verdef: {
       Expected<ELFYAML::VerdefSection *> SecOrErr = dumpVerdefSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Sections.emplace_back(*SecOrErr);
       break;
     }
     case ELF::SHT_GNU_versym: {
ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
   S->Size = Shdr->sh_size;
 
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::HashSection *>
+ELFDumper<ELFT>::dumpHashSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::HashSection>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  auto ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+
+  ArrayRef<uint8_t> Content = *ContentOrErr;
+  if (Content.size() % 4 != 0 || Content.size() < 8) {
+    S->Content = yaml::BinaryRef(Content);
+    return S.release();
+  }
+
+  DataExtractor::Cursor Cur(0);
+  DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);
+  uint32_t NBucket = Data.getUnsigned(Cur, 4);
+  uint32_t NChain = Data.getUnsigned(Cur, 4);
+  if (Content.size() != (2 + NBucket + NChain) * 4) {
+    S->Content = yaml::BinaryRef(Content);
+    return S.release();
+  }
+
+  std::vector<uint32_t> Bucket;
+  while (NBucket--)
+    Bucket.push_back(Data.getUnsigned(Cur, 4));
+  S->Bucket = std::move(Bucket);
+
+  std::vector<uint32_t> Chain;
+  while (NChain--)
+    Chain.push_back(Data.getUnsigned(Cur, 4));
+  S->Chain = std::move(Chain);
+
+  assert(Cur && "entries were not read correctly");
+  return S.release();
+}
+
+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);