[Propeller] Encode address offsets of basic blocks relative to the end of the previous basic blocks.

[rahmanl]

Summary

This is a resurrection of D106421 with the change that it keeps backward-compatibility. This means decoding the previous version of LLVM_BB_ADDR_MAP will work. This is required as the profile mapping tool is not released with LLVM (AutoFDO). As suggested by @jhenderson we rename the original section type value to SHT_LLVM_BB_ADDR_MAP_V0 and assign a new value to the SHT_LLVM_BB_ADDR_MAP section type. The new encoding adds a version byte to each function entry to specify the encoding version for that function. This patch also adds a feature byte to be used with more flexibility in the future. An use-case example for the feature field is encoding multi-section functions more concisely using a different format.

Conceptually, the new encoding emits basic block offsets and sizes as label differences between each two consecutive basic block begin and end label. When decoding, offsets must be aggregated along with basic block sizes to calculate the final offsets of basic blocks relative to the function address.

This encoding uses smaller values compared to the existing one (offsets relative to function symbol).
Smaller values tend to occupy fewer bytes in ULEB128 encoding. As a result, we get about 17% total reduction in the size of the bb-address-map section (from about 11MB to 9MB for the clang PGO binary).
The extra two bytes (version and feature fields) incur a small 3% size overhead to the LLVM_BB_ADDR_MAP section size.

[rahmanl]

Cleanup.

[rahmanl]

Cleanup unrelated changes.

[amharc]

I think that Extensions.rst should be updated as well, including a description of the versioning scheme, the fact that the section name is now a semantically significant property, and a description of both the v0 and v1 formats.

[rahmanl]

Update Extensions.rst.

[rahmanl]

Remove empty lines.

[rahmanl]

Add unit-tests for checking invalid bb-address-map version suffixes.

[rahmanl]

In D121346#3476988, @amharc wrote:

I think that Extensions.rst should be updated as well, including a description of the versioning scheme, the fact that the section name is now a semantically significant property, and a description of both the v0 and v1 formats.

Thanks for the note. Updated Extensions.rst.

[rahmanl]

Would you mind taking a look @jhenderson?

[rahmanl]

Rebase.

[rahmanl]

Rebase again.

[jhenderson]

Has the spec for this been finalised anywhere? My main conceren is the use of section names to have semantic importance. ELF generally tries to avoid this, hence the use of section types, and it would be a shame to introduce this approach when there are other options. It would be far more preferable to include the version number in the section data somewhere, a bit like how most DWARF sections are encoded. I can think of one other possible way of doing this: change the section type value for version 1 and upwards, and rename the original value to something like SHT_LLVM_BB_ADDR_MAP_V0. Add the version field as the first N bytes (2 or 4 probably) of the new section type. Parsers understanding the old data structure only won't recognise the new section type as a recognised format. This is good because it doesn't mislead people by printing incorrect offsets (in addition to not needing to rely on the section name).

llvm/docs/Extensions.rst

404–415

432–452

Do we need a note saying that v0 BB Addr maps may not have the version suffix in the section name?

llvm/lib/Object/ELF.cpp

641

int seems like an odd type for Version. It probably should be some unsigned type?

[jhenderson]

llvm/lib/Object/ELF.cpp

644–648

Coding standards say to use lower-case for first letter of error messages.

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

75

For V1 output, I feel like it would be useful to have both the raw offset and the calculated offset printed. I'm not sure exactly what would be the best way of doing that though.

[rahmanl]

In D121346#3518196, @jhenderson wrote:

Has the spec for this been finalised anywhere? My main conceren is the use of section names to have semantic importance. ELF generally tries to avoid this, hence the use of section types, and it would be a shame to introduce this approach when there are other options. It would be far more preferable to include the version number in the section data somewhere, a bit like how most DWARF sections are encoded. I can think of one other possible way of doing this: change the section type value for version 1 and upwards, and rename the original value to something like SHT_LLVM_BB_ADDR_MAP_V0. Add the version field as the first N bytes (2 or 4 probably) of the new section type. Parsers understanding the old data structure only won't recognise the new section type as a recognised format. This is good because it doesn't mislead people by printing incorrect offsets (in addition to not needing to rely on the section name).

Thanks for the review. And apologies for my delayed followup.
We did consider several ideas for storing the version.

1. Store it for each function: wasteful for object-file size
2. Store it once in a different COMDAT section of the object file and have the linker merge them all: Would not work for mixing different versions.
3. Store it outside the section as a weak symbol. (Similar to 2).
4. Store it inside the section metadata: For example, we can suffix the section name with the version name and then have the LLVM_BB_ADDR_MAP reading code read sections of different versions.

We chose idea 4 mostly for convenience reasons.

IIUC, your suggestion is to embed the version in the section data. The problem with this approach is that the linker must read and deduplicate the version data when linking the sections (unless if we store the version for each function separately).
Also, if we compile with different compiler versions, the linker must create multiple LLVM_BB_ADDR_MAP sections if multiple versions exist.
For these reasons I am a bit hesitant to add linker dependency to the feature, even though section-name-independence is great to have. I'd be happy to change course if we can avoid involving the linker. Any thoughts?

[jhenderson]

In D121346#3574742, @rahmanl wrote:

IIUC, your suggestion is to embed the version in the section data. The problem with this approach is that the linker must read and deduplicate the version data when linking the sections (unless if we store the version for each function separately).
Also, if we compile with different compiler versions, the linker must create multiple LLVM_BB_ADDR_MAP sections if multiple versions exist.
For these reasons I am a bit hesitant to add linker dependency to the feature, even though section-name-independence is great to have. I'd be happy to change course if we can avoid involving the linker. Any thoughts?

One thing to consider is how DWARF debug sections are designed. Most DWARF sections have a format that is something akin to the following:

header consisting of:
  unit length - 32 or 64-bit number indicating the size of this input section
  version - uint16_t for the section's version
  other metadata as appropriate for the section type
actual section payload

The linker concatenates these together into a single output section. Consumers iterate over a section by inspecting the first header, using that to parse the immediate next payload and then, if the unit length doesn't mean the end of section has been reached, parses the next header and so on. In your case, you could have a single "header" (which might just consist of a length and version), followed by many functions that conform to that header. Consumers would just have to know how to iterate over them and then, if there are multiple versions, handle the corresponding payload accordingly. The linker would just concatenate together.

[rahmanl]

In D121346#3577252, @jhenderson wrote:

In D121346#3574742, @rahmanl wrote:

IIUC, your suggestion is to embed the version in the section data. The problem with this approach is that the linker must read and deduplicate the version data when linking the sections (unless if we store the version for each function separately).
Also, if we compile with different compiler versions, the linker must create multiple LLVM_BB_ADDR_MAP sections if multiple versions exist.
For these reasons I am a bit hesitant to add linker dependency to the feature, even though section-name-independence is great to have. I'd be happy to change course if we can avoid involving the linker. Any thoughts?

One thing to consider is how DWARF debug sections are designed. Most DWARF sections have a format that is something akin to the following:

header consisting of:
  unit length - 32 or 64-bit number indicating the size of this input section
  version - uint16_t for the section's version
  other metadata as appropriate for the section type
actual section payload

The linker concatenates these together into a single output section. Consumers iterate over a section by inspecting the first header, using that to parse the immediate next payload and then, if the unit length doesn't mean the end of section has been reached, parses the next header and so on. In your case, you could have a single "header" (which might just consist of a length and version), followed by many functions that conform to that header. Consumers would just have to know how to iterate over them and then, if there are multiple versions, handle the corresponding payload accordingly. The linker would just concatenate together.

