[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

1333

1339

You don't need to have curly braces here.

llvm/lib/ObjectYAML/ELFYAML.cpp

1542

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

1544

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

1544

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

1333

Adopted in the line above.

llvm/lib/ObjectYAML/ELFYAML.cpp

1542

Please look at the added test.

1544

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

4

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

113

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

115

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.

140

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

115

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

8

41

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

41

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

115

Used -DCONTENT="00"

140

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

60

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.

100

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

60

Fixed here and elsewhere.

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

1502

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

1502

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;
+  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<std::vector<BBAddrMapEntry>> Entries;
+
+  BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::BBAddrMap;
+  }
+};
+
 struct StackSizesSection : Section {
   Optional<std::vector<StackSizeEntry>> Entries;
 
   StackSizesSection() : Section(ChunkKind::StackSizes) {}
 
   std::vector<std::pair<StringRef, bool>> getEntries() const override {
     return {{"Entries", Entries.hasValue()}};
   };
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 std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
 };
 
 template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
   static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
 };
 
+template <> struct MappingTraits<ELFYAML::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.Entries)
+    return;
+
+  for (const ELFYAML::BBAddrMapEntry &E : *Section.Entries) {
+    // Write the address of the function.
+    CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
+    // Write number of BBEntries (number of basic blocks in the function).
+    size_t NumBlocks = E.BBEntries ? E.BBEntries->size() : 0;
+    SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(NumBlocks);
+    if (!NumBlocks)
+      continue;
+    // Write all BBEntries.
+    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.Options)
     return;
 
   for (const ELFYAML::LinkerOption &LO : *Section.Options) {
     CBA.write(LO.Key.data(), LO.Key.size());
     CBA.write('\0');

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.ContentBuf) {
     if (Section.Content)
       IO.setError("Content and ContentArray can't be used together");
     Section.Content = yaml::BinaryRef(*Section.ContentBuf);
   }
 
   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("Entries", Section.Entries);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::HashSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Bucket", Section.Bucket);
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 *MF = dyn_cast<ELFYAML::MipsABIFlags>(C.get())) {
     if (MF->Content)
       return "\"Content\" key is not implemented for SHT_MIPS_ABIFLAGS "
              "sections";
     if (MF->Size)
       return "\"Size\" key is not implemented for SHT_MIPS_ABIFLAGS sections";
     return "";
   }
 
