[BOLT][NFCI] Use MetadataRewriter interface to update SDT markers

[maksfb]

Summary

Migrate SDT markers processing to the new MetadataRewriter interface.

Depends on D154020

[maksfb]

Rebase.

[maksfb]

Rebase.

bolt/include/bolt/Core/BinaryBasicBlock.h

private:
   /// symbol. Enables writing BOLT address translation tables used for mapping
   /// control transfer in the output binary back to the original binary.
   using LocSymsTy = std::vector<std::pair<uint32_t, const MCSymbol *>>;
   std::unique_ptr<LocSymsTy> LocSyms;
 
   /// After output/codegen, map output offsets of instructions in this basic
   /// block to instruction offsets in the original function. Note that the
   /// output basic block could be different from the input basic block.
-  /// We only map instruction of interest, such as calls, and sdt markers.
+  /// We only map instruction of interest, such as calls and markers.
   ///
   /// We store the offset array in a basic block to facilitate BAT tables
   /// generation. Otherwise, the mapping could be done at function level.
   using OffsetTranslationTableTy = std::vector<std::pair<uint32_t, uint32_t>>;
   std::unique_ptr<OffsetTranslationTableTy> OffsetTranslationTable;
 
   /// Alignment requirements for the block.
   uint32_t Alignment{1};

bolt/include/bolt/Core/BinaryContext.h

public:
   uint64_t PageAlign{HugePageSize};
 
   /// True if the binary requires immediate relocation processing.
   bool RequiresZNow{false};
 
   /// List of functions that always trap.
   std::vector<const BinaryFunction *> TrappedFunctions;
 
-  /// Map SDT locations to SDT markers info
-  std::unordered_map<uint64_t, SDTMarkerInfo> SDTMarkers;
-
   /// 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;
 

bolt/include/bolt/Core/BinaryFunction.h

public:
 
   void setHasCanonicalCFG(bool V) { HasCanonicalCFG = V; }
 
   void setFolded(BinaryFunction *BF) { FoldedIntoFunction = BF; }
 
   /// Indicate that another function body was merged with this function.
   void setHasFunctionsFoldedInto() { HasFunctionsFoldedInto = true; }
 
+  void setHasSDTMarker(bool V) { HasSDTMarker = V; }
+
   BinaryFunction &setPersonalityFunction(uint64_t Addr) {
     assert(!PersonalityFunction && "can't set personality function twice");
     PersonalityFunction = BC.getOrCreateGlobalSymbol(Addr, "FUNCat");
     return *this;
   }
 
   BinaryFunction &setPersonalityEncoding(uint8_t Encoding) {
     PersonalityEncoding = Encoding;

bolt/include/bolt/Core/BinarySection.h

return copyByteArray(reinterpret_cast<const uint8_t *>(Buffer.data()),
                        Buffer.size());
 }
 
 inline raw_ostream &operator<<(raw_ostream &OS, const BinarySection &Section) {
   Section.print(OS);
   return OS;
 }
 
-struct SDTMarkerInfo {
-  uint64_t PC;
-  uint64_t Base;
-  uint64_t Semaphore;
-  StringRef Provider;
-  StringRef Name;
-  StringRef Args;
-
-  /// The offset of PC within the note section
-  unsigned PCOffset;
-};
-
 /// Linux Kernel special sections point to a specific instruction in many cases.
 /// Unlike SDTMarkerInfo, these markers can come from different sections.
 struct LKInstructionMarkerInfo {
   uint64_t SectionOffset;
   int32_t PCRelativeOffset;
   bool IsPCRelative;
   StringRef SectionName;
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/include/bolt/Rewrite/RewriteInstance.h

private:
   void linkRuntime();
 
   /// Process metadata in special sections before CFG is built for functions.
   void processMetadataPreCFG();
 
   /// Update debug and other auxiliary information in the file.
   void updateMetadata();
 
-  /// Update SDTMarkers' locations for the output binary.
-  void updateSDTMarkers();
-
   /// Update LKMarkers' locations for the output binary.
   void updateLKMarkers();
 
   /// Update address of MCDecodedPseudoProbe.
   void updatePseudoProbes();
 
   /// Encode MCDecodedPseudoProbe.
   void encodePseudoProbes();
#define ELF_FUNCTION(TYPE, FUNC)                                               \
   /// Return 0 if the address has no mapping in the file, including being
   /// part of .bss section.
   uint64_t getFileOffsetForAddress(uint64_t Address) const;
 
   /// Return true if we will overwrite contents of the section instead
   /// of appending contents to it.
   bool willOverwriteSection(StringRef SectionName);
 
-  /// Parse .note.stapsdt section
-  void parseSDTNotes();
-
   /// Parse .pseudo_probe_desc section and .pseudo_probe section
   /// Setup Pseudo probe decoder
   void parsePseudoProbe();
 
-  /// Print all SDT markers
-  void printSDTMarkers();
-
 public:
   /// Standard ELF sections we overwrite.
   static constexpr const char *SectionsToOverwrite[] = {
       ".shstrtab",
       ".symtab",
       ".strtab",
   };
 
private:
 
   /// Exception handling and stack unwinding information in this binary.
   ErrorOr<BinarySection &> LSDASection{std::errc::bad_address};
   ErrorOr<BinarySection &> EHFrameSection{std::errc::bad_address};
 
   /// .note.gnu.build-id section.
   ErrorOr<BinarySection &> BuildIDSection{std::errc::bad_address};
 
-  /// .note.stapsdt section.
-  /// Contains information about statically defined tracing points
-  ErrorOr<BinarySection &> SDTSection{std::errc::bad_address};
-
   /// .pseudo_probe_desc section.
   /// Contains information about pseudo probe description, like its related
   /// function
   ErrorOr<BinarySection &> PseudoProbeDescSection{std::errc::bad_address};
 
   /// .pseudo_probe section.
   /// Contains information about pseudo probe details, like its address
   ErrorOr<BinarySection &> PseudoProbeSection{std::errc::bad_address};

bolt/include/bolt/Rewrite/Rewriters.h

 
 #include <memory>
 
 namespace llvm {
 namespace bolt {
 
 class RewriterBase;
 
-/// The list of rewriter build functions (e.g. createNewRewriter()).
+// The list of rewriter build functions.
+
+std::unique_ptr<RewriterBase> createSDTRewriter();
 
 } // namespace bolt
 } // namespace llvm
 
 #endif // BOLT_REWRITE_REWRITERS_H

bolt/lib/Core/BinaryFunction.cpp

if (LI != Labels.end()) {
       InsertBB = addBasicBlockAt(LI->first, LI->second);
       if (opts::PreserveBlocksAlignment && IsLastInstrNop)
         InsertBB->setDerivedAlignment();
 
       if (PrevBB)
         updateOffset(LastInstrOffset);
     }
 
-    const uint64_t InstrInputAddr = I->first + Address;
-    bool IsSDTMarker =
-        MIB->isNoop(Instr) && BC.SDTMarkers.count(InstrInputAddr);
-    bool IsLKMarker = BC.LKMarkers.count(InstrInputAddr);
+    bool IsLKMarker = BC.LKMarkers.count(I->first + Address);
     // Mark all nops with Offset for profile tracking purposes.
     if (MIB->isNoop(Instr) || IsLKMarker) {
-      if (!MIB->getOffset(Instr))
+      // If "Offset" annotation is not present, set it and mark the nop for
+      // deletion.
+      if (!MIB->getOffset(Instr)) {
         MIB->setOffset(Instr, static_cast<uint32_t>(Offset), AllocatorId);
-      if (IsSDTMarker || IsLKMarker)
-        HasSDTMarker = true;
-      else
         // Annotate ordinary nops, so we can safely delete them if required.
-        MIB->addAnnotation(Instr, "NOP", static_cast<uint32_t>(1), AllocatorId);
+        if (!IsLKMarker)
+          MIB->addAnnotation(Instr, "NOP", static_cast<uint32_t>(1),
+                             AllocatorId);
+      }
+      if (IsLKMarker)
+        HasSDTMarker = true;
     }
 
     if (!InsertBB) {
       // It must be a fallthrough or unreachable code. Create a new block unless
       // we see an unconditional branch following a conditional one. The latter
       // should not be a conditional tail call.
       assert(PrevBB && "no previous basic block for a fall through");
       MCInst *PrevInstr = PrevBB->getLastNonPseudoInstr();

bolt/lib/Rewrite/CMakeLists.txt

add_llvm_library(LLVMBOLTRewrite
   BinaryPassManager.cpp
   BoltDiff.cpp
   DWARFRewriter.cpp
   ExecutableFileMemoryManager.cpp
   JITLinkLinker.cpp
   MachORewriteInstance.cpp
   RewriteInstance.cpp
   RewriteManager.cpp
+  SDTRewriter.cpp
 
   DISABLE_LLVM_LINK_LLVM_DYLIB
 
   LINK_LIBS
   ${LLVM_PTHREAD_LIB}
   )
 
 target_link_libraries(LLVMBOLTRewrite

bolt/lib/Rewrite/RewriteInstance.cpp

PrintGlobals("print-globals",
                  cl::cat(BoltCategory));
 
 extern cl::opt<bool> PrintSections;
 
 static cl::opt<bool> PrintLoopInfo("print-loops",
                                    cl::desc("print loop related information"),
                                    cl::Hidden, cl::cat(BoltCategory));
 
-static cl::opt<bool> PrintSDTMarkers("print-sdt",
-                                     cl::desc("print all SDT markers"),
-                                     cl::Hidden, cl::cat(BoltCategory));
-
 enum PrintPseudoProbesOptions {
   PPP_None = 0,
   PPP_Probes_Section_Decode = 0x1,
   PPP_Probes_Address_Conversion = 0x2,
   PPP_Encoded_Probes = 0x3,
   PPP_All = 0xf
 };
 
if (opts::Instrument)
     BC->setRuntimeLibrary(std::make_unique<InstrumentationRuntimeLibrary>());
   else if (opts::Hugify)
     BC->setRuntimeLibrary(std::make_unique<HugifyRuntimeLibrary>());
 }
 
 RewriteInstance::~RewriteInstance() {}
 
 void RewriteInstance::initializeRewriters() {
+  RewriteManager::getManager()->registerRewriter(createSDTRewriter());
+
   RewriteManager::getManager()->initRewriters(*BC);
 }
 
 Error RewriteInstance::setProfile(StringRef Filename) {
   if (!sys::fs::exists(Filename))
     return errorCodeToError(make_error_code(errc::no_such_file_or_directory));
 
   if (ProfileReader) {
Error RewriteInstance::discoverStorage() {
   if (!getFileOffsetForAddress(BC->OldTextSectionAddress))
     return createStringError(errc::executable_format_error,
                              "BOLT-ERROR: input binary is not a valid ELF "
                              "executable as its text section is not "
                              "mapped to a valid segment");
   return Error::success();
 }
 
-void RewriteInstance::parseSDTNotes() {
-  if (!SDTSection)
-    return;
-
-  StringRef Buf = SDTSection->getContents();
-  DataExtractor DE = DataExtractor(Buf, BC->AsmInfo->isLittleEndian(),
-                                   BC->AsmInfo->getCodePointerSize());
-  uint64_t Offset = 0;
-
-  while (DE.isValidOffset(Offset)) {
-    uint32_t NameSz = DE.getU32(&Offset);
-    DE.getU32(&Offset); // skip over DescSz
-    uint32_t Type = DE.getU32(&Offset);
-    Offset = alignTo(Offset, 4);
-
-    if (Type != 3)
-      errs() << "BOLT-WARNING: SDT note type \"" << Type
-             << "\" is not expected\n";
-
-    if (NameSz == 0)
-      errs() << "BOLT-WARNING: SDT note has empty name\n";
-
-    StringRef Name = DE.getCStr(&Offset);
-
-    if (!Name.equals("stapsdt"))
-      errs() << "BOLT-WARNING: SDT note name \"" << Name
-             << "\" is not expected\n";
-
-    // Parse description
-    SDTMarkerInfo Marker;
-    Marker.PCOffset = Offset;
-    Marker.PC = DE.getU64(&Offset);
-    Marker.Base = DE.getU64(&Offset);
-    Marker.Semaphore = DE.getU64(&Offset);
-    Marker.Provider = DE.getCStr(&Offset);
-    Marker.Name = DE.getCStr(&Offset);
-    Marker.Args = DE.getCStr(&Offset);
-    Offset = alignTo(Offset, 4);
-    BC->SDTMarkers[Marker.PC] = Marker;
-  }
-
-  if (opts::PrintSDTMarkers)
-    printSDTMarkers();
-}
-
 void RewriteInstance::parsePseudoProbe() {
   if (!PseudoProbeDescSection && !PseudoProbeSection) {
     // pesudo probe is not added to binary. It is normal and no warning needed.
     return;
   }
 
   // If only one section is found, it might mean the ELF is corrupted.
   if (!PseudoProbeDescSection) {
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());
   }
 }
 
-void RewriteInstance::printSDTMarkers() {
-  outs() << "BOLT-INFO: Number of SDT markers is " << BC->SDTMarkers.size()
-         << "\n";
-  for (auto It : BC->SDTMarkers) {
-    SDTMarkerInfo &Marker = It.second;
-    outs() << "BOLT-INFO: PC: " << utohexstr(Marker.PC)
-           << ", Base: " << utohexstr(Marker.Base)
-           << ", Semaphore: " << utohexstr(Marker.Semaphore)
-           << ", Provider: " << Marker.Provider << ", Name: " << Marker.Name
-           << ", Args: " << Marker.Args << "\n";
-  }
-}
-
 void RewriteInstance::parseBuildID() {
   if (!BuildIDSection)
     return;
 
   StringRef Buf = BuildIDSection->getContents();
 
   // Reading notes section (see Portable Formats Specification, Version 1.1,
   // pg 2-5, section "Note Section").
errs() << "BOLT-WARNING: debug info will be stripped from the binary. "
               "Use -update-debug-sections to keep it.\n";
   }
 
   HasTextRelocations = (bool)BC->getUniqueSectionByName(".rela.text");
   HasSymbolTable = (bool)BC->getUniqueSectionByName(".symtab");
   LSDASection = BC->getUniqueSectionByName(".gcc_except_table");
   EHFrameSection = BC->getUniqueSectionByName(".eh_frame");
   BuildIDSection = BC->getUniqueSectionByName(".note.gnu.build-id");
-  SDTSection = BC->getUniqueSectionByName(".note.stapsdt");
   PseudoProbeDescSection = BC->getUniqueSectionByName(".pseudo_probe_desc");
   PseudoProbeSection = BC->getUniqueSectionByName(".pseudo_probe");
 
   if (ErrorOr<BinarySection &> BATSec =
           BC->getUniqueSectionByName(BoltAddressTranslation::SECTION_NAME)) {
     // Do not read BAT when plotting a heatmap
     if (!opts::HeatmapMode) {
       if (std::error_code EC = BAT->parse(BATSec->getContents())) {
if (!EHFrameOrError)
     report_error("expected valid eh_frame section", EHFrameOrError.takeError());
   CFIRdWrt.reset(new CFIReaderWriter(*EHFrameOrError.get()));
 
   // Parse build-id
   parseBuildID();
   if (std::optional<std::string> FileBuildID = getPrintableBuildID())
     BC->setFileBuildID(*FileBuildID);
 
-  parseSDTNotes();
-
   // Read .dynamic/PT_DYNAMIC.
   return readELFDynamic();
 }
 
 void RewriteInstance::adjustCommandLineOptions() {
   if (BC->isAArch64() && !BC->HasRelocations)
     errs() << "BOLT-WARNING: non-relocation mode for AArch64 is not fully "
               "supported\n";
outs() << "BOLT-INFO: intermediary output object file saved for debugging "
            << OutObjectPath << "\n";
   }
 }
 
 void RewriteInstance::updateMetadata() {
   RewriteManager::getManager()->runFinalizersAfterEmit();
 
   // TODO: use RewriteManager for updates.
-  updateSDTMarkers();
   updateLKMarkers();
   parsePseudoProbe();
   updatePseudoProbes();
 
   if (opts::UpdateDebugSections) {
     NamedRegionTimer T("updateDebugInfo", "update debug info", TimerGroupName,
                        TimerGroupDesc, opts::TimeRewrite);
     DebugInfoRewriter->updateDebugInfo();
if (opts::PrintPseudoProbes == opts::PrintPseudoProbesOptions::PPP_All ||
     }
     DummyDecoder.buildAddress2ProbeMap(
         reinterpret_cast<const uint8_t *>(ProbeContents.data()),
         ProbeContents.size(), GuidFilter, FuncStartAddrs);
     DummyDecoder.printProbesForAllAddresses(outs());
   }
 }
 
-void RewriteInstance::updateSDTMarkers() {
-  NamedRegionTimer T("updateSDTMarkers", "update SDT markers", TimerGroupName,
-                     TimerGroupDesc, opts::TimeRewrite);
-
-  if (!SDTSection)
-    return;
-  SDTSection->registerPatcher(std::make_unique<SimpleBinaryPatcher>());
-
-  SimpleBinaryPatcher *SDTNotePatcher =
-      static_cast<SimpleBinaryPatcher *>(SDTSection->getPatcher());
-  for (auto &SDTInfoKV : BC->SDTMarkers) {
-    const uint64_t OriginalAddress = SDTInfoKV.first;
-    SDTMarkerInfo &SDTInfo = SDTInfoKV.second;
-    const BinaryFunction *F =
-        BC->getBinaryFunctionContainingAddress(OriginalAddress);
-    if (!F)
-      continue;
-    const uint64_t NewAddress =
-        F->translateInputToOutputAddress(OriginalAddress);
-    SDTNotePatcher->addLE64Patch(SDTInfo.PCOffset, NewAddress);
-  }
-}
-
 void RewriteInstance::updateLKMarkers() {
   if (BC->LKMarkers.size() == 0)
     return;
 
   NamedRegionTimer T("updateLKMarkers", "update LK markers", TimerGroupName,
                      TimerGroupDesc, opts::TimeRewrite);
 
   std::unordered_map<std::string, uint64_t> PatchCounts;

bolt/lib/Rewrite/SDTRewriter.cpp

+//===- bolt/Rewrite/SDTRewriter.cpp ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implement the support for System Tap Statically-Defined Trace points stored
+// in .note.stapsdt section.
+//
+//===----------------------------------------------------------------------===//
+
+#include "bolt/Core/BinaryFunction.h"
+#include "bolt/Core/DebugData.h"
+#include "bolt/Rewrite/RewriteManager.h"
+#include "bolt/Rewrite/Rewriters.h"
+#include "bolt/Utils/CommandLineOpts.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Timer.h"
+
+using namespace llvm;
+using namespace bolt;
+
+namespace opts {
+static cl::opt<bool> PrintSDTMarkers("print-sdt",
+                                     cl::desc("print all SDT markers"),
+                                     cl::Hidden, cl::cat(BoltCategory));
+}
+
+namespace {
+class SDTRewriter final : public RewriterBase {
+  ErrorOr<BinarySection &> SDTSection{std::errc::bad_address};
+
+  struct SDTMarkerInfo {
+    uint64_t PC;
+    uint64_t Base;
+    uint64_t Semaphore;
+    StringRef Provider;
+    StringRef Name;
+    StringRef Args;
+
+    /// The offset of PC within the note section
+    unsigned PCOffset;
+  };
+
+  /// Map SDT locations to SDT markers info
+  using SDTMarkersListType = std::unordered_map<uint64_t, SDTMarkerInfo>;
+  SDTMarkersListType SDTMarkers;
+
+  /// Read section to populate SDTMarkers.
+  void readSection();
+
+  void printSDTMarkers() const;
+
+public:
+  SDTRewriter() : RewriterBase("sdt-rewriter") {}
+
+  Error preCFGInitializer() override;
+
+  Error postEmitFinalizer() override;
+};
+
+void SDTRewriter::readSection() {
+  SDTSection = BC->getUniqueSectionByName(".note.stapsdt");
+  if (!SDTSection)
+    return;
+
+  StringRef Buf = SDTSection->getContents();
+  DataExtractor DE = DataExtractor(Buf, BC->AsmInfo->isLittleEndian(),
+                                   BC->AsmInfo->getCodePointerSize());
+  uint64_t Offset = 0;
+
+  while (DE.isValidOffset(Offset)) {
+    uint32_t NameSz = DE.getU32(&Offset);
+    DE.getU32(&Offset); // skip over DescSz
+    uint32_t Type = DE.getU32(&Offset);
+    Offset = alignTo(Offset, 4);
+
+    if (Type != 3)
+      errs() << "BOLT-WARNING: SDT note type \"" << Type
+             << "\" is not expected\n";
+
+    if (NameSz == 0)
+      errs() << "BOLT-WARNING: SDT note has empty name\n";
+
+    StringRef Name = DE.getCStr(&Offset);
+
+    if (!Name.equals("stapsdt"))
+      errs() << "BOLT-WARNING: SDT note name \"" << Name
+             << "\" is not expected\n";
+
+    // Parse description
+    SDTMarkerInfo Marker;
+    Marker.PCOffset = Offset;
+    Marker.PC = DE.getU64(&Offset);
+    Marker.Base = DE.getU64(&Offset);
+    Marker.Semaphore = DE.getU64(&Offset);
+    Marker.Provider = DE.getCStr(&Offset);
+    Marker.Name = DE.getCStr(&Offset);
+    Marker.Args = DE.getCStr(&Offset);
+    Offset = alignTo(Offset, 4);
+    SDTMarkers[Marker.PC] = Marker;
+  }
+
+  if (opts::PrintSDTMarkers)
+    printSDTMarkers();
+}
+
+Error SDTRewriter::preCFGInitializer() {
+  // Populate SDTMarkers.
+  readSection();
+
+  // Mark nop instructions referenced by SDT and the containing function.
+  for (const uint64_t PC : llvm::make_first_range(SDTMarkers)) {
+    BinaryFunction *BF = BC->getBinaryFunctionContainingAddress(PC);
+
+    if (!BF || !BC->shouldEmit(*BF))
+      continue;
+
+    const uint64_t Offset = PC - BF->getAddress();
+    MCInst *Inst = BF->getInstructionAtOffset(Offset);
+    if (!Inst)
+      return createStringError(errc::executable_format_error,
+                               "no instruction matches SDT offset");
+
+    if (!BC->MIB->isNoop(*Inst))
+      return createStringError(std::make_error_code(std::errc::not_supported),
+                               "nop instruction expected at SDT offset");
+
+    BC->MIB->setOffset(*Inst, static_cast<uint32_t>(Offset));
+
+    BF->setHasSDTMarker(true);
+  }
+
+  return Error::success();
+}
+
+Error SDTRewriter::postEmitFinalizer() {
+  if (!SDTSection)
+    return Error::success();
+
+  SDTSection->registerPatcher(std::make_unique<SimpleBinaryPatcher>());
+
+  SimpleBinaryPatcher *SDTNotePatcher =
+      static_cast<SimpleBinaryPatcher *>(SDTSection->getPatcher());
+  for (auto &SDTInfoKV : SDTMarkers) {
+    const uint64_t OriginalAddress = SDTInfoKV.first;
+    const SDTMarkerInfo &SDTInfo = SDTInfoKV.second;
+    const BinaryFunction *F =
+        BC->getBinaryFunctionContainingAddress(OriginalAddress);
+    if (!F)
+      continue;
+    const uint64_t NewAddress =
+        F->translateInputToOutputAddress(OriginalAddress);
+    SDTNotePatcher->addLE64Patch(SDTInfo.PCOffset, NewAddress);
+  }
+
+  return Error::success();
+}
+
+void SDTRewriter::printSDTMarkers() const {
+  outs() << "BOLT-INFO: Number of SDT markers is " << SDTMarkers.size() << "\n";
+  for (const SDTMarkerInfo &Marker : llvm::make_second_range(SDTMarkers)) {
+    outs() << "BOLT-INFO: PC: " << utohexstr(Marker.PC)
+           << ", Base: " << utohexstr(Marker.Base)
+           << ", Semaphore: " << utohexstr(Marker.Semaphore)
+           << ", Provider: " << Marker.Provider << ", Name: " << Marker.Name
+           << ", Args: " << Marker.Args << "\n";
+  }
+}
+} // namespace
+
+std::unique_ptr<RewriterBase> llvm::bolt::createSDTRewriter() {
+  return std::make_unique<SDTRewriter>();
+}