Thanks for the explanation. If we use -function-sections it also means that we'll generate a unique LLVM_BB_ADDR_MAP per function. In this case, I believe the version data will be repeated for every function. Correct? I think we can live with that for now. It's only one or two bytes per function.

[jhenderson]

In D121346#3580806, @rahmanl wrote:

Thanks for the explanation. If we use -function-sections it also means that we'll generate a unique LLVM_BB_ADDR_MAP per function. In this case, I believe the version data will be repeated for every function. Correct? I think we can live with that for now. It's only one or two bytes per function.

Yes, that's what I'd expect. (It's worth noting that -function-sections imposes other overheads like the ELF section header, so a couple of bytes is comparatively small).

[rahmanl]

In D121346#3580925, @jhenderson wrote:

In D121346#3580806, @rahmanl wrote:

Thanks for the explanation. If we use -function-sections it also means that we'll generate a unique LLVM_BB_ADDR_MAP per function. In this case, I believe the version data will be repeated for every function. Correct? I think we can live with that for now. It's only one or two bytes per function.

Yes, that's what I'd expect. (It's worth noting that -function-sections imposes other overheads like the ELF section header, so a couple of bytes is comparatively small).

Correct, but with the difference that the ELF section header won't be repeated many times in the final linked section, but the version number will.

[rahmanl]

Encode the version number as a field of each function's LLVM_BB_ADDR_MAP entry instead of section names.

[rahmanl]

• Fix tests.

[rahmanl]

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

75

I think we should only care about the final calculated offset for verification. The raw offset is just an encoding technicality and should not be given much semantic importance.

[rahmanl]

• clang-format.

[jhenderson]

llvm/docs/Extensions.rst

399

Does this need extending?

456

Nit: looks like this line has gained some trailing whitespace somehow.

llvm/lib/Object/ELF.cpp

670–673

Nit: no need for braces here.

llvm/test/CodeGen/X86/basic-block-sections-labels.ll

49–50

It would be good if these could have comments in the asm indicating what they represent (i.e. version and feature), for those not familiar with the format.

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

193

I wonder if it would be better to link against the same section? This would allow you to compare the differences more easily.

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

109

Typo

129–132

I actually think the Version field should be mandatory. It seems odd to pin the default to the oldest version, but we also shouldn't have it change when a new version is added as otherwise it'll cause existing YAML to change behaviour.

132

Nit: let's line things up.

181

Nit

llvm/tools/obj2yaml/elf2yaml.cpp

897

We probably should emit an error for unsupported versions. The file format may change in a future version such that the existing parsing will break in nasty ways. Same probably goes for llvm-readobj.

[rahmanl]

• Address comments

[rahmanl]

llvm/docs/Extensions.rst

399

I interpreted your comment as we should remove it. Did you mean we should add a separate extension for this?

llvm/lib/Object/ELF.cpp

670–673

Also removed braces elsewhere.

[jhenderson]

llvm/docs/Extensions.rst

399

I was referring to the underline, which didn't match the modified header length sorry for the confusion! I'm happy either way with having just the "normal" title, or both mentioned in the header.

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

61

87

This didn't occur to me until now, but it's unfortunate that we have to have duplicate check patterns and near-duplicate YAML to do the v0 comparison check. I believe we can avoid it as follows:

1. Have an additional YAML file that just describes the section, with the Type (and potentially Version) field parameterised.
2. Create two ELF objects from this YAML, one with each of the two section types, the newer type having an explicit Version 0.
3. Run llvm-readobj twice, to dump each of them individually.
4. Use the same check pattern for the pair of these invocations.

What do you think?

196

Ah, that's an unfortunate side-effect. I think we should aim to avoid it somehow. About the best idea I have for this is to use different struct types in the ELFYAML code for SHT_LLVM_BB_ADDR_MAP_V0 entries and those in SHT_LLVM_BB_ADDR_MAP sections. This also means you can't set Features when it doesn't make sense (which is a good thing).

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

131–133

Any particular reason you have a double space between the colon and value here and below?

[rahmanl]

• Use the same checks for SHT_LLVM_BB_ADDR_MAP (with version=0) and SHT_LLVM_BB_ADDR_MAP_V0.

[rahmanl]

Thanks for the review @jhenderson

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

196

The problem is I would have to add alternative structs for BBAddrMapSection and BBAddrMapEntry and also define new mapping functions and writeSectionContent (with mostly identical code) for the SHT_LLVM_BB_ADDR_MAP_V0 type. We should be able to fully deprecate SHT_LLVM_BB_ADDR_MAP_V0 in a few months. So maybe this test won't stay around for too long. Of course, future versions will still use the same SHT_LLVM_BB_ADDR_MAP section type and therefore, new YAML fields will be optional (even if they are required for the new versions). So we won't have a major issue. Can I keep it as is?

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

131–133

It should be 3 spaces because of NumBlocks being used sometime. Aligned the YAML keys in this test more carefully.

[jhenderson]

llvm/lib/Object/ELF.cpp

671–672

Test case?

Also, the type is "SHT_LLVM_BB_ADDR_MAP", so probably wants to include the SHT_ too, to match (and be consistent with other error messages)

llvm/test/CodeGen/X86/basic-block-sections-labels-functions-sections.ll

13

Should we instead be including the version etc bytes? (I don't mind, just trying to understand the thought process)

35

If you're adding the comment here, I'd also add it to the other cases above (plus it makes it more robust, since it reduces the chance of spurious matches)

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

196

Yeah, leave as-is. Thanks for the explanation.

213

Nit: double blank line.

221

Super Nit: here and throughout, --check-prefixes -> --check-prefix when there's only one prefix to check (optional though - if you prefer to leave as-is, that's fine).

249

Nit: spurious extra line?

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

131–133

FWIW, I only align within the individual block, so here, I'd align with only the single space, and then use 3 spaces where NumBlocks is present. I don't care really though, as long as the spacing doesn't get excessive (at which point it can make readability an issue).

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

79–81

Nit: these should line up.

133

Nit: this should line up.

139

Nit: for consistent formatting, add a blank line before the YAML.

[rahmanl]

• Cleanups.

[rahmanl]

• Cleanups.

llvm/test/CodeGen/X86/basic-block-sections-labels-functions-sections.ll

13

You're right. We can do that.

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

131–133

Thanks. Adopted your approach.

[rahmanl]

• Cleanups.

[rahmanl]

• Cleanups.

[jhenderson]

llvm/lib/Object/ELF.cpp

671–672

Looks like there's still no test case?

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

180

FWIW, there are still 2 spaces here, rather than just 1.

[rahmanl]

• Cleanups.

llvm/lib/Object/ELF.cpp

671–672

Sorry, my response wasn't sent: I can't add a test to exercise this because I can't make a valid Yaml with an unsupported version number (ELFEmitter.cpp returns error if I specify version> 1), but I also don't think it's a good idea to remove that error handling. What do you suggest?

[jhenderson]

llvm/lib/Object/ELF.cpp

671–672

Hmm, good point. What do you think about the following proposal:

1. Emit a warning rather than an error with yaml2obj.
2. In this case, treat it as the max supported version (i.e. 1) and generate data like that, except with a value 2 for the Version field.

YAML is really only used for testing, so emitting an error blocks us from testing the actual production code we want to test, which seems unfortunate!

The alternative approach would be to use assembly, right?

[rahmanl]

• Add a llvm-readobj unit test with unsupported versions.

llvm/lib/Object/ELF.cpp

671–672

Done. Thanks for the suggestion.

[jhenderson]

Two nits, otherwise LGTM.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1402

Nit: semi-colon rather than comma is probably more correct

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

135

[rahmanl]

• Final nits.

llvm/docs/Extensions.rst

 .. code-block:: gas
 
   .section ".llvm_sympart","",@llvm_sympart
   .asciz "libpartition.so"
   .word symbol_in_partition
 
 .. _partition: https://lld.llvm.org/Partitions.html
 
-``SHT_LLVM_BB_ADDR_MAP`` Section (basic block address map)
+``SHT_LLVM_BB_ADDR_MAP`` and ``SHT_LLVM_BB_ADDR_MAP_V0`` Sections (basic block address map)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 This section stores the binary address of basic blocks along with other related
 metadata. This information can be used to map binary profiles (like perf
 profiles) directly to machine basic blocks.
 This section is emitted with ``-basic-block-sections=labels`` and will contain
-a BB address map table for every function which may be constructed as follows:
+a BB address map table for every function.
+
+The ``SHT_LLVM_BB_ADDR_MAP`` type provides backward compatibility to allow
+reading older versions of the BB address map generated by older compilers. Each
+function entry starts with a version byte which specifies the encoding version
+to use. The following versioning schemes are currently supported.
+
+Version 1 (newest): basic block address offsets are computed relative to the end
+of previous blocks.
+
+Example:
 
 .. code-block:: gas
 
   .section  ".llvm_bb_addr_map","",@llvm_bb_addr_map
+  .byte     1                             # version number
+  .byte     0                             # feature byte (reserved for future use)
   .quad     .Lfunc_begin0                 # address of the function
   .byte     2                             # number of basic blocks
   # BB record for BB_0
    .uleb128  .Lfunc_beign0-.Lfunc_begin0  # BB_0 offset relative to function entry (always zero)
    .uleb128  .LBB_END0_0-.Lfunc_begin0    # BB_0 size
    .byte     x                            # BB_0 metadata
   # BB record for BB_1
-   .uleb128  .LBB0_1-.Lfunc_begin0        # BB_1 offset relative to function entry
-   .uleb128  .LBB_END0_1-.Lfunc_begin0    # BB_1 size
+   .uleb128  .LBB0_1-.LBB_END0_0          # BB_1 offset relative to the end of last block (BB_0).
+   .uleb128  .LBB_END0_1-.LBB0_1          # BB_1 size
    .byte     y                            # BB_1 metadata
 
-This creates a BB address map table for a function with two basic blocks.
+Version 0: basic block address offsets are computed relative to the function
+address. This uses the unversioned ``SHT_LLVM_BB_ADDR_MAP_V0`` section type and
+is semantically equivalent to using ``SHT_LLVM_BB_ADDR_MAP`` with a zero
+version field.
+
+Example:
+
+.. code-block:: gas
+
+  .section  ".llvm_bb_addr_map","",@llvm_bb_addr_map_v0
+  .quad     .Lfunc_begin0                 # address of the function
+  .byte     2                             # number of basic blocks
+  # BB record for BB_0
+   .uleb128  .Lfunc_beign0-.Lfunc_begin0  # BB_0 offset relative to the function entry (always zero)
+   .uleb128  .LBB_END0_0-.Lfunc_begin0    # BB_0 size
+   .byte     x                            # BB_0 metadata
+  # BB record for BB_1
+   .uleb128  .LBB0_1-.Lfunc_begin0        # BB_1 offset relative to the function entry
+   .uleb128  .LBB_END0_1-.LBB0_1          # BB_1 size
+   .byte     y                            # BB_1 metadata
 
 CodeView-Dependent
 ------------------
 
-``.cv_file`` Directive
+``.cv_file`` Directive 
 ^^^^^^^^^^^^^^^^^^^^^^
 Syntax:
   ``.cv_file`` *FileNumber FileName* [ *checksum* ] [ *checksumkind* ]
 
 ``.cv_func_id`` Directive
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 Introduces a function ID that can be used with ``.cv_loc``.
 

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
   SHT_LLVM_ADDRSIG = 0x6fff4c03,        // List of address-significant symbols
                                         // for safe ICF.
   SHT_LLVM_DEPENDENT_LIBRARIES =
       0x6fff4c04,                    // LLVM Dependent Library Specifiers.
   SHT_LLVM_SYMPART = 0x6fff4c05,     // Symbol partition specification.
   SHT_LLVM_PART_EHDR = 0x6fff4c06,   // ELF header for loadable partition.
   SHT_LLVM_PART_PHDR = 0x6fff4c07,   // Phdrs for loadable partition.
-  SHT_LLVM_BB_ADDR_MAP = 0x6fff4c08, // LLVM Basic Block Address Map.
+  SHT_LLVM_BB_ADDR_MAP_V0 = 0x6fff4c08, // LLVM Basic Block Address Map (old version kept for backward-compatibility).
   SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c09, // LLVM Call Graph Profile.
+  SHT_LLVM_BB_ADDR_MAP = 0x6fff4c0a, // LLVM Basic Block Address Map.
   // Android's experimental support for SHT_RELR sections.
   // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
   SHT_ANDROID_RELR = 0x6fffff00,   // Relocation entries; only offsets.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5, // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,       // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,     // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,    // GNU version references.
   SHT_GNU_versym = 0x6fffffff,     // GNU symbol versions table.

llvm/include/llvm/MC/MCContext.h

private:
   DenseMap<unsigned, MCLabel *> Instances;
   /// NextInstance() creates the next instance of the directional local label
   /// for the LocalLabelVal and adds it to the map if needed.
   unsigned NextInstance(unsigned LocalLabelVal);
   /// GetInstance() gets the current instance of the directional local label
   /// for the LocalLabelVal and adds it to the map if needed.
   unsigned GetInstance(unsigned LocalLabelVal);
 
+  /// LLVM_BB_ADDR_MAP version to emit.
+  uint8_t BBAddrMapVersion = 1;
+
   /// The file name of the log file from the environment variable
   /// AS_SECURE_LOG_FILE.  Which must be set before the .secure_log_unique
   /// directive is used or it is an error.
   char *SecureLogFile;
   /// The stream that gets written to for the .secure_log_unique directive.
   std::unique_ptr<raw_fd_ostream> SecureLog;
   /// Boolean toggled when .secure_log_unique / .secure_log_reset is seen to
   /// catch errors if .secure_log_unique appears twice without
MCSectionXCOFF *getXCOFFSection(
       StringRef Section, SectionKind K,
       Optional<XCOFF::CsectProperties> CsectProp = None,
       bool MultiSymbolsAllowed = false, const char *BeginSymName = nullptr,
       Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags = None);
 
   // Create and save a copy of STI and return a reference to the copy.
   MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
+  uint8_t getBBAddrMapVersion() const { return BBAddrMapVersion; }
+
   /// @}
 
   /// \name Dwarf Management
   /// @{
 
   /// Get the compilation directory for DW_AT_comp_dir
   /// The compilation directory should be set with \c setCompilationDir before
   /// calling this function. If it is unset, an empty string will be returned.

llvm/include/llvm/ObjectYAML/ELFYAML.h

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

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
   MCSection *BBAddrMapSection =
       getObjFileLowering().getBBAddrMapSection(*MF.getSection());
   assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");
 
   const MCSymbol *FunctionSymbol = getFunctionBegin();
 
   OutStreamer->pushSection();
   OutStreamer->switchSection(BBAddrMapSection);
+  // Emit the version and feature values.
+  OutStreamer->emitInt8(OutStreamer->getContext().getBBAddrMapVersion());
+  OutStreamer->emitInt8(0);
   OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
   // Emit the total number of basic blocks in this function.
   OutStreamer->emitULEB128IntValue(MF.size());
+  const MCSymbol *PrevMBBEndSymbol = FunctionSymbol;
   // Emit BB Information for each basic block in the funciton.
   for (const MachineBasicBlock &MBB : MF) {
     const MCSymbol *MBBSymbol =
         MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
-    // Emit the basic block offset.
-    emitLabelDifferenceAsULEB128(MBBSymbol, FunctionSymbol);
+    // Emit the basic block offset relative to the end of the previous block.
+    // This is zero unless the block is padded due to alignment.
+    emitLabelDifferenceAsULEB128(MBBSymbol, PrevMBBEndSymbol);
     // Emit the basic block size. When BBs have alignments, their size cannot
     // always be computed from their offsets.
     emitLabelDifferenceAsULEB128(MBB.getEndSymbol(), MBBSymbol);
     OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB));
+    PrevMBBEndSymbol = MBB.getEndSymbol();
   }
   OutStreamer->popSection();
 }
 
 void AsmPrinter::emitPseudoProbe(const MachineInstr &MI) {
   if (PP) {
     auto GUID = MI.getOperand(0).getImm();
     auto Index = MI.getOperand(1).getImm();

llvm/lib/CodeGen/BasicBlockSections.cpp

 //    needs special handling with basic block sections. DebugInfo needs to be
 //    emitted with more relocations as basic block sections can break a
 //    function into potentially several disjoint pieces, and CFI needs to be
 //    emitted per cluster. This also bloats the object file and binary sizes.
 //
 // Basic Block Labels
 // ==================
 //
-// With -fbasic-block-sections=labels, we emit the offsets of BB addresses of
+// With -fbasic-block-sections=labels, we encode the offsets of BB addresses of
 // every function into the .llvm_bb_addr_map section. Along with the function
 // symbols, this allows for mapping of virtual addresses in PMU profiles back to
 // the corresponding basic blocks. This logic is implemented in AsmPrinter. This
 // pass only assigns the BBSectionType of every function to ``labels``.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Optional.h"

llvm/lib/MC/MCSectionELF.cpp

void MCSectionELF::printSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   else if (Type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE)
     OS << "llvm_call_graph_profile";
   else if (Type == ELF::SHT_LLVM_DEPENDENT_LIBRARIES)
     OS << "llvm_dependent_libraries";
   else if (Type == ELF::SHT_LLVM_SYMPART)
     OS << "llvm_sympart";
   else if (Type == ELF::SHT_LLVM_BB_ADDR_MAP)
     OS << "llvm_bb_addr_map";
+  else if (Type == ELF::SHT_LLVM_BB_ADDR_MAP_V0)
+    OS << "llvm_bb_addr_map_v0";
   else
     report_fatal_error("unsupported type 0x" + Twine::utohexstr(Type) +
                        " for section " + getName());
 
   if (EntrySize) {
     assert(Flags & ELF::SHF_MERGE);
     OS << "," << EntrySize;
   }

llvm/lib/Object/ELF.cpp

switch (Type) {
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);
+    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0);
     STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
     STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
   default:
     return "Unknown";

 template <class ELFT>
 Expected<std::vector<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);
