[Support] Untie the llvm::Signpost interface from llvm::Timer

[JDevlieghere]

Summary

Make llvm::Signpost more generic by untying from llvm::Timer. This allows signposts to be used in a different context.

My motivation for doing this is being able to use signposts in LLDB.

[dsanders]

LGTM, Thanks

llvm/include/llvm/Support/Signposts.h

 /// can be emitted by the application and these will be rendered to the Points
 /// of Interest track on the instruments timeline.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SIGNPOSTS_H
 #define LLVM_SUPPORT_SIGNPOSTS_H
 
+#include "llvm/ADT/StringRef.h"
+
 namespace llvm {
 class SignpostEmitterImpl;
-class Timer;
 
 /// Manages the emission of signposts into the recording method supported by
 /// the OS.
 class SignpostEmitter {
   SignpostEmitterImpl *Impl;
 
 public:
   SignpostEmitter();
   ~SignpostEmitter();
 
   bool isEnabled() const;
 
-  /// Begin a signposted interval for the given timer.
-  void startTimerInterval(Timer *T);
-  /// End a signposted interval for the given timer.
-  void endTimerInterval(Timer *T);
+  /// Begin a signposted interval for a given object.
+  void startInterval(const void *O, StringRef Name);
+  /// End a signposted interval for a given object.
+  void endInterval(const void *O, StringRef Name);
 };
 
 } // end namespace llvm
 
 #endif // ifndef LLVM_SUPPORT_SIGNPOSTS_H

llvm/lib/Support/Signposts.cpp

 //===-- Signposts.cpp - Interval debug annotations ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
+// class StringRef
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Signposts.h"
 #include "llvm/Support/Timer.h"
 
 #include "llvm/Config/config.h"
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS

 void LogDeleter(os_log_t *X) {
   os_release(*X);
   delete X;
 }
 } // end anonymous namespace
 
 namespace llvm {
 class SignpostEmitterImpl {
-  using LogPtrTy =
-      std::unique_ptr<os_log_t, std::function<void(os_log_t *)>>;
+  using LogPtrTy = std::unique_ptr<os_log_t, std::function<void(os_log_t *)>>;
   using LogTy = LogPtrTy::element_type;
 
   LogPtrTy SignpostLog;
-  DenseMap<const Timer *, os_signpost_id_t> Signposts;
+  DenseMap<const void *, os_signpost_id_t> Signposts;
 
   LogTy &getLogger() const { return *SignpostLog; }
-  os_signpost_id_t getSignpostForTimer(const Timer *T) {
-    const auto &I = Signposts.find(T);
+  os_signpost_id_t getSignpostForObject(const void *O) {
+    const auto &I = Signposts.find(O);
     if (I != Signposts.end())
       return I->second;
 
     const auto &Inserted = Signposts.insert(
-        std::make_pair(T, os_signpost_id_make_with_pointer(getLogger(), T)));
+        std::make_pair(O, os_signpost_id_make_with_pointer(getLogger(), O)));
     return Inserted.first->second;
   }
 
 public:
   SignpostEmitterImpl() : SignpostLog(LogCreator(), LogDeleter), Signposts() {}
 
   bool isEnabled() const { return os_signpost_enabled(*SignpostLog); }
 
-  void startTimerInterval(Timer *T) {
+  void startInterval(const void *O, llvm::StringRef Name) {
     if (isEnabled()) {
-      // Both strings used here are required to be constant literal strings
-      os_signpost_interval_begin(getLogger(), getSignpostForTimer(T),
-                                 "Pass Timers", "Begin %s",
-                                 T->getName().c_str());
+      // Both strings used here are required to be constant literal strings.
+      os_signpost_interval_begin(getLogger(), getSignpostForObject(O),
+                                 "LLVM Timers", "Begin %s", Name.data());
     }
   }
 
-  void endTimerInterval(Timer *T) {
+  void endInterval(const void *O, llvm::StringRef Name) {
     if (isEnabled()) {
-      // Both strings used here are required to be constant literal strings
-      os_signpost_interval_end(getLogger(), getSignpostForTimer(T),
-                               "Pass Timers", "End %s", T->getName().c_str());
+      // Both strings used here are required to be constant literal strings.
+      os_signpost_interval_end(getLogger(), getSignpostForObject(O),
+                               "LLVM Timers", "End %s", Name.data());
     }
   }
 };
 } // end namespace llvm
 #endif // if LLVM_SUPPORT_XCODE_SIGNPOSTS
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
 #define HAVE_ANY_SIGNPOST_IMPL 1
 #else
 #define HAVE_ANY_SIGNPOST_IMPL 0
 #endif
 
 SignpostEmitter::SignpostEmitter() {
 #if HAVE_ANY_SIGNPOST_IMPL
   Impl = new SignpostEmitterImpl();
-#else // if HAVE_ANY_SIGNPOST_IMPL
+#else  // if HAVE_ANY_SIGNPOST_IMPL
   Impl = nullptr;
 #endif // if !HAVE_ANY_SIGNPOST_IMPL
 }
 
 SignpostEmitter::~SignpostEmitter() {
 #if HAVE_ANY_SIGNPOST_IMPL
   delete Impl;
 #endif // if HAVE_ANY_SIGNPOST_IMPL
 }
 
 bool SignpostEmitter::isEnabled() const {
 #if HAVE_ANY_SIGNPOST_IMPL
   return Impl->isEnabled();
 #else
   return false;
 #endif // if !HAVE_ANY_SIGNPOST_IMPL
 }
 
-void SignpostEmitter::startTimerInterval(Timer *T) {
+void SignpostEmitter::startInterval(const void *O, StringRef Name) {
 #if HAVE_ANY_SIGNPOST_IMPL
   if (Impl == nullptr)
     return;
-  return Impl->startTimerInterval(T);
+  return Impl->startInterval(O, Name);
 #endif // if !HAVE_ANY_SIGNPOST_IMPL
 }
 
-void SignpostEmitter::endTimerInterval(Timer *T) {
+void SignpostEmitter::endInterval(const void *O, StringRef Name) {
 #if HAVE_ANY_SIGNPOST_IMPL
   if (Impl == nullptr)
     return;
-  Impl->endTimerInterval(T);
+  Impl->endInterval(O, Name);
 #endif // if !HAVE_ANY_SIGNPOST_IMPL
 }

llvm/lib/Support/Timer.cpp

TimeRecord TimeRecord::getCurrentTime(bool Start) {
   Result.UserTime = Seconds(user).count();
   Result.SystemTime = Seconds(sys).count();
   return Result;
 }
 
 void Timer::startTimer() {
   assert(!Running && "Cannot start a running timer");
   Running = Triggered = true;
-  Signposts->startTimerInterval(this);
+  Signposts->startInterval(this, getName());
   StartTime = TimeRecord::getCurrentTime(true);
 }
 
 void Timer::stopTimer() {
   assert(Running && "Cannot stop a paused timer");
   Running = false;
   Time += TimeRecord::getCurrentTime(false);
   Time -= StartTime;
-  Signposts->endTimerInterval(this);
+  Signposts->endInterval(this, getName());
 }
 
 void Timer::clear() {
   Running = Triggered = false;
   Time = StartTime = TimeRecord();
 }
 
 static void printVal(double Val, double Total, raw_ostream &OS) {