[llvm-readelf] Support dumping the BB address map section with --bb-addr-map.

[rahmanl]

Summary

This patch lets llvm-readelf dump the content of the BB address map
section in the following format:

Function {
  At: <address>
  BB entries [
    {
      Offset:   <offset>
      Size:     <size>
      Metadata: <metadata>
    },
    ...
  ]
}
...

[rahmanl]

rebase.

[grimar]

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

38

I'd separate the YAML from the check lines with an empty line.
The same below.

Also I'd separate LLVM checks from GNU.

61

This needs a comment to describe what is exactly wrong with the section.
There are multiple possible issues that might occur, but you test only one of them.

I'd suggest to create a valid section and use ShSize key with a macro to truncate it
by different ways. This will allow to easily test each of cases

uint32_t Offset = Data.getULEB128(Cur);
uint32_t Size = Data.getULEB128(Cur);
uint32_t Metadata = Data.getULEB128(Cur);

I.e. you can just reuse the first YAML:

Sections:
  - Name:    .llvm_bb_addr_map
    Type:    SHT_LLVM_BB_ADDR_MAP
    ShSize: [[SIZE=<none>]] <--- just add this line and use the power of macros
    Entries:
.....

63

I am not sure that 0x{{([[:xdigit:]]{8})}} is usefull? I'd just check the offset.
Also I guess you can reuse this check line for other broken cases and have a [[OFFSET]] macro instead.

...  | FileCheck %s -DFILE=%t2.o --check-prefix=INVALID -DOFFSET=0x....
# INVALID: warning: '[[FILE]]': unable to dump the SHT_LLVM_BB_ADDR_MAP section: unable to decode LEB128 at offset [[OFFSET]]: malformed uleb128, extends past end

66

It is slightly misaligned vertically.

72

Usually we reduce the number of spaces to minimal.

- Name: .llvm_bb_addr_map
  Type: SHT_LLVM_BB_ADDR_MAP
  Size: 8

(The same applies for the first YAML).

llvm/tools/llvm-readobj/ELFDumper.cpp

6545

It would me more consistent to use the describe helper to build the message. E.g. see:

return createError("invalid section linked to " + describe(Obj, Sec) +
                   ": " + toString(SymtabOrErr.takeError()));

[jhenderson]

You need to add this option to the llvm-readobj and llvm-readelf command guides under llvm/docs/CommandGuide.

Ideally, I think you should add gtest unit tests for the libObject code. The lit test would then just (primarily) test the llvm-readobj handling of the potential return values of the parsing code.

llvm/include/llvm/Object/ELF.h

281

I'm not sure why some functions use _ instead of camelCase, but it's probably best you use the latter. Maybe put it after the notes functions so that we don't switch back and forth between styles too.

llvm/include/llvm/Object/ELFTypes.h

797

Is there a specification to point to somewhere for this section? If so, what case style does it use? If there isn't, we should probably use LLVM style, though I'm not sure.

llvm/lib/Object/ELF.cpp

379

getULEB128 can return uint64_t, so I'd use uint64_t here and below - it defers truncation of large values to as late as possible, which I think is a good thing. Optionally, also consider an error check that the values aren't greater than max UINT32. A ULEB128 has no defined max size, so if the input format is ULEB128, users might theoretically expect to allow more than 32-bits worth of data. Alternatively, consider using uin64_t for the struct member sizes. Values outside that range will be picked up by the ULEB parser and reported, so we don't need to do more then.

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

2

--bb-addr-map is the canonical option, so use that terminology in the comments rather than --elf-...

61

See also my out-of-line comment, but I think it would make more sense for the testing of the different ways things can go wrong to be in the libObject unit tests if possible, with just a single test in llvm-readobj lit tests showing that a warning is reported if there's a problem.

llvm/tools/llvm-readobj/llvm-readobj.cpp

373–374

Any particular reason for the elf alias? The alias is there for some older options (cg-profile specifically) because they were initially added as elf-..., so we keep the alias for backwards compatibility. If there isn't a reason, I'd drop it.

[rahmanl]

Test the 32-bit case.
Address @grimar's comments.

[rahmanl]

Thanks for the comments @grimar

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

61

Thanks for the suggestion. Adopted.
I am not sure if I want to exercise more invalid cases. Of course I can truncate the content by different sizes, but I don't think it will add a lot of value.

63

Thanks. Used [[OFFSET]] even though it's only used for one test case.

72

I removed this YAML since I am reusing the first YAML for the invalid case.

[rahmanl]

llvm/lib/Object/ELF.cpp

379

Thanks. Based on your suggestion, I plan to read these values as uint64_t and add cast to uint32_t (And add proper error checking). But I noticed that my elf2yaml code had the same problem (reading ULEB-encoded values as uint32_t). So I appreciate if you could please review D95767 before coming back to this patch.

[rahmanl]

• Decode ULEB128 as uint64_t and then cast to uint32_t. Report error if over the limit.

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

61

Thanks James. Allow me get to this (and the cmd documentation) after I get the logic right.
Would you mind elaborate on what specifically needs to be checked in the libObject unit test (Also, is there a precedent/example I can follow)?

[jhenderson]

Note to self: I've not yet reviewed the testing in depth. Need to do that still.

Would you mind elaborate on what specifically needs to be checked in the libObject unit test (Also, is there a precedent/example I can follow)?

