[BOLT][NFCI] Move ProbeDecoder to PseudoProbeRewriter

[maksfb]

Summary

ProbeDecoder is used only by PseudoProbeRewriter. Move it out of the
BinaryContext.

Depends on D154022

[maksfb]

Rebase.

[maksfb]

Rebase.

[Amir]

Accepting but could be folded into the previous diff?

[maksfb]

Sounds good. This diff used to be larger, but then parts of it got merged into the previous one. At this point it's easier just to merge the two.

[maksfb]

Committed in D154022.

bolt/include/bolt/Core/BinaryContext.h

 #include "llvm/ADT/iterator.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
-#include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/RWMutex.h"
 #include "llvm/Support/raw_ostream.h"
public:
   /// Map linux kernel program locations/instructions to their pointers in
   /// special linux kernel sections
   std::unordered_map<uint64_t, std::vector<LKInstructionMarkerInfo>> LKMarkers;
 
   /// List of external addresses in the code that are not a function start
   /// and are referenced from BinaryFunction.
   std::list<std::pair<BinaryFunction *, uint64_t>> InterproceduralReferences;
 
-  /// PseudoProbe decoder
-  MCPseudoProbeDecoder ProbeDecoder;
-
   /// DWARF encoding. Available encoding types defined in BinaryFormat/Dwarf.h
   /// enum Constants, e.g. DW_EH_PE_omit.
   unsigned LSDAEncoding = dwarf::DW_EH_PE_omit;
 
   BinaryContext(std::unique_ptr<MCContext> Ctx,
                 std::unique_ptr<DWARFContext> DwCtx,
                 std::unique_ptr<Triple> TheTriple, const Target *TheTarget,
                 std::string TripleName, std::unique_ptr<MCCodeEmitter> MCE,

bolt/lib/Rewrite/PseudoProbeRewriter.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Core/BinaryFunction.h"
 #include "bolt/Rewrite/RewriteManager.h"
 #include "bolt/Rewrite/Rewriters.h"
 #include "bolt/Utils/CommandLineOpts.h"
 #include "llvm/IR/Function.h"
+#include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/LEB128.h"
 
 #undef DEBUG_TYPE
 #define DEBUG_TYPE "pseudo-probe-rewriter"
 
 using namespace llvm;
class PseudoProbeRewriter final : public RewriterBase {
 
   /// Encode MCDecodedPseudoProbe.
   void encodePseudoProbes();
 
   /// Parse .pseudo_probe_desc section and .pseudo_probe section
   /// Setup Pseudo probe decoder
   void parsePseudoProbe();
 
+  /// PseudoProbe decoder
+  MCPseudoProbeDecoder ProbeDecoder;
+
 public:
   PseudoProbeRewriter() : RewriterBase("pseudo-probe-rewriter") {}
 
   Error postEmitFinalizer() override;
 };
 
 Error PseudoProbeRewriter::postEmitFinalizer() {
   parsePseudoProbe();
if (!PseudoProbeDescSection) {
     errs() << "BOLT-WARNING: fail in reading .pseudo_probe_desc binary\n";
     return;
   } else if (!PseudoProbeSection) {
     errs() << "BOLT-WARNING: fail in reading .pseudo_probe binary\n";
     return;
   }
 
   StringRef Contents = PseudoProbeDescSection->getContents();
-  if (!BC->ProbeDecoder.buildGUID2FuncDescMap(
+  if (!ProbeDecoder.buildGUID2FuncDescMap(
           reinterpret_cast<const uint8_t *>(Contents.data()),
           Contents.size())) {
     errs() << "BOLT-WARNING: fail in building GUID2FuncDescMap\n";
     return;
   }
 
   MCPseudoProbeDecoder::Uint64Set GuidFilter;
   MCPseudoProbeDecoder::Uint64Map FuncStartAddrs;
   for (const BinaryFunction *F : BC->getAllBinaryFunctions()) {
     for (const MCSymbol *Sym : F->getSymbols()) {
       FuncStartAddrs[Function::getGUID(NameResolver::restore(Sym->getName()))] =
           F->getAddress();
     }
   }
   Contents = PseudoProbeSection->getContents();
-  if (!BC->ProbeDecoder.buildAddress2ProbeMap(
+  if (!ProbeDecoder.buildAddress2ProbeMap(
           reinterpret_cast<const uint8_t *>(Contents.data()), Contents.size(),
           GuidFilter, FuncStartAddrs)) {
-    BC->ProbeDecoder.getAddress2ProbesMap().clear();
+    ProbeDecoder.getAddress2ProbesMap().clear();
     errs() << "BOLT-WARNING: fail in building Address2ProbeMap\n";
     return;
   }
 
   if (opts::PrintPseudoProbes == opts::PrintPseudoProbesOptions::PPP_All ||
       opts::PrintPseudoProbes ==
           opts::PrintPseudoProbesOptions::PPP_Probes_Section_Decode) {
     outs() << "Report of decoding input pseudo probe binaries \n";
-    BC->ProbeDecoder.printGUID2FuncDescMap(outs());
-    BC->ProbeDecoder.printProbesForAllAddresses(outs());
+    ProbeDecoder.printGUID2FuncDescMap(outs());
+    ProbeDecoder.printProbesForAllAddresses(outs());
   }
 }
 
 void PseudoProbeRewriter::updatePseudoProbes() {
   // check if there is pseudo probe section decoded
-  if (BC->ProbeDecoder.getAddress2ProbesMap().empty())
+  if (ProbeDecoder.getAddress2ProbesMap().empty())
     return;
   // input address converted to output
-  AddressProbesMap &Address2ProbesMap = BC->ProbeDecoder.getAddress2ProbesMap();
-  const GUIDProbeFunctionMap &GUID2Func =
-      BC->ProbeDecoder.getGUID2FuncDescMap();
+  AddressProbesMap &Address2ProbesMap = ProbeDecoder.getAddress2ProbesMap();
+  const GUIDProbeFunctionMap &GUID2Func = ProbeDecoder.getGUID2FuncDescMap();
 
   for (auto &AP : Address2ProbesMap) {
     BinaryFunction *F = BC->getBinaryFunctionContainingAddress(AP.first);
     // If F is removed, eliminate all probes inside it from inline tree
     // Setting probes' addresses as INT64_MAX means elimination
     if (!F) {
       for (MCDecodedPseudoProbe &Probe : AP.second)
         Probe.setAddress(INT64_MAX);
void PseudoProbeRewriter::encodePseudoProbes() {
 
   // DFS of inline tree to emit pseudo probes in all tree node
   // Inline site index of a probe is emitted first.
   // Then tree node Guid, size of pseudo probes and children nodes, and detail
   // of contained probes are emitted Deleted probes are skipped Root node is not
   // encoded to binaries. It's a "wrapper" of inline trees of each function.
   std::list<std::pair<uint64_t, MCDecodedPseudoProbeInlineTree *>> NextNodes;
   const MCDecodedPseudoProbeInlineTree &Root =
-      BC->ProbeDecoder.getDummyInlineRoot();
+      ProbeDecoder.getDummyInlineRoot();
   for (auto Child = Root.getChildren().begin();
        Child != Root.getChildren().end(); ++Child)
     Inlinees[Child->first] = Child->second.get();
 
   for (auto Inlinee : Inlinees)
     // INT64_MAX is "placeholder" of unused callsite index field in the pair
     NextNodes.push_back({INT64_MAX, Inlinee.second});