[obj2yaml] [yaml2obj] Add yaml support for SHT_LLVM_BB_ADDR_MAP section.

[rahmanl]

Summary

YAML support allows us to better test the feature in the subsequent patches. The implementation is quite similar to the .stack_sizes section.

[rahmanl]

Remove the ELFDumper.cpp change.

[rahmanl]

Rebase.

[rahmanl]

• Add three more test cases to bb-addr-map.yaml.

[grimar]

Generally looks fine to me, I've put a few comments inline and also:

1. This needs a rebasing (D89039 was landed, it added support of "Size"/"Content" for all sections).
2. This needs yaml2obj tests. I think following are reasonable for initial support:
   • a) Check values of section fields produced by default (sh_link, sh_info, etc).
   • b) Check you can specify none of "Content", "Size" or "Entries" to produce an empty section.
   • c) Check you can specify only "Size", only "Content" or only "Entries" (see tests in D89039 and others).
   • d) Check you can't specify "Entries" with "Content"/"Size" (you need to add the code to validate(), see D89391).

llvm/lib/ObjectYAML/ELFEmitter.cpp

1311

1317

You don't need to have curly braces here.

llvm/lib/ObjectYAML/ELFYAML.cpp

1670

This needs a yaml2obj test to show that we can omit "Address" and it will accept it and produce "0" as address.

1672

I think you don't need NumBlock YAML key. It matches the number of items in "BBEntries", right?
E.g. see how we describe Notes (and other things):

- Name:  .note.foo
  Type:  SHT_NOTE
  Flags: [ SHF_ALLOC ]
  Notes:
    - Name: AB
      Desc: ''
      Type: 0xFF
    - Name: ABC
      Desc: '123456'
      Type: 254

llvm/test/tools/obj2yaml/ELF/bb-addr-map.yaml

148

Missing empty line before "--- !ELF"

157