The existing libObject unit tests are patchy at best, unfortunately, so finding a clear-cut precedent is a little tricky. Probably the easiest thing to do would be to follow things like the InvalidSymbolTest in ELFObjectFileTest.cpp to generate an ELFFile instance from YAML written as a string in the code. With a bit of care, you could probably dynamically build up the YAML string from common components to avoid a verbose string literal in each test case. Once you have an ELFFile instance, you can then just call decodeBBAddrMap on that. The aim of this test would be to test the code that is in the library directly, without worring about whatever llvm-readobj does. In particular, you can test all the error paths there, using things like EXPECT_THAT_EXPECTED(..., FailedWithMessage(...));. In the lit test, you could then treat the function as a black box and test only one way of getting the error (to show that the error is handled properly), plus that the dumpign code works as expected in a valid case. Does that make sense?

llvm/include/llvm/Object/ELFTypes.h

797

Nit: these comments probably all want trailing full stops.

llvm/lib/Object/ELF.cpp

620

Lambda case style is the same as variable case style (i.e. UpperCamelCase). I guess, because they're more like pointers to functions than functions themselves?

627

Coding standard for error messages is no trailing full stop (for consistency with most existing messages).

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

61

See out-of-line comment (moved out-of-line due to length).

[rahmanl]

• Move error path tests under libObject unittests.

[rahmanl]

Thanks @jhenderson. Your explanation was very helpful. Would you please advise on whether I should keep the error paths in the lit tests, as is?

[rahmanl]

• Add command line guides for llvm-readobj and llvm-readelf.

[mtrofin]

Can the output be consumed programmatically? (i.e. is it for example valid yaml or json)

[rahmanl]

In D95511#2541040, @mtrofin wrote:

Can the output be consumed programmatically? (i.e. is it for example valid yaml or json)

Yes, but it's not yaml or json. The output is std::vector<Elf_BBAddrMap> and it is accessible via the library call: ELFFile::decodeBBAddrMap(Elf_Shdr&) (However, the user needs to find the BB address map section).

[mtrofin]

In D95511#2541073, @rahmanl wrote:

In D95511#2541040, @mtrofin wrote:

Can the output be consumed programmatically? (i.e. is it for example valid yaml or json)

Yes, but it's not yaml or json. The output is std::vector<Elf_BBAddrMap> and it is accessible via the library call: ELFFile::decodeBBAddrMap(Elf_Shdr&) (However, the user needs to find the BB address map section).

I meant the textual output. It's very close to json - the benefit of it actually being json is that one could script from llvm-readobj output.

The other question - looking at the textual output, could it go the next step and produce the association bbaddress - name? My thinking is that the user of the output would find that more valuable (quick scripting, for instance)

[rahmanl]

In D95511#2541083, @mtrofin wrote:

In D95511#2541073, @rahmanl wrote:

In D95511#2541040, @mtrofin wrote:

Can the output be consumed programmatically? (i.e. is it for example valid yaml or json)

Yes, but it's not yaml or json. The output is std::vector<Elf_BBAddrMap> and it is accessible via the library call: ELFFile::decodeBBAddrMap(Elf_Shdr&) (However, the user needs to find the BB address map section).

I meant the textual output. It's very close to json - the benefit of it actually being json is that one could script from llvm-readobj output.

I see. You're right. The output is similar to json. This is produced by ScopedPrinter. The relevant sources do not point out similarity with JSON at all. Maybe @jhenderson can answer this.

The other question - looking at the textual output, could it go the next step and produce the association bbaddress - name? My thinking is that the user of the output would find that more valuable (quick scripting, for instance)

This is a good point. Currently, the bb-address-map is only generated using -fbasic-block-sections=labels which also renumbers the basic block in ascending. So we can say that the MBB number associated with the i'th BB entry is i.

[jhenderson]

In D95511#2541120, @rahmanl wrote:

In D95511#2541083, @mtrofin wrote:

In D95511#2541073, @rahmanl wrote:

In D95511#2541040, @mtrofin wrote:

Can the output be consumed programmatically? (i.e. is it for example valid yaml or json)

Yes, but it's not yaml or json. The output is std::vector<Elf_BBAddrMap> and it is accessible via the library call: ELFFile::decodeBBAddrMap(Elf_Shdr&) (However, the user needs to find the BB address map section).

I meant the textual output. It's very close to json - the benefit of it actually being json is that one could script from llvm-readobj output.

I see. You're right. The output is similar to json. This is produced by ScopedPrinter. The relevant sources do not point out similarity with JSON at all. Maybe @jhenderson can answer this.

The LLVM-style output format for llvm-readobj is not intended to be JSON, although it is somewhat similar. Primarily, the output is intended for ease of testing within the LLVM lit tests. See in particular the second of the following two commits (the first contains some general rules for the output format).

https://github.com/llvm/llvm-project/commit/9cad53cfeceed2ef75aa17f0553edd27afd2e950
https://github.com/llvm/llvm-project/commit/d7e7003e8b2d4632b72533e0d05ad5558e5bdcbc#diff-53e1a2a2a247ad1a4cac5242c17c0aa36eefdec70b4369fb31f911aaf89aad2c

I don't think it's practical to make the general output JSON-like due to the amount of turbulence this would cause. If there's a particularly strong desire to do this, it should be discussed on llvm-dev in the first instance, I think, and secondly, I think would be best as a third output format (e.g. --elf-output-style=json).

llvm/docs/CommandGuide/llvm-readelf.rst

37

Spell out "BB". I assume it is "basic block"? Also, as this is only implemented for LLVM output style, I'd mention that in the documentation. Also, you say "section(s)", implying there might be more than one. However, the code only supports dumping a single section per object file. Either your code or your documentation needs updating!

llvm/docs/CommandGuide/llvm-readobj.rst

153

Same as above.

llvm/include/llvm/Object/ELFTypes.h

800

llvm/lib/Object/ELF.cpp

643–644

I might be mistaken, but won't this cause an assertion due to Cur not being checked and reported if it is in a bad state? I think it could happen if reading NumBlocks produces too large a number, and then a later value is truncated (for example).

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

18

