[Propeller] Allow basic-block-sections and labels be used together by decoupling the handling of the two features.

[rahmanl]

Summary

Background

Today -split-machine-functions (MFS) and -fbasic-block-sections={all,list} cannot be combined with -basic-block-sections=labels (the labels option will be ignored).
The inconsistency comes from the way basic block address map -- the underlying mechanism for basic block labels -- encodes basic block addresses (https://lists.llvm.org/pipermail/llvm-dev/2020-July/143512.html). Specifically, basic block offsets are computed relative to the function begin symbol. This relies on functions being contiguous which is not the case for MFS and basic block section binaries. This means Propeller cannot use binary profiles collected from these binaries, which limits the applicability of Propeller for iterative optimization.

New Encoding for BB Address Map

To make the BB address map feature work with BB section binaries, we propose modifying the encoding of the BB address map as follows.

The current encoding emits the address of each function and its number of basic blocks, followed by basic block entries for each basic block.

Address of the function	Address	-> 8 bytes (pointer size)
Number of basic blocks in this function	NumBlocks	-> ULEB128
BB entry #1
BB entry #2
...
BB entry #NumBlocks

To make this work for basic block sections, we treat each basic block section similar to a function, except that basic block sections of the same function must be encapsulated in the same structure so we can map all of them to their single function.

We modify the encoding to first emit the number of basic block sections (BB ranges) in the function. Then we emit the address map of each basic block section section as before: the base address of the section, its number of blocks, and BB entries for its basic block. The first section in the BB address map is always the function entry section.

Number of sections for this function	NumBBRanges)	-> ULEB128

Section 0 begin address	BaseAddress[0]	-> 8 bytes (pointer size)
Number of basic blocks in section 0	NumBlocks[0]	-> ULEB128
BB entries for Section 0

.
.
.

Section K begin address	BaseAddress[K]	-> 8 bytes (pointer size)
Number of basic blocks in section K	NumBlocks[K]	-> ULEB128
BB entries for Section K

The encoding of basic block entries remains as before with the minor change that each basic block offset is now computed relative to the begin symbol of its containing BB section.

Option Processing

This patch adds a new boolean codegen option -basic-block-address-map. Correspondingly, the front-end flag -fbasic-block-address-map and LLD flag --lto-basic-block-address-map are introduced.
Analogously, we add a new TargetOption field BBAddrMap. This means BB address maps are either generated for all functions in the compiling unit, or for none (depending on TargetOptions::BBAddrMap).

This patch disables the old -fbasic-block-sections=labels value option but does not remove it. A subsequent patch will remove the obsolete option.

Pass Changes

We refactor the BasicBlockSections pass by separating the BB address map and BB sections handing to their own functions (named handleBBAddrMap and handleBBSections). handleBBSections renumbers basic blocks and places them in their assigned sections. handleBBAddrMap is invoked after handleBBSections (if requested) and only renumbers the blocks.

Tests

• New tests added:
  1. A codgen test basic-block-labels-with-sections.ll to exercise the combination of -basic-block-address-map with -basic-block-sections=list.
  2. A driver sanity test for the -fbasic-block-address-map option.
  3. An LLD test for testing the --lto-basic-block-address-map option. This reuses the LLVM IR from lld/test/ELF/lto/basic-block-sections.ll.
• Renamed and modified the two existing codegen tests for basic block address map (basic-block-sections-labels-functions-sections.ll and basic-block-sections-labels.ll)

[rahmanl]

Rebase.

[rahmanl]

• Fix decoding in ELF.cpp

[rahmanl]

• Fix decoding in ELF.cpp

[rahmanl]

• Remove HasBBLabels.

[tmsriram]

First pass:

• Check Description for typos like "MS" used instead of "MFS"
• Maybe motivation can say that basic-block-sections=all and MFS cannot be used with labels

clang/include/clang/Basic/CodeGenOptions.def

93

Upstream will ask you to break up this patch, same thing happened with -funique-internal-linkage-names. I can think of the following break-up :

1. Patch I will not delete -fbasic-block-sections=labels but just disable it and introduce the new option.
2. Once Patch I is committed, Patch II should delete the old option.

clang/include/clang/Driver/Options.td

2625

Some bike shedding, can this be named basic block addr map, labels seems a residue from the old implementation.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

3290

This code is confusing, it seems like a remnant from the first implementation of labels before bb_addr_map?

llvm/lib/CodeGen/BasicBlockSections.cpp

51

Change comment to reflect new option.

[rahmanl]

• Keep, but disable the old -fbasic-block-sections=labels option.

[rahmanl]

• Refactor AsmPrinter.cpp

[rahmanl]

• Use -fbasic-block-address-map in option description.

[rahmanl]

Thanks for the comments @tmsriram. Please let me know if you have more comments and suggestions.

clang/include/clang/Basic/CodeGenOptions.def

93

Thanks. Adopted the strategy.

clang/include/clang/Driver/Options.td

2625

Thanks. Renamed to basic-block-address-map.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

3290

Actually, basic block labels (maybe local LBB symbols) are required for all basic blocks when the bb address map is requested. This is because we need to compute the basic block address offsets relative to the function entry symbol.

[rahmanl]

• Rebase after D96918.

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(EmitOpenCLArgMetadata , 1, 0) ///< Emit OpenCL kernel arg metadata.
 CODEGENOPT(EmulatedTLS       , 1, 0) ///< Set by default or -f[no-]emulated-tls.
 CODEGENOPT(ExplicitEmulatedTLS , 1, 0) ///< Set if -f[no-]emulated-tls is used.
 /// Embed Bitcode mode (off/all/bitcode/marker).
 ENUM_CODEGENOPT(EmbedBitcode, EmbedBitcodeKind, 2, Embed_Off)
 CODEGENOPT(ForbidGuardVariables , 1, 0) ///< Issue errors if C++ guard variables
                                         ///< are required.
 CODEGENOPT(FunctionSections  , 1, 0) ///< Set when -ffunction-sections is enabled.
+CODEGENOPT(BBAddrMap  , 1, 0) ///< Set when -fbasic-block-address-map is enabled.
 CODEGENOPT(InstrumentFunctions , 1, 0) ///< Set when -finstrument-functions is
                                        ///< enabled.
 CODEGENOPT(InstrumentFunctionsAfterInlining , 1, 0) ///< Set when
                           ///< -finstrument-functions-after-inlining is enabled.
 CODEGENOPT(InstrumentFunctionEntryBare , 1, 0) ///< Set when
                                ///< -finstrument-function-entry-bare is enabled.
 CODEGENOPT(CFProtectionReturn , 1, 0) ///< if -fcf-protection is
                                       ///< set to full or return.

clang/include/clang/Driver/Options.td

 defm zero_initialized_in_bss : BoolFOption<"zero-initialized-in-bss",
   CodeGenOpts<"NoZeroInitializedInBSS">, DefaultFalse,
   NegFlag<SetTrue, [CC1Option], "Don't place zero initialized data in BSS">,
   PosFlag<SetFalse>>;
 defm function_sections : BoolFOption<"function-sections",
   CodeGenOpts<"FunctionSections">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Place each function in its own section">,
   NegFlag<SetFalse>>;
+defm basic_block_address_map : BoolFOption<"basic-block-address-map",
+  CodeGenOpts<"BBAddrMap">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option], "Emit the basic block address map section.">,
+  NegFlag<SetFalse>>;
 def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>,
   Flags<[CC1Option, CC1AsOption]>,
   HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">,
   DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>,
   Values<"all,labels,none,list=">,
   MarshallingInfoString<CodeGenOpts<"BBSections">, [{"none"}]>;
 defm data_sections : BoolFOption<"data-sections",
   CodeGenOpts<"DataSections">, DefaultFalse,