+  if (const auto *BBAM = dyn_cast<ELFYAML::BBAddrMapSection>(C.get())) {
+    if ((BBAM->Content || BBAM->Size) && BBAM->Entries)
+      return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
+    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::BBAddrMapEntry>::mapping(
+    IO &IO, ELFYAML::BBAddrMapEntry &E) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapOptional("Address", E.Address, Hex64(0));
+  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:
+## Verify that the 'Address' field is omitted when it's zero.
+# VALID-NOT:  Address
+# 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:         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:   0x0000000000000000
+        BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+          - AddressOffset:    0x00000004
+            Size:             0x00000005
+            Metadata:         0x00000006
+          - AddressOffset:    0x00000007
+            Size:             0x00000008
+            Metadata:         0x00000009
+      - Address:   0x0000000000000020
+        BBEntries:
+          - AddressOffset:    0x0000000A
+            Size:             0x0000000B
+            Metadata:         0x0000000C
+
+## Check that obj2yaml uses the "Content" tag to describe a .llvm_bb_addr_map section
+## when it can't extract the entries. For instance, when truncated data is given as
+## 'Content'.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
+
+# INVALID:      --- !ELF
+# INVALID-NEXT: FileHeader:
+# INVALID-NEXT:   Class:   ELFCLASS64
+# INVALID-NEXT:   Data:    ELFDATA2LSB
+# INVALID-NEXT:   Type:    ET_EXEC
+# INVALID-NEXT: Sections:
+# INVALID-NEXT:   - Name: .llvm_bb_addr_map
+# INVALID-NEXT:     Type: SHT_LLVM_BB_ADDR_MAP
+# INVALID-NEXT:     Content: '10000000000000'
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:    .llvm_bb_addr_map
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Content: '10000000000000'
+
+## Check obj2yaml can dump empty .llvm_bb_addr_map sections.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: obj2yaml %t3 | FileCheck %s --check-prefix=EMPTY
+
+# EMPTY:      --- !ELF
+# EMPTY-NEXT: FileHeader:
+# EMPTY-NEXT:   Class: ELFCLASS64
+# EMPTY-NEXT:   Data:  ELFDATA2LSB
+# EMPTY-NEXT:   Type:  ET_EXEC
+# EMPTY-NEXT: Sections:
+# EMPTY-NEXT:   - Name:    .llvm_bb_addr_map
+# EMPTY-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP
+# EMPTY-NEXT:     Content: ''
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:    .llvm_bb_addr_map
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Content: ""
+
+## Check obj2yaml can dump multiple .llvm_bb_addr_map sections.
+
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: obj2yaml %t4 | FileCheck %s --check-prefix=MULTI
+
+# MULTI:      --- !ELF
+# MULTI-NEXT: FileHeader:
+# MULTI-NEXT:   Class: ELFCLASS64
+# MULTI-NEXT:   Data:  ELFDATA2LSB
+# MULTI-NEXT:   Type:  ET_EXEC
+# MULTI-NEXT: Sections:
+# MULTI-NEXT:   - Name:    .llvm_bb_addr_map
+# MULTI-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP
+# MULTI-NEXT:     Entries:
+## Check that Address is not emitted when it's zero.
+# MULTI-NOT:          Address
+# MULTI-NEXT:       - BBEntries:
+# MULTI-NEXT:           - AddressOffset:    0x00000001
+# MULTI-NEXT:             Size:             0x00000002
+# MULTI-NEXT:             Metadata:         0x00000003
+# MULTI-NEXT:   - Name:    '.llvm_bb_addr_map (1)'
+# MULTI-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP
+# MULTI-NEXT:     Entries:
+# MULTI-NEXT:       - Address: 0x0000000000000020
+# MULTI-NEXT:         BBEntries: []
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:    .llvm_bb_addr_map
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+## Check that obj2yaml does not emit the Address field when it's zero.
+      - Address:   0x0000000000000000
+        BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+  - Name:    '.llvm_bb_addr_map (1)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - Address:   0x0000000000000020

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

+## Check how yaml2obj produces .llvm_bb_addr_map sections.
+
+## Test the following cases"
+## 1) We can produce a .llvm_bb_addr_map section from a description with section
+##    content.
+## 2) We can produce an empty .llvm_bb_addr_map section from a description
+##    swith empty section content.
+## 3) We can produce a zero .llvm_bb_addr_map section of a specific size when
+##    we specify the size only.
+## 4) We can produce a .llvm_bb_addr_map section from a description with
+##    Entries.
+## 5) When specifying the description with Entries, the 'Address' field will be
+##    zero when omitted.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s
+
+## Case 1: Specify content.
+# CHECK:      Section {
+# CHECK:        Index: 1
+# CHECK-NEXT:   Name: .llvm_bb_addr_map (1)
+# CHECK-NEXT:   Type: SHT_LLVM_BB_ADDR_MAP (0x6FFF4C08)
+# CHECK-NEXT:   Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Address: 0x0
+# CHECK-NEXT:   Offset: 0x40
+# CHECK-NEXT:   Size: 12
+# CHECK-NEXT:   Link: 0
+# CHECK-NEXT:   Info: 0
+# CHECK-NEXT:   AddressAlignment: 0
+# CHECK-NEXT:   EntrySize: 0
+# CHECK-NEXT:   SectionData (
+# CHECK-NEXT:     0000: 00000000 00000000 01010203
+# CHECK-NEXT:   )
+# CHECK-NEXT: }
+
+## Case 2: Empty.
+# CHECK:        Name: .llvm_bb_addr_map (1)
+# CHECK:        Size:
+# CHECK-SAME:   0
+
+## Case 3: Specify Size only.
+# CHECK:        Name: .llvm_bb_addr_map (1)
+# CHECK:        SectionData (
+# CHECK-NEXT:     0000: 00000000 00000000
+# CHECK-NEXT:   )
+
+# Case 4: Specify Entries.
+# CHECK:        Name: .llvm_bb_addr_map (1)
+# CHECK:        SectionData (
+# CHECK-NEXT:     0000: 20000000 00000000 01010203
+# CHECK-NEXT:   )
+
+# Case 5: Specify Entries and omit the Address field.
+# CHECK:        Name: .llvm_bb_addr_map (1)
+# CHECK:        SectionData (
+# CHECK-NEXT:     0000: 00000000 00000000 01010203
+# CHECK-NEXT:   )
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+
+##  Specify Content.
+  - Name:    '.llvm_bb_addr_map (1)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Content: "000000000000000001010203"
+
+## Empty.
+  - Name:    '.llvm_bb_addr_map (2)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+
+## Specify Size.
+  - Name:    '.llvm_bb_addr_map (3)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Size:    8
+
+## Specify Entries.
+  - Name:    '.llvm_bb_addr_map (4)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - Address:   0x0000000000000020
+        BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+
+## Check we can omit the "Address" tag. In this case the address will be zero.
+  - Name:    '.llvm_bb_addr_map (5)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+
+
+## Check we can't use both "Content" and "Entries" tags at the same time.
+# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-CONTENT
+# ENTRIES-AND-CONTENT: error: "Entries" cannot be used with "Content" or "Size"
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+##  Specify Content and Entries
+  - Name:    '.llvm_bb_addr_map (1)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+    Content: "000000000000000001010203"
+
+## Check we can't use both "Size" and "Entries" tags at the same time.
+# RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-SIZE
+# ENTRIES-AND-SIZE: error: "Entries" cannot be used with "Content" or "Size"
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+##  Specify Content and Size
+  - Name:    '.llvm_bb_addr_map (1)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - BBEntries:
+          - AddressOffset:    0x00000001
+            Size:             0x00000002
+            Metadata:         0x00000003
+    Size:    12

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;
+    // Read the specified number of BB entries, or until decoding fails.
+    for (uint32_t BlockID = 0; Cur && 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, 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)