+  DataExtractor::Cursor Cur(0);
   std::vector<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);
   };
 
+
+  uint8_t Version = 0;
   while (!ULEBSizeErr && Cur && Cur.tell() < Content.size()) {
+    if (Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
+      Version = Data.getU8(Cur);
+      if (!Cur)
+        break;
+      if (Version > 1) {
+        return createError("unsupported LLVM_BB_ADDR_MAP version: " + Twine(static_cast<int>(Version)));
+      }
+      Data.getU8(Cur); // Feature byte
+    }
     uintX_t Address = static_cast<uintX_t>(Data.getAddress(Cur));
     uint32_t NumBlocks = ReadULEB128AsUInt32();
     std::vector<BBAddrMap::BBEntry> BBEntries;
+    uint32_t PrevBBEndOffset = 0;
     for (uint32_t BlockID = 0; !ULEBSizeErr && Cur && (BlockID < NumBlocks);
          ++BlockID) {
       uint32_t Offset = ReadULEB128AsUInt32();
       uint32_t Size = ReadULEB128AsUInt32();
       uint32_t Metadata = ReadULEB128AsUInt32();
+      if (Version >= 1) {
+        // Offset is calculated relative to the end of the previous BB.
+        Offset += PrevBBEndOffset;
+        PrevBBEndOffset = Offset + Size;
+      }
       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/Object/ELFObjectFile.cpp

 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)
+    if (Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP && Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP_V0) {
       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;

llvm/lib/ObjectYAML/ELFEmitter.cpp

 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 version and feature values.
+    if (Section.Type == llvm::ELF::SHT_LLVM_BB_ADDR_MAP) {
+      CBA.write(E.Version);
+      CBA.write(E.Feature);
+      SHeader.sh_size += 2;
+    }
     // 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 overridden by the 'NumBlocks' YAML field when specified.
     uint64_t NumBlocks =
         E.NumBlocks.getValueOr(E.BBEntries ? E.BBEntries->size() : 0);
     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(NumBlocks);
     // Write all BBEntries.

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

llvm/test/CodeGen/X86/basic-block-sections-labels-functions-sections.ll

 ; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=labels | FileCheck %s
 
 $_Z4fooTIiET_v = comdat any
 
 define dso_local i32 @_Z3barv() {
   ret i32 0
 }
 ;; Check we add SHF_LINK_ORDER for .llvm_bb_addr_map and link it with the corresponding .text sections.
 ; CHECK:    .section .text._Z3barv,"ax",@progbits
 ; CHECK-LABEL:  _Z3barv:
 ; CHECK-NEXT: [[BAR_BEGIN:.Lfunc_begin[0-9]+]]:
 ; CHECK:    .section .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text._Z3barv{{$}}
-; CHECK-NEXT:   .quad [[BAR_BEGIN]]
+; CHECK:    .quad [[BAR_BEGIN]]
 
 
 define dso_local i32 @_Z3foov() {
   %1 = call i32 @_Z4fooTIiET_v()
   ret i32 %1
 }
 ; CHECK:    .section .text._Z3foov,"ax",@progbits
 ; CHECK-LABEL:  _Z3foov:
 ; CHECK-NEXT: [[FOO_BEGIN:.Lfunc_begin[0-9]+]]:
 ; CHECK:    .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text._Z3foov{{$}}
-; CHECK-NEXT:   .quad [[FOO_BEGIN]]
+; CHECK:    .quad [[FOO_BEGIN]]
 
 
 define linkonce_odr dso_local i32 @_Z4fooTIiET_v() comdat {
   ret i32 0
 }
 ;; Check we add .llvm_bb_addr_map section to a COMDAT group with the corresponding .text section if such a COMDAT exists.
 ; CHECK:    .section .text._Z4fooTIiET_v,"axG",@progbits,_Z4fooTIiET_v,comdat
 ; CHECK-LABEL:  _Z4fooTIiET_v:
 ; CHECK-NEXT: [[FOOCOMDAT_BEGIN:.Lfunc_begin[0-9]+]]:
 ; CHECK:    .section .llvm_bb_addr_map,"Go",@llvm_bb_addr_map,_Z4fooTIiET_v,comdat,.text._Z4fooTIiET_v{{$}}
-; CHECK-NEXT:   .quad [[FOOCOMDAT_BEGIN]]
+; CHECK:    .quad [[FOOCOMDAT_BEGIN]]

llvm/test/CodeGen/X86/basic-block-sections-labels.ll

 ; CHECK-LABEL:  .LBB_END0_2:
 ; CHECK-LABEL:  .LBB0_3:
 ; CHECK-LABEL:  .LBB_END0_3:
 ; CHECK-LABEL:  .Lfunc_end0:
 
 ; UNIQ:     .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text._Z3bazb{{$}}
 ;; Verify that with -unique-section-names=false, the unique id of the text section gets assigned to the llvm_bb_addr_map section.
 ; NOUNIQ:   .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text,unique,1
+; CHECK-NEXT:   .byte   1
+; CHECK-NEXT:   .byte   0
 ; CHECK-NEXT: .quad .Lfunc_begin0
 ; CHECK-NEXT: .byte 4
 ; CHECK-NEXT: .uleb128 .Lfunc_begin0-.Lfunc_begin0
 ; CHECK-NEXT: .uleb128 .LBB_END0_0-.Lfunc_begin0
 ; CHECK-NEXT: .byte 8
-; CHECK-NEXT: .uleb128 .LBB0_1-.Lfunc_begin0
+; CHECK-NEXT: .uleb128 .LBB0_1-.LBB_END0_0
 ; CHECK-NEXT: .uleb128 .LBB_END0_1-.LBB0_1
 ; CHECK-NEXT: .byte 8
-; CHECK-NEXT: .uleb128 .LBB0_2-.Lfunc_begin0
+; CHECK-NEXT: .uleb128 .LBB0_2-.LBB_END0_1
 ; CHECK-NEXT: .uleb128 .LBB_END0_2-.LBB0_2
 ; CHECK-NEXT: .byte 1
-; CHECK-NEXT: .uleb128 .LBB0_3-.Lfunc_begin0
+; CHECK-NEXT: .uleb128 .LBB0_3-.LBB_END0_2
 ; CHECK-NEXT: .uleb128 .LBB_END0_3-.LBB0_3
 ; CHECK-NEXT: .byte 5

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

 ## This test checks how we handle the --bb-addr-map option.
 
-# Check 64-bit:
-# RUN: yaml2obj %s -DBITS=64 -DADDR=0x999999999 -o %t1.x64.o
-# RUN: llvm-readobj %t1.x64.o --bb-addr-map 2>&1 | FileCheck %s -DADDR=0x999999999 -DFILE=%t1.x64.o --check-prefix=LLVM
-
+## Check 64-bit (version #0 encoding):
+# RUN: yaml2obj %s -DBITS=64 -DVERSION=0 -DADDR=0x999999999 -o %t1.x64.o
+# RUN: llvm-readobj %t1.x64.o --bb-addr-map 2>&1 | FileCheck %s -DADDR=0x999999999 -DFILE=%t1.x64.o --check-prefixes=CHECK,V0
 # RUN: llvm-readelf %t1.x64.o --bb-addr-map | FileCheck %s --check-prefix=GNU
 
+## Check 64-bit (version #1 encoding):
+# RUN: yaml2obj %s -DBITS=64 -DVERSION=1 -DADDR=0x999999999 -o %t1.v1.x64.o
+# RUN: llvm-readobj %t1.v1.x64.o --bb-addr-map 2>&1 | FileCheck %s -DADDR=0x999999999 -DFILE=%t1.v1.x64.o --check-prefixes=CHECK,V1
+
 ## Check 32-bit:
 # RUN: yaml2obj %s -DBITS=32 -o %t1.x32.o
-# RUN: llvm-readobj %t1.x32.o --bb-addr-map 2>&1 | FileCheck -DADDR=0x11111 %s -DFILE=%t1.x32.o --check-prefix=LLVM
+# RUN: llvm-readobj %t1.x32.o --bb-addr-map 2>&1 | FileCheck -DADDR=0x11111 %s -DFILE=%t1.x32.o --check-prefixes=CHECK,V1
 # 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
+# RUN: yaml2obj %s -DBITS=32 -DSIZE=6 -o %t2.o
+# RUN: llvm-readobj %t2.o --bb-addr-map 2>&1 | FileCheck %s -DOFFSET=0x00000006 -DFILE=%t2.o --check-prefix=TRUNCATED
 
-# LLVM:      BBAddrMap [
-# LLVM-NEXT:   Function {
-# LLVM-NEXT:     At: [[ADDR]]
-# LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for address ([[ADDR]]) in SHT_LLVM_BB_ADDR_MAP section with index 3
-# LLVM-NEXT:     Name: <?>
-# LLVM-NEXT:     BB entries [
-# LLVM-NEXT:       {
-# LLVM-NEXT:         Offset: 0x0
-# LLVM-NEXT:         Size: 0x1
-# LLVM-NEXT:         HasReturn: No
-# LLVM-NEXT:         HasTailCall: Yes
-# LLVM-NEXT:         IsEHPad: No
-# LLVM-NEXT:         CanFallThrough: No
-# LLVM-NEXT:       }
-# LLVM-NEXT:       {
-# LLVM-NEXT:         Offset: 0x3
-# LLVM-NEXT:         Size: 0x4
-# LLVM-NEXT:         HasReturn: Yes
-# LLVM-NEXT:         HasTailCall: No
-# LLVM-NEXT:         IsEHPad: Yes
-# LLVM-NEXT:         CanFallThrough: No
-# LLVM-NEXT:       }
-# LLVM-NEXT:     ]
-# LLVM-NEXT:   }
-# LLVM-NEXT:   Function {
-# LLVM-NEXT:     At: 0x22222
-# LLVM-NEXT:     Name: foo
-# LLVM-NEXT:     BB entries [
-# LLVM-NEXT:       {
-# LLVM-NEXT:         Offset: 0x6
-# LLVM-NEXT:         Size: 0x7
-# LLVM-NEXT:         HasReturn: No
-# LLVM-NEXT:         HasTailCall: No
-# LLVM-NEXT:         IsEHPad: No
-# LLVM-NEXT:         CanFallThrough: Yes
-# LLVM-NEXT:       }
-# LLVM-NEXT:     ]
-# LLVM-NEXT:   }
-# LLVM-NEXT: ]
-# LLVM-NEXT: BBAddrMap [
-# LLVM-NEXT:   Function {
-# LLVM-NEXT:     At: 0x33333
-# LLVM-NEXT:     Name: bar
-# LLVM-NEXT:     BB entries [
-# LLVM-NEXT:       {
-# LLVM-NEXT:         Offset: 0x9
-# LLVM-NEXT:         Size: 0xA
-# LLVM-NEXT:         HasReturn: Yes
-# LLVM-NEXT:         HasTailCall: Yes
-# LLVM-NEXT:         IsEHPad: No
-# LLVM-NEXT:         CanFallThrough: Yes
-# LLVM-NEXT:       }
-# LLVM-NEXT:     ]
-# LLVM-NEXT:   }
-# LLVM-NEXT: ]
+# CHECK:      BBAddrMap [
+# CHECK-NEXT:   Function {
+# CHECK-NEXT:     At: [[ADDR]]
+# CHECK-NEXT: warning: '[[FILE]]': could not identify function symbol for address ([[ADDR]]) in SHT_LLVM_BB_ADDR_MAP section with index 4
+# CHECK-NEXT:     Name: <?>
+# CHECK-NEXT:     BB entries [
+# CHECK-NEXT:       {
+# CHECK-NEXT:         Offset: 0x0
+# CHECK-NEXT:         Size: 0x1
+# CHECK-NEXT:         HasReturn: No
+# CHECK-NEXT:         HasTailCall: Yes
+# CHECK-NEXT:         IsEHPad: No
+# CHECK-NEXT:         CanFallThrough: No
+# CHECK-NEXT:       }
+# CHECK-NEXT:       {
+# V0-NEXT:            Offset: 0x3
+# V1-NEXT:            Offset: 0x4
+# CHECK-NEXT:         Size: 0x4
+# CHECK-NEXT:         HasReturn: Yes
+# CHECK-NEXT:         HasTailCall: No
+# CHECK-NEXT:         IsEHPad: Yes
+# CHECK-NEXT:         CanFallThrough: No
+# CHECK-NEXT:       }
+# CHECK-NEXT:     ]
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Function {
+# CHECK-NEXT:     At: 0x22222
+# CHECK-NEXT:     Name: foo
+# CHECK-NEXT:     BB entries [
+# CHECK-NEXT:       {
+# CHECK-NEXT:         Offset: 0x6
+# CHECK-NEXT:         Size: 0x7
+# CHECK-NEXT:         HasReturn: No
+# CHECK-NEXT:         HasTailCall: No
+# CHECK-NEXT:         IsEHPad: No
+# CHECK-NEXT:         CanFallThrough: Yes
+# CHECK-NEXT:       }
+# CHECK-NEXT:     ]
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK-NEXT: BBAddrMap [
+# CHECK-NEXT:   Function {
+# CHECK-NEXT:     At: 0x33333
+# CHECK-NEXT:     Name: bar
+# CHECK-NEXT:     BB entries [
+# CHECK-NEXT:       {
+# CHECK-NEXT:         Offset: 0x9
+# CHECK-NEXT:         Size: 0xA
+# CHECK-NEXT:         HasReturn: Yes
+# CHECK-NEXT:         HasTailCall: Yes
+# CHECK-NEXT:         IsEHPad: No
+# CHECK-NEXT:         CanFallThrough: Yes
+# CHECK-NEXT:       }
+# CHECK-NEXT:       {
+# CHECK-NEXT:         Offset: 0xC
+# CHECK-NEXT:         Size: 0xD
+# CHECK-NEXT:         HasReturn: No
+# CHECK-NEXT:         HasTailCall: Yes
+# CHECK-NEXT:         IsEHPad: Yes
+# CHECK-NEXT:         CanFallThrough: Yes
+# CHECK-NEXT:       }
+# CHECK-NEXT:     ]
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK-NEXT: BBAddrMap [
+# CHECK-NEXT:   Function {
+# CHECK-NEXT:     At: 0x44444
+# CHECK-NEXT:     Name: baz
+# CHECK-NEXT:     BB entries [
+# CHECK-NEXT:       {
+# CHECK-NEXT:         Offset: 0xF
+# CHECK-NEXT:         Size: 0x10
+# CHECK-NEXT:         HasReturn:
+# CHECK-NEXT:         HasTailCall
+# CHECK-NEXT:         IsEHPad:
+# CHECK-NEXT:         CanFallThrough:
+# CHECK-NEXT:       }
+# CHECK-NEXT:       {
+# CHECK-NEXT:         Offset: 0x12
+# CHECK-NEXT:         Size: 0x13
+# CHECK-NEXT:         HasReturn:
+# CHECK-NEXT:         HasTailCall:
+# CHECK-NEXT:         IsEHPad:
+# CHECK-NEXT:         CanFallThrough:
+# CHECK-NEXT:       }
+# CHECK-NEXT:     ]
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
 
 # GNU: GNUStyle::printBBAddrMaps not implemented
 
 # TRUNCATED:      BBAddrMap [
-# TRUNCATED-NEXT:   warning: '[[FILE]]': unable to dump SHT_LLVM_BB_ADDR_MAP section with index 3: unable to decode LEB128 at offset [[OFFSET]]: malformed uleb128, extends past end
+# TRUNCATED-NEXT:   warning: '[[FILE]]': unable to dump SHT_LLVM_BB_ADDR_MAP section with index 4: 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:     Name: bar
 # TRUNCATED-NEXT:     BB entries [
 # TRUNCATED-NEXT:       {
 # TRUNCATED-NEXT:         Offset: 0x9
 # TRUNCATED-NEXT:         Size: 0xA
 # TRUNCATED-NEXT:         HasReturn: Yes
 # TRUNCATED-NEXT:         HasTailCall: Yes
 # TRUNCATED-NEXT:         IsEHPad: No
 # TRUNCATED-NEXT:         CanFallThrough: Yes
 # TRUNCATED-NEXT:       }
+# TRUNCATED-NEXT:       {
+# TRUNCATED-NEXT:         Offset: 0xC
+# TRUNCATED-NEXT:         Size: 0xD
+# TRUNCATED-NEXT:         HasReturn: No
+# TRUNCATED-NEXT:         HasTailCall: Yes
+# TRUNCATED-NEXT:         IsEHPad: Yes
+# TRUNCATED-NEXT:         CanFallThrough: Yes
+# TRUNCATED-NEXT:       }
 # TRUNCATED-NEXT:     ]
 # TRUNCATED-NEXT:   }
 # TRUNCATED-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:   .text
     Type:   SHT_PROGBITS
     Flags:  [SHF_ALLOC]
   - Name:   .text.bar
     Type:   SHT_PROGBITS
     Flags:  [SHF_ALLOC]
-  - Name:   bb_addr_map_1
+  - Name:   .text.baz
+    Type:   SHT_PROGBITS
+    Flags:  [SHF_ALLOC]
+  - Name:   .llvm_bb_addr_map
     Type:   SHT_LLVM_BB_ADDR_MAP
     ShSize: [[SIZE=<none>]]
     Link:   .text
     Entries:
       - Address: [[ADDR=0x11111]]
+        Version: [[VERSION=1]]
         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
+  - Name:   '.llvm_bb_addr_map (1)'
     Type:   SHT_LLVM_BB_ADDR_MAP
     Link:   .text.bar
     Entries:
       - Address: 0x33333
         BBEntries:
           - AddressOffset: 0x9
             Size:          0xa
             Metadata:      0xb
+          - AddressOffset: 0xc
+            Size:          0xd
+            Metadata:      0xe
+  - Name:   '.llvm_bb_addr_map (2)'
+# Old section type
+    Type:   SHT_LLVM_BB_ADDR_MAP_V0
+    Link:   .text.baz
+    Entries:
+      - Address: 0x44444
+        BBEntries:
+          - AddressOffset: 0xf
+            Size:          0x10
+            Metadata:      0x11
+          - AddressOffset: 0x12
+            Size:          0x13
+            Metadata:      0x14
 Symbols:
   - Name:    foo
     Section: .text
     Type:    STT_FUNC
     Value:   0x22222
   - Name:    bar
     Section: .text.bar
     Type:    STT_FUNC
     Value:   0x33333
+  - Name:    baz
+    Section: .text.baz
+    Type:    STT_FUNC
+    Value:   0x44444

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

 # 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:
 ## The 'Address' field is omitted when it's zero.
+# VALID-NEXT:       - Version: 1
+# VALID-NEXT:         Feature: 0xFF
 # VALID-NEXT:         BBEntries:
 # VALID-NEXT:           - AddressOffset:    0x1
 # VALID-NEXT:             Size:             0x2
 # VALID-NEXT:             Metadata:         0x3
 # VALID-NEXT:           - AddressOffset:    0x4
 # VALID-NEXT:             Size:             0x5
 # VALID-NEXT:             Metadata:         0x6
 # VALID-NEXT:           - AddressOffset:    0xFFFFFFFFFFFFFFF7
 # VALID-NEXT:             Size:             0xFFFFFFFFFFFFFFF8
 # VALID-NEXT:             Metadata:         0xFFFFFFFFFFFFFFF9
-# VALID-NEXT:       - Address:   0xFFFFFFFFFFFFFF20
+# VALID-NEXT:       - Version: 2
+# VALID-NEXT:         Feature: 0xEE
+# VALID-NEXT:         Address:   0xFFFFFFFFFFFFFF20
 # VALID-NEXT:         BBEntries:
 # VALID-NEXT:           - AddressOffset:    0xA
 # VALID-NEXT:             Size:             0xB
 # VALID-NEXT:             Metadata:         0xC
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .llvm_bb_addr_map
     Type:    SHT_LLVM_BB_ADDR_MAP
-    ShSize:    [[SIZE=<none>]]
+    ShSize:  [[SIZE=<none>]]
     Entries:
-      - Address:   0x0
+      - Version:  1
+        Feature:  0xFF
+        Address:   0x0
         NumBlocks: [[NUMBLOCKS=<none>]]
         BBEntries:
           - AddressOffset:    0x1
             Size:             0x2
             Metadata:         0x3
           - AddressOffset:    0x4
             Size:             0x5
             Metadata:         0x6
           - AddressOffset:    0xFFFFFFFFFFFFFFF7
             Size:             0xFFFFFFFFFFFFFFF8
             Metadata:         0xFFFFFFFFFFFFFFF9
-      - Address:   0xFFFFFFFFFFFFFF20
+      - Version:  2
+        Feature:  0xEE
+        Address:   0xFFFFFFFFFFFFFF20
         BBEntries:
           - AddressOffset:    0xA
             Size:             0xB
             Metadata:         0xC
 
 ## Check obj2yaml can dump empty .llvm_bb_addr_map sections.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2

 # 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:
-## The 'Address' field is omitted when it's zero.
+## Fields 'Address', 'Version', and 'Feature' are omitted when theyr are zero.
 # MULTI-NEXT:       - BBEntries:
 # MULTI-NEXT:           - AddressOffset:    0x1
 # MULTI-NEXT:             Size:             0x2
 # MULTI-NEXT:             Metadata:         0x3
 # MULTI-NEXT:   - Name:    '.llvm_bb_addr_map (1)'
 # MULTI-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP
 # MULTI-NEXT:     Entries:
 # MULTI-NEXT:       - Address: 0x20
 # 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:   0x0
+## Check that obj2yaml does not emit the Address, Version, and Feature fields when it's zero.
+      - Version: 0
+        Feature: 0x0
+        Address:   0x0
         BBEntries:
           - AddressOffset:    0x1
             Size:             0x2
             Metadata:         0x3
   - Name:    '.llvm_bb_addr_map (1)'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Entries:
       - Address:   0x20
 

 # 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
 # BADNUMBLOCKS-NEXT:     Content: {{([[:xdigit:]]+)}}{{$}}
-# TRUNCATED-NEXT:        Content: '{{([[:xdigit:]]{16})}}'{{$}}
+# TRUNCATED-NEXT:        Content: {{([[:xdigit:]]{16})}}{{$}}
+
+## Check obj2yaml for SHT_LLVM_BB_ADDR_MAP_V0.
+# RUN: yaml2obj --docnum=4 %s -o %t6
+# RUN: obj2yaml %t6 | FileCheck %s --check-prefix=V0
+
+# V0:      --- !ELF
+# V0-NEXT: FileHeader:
+# V0-NEXT:   Class: ELFCLASS64
+# V0-NEXT:   Data:  ELFDATA2LSB
+# V0-NEXT:   Type:  ET_EXEC
+# V0-NEXT: Sections:
+# V0-NEXT:   - Name:    .llvm_bb_addr_map
+# V0-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP_V0
+# V0-NEXT:     Entries:
+# V0-NEXT:       - Address: 0x1111
+# V0-NEXT:         BBEntries:
+# V0-NEXT:           - AddressOffset:    0x1
+# V0-NEXT:             Size:             0x2
+# V0-NEXT:             Metadata:         0x3
+#
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:    .llvm_bb_addr_map
+    Type:    SHT_LLVM_BB_ADDR_MAP_V0
+    Entries:
+      - Address:   0x1111
+        BBEntries:
+          - AddressOffset:    0x1
+            Size:             0x2
+            Metadata:         0x3

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

 ## Check how yaml2obj produces .llvm_bb_addr_map sections.
 
 # 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:   Type: SHT_LLVM_BB_ADDR_MAP (0x6FFF4C0A)
 # 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:        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:     0000: 00002000 00000000 00000101 0203
 # CHECK-NEXT:   )
 
 # Case 5: Specify Entries and omit the Address field.
 # CHECK:        Name: .llvm_bb_addr_map (1)
 # CHECK:        Address:
 # CHECK-SAME:   {{^ 0x0$}}
 # CHECK:        SectionData (
-# CHECK-NEXT:     0000: 00000000 00000000 01010203
+# CHECK-NEXT:     0000: 00000000 00000000 00000101 0203
 # CHECK-NEXT:   )
 
 # Case 6: Override the NumBlocks field.
 # CHECK:        Name: .llvm_bb_addr_map (1)
 # CHECK:        SectionData (
-# CHECK-NEXT:     0000: 20000000 00000000 02010203
+# CHECK-NEXT:     0000: 00002000 00000000 00000201 0203
 # CHECK-NEXT:   )
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:

 
 ## 2) We can produce an empty .llvm_bb_addr_map section from a description
 ##    with empty section content.
   - Name:    '.llvm_bb_addr_map (2)'
     Type:    SHT_LLVM_BB_ADDR_MAP
 
 ## 3) We can produce a zero .llvm_bb_addr_map section of a specific size when
 ##    we specify the size only.
   - Name:    '.llvm_bb_addr_map (3)'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Size:    8
 
 ## 4) We can produce an .llvm_bb_addr_map section from a description with
 ##    Entries.
   - Name:    '.llvm_bb_addr_map (4)'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Entries:
       - Address:   0x0000000000000020
         BBEntries:
FileHeader:
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
 ##  Specify Content and Size
   - Name:    '.llvm_bb_addr_map'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Entries: []
     Content: [[CONTENT=<none>]]
     Size:    [[SIZE=<none>]]

llvm/tools/llvm-readobj/ELFDumper.cpp

for (uint32_t I = 0, Size = CGProfileOrErr->size(); I != Size; ++I) {
       W.printNumber("Weight", CGPE.cgp_weight);
     }
   }
 }
 
 template <class ELFT> void LLVMELFDumper<ELFT>::printBBAddrMaps() {
   bool IsRelocatable = this->Obj.getHeader().e_type == ELF::ET_REL;
   for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
-    if (Sec.sh_type != SHT_LLVM_BB_ADDR_MAP)
+    if (Sec.sh_type != SHT_LLVM_BB_ADDR_MAP && Sec.sh_type != SHT_LLVM_BB_ADDR_MAP_V0)
       continue;
     Optional<const Elf_Shdr *> FunctionSec = None;
     if (IsRelocatable)
       FunctionSec =
           unwrapOrError(this->FileName, this->Obj.getSection(Sec.sh_link));
     ListScope L(W, "BBAddrMap");
     Expected<std::vector<BBAddrMap>> BBAddrMapOrErr =
         this->Obj.decodeBBAddrMap(Sec);

llvm/tools/obj2yaml/elf2yaml.cpp

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_V0:
     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.
ELFDumper<ELFT>::dumpBBAddrMapSection(const Elf_Shdr *Shdr) {
   ArrayRef<uint8_t> Content = *ContentOrErr;
   if (Content.empty())
     return S.release();
 
   DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);
 
   std::vector<ELFYAML::BBAddrMapEntry> Entries;
   DataExtractor::Cursor Cur(0);
+  uint8_t Version = 0;
+  uint8_t Feature = 0;
   while (Cur && Cur.tell() < Content.size()) {
+    if  (Shdr->sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
+      Version = Data.getU8(Cur);
+      Feature = Data.getU8(Cur);
+    }
     uint64_t Address = Data.getAddress(Cur);
     uint64_t NumBlocks = Data.getULEB128(Cur);
     std::vector<ELFYAML::BBAddrMapEntry::BBEntry> BBEntries;
     // Read the specified number of BB entries, or until decoding fails.
     for (uint64_t BlockID = 0; Cur && BlockID < NumBlocks; ++BlockID) {
       uint64_t Offset = Data.getULEB128(Cur);
       uint64_t Size = Data.getULEB128(Cur);
       uint64_t Metadata = Data.getULEB128(Cur);
       BBEntries.push_back({Offset, Size, Metadata});
     }
-    Entries.push_back({Address, /*NumBlocks=*/{}, BBEntries});
+    Entries.push_back({Version, Feature, Address, /*NumBlocks=*/{}, BBEntries});
   }
 
   if (!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);

llvm/unittests/Object/ELFObjectFileTest.cpp

 TEST(ELFObjectFileTest, InvalidDecodeBBAddrMap) {
   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
+  - Type: SHT_LLVM_BB_ADDR_MAP
+    Name: .llvm_bb_addr_map
 )");
 
   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 invalid and unsupported versions.
+  SmallVector<SmallString<128>, 2> InvalidVersionYamlStrings(2, CommonYamlString);
+  InvalidVersionYamlStrings[0] += R"(
+    Entries:
+      - Version: 2
+)";
+  InvalidVersionYamlStrings[1] += R"(
+    Entries:
+      - Version: 255
+)";
+  DoCheck(InvalidVersionYamlStrings[0],
+          "unsupported LLVM_BB_ADDR_MAP version: 2");
+  DoCheck(InvalidVersionYamlStrings[1],
+          "unsupported LLVM_BB_ADDR_MAP version: 255");
+
+  SmallString<128> CommonValidYamlString(CommonYamlString);
+  CommonValidYamlString += R"(
+    Entries:
+      - Address: 0x11111
+        Version: 1
+        BBEntries:
+          - AddressOffset: 0x0
+            Size:          0x1
+            Metadata:      0x2
+)";
+
   // Check that we can detect the malformed encoding when the section is
   // truncated.
-  SmallString<128> TruncatedYamlString(CommonYamlString);
+  SmallString<128> TruncatedYamlString(CommonValidYamlString);
   TruncatedYamlString += R"(
-    ShSize: 0x8
+    ShSize: 0xa
 )";