clang/lib/CodeGen/BackendUtil.cpp

if (LangOpts.hasWasmExceptions())
     Options.ExceptionModel = llvm::ExceptionHandling::Wasm;
 
   Options.NoInfsFPMath = LangOpts.NoHonorInfs;
   Options.NoNaNsFPMath = LangOpts.NoHonorNaNs;
   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
   Options.UnsafeFPMath = LangOpts.UnsafeFPMath;
   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
 
+  Options.BBAddrMap = CodeGenOpts.BBAddrMap;
   Options.BBSections =
       llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.BBSections)
           .Case("all", llvm::BasicBlockSection::All)
           .Case("labels", llvm::BasicBlockSection::Labels)
           .StartsWith("list=", llvm::BasicBlockSection::List)
           .Case("none", llvm::BasicBlockSection::None)
           .Default(llvm::BasicBlockSection::None);
 

clang/lib/Driver/ToolChains/Clang.cpp

#endif
 
   bool UseSeparateSections = isUseSeparateSections(Triple);
 
   if (Args.hasFlag(options::OPT_ffunction_sections,
                    options::OPT_fno_function_sections, UseSeparateSections)) {
     CmdArgs.push_back("-ffunction-sections");
   }
 
+  if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_address_map,
+                               options::OPT_fno_basic_block_address_map)) {
+    if (Triple.isX86() && Triple.isOSBinFormatELF()) {
+      if (A->getOption().matches(options::OPT_fbasic_block_address_map))
+        A->render(Args, CmdArgs);
+    } else {
+      D.Diag(diag::err_drv_unsupported_opt_for_target)
+          << A->getAsString(Args) << TripleStr;
+    }
+  }
+
   if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) {
     if (Triple.isX86() && Triple.isOSBinFormatELF()) {
       StringRef Val = A->getValue();
       if (Val != "all" && Val != "labels" && Val != "none" &&
           !Val.startswith("list="))
         D.Diag(diag::err_drv_invalid_value)
             << A->getAsString(Args) << A->getValue();
       else

clang/test/Driver/basic-block-address-map.c

+// RUN: %clang -### -target x86_64 -fbasic-block-address-map %s -S 2>&1 | FileCheck -check-prefix=CHECK-PRESENT %s
+// CHECK-PRESENT: -fbasic-block-address-map
+
+// RUN: %clang -### -target x86_64 -fno-basic-block-address-map %s -S 2>&1 | FileCheck %s --check-prefix=CHECK-ABSENT
+// CHECK-ABSENT-NOT: -fbasic-block-address-map
+
+// RUN: not %clang -c -target x86_64-apple-darwin10 -fbasic-block-address-map %s -S 2>&1 | FileCheck -check-prefix=CHECK-TRIPLE %s
+// CHECK-TRIPLE: error: unsupported option '-fbasic-block-address-map' for target

lld/ELF/Config.h

struct Configuration {
   llvm::StringRef optRemarksFormat;
   llvm::StringRef progName;
   llvm::StringRef printArchiveStats;
   llvm::StringRef printSymbolOrder;
   llvm::StringRef soName;
   llvm::StringRef sysroot;
   llvm::StringRef thinLTOCacheDir;
   llvm::StringRef thinLTOIndexOnlyArg;
+  bool ltoBBAddrMap;
   llvm::StringRef ltoBasicBlockSections;
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOObjectSuffixReplace;
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOPrefixReplace;
   std::string rpath;
   std::vector<VersionDefinition> versionDefinitions;
   std::vector<llvm::StringRef> auxiliaryList;
   std::vector<llvm::StringRef> filterList;
   std::vector<llvm::StringRef> searchPaths;

lld/ELF/Driver.cpp

config->ltoWholeProgramVisibility =
       args.hasFlag(OPT_lto_whole_program_visibility,
                    OPT_no_lto_whole_program_visibility, false);
   config->ltoo = args::getInteger(args, OPT_lto_O, 2);
   config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path_eq);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
   config->ltoPseudoProbeForProfiling =
       args.hasArg(OPT_lto_pseudo_probe_for_profiling);
   config->ltoSampleProfile = args.getLastArgValue(OPT_lto_sample_profile);
+  config->ltoBBAddrMap =
+      args.hasFlag(OPT_lto_basic_block_address_map,
+                   OPT_no_lto_basic_block_address_map, false);
   config->ltoBasicBlockSections =
       args.getLastArgValue(OPT_lto_basic_block_sections);
   config->ltoUniqueBasicBlockSectionNames =
       args.hasFlag(OPT_lto_unique_basic_block_section_names,
                    OPT_no_lto_unique_basic_block_section_names, false);
   config->mapFile = args.getLastArgValue(OPT_Map);
   config->mipsGotSize = args::getInteger(args, OPT_mips_got_size, 0xfff0);
   config->mergeArmExidx =

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.Options = initTargetOptionsFromCodeGenFlags();
   c.Options.RelaxELFRelocations = true;
   c.Options.EmitAddrsig = true;
 
   // Always emit a section per function/datum with LTO.
   c.Options.FunctionSections = true;
   c.Options.DataSections = true;
 
+  c.Options.BBAddrMap = config->ltoBBAddrMap;
+
   // Check if basic block sections must be used.
   // Allowed values for --lto-basic-block-sections are "all", "labels",
   // "<file name specifying basic block ids>", or none.  This is the equivalent
   // of -fbasic-block-sections= flag in clang.
   if (!config->ltoBasicBlockSections.empty()) {
     if (config->ltoBasicBlockSections == "all") {
       c.Options.BBSections = BasicBlockSection::All;
     } else if (config->ltoBasicBlockSections == "labels") {

lld/ELF/Options.td

defm opt_remarks_hotness_threshold: EEq<"opt-remarks-hotness-threshold",
   MetaVarName<"<value>">;
 def opt_remarks_passes: Separate<["--"], "opt-remarks-passes">,
   HelpText<"Regex for the passes that need to be serialized to the output file">;
 def opt_remarks_with_hotness: FF<"opt-remarks-with-hotness">,
   HelpText<"Include hotness information in the optimization remarks file">;
 def opt_remarks_format: Separate<["--"], "opt-remarks-format">,
   HelpText<"The format used for serializing remarks (default: YAML)">;
 def save_temps: F<"save-temps">, HelpText<"Save intermediate LTO compilation results">;
+defm lto_basic_block_address_map: BB<"lto-basic-block-address-map",
+    "Enable emitting the basic block address map section for LTO",
+    "Disable emitting the basic block address map section for LTO (default)">;
 def lto_basic_block_sections: JJ<"lto-basic-block-sections=">,
   HelpText<"Enable basic block sections for LTO">;
 defm lto_unique_basic_block_section_names: BB<"lto-unique-basic-block-section-names",
     "Give unique names to every basic block section for LTO",
     "Do not give unique names to every basic block section for LTO (default)">;
 defm shuffle_sections: EEq<"shuffle-sections",
   "Shuffle matched sections using the given seed before mapping them to the output sections. "
   "If -1, reverse the section order. If 0, use a random seed">,

lld/test/ELF/lto/basic-block-address-map.ll

+; REQUIRES: x86
+; RUN: llvm-as %s -o %t.o
+; RUN: ld.lld %t.o -o %t --lto-basic-block-address-map --lto-O0 --save-temps
+; RUN: llvm-readobj -s %t.lto.o | FileCheck --check-prefix=SECNAMES %s
+
+; SECNAMES: Type: SHT_LLVM_BB_ADDR_MAP
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo(i32 %b) local_unnamed_addr {
+entry:
+  %tobool.not = icmp eq i32 %b, 0
+  br i1 %tobool.not, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  tail call void @foo(i32 0)
+  br label %if.end
+
+if.end:                                           ; preds = %entry, %if.then
+  ret void
+}
+
+define void @_start() {
+  call void @foo(i32 1)
+  ret void
+}

llvm/include/llvm/CodeGen/CommandFlags.h

 bool getXRayOmitFunctionIndex();
 
 /// Create this object with static storage to register codegen-related command
 /// line options.
 struct RegisterCodeGenFlags {
   RegisterCodeGenFlags();
 };
 
+bool getEnableBBAddrMap();
+
 llvm::BasicBlockSection getBBSectionsMode(llvm::TargetOptions &Options);
 
 llvm::StackProtectorGuards
 getStackProtectorGuardMode(llvm::TargetOptions &Options);
 
 /// Common utility function tightly tied to the options listed here. Initializes
 /// a TargetOptions object with CodeGen flags and returns it.
 /// \p TheTriple is used to determine the default value for options if

llvm/include/llvm/Object/ELFTypes.h

template <class ELFT> struct Elf_Mips_ABIFlags {
   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 Offset; // Offset of basic block relative to the base address.
     uint32_t Size;   // Size of the basic block.
 
     // The following fields are decoded from the Metadata field. The encoding
     // happens in AsmPrinter.cpp:getBBAddrMapMetadata.
     bool HasReturn;      // If this block ends with a return (or tail call).
     bool HasTailCall;    // If this block ends with a tail call.
     bool IsEHPad;        // If this is an exception handling block.
     bool CanFallThrough; // If this block can fall through to its next.
 
     BBEntry(uint32_t Offset, uint32_t Size, uint32_t Metadata)
         : Offset(Offset), Size(Size), HasReturn(Metadata & 1),
           HasTailCall(Metadata & (1 << 1)), IsEHPad(Metadata & (1 << 2)),
           CanFallThrough(Metadata & (1 << 3)){};
   };
-  std::vector<BBEntry> BBEntries; // Basic block entries for this function.
+
+  // Struct representing the BBAddrMap information for a contiguous range of
+  // basic blocks (a function or a basic block section).
+  struct BBRangeEntry {
+    uintX_t BaseAddr;               // Base address of the range.
+    std::vector<BBEntry> BBEntries; // Basic block entries for this range.
+  };
+
+  // All ranges for this function. The first range always corresponds to the
+  // function entry.
+  std::vector<BBRangeEntry> BBRanges;
 };
 
 } // 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;
+
+  struct BBRangeEntry {
+    llvm::yaml::Hex64 BaseAddress;
     Optional<uint64_t> NumBlocks;
     Optional<std::vector<BBEntry>> BBEntries;
   };
 
+  Optional<uint64_t> NumBBRanges;
+  Optional<std::vector<BBRangeEntry>> BBRanges;
+};
+
 struct StackSizeEntry {
   llvm::yaml::Hex64 Address;
   llvm::yaml::Hex64 Size;
 };
 
 struct NoteEntry {
   StringRef Name;
   yaml::BinaryRef Desc;
bool shouldAllocateFileSpace(ArrayRef<ProgramHeader> Phdrs,
                              const NoBitsSection &S);
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBRangeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)

 template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
   static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::BBAddrMapEntry> {
   static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &Rel);
 };
 
