revert r99862 which is causing FNT failures.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@99870 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 222 insertions, 190 deletions

diff --git a/include/llvm/PassManagers.h b/include/llvm/PassManagers.h
index ed1e80eae6..d5685c664c 100644
--- a/include/llvm/PassManagers.h
+++ b/include/llvm/PassManagers.h
@@ -413,6 +413,7 @@ private:
 /// It batches all function passes and basic block pass managers together and 
 /// sequence them to process one function at a time before processing next 
 /// function.
+
 class FPPassManager : public ModulePass, public PMDataManager {
 public:
   static char ID;
@@ -461,7 +462,8 @@ public:
   }
 };
 
-Timer *getPassTimer(Pass *);
+extern Timer *StartPassTimer(Pass *);
+extern void StopPassTimer(Pass *, Timer *);
 
 }
 
diff --git a/include/llvm/Support/Timer.h b/include/llvm/Support/Timer.h
index 59bab1d474..ecd2e65852 100644
--- a/include/llvm/Support/Timer.h
+++ b/include/llvm/Support/Timer.h
@@ -16,62 +16,15 @@
 #define LLVM_SUPPORT_TIMER_H
 
 #include "llvm/System/DataTypes.h"
-#include <cassert>
 #include <string>
 #include <vector>
-#include <utility>
+#include <cassert>
 
 namespace llvm {
 
-class Timer;
 class TimerGroup;
 class raw_ostream;
 
-class TimeRecord {
-  double WallTime;       // Wall clock time elapsed in seconds
-  double UserTime;       // User time elapsed
-  double SystemTime;     // System time elapsed
-  ssize_t MemUsed;       // Memory allocated (in bytes)
-public:
-  TimeRecord() : WallTime(0), UserTime(0), SystemTime(0), MemUsed(0) {}
-  
-  /// getCurrentTime - Get the current time and memory usage.  If Start is true
-  /// we get the memory usage before the time, otherwise we get time before
-  /// memory usage.  This matters if the time to get the memory usage is
-  /// significant and shouldn't be counted as part of a duration.
-  static TimeRecord getCurrentTime(bool Start = true);
-  
-  double getProcessTime() const { return UserTime+SystemTime; }
-  double getUserTime() const { return UserTime; }
-  double getSystemTime() const { return SystemTime; }
-  double getWallTime() const { return WallTime; }
-  ssize_t getMemUsed() const { return MemUsed; }
-  
-  
-  // operator< - Allow sorting.
-  bool operator<(const TimeRecord &T) const {
-    // Sort by Wall Time elapsed, as it is the only thing really accurate
-    return WallTime < T.WallTime;
-  }
-  
-  void operator+=(const TimeRecord &RHS) {
-    WallTime   += RHS.WallTime;
-    UserTime   += RHS.UserTime;
-    SystemTime += RHS.SystemTime;
-    MemUsed    += RHS.MemUsed;
-  }
-  void operator-=(const TimeRecord &RHS) {
-    WallTime   -= RHS.WallTime;
-    UserTime   -= RHS.UserTime;
-    SystemTime -= RHS.SystemTime;
-    MemUsed    -= RHS.MemUsed;
-  }
-  
-  /// print - Print the current timer to standard error, and reset the "Started"
-  /// flag.
-  void print(const TimeRecord &Total, raw_ostream &OS) const;
-};
-  
 /// Timer - This class is used to track the amount of time spent between
 /// invocations of its startTimer()/stopTimer() methods.  Given appropriate OS
 /// support it can also keep track of the RSS of the program at various points.
@@ -81,30 +34,35 @@ public:
 /// if they are never started.
 ///
 class Timer {
-  TimeRecord Time;
+  double Elapsed;        // Wall clock time elapsed in seconds
+  double UserTime;       // User time elapsed
+  double SystemTime;     // System time elapsed
+  ssize_t MemUsed;       // Memory allocated (in bytes)
   std::string Name;      // The name of this time variable.
   bool Started;          // Has this time variable ever been started?
   TimerGroup *TG;        // The TimerGroup this Timer is in.
 public:
-  explicit Timer(const std::string &N) : TG(0) { init(N); }
-  Timer(const std::string &N, TimerGroup &tg) : TG(0) { init(N, tg); }
-  Timer(const Timer &RHS) : TG(0) {
-    assert(RHS.TG == 0 && "Can only copy uninitialized timers");
-  }
-  const Timer &operator=(const Timer &T) {
-    assert(TG == 0 && T.TG == 0 && "Can only assign uninit timers");
-    return *this;
-  }
+  explicit Timer(const std::string &N);
+  Timer(const std::string &N, TimerGroup &tg);
+  Timer(const Timer &T);
   ~Timer();
 
-  // Create an uninitialized timer, client must use 'init'.
-  explicit Timer() : TG(0) {}
-  void init(const std::string &N);
-  void init(const std::string &N, TimerGroup &tg);
-  
-  const std::string &getName() const { return Name; }
-  bool isInitialized() const { return TG != 0; }
+private:
+  double getProcessTime() const { return UserTime+SystemTime; }
+  double getWallTime() const { return Elapsed; }
+  ssize_t getMemUsed() const { return MemUsed; }
+public:
+  std::string getName() const { return Name; }
+
+  const Timer &operator=(const Timer &T);
   
+  // operator< - Allow sorting.
+  bool operator<(const Timer &T) const {
+    // Sort by Wall Time elapsed, as it is the only thing really accurate
+    return Elapsed < T.Elapsed;
+  }
+  bool operator>(const Timer &T) const { return T.operator<(*this); }
+
   /// startTimer - Start the timer running.  Time between calls to
   /// startTimer/stopTimer is counted by the Timer class.  Note that these calls
   /// must be correctly paired.
@@ -115,8 +73,19 @@ public:
   ///
   void stopTimer();
 
+  /// print - Print the current timer to standard error, and reset the "Started"
+  /// flag.
+  void print(const Timer &Total, raw_ostream &OS);
+
 private:
   friend class TimerGroup;
+
+  // Copy ctor, initialize with no TG member.
+  Timer(bool, const Timer &T);
+
+  /// sum - Add the time accumulated in the specified timer into this timer.
+  ///
+  void sum(const Timer &T);
 };
 
 
@@ -163,13 +132,9 @@ struct NamedRegionTimer : public TimeRegion {
 class TimerGroup {
   std::string Name;
   unsigned NumTimers;
-  std::vector<std::pair<TimeRecord, std::string> > TimersToPrint;
+  std::vector<Timer> TimersToPrint;
 public:
   explicit TimerGroup(const std::string &name) : Name(name), NumTimers(0) {}
-  explicit TimerGroup() : NumTimers(0) {}
-  
-  void setName(const std::string &name) { Name = name; }
-  
   ~TimerGroup() {
     assert(NumTimers == 0 &&
            "TimerGroup destroyed before all contained timers!");
@@ -179,7 +144,7 @@ private:
   friend class Timer;
   void addTimer();
   void removeTimer();
-  void addTimerToPrint(const TimeRecord &T, const std::string &Name);
+  void addTimerToPrint(const Timer &T);
 };
 
 } // End llvm namespace
diff --git a/lib/Analysis/IPA/CallGraphSCCPass.cpp b/lib/Analysis/IPA/CallGraphSCCPass.cpp
index 0f39f44a00..0e333d1774 100644
--- a/lib/Analysis/IPA/CallGraphSCCPass.cpp
+++ b/lib/Analysis/IPA/CallGraphSCCPass.cpp
@@ -17,13 +17,12 @@
 
 #define DEBUG_TYPE "cgscc-passmgr"
 #include "llvm/CallGraphSCCPass.h"
-#include "llvm/IntrinsicInst.h"
-#include "llvm/Function.h"
-#include "llvm/PassManagers.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/ADT/SCCIterator.h"
+#include "llvm/PassManagers.h"
+#include "llvm/Function.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/Timer.h"
+#include "llvm/IntrinsicInst.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
@@ -103,10 +102,9 @@ bool CGPassManager::RunPassOnSCC(Pass *P, std::vector<CallGraphNode*> &CurSCC,
       CallGraphUpToDate = true;
     }
 
-    {
-      TimeRegion PassTimer(getPassTimer(CGSP));
-      Changed = CGSP->runOnSCC(CurSCC);
-    }
+    Timer *T = StartPassTimer(CGSP);
+    Changed = CGSP->runOnSCC(CurSCC);
+    StopPassTimer(CGSP, T);
     
     // After the CGSCCPass is done, when assertions are enabled, use
     // RefreshCallGraph to verify that the callgraph was correctly updated.
@@ -127,8 +125,9 @@ bool CGPassManager::RunPassOnSCC(Pass *P, std::vector<CallGraphNode*> &CurSCC,
   for (unsigned i = 0, e = CurSCC.size(); i != e; ++i) {
     if (Function *F = CurSCC[i]->getFunction()) {
       dumpPassInfo(P, EXECUTION_MSG, ON_FUNCTION_MSG, F->getName());
-      TimeRegion PassTimer(getPassTimer(FPP));
+      Timer *T = StartPassTimer(FPP);
       Changed |= FPP->runOnFunction(*F);
+      StopPassTimer(FPP, T);
     }
   }
   
diff --git a/lib/Analysis/LoopPass.cpp b/lib/Analysis/LoopPass.cpp
index f26c0eb666..2d613f6de7 100644
--- a/lib/Analysis/LoopPass.cpp
+++ b/lib/Analysis/LoopPass.cpp
@@ -14,7 +14,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/LoopPass.h"
-#include "llvm/Support/Timer.h"
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
@@ -229,9 +228,9 @@ bool LPPassManager::runOnFunction(Function &F) {
 
       {
         PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
-        TimeRegion PassTimer(getPassTimer(P));
-
+        Timer *T = StartPassTimer(P);
         Changed |= P->runOnLoop(CurrentLoop, *this);
+        StopPassTimer(P, T);
       }
 
       if (Changed)
@@ -246,10 +245,9 @@ bool LPPassManager::runOnFunction(Function &F) {
         // is a function pass and it's really expensive to verify every
         // loop in the function every time. That level of checking can be
         // enabled with the -verify-loop-info option.
-        {
-          TimeRegion PassTimer(getPassTimer(LI));
-          CurrentLoop->verifyLoop();
-        }
+        Timer *T = StartPassTimer(LI);
+        CurrentLoop->verifyLoop();
+        StopPassTimer(LI, T);
 
         // Then call the regular verifyAnalysis functions.
         verifyPreservedAnalysis(P);
diff --git a/lib/Support/Timer.cpp b/lib/Support/Timer.cpp
index 96f440a4ed..317d5ac9c5 100644
--- a/lib/Support/Timer.cpp
+++ b/lib/Support/Timer.cpp
@@ -19,7 +19,6 @@
 #include "llvm/Support/Format.h"
 #include "llvm/System/Mutex.h"
 #include "llvm/System/Process.h"
-#include "llvm/ADT/StringMap.h"
 #include <map>
 using namespace llvm;
 
@@ -96,28 +95,37 @@ static TimerGroup *getDefaultTimerGroup() {
 // Timer Implementation
 //===----------------------------------------------------------------------===//
 
-void Timer::init(const std::string &N) {
-  assert(TG == 0 && "Timer already initialized");
-  Name = N;
-  Started = false;
-  TG = getDefaultTimerGroup();
+Timer::Timer(const std::string &N)
+  : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), Name(N),
+    Started(false), TG(getDefaultTimerGroup()) {
   TG->addTimer();
 }
 
-void Timer::init(const std::string &N, TimerGroup &tg) {
-  assert(TG == 0 && "Timer already initialized");
-  Name = N;
-  Started = false;
-  TG = &tg;
+Timer::Timer(const std::string &N, TimerGroup &tg)
+  : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), Name(N),
+    Started(false), TG(&tg) {
   TG->addTimer();
 }
 
+Timer::Timer(const Timer &T) {
+  TG = T.TG;
+  if (TG) TG->addTimer();
+  operator=(T);
+}
+
+// Copy ctor, initialize with no TG member.
+Timer::Timer(bool, const Timer &T) {
+  TG = T.TG;     // Avoid assertion in operator=
+  operator=(T);  // Copy contents
+  TG = 0;
+}
+
 Timer::~Timer() {
-  if (!TG) return;  // Never initialized.
+  if (!TG) return;
   
   if (Started) {
     Started = false;
-    TG->addTimerToPrint(Time, Name);
+    TG->addTimerToPrint(*this);
   }
   TG->removeTimer();
 }
@@ -128,7 +136,12 @@ static inline size_t getMemUsage() {
   return 0;
 }
 
-TimeRecord TimeRecord::getCurrentTime(bool Start) {
+struct TimeRecord {
+  double Elapsed, UserTime, SystemTime;
+  ssize_t MemUsed;
+};
+
+static TimeRecord getTimeRecord(bool Start) {
   TimeRecord Result;
 
   sys::TimeValue now(0,0);
@@ -144,9 +157,9 @@ TimeRecord TimeRecord::getCurrentTime(bool Start) {
     MemUsed = getMemUsage();
   }
 
-  Result.WallTime   =  now.seconds() +  now.microseconds() / 1000000.0;
+  Result.Elapsed    =  now.seconds()  + now.microseconds() / 1000000.0;
   Result.UserTime   = user.seconds() + user.microseconds() / 1000000.0;
-  Result.SystemTime =  sys.seconds() +  sys.microseconds() / 1000000.0;
+  Result.SystemTime =  sys.seconds()  + sys.microseconds() / 1000000.0;
   Result.MemUsed = MemUsed;
   return Result;
 }
@@ -156,11 +169,19 @@ static ManagedStatic<std::vector<Timer*> > ActiveTimers;
 void Timer::startTimer() {
   Started = true;
   ActiveTimers->push_back(this);
-  Time -= TimeRecord::getCurrentTime(true);
+  TimeRecord TR = getTimeRecord(true);
+  Elapsed    -= TR.Elapsed;
+  UserTime   -= TR.UserTime;
+  SystemTime -= TR.SystemTime;
+  MemUsed    -= TR.MemUsed;
 }
 
 void Timer::stopTimer() {
-  Time += TimeRecord::getCurrentTime(false);
+  TimeRecord TR = getTimeRecord(false);
+  Elapsed    += TR.Elapsed;
+  UserTime   += TR.UserTime;
+  SystemTime += TR.SystemTime;
+  MemUsed    += TR.MemUsed;
 
   if (ActiveTimers->back() == this) {
     ActiveTimers->pop_back();
@@ -172,6 +193,25 @@ void Timer::stopTimer() {
   }
 }
 
+void Timer::sum(const Timer &T) {
+  Elapsed    += T.Elapsed;
+  UserTime   += T.UserTime;
+  SystemTime += T.SystemTime;
+  MemUsed    += T.MemUsed;
+}
+
+const Timer &Timer::operator=(const Timer &T) {
+  Elapsed = T.Elapsed;
+  UserTime = T.UserTime;
+  SystemTime = T.SystemTime;
+  MemUsed = T.MemUsed;
+  Name = T.Name;
+  Started = T.Started;
+  assert(TG == T.TG && "Can only assign timers in the same TimerGroup!");
+  return *this;
+}
+
+
 static void printVal(double Val, double Total, raw_ostream &OS) {
   if (Total < 1e-7)   // Avoid dividing by zero.
     OS << "        -----     ";
@@ -181,19 +221,23 @@ static void printVal(double Val, double Total, raw_ostream &OS) {
   }
 }
 
-void TimeRecord::print(const TimeRecord &Total, raw_ostream &OS) const {
-  if (Total.getUserTime())
-    printVal(getUserTime(), Total.getUserTime(), OS);
-  if (Total.getSystemTime())
-    printVal(getSystemTime(), Total.getSystemTime(), OS);
+void Timer::print(const Timer &Total, raw_ostream &OS) {
+  if (Total.UserTime)
+    printVal(UserTime, Total.UserTime, OS);
+  if (Total.SystemTime)
+    printVal(SystemTime, Total.SystemTime, OS);
   if (Total.getProcessTime())
     printVal(getProcessTime(), Total.getProcessTime(), OS);
-  printVal(getWallTime(), Total.getWallTime(), OS);
+  printVal(Elapsed, Total.Elapsed, OS);
   
   OS << "  ";
   
-  if (Total.getMemUsed())
-    OS << format("%9lld", (long long)getMemUsed()) << "  ";
+  if (Total.MemUsed)
+    OS << format("%9lld", (long long)MemUsed) << "  ";
+
+  OS << Name << "\n";
+  
+  Started = false;  // Once printed, don't print again
 }
 
 
@@ -201,35 +245,40 @@ void TimeRecord::print(const TimeRecord &Total, raw_ostream &OS) const {
 //   NamedRegionTimer Implementation
 //===----------------------------------------------------------------------===//
 
-typedef StringMap<Timer> Name2TimerMap;
-typedef StringMap<std::pair<TimerGroup, Name2TimerMap> > Name2PairMap;
+typedef std::map<std::string, Timer> Name2Timer;
+typedef std::map<std::string, std::pair<TimerGroup, Name2Timer> > Name2Pair;
 
-static ManagedStatic<Name2TimerMap> NamedTimers;
-static ManagedStatic<Name2PairMap> NamedGroupedTimers;
+static ManagedStatic<Name2Timer> NamedTimers;
+static ManagedStatic<Name2Pair> NamedGroupedTimers;
 
 static Timer &getNamedRegionTimer(const std::string &Name) {
   sys::SmartScopedLock<true> L(*TimerLock);
-  
-  Timer &T = (*NamedTimers)[Name];
-  if (!T.isInitialized())
-    T.init(Name);
-  return T;
+  Name2Timer::iterator I = NamedTimers->find(Name);
+  if (I != NamedTimers->end())
+    return I->second;
+
+  return NamedTimers->insert(I, std::make_pair(Name, Timer(Name)))->second;
 }
 
 static Timer &getNamedRegionTimer(const std::string &Name,
                                   const std::string &GroupName) {
   sys::SmartScopedLock<true> L(*TimerLock);
 
-  std::pair<TimerGroup, Name2TimerMap> &GroupEntry =
-    (*NamedGroupedTimers)[GroupName];
+  Name2Pair::iterator I = NamedGroupedTimers->find(GroupName);
+  if (I == NamedGroupedTimers->end()) {
+    TimerGroup TG(GroupName);
+    std::pair<TimerGroup, Name2Timer> Pair(TG, Name2Timer());
+    I = NamedGroupedTimers->insert(I, std::make_pair(GroupName, Pair));
+  }
 
-  if (GroupEntry.second.empty())
-    GroupEntry.first.setName(GroupName);
+  Name2Timer::iterator J = I->second.second.find(Name);
+  if (J == I->second.second.end())
+    J = I->second.second.insert(J,
+                                std::make_pair(Name,
+                                               Timer(Name,
+                                                     I->second.first)));
 
-  Timer &T = GroupEntry.second[Name];
-  if (!T.isInitialized())
-    T.init(Name);
-  return T;
+  return J->second;
 }
 
 NamedRegionTimer::NamedRegionTimer(const std::string &Name)
@@ -249,7 +298,8 @@ void TimerGroup::removeTimer() {
     return; // Don't print timing report.
   
   // Sort the timers in descending order by amount of time taken.
-  std::sort(TimersToPrint.begin(), TimersToPrint.end());
+  std::sort(TimersToPrint.begin(), TimersToPrint.end(),
+            std::greater<Timer>());
 
   // Figure out how many spaces to indent TimerGroup name.
   unsigned Padding = (80-Name.length())/2;
@@ -257,46 +307,50 @@ void TimerGroup::removeTimer() {
 
   raw_ostream *OutStream = GetLibSupportInfoOutputFile();
 
-  TimeRecord Total;
-  for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
-    Total += TimersToPrint[i].first;
-
-  // Print out timing header.
-  *OutStream << "===" << std::string(73, '-') << "===\n";
-  OutStream->indent(Padding) << Name << '\n';
-  *OutStream << "===" << std::string(73, '-') << "===\n";
-
-  // If this is not an collection of ungrouped times, print the total time.
-  // Ungrouped timers don't really make sense to add up.  We still print the
-  // TOTAL line to make the percentages make sense.
-  if (this != DefaultTimerGroup) {
-    *OutStream << "  Total Execution Time: ";
-    *OutStream << format("%5.4f", Total.getProcessTime()) << " seconds (";
-    *OutStream << format("%5.4f", Total.getWallTime()) << " wall clock)\n";
-  }
-  *OutStream << "\n";
-
-  if (Total.getUserTime())
-    *OutStream << "   ---User Time---";
-  if (Total.getSystemTime())
-    *OutStream << "   --System Time--";
-  if (Total.getProcessTime())
-    *OutStream << "   --User+System--";
-  *OutStream << "   ---Wall Time---";
-  if (Total.getMemUsed())
-    *OutStream << "  ---Mem---";
-  *OutStream << "  --- Name ---\n";
-
-  // Loop through all of the timing data, printing it out.
-  for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i) {
-    const std::pair<TimeRecord, std::string> &Entry = TimersToPrint[e-i-1];
-    Entry.first.print(Total, *OutStream);
-    *OutStream << Entry.second << '\n';
+  ++NumTimers;
+  {  // Scope to contain Total timer: don't allow total timer to drop us to
+     // zero timers.
+    Timer Total("TOTAL");
+
+    for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
+      Total.sum(TimersToPrint[i]);
+
+    // Print out timing header.
+    *OutStream << "===" << std::string(73, '-') << "===\n"
+               << std::string(Padding, ' ') << Name << "\n"
+               << "===" << std::string(73, '-')
+               << "===\n";
+
+    // If this is not an collection of ungrouped times, print the total time.
+    // Ungrouped timers don't really make sense to add up.  We still print the
+    // TOTAL line to make the percentages make sense.
+    if (this != DefaultTimerGroup) {
+      *OutStream << "  Total Execution Time: ";
+      *OutStream << format("%5.4f", Total.getProcessTime()) << " seconds (";
+      *OutStream << format("%5.4f", Total.getWallTime()) << " wall clock)\n";
+    }
+    *OutStream << "\n";
+
+    if (Total.UserTime)
+      *OutStream << "   ---User Time---";
+    if (Total.SystemTime)
+      *OutStream << "   --System Time--";
+    if (Total.getProcessTime())
+      *OutStream << "   --User+System--";
+    *OutStream << "   ---Wall Time---";
+    if (Total.getMemUsed())
+      *OutStream << "  ---Mem---";
+    *OutStream << "  --- Name ---\n";
+
+    // Loop through all of the timing data, printing it out.
+    for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
+      TimersToPrint[i].print(Total, *OutStream);
+
+    Total.print(Total, *OutStream);
+    *OutStream << '\n';
+    OutStream->flush();
   }
-
-  Total.print(Total, *OutStream);
-  *OutStream << "Total\n\n";
-  OutStream->flush();
+  --NumTimers;
 
   TimersToPrint.clear();
 
@@ -309,8 +363,8 @@ void TimerGroup::addTimer() {
   ++NumTimers;
 }
 
-void TimerGroup::addTimerToPrint(const TimeRecord &T, const std::string &Name) {
+void TimerGroup::addTimerToPrint(const Timer &T) {
   sys::SmartScopedLock<true> L(*TimerLock);
-  TimersToPrint.push_back(std::make_pair(T, Name));
+  TimersToPrint.push_back(Timer(true, T));
 }
 
diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index 6d83261996..c4dfe1409b 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -378,7 +378,7 @@ namespace {
 static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
 
 class TimingInfo {
-  DenseMap<Pass*, Timer> TimingData;
+  std::map<Pass*, Timer> TimingData;
   TimerGroup TG;
 
 public:
@@ -397,16 +397,19 @@ public:
   // null.  It may be called multiple times.
   static void createTheTimeInfo();
 
-  /// getPassTimer - Return the timer for the specified pass if it exists.
-  Timer *getPassTimer(Pass *P) {
+  /// passStarted - This method creates a timer for the given pass if it doesn't
+  /// already have one, and starts the timer.
+  Timer *passStarted(Pass *P) {
     if (P->getAsPMDataManager()) 
       return 0;
 
     sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
-    Timer &T = TimingData[P];
-    if (!T.isInitialized())
-      T.init(P->getPassName(), TG);
-    return &T;
+    std::map<Pass*, Timer>::iterator I = TimingData.find(P);
+    if (I == TimingData.end())
+      I=TimingData.insert(std::make_pair(P, Timer(P->getPassName(), TG))).first;
+    Timer *T = &I->second;
+    T->startTimer();
+    return T;
   }
 };
 
@@ -701,8 +704,11 @@ void PMDataManager::verifyPreservedAnalysis(Pass *P) {
          E = PreservedSet.end(); I != E; ++I) {
     AnalysisID AID = *I;
     if (Pass *AP = findAnalysisPass(AID, true)) {
-      TimeRegion PassTimer(getPassTimer(AP));
+
+      Timer *T = 0;
+      if (TheTimeInfo) T = TheTimeInfo->passStarted(AP);
       AP->verifyAnalysis();
+      if (T) T->stopTimer();
     }
   }
 }
@@ -786,9 +792,10 @@ void PMDataManager::freePass(Pass *P, StringRef Msg,
   {
     // If the pass crashes releasing memory, remember this.
     PassManagerPrettyStackEntry X(P);
-    TimeRegion PassTimer(getPassTimer(P));
-
+    
+    Timer *T = StartPassTimer(P);
     P->releaseMemory();
+    StopPassTimer(P, T);
   }
 
   if (const PassInfo *PI = P->getPassInfo()) {
@@ -1121,9 +1128,10 @@ bool BBPassManager::runOnFunction(Function &F) {
       {
         // If the pass crashes, remember this.
         PassManagerPrettyStackEntry X(BP, *I);
-        TimeRegion PassTimer(getPassTimer(BP));
-
+      
+        Timer *T = StartPassTimer(BP);
         LocalChanged |= BP->runOnBasicBlock(*I);
+        StopPassTimer(BP, T);
       }
 
       Changed |= LocalChanged;
@@ -1337,9 +1345,10 @@ bool FPPassManager::runOnFunction(Function &F) {
 
     {
       PassManagerPrettyStackEntry X(FP, F);
-      TimeRegion PassTimer(getPassTimer(FP));
 
+      Timer *T = StartPassTimer(FP);
       LocalChanged |= FP->runOnFunction(F);
+      StopPassTimer(FP, T);
     }
 
     Changed |= LocalChanged;
@@ -1411,9 +1420,9 @@ MPPassManager::runOnModule(Module &M) {
 
     {
       PassManagerPrettyStackEntry X(MP, M);
-      TimeRegion PassTimer(getPassTimer(MP));
-
+      Timer *T = StartPassTimer(MP);
       LocalChanged |= MP->runOnModule(M);
+      StopPassTimer(MP, T);
     }
 
     Changed |= LocalChanged;
@@ -1550,12 +1559,17 @@ void TimingInfo::createTheTimeInfo() {
 }
 
 /// If TimingInfo is enabled then start pass timer.
-Timer *llvm::getPassTimer(Pass *P) {
+Timer *llvm::StartPassTimer(Pass *P) {
   if (TheTimeInfo) 
-    return TheTimeInfo->getPassTimer(P);
+    return TheTimeInfo->passStarted(P);
   return 0;
 }
 
+/// If TimingInfo is enabled then stop pass timer.
+void llvm::StopPassTimer(Pass *P, Timer *T) {
+  if (T) T->stopTimer();
+}
+
 //===----------------------------------------------------------------------===//
 // PMStack implementation
 //