But actually, you only need one of this and the above test case that checks the error behaviour in a lit test - the libObject unit test is sufficient for the other failure path(s). In fact, you should probably change the comment of the kept error case, simply to say something like "Check that a malformed section can be handled."

llvm/unittests/Object/ELFObjectFileTest.cpp

515

I'm not sure this line is really needed?

529

[rahmanl]

• Support dumping multiple BB address map sections.
• Address other @jhenderson's comments.

[rahmanl]

• Support dumping multiple BB address map sections.
• Add a unit test to check that we don't generate an unhandled error.
• Keep only one error path in the lit test.

[rahmanl]

llvm/docs/CommandGuide/llvm-readelf.rst

37

You're right. I am changing the code to support dumping multiple BB address map sections.

llvm/lib/Object/ELF.cpp

643–644

Thanks for the scrutiny. I think this won't happen because ReadULEB128AsUInt32 always checks ULEBSizeErr and return zero if it's in the error state. However, if we ever read with Data.getULEB128(Cur) we may run into the unhandled error problem.
I added a unit test case to exercise the case that you mentioned, but at this point, I am not sure if the benefit of restricting to uint32_t outweighs the readability cost of this code.

[rahmanl]

• Add a dummy SHT_PROGBITS section in the test for further test coverage.

[jhenderson]

llvm/lib/Object/ELF.cpp

637

If the ULEB for NumBlocks happened to be 0xffffffffffffffff, I think NumBlocks will be 0xffffffff, which will mean you'll add that many (0, 0, 0) entries to BBEntries. I suspect this is best avoided due to the time and memory cost before you eventually get the reported error.

Adding an extra check to ensure ULEBSizeErr isn't bad here is probably necessary.

643–644

I see, yes. I'd prefer to keep the checks, but if you think it's really making it hard to read, I'm not opposed to reverting to a version without them.

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

60

Would it make sense to show that the second section is still dumped in this case?

87

Why ShSize? Do you mean Size to give it a non-zero actual size on disk? (ShSize overrides only the value in the header - it doesn't impact the section placement).

llvm/tools/llvm-readobj/ELFDumper.cpp

553

Here and below, it looks like clang-tidy is unhappy. You probably need to change the base virtual function?

[rahmanl]

• Handle @jhenderson's comments.
• Add a test for error handling when NumBlocks is out-of-range.

[rahmanl]

Thanks for the comments @jhenderson

llvm/lib/Object/ELF.cpp

637

Thanks. You're right.
I am fixing this in two ways:

1. Changing ReadULEB128AsUInt32 to return zero when ULEBSizeErr is set.
2. Checking ULEBSizeErr in the inner loop to prevent from further iteration when the error is set (similar to the cursor error).

After this change, the unit test failed with "Success values must still be checked prior to being destroyed" which made me realize that the error checking order may leave the Cursor error unchecked. So I reversed the checks after the loop to fix it.

I also added a test which exercises the case that you mentioned. Had to encode ULEB128 since our YAML format does not take in NumBlocks as input.

643–644

Thanks. I am going to keep the uint32_t restriction. It's not looking bad.

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

87

You're right. Fixed. (I now understand why we use ShSize for truncating the section).

[rahmanl]

• Remove errs() lines.

[jhenderson]

llvm/lib/Object/ELF.cpp

624

644

clang-format is complaining.

Had to encode ULEB128 since our YAML format does not take in NumBlocks as input.

Sounds like this should be added to the YAML input support, so that you can write a custom NumBlocks value that doesn't match the real number of blocks. We do similar things for ELF sections for example, where you can override the implicit value with a value of your own choice which gets written to the field.

652–659

This is probably fine, but feels a little fragile. How about using joinErrors to combine the two errors into a single one that can be reported, as suggested in the inline edit? That also avoids any risk of problems in the event the code changes such that they could both be in a bad state. joinErrors of an Error::success() and a non-success Error is safe and equivalent to just returning the actual Error, if I remember correctly.

llvm/unittests/Object/ELFObjectFileTest.cpp

583

Consider instead making the suggested yaml2obj change first, and then using that for this test case.

[rahmanl]

• Use joinErrors to join ULEBSizeErr and the cursor error.

[rahmanl]

llvm/lib/Object/ELF.cpp

644

Thanks for the suggestion. Please review D96831.

[jhenderson]

llvm/lib/Object/ELF.cpp

653

Let's use the variable name explicitly.

[rahmanl]

• Use the NumBlocks field in the unit test, instead of encoding by hand.
• Change the type of 'NumBlocks' to uint64_t so we can write the invalid unit test.

[rahmanl]

• Use Cur instead of cursor in the comment.

[rahmanl]

• Decode the Metadata field consistently with the encoding in AsmPrinter::getBBAddrMapMetadata.

[rahmanl]

In D95511#2570218, @rahmanl wrote:

• Decode the Metadata field consistently with the encoding in AsmPrinter::getBBAddrMapMetadata.

@jhenderson and @shenhan I decided to decode the Metadata field right here so the user wouldn't need to worry about it.

[jhenderson]

I'd like to do another review pass of the testing before signing off on this, but generally, this is looking good.

llvm/include/llvm/Object/ELFTypes.h

803

Typo/incomplete sentence?

llvm/unittests/Object/ELFObjectFileTest.cpp

583

I would suggest either "Check for proper error ..." or "Check proper error ..."

[rahmanl]

Fix typos.

[rahmanl]

In D95511#2578440, @jhenderson wrote:

I'd like to do another review pass of the testing before signing off on this, but generally, this is looking good.

No worries. Please take your time.

[jhenderson]

Just a few small suggestions, otherwise this looks good, thanks!

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

4

Maybe : or . to end this and the Check 32 bit line.

9

I'm not sure "x32" is really a thing. I think you probably just want to call it "64-bit" and "32-bit".

llvm/unittests/Object/ELFObjectFileTest.cpp

533

It might make sense to do proper edge-case testing here, with values of 0xffffffff and 0x100000000.

[rahmanl]

• Typos and edge-cases.

llvm/unittests/Object/ELFObjectFileTest.cpp

533

Good idea. Done here and below.

[rahmanl]

@jhenderson Is this good now? Thanks for the review.

[jhenderson]

Apologies for the delay - I've missed most of this week due to illness. LGTM.

[rahmanl]

In D95511#2605783, @jhenderson wrote:

Apologies for the delay - I've missed most of this week due to illness. LGTM.

Thank you for the review. Hope everything is going well for you now.

llvm/docs/CommandGuide/llvm-readelf.rst

 .. option:: --addrsig
 
  Display the address-significance table.
 
 .. option:: --arch-specific, -A
 
  Display architecture-specific information, e.g. the ARM attributes section on ARM.
 
+.. option:: --bb-addr-map
+
+ Display the contents of the basic block address map section(s), which contain the
+ address of each function, along with the relative offset of each basic block.
+
 .. option:: --color
 
  Use colors in the output for warnings and errors.
 
 .. option:: --demangle, -C
 
  Display demangled symbol names in the output.
 

llvm/docs/CommandGuide/llvm-readobj.rst

 --------------------
 
 The following options are implemented only for the ELF file format.
 
 .. option:: --arch-specific, -A
 
  Display architecture-specific information, e.g. the ARM attributes section on ARM.
 
+.. option:: --bb-addr-map
+
+ Display the contents of the basic block address map section(s), which contain the
+ address of each function, along with the relative offset of each basic block.
+
 .. option:: --demangle, -C
 
  Display demangled symbol names in the output.
 
 .. option:: --dependent-libraries
 
  Display the dependent libraries section.
 

llvm/include/llvm/Object/ELF.h

Expected<Elf_Relr_Range> relrs(const Elf_Shdr &Sec) const {
     return getSectionContentsAsArray<Elf_Relr>(Sec);
   }
 
   std::vector<Elf_Rel> decode_relrs(Elf_Relr_Range relrs) const;
 
   Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr &Sec) const;
 
   /// Iterate over program header table.
   Expected<Elf_Phdr_Range> program_headers() const {
     if (getHeader().e_phnum && getHeader().e_phentsize != sizeof(Elf_Phdr))
       return createError("invalid e_phentsize: " +
                          Twine(getHeader().e_phentsize));
 
     uint64_t HeadersSize =
         (uint64_t)getHeader().e_phnum * getHeader().e_phentsize;
     uint64_t PhOff = getHeader().e_phoff;
     if (PhOff + HeadersSize < PhOff || PhOff + HeadersSize > getBufSize())
public:
   getSectionName(const Elf_Shdr &Section,
                  WarningHandler WarnHandler = &defaultWarningHandler) const;
   Expected<StringRef> getSectionName(const Elf_Shdr &Section,
                                      StringRef DotShstrtab) const;
   template <typename T>
   Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr &Sec) const;
   Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr &Sec) const;
   Expected<ArrayRef<uint8_t>> getSegmentContents(const Elf_Phdr &Phdr) const;