+template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBRangeEntry> {
+  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBRangeEntry &Rel);
+};
+
 template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
   static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &Rel);
 };
 
 template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
   static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);
 };
 

llvm/include/llvm/Target/TargetOptions.h

namespace llvm {
 
   enum class BasicBlockSection {
     All,    // Use Basic Block Sections for all basic blocks.  A section
             // for every basic block can significantly bloat object file sizes.
     List,   // Get list of functions & BBs from a file. Selectively enables
             // basic block sections for a subset of basic blocks which can be
             // used to control object size bloats from creating sections.
     Labels, // Do not use Basic Block Sections but label basic blocks.  This
-            // is useful when associating profile counts from virtual addresses
-            // to basic blocks.
+            // is useful when associating profile counts from virtual
+            // addresses to basic blocks.
     Preset, // Similar to list but the blocks are identified by passes which
             // seek to use Basic Block Sections, e.g. MachineFunctionSplitter.
             // This option cannot be set via the command line.
     None    // Do not use Basic Block Sections.
   };
 
   enum class StackProtectorGuards {
     None,
TargetOptions()
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
           IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true),
           UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
           TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
           EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
-          EmitAddrsig(false), EmitCallSiteInfo(false),
+          EmitAddrsig(false), BBAddrMap(false), EmitCallSiteInfo(false),
           SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
           PseudoProbeForProfiling(false), ValueTrackingVariableLocations(false),
           ForceDwarfFrameSection(false), XRayOmitFunctionIndex(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
     bool DisableFramePointerElim(const MachineFunction &MF) const;
public:
     unsigned EnableMachineFunctionSplitter : 1;
 
     /// Set if the target supports default outlining behaviour.
     unsigned SupportsDefaultOutlining : 1;
 
     /// Emit address-significance table.
     unsigned EmitAddrsig : 1;
 
+    // Emit section containing basic block address offsets, which Propeller uses
+    // to associate profile counts from virtual addresses to basic blocks.
+    unsigned BBAddrMap : 1;
+
     /// Emit basic blocks into separate sections.
     BasicBlockSection BBSections = BasicBlockSection::None;
 
     /// Memory Buffer that contains information on sampled basic blocks and used
     /// to selectively generate basic block sections.
     std::shared_ptr<MemoryBuffer> BBSectionsFuncListBuf;
 
     /// The flag enables call site info production. It is used only for debug

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);
-  OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
-  // Emit the total number of basic blocks in this function.
-  OutStreamer->emitULEB128IntValue(MF.size());
-  // Emit BB Information for each basic block in the funciton.
+
+  // Emit the number of basic block ranges.
+  OutStreamer->emitULEB128IntValue(MBBSectionRanges.size());
+
+  // Count the number of blocks in each MBB section.
+  MapVector<unsigned, unsigned> MBBSectionNumBlocks;
+
+  if (!MF.hasBBSections()) {
+    // If this function has no basic block sections, it will have a single basic
+    // block range which contains all of its blocks.
+    MBBSectionNumBlocks[MF.front().getSectionIDNum()] = MF.size();
+  } else {
+    unsigned BBCount = 0;
+    for (const MachineBasicBlock &MBB : MF) {
+      BBCount++;
+      if (MBB.isEndSection()) {
+        // Store each section's basic block count when it ends.
+        MBBSectionNumBlocks[MBB.getSectionIDNum()] = BBCount;
+        // Reset the count for the next section.
+        BBCount = 0;
+      }
+    }
+  }
+
+  // Emit the BB entry for each basic block in the function.
   for (const MachineBasicBlock &MBB : MF) {
     const MCSymbol *MBBSymbol =
         MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
+
+    if (MBB.isBeginSection() || MBB.isEntryBlock()) {
+      OutStreamer->emitSymbolValue(MBBSymbol, getPointerSize());
+      OutStreamer->emitULEB128IntValue(
+          MBBSectionNumBlocks[MBB.getSectionIDNum()]);
+    }
+
     // Emit the basic block offset.
-    emitLabelDifferenceAsULEB128(MBBSymbol, FunctionSymbol);
+    emitLabelDifferenceAsULEB128(
+        MBBSymbol, MBBSectionRanges[MBB.getSectionIDNum()].BeginLabel);
     // 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));
   }
   OutStreamer->PopSection();
 }
 
for (auto &MI : MBB) {
         HI.Handler->endInstruction();
       }
     }
 
     // We must emit temporary symbol for the end of this basic block, if either
     // we have BBLabels enabled or if this basic blocks marks the end of a
     // section (except the section containing the entry basic block as the end
     // symbol for that section is CurrentFnEnd).
