From 0d2725ad696afb60c86076469031783669809739 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 30 Mar 2010 03:57:00 +0000 Subject: [PATCH] revert r99862 which is causing FNT failures. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@99870 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/PassManagers.h | 4 +- include/llvm/Support/Timer.h | 107 +++++-------- lib/Analysis/IPA/CallGraphSCCPass.cpp | 17 +- lib/Analysis/LoopPass.cpp | 12 +- lib/Support/Timer.cpp | 220 ++++++++++++++++---------- lib/VMCore/PassManager.cpp | 48 ++++-- 6 files changed, 220 insertions(+), 188 deletions(-) diff --git a/include/llvm/PassManagers.h b/include/llvm/PassManagers.h index ed1e80eae69..d5685c664c2 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 59bab1d4741..ecd2e65852a 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 #include #include -#include +#include 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 > TimersToPrint; + std::vector 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 0f39f44a009..0e333d17745 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 &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 &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 f26c0eb6668..2d613f6de71 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 96f440a4ed4..317d5ac9c54 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 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 > 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 Name2TimerMap; -typedef StringMap > Name2PairMap; +typedef std::map Name2Timer; +typedef std::map > Name2Pair; -static ManagedStatic NamedTimers; -static ManagedStatic NamedGroupedTimers; +static ManagedStatic NamedTimers; +static ManagedStatic NamedGroupedTimers; static Timer &getNamedRegionTimer(const std::string &Name) { sys::SmartScopedLock 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 L(*TimerLock); - std::pair &GroupEntry = - (*NamedGroupedTimers)[GroupName]; + Name2Pair::iterator I = NamedGroupedTimers->find(GroupName); + if (I == NamedGroupedTimers->end()) { + TimerGroup TG(GroupName); + std::pair 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()); // 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; + ++NumTimers; + { // Scope to contain Total timer: don't allow total timer to drop us to + // zero timers. + Timer Total("TOTAL"); - // Print out timing header. - *OutStream << "===" << std::string(73, '-') << "===\n"; - OutStream->indent(Padding) << Name << '\n'; - *OutStream << "===" << std::string(73, '-') << "===\n"; + for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i) + Total.sum(TimersToPrint[i]); - // 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"; + // 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(); } - *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 &Entry = TimersToPrint[e-i-1]; - Entry.first.print(Total, *OutStream); - *OutStream << Entry.second << '\n'; - } - - 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 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 6d832619968..c4dfe1409b9 100644 --- a/lib/VMCore/PassManager.cpp +++ b/lib/VMCore/PassManager.cpp @@ -378,7 +378,7 @@ namespace { static ManagedStatic > TimingInfoMutex; class TimingInfo { - DenseMap TimingData; + std::map 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 Lock(*TimingInfoMutex); - Timer &T = TimingData[P]; - if (!T.isInitialized()) - T.init(P->getPassName(), TG); - return &T; + std::map::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 //