+  Expected<std::vector<Elf_BBAddrMap>>
+  decodeBBAddrMap(const Elf_Shdr &Sec) const;
 };
 
 using ELF32LEFile = ELFFile<ELF32LE>;
 using ELF64LEFile = ELFFile<ELF64LE>;
 using ELF32BEFile = ELFFile<ELF32BE>;
 using ELF64BEFile = ELFFile<ELF64BE>;
 
 template <class ELFT>

llvm/include/llvm/Object/ELFTypes.h

 template <class ELFT> struct Elf_Versym_Impl;
 template <class ELFT> struct Elf_Hash_Impl;
 template <class ELFT> struct Elf_GnuHash_Impl;
 template <class ELFT> struct Elf_Chdr_Impl;
 template <class ELFT> struct Elf_Nhdr_Impl;
 template <class ELFT> class Elf_Note_Impl;
 template <class ELFT> class Elf_Note_Iterator_Impl;
 template <class ELFT> struct Elf_CGProfile_Impl;
+template <class ELFT> struct Elf_BBAddrMap_Impl;
 
 template <endianness E, bool Is64> struct ELFType {
 private:
   template <typename Ty>
   using packed = support::detail::packed_endian_specific_integral<Ty, E, 1>;
 
 public:
   static const endianness TargetEndianness = E;
public:
   using Versym = Elf_Versym_Impl<ELFType<E, Is64>>;
   using Hash = Elf_Hash_Impl<ELFType<E, Is64>>;
   using GnuHash = Elf_GnuHash_Impl<ELFType<E, Is64>>;
   using Chdr = Elf_Chdr_Impl<ELFType<E, Is64>>;
   using Nhdr = Elf_Nhdr_Impl<ELFType<E, Is64>>;
   using Note = Elf_Note_Impl<ELFType<E, Is64>>;
   using NoteIterator = Elf_Note_Iterator_Impl<ELFType<E, Is64>>;
   using CGProfile = Elf_CGProfile_Impl<ELFType<E, Is64>>;
+  using BBAddrMap = Elf_BBAddrMap_Impl<ELFType<E, Is64>>;
   using DynRange = ArrayRef<Dyn>;
   using ShdrRange = ArrayRef<Shdr>;
   using SymRange = ArrayRef<Sym>;
   using RelRange = ArrayRef<Rel>;
   using RelaRange = ArrayRef<Rela>;
   using RelrRange = ArrayRef<Relr>;
   using PhdrRange = ArrayRef<Phdr>;
 
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)                                       \
   using Elf_Vernaux = typename ELFT::Vernaux;                                  \
   using Elf_Versym = typename ELFT::Versym;                                    \
   using Elf_Hash = typename ELFT::Hash;                                        \
   using Elf_GnuHash = typename ELFT::GnuHash;                                  \
   using Elf_Nhdr = typename ELFT::Nhdr;                                        \
   using Elf_Note = typename ELFT::Note;                                        \
   using Elf_Note_Iterator = typename ELFT::NoteIterator;                       \
   using Elf_CGProfile = typename ELFT::CGProfile;                              \