-    if (MF->hasBBLabels() ||
+    if (MF->getTarget().Options.BBAddrMap ||
         (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection() &&
          !MBB.sameSection(&MF->front())))
       OutStreamer->emitLabel(MBB.getEndSymbol());
 
     if (MBB.isEndSection()) {
       // The size directive for the section containing the entry block is
       // handled separately by the function section.
       if (!MBB.sameSection(&MF->front())) {
void AsmPrinter::emitFunctionBody() {
   for (const HandlerInfo &HI : Handlers) {
     NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
                        HI.TimerGroupDescription, TimePassesIsEnabled);
     HI.Handler->endFunction(MF);
   }
 
   // Emit section containing BB address offsets and their metadata, when
   // BB labels are requested for this function.
-  if (MF->hasBBLabels())
+  if (MF->getTarget().Options.BBAddrMap)
     emitBBAddrMapSection(*MF);
 
   // Emit section containing stack size metadata.
   emitStackSizeSection(*MF);
 
   emitPatchableFunctionEntries();
 
   if (isVerbose())
void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   CurrentSectionBeginSym = nullptr;
   MBBSectionRanges.clear();
   MBBSectionExceptionSyms.clear();
   bool NeedsLocalForSize = MAI->needsLocalForSize();
   if (F.hasFnAttribute("patchable-function-entry") ||
       F.hasFnAttribute("function-instrument") ||
       F.hasFnAttribute("xray-instruction-threshold") ||
       needFuncLabelsForEHOrDebugInfo(MF) || NeedsLocalForSize ||
-      MF.getTarget().Options.EmitStackSizeSection || MF.hasBBLabels()) {
+      MF.getTarget().Options.EmitStackSizeSection ||
+      MF.getTarget().Options.BBAddrMap) {
     CurrentFnBegin = createTempSymbol("func_begin");
     if (NeedsLocalForSize)
       CurrentFnSymForSize = CurrentFnBegin;
   }
 
   ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
 }
 
void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility,
   }
 
   if (Attr != MCSA_Invalid)
     OutStreamer->emitSymbolAttribute(Sym, Attr);
 }
 
 bool AsmPrinter::shouldEmitLabelForBasicBlock(
     const MachineBasicBlock &MBB) const {
-  // With `-fbasic-block-sections=`, a label is needed for every non-entry block
-  // in the labels mode (option `=labels`) and every section beginning in the
-  // sections mode (`=all` and `=list=`).
-  if ((MF->hasBBLabels() || MBB.isBeginSection()) && !MBB.isEntryBlock())
+  // With `-fbasic-block-address-map`, a label is needed for every non-entry
+  // block. With `-fbaisc-block-sections`, a label is needed for each
+  // (non-entry) basic block which begins a section.
+  if ((MF->getTarget().Options.BBAddrMap || MBB.isBeginSection()) &&
+      !MBB.isEntryBlock())
     return true;
   // A label is needed for any block with at least one predecessor (when that
   // predecessor is not the fallthrough predecessor, or if it is an EH funclet
   // entry, or if a label is forced).
   return !MBB.pred_empty() &&
          (!isBlockOnlyReachableByFallthrough(&MBB) || MBB.isEHFuncletEntry() ||
           MBB.hasLabelMustBeEmitted());
 }

llvm/lib/CodeGen/BasicBlockSections.cpp

 //    time, and therefore, long branch instructions have to be used for those.
 //
 // 3. Debug Information (DebugInfo) and Call Frame Information (CFI) emission
 //    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
+// Basic Block Address Map
 // ==================
 //
-// With -fbasic-block-sections=labels, we emit the offsets of BB addresses of
+// With -fbasic-block-address-map, we emit 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``.
+// pass only renumbers basic blocks.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
public:
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   /// Read profiles of basic blocks if available here.
   bool doInitialization(Module &M) override;
 
   /// Identify basic blocks that need separate sections and prepare to emit them
   /// accordingly.
+  bool handleBBSections(MachineFunction &MF);
+
+  bool handleBBAddrMap(MachineFunction &MF);
+
   bool runOnMachineFunction(MachineFunction &MF) override;
 };
 
 } // end anonymous namespace
 
 char BasicBlockSections::ID = 0;
 INITIALIZE_PASS(BasicBlockSections, "bbsections-prepare",
                 "Prepares for basic block sections, by splitting functions "
if (Existing) {
     for (auto &N : Tuple->operands())
       if (cast<MDString>(N.get())->getString() == MetadataName)
         return true;
   }
 
   return false;
 }
 