I'd change 0x0000000000000010 to 0x0000000000000000 and demonstrate that
obj2yaml does not emit the "Address" key when it is 0x0. (I haven't check, but this is how I expect the code works now).

llvm/tools/obj2yaml/elf2yaml.cpp

511

Excessive empty line.

[jhenderson]

llvm/lib/ObjectYAML/ELFYAML.cpp

1672

Presumably if the NumBlock field corresponds to part of the data structure, we want it to be an Optional member, so that users can override it independently of the number of entries - that way tests can be crafted that show what happens if the value is invalid.

[rahmanl]

• Remove NumBlocks from the YAML key.
• Add yaml2obj test.

[rahmanl]

Thanks for your helpful comments @grimar.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1311

Adopted in the line above.

llvm/lib/ObjectYAML/ELFYAML.cpp

1670

Please look at the added test.

1672

Great suggestion. Thanks. Removed the NumBlocks YAML key, even though the field still shows up in the section data.

llvm/test/tools/obj2yaml/ELF/bb-addr-map.yaml

157

Thanks. It works as expected.

[rahmanl]

• Remove excessive empty line.

[grimar]

llvm/test/tools/obj2yaml/ELF/bb-addr-map.yaml

19

You don't need this line, since you are always using -NEXT and dump all output.

llvm/test/tools/yaml2obj/ELF/bb-addr-map.yaml

3 ↗

(On Diff #300821)

I'd move these 1-5 comments to YAML description though:

Sections:
## 1) We can produce a .llvm_bb_addr_map section from a description with section
##    content.
  - Name:    '.llvm_bb_addr_map (1)'
    Type:    SHT_LLVM_BB_ADDR_MAP
    Content: "000000000000000001010203"
## 2) We can produce an empty .llvm_bb_addr_map section from a description
##    swith empty section content.
  - Name:    '.llvm_bb_addr_map (2)'
    Type:    SHT_LLVM_BB_ADDR_MAP
...

112 ↗

(On Diff #300821)

You don't need (1) for this test.

114 ↗

(On Diff #300821)

I think you should be able to write just Entries: []. No need to provide more input data than needed.
The same for Context: a single byte should be enough for this test.

139 ↗

(On Diff #300821)

I'd merge last two YAMLs into one with the use of macros. I think something like the
following should work:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
Sections:
##  Specify Content and Entries
  - Name:    '.llvm_bb_addr_map'
    Type:    SHT_LLVM_BB_ADDR_MAP
    Entries: []
    Content: [[CONTENT=<none>]]
    Size:    [[SIZE=<none>]]

And then you can:

not yaml2obj --docnum=2 -DCONTENT="00"...
not yaml2obj --docnum=2 -DSIZE=0...

[grimar]

llvm/test/tools/yaml2obj/ELF/bb-addr-map.yaml

114 ↗

(On Diff #300821)

Or even: Content: ""

[jhenderson]

llvm/test/tools/obj2yaml/ELF/bb-addr-map.yaml

129

Same as above - the -NOT check is unnecessary due to the use of the -NEXT pattern throughout.

llvm/test/tools/yaml2obj/ELF/bb-addr-map.yaml

7 ↗

(On Diff #300821)

40 ↗

(On Diff #300821)

Watch out - this will also match Size: 10. You need extra regex patterns to make sure there are no preceding characters, e.g:

# CHECK:      Size:{{ }}
# CHECK-SAME: {{^}}0

(in this context the ^ character represents the end of the previous match).

llvm/tools/obj2yaml/elf2yaml.cpp

801

In the empty() case, I think it would be great to not specify Content or Entries, so that you end up with a section like this:

Name: .llvm_bb_addr_map
Type: SHT_LLVM_BB_ADDR_MAP

[rahmanl]

• Refine tests.

llvm/test/tools/yaml2obj/ELF/bb-addr-map.yaml

40 ↗

(On Diff #300821)

Thanks for the catch.
Applied your suggestion with some minor changes.

114 ↗

(On Diff #300821)

Used -DCONTENT="00"

139 ↗

(On Diff #300821)

Looks neat. Thanks.

[rahmanl]

llvm/tools/obj2yaml/elf2yaml.cpp

801

Checked for Content.empty() before jumping into the while loop.

[jhenderson]

LGTM, with a couple of nits.

llvm/test/tools/yaml2obj/ELF/bb-addr-map.yaml

59 ↗

(On Diff #302670)

Trivial nit: to me, the '.' is silent when I say this out loud, so it sounds like "an .llvm_bb_addr_map" would be better than "a .llvm_bb_addr_map". Same applies for point 4). Feel free to ignore.

99 ↗

(On Diff #302670)

Reads more cleanly to me.

[grimar]

LGTM too.

[rahmanl]

• Typos/Style fix.

[rahmanl]

Thank you @grimar and @jhenderson for the thorough feedback. I will start on llvm-readobj support once I submit this patch.

llvm/test/tools/yaml2obj/ELF/bb-addr-map.yaml

59 ↗

(On Diff #302670)

Fixed here and elsewhere.

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

1573

Oh. This piece is actually not needed anymore, we have a general mechanism for validating fields.
I've committed rGc9d036ad4a2962059c595c77abb51154e2f5ec27

[rahmanl]

llvm/lib/ObjectYAML/ELFYAML.cpp

1573

Thanks for submitting the fix.

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct SectionOrType {
   StringRef sectionNameOrType;
 };
 
 struct DynamicEntry {
   ELF_DYNTAG Tag;
   llvm::yaml::Hex64 Val;
 };
 
+struct BBAddrMapEntry {
+  struct BBEntry {
+    llvm::yaml::Hex32 AddressOffset;
+    llvm::yaml::Hex32 Size;
+    llvm::yaml::Hex32 Metadata;
+  };
+  llvm::yaml::Hex64 Address;
+  llvm::yaml::Hex32 NumBlocks;
+  Optional<std::vector<BBEntry>> BBEntries;
+};
+
 struct StackSizeEntry {
   llvm::yaml::Hex64 Address;
   llvm::yaml::Hex64 Size;
 };
 
 struct NoteEntry {
   StringRef Name;
   yaml::BinaryRef Desc;
enum class ChunkKind {
     SymtabShndxSection,
     Symver,
     ARMIndexTable,
     MipsABIFlags,
     Addrsig,
     Fill,
     LinkerOptions,
     DependentLibraries,
-    CallGraphProfile
+    CallGraphProfile,
+    BBAddrMap
   };
 
   ChunkKind Kind;
   StringRef Name;
   Optional<llvm::yaml::Hex64> Offset;
 
   Chunk(ChunkKind K) : Kind(K) {}
   virtual ~Chunk();
struct Fill : Chunk {
   Optional<yaml::BinaryRef> Pattern;
   llvm::yaml::Hex64 Size;
 
   Fill() : Chunk(ChunkKind::Fill) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
 };
 
+struct BBAddrMapSection : Section {
+  Optional<yaml::BinaryRef> Content;
+  Optional<std::vector<BBAddrMapEntry>> Entries;
+
+  BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::BBAddrMap;
+  }
+};
+
 struct StackSizesSection : Section {
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
   Optional<std::vector<StackSizeEntry>> Entries;
 
   StackSizesSection() : Section(ChunkKind::StackSizes) {}
 
   static bool classof(const Chunk *S) {
struct Object {
 
   unsigned getMachine() const;
 };
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
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::BBAddrMapEntry> {
+  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &Rel);
+};
+
+template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
+  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &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);
 };
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            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::BBAddrMapSection &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::NoteSection &Section,
                            ContiguousBlobAccumulator &CBA);
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     } 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 if (auto S = dyn_cast<ELFYAML::DependentLibrariesSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::CallGraphProfileSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::BBAddrMapSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else {
       llvm_unreachable("Unknown section type");
     }
 
     LocationCounter += SHeader.sh_size;
 
     // Override section fields if requested.
     overrideFields<ELFT>(Sec, SHeader);
void ELFState<ELFT>::writeSectionContent(
   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
     CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(E.Size);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::BBAddrMapSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, None);
+    return;
+  }
+
+  for (const ELFYAML::BBAddrMapEntry &E : *Section.Entries) {
+    CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
+    SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(E.NumBlocks);
+    if (!E.BBEntries.hasValue())
+      continue;
+    for (const ELFYAML::BBAddrMapEntry::BBEntry &BBE : *E.BBEntries) {
+      SHeader.sh_size += CBA.writeULEB128(BBE.AddressOffset) +
+                         CBA.writeULEB128(BBE.Size) +
+                         CBA.writeULEB128(BBE.Metadata);
+    }
+  }
+}
+
+template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (Section.Content) {
     SHeader.sh_size = writeContent(CBA, Section.Content, None);
     return;
   }
 
   if (!Section.Options)

llvm/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(SHT_LLVM_ODRTAB);
   ECase(SHT_LLVM_LINKER_OPTIONS);
   ECase(SHT_LLVM_CALL_GRAPH_PROFILE);
   ECase(SHT_LLVM_ADDRSIG);
   ECase(SHT_LLVM_DEPENDENT_LIBRARIES);
   ECase(SHT_LLVM_SYMPART);
   ECase(SHT_LLVM_PART_EHDR);
   ECase(SHT_LLVM_PART_PHDR);
+  ECase(SHT_LLVM_BB_ADDR_MAP);
   ECase(SHT_GNU_ATTRIBUTES);
   ECase(SHT_GNU_HASH);
   ECase(SHT_GNU_verdef);
   ECase(SHT_GNU_verneed);
   ECase(SHT_GNU_versym);
   switch (Object->getMachine()) {
   case ELF::EM_ARM:
     ECase(SHT_ARM_EXIDX);
if (Section.Content)
       IO.setError("Content and ContentArray can't be used together");
     Section.Content = yaml::BinaryRef(*Section.ContentBuf);
   }
 
   IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Info", Section.Info);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::BBAddrMapSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Entries", Section.Entries);
+}
+
 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) {
case ELF::SHT_LLVM_DEPENDENT_LIBRARIES:
     sectionMapping(IO,
                    *cast<ELFYAML::DependentLibrariesSection>(Section.get()));
     break;
   case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
     if (!IO.outputting())
       Section.reset(new ELFYAML::CallGraphProfileSection());
     sectionMapping(IO, *cast<ELFYAML::CallGraphProfileSection>(Section.get()));
     break;
+  case ELF::SHT_LLVM_BB_ADDR_MAP:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::BBAddrMapSection());
+    sectionMapping(IO, *cast<ELFYAML::BBAddrMapSection>(Section.get()));
+    break;
   default:
     if (!IO.outputting()) {
       StringRef Name;
       IO.mapOptional("Name", Name, StringRef());
       Name = ELFYAML::dropUniqueSuffix(Name);
 
       if (ELFYAML::StackSizesSection::nameMatches(Name))
         Section = std::make_unique<ELFYAML::StackSizesSection>();
if (const auto *Sec = dyn_cast<ELFYAML::GnuHashSection>(C.get())) {
     // Only Content is specified.
     return {};
   }
 
   if (const auto *Sec = dyn_cast<ELFYAML::LinkerOptionsSection>(C.get())) {
     if (Sec->Options && Sec->Content)
       return "\"Options\" and \"Content\" can't be used together";
     return {};
   }
 
   if (const auto *Sec = dyn_cast<ELFYAML::DependentLibrariesSection>(C.get())) {
     if (Sec->Libs && Sec->Content)
       return "SHT_LLVM_DEPENDENT_LIBRARIES: \"Libraries\" and \"Content\" "
              "can't "
              "be used together";
     return {};
   }

 
 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::BBAddrMapEntry>::mapping(
+    IO &IO, ELFYAML::BBAddrMapEntry &E) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapOptional("Address", E.Address, Hex64(0));
+  IO.mapRequired("NumBlocks", E.NumBlocks);
+  IO.mapOptional("BBEntries", E.BBEntries);
+}
+
+void MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry>::mapping(
+    IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &E) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapRequired("AddressOffset", E.AddressOffset);
+  IO.mapRequired("Size", E.Size);
+  IO.mapRequired("Metadata", E.Metadata);
+}
+
 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);
 }

llvm/test/tools/obj2yaml/ELF/bb-addr-map.yaml

+## Check how obj2yaml produces YAML .llvm_bb_addr_map descriptions.
+
+## Check that obj2yaml uses the "Entries" tag to describe a .llvm_bb_addr_map section.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
+
+# VALID:      --- !ELF
+# VALID-NEXT: FileHeader:
+# VALID-NEXT:   Class:   ELFCLASS64
+# VALID-NEXT:   Data:    ELFDATA2LSB
+# VALID-NEXT:   Type:    ET_EXEC
+# VALID-NEXT: Sections:
+# VALID-NEXT:   - Name: .llvm_bb_addr_map
+# VALID-NEXT:     Type: SHT_LLVM_BB_ADDR_MAP
+# VALID-NEXT:     Entries:
+# VALID-NEXT:       - Address:   0x0000000000000010
+# VALID-NEXT:         NumBlocks: 0x00000003
+# VALID-NEXT:         BBEntries:
+# VALID-NEXT:           - AddressOffset:    0x00000001
+# VALID-NEXT:             Size:             0x00000002
+# VALID-NEXT:             Metadata:         0x00000003
+# VALID-NEXT:           - AddressOffset:    0x00000004
+# VALID-NEXT:             Size:             0x00000005
+# VALID-NEXT:             Metadata:         0x00000006
+# VALID-NEXT:           - AddressOffset:    0x00000007
+# VALID-NEXT:             Size:             0x00000008
+# VALID-NEXT:             Metadata:         0x00000009
+# VALID-NEXT:       - Address:   0x0000000000000020
+# VALID-NEXT:         NumBlocks: 0x00000001
+# VALID-NEXT:         BBEntries:
+# VALID-NEXT:           - AddressOffset:    0x0000000A
+# VALID-NEXT:             Size:             0x0000000B
+# VALID-NEXT:             Metadata:         0x0000000C
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:    .llvm_bb_addr_map
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - Address:   0x0000000000000010
+        NumBlocks: 0x00000003
+        BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+          - AddressOffset:    0x00000004
+            Size:             0x00000005
+            Metadata:         0x00000006
+          - AddressOffset:    0x00000007
+            Size:             0x00000008
+            Metadata:         0x00000009
+      - Address:   0x0000000000000020
+        NumBlocks: 0x00000001
+        BBEntries:
+          - AddressOffset:    0x0000000A
+            Size:             0x0000000B
+            Metadata:         0x0000000C

llvm/tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::GroupSection *> dumpGroupSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::ARMIndexTableSection *>
   dumpARMIndexTableSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
   Expected<ELFYAML::StackSizesSection *>
   dumpStackSizesSection(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::BBAddrMapSection *>
+  dumpBBAddrMapSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RawContentSection *>
   dumpPlaceholderSection(const Elf_Shdr *Shdr);
 
   bool shouldPrintSection(const ELFYAML::Section &S, const Elf_Shdr &SHdr,
                           Optional<DWARFYAML::Data> DWARF);
 
 public:
   ELFDumper(const object::ELFFile<ELFT> &O, std::unique_ptr<DWARFContext> DCtx);
case ELF::SHT_LLVM_LINKER_OPTIONS:
       return [this](const Elf_Shdr *S) { return dumpLinkerOptionsSection(S); };
     case ELF::SHT_LLVM_DEPENDENT_LIBRARIES:
       return [this](const Elf_Shdr *S) {
         return dumpDependentLibrariesSection(S);
       };
     case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
       return
           [this](const Elf_Shdr *S) { return dumpCallGraphProfileSection(S); };
+
+    case ELF::SHT_LLVM_BB_ADDR_MAP:
+      return [this](const Elf_Shdr *S) { return dumpBBAddrMapSection(S); };
     case ELF::SHT_STRTAB:
     case ELF::SHT_SYMTAB:
     case ELF::SHT_DYNSYM:
       // The contents of these sections are described by other parts of the YAML
       // file. But we still want to dump them, because their properties can be
       // important. See comments for 'shouldPrintSection()' for more details.
       return [this](const Elf_Shdr *S) { return dumpPlaceholderSection(S); };
     default:
ELFDumper<ELFT>::dumpStackSizesSection(const Elf_Shdr *Shdr) {
   } else {
     S->Entries = std::move(Entries);
   }
 
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::BBAddrMapSection *>
+ELFDumper<ELFT>::dumpBBAddrMapSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::BBAddrMapSection>();
+  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;
+  DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);
+
+  std::vector<ELFYAML::BBAddrMapEntry> Entries;
+  DataExtractor::Cursor Cur(0);
+  while (Cur && Cur.tell() < Content.size()) {
+    uint64_t Address = Data.getAddress(Cur);
+    uint32_t NumBlocks = Data.getULEB128(Cur);
+    std::vector<ELFYAML::BBAddrMapEntry::BBEntry> BBEntries;
+    for (uint32_t BlockID = 0;
+         Cur && Cur.tell() < Content.size() && BlockID < NumBlocks; ++BlockID) {
+      uint32_t Offset = Data.getULEB128(Cur);
+      uint32_t Size = Data.getULEB128(Cur);
+      uint32_t Metadata = Data.getULEB128(Cur);
+      BBEntries.push_back({Offset, Size, Metadata});
+    }
+    Entries.push_back({Address, NumBlocks, BBEntries});
+  }
+
+  if (Content.empty() || !Cur) {
+    // If the section cannot be decoded, we dump it as an array of bytes.
+    consumeError(Cur.takeError());
+    S->Content = yaml::BinaryRef(Content);
+  } else {
+    S->Entries = std::move(Entries);
+  }
+
+  return S.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::AddrsigSection *>
 ELFDumper<ELFT>::dumpAddrsigSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::AddrsigSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto ContentOrErr = Obj.getSectionContents(*Shdr);
   if (!ContentOrErr)