Switch to section start/stop markers for the .llvm_bb_addr_map section.

Prior to this change, each *function* would get a start/stop symbol pair
and the runtime would need to know the names of all the functions in
order to load each map from the `.llvm_bb_addr_map` section.

The problem with that approach is that to know the names of all of the
functions, you need to also have the LLVM IR in order to iterate over
the functions in the module. To do that, you need to have the LLVM IR
parser, which means linking LLVM.

In upcoming work (for the fast ykpt trace decoder), the block map parser
will need to be moved out of `yk` and into `hwtracer`, so that hwtracer
can pick up the decoding hints we are going to add to the block map.

It seems unreasonable and cumbersome for `hwtracer` to have to link
LLVM just to load the blockmap.

This change uses *section* start and stop symbols (instead of
per-function start/stop symbols), so that `hwtracer` will be able to
load the whole blockmap section without any knowledge of LLVM IR.

It is probably also a bit quicker at runtime, since we no longer need to
iterate over the functions in the IR and load their maps individually.

(The approach assumes that LTO is being used, which is already a
requirement of Yk).

Author: vext01

llvm/include/llvm/CodeGen/AsmPrinter.h

@@ -226,6 +226,13 @@ class AsmPrinter : public MachineFunctionPass {
   /// split stack prologue.
   bool HasNoSplitStack = false;
 
+  /// `true` when the `.llvm_bb_addr_map` section is going to be loaded at
+  /// runtime and we've emitted at least one entry.
+  bool YkEmittedFirstBBAddrMap = false;
+
+  /// The last `.llvm_bb_addr_map` section fragment that we handled (if any).
+  MCSection *YkLastBBAddrMapSection = nullptr;
+
 protected:
   explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

@@ -1326,16 +1326,24 @@ static unsigned getBBAddrMapMetadata(const MachineBasicBlock &MBB) {
          (const_cast<MachineBasicBlock &>(MBB).canFallThrough() << 3);
 }
 
-void emitYkBBAddrMapSymbol(const MachineFunction &MF, MCStreamer &OutStreamer,
+/// Emit a start (or stop) marker symbol into the `.llvm_bb_addr_map` section
+/// so that we can find the extent of the section at runtime.
+///
+/// The `MCStreamer` should be primed to output to the `.llvm_bb_addr_map`
+/// section prior to calling this function.
+///
+/// This assumes that LTO is being used (as is required for the Yk JIT), and
+/// thus that there is only a single `Module` in play, and in turn that no
+/// symbol clashes can occur.
+void emitYkBBAddrMapSymbol(MCContext &MCtxt, MCStreamer &OutStreamer,
                            bool Start) {
-  std::string SymName("ykllvm.bbaddrmap.");
-  SymName.append(MF.getName().str());
+  std::string SymName("ykllvm.bbaddrmaps");
   if (Start)
     SymName.append(".start");
   else
-    SymName.append(".end");
+    SymName.append(".stop");
 
-  MCSymbol *Sym = MF.getContext().getOrCreateSymbol(SymName);
+  MCSymbol *Sym = MCtxt.getOrCreateSymbol(SymName);
   OutStreamer.emitSymbolAttribute(Sym, llvm::MCSA_Global);
   OutStreamer.emitLabel(Sym);
 }
@@ -1350,9 +1358,16 @@ void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
   OutStreamer->pushSection();
   OutStreamer->switchSection(BBAddrMapSection);
 
-  // Add the `ykllvm.bbaddrmap.<func>.start` symbol.
-  if (YkAllocLLVMBBAddrMapSection)
-    emitYkBBAddrMapSymbol(MF, *OutStreamer, true);
+  if (YkAllocLLVMBBAddrMapSection) {
+    if (!YkEmittedFirstBBAddrMap) {
+      // Add the `ykllvm.bbaddrmaps.start` symbol.
+      emitYkBBAddrMapSymbol(MF.getContext(), *OutStreamer, true);
+      YkEmittedFirstBBAddrMap = true;
+    }
+    // We cache the last seen bbaddrmap section fragment so that we can insert
+    // the stop symbol when the asmprinter is finalising.
+    YkLastBBAddrMapSection = BBAddrMapSection;
+  }
 
   OutStreamer->AddComment("version");
   OutStreamer->emitInt8(OutStreamer->getContext().getBBAddrMapVersion());
@@ -1443,10 +1458,6 @@ void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
     }
   }
 
-  // Add the `ykllvm.bbaddrmap.<func>.end` symbol.
-  if (YkAllocLLVMBBAddrMapSection)
-    emitYkBBAddrMapSymbol(MF, *OutStreamer, false);
-
   OutStreamer->popSection();
 }
 
@@ -2030,6 +2041,14 @@ void AsmPrinter::emitRemarksSection(remarks::RemarkStreamer &RS) {
 }
 
 bool AsmPrinter::doFinalization(Module &M) {
+  if (YkAllocLLVMBBAddrMapSection && YkEmittedFirstBBAddrMap) {
+    // Add the `ykllvm.bbaddrmaps.stop` symbol.
+    OutStreamer->pushSection();
+    OutStreamer->switchSection(YkLastBBAddrMapSection);
+    emitYkBBAddrMapSymbol(OutContext, *OutStreamer, false);
+    OutStreamer->popSection();
+  }
+
   // The `embed-bitcode` flag serialises the IR after only architecture
   // agnostic optimisations have been run, but then proceeds to apply other
   // optimisations and transformations afterwards. Sometimes this final version