[llvm-objdump] Let --symbolize-operands symbolize basic block addresses based on the SHT_LLVM_BB_ADDR_MAP section.

[rahmanl]

Summary

--symbolize-operands already symbolizes branch targets based on the disassembly. When the object file is created with -fbasic-block-sections=labels (ELF-only) it will include a SHT_LLVM_BB_ADDR_MAP section which maps basic blocks to their addresses. In such case llvm-objdump can annotate the disassembly based on labels inferred on this section.

In contrast to the current labels, SHT_LLVM_BB_ADDR_MAP-based labels are created for every machine basic block including empty blocks and those which are not branched into (fallthrough blocks).

The old logic is still executed even when the SHT_LLVM_BB_ADDR_MAP section is present to handle functions which have not been received an entry in this section.

[rahmanl]

Add a basic block to the test which is not branched into.

[mtrofin]

llvm/lib/Object/ELFObjectFile.cpp

681

Coding style: BBAddrMap (i.e. first letter capital, no '_')

llvm/tools/llvm-objdump/llvm-objdump.cpp

1008

I (capital)

[jhenderson]

llvm/lib/Object/ELFObjectFile.cpp

684

Errors should use lower-case first letter (and no trailing full stop). Applies below too.

689

I'd remove the exclamation mark. It feels a little unprofessional to me, if I'm honest: it's not unreasonable for such section to exist apart from anything else.

llvm/tools/llvm-objdump/llvm-objdump.cpp

991

It seems like this should at least be a warning?

1332

The Programmer's manual says not to use unordererd_map, although I doubt its reasoning is necessarily important here. Would DenseMap be more appropriate anyway?

[rahmanl]

Thanks for the reviews. Just realized this isn't working when multiple BB-address-map sections are present. Will fix soon.

[MaskRay]

When the object file is created with -basic-block-labels it will include

Typo about -basic-block-labels? Better to use a Clang driver option. If that is unavailable, use an llc option.

[rahmanl]

• Handled the multi-section case.
• Added unit tests for the ELFObjectFile::readBBAddrMap API.

[rahmanl]

llvm/tools/llvm-objdump/llvm-objdump.cpp

991

Reporting errors now.

1332

Also changed the preexisting unordered_map to a DenseMap.

[jhenderson]

I've run out of time to properly review this today, but some more nits to be getting on with.

llvm/lib/Object/ELFObjectFile.cpp

689

I'd find this more readable (i.e. I can tell more clearly that it is going to give you the right thing).

693–696

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands-multi-section.yaml

31

Too many blank lines

[jhenderson]

I don't know the disassembly code well enough to feel comfortable reviewing it or its corresponding testing, without sinking more time into this review than I have available, so someone else better look at those parts at least.

llvm/include/llvm/Object/ELFObjectFile.h

107

llvm/tools/llvm-objdump/llvm-objdump.cpp

1274

1277

I wonder if this should be a warning rather than an error: it's still possible to disassemble, just not with all the information.

1500

llvm/unittests/Object/ELFObjectFileTest.cpp

608

Do you have a test case where the TextSectionIndex is specified, but there are no matching sections?

I'd also expect to see checks that the retrieved entries match what was expected, but don't see any of those.

666

[rahmanl]

• Added more cases in the unit test.

llvm/unittests/Object/ELFObjectFileTest.cpp

608

Do you have a test case where the TextSectionIndex is specified, but there are no matching sections?

Would you please clarify?

I do have tests for when the requested TextSectionIndex doesn't match with sh_link of the bb-address-map sections. The call to readBBAddrMap would succeed and return an empty vector in such case -- indicating that no BB-address-map was found for that section. Do you suggest I return Error in this case?

Or do you mean a test for when the requested TextSectionIndex is not a valid text section?

I'd also expect to see checks that the retrieved entries match what was expected, but don't see any of those.

Sure. I added additional cases and also support for equality of BBAddrMaps.

[rahmanl]

• Update llvm-objdump.rst.

[rahmanl]

• Nicer BBAddrMap initialization in the unit test.

[jhenderson]

llvm/docs/CommandGuide/llvm-objdump.rst

229 ↗