-  DoCheck(TruncatedYamlString, "unable to decode LEB128 at offset 0x00000008: "
+  DoCheck(TruncatedYamlString, "unable to decode LEB128 at offset 0x0000000a: "
                                "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);
+  SmallVector<SmallString<128>, 3> OverInt32LimitYamlStrings(
+      3, CommonValidYamlString);
   OverInt32LimitYamlStrings[0] += R"(
           - AddressOffset: 0x100000000
             Size:          0xFFFFFFFF
             Metadata:      0xFFFFFFFF
 )";
 
   OverInt32LimitYamlStrings[1] += R"(
           - AddressOffset: 0xFFFFFFFF
             Size:          0x100000000
             Metadata:      0xFFFFFFFF
 )";
 
   OverInt32LimitYamlStrings[2] += R"(
           - AddressOffset: 0xFFFFFFFF
             Size:          0xFFFFFFFF
             Metadata:      0x100000000
 )";
 
   DoCheck(OverInt32LimitYamlStrings[0],
-          "ULEB128 value at offset 0xc exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0xe exceeds UINT32_MAX (0x100000000)");
   DoCheck(OverInt32LimitYamlStrings[1],
-          "ULEB128 value at offset 0x11 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x13 exceeds UINT32_MAX (0x100000000)");
   DoCheck(OverInt32LimitYamlStrings[2],
-          "ULEB128 value at offset 0x16 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x18 exceeds UINT32_MAX (0x100000000)");
 
   // 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: 0x15