+  using Elf_BBAddrMap = typename ELFT::BBAddrMap;                              \
   using Elf_Dyn_Range = typename ELFT::DynRange;                               \
   using Elf_Shdr_Range = typename ELFT::ShdrRange;                             \
   using Elf_Sym_Range = typename ELFT::SymRange;                               \
   using Elf_Rel_Range = typename ELFT::RelRange;                               \
   using Elf_Rela_Range = typename ELFT::RelaRange;                             \
   using Elf_Relr_Range = typename ELFT::RelrRange;                             \
-  using Elf_Phdr_Range = typename ELFT::PhdrRange;                             \
+  using Elf_Phdr_Range = typename ELFT::PhdrRange;
 
 #define LLVM_ELF_COMMA ,
 #define LLVM_ELF_IMPORT_TYPES(E, W)                                            \
   LLVM_ELF_IMPORT_TYPES_ELFT(ELFType<E LLVM_ELF_COMMA W>)
 
 // Section header.
 template <class ELFT> struct Elf_Shdr_Base;
 
template <class ELFT> struct Elf_Mips_ABIFlags {
   uint8_t cpr2_size; // Co-processor 2 registers size
   uint8_t fp_abi;    // Floating-point ABI flag
   Elf_Word isa_ext;  // Processor-specific extension
   Elf_Word ases;     // ASEs flags
   Elf_Word flags1;   // General flags
   Elf_Word flags2;   // General flags
 };
 
+// Struct representing the BBAddrMap for one function.
+template <class ELFT> struct Elf_BBAddrMap_Impl {
+  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
+  uintX_t Addr; // Function address
+  // Struct representing the BBAddrMap information for one basic block.
+  struct BBEntry {
+    uint32_t Offset;   // Offset of basic block relative to function start.
+    uint32_t Size;     // Size of the basic block.
+    uint32_t Metadata; // Metadata for this basic block.
+  };
+  std::vector<BBEntry> BBEntries; // Basic block entries for this function.
+};
+
 } // end namespace object.
 } // end namespace llvm.
 
 #endif // LLVM_OBJECT_ELFTYPES_H

llvm/include/llvm/ObjectYAML/ELFYAML.h

 
 struct BBAddrMapEntry {
   struct BBEntry {
     llvm::yaml::Hex64 AddressOffset;
     llvm::yaml::Hex64 Size;
     llvm::yaml::Hex64 Metadata;
   };
   llvm::yaml::Hex64 Address;
-  Optional<uint32_t> NumBlocks;
+  Optional<uint64_t> NumBlocks;
   Optional<std::vector<BBEntry>> BBEntries;
 };
 
 struct StackSizeEntry {
   llvm::yaml::Hex64 Address;
   llvm::yaml::Hex64 Size;
 };
 

llvm/lib/Object/ELF.cpp

ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
   // This function reads relocations in Android's packed relocation format,
   // which is based on SLEB128 and delta encoding.
   Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
   if (!ContentsOrErr)
     return ContentsOrErr.takeError();
   ArrayRef<uint8_t> Content = *ContentsOrErr;
   if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' ||
       Content[2] != 'S' || Content[3] != '2')
     return createError("invalid packed relocation header");
   DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
   DataExtractor::Cursor Cur(/*Offset=*/4);
 
   uint64_t NumRelocs = Data.getSLEB128(Cur);
   uint64_t Offset = Data.getSLEB128(Cur);
   uint64_t Addend = 0;
 
   if (!Cur)
return createError("can't map virtual address 0x" +
                        ": the segment ends at 0x" +
                        Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
                        ", which is greater than the file size (0x" +
                        Twine::utohexstr(getBufSize()) + ")");
 
   return base() + Offset;
 }
 
+template <class ELFT>
+Expected<std::vector<typename ELFT::BBAddrMap>>
+ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec) const {
+  Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
+  if (!ContentsOrErr)
+    return ContentsOrErr.takeError();
+  ArrayRef<uint8_t> Content = *ContentsOrErr;
+  DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
+  std::vector<Elf_BBAddrMap> FunctionEntries;
+
+  DataExtractor::Cursor Cur(0);
+  Error ULEBSizeErr = Error::success();
+
+  // Helper to extract and decode the next ULEB128 value as uint32_t.
+  // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the uint32_t
+  // limit.
+  // Also returns zero if ULEBSizeErr is already in an error state.
+  auto ReadULEB128AsUInt32 = [&Data, &Cur, &ULEBSizeErr]() -> uint32_t {
+    // Bail out and do not extract data if ULEBSizeErr is already set.
+    if (ULEBSizeErr)
+      return 0;
+    uint64_t Offset = Cur.tell();
+    uint64_t Value = Data.getULEB128(Cur);
+    if (Value > UINT32_MAX) {
+      ULEBSizeErr = createError(
+          "ULEB128 value at offset 0x" + Twine::utohexstr(Offset) +
+          " exceeds UINT32_MAX (0x" + Twine::utohexstr(Value) + ")");
+      return 0;
+    }
+    return static_cast<uint32_t>(Value);
+  };
+
+  while (!ULEBSizeErr && Cur && Cur.tell() < Content.size()) {
+    uintX_t Address = static_cast<uintX_t>(Data.getAddress(Cur));
+    uint32_t NumBlocks = ReadULEB128AsUInt32();
+    std::vector<typename Elf_BBAddrMap::BBEntry> BBEntries;
+    for (uint32_t BlockID = 0; !ULEBSizeErr && Cur && (BlockID < NumBlocks);
+         ++BlockID) {
+      uint32_t Offset = ReadULEB128AsUInt32();
+      uint32_t Size = ReadULEB128AsUInt32();
+      uint32_t Metadata = ReadULEB128AsUInt32();
+      BBEntries.push_back({Offset, Size, Metadata});
+    }
+    FunctionEntries.push_back({Address, BBEntries});
+  }
+  // Either Cur is in the error state, or ULEBSizeError is set (not both), but
+  // we join the two errors here to be safe.
+  if (!Cur || ULEBSizeErr)
+    return joinErrors(Cur.takeError(), std::move(ULEBSizeErr));
+  return FunctionEntries;
+}
+
 template class llvm::object::ELFFile<ELF32LE>;
 template class llvm::object::ELFFile<ELF32BE>;
 template class llvm::object::ELFFile<ELF64LE>;
 template class llvm::object::ELFFile<ELF64BE>;