(On Diff #427459)

llvm/include/llvm/Object/ELFTypes.h

816

Did you consider using std::memcmp here instead of checking each individual field separately. The problem with the current code is that if you add a new field, it'll be easy to forget to add it in the comparison. On the other hand, std::memcmp would prevent adding non-POD fields, like std::vector etc, so may not be appropriate. Up to you.

llvm/unittests/Object/ELFObjectFileTest.cpp

608

I do have tests for when the requested TextSectionIndex doesn't match with sh_link of the bb-address-map sections. The call to readBBAddrMap would succeed and return an empty vector in such case -- indicating that no BB-address-map was found for that section. Do you suggest I return Error in this case?

No, what you've added in this latest version is what I wanted.

Aside: the test name is no longer really valid.

689

717

I think?

[rahmanl]

• nits.

llvm/include/llvm/Object/ELFTypes.h

816

Thanks for the suggestion. I would go for field-by-field comparison. I don't expect the operator to be used for anything other than unit-tests.

[jhenderson]

One remaining nit from my point of view, but as noted, I haven't attempted to review the disassembly aspects in depth.

llvm/docs/CommandGuide/llvm-objdump.rst

229 ↗

(On Diff #427459)

Still missing "the" after the "i.e.".

[rahmanl]

• Last nit. Thanks for the review James.

[rahmanl]

@MaskRay Is this patch good in terms of disassembly?

[MaskRay]

(I was out of town for like one week. Just came back.)

@MaskRay Is this patch good in terms of disassembly?

Looks good.

---

The subject may be clearer if you mention --symbolize-operands somewhere: this does not affect non --symbolize-operands functionality AFAICT.

Use one spelling for BB address map. If BB address map is canonical, avoid bb-address-map. It's also fine to refer to the concept with SHT_LLVM_BB_ADDR_MAP everywhere. (I don't think any object file format will pick up this soon)

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands-multi-section.yaml

2

Add a file-level comment stating the purpose of the test.

llvm/tools/llvm-objdump/llvm-objdump.cpp

997

See https://llvm.org/docs/CodingStandards.html#don-t-evaluate-end-every-time-through-a-loop

1281

FunctionBBAddrMap is a const reference. std::move cannot save a copy.

Use for (BBAddrMap &FunctionBBAddrMap : ...

1447–1449

The original std::unordered_map<uint64_t, std::string> is better.

Inserting -1 and -2 (tombstone and empty) into a DenseMap<uint64_t, ...> leads to an assertion failure. The values are not realistic but we should guard against pathological cases.

[rahmanl]

Addressed comments.

[MaskRay]

Mostly looks good to me.

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands-multi-section.yaml

2

Can the test be merged into the other one?

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands.yaml

2

Consider using wording like:
## Test that in the presence of SHT_LLVM_BB_ADDR_MAP, --symbolize-operands can display <BB.*> labels.

[rahmanl]

Merged the two tests into one.

[rahmanl]

minor changes.

[MaskRay]

Looks great! But best to wait for @jhenderson

llvm/docs/CommandGuide/llvm-objdump.rst

229 ↗

(On Diff #429358)

rst has different quoting rules than markdown.

[skan]

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands.yaml

22

The memory operand of cmpl disappears here. Is it on purpose?

[MaskRay]

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands.yaml

22

--symbolize-operands only works with -M intel. The -M att support is quite broken but having the test helps we know the current state.

[skan]

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands.yaml

22

I see. Thanks for the clarifying it.

llvm/tools/llvm-objdump/llvm-objdump.cpp

991

Do we need this clear?

[jhenderson]

In D124560#3512784, @MaskRay wrote:

Looks great! But best to wait for @jhenderson

I've got no issues with the most recent changes.

[rahmanl]

Fix llvm-objdump.rst.

llvm/include/llvm/Object/ELFObjectFile.h

public:
   virtual uint16_t getEMachine() const = 0;
 
   std::vector<std::pair<Optional<DataRefImpl>, uint64_t>>
   getPltAddresses() const;
 
   /// Returns a vector containing a symbol version for each dynamic symbol.
   /// Returns an empty vector if version sections do not exist.
   Expected<std::vector<VersionEntry>> readDynsymVersions() const;
+
+  /// Returns a vector of all BB address maps in the object file. When
+  // `TextSectionIndex` is specified, only returns the BB address maps
+  // corresponding to the section with that index.
+  Expected<std::vector<BBAddrMap>>
+  readBBAddrMap(Optional<unsigned> TextSectionIndex = None) const;
 };
 
 class ELFSectionRef : public SectionRef {
 public:
   ELFSectionRef(const SectionRef &B) : SectionRef(B) {
     assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
   }
 

llvm/include/llvm/Object/ELFTypes.h

struct BBEntry {
     bool HasTailCall;    // If this block ends with a tail call.
     bool IsEHPad;        // If this is an exception handling block.
     bool CanFallThrough; // If this block can fall through to its next.
 
     BBEntry(uint32_t Offset, uint32_t Size, uint32_t Metadata)
         : Offset(Offset), Size(Size), HasReturn(Metadata & 1),
           HasTailCall(Metadata & (1 << 1)), IsEHPad(Metadata & (1 << 2)),
           CanFallThrough(Metadata & (1 << 3)){};
+
+    bool operator==(const BBEntry &Other) const {
+      return Offset == Other.Offset && Size == Other.Size &&
+             HasReturn == Other.HasReturn && HasTailCall == Other.HasTailCall &&
+             IsEHPad == Other.IsEHPad && CanFallThrough == Other.CanFallThrough;
+    }
   };
   std::vector<BBEntry> BBEntries; // Basic block entries for this function.
+
+  // Equality operator for unit testing.
+  bool operator==(const BBAddrMap &Other) const {
+    return Addr == Other.Addr && std::equal(BBEntries.begin(), BBEntries.end(),
+                                            Other.BBEntries.begin());
+  }
 };
 
 } // end namespace object.
 } // end namespace llvm.
 
 #endif // LLVM_OBJECT_ELFTYPES_H