-bool BasicBlockSections::runOnMachineFunction(MachineFunction &MF) {
+// Identify, arrange, and modify basic blocks which need separate sections
+// according to the specification provided by the -fbasic-block-sections flag.
+bool BasicBlockSections::handleBBSections(MachineFunction &MF) {
   auto BBSectionsType = MF.getTarget().getBBSectionsType();
-  assert(BBSectionsType != BasicBlockSection::None &&
-         "BB Sections not enabled!");
+  if (BBSectionsType == BasicBlockSection::None)
+    return false;
 
   // Check for source drift.  If the source has changed since the profiles
   // were obtained, optimizing basic blocks might be sub-optimal.
   // This only applies to BasicBlockSection::List as it creates
   // clusters of basic blocks using basic block ids. Source drift can
   // invalidate these groupings leading to sub-optimal code generation with
   // regards to performance.
   if (BBSectionsType == BasicBlockSection::List &&
       hasInstrProfHashMismatch(MF))
-    return true;
+    return false;
 
-  // Renumber blocks before sorting them for basic block sections.  This is
-  // useful during sorting, basic blocks in the same section will retain the
-  // default order.  This renumbering should also be done for basic block
-  // labels to match the profiles with the correct blocks.
+  // Renumber blocks before sorting them to match the profiles with the correct
+  // blocks.  This is also useful during sorting as basic blocks in the same
+  // section will retain the default order.
   MF.RenumberBlocks();
 
-  if (BBSectionsType == BasicBlockSection::Labels) {
-    MF.setBBSectionsType(BBSectionsType);
-    return true;
-  }
-
   std::vector<Optional<BBClusterInfo>> FuncBBClusterInfo;
   if (BBSectionsType == BasicBlockSection::List &&
       !getBBClusterInfoForFunction(MF, FuncAliasMap, ProgramBBClusterInfo,
                                    FuncBBClusterInfo))
-    return true;
+    return false;
   MF.setBBSectionsType(BBSectionsType);
   assignSections(MF, FuncBBClusterInfo);
 
   // We make sure that the cluster including the entry basic block precedes all
   // other clusters.
   auto EntryBBSectionID = MF.front().getSectionID();
 
   // Helper function for ordering BB sections as follows:
auto Comparator = [&](const MachineBasicBlock &X,
     return X.getNumber() < Y.getNumber();
   };
 
   sortBasicBlocksAndUpdateBranches(MF, Comparator);
   avoidZeroOffsetLandingPad(MF);
   return true;
 }
 
+// When the BB address map needs to be generated, this renumbers basic blocks to
+// make them appear in increasing order of their IDs in the function. This
+// avoids the need to store basic block IDs in the BB address map section, since
+// they can be determined implicitly.
+bool BasicBlockSections::handleBBAddrMap(MachineFunction &MF) {
+  if (MF.getTarget().Options.BBAddrMap) {
+    MF.RenumberBlocks();
+    return true;
+  }
+  return false;
+}
+
+bool BasicBlockSections::runOnMachineFunction(MachineFunction &MF) {
+  // First handle the basic block sections.
+  auto R1 = handleBBSections(MF);
+  // Handle basic block address map after basic block sections are finalized.
+  auto R2 = handleBBAddrMap(MF);
+  return R1 || R2;
+}
+
 // Basic Block Sections can be enabled for a subset of machine basic blocks.
 // This is done by passing a file containing names of functions for which basic
 // block sections are desired.  Additionally, machine basic block ids of the
 // functions can also be specified for a finer granularity. Moreover, a cluster
 // of basic blocks could be assigned to the same section.
 // A file with basic block sections for all of function main and three blocks
 // for function foo (of which 1 and 2 are placed in a cluster) looks like this:
 // ----------------------------

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(bool, StackRealign)
 CGOPT(std::string, TrapFuncName)
 CGOPT(bool, UseCtors)
 CGOPT(bool, RelaxELFRelocations)
 CGOPT_EXP(bool, DataSections)
 CGOPT_EXP(bool, FunctionSections)
 CGOPT(bool, IgnoreXCOFFVisibility)
 CGOPT(bool, XCOFFTracebackTable)
+CGOPT(bool, EnableBBAddrMap)
 CGOPT(std::string, BBSections)
 CGOPT(std::string, StackProtectorGuard)
 CGOPT(unsigned, StackProtectorGuardOffset)
 CGOPT(std::string, StackProtectorGuardReg)
 CGOPT(unsigned, TLSSize)
 CGOPT(bool, EmulatedTLS)
 CGOPT(bool, UniqueSectionNames)
 CGOPT(bool, UniqueBasicBlockSectionNames)
static cl::opt<bool> IgnoreXCOFFVisibility(
       cl::init(false));
   CGBINDOPT(IgnoreXCOFFVisibility);
 
   static cl::opt<bool> XCOFFTracebackTable(
       "xcoff-traceback-table", cl::desc("Emit the XCOFF traceback table"),
       cl::init(true));
   CGBINDOPT(XCOFFTracebackTable);
 
+  static cl::opt<bool> EnableBBAddrMap(
+      "basic-block-address-map",
+      cl::desc("Emit the basic block address map section"), cl::init(false));
+  CGBINDOPT(EnableBBAddrMap);
+
   static cl::opt<std::string> BBSections(
       "basic-block-sections",
       cl::desc("Emit basic blocks into separate sections"),
       cl::value_desc("all | <function list (file)> | labels | none"),
       cl::init("none"));
   CGBINDOPT(BBSections);
 
   static cl::opt<std::string> StackProtectorGuard(
codegen::InitTargetOptionsFromCodeGenFlags(const Triple &TheTriple) {
   Options.StackSymbolOrdering = getStackSymbolOrdering();
   Options.UseInitArray = !getUseCtors();
   Options.RelaxELFRelocations = getRelaxELFRelocations();
   Options.DataSections =
       getExplicitDataSections().getValueOr(TheTriple.hasDefaultDataSections());
   Options.FunctionSections = getFunctionSections();
   Options.IgnoreXCOFFVisibility = getIgnoreXCOFFVisibility();
   Options.XCOFFTracebackTable = getXCOFFTracebackTable();
+  Options.BBAddrMap = getEnableBBAddrMap();
   Options.BBSections = getBBSectionsMode(Options);
   Options.UniqueSectionNames = getUniqueSectionNames();
   Options.UniqueBasicBlockSectionNames = getUniqueBasicBlockSectionNames();
   Options.StackProtectorGuard = getStackProtectorGuardMode(Options);
   Options.StackProtectorGuardOffset = getStackProtectorGuardOffset();
   Options.StackProtectorGuardReg = getStackProtectorGuardReg();
   Options.TLSSize = getTLSSize();
   Options.EmulatedTLS = getEmulatedTLS();

llvm/lib/CodeGen/TargetPassConfig.cpp

if (TM->Options.EnableMachineOutliner && getOptLevel() != CodeGenOpt::None &&
     bool RunOnAllFunctions =
         (EnableMachineOutliner == RunOutliner::AlwaysOutline);
     bool AddOutliner =
         RunOnAllFunctions || TM->Options.SupportsDefaultOutlining;
     if (AddOutliner)
       addPass(createMachineOutlinerPass(RunOnAllFunctions));
   }
 
+  bool NeedsBBSections =
+      TM->getBBSectionsType() != llvm::BasicBlockSection::None;
   // Machine function splitter uses the basic block sections feature. Both
-  // cannot be enabled at the same time. Basic block sections takes precedence.
-  // FIXME: In principle, BasicBlockSection::Labels and splitting can used
-  // together. Update this check once we have addressed any issues.
-  if (TM->getBBSectionsType() != llvm::BasicBlockSection::None) {
-    addPass(llvm::createBasicBlockSectionsPass(TM->getBBSectionsFuncListBuf()));
-  } else if (TM->Options.EnableMachineFunctionSplitter ||
-             EnableMachineFunctionSplitter) {
+  // cannot be enabled at the same time. We do not apply machine function
+  // splitter if -basic-block-sections is requested.
+  if (!NeedsBBSections && (TM->Options.EnableMachineFunctionSplitter ||
+                           EnableMachineFunctionSplitter))
     addPass(createMachineFunctionSplitterPass());
-  }
+  // We run the BasicBlockSections pass if either we need BB sections or BB
+  // labels (or both).
+  if (NeedsBBSections || TM->Options.BBAddrMap)
+    addPass(llvm::createBasicBlockSectionsPass(TM->getBBSectionsFuncListBuf()));
 
   // Add passes that directly emit MI after all other MI passes.
   addPreEmitPass2();
 
   // Insert pseudo probe annotation for callsite profiling
   if (TM->Options.PseudoProbeForProfiling)
     addPass(createPseudoProbeInserter());
 

llvm/lib/Object/ELF.cpp

if (Value > UINT32_MAX) {
           "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));
+    std::vector<typename Elf_BBAddrMap::BBRangeEntry> BBRangeEntries;
+    uint32_t NumBBRanges = ReadULEB128AsUInt32();
+    for (uint32_t BBRangeID = 0;
+         !ULEBSizeErr && Cur && (BBRangeID != NumBBRanges); ++BBRangeID) {
+      uintX_t BaseAddress = 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);
+      BBEntries.reserve(NumBlocks);
+      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});
+      BBRangeEntries.push_back({BaseAddress, BBEntries});
+    }
+    FunctionEntries.push_back({BBRangeEntries});
   }
   // 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

 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::BBAddrMapSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::BBAddrMapEntry &E : *Section.Entries) {
-    // Write the address of the function.
-    CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
-    // Write number of BBEntries (number of basic blocks in the function). This
-    // is overridden by the 'NumBlocks' YAML field when specified.
+    // Write the number of basic block ranges, which is overridden by the
+    // 'NumBBRanges' field when specified.
+    uint32_t NumBBRanges =
+        E.NumBBRanges.getValueOr(E.BBRanges ? E.BBRanges->size() : 0);
+    SHeader.sh_size += CBA.writeULEB128(NumBBRanges);
+    for (const ELFYAML::BBAddrMapEntry::BBRangeEntry &BBR : *E.BBRanges) {
+      // Write the base address of the range.
+      CBA.write<uintX_t>(BBR.BaseAddress, ELFT::TargetEndianness);
+      // Write number of BBEntries (number of basic blocks in this basic block
+      // range). This is overridden by the 'NumBlocks' YAML field when
+      // specified.
       uint64_t NumBlocks =
-        E.NumBlocks.getValueOr(E.BBEntries ? E.BBEntries->size() : 0);
+          BBR.NumBlocks.getValueOr(BBR.BBEntries ? BBR.BBEntries->size() : 0);
       SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(NumBlocks);
-    // Write all BBEntries.
-    if (!E.BBEntries)
+      // Write all BBEntries in this BBRange.
+      if (!BBR.BBEntries)
         continue;
-    for (const ELFYAML::BBAddrMapEntry::BBEntry &BBE : *E.BBEntries)
+      for (const ELFYAML::BBAddrMapEntry::BBEntry &BBE : *BBR.BBEntries)
         SHeader.sh_size += CBA.writeULEB128(BBE.AddressOffset) +
                            CBA.writeULEB128(BBE.Size) +
                            CBA.writeULEB128(BBE.Metadata);
     }
   }
+}
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (!Section.Options)
     return;
 

llvm/lib/ObjectYAML/ELFYAML.cpp

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("Address", E.Address, Hex64(0));
+  IO.mapOptional("NumBBRanges", E.NumBBRanges);
+  IO.mapOptional("BBRanges", E.BBRanges);
+}
+
+void MappingTraits<ELFYAML::BBAddrMapEntry::BBRangeEntry>::mapping(
+    IO &IO, ELFYAML::BBAddrMapEntry::BBRangeEntry &E) {
+  IO.mapOptional("BaseAddress", E.BaseAddress, 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");
   IO.mapRequired("AddressOffset", E.AddressOffset);

llvm/test/CodeGen/X86/basic-block-address-map-function-sections.ll

-; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=labels | FileCheck %s
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-address-map | 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:   .byte 1
 ; CHECK-NEXT:   .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:   .byte 1
 ; CHECK-NEXT:   .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:   .byte 1
 ; CHECK-NEXT:   .quad [[FOOCOMDAT_BEGIN]]

llvm/test/CodeGen/X86/basic-block-address-map-with-sections.ll

+;; Check that the basic-block-address-map option works when used along with -basic-block-sections.
+;; Let a function with 4 basic blocks get split into 2 sections.
+; RUN: echo '!_Z3bazb' > %t
+; RUN: echo '!!0 2' >> %t
+; RUN: llc < %s -mtriple=x86_64 -unique-section-names=false -basic-block-address-map -basic-block-sections=%t | FileCheck %s
+
+define void @_Z3bazb(i1 zeroext) personality i32 (...)* @__gxx_personality_v0 {
+  br i1 %0, label %2, label %7
+
+2:
+  %3 = invoke i32 @_Z3barv()
+          to label %7 unwind label %5
+  br label %9
+
+5:
+  landingpad { i8*, i32 }
+          catch i8* null
+  br label %9
+
+7:
+  %8 = call i32 @_Z3foov()
+  br label %9
+
+9:
+  ret void
+}
+
+declare i32 @_Z3barv() #1
+
+declare i32 @_Z3foov() #1
+
+declare i32 @__gxx_personality_v0(...)
+
+; CHECK:    .section .text,"ax",@progbits,unique,1
+; CHECK-LABEL:  _Z3bazb:
+; CHECK-LABEL:  .Lfunc_begin0:
+; CHECK-LABEL:  .LBB_END0_0:
+; CHECK-LABEL:  .LBB0_1:
+; CHECK-LABEL:  .LBB_END0_1:
+; CHECK:    .section .text.split._Z3bazb,"ax",@progbits
+; CHECK-LABEL:  _Z3bazb.cold:
+; CHECK-LABEL:  .LBB_END0_2:
+; CHECK-LABEL:  .LBB0_3:
+; CHECK-LABEL:  .LBB_END0_3:
+; CHECK-LABEL:  .Lfunc_end0:
+
+; CHECK:    .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text,unique,1
+; CHECK-NEXT: .byte 2
+; CHECK-NEXT: .quad .Lfunc_begin0
+; CHECK-NEXT: .byte 2
+; 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 .LBB_END0_1-.LBB0_1
+; CHECK-NEXT: .byte 1
+; CHECK-NEXT: .quad _Z3bazb.cold
+; CHECK-NEXT: .byte 2
+; CHECK-NEXT: .uleb128 _Z3bazb.cold-_Z3bazb.cold
+; CHECK-NEXT: .uleb128 .LBB_END0_2-_Z3bazb.cold
+; CHECK-NEXT: .byte 0
+; CHECK-NEXT: .uleb128 .LBB0_3-_Z3bazb.cold
+; CHECK-NEXT: .uleb128 .LBB_END0_3-.LBB0_3
+; CHECK-NEXT: .byte 5

llvm/test/CodeGen/X86/basic-block-address-map.ll

 ; Check the basic block sections labels option
-; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=true -basic-block-sections=labels | FileCheck %s --check-prefix=UNIQ
-; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=false -basic-block-sections=labels | FileCheck %s --check-prefix=NOUNIQ
-; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=true -basic-block-sections=labels -split-machine-functions | FileCheck %s --check-prefix=UNIQ
+; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=true -basic-block-address-map | FileCheck %s --check-prefixes=CHECK,UNIQ
+; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=false -basic-block-address-map | FileCheck %s --check-prefixes=CHECK,NOUNIQ
+; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=true -basic-block-address-map -split-machine-functions | FileCheck %s --check-prefixes=CHECK,UNIQ
+; RUN: llc < %s -mtriple=x86_64 -basic-block-address-map | FileCheck %s --check-prefixes=CHECK,NOFSEC
 
 define void @_Z3bazb(i1 zeroext) personality i32 (...)* @__gxx_personality_v0 {
   br i1 %0, label %2, label %7
 
 2:
   %3 = invoke i32 @_Z3barv()
           to label %7 unwind label %5
   br label %9

 
 declare i32 @_Z3barv() #1
 
 declare i32 @_Z3foov() #1
 
 declare i32 @__gxx_personality_v0(...)
 
 ; UNIQ:     .section .text._Z3bazb,"ax",@progbits{{$}}
-; NOUNIQ:   .section .text,"ax",@progbits,unique,1
+; NOUNIQ:   .section .text,"ax",@progbits,unique,1{{$}}
+; NOFSEC:   .text
 ; CHECK-LABEL:  _Z3bazb:
 ; CHECK-LABEL:  .Lfunc_begin0:
 ; CHECK-LABEL:  .LBB_END0_0:
 ; CHECK-LABEL:  .LBB0_1:
 ; CHECK-LABEL:  .LBB_END0_1:
-; CHECK-LABEL:  .LBB0_2:
+; CHECK-LABEL:  .LBB0_2:
 ; 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
+; NOUNIQ:   .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text,unique,1{{$}}
+; NOFSEC:   .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text{{$}}
+; CHECK-NEXT: .byte 1
 ; 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 0
+; CHECK-NEXT: .byte 8
 ; CHECK-NEXT: .uleb128 .LBB0_1-.Lfunc_begin0
 ; CHECK-NEXT: .uleb128 .LBB_END0_1-.LBB0_1
-; CHECK-NEXT: .byte 0
+; CHECK-NEXT: .byte 8
 ; CHECK-NEXT: .uleb128 .LBB0_2-.Lfunc_begin0
 ; CHECK-NEXT: .uleb128 .LBB_END0_2-.LBB0_2
 ; CHECK-NEXT: .byte 1
 ; CHECK-NEXT: .uleb128 .LBB0_3-.Lfunc_begin0
 ; 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=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 32-bit:
 # 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
+# RUN: yaml2obj %s -DBITS=32 -DSIZE=5 -o %t2.o
+# RUN: llvm-readobj %t2.o --bb-addr-map 2>&1 | FileCheck %s -DOFFSET=0x00000005 -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:         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:     BB Ranges [
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Base Address: [[ADDR]]
+# 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:       }
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Base Address: 0x44444
+# LLVM-NEXT:         BB Entries [
+# 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:     ]
+# 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:         HasReturn: No
-# LLVM-NEXT:         HasTailCall: No
-# LLVM-NEXT:         IsEHPad: No
-# LLVM-NEXT:         CanFallThrough: Yes
-# LLVM-NEXT:       }
-# LLVM-NEXT:     ]
-# LLVM-NEXT:   }
-# LLVM-NEXT: ]
+# LLVM-NEXT:     BB Ranges [
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Base Address: 0x22222
+# 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:   }
+# 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:         HasReturn: Yes
-# LLVM-NEXT:         HasTailCall: Yes
-# LLVM-NEXT:         IsEHPad: No
-# LLVM-NEXT:         CanFallThrough: Yes
-# LLVM-NEXT:       }
-# LLVM-NEXT:     ]
-# LLVM-NEXT:   }
-# LLVM-NEXT: ]
+# LLVM-NEXT:     BB Ranges [
+# LLVM-NEXT:       {
+# LLVM-NEXT:         Base Address: 0x33333
+# 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:     ]
+# 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:         HasReturn: Yes
-# TRUNCATED-NEXT:         HasTailCall: Yes
-# TRUNCATED-NEXT:         IsEHPad: No
-# TRUNCATED-NEXT:         CanFallThrough: Yes
-# TRUNCATED-NEXT:       }
-# TRUNCATED-NEXT:     ]
-# TRUNCATED-NEXT:   }
-# TRUNCATED-NEXT: ]
+# TRUNCATED-NEXT:     At: 0x33333
+# TRUNCATED-NEXT:     BB Ranges [
+# TRUNCATED-NEXT:       {
+# TRUNCATED-NEXT:         Base Address: 0x33333
+# 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:       }
+# 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]]
+      - BBRanges:
+        - BaseAddress: [[ADDR=0x11111]]
           BBEntries:
             - AddressOffset: 0x0
               Size:          0x1
               Metadata:      0xF0000002
+        - BaseAddress: 0x44444
+          BBEntries:
             - AddressOffset: 0x3
               Size:          0x4
               Metadata:      0x5
-      - Address: 0x22222
+      - BBRanges:
+        - BaseAddress: 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
+      - BBRanges:
+        - BaseAddress: 0x33333
           BBEntries:
             - AddressOffset: 0x9
               Size:          0xa
               Metadata:      0xb

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

 ## Check how obj2yaml produces YAML .llvm_bb_addr_map descriptions.
 
 ## Check that obj2yaml uses the "Entries" tag to describe an .llvm_bb_addr_map section.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
 
 # VALID:      --- !ELF
 # VALID-NEXT: FileHeader:
 # VALID-NEXT:   Class:   ELFCLASS64
 # VALID-NEXT:   Data:    ELFDATA2LSB
 # VALID-NEXT:   Type:    ET_EXEC
 # VALID-NEXT: Sections:
 # VALID-NEXT:   - Name: .llvm_bb_addr_map
 # VALID-NEXT:     Type: SHT_LLVM_BB_ADDR_MAP
 # VALID-NEXT:     Entries:
-## The 'Address' field is omitted when it's zero.
-# 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:         BBEntries:
-# VALID-NEXT:           - AddressOffset:    0xA
-# VALID-NEXT:             Size:             0xB
-# VALID-NEXT:             Metadata:         0xC
+# VALID-NEXT:       - BBRanges:
+## The 'BaseAddress' field is omitted when it's zero.
+# 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:           - BaseAddress:   0xFFFFFFFFFFFFFFF7
+# VALID-NEXT:             BBEntries:
+# VALID-NEXT:               - AddressOffset:    0xFFFFFFFFFFFFFFF8
+# VALID-NEXT:                 Size:             0xFFFFFFFFFFFFFFF9
+# VALID-NEXT:                 Metadata:         0xFFFFFFFFFFFFFFFA
+# VALID-NEXT:         BBRanges:
+# VALID-NEXT:           - BaseAddress:   0xB
+# VALID-NEXT:             BBEntries:
+# VALID-NEXT:               - AddressOffset:    0xC
+# VALID-NEXT:                 Size:             0xD
+# VALID-NEXT:                 Metadata:         0xE
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .llvm_bb_addr_map
     Type:    SHT_LLVM_BB_ADDR_MAP
     ShSize:    [[SIZE=<none>]]
     Entries:
-      - Address:   0x0
+      - BBRanges:
+          - BaseAddress:   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
+          - BaseAddress:   0xFFFFFFFFFFFFFFF7
+            BBEntries:
+              - AddressOffset:    0xFFFFFFFFFFFFFFF8
+                Size:             0xFFFFFFFFFFFFFFF9
+                Metadata:         0xFFFFFFFFFFFFFFFA
+      - BBRanges:
+        - BaseAddress:   0xB
           BBEntries:
-          - AddressOffset:    0xA
-            Size:             0xB
-            Metadata:         0xC
+            - AddressOffset:    0xC
+              Size:             0xD
+              Metadata:         0xE
+        NumBBRanges: [[NUMBBRANGES=<none>]]
 
 ## Check obj2yaml can dump empty .llvm_bb_addr_map sections.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=EMPTY
 
 # EMPTY:      --- !ELF
 # EMPTY-NEXT: FileHeader:

 # 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.
-# MULTI-NEXT:       - BBEntries:
-# MULTI-NEXT:           - AddressOffset:    0x1
-# MULTI-NEXT:             Size:             0x2
-# MULTI-NEXT:             Metadata:         0x3
+# MULTI-NEXT:       - BBRanges:
+## The 'BaseAddress' field is omitted when it's 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: []
+# MULTI-NEXT:       - BBRanges:
+# MULTI-NEXT:           - BaseAddress: 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:
+      - BBRanges:
 ## Check that obj2yaml does not emit the Address field when it's zero.
-      - Address:   0x0
+          - BaseAddress:   0x0
             BBEntries:
               - AddressOffset:    0x1
                 Size:             0x2
                 Metadata:         0x3
   - Name:    '.llvm_bb_addr_map (1)'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Entries:
-      - Address:   0x20
+      - BBRanges:
+          - BaseAddress:   0x20
 
 ## Check that obj2yaml uses the "Content" tag to describe an .llvm_bb_addr_map section
 ## when it can't extract the entries, for example, when the section is truncated, or
 ## when an invalid 'NumBlocks' field is specified.
 
 # RUN: yaml2obj --docnum=1 -DSIZE=0x8 %s -o %t4
 # RUN: obj2yaml %t4 | FileCheck %s --check-prefixes=TRUNCATED,INVALID
 
-# RUN: yaml2obj --docnum=1 -DNUMBLOCKS=2 %s -o %t5
+# RUN: yaml2obj --docnum=1 -DNUMBLOCKS=3 %s -o %t5
 # RUN: obj2yaml %t5 | FileCheck %s --check-prefixes=BADNUMBLOCKS,INVALID
 
-# INVALID:           --- !ELF
-# INVALID-NEXT:      FileHeader:
-# INVALID-NEXT:        Class:   ELFCLASS64
-# INVALID-NEXT:        Data:    ELFDATA2LSB
-# INVALID-NEXT:        Type:    ET_EXEC
-# INVALID-NEXT:      Sections:
-# INVALID-NEXT:        - Name: .llvm_bb_addr_map
-# INVALID-NEXT:          Type: SHT_LLVM_BB_ADDR_MAP
-# BADNUMBLOCKS-NEXT:     Content: {{([[:xdigit:]]+)}}{{$}}
-# TRUNCATED-NEXT:        Content: '{{([[:xdigit:]]{16})}}'{{$}}
+# RUN: yaml2obj --docnum=1 -DNUMBBRANGES=2 %s -o %t6
+# RUN: obj2yaml %t6 | FileCheck %s --check-prefixes=BADNUMBBRANGES,INVALID
+
+# INVALID:             --- !ELF
+# INVALID-NEXT:        FileHeader:
+# INVALID-NEXT:          Class:   ELFCLASS64
+# INVALID-NEXT:          Data:    ELFDATA2LSB
+# INVALID-NEXT:          Type:    ET_EXEC
+# INVALID-NEXT:        Sections:
+# INVALID-NEXT:          - Name: .llvm_bb_addr_map
+# INVALID-NEXT:            Type: SHT_LLVM_BB_ADDR_MAP
+# TRUNCATED-NEXT:          Content: '{{([[:xdigit:]]{16})}}'{{$}}
+# BADNUMBLOCKS-NEXT:       Content: {{([[:xdigit:]]+)}}{{$}}
+# BADNUMBBRANGES-NEXT:     Content: {{([[:xdigit:]]+)}}{{$}}

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

 # 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: 02200000 00000000 00010102 03400000
+# CHECK-NEXT:     0010: 00000000 00010506 07
 # 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: 01000000 00000000 00010102 03
 # 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: 01200000 00000000 00020102 03
+# CHECK-NEXT:   )
+
+# Case 7: Override the NumBBRanges field.
+# CHECK:        Name: .llvm_bb_addr_map (1)
+# CHECK:        SectionData (
+# CHECK-NEXT:     0000: 02200000 00000000 00010102 03
 # CHECK-NEXT:   )
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
- 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
+      - BBRanges:
+        - BaseAddress:   0x0000000000000020
           BBEntries:
             - AddressOffset:    0x00000001
               Size:             0x00000002
               Metadata:         0x00000003
+        - BaseAddress:   0x0000000000000040
+          BBEntries:
+            - AddressOffset:    0x00000005
+              Size:             0x00000006
+              Metadata:         0x00000007
 
-## 5) When specifying the description with Entries, the 'Address' field will be
+## 5) When specifying the description with Entries, the 'BaseAddress' field will be
 ##    zero when omitted.
   - Name:    '.llvm_bb_addr_map (5)'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Entries:
+      - BBRanges:
         - BBEntries:
           - AddressOffset:    0x00000001
             Size:             0x00000002
             Metadata:         0x00000003
 
 ## 6) We can override the NumBlocks field with a value different from the
 ##    actual number of BB Entries.
   - Name:    '.llvm_bb_addr_map (6)'
     Type:    SHT_LLVM_BB_ADDR_MAP
     Entries:
-      - Address:   0x0000000000000020
+      - BBRanges:
+        - BaseAddress:   0x0000000000000020
           NumBlocks: 2
           BBEntries:
             - AddressOffset:    0x00000001
               Size:             0x00000002
               Metadata:         0x00000003
 
+## 7) We can override the NumBBRanges field with a value different from the
+##    actual number of BB Ranges.
+  - Name:    '.llvm_bb_addr_map (7)'
+    Type:    SHT_LLVM_BB_ADDR_MAP
+    Entries:
+      - NumBBRanges: 2
+        BBRanges:
+        - BaseAddress:   0x0000000000000020
+          BBEntries:
+            - AddressOffset:    0x00000001
+              Size:             0x00000002
+              Metadata:         0x00000003
+
+
+
 ## Check we can't use Entries at the same time as either Content or Size.
 # RUN: not yaml2obj --docnum=2 -DCONTENT="00" %s 2>&1 | FileCheck %s --check-prefix=INVALID
 # RUN: not yaml2obj --docnum=2 -DSIZE="0" %s 2>&1 | FileCheck %s --check-prefix=INVALID
 
 # INVALID: error: "Entries" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:

llvm/tools/llvm-readobj/ELFDumper.cpp

for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     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);
+      DictScope FD(W, "Function");
+      if (AM.BBRanges.empty())
+        continue;
+      uintX_t FunctionAddress = AM.BBRanges.front().BaseAddr;
+      W.printHex("At", FunctionAddress);
+      ListScope BBRL(W, "BB Ranges");
+      for (const typename Elf_BBAddrMap::BBRangeEntry &BBR : AM.BBRanges) {
+        DictScope BBRD(W);
+        W.printHex("Base Address", BBR.BaseAddr);
+        ListScope BBEL(W, "BB Entries");
+        for (const typename Elf_BBAddrMap::BBEntry &BBE : BBR.BBEntries) {
+          DictScope BBED(W);
           W.printHex("Offset", BBE.Offset);
           W.printHex("Size", BBE.Size);
           W.printBoolean("HasReturn", BBE.HasReturn);
           W.printBoolean("HasTailCall", BBE.HasTailCall);
           W.printBoolean("IsEHPad", BBE.IsEHPad);
           W.printBoolean("CanFallThrough", BBE.CanFallThrough);
         }
       }
     }
   }