+    ShSize: 0x17
 )";
   // Truncate at the end of the 5-byte field.
   OverInt32LimitAndTruncated[1] += R"(
-    ShSize: 0x16
+    ShSize: 0x18
 )";
   // Truncate after the end of the 5-byte field.
   OverInt32LimitAndTruncated[2] += R"(
-    ShSize: 0x17
+    ShSize: 0x19
 )";
 
   DoCheck(OverInt32LimitAndTruncated[0],
-          "unable to decode LEB128 at offset 0x00000011: malformed uleb128, "
+          "unable to decode LEB128 at offset 0x00000013: malformed uleb128, "
           "extends past end");
   DoCheck(OverInt32LimitAndTruncated[1],
-          "ULEB128 value at offset 0x11 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x13 exceeds UINT32_MAX (0x100000000)");
   DoCheck(OverInt32LimitAndTruncated[2],
-          "ULEB128 value at offset 0x11 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x13 exceeds UINT32_MAX (0x100000000)");
 
   // Check for proper error handling when the 'NumBlocks' field is overridden
   // with an out-of-range value.
-  SmallString<128> OverLimitNumBlocks(CommonYamlString);
+  SmallString<128> OverLimitNumBlocks(CommonValidYamlString);
   OverLimitNumBlocks += R"(
         NumBlocks: 0x100000000
 )";
 
   DoCheck(OverLimitNumBlocks,
-          "ULEB128 value at offset 0x8 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0xa exceeds UINT32_MAX (0x100000000)");
 }
 
 // Test for the ELFObjectFile::readBBAddrMap API.
 TEST(ELFObjectFileTest, ReadBBAddrMap) {
   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
+      - Version: 1
+        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
+      - Version: 1
+        Address: 0x22222
         BBEntries:
           - AddressOffset: 0x0
             Size:          0x2
             Metadata:      0x4
   - Name: .llvm_bb_addr_map
-    Type: SHT_LLVM_BB_ADDR_MAP
+    Type: SHT_LLVM_BB_ADDR_MAP_V0
   # Link: 0 (by default)
     Entries:
       - Address: 0x33333
         BBEntries:
           - AddressOffset: 0x0
             Size:          0x3
             Metadata:      0x6
 )");
)");
   // 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");
+               "unable to get the linked-to section for "
+               "SHT_LLVM_BB_ADDR_MAP_V0 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 read SHT_LLVM_BB_ADDR_MAP_V0 section with index 3: "
                "unable to decode LEB128 at offset 0x00000008: malformed "
                "uleb128, extends past end");
   // Check that we can read the other section's bb-address-maps which are
   // valid.
   DoCheckSucceeds(TruncatedYamlString, /*TextSectionIndex=*/1,
                   Section1BBAddrMaps);
 }