llvm/lib/Object/ELFObjectFile.cpp

if (PltEntryIter != GotToPlt.end()) {
       else
         Result.emplace_back(Sym->getRawDataRefImpl(), PltEntryIter->second);
     }
   }
   return Result;
 }
 
 template <class ELFT>
+Expected<std::vector<BBAddrMap>>
+readBBAddrMapImpl(const ELFFile<ELFT> &EF,
+                  Optional<unsigned> TextSectionIndex) {
+  using Elf_Shdr = typename ELFT::Shdr;
+  std::vector<BBAddrMap> BBAddrMaps;
+  const auto &Sections = cantFail(EF.sections());
+  for (const Elf_Shdr &Sec : Sections) {
+    if (Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP)
+      continue;
+    if (TextSectionIndex) {
+      Expected<const Elf_Shdr *> TextSecOrErr = EF.getSection(Sec.sh_link);
+      if (!TextSecOrErr)
+        return createError("unable to get the linked-to section for " +
+                           describe(EF, Sec) + ": " +
+                           toString(TextSecOrErr.takeError()));
+      if (*TextSectionIndex != std::distance(Sections.begin(), *TextSecOrErr))
+        continue;
+    }
+    Expected<std::vector<BBAddrMap>> BBAddrMapOrErr = EF.decodeBBAddrMap(Sec);
+    if (!BBAddrMapOrErr)
+      return createError("unable to read " + describe(EF, Sec) + ": " +
+                         toString(BBAddrMapOrErr.takeError()));
+    std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),
+              std::back_inserter(BBAddrMaps));
+  }
+  return BBAddrMaps;
+}
+
+template <class ELFT>
 static Expected<std::vector<VersionEntry>>
 readDynsymVersionsImpl(const ELFFile<ELFT> &EF,
                        ELFObjectFileBase::elf_symbol_iterator_range Symbols) {
   using Elf_Shdr = typename ELFT::Shdr;
   const Elf_Shdr *VerSec = nullptr;
   const Elf_Shdr *VerNeedSec = nullptr;
   const Elf_Shdr *VerDefSec = nullptr;
   // The user should ensure sections() can't fail here.
if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
   if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
   if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
   return readDynsymVersionsImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
                                 Symbols);
 }