+}
 
 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);

llvm/tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpBBAddrMapSection(const Elf_Shdr *Shdr) {
   if (Content.empty())
     return S.release();
 
   DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);
 
   std::vector<ELFYAML::BBAddrMapEntry> Entries;
   DataExtractor::Cursor Cur(0);
   while (Cur && Cur.tell() < Content.size()) {
-    uint64_t Address = Data.getAddress(Cur);
+    uint64_t NumBBRanges = Data.getULEB128(Cur);
+    std::vector<ELFYAML::BBAddrMapEntry::BBRangeEntry> BBRanges;
+    for (uint64_t BBRangeN = 0; Cur && BBRangeN != NumBBRanges; ++BBRangeN) {
+      uint64_t BaseAddress = 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) {
+      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});
+      BBRanges.push_back({BaseAddress, /*NumBlocks=*/{}, BBEntries});
+    }
+    Entries.push_back({/*NumBBRanges=*/{}, BBRanges});
   }
 
   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

 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name: .llvm_bb_addr_map
     Type: SHT_LLVM_BB_ADDR_MAP
     Entries:
-      - Address: 0x11111
+      - BBRanges:
+          - BaseAddress: 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
+    ShSize: 0x9
 )";
-  DoCheck(TruncatedYamlString, "unable to decode LEB128 at offset 0x00000008: "
+  DoCheck(TruncatedYamlString, "unable to decode LEB128 at offset 0x00000009: "
                                "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: 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 0xd exceeds UINT32_MAX (0x100000000)");
   DoCheck(OverInt32LimitYamlStrings[1],
-          "ULEB128 value at offset 0x11 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x12 exceeds UINT32_MAX (0x100000000)");
   DoCheck(OverInt32LimitYamlStrings[2],
-          "ULEB128 value at offset 0x16 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x17 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: 0x16
 )";
   // Truncate at the end of the 5-byte field.
   OverInt32LimitAndTruncated[1] += R"(
-    ShSize: 0x16
+    ShSize: 0x17
 )";
   // Truncate after the end of the 5-byte field.
   OverInt32LimitAndTruncated[2] += R"(
-    ShSize: 0x17
+    ShSize: 0x18
 )";
 
   DoCheck(OverInt32LimitAndTruncated[0],
-          "unable to decode LEB128 at offset 0x00000011: malformed uleb128, "
+          "unable to decode LEB128 at offset 0x00000012: malformed uleb128, "
           "extends past end");
   DoCheck(OverInt32LimitAndTruncated[1],
-          "ULEB128 value at offset 0x11 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x12 exceeds UINT32_MAX (0x100000000)");
   DoCheck(OverInt32LimitAndTruncated[2],
-          "ULEB128 value at offset 0x11 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x12 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);
   OverLimitNumBlocks += R"(
             NumBlocks: 0x100000000
 )";
 
   DoCheck(OverLimitNumBlocks,
-          "ULEB128 value at offset 0x8 exceeds UINT32_MAX (0x100000000)");
+          "ULEB128 value at offset 0x9 exceeds UINT32_MAX (0x100000000)");
 }