llvm/lib/ObjectYAML/ELFEmitter.cpp

void ELFState<ELFT>::writeSectionContent(
   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). This
     // is overriden by the 'NumBlocks' YAML field if specified.
-    uint32_t NumBlocks =
+    uint64_t NumBlocks =
         E.NumBlocks.getValueOr(E.BBEntries ? E.BBEntries->size() : 0);
     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(NumBlocks);
     // Write all BBEntries.
     if (!E.BBEntries)
       continue;
     for (const ELFYAML::BBAddrMapEntry::BBEntry &BBE : *E.BBEntries)
       SHeader.sh_size += CBA.writeULEB128(BBE.AddressOffset) +
                          CBA.writeULEB128(BBE.Size) +

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

+## This test checks how we handle the --bb-addr-map option.
+
+## Check x64
+# RUN: yaml2obj %s -DBITS=64 -DADDR=0xFFFFFFFF1 -o %t1.x64.o
+# RUN: llvm-readobj %t1.x64.o --bb-addr-map | FileCheck %s -DADDR=0xFFFFFFFF1 --check-prefix=LLVM
+# RUN: llvm-readelf %t1.x64.o --bb-addr-map | FileCheck %s --check-prefix=GNU
+
+## Check x32
+# RUN: yaml2obj %s -DBITS=32 -o %t1.x32.o
+# RUN: llvm-readobj %t1.x32.o --bb-addr-map | FileCheck -DADDR=0x11111 %s --check-prefix=LLVM
+# RUN: llvm-readelf %t1.x32.o --bb-addr-map | FileCheck %s --check-prefix=GNU
+
+## Check that a malformed section can be handled.
+# RUN: yaml2obj %s -DBITS=32 -DSIZE=4 -o %t2.o
+# RUN: llvm-readobj %t2.o --bb-addr-map 2>&1 | FileCheck %s -DOFFSET=0x00000004 -DFILE=%t2.o --check-prefix=TRUNCATED
+
+# LLVM:      BBAddrMap [
+# LLVM-NEXT:   Function {
+# LLVM-NEXT:     At: [[ADDR]]
+# LLVM-NEXT:     BB entries [
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Offset: 0x0
+# LLVM-NEXT:         Size: 0x1
+# LLVM-NEXT:         Metadata: 0xF0000002
+# LLVM-NEXT:       }
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Offset: 0x3
+# LLVM-NEXT:         Size: 0x4
+# LLVM-NEXT:         Metadata: 0x5
+# LLVM-NEXT:       }
+# LLVM-NEXT:     ]
+# LLVM-NEXT:   }
+# LLVM-NEXT:   Function {
+# LLVM-NEXT:     At: 0x22222
+# LLVM-NEXT:     BB entries [
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Offset: 0x6
+# LLVM-NEXT:         Size: 0x7
+# LLVM-NEXT:         Metadata: 0x8
+# LLVM-NEXT:       }
+# LLVM-NEXT:     ]
+# LLVM-NEXT:   }
+# LLVM-NEXT: ]
+# LLVM-NEXT: BBAddrMap [
+# LLVM-NEXT:   Function {
+# LLVM-NEXT:     At: 0x33333
+# LLVM-NEXT:     BB entries [
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Offset: 0x9
+# LLVM-NEXT:         Size: 0xA
+# LLVM-NEXT:         Metadata: 0xB
+# LLVM-NEXT:       }
+# LLVM-NEXT:     ]
+# LLVM-NEXT:   }
+# LLVM-NEXT: ]
+
+# GNU: GNUStyle::printBBAddrMaps not implemented
+
+# TRUNCATED:      BBAddrMap [
+# TRUNCATED-NEXT:   warning: '[[FILE]]': unable to dump SHT_LLVM_BB_ADDR_MAP section with index 1: unable to decode LEB128 at offset [[OFFSET]]: malformed uleb128, extends past end
+# TRUNCATED-NEXT: ]
+## Check that the other valid section is properly dumped.
+# TRUNCATED-NEXT: BBAddrMap [
+# TRUNCATED-NEXT:   Function {
+# TRUNCATED-NEXT:          At: 0x33333
+# TRUNCATED-NEXT:          BB entries [
+# TRUNCATED-NEXT:            {
+# TRUNCATED-NEXT:         Offset: 0x9
+# TRUNCATED-NEXT:         Size: 0xA
+# TRUNCATED-NEXT:         Metadata: 0xB
+# TRUNCATED-NEXT:       }
+# TRUNCATED-NEXT:     ]
+# TRUNCATED-NEXT:   }
+# TRUNCATED-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS[[BITS]]
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:   bb_addr_map_1
+    Type:   SHT_LLVM_BB_ADDR_MAP
+    ShSize: [[SIZE=<none>]]
+    Entries:
+      - Address: [[ADDR=0x11111]]
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0xF0000002
+          - AddressOffset: 0x3
+            Size:          0x4
+            Metadata:      0x5
+      - Address: 0x22222
+        BBEntries:
+          - AddressOffset: 0x6
+            Size:          0x7
+            Metadata:      0x8
+  - Name:   dummy_section
+    Type:   SHT_PROGBITS
+    Size:   16
+  - Name:   bb_addr_map_2
+    Type:   SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - Address: 0x33333
+        BBEntries:
+          - AddressOffset: 0x9
+            Size:          0xa
+            Metadata:      0xb

llvm/tools/llvm-readobj/ELFDumper.cpp

void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
                           bool NonVisibilityBitsUsed) const override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const Elf_Shdr *Sec) override;
   void printHashHistograms() override;
   void printCGProfile() override;
+  void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
 
 private:
   void printHashHistogram(const Elf_Hash &HashTable);
   void printGnuHashHistogram(const Elf_GnuHash &GnuHashTable);
public:
   void printDynamicRelocations() override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const Elf_Shdr *Sec) override;
   void printHashHistograms() override;
   void printCGProfile() override;
+  void printBBAddrMaps() override;
   void printAddrsig() override;
   void printNotes() override;
   void printELFLinkerOptions() override;
   void printStackSizes() override;
 
 private:
   void printRelrReloc(const Elf_Relr &R) override;
   void printRelRelaReloc(const Relocation<ELFT> &R,
else
       printGnuHashHistogram(*this->GnuHashTable);
   }
 }
 
 template <class ELFT> void GNUELFDumper<ELFT>::printCGProfile() {
   OS << "GNUStyle::printCGProfile not implemented\n";
 }
 
+template <class ELFT> void GNUELFDumper<ELFT>::printBBAddrMaps() {
+  OS << "GNUStyle::printBBAddrMaps not implemented\n";
+}
+
 static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) {
   std::vector<uint64_t> Ret;
   const uint8_t *Cur = Data.begin();
   const uint8_t *End = Data.end();
   while (Cur != End) {
     unsigned Size;
     const char *Err;
     Ret.push_back(decodeULEB128(Cur, &Size, End, &Err));
for (const Elf_CGProfile &CGPE : *CGProfileOrErr) {
     W.printNumber("From", this->getStaticSymbolName(CGPE.cgp_from),
                   CGPE.cgp_from);
     W.printNumber("To", this->getStaticSymbolName(CGPE.cgp_to),
                   CGPE.cgp_to);
     W.printNumber("Weight", CGPE.cgp_weight);
   }
 }
 
+template <class ELFT> void LLVMELFDumper<ELFT>::printBBAddrMaps() {
+  for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
+    if (Sec.sh_type != SHT_LLVM_BB_ADDR_MAP)
+      continue;
+    ListScope L(W, "BBAddrMap");
+    Expected<std::vector<Elf_BBAddrMap>> BBAddrMapOrErr =
+        this->Obj.decodeBBAddrMap(Sec);
+    if (!BBAddrMapOrErr) {
+      this->reportUniqueWarning("unable to dump " + this->describe(Sec) + ": " +
+                                toString(BBAddrMapOrErr.takeError()));
+      continue;
+    }
+    for (const Elf_BBAddrMap &AM : *BBAddrMapOrErr) {
+      DictScope D(W, "Function");
+      W.printHex("At", AM.Addr);
+      ListScope L(W, "BB entries");
+      for (const typename Elf_BBAddrMap::BBEntry &BBE : AM.BBEntries) {
+        DictScope L(W);
+        W.printHex("Offset", BBE.Offset);
+        W.printHex("Size", BBE.Size);
+        W.printHex("Metadata", BBE.Metadata);
+      }
+    }
+  }
+}
+
 template <class ELFT> void LLVMELFDumper<ELFT>::printAddrsig() {
   ListScope L(W, "Addrsig");
   if (!this->DotAddrsigSec)
     return;
 
   Expected<std::vector<uint64_t>> SymsOrErr =
       decodeAddrsigSection(this->Obj, *this->DotAddrsigSec);
   if (!SymsOrErr) {

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printHashTable() { }
   virtual void printGnuHashTable() {}
   virtual void printHashSymbols() {}
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistograms() {}
   virtual void printCGProfile() {}
+  virtual void printBBAddrMaps() {}
   virtual void printAddrsig() {}
   virtual void printNotes() {}
   virtual void printELFLinkerOptions() {}
   virtual void printStackSizes() {}
   virtual void printSectionDetails() {}
   virtual void printArchSpecificInfo() {}
 
   // Only implemented for PE/COFF.

llvm/tools/llvm-readobj/llvm-readobj.cpp

cl::alias HistogramAlias("histogram",
                            cl::aliasopt(HashHistogram));
 
   // --cg-profile
   cl::opt<bool> CGProfile("cg-profile",
                           cl::desc("Display callgraph profile section"));
   cl::alias ELFCGProfile("elf-cg-profile", cl::desc("Alias for --cg-profile"),
                          cl::aliasopt(CGProfile));
 
+  // --bb-addr-map
+  cl::opt<bool> BBAddrMap("bb-addr-map",
+                          cl::desc("Display the BB address map section"));
+
   // -addrsig
   cl::opt<bool> Addrsig("addrsig",
                         cl::desc("Display address-significance table"));
 
   // -elf-output-style
   cl::opt<OutputStyleTy>
       Output("elf-output-style", cl::desc("Specify ELF dump style"),
              cl::values(clEnumVal(LLVM, "LLVM default style"),
                         clEnumVal(GNU, "GNU readelf style")),
if (Obj.isELF()) {
     if (opts::ArchSpecificInfo)
       Dumper->printArchSpecificInfo();
     if (opts::SectionGroups)
       Dumper->printGroupSections();
     if (opts::HashHistogram)
       Dumper->printHashHistograms();
     if (opts::CGProfile)
       Dumper->printCGProfile();
+    if (opts::BBAddrMap)
+      Dumper->printBBAddrMaps();
     if (opts::Addrsig)
       Dumper->printAddrsig();
     if (opts::Notes)
       Dumper->printNotes();
   }
   if (Obj.isCOFF()) {
     if (opts::COFFImports)
       Dumper->printCOFFImports();

llvm/unittests/Object/ELFObjectFileTest.cpp

)");
   // table.
   DoCheck(0x1, "can't read an entry at 0x18: it goes past the end of the "
                "section (0x18)");
 
   // We create a symbol with an index that is too large to exist in the object.
   DoCheck(0xFFFFFFFF, "can't read an entry at 0x17ffffffe8: it goes past the "
                       "end of the section (0x18)");
 }
+
+// Tests for error paths of the ELFFile::decodeBBAddrMap API.
+TEST(ELFObjectFileTest, InvalidBBAddrMap) {
+  StringRef CommonYamlString(R"(
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name: .llvm_bb_addr_map
+    Type: SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - Address: 0x11111
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0x2
+)");
+
+  auto DoCheck = [&](StringRef YamlString, const char *ErrMsg) {
+    SmallString<0> Storage;
+    Expected<ELFObjectFile<ELF64LE>> ElfOrErr =
+        toBinary<ELF64LE>(Storage, YamlString);
+    ASSERT_THAT_EXPECTED(ElfOrErr, Succeeded());
+    const ELFFile<ELF64LE> &Elf = ElfOrErr->getELFFile();
+
+    Expected<const typename ELF64LE::Shdr *> BBAddrMapSecOrErr =
+        Elf.getSection(1);
+    ASSERT_THAT_EXPECTED(BBAddrMapSecOrErr, Succeeded());
+    EXPECT_THAT_ERROR(Elf.decodeBBAddrMap(**BBAddrMapSecOrErr).takeError(),
+                      FailedWithMessage(ErrMsg));
+  };
+
+  // Check that we can detect the malformed encoding when the section is
+  // truncated.
+  SmallString<128> TruncatedYamlString(CommonYamlString);
+  TruncatedYamlString += R"(
+    ShSize: 0x8
+)";
+  DoCheck(TruncatedYamlString, "unable to decode LEB128 at offset 0x00000008: "
+                               "malformed uleb128, extends past end");
+
+  // Check that we can detect when the encoded BB entry fields exceed the UINT32
+  // limit.
+  SmallVector<SmallString<128>, 3> OverInt32LimitYamlStrings(3,
+                                                             CommonYamlString);
+  OverInt32LimitYamlStrings[0] += R"(
+          - AddressOffset: 0xFFFFFFFF3
+            Size:          0x4
+            Metadata:      0x5
+)";
+
+  OverInt32LimitYamlStrings[1] += R"(
+          - AddressOffset: 0x3
+            Size:          0xFFFFFFFF4
+            Metadata:      0x5
+)";
+
+  OverInt32LimitYamlStrings[2] += R"(
+          - AddressOffset: 0x3
+            Size:          0x4
+            Metadata:      0xFFFFFFFF5
+)";
+
+  DoCheck(OverInt32LimitYamlStrings[0],
+          "ULEB128 value at offset 0xc exceeds UINT32_MAX (0xffffffff3)");
+  DoCheck(OverInt32LimitYamlStrings[1],
+          "ULEB128 value at offset 0xd exceeds UINT32_MAX (0xffffffff4)");
+  DoCheck(OverInt32LimitYamlStrings[2],
+          "ULEB128 value at offset 0xe exceeds UINT32_MAX (0xffffffff5)");
+
+  // Check the proper error handling when the section has fields exceeding
+  // UINT32 and is also truncated. This is for checking that we don't generate
+  // unhandled errors.
+  SmallVector<SmallString<128>, 3> OverInt32LimitAndTruncated(
+      3, OverInt32LimitYamlStrings[1]);
+  // Truncate before the end of the 5-byte field.
+  OverInt32LimitAndTruncated[0] += R"(
+    ShSize: 0x12
+)";
+  // Truncate at the end of the 5-byte field.
+  OverInt32LimitAndTruncated[1] += R"(
+    ShSize: 0x13
+)";
+  // Truncate after the end of the 5-byte field.
+  OverInt32LimitAndTruncated[2] += R"(
+    ShSize: 0x14
+)";
+
+  DoCheck(OverInt32LimitAndTruncated[0],
+          "unable to decode LEB128 at offset 0x0000000d: malformed uleb128, "
+          "extends past end");
+  DoCheck(OverInt32LimitAndTruncated[1],
+          "ULEB128 value at offset 0xd exceeds UINT32_MAX (0xffffffff4)");
+  DoCheck(OverInt32LimitAndTruncated[2],
+          "ULEB128 value at offset 0xd exceeds UINT32_MAX (0xffffffff4)");
+
+  // Check the proper error handling when the 'NumBlocks" field is overridden
+  // with an out-of-range value.
+  SmallString<128> OverLimitNumBlocks(CommonYamlString);
+  OverLimitNumBlocks += R"(
+        NumBlocks: 0x1ffffffff
+)";
+
+  DoCheck(OverLimitNumBlocks,
+          "ULEB128 value at offset 0x8 exceeds UINT32_MAX (0x1ffffffff)");
+}