+
+Expected<std::vector<BBAddrMap>>
+ELFObjectFileBase::readBBAddrMap(Optional<unsigned> TextSectionIndex) const {
+  if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
+    return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
+  if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
+    return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
+  if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
+    return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
+  if (const auto *Obj = cast<ELF64BEObjectFile>(this))
+    return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
+  else
+    llvm_unreachable("Unsupported binary format");
+}

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands-multi-section.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objdump %t -d --symbolize-operands -M intel --no-show-raw-insn --no-leading-addr | \
+# RUN:   FileCheck %s --match-full-lines --check-prefix=INTEL
+# RUN: llvm-objdump %t -d --symbolize-operands -M att --no-show-raw-insn --no-leading-addr | \
+# RUN:   FileCheck %s --match-full-lines --check-prefix=ATT
+
+## Expect to find the branch labels and global variable name.
+# ATT:      <foo>:
+# ATT-NEXT: <BB0>:
+# ATT-NEXT:   pushq %rax
+# ATT-NEXT: <BB1>:
+# ATT-NEXT:   cmpl  , %eax <symbol>
+# ATT-NEXT:   nop
+# ATT-NEXT: <BB2>:
+# ATT-NEXT:   jge   <BB3>
+# ATT-NEXT:   jmp   <BB1>
+# ATT-NEXT: <BB3>:
+# ATT-NEXT:   retq
+
+# ATT:      <bar>:
+# ATT-NEXT: <BB0>:
+# ATT-NEXT:   pushq  %rax
+# ATT-NEXT:   movl   %edx, %eax
+# ATT-NEXT:   je     <BB2>
+# ATT-NEXT: <BB1>:
+# ATT-NEXT:   xorl   %esi, %esi
+# ATT-NEXT: <BB2>:
+# ATT-NEXT:   callq  <bar>
+# ATT-NEXT:   retq
+
+# INTEL:      <foo>:
+# INTEL-NEXT: <BB0>:
+# INTEL-NEXT:   push  rax
+# INTEL-NEXT: <BB1>:
+# INTEL-NEXT:   cmp   eax, dword ptr <symbol>
+# INTEL-NEXT:   nop
+# INTEL-NEXT: <BB2>:
+# INTEL-NEXT:   jge   <BB3>
+# INTEL-NEXT:   jmp   <BB1>
+# INTEL-NEXT: <BB3>:
+# INTEL-NEXT:   ret
+
+# INTEL:      <bar>:
+# INTEL-NEXT: <BB0>:
+# INTEL-NEXT:   push  rax
+# INTEL-NEXT:   mov   eax, edx
+# INTEL-NEXT:   je    <BB2>
+# INTEL-NEXT: <BB1>:
+# INTEL-NEXT:   xor   esi, esi
+# INTEL-NEXT: <BB2>:
+# INTEL-NEXT:   call  <bar>
+# INTEL-NEXT:   ret
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text.foo
+    Type:    SHT_PROGBITS
+    Address: 0x4000
+    Flags:   [SHF_ALLOC, SHF_EXECINSTR]
+    Content: '503b0505200000907d02ebf5c3'
+  - Name:    .text.bar
+    Type:    SHT_PROGBITS
+    Address: 0x5000
+    Flags:   [SHF_ALLOC, SHF_EXECINSTR]
+    Content: '5089d0740231f6e8f4ffffffc3'
+  - Name:    .data
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC, SHF_WRITE]
+    Address: 0x6000
+  - Name:   bb_addr_map.foo
+    Type:   SHT_LLVM_BB_ADDR_MAP
+    Link:   .text.foo
+    Entries:
+      - Address: 0x4000
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0x1
+          - AddressOffset: 0x1
+            Size:          0x6
+            Metadata:      0x0
+          - AddressOffset: 0x8
+            Size:          0x3
+            Metadata:      0x0
+          - AddressOffset: 0xc
+            Size:          0x1
+            Metadata:      0x2
+  - Name:   bb_addr_map.bar
+    Type:   SHT_LLVM_BB_ADDR_MAP
+    Link:   .text.bar
+    Entries:
+      - Address: 0x5000
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0x1
+          - AddressOffset: 0x5
+            Size:          0x2
+            Metadata:      0x0
+          - AddressOffset: 0x7
+            Size:          0x6
+            Metadata:      0x0
+
+Symbols:
+  - Name:    foo
+    Section: .text.foo
+    Value:   0x4000
+  - Name:    bar
+    Section: .text.bar
+    Value:   0x5000
+  - Name:    symbol
+    Section: .data
+    Value:   0x600c

llvm/test/tools/llvm-objdump/X86/elf-bbaddrmap-disassemble-symbolize-operands.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objdump %t -d --symbolize-operands -M intel --no-show-raw-insn --no-leading-addr | \
+# RUN:   FileCheck %s --match-full-lines --check-prefix=INTEL
+# RUN: llvm-objdump %t -d --symbolize-operands -M att --no-show-raw-insn --no-leading-addr | \
+# RUN:   FileCheck %s --match-full-lines --check-prefix=ATT
+
+## Expect to find the branch labels and global variable name.
+# ATT:      <_start>:
+# ATT-NEXT: <BB0>:
+# ATT-NEXT:   pushq %rax
+# ATT-NEXT: <BB1>:
+# ATT-NEXT:   cmpl  , %eax <symbol>
+# ATT-NEXT:   nop
+# ATT-NEXT: <BB2>:
+# ATT-NEXT:   jge    <BB3>
+# ATT-NEXT:   jmp    <BB1>
+# ATT-NEXT: <BB3>:
+# ATT-NEXT:   retq
+
+# INTEL:      <_start>:
+# INTEL-NEXT: <BB0>:
+# INTEL-NEXT:   push rax
+# INTEL-NEXT: <BB1>:
+# INTEL-NEXT:   cmp  eax, dword ptr <symbol>
+# INTEL-NEXT:   nop
+# INTEL-NEXT: <BB2>:
+# INTEL-NEXT:   jge   <BB3>
+# INTEL-NEXT:   jmp   <BB1>
+# INTEL-NEXT: <BB3>:
+# INTEL-NEXT:   ret
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Address: 0x4000
+    Flags:   [SHF_ALLOC, SHF_EXECINSTR]
+    Content: '503b0505100000907d02ebf5c3'
+  - Name:    .data
+    Type:    SHT_PROGBITS
+    Flags:   [SHF_ALLOC, SHF_WRITE]
+    Address: 0x5000
+  - Name:   bb_addr_map_1
+    Type:   SHT_LLVM_BB_ADDR_MAP
+    Link:   .text
+    Entries:
+      - Address: 0x4000
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0x1
+          - AddressOffset: 0x1
+            Size:          0x6
+            Metadata:      0x0
+          - AddressOffset: 0x8
+            Size:          0x3
+            Metadata:      0x0
+          - AddressOffset: 0xc
+            Size:          0x1
+            Metadata:      0x2
+Symbols:
+  - Name:    _start
+    Section: .text
+    Value:   0x4000
+  - Name:    symbol
+    Section: .data
+    Value:   0x500c

llvm/tools/llvm-objdump/llvm-objdump.cpp

 #include "llvm-objdump.h"
 #include "COFFDump.h"
 #include "ELFDump.h"
 #include "MachODump.h"
 #include "ObjdumpOptID.h"
 #include "SourcePrinter.h"
 #include "WasmDump.h"
 #include "XCOFFDump.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"

 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/FaultMapParser.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"

 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>
 #include <cstring>
 #include <system_error>
-#include <unordered_map>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objdump;
 using namespace llvm::opt;
 
 namespace {
static SymbolInfoTy createDummySymbolInfo(const ObjectFile *Obj,
                                           uint8_t Type) {
   if (Obj->isXCOFF() && SymbolDescription)
     return SymbolInfoTy(Addr, Name, None, None, false);
   else
     return SymbolInfoTy(Addr, Name, Type);
 }
 
 static void
-collectLocalBranchTargets(ArrayRef<uint8_t> Bytes, const MCInstrAnalysis *MIA,
-                          MCDisassembler *DisAsm, MCInstPrinter *IP,
-                          const MCSubtargetInfo *STI, uint64_t SectionAddr,
-                          uint64_t Start, uint64_t End,
-                          std::unordered_map<uint64_t, std::string> &Labels) {
+collectBBAddrMapLabels(const DenseMap<uint64_t, BBAddrMap> &AddrToBBAddrMap,
+                       uint64_t SectionAddr, uint64_t Start, uint64_t End,
+                       DenseMap<uint64_t, std::vector<std::string>> &Labels) {
+  if (AddrToBBAddrMap.empty())
+    return;
+  Labels.clear();
+  uint64_t StartAddress = SectionAddr + Start;
+  uint64_t EndAddress = SectionAddr + End;
+  auto Iter = AddrToBBAddrMap.find(StartAddress);
+  if (Iter == AddrToBBAddrMap.end())
+    return;
+  for (unsigned I = 0; I < Iter->second.BBEntries.size(); ++I) {
+    uint64_t BBAddress = Iter->second.BBEntries[I].Offset + Iter->second.Addr;
+    if (BBAddress >= EndAddress)
+      continue;
+    Labels[BBAddress].push_back(("BB" + Twine(I)).str());
+  }
+}
+
+static void collectLocalBranchTargets(
+    ArrayRef<uint8_t> Bytes, const MCInstrAnalysis *MIA, MCDisassembler *DisAsm,
+    MCInstPrinter *IP, const MCSubtargetInfo *STI, uint64_t SectionAddr,
+    uint64_t Start, uint64_t End, DenseMap<uint64_t, std::string> &Labels) {
   // So far only supports PowerPC and X86.
   if (!STI->getTargetTriple().isPPC() && !STI->getTargetTriple().isX86())
     return;
 
   Labels.clear();
   unsigned LabelCount = 0;
   Start += SectionAddr;
   End += SectionAddr;
if (Disassembled && MIA) {
       bool TargetKnown = MIA->evaluateBranch(Inst, Index, Size, Target);
       // On PowerPC, if the address of a branch is the same as the target, it
       // means that it's a function call. Do not mark the label for this case.
       if (TargetKnown && (Target >= Start && Target < End) &&
           !Labels.count(Target) &&
           !(STI->getTargetTriple().isPPC() && Target == Index))
         Labels[Target] = ("L" + Twine(LabelCount++)).str();
     }
-
     Index += Size;
   }
 }
 
 // Create an MCSymbolizer for the target and add it to the MCDisassembler.
 // This is currently only used on AMDGPU, and assumes the format of the
 // void * argument passed to AMDGPU's createMCSymbolizer.
 static void addSymbolizer(
if (FilterSections.empty() && !DisassembleAll &&
         (!Section.isText() || Section.isVirtual()))
       continue;
 
     uint64_t SectionAddr = Section.getAddress();
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
       continue;
 
+    DenseMap<uint64_t, BBAddrMap> AddrToBBAddrMap;
+    if (SymbolizeOperands) {
+      if (auto *Elf = dyn_cast<ELFObjectFileBase>(Obj)) {
+        // Read the BB-address-map corresponding to this section, if present.
+        auto SectionBBAddrMapsOrErr = Elf->readBBAddrMap(Section.getIndex());
+        if (!SectionBBAddrMapsOrErr)
+          reportWarning(toString(SectionBBAddrMapsOrErr.takeError()),
+                        Obj->getFileName());
+        for (const auto &FunctionBBAddrMap : *SectionBBAddrMapsOrErr)
+          AddrToBBAddrMap.try_emplace(FunctionBBAddrMap.Addr,
+                                      std::move(FunctionBBAddrMap));
+      }
+    }
+
     // Get the list of all the symbols in this section.
     SectionSymbolsTy &Symbols = AllSymbols[Section];
     std::vector<MappingSymbolPair> MappingSymbols;
     if (hasMappingSymbols(Obj)) {
       for (const auto &Symb : Symbols) {
         uint64_t Address = Symb.Addr;
         StringRef Name = Symb.Name;
         if (Name.startswith("$d"))
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
 
     SmallString<40> Comments;
     raw_svector_ostream CommentStream(Comments);
 
     uint64_t VMAAdjustment = 0;
     if (shouldAdjustVA(Section))
       VMAAdjustment = AdjustVMA;
 
     // In executable and shared objects, r_offset holds a virtual address.
     // Subtract SectionAddr from the r_offset field of a relocation to get
     // the section offset.
     uint64_t RelAdjustment = Obj->isRelocatableObject() ? 0 : SectionAddr;
     uint64_t Size;
     uint64_t Index;
     bool PrintedSection = false;
     std::vector<RelocationRef> Rels = RelocMap[Section];
     std::vector<RelocationRef>::const_iterator RelCur = Rels.begin();
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
       }
 
       bool CheckARMELFData = hasMappingSymbols(Obj) &&
                              Symbols[SI].Type != ELF::STT_OBJECT &&
                              !DisassembleAll;
       bool DumpARMELFData = false;
       formatted_raw_ostream FOS(outs());
 
-      std::unordered_map<uint64_t, std::string> AllLabels;
-      if (SymbolizeOperands)
+      DenseMap<uint64_t, std::string> AllLabels;
+      DenseMap<uint64_t, std::vector<std::string>> BBAddrMapLabels;
+      if (SymbolizeOperands) {
         collectLocalBranchTargets(Bytes, MIA, DisAsm, IP, PrimarySTI,
                                   SectionAddr, Index, End, AllLabels);
+        collectBBAddrMapLabels(AddrToBBAddrMap, SectionAddr, Index, End,
+                               BBAddrMapLabels);
+      }
 
       while (Index < End) {
         // ARM and AArch64 ELF binaries can interleave data and text in the
         // same section. We rely on the markers introduced to understand what
         // we need to dump. If the data marker is within a function, it is
         // denoted as a word/short etc.
         if (CheckARMELFData) {
           char Kind = getMappingSymbolKind(MappingSymbols, Index);
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
                     countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
               FOS << "\t\t..." << '\n';
               Index += N;
               continue;
             }
           }
 
           // Print local label if there's any.
-          auto Iter = AllLabels.find(SectionAddr + Index);
-          if (Iter != AllLabels.end())
-            FOS << "<" << Iter->second << ">:\n";
+          auto Iter1 = BBAddrMapLabels.find(SectionAddr + Index);
+          if (Iter1 != BBAddrMapLabels.end()) {
+            for (StringRef Label : Iter1->second)
+              FOS << "<" << Label << ">:\n";
+          } else {
+            auto Iter2 = AllLabels.find(SectionAddr + Index);
+            if (Iter2 != AllLabels.end())
+              FOS << "<" << Iter2->second << ">:\n";
+          }
 
           // Disassemble a real instruction or a data when disassemble all is
           // provided
           MCInst Inst;
           bool Disassembled =
               DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                      SectionAddr + Index, CommentStream);
           if (Size == 0)
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
                     [=](const SymbolInfoTy &O) { return O.Addr <= Target; });
                 if (It != TargetSymbols->begin()) {
                   TargetSym = &*(It - 1);
                   break;
                 }
               }
 
               // Print the labels corresponding to the target if there's any.
+              bool BBAddrMapLabelAvailable = BBAddrMapLabels.count(Target);
               bool LabelAvailable = AllLabels.count(Target);
               if (TargetSym != nullptr) {
                 uint64_t TargetAddress = TargetSym->Addr;
                 uint64_t Disp = Target - TargetAddress;
                 std::string TargetName = TargetSym->Name.str();
                 if (Demangle)
                   TargetName = demangle(TargetName);
 
                 *TargetOS << " <";
                 if (!Disp) {
                   // Always Print the binary symbol precisely corresponding to
                   // the target address.
                   *TargetOS << TargetName;
-                } else if (!LabelAvailable) {
+                } else if (BBAddrMapLabelAvailable) {
+                  *TargetOS << BBAddrMapLabels[Target].front();
+                } else if (LabelAvailable) {
+                  *TargetOS << AllLabels[Target];
+                } else {
                   // Always Print the binary symbol plus an offset if there's no
                   // local label corresponding to the target address.
                   *TargetOS << TargetName << "+0x" << Twine::utohexstr(Disp);
-                } else {
-                  *TargetOS << AllLabels[Target];
                 }
                 *TargetOS << ">";
+              } else if (BBAddrMapLabelAvailable) {
+                *TargetOS << " <" << BBAddrMapLabels[Target].front() << ">";
               } else if (LabelAvailable) {
                 *TargetOS << " <" << AllLabels[Target] << ">";
               }
               // By convention, each record in the comment stream should be
               // terminated.
               if (TargetOS == &CommentStream)
                 *TargetOS << "\n";
             }

llvm/unittests/Object/ELFObjectFileTest.cpp

)";
   OverLimitNumBlocks += R"(
         NumBlocks: 0x100000000
 )";
 
   DoCheck(OverLimitNumBlocks,
           "ULEB128 value at offset 0x8 exceeds UINT32_MAX (0x100000000)");
 }
 
+// Test for the ELFObjectFile::readBBAddrMap API.
+TEST(ELFObjectFileTest, InvalidReadBBAddrMap) {
+  StringRef CommonYamlString(R"(
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name: .llvm_bb_addr_map_1
+    Type: SHT_LLVM_BB_ADDR_MAP
+    Link: 1
+    Entries:
+      - Address: 0x11111
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0x2
+  - Name: .llvm_bb_addr_map_2
+    Type: SHT_LLVM_BB_ADDR_MAP
+    Link: 1
+    Entries:
+      - Address: 0x22222
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x2
+            Metadata:      0x4
+  - Name: .llvm_bb_addr_map
+    Type: SHT_LLVM_BB_ADDR_MAP
+  # Link: 0 (by default)
+    Entries:
+      - Address: 0x33333
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x3
+            Metadata:      0x6
+)");
+
+  BBAddrMap E1({0x11111, {BBAddrMap::BBEntry({0x0, 0x1, 0x2})}});
+  BBAddrMap E2({0x22222, {BBAddrMap::BBEntry({0x0, 0x2, 0x4})}});
+  BBAddrMap E3({0x33333, {BBAddrMap::BBEntry({0x0, 0x3, 0x6})}});
+
+  std::vector<BBAddrMap> Section0BBAddrMaps = {E3};
+  std::vector<BBAddrMap> Section1BBAddrMaps = {E1, E2};
+  std::vector<BBAddrMap> AllBBAddrMaps = {E1, E2, E3};
+
+  auto DoCheckSucceeds = [&](StringRef YamlString,
+                             Optional<unsigned> TextSectionIndex,
+                             std::vector<BBAddrMap> ExpectedResult) {
+    SmallString<0> Storage;
+    Expected<ELFObjectFile<ELF64LE>> ElfOrErr =
+        toBinary<ELF64LE>(Storage, YamlString);
+    ASSERT_THAT_EXPECTED(ElfOrErr, Succeeded());
+
+    Expected<const typename ELF64LE::Shdr *> BBAddrMapSecOrErr =
+        ElfOrErr->getELFFile().getSection(1);
+    ASSERT_THAT_EXPECTED(BBAddrMapSecOrErr, Succeeded());
+    auto BBAddrMaps = ElfOrErr->readBBAddrMap(TextSectionIndex);
+    EXPECT_THAT_EXPECTED(BBAddrMaps, Succeeded());
+    EXPECT_EQ(*BBAddrMaps, ExpectedResult);
+  };
+
+  auto DoCheckFails = [&](StringRef YamlString,
+                          Optional<unsigned> TextSectionIndex,
+                          const char *ErrMsg) {
+    SmallString<0> Storage;
+    Expected<ELFObjectFile<ELF64LE>> ElfOrErr =
+        toBinary<ELF64LE>(Storage, YamlString);
+    ASSERT_THAT_EXPECTED(ElfOrErr, Succeeded());
+
+    Expected<const typename ELF64LE::Shdr *> BBAddrMapSecOrErr =
+        ElfOrErr->getELFFile().getSection(1);
+    ASSERT_THAT_EXPECTED(BBAddrMapSecOrErr, Succeeded());
+    EXPECT_THAT_ERROR(ElfOrErr->readBBAddrMap(TextSectionIndex).takeError(),
+                      FailedWithMessage(ErrMsg));
+  };
+
+  // Check that we can retrieve the data in the normal case.
+  DoCheckSucceeds(CommonYamlString, /*TextSectionIndex=*/None, AllBBAddrMaps);
+  DoCheckSucceeds(CommonYamlString, /*TextSectionIndex=*/0, Section0BBAddrMaps);
+  DoCheckSucceeds(CommonYamlString, /*TextSectionIndex=*/1, Section1BBAddrMaps);
+  // Check that when no bb-address-map section is found for a text section,
+  // we return empty result.
+  DoCheckSucceeds(CommonYamlString, /*TextSectionIndex=*/2, {});
+
+  // Check that we detect when a bb-addr-map section is linked to an invalid
+  // (not present) section.
+  SmallString<128> InvalidLinkedYamlString(CommonYamlString);
+  InvalidLinkedYamlString += R"(
+    Link: 10
+)";
+
+  DoCheckFails(InvalidLinkedYamlString, /*TextSectionIndex=*/1,
+               "unable to get the linked-to section for SHT_LLVM_BB_ADDR_MAP "
+               "section with index 3: invalid section index: 10");
+  // Linked sections are not checked when we don't target a specific text
+  // section.
+  DoCheckSucceeds(InvalidLinkedYamlString, /*TextSectionIndex=*/None,
+                  AllBBAddrMaps);
+
+  // Check that we can detect when bb-address-map decoding fails.
+  SmallString<128> TruncatedYamlString(CommonYamlString);
+  TruncatedYamlString += R"(
+    ShSize: 0x8
+)";
+
+  DoCheckFails(TruncatedYamlString, /*TextSectionIndex=*/None,
+               "unable to read SHT_LLVM_BB_ADDR_MAP section with index 3: "
+               "unable to decode LEB128 at offset 0x00000008: malformed "
+               "uleb128, extends past end");
+  // Check that when we can read the other section's bb-address-maps which are
+  // valid.
+  DoCheckSucceeds(TruncatedYamlString, /*TextSectionIndex=*/1,
+                  Section1BBAddrMaps);
+}
+
 // Test for ObjectFile::getRelocatedSection: check that it returns a relocated
 // section for executable and relocatable files.
 TEST(ELFObjectFileTest, ExecutableWithRelocs) {
   StringRef HeaderString(R"(
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB