[PassTiming] cleaning up legacy PassTimingInfo interface. NFCI.

[fedor.sergeev]

Summary

During D51276 discussion it was decided that legacy PassTimingInfo
interface can not be reused for new pass manager's implementation
of -time-passes.

This is a cleanup in preparation for D51276 to make legacy interface
as concise as possible, moving the PassTimingInfo from the header
into the anonymous legacy namespace in .cpp.

It is rather close to a revert of rL340872 in a sense that it hides
the interface and gets rid of templates. However as compared to
a complete revert it resides in a different translation unit and has
an additional pass-instance counting funcitonality (PassIDCountMap).

[philip.pfaffe]

is this in some sense a revert of rL340872? Which parts of that change remain?

[fedor.sergeev]

In D52356#1243219, @philip.pfaffe wrote:

is this in some sense a revert of rL340872? Which parts of that change remain?

It is not a complete revert, but definitely very close to it.
One of the changes that were not restored to the original form is removal of createTheTimeInfo, which had been replaced with init() and still remains in that form now.
Functionally, the biggest change from pre-L340872 was introduced a bit later - PassIDCountMap that counts instances and adds #instance-numbers to the report.
And it remains "unreverted" in this change.

[philip.pfaffe]

Is that remaining change still useful? Does it make sense to revert instead?

[fedor.sergeev]

In D52356#1243299, @philip.pfaffe wrote:

Is that remaining change still useful? Does it make sense to revert instead?

At the very least we need the move from LegacyPassManager.cpp into PassTimingInfo.cpp, to consolidate different implementations of time-passes in a single source file.
You can see this change (compared to pre-rL340872) as a move with cleanup.

[philip.pfaffe]

Okay, all in all this looks alright, and making a single cleanup change seems less verbose than reverting rL340872 first. Please make very clear in this commit message that this is a partial revert and why.

include/llvm/IR/LegacyPassManager.h

private:
   Module *M;
 };
 
 } // End legacy namespace
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_STDCXX_CONVERSION_FUNCTIONS(legacy::PassManagerBase, LLVMPassManagerRef)
 
-/// If -time-passes has been specified, report the timings immediately and then
-/// reset the timers to zero.
-void reportAndResetTimings();
 } // End llvm namespace
 
 #endif

include/llvm/IR/PassTimingInfo.h

 /// This header defines classes/functions to handle pass execution timing
 /// information with an interface suitable for both pass managers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_PASSTIMINGINFO_H
 #define LLVM_IR_PASSTIMINGINFO_H
 
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Timer.h"
-#include <string>
-
 namespace llvm {
 
 class Pass;
-class TimerGroup;
-
-/// Provides a generic interface for collecting pass timing information.
-/// Legacy pass managers should specialize with \p PassInfo*.
-/// New pass managers should specialize with \p StringRef.
-template <typename PassInfoT> class PassTimingInfo {
-public:
-  using PassInstanceID = void *;
-
-private:
-  StringMap<unsigned> PassIDCountMap; ///< Map that counts instances of passes
-  DenseMap<PassInstanceID, Timer *> TimingData; ///< timers for pass instances
-  TimerGroup TG;
-
-public:
-  /// Default constructor for yet-inactive timeinfo.
-  /// Use \p init() to activate it.
-  PassTimingInfo();
-
-  /// Print out timing information and release timers.
-  ~PassTimingInfo();
-
-  /// Initializes the static \p TheTimeInfo member to a non-null value when
-  /// -time-passes is enabled. Leaves it null otherwise.
-  ///
-  /// This method may be called multiple times.
-  static void init();
-
-  /// Prints out timing information and then resets the timers.
-  void print();
-
-  /// Returns the timer for the specified pass if it exists.
-  Timer *getPassTimer(PassInfoT, PassInstanceID);
-
-  static PassTimingInfo *TheTimeInfo;
+class Timer;
 
-private:
-  Timer *newPassTimer(StringRef PassID, StringRef PassDesc);
-};
+/// If -time-passes has been specified, report the timings immediately and then
+/// reset the timers to zero.
+void reportAndResetTimings();
 
+/// Request the timer for this legacy-pass-manager's pass instance.
 Timer *getPassTimer(Pass *);
-Timer *getPassTimer(StringRef);
 
 /// If the user specifies the -time-passes argument on an LLVM tool command line
 /// then the value of this boolean will be true, otherwise false.
 /// This is the storage for the -time-passes option.
 extern bool TimePassesIsEnabled;
 
 } // namespace llvm
 
 #endif

lib/IR/PassTimingInfo.cpp

 //===- PassTimingInfo.cpp - LLVM Pass Timing Implementation ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LLVM Pass Timing infrastructure for both
 // new and legacy pass managers.
 //
-// TimingInfo Class - This class is used to calculate information about the
+// PassTimingInfo Class - This class is used to calculate information about the
 // amount of time each pass takes to execute.  This only happens when
 // -time-passes is enabled on the command line.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/PassTimingInfo.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 
 using namespace llvm;
 
 namespace llvm {
 
-//===----------------------------------------------------------------------===//
-// TimingInfo implementation
-
 bool TimePassesIsEnabled = false;
+
 static cl::opt<bool, true> EnableTiming(
     "time-passes", cl::location(TimePassesIsEnabled), cl::Hidden,
     cl::desc("Time each pass, printing elapsed time for each on exit"));
 
 namespace {
+namespace legacy {
+
+//===----------------------------------------------------------------------===//
+// TimingInfo implementation
+
+/// Provides an interface for collecting pass timing information.
+///
+/// It was intended to be generic but now we decided to split
+/// interfaces completely. This is now exclusively for legacy-pass-manager use.
+class PassTimingInfo {
+public:
+  using PassInstanceID = void *;
+
+private:
+  StringMap<unsigned> PassIDCountMap; ///< Map that counts instances of passes
+  DenseMap<PassInstanceID, Timer *> TimingData; ///< timers for pass instances
+  TimerGroup TG;
+
+public:
+  /// Default constructor for yet-inactive timeinfo.
+  /// Use \p init() to activate it.
+  PassTimingInfo();
+
+  /// Print out timing information and release timers.
+  ~PassTimingInfo();
+
+  /// Initializes the static \p TheTimeInfo member to a non-null value when
+  /// -time-passes is enabled. Leaves it null otherwise.
+  ///
+  /// This method may be called multiple times.
+  static void init();
+
+  /// Prints out timing information and then resets the timers.
+  void print();
+
+  /// Returns the timer for the specified pass if it exists.
+  Timer *getPassTimer(Pass *, PassInstanceID);
+
+  static PassTimingInfo *TheTimeInfo;
+
+private:
+  Timer *newPassTimer(StringRef PassID, StringRef PassDesc);
+};
+
 static ManagedStatic<sys::SmartMutex<true>> TimingInfoMutex;
-}
 
-template <typename PassT>
-PassTimingInfo<PassT>::PassTimingInfo()
+PassTimingInfo::PassTimingInfo()
     : TG("pass", "... Pass execution timing report ...") {}
 
-template <typename PassT> PassTimingInfo<PassT>::~PassTimingInfo() {
+PassTimingInfo::~PassTimingInfo() {
   // Deleting the timers accumulates their info into the TG member.
   // Then TG member is (implicitly) deleted, actually printing the report.
   for (auto &I : TimingData)
     delete I.getSecond();
 }
 
-template <typename PassT> void PassTimingInfo<PassT>::init() {
+void PassTimingInfo::init() {
   if (!TimePassesIsEnabled || TheTimeInfo)
     return;
 
   // Constructed the first time this is called, iff -time-passes is enabled.
   // This guarantees that the object will be constructed after static globals,
   // thus it will be destroyed before them.
   static ManagedStatic<PassTimingInfo> TTI;
   TheTimeInfo = &*TTI;
 }
 
 /// Prints out timing information and then resets the timers.
-template <typename PassT> void PassTimingInfo<PassT>::print() {
-  TG.print(*CreateInfoOutputFile());
-}
+void PassTimingInfo::print() { TG.print(*CreateInfoOutputFile()); }
 
-template <typename PassInfoT>
-Timer *PassTimingInfo<PassInfoT>::newPassTimer(StringRef PassID,
-                                               StringRef PassDesc) {
+Timer *PassTimingInfo::newPassTimer(StringRef PassID, StringRef PassDesc) {
   unsigned &num = PassIDCountMap[PassID];
   num++;
   // Appending description with a pass-instance number for all but the first one
   std::string PassDescNumbered =
       num <= 1 ? PassDesc.str() : formatv("{0} #{1}", PassDesc, num).str();
   return new Timer(PassID, PassDescNumbered, TG);
 }
 
-/// Returns the timer for the specified pass instance \p Pass.
-/// Instances of the same pass type (uniquely identified by \p PassID) are
-/// numbered by the order of appearance.
-template <>
-Timer *PassTimingInfo<StringRef>::getPassTimer(StringRef PassID,
-                                               PassInstanceID Pass) {
-  init();
-  sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
-  Timer *&T = TimingData[Pass];
-  if (!T)
-    T = newPassTimer(PassID, PassID);
-  return T;
-}
-
-template <>
-Timer *PassTimingInfo<Pass *>::getPassTimer(Pass *P, PassInstanceID Pass) {
+Timer *PassTimingInfo::getPassTimer(Pass *P, PassInstanceID Pass) {
   if (P->getAsPMDataManager())
     return nullptr;
 
   init();
   sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
   Timer *&T = TimingData[Pass];
 
   if (!T) {
     StringRef PassName = P->getPassName();
     StringRef PassArgument;
     if (const PassInfo *PI = Pass::lookupPassInfo(P->getPassID()))
       PassArgument = PI->getPassArgument();
     T = newPassTimer(PassArgument.empty() ? PassName : PassArgument, PassName);
   }
   return T;
 }
 
-template <typename PassInfoT>
-PassTimingInfo<PassInfoT> *PassTimingInfo<PassInfoT>::TheTimeInfo;
-
-template class PassTimingInfo<Pass *>;
-template class PassTimingInfo<StringRef>;
+PassTimingInfo *PassTimingInfo::TheTimeInfo;
+} // namespace legacy
+} // namespace
 
 Timer *getPassTimer(Pass *P) {
-  PassTimingInfo<Pass *>::init();
-  if (PassTimingInfo<Pass *>::TheTimeInfo)
-    return PassTimingInfo<Pass *>::TheTimeInfo->getPassTimer(P, P);
-  return nullptr;
-}
-
-Timer *getPassTimer(StringRef PassName) {
-  PassTimingInfo<StringRef>::init();
-  if (PassTimingInfo<StringRef>::TheTimeInfo)
-    return PassTimingInfo<StringRef>::TheTimeInfo->getPassTimer(PassName,
-                                                                nullptr);
+  legacy::PassTimingInfo::init();
+  if (legacy::PassTimingInfo::TheTimeInfo)
+    return legacy::PassTimingInfo::TheTimeInfo->getPassTimer(P, P);
   return nullptr;
 }
 
 /// If timing is enabled, report the times collected up to now and then reset
 /// them.
 void reportAndResetTimings() {
-  if (PassTimingInfo<StringRef>::TheTimeInfo)
-    PassTimingInfo<StringRef>::TheTimeInfo->print();
-  if (PassTimingInfo<Pass *>::TheTimeInfo)
-    PassTimingInfo<Pass *>::TheTimeInfo->print();
+  if (legacy::PassTimingInfo::TheTimeInfo)
+    legacy::PassTimingInfo::TheTimeInfo->print();
 }
 
 } // namespace llvm

lib/LTO/LTOCodeGenerator.cpp

 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/PassTimingInfo.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/LTO/legacy/LTOModule.h"
 #include "llvm/LTO/legacy/UpdateCompilerUsed.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"

lib/LTO/ThinLTOCodeGenerator.cpp

 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
+#include "llvm/IR/PassTimingInfo.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"