X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=lib%2FVMCore%2FPass.cpp;h=b673484f214400e0c14d6dc6b86e52f27b16258f;hb=a98bde53a7eb13e02c1dc707dae58aa21fd7ea2c;hp=b4f837d0d8ab741e8943752fd1371e44d7ecfb36;hpb=27ad137d5ef5bb08f95c388e825b02e9c074b667;p=oota-llvm.git diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index b4f837d0d8a..b673484f214 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -9,32 +9,24 @@ #include "llvm/PassManager.h" #include "PassManagerT.h" // PassManagerT implementation #include "llvm/Module.h" -#include "llvm/Function.h" -#include "llvm/BasicBlock.h" #include "Support/STLExtras.h" -#include "Support/CommandLine.h" -#include -#include -#include +#include "Support/TypeInfo.h" #include +#include +#include +#include + +// IncludeFile - Stub function used to help linking out. +IncludeFile::IncludeFile(void*) {} //===----------------------------------------------------------------------===// // AnalysisID Class Implementation // -static std::vector CFGOnlyAnalyses; - -// Source of unique analysis ID #'s. -unsigned AnalysisID::NextID = 0; +static std::vector CFGOnlyAnalyses; -AnalysisID::AnalysisID(const AnalysisID &AID, bool DependsOnlyOnCFG) { - ID = AID.ID; // Implement the copy ctor part... - Constructor = AID.Constructor; - - // If this analysis only depends on the CFG of the function, add it to the CFG - // only list... - if (DependsOnlyOnCFG) - CFGOnlyAnalyses.push_back(AID); +void RegisterPassBase::setPreservesCFG() { + CFGOnlyAnalyses.push_back(PIObj); } //===----------------------------------------------------------------------===// @@ -75,7 +67,7 @@ void AnalysisUsage::preservesCFG() { PassManager::PassManager() : PM(new PassManagerT()) {} PassManager::~PassManager() { delete PM; } void PassManager::add(Pass *P) { PM->add(P); } -bool PassManager::run(Module *M) { return PM->run(M); } +bool PassManager::run(Module &M) { return PM->run(M); } //===----------------------------------------------------------------------===// @@ -83,15 +75,88 @@ bool PassManager::run(Module *M) { return PM->run(M); } // amount of time each pass takes to execute. This only happens with // -time-passes is enabled on the command line. // -static cl::Flag EnableTiming("time-passes", "Time each pass, printing elapsed" - " time for each on exit"); +static cl::opt +EnableTiming("time-passes", + cl::desc("Time each pass, printing elapsed time for each on exit")); + +static TimeRecord getTimeRecord() { + static unsigned long PageSize = 0; + + if (PageSize == 0) { +#ifdef _SC_PAGE_SIZE + PageSize = sysconf(_SC_PAGE_SIZE); +#else +#ifdef _SC_PAGESIZE + PageSize = sysconf(_SC_PAGESIZE); +#else + PageSize = getpagesize(); +#endif +#endif + } -static double getTime() { + struct rusage RU; struct timeval T; gettimeofday(&T, 0); - return T.tv_sec + T.tv_usec/1000000.0; + if (getrusage(RUSAGE_SELF, &RU)) { + perror("getrusage call failed: -time-passes info incorrect!"); + } + + TimeRecord Result; + Result.Elapsed = T.tv_sec + T.tv_usec/1000000.0; + Result.UserTime = RU.ru_utime.tv_sec + RU.ru_utime.tv_usec/1000000.0; + Result.SystemTime = RU.ru_stime.tv_sec + RU.ru_stime.tv_usec/1000000.0; + Result.MaxRSS = RU.ru_maxrss*PageSize; + + return Result; +} + +bool TimeRecord::operator<(const TimeRecord &TR) const { + // Primary sort key is User+System time + if (UserTime+SystemTime < TR.UserTime+TR.SystemTime) + return true; + if (UserTime+SystemTime > TR.UserTime+TR.SystemTime) + return false; + + // Secondary sort key is Wall Time + return Elapsed < TR.Elapsed; +} + +void TimeRecord::passStart(const TimeRecord &T) { + Elapsed -= T.Elapsed; + UserTime -= T.UserTime; + SystemTime -= T.SystemTime; + RSSTemp = T.MaxRSS; } +void TimeRecord::passEnd(const TimeRecord &T) { + Elapsed += T.Elapsed; + UserTime += T.UserTime; + SystemTime += T.SystemTime; + RSSTemp = T.MaxRSS - RSSTemp; + MaxRSS = std::max(MaxRSS, RSSTemp); +} + +static void printVal(double Val, double Total) { + if (Total < 1e-7) // Avoid dividing by zero... + fprintf(stderr, " ----- "); + else + fprintf(stderr, " %7.4f (%5.1f%%)", Val, Val*100/Total); +} + +void TimeRecord::print(const char *PassName, const TimeRecord &Total) const { + printVal(UserTime, Total.UserTime); + printVal(SystemTime, Total.SystemTime); + printVal(UserTime+SystemTime, Total.UserTime+Total.SystemTime); + printVal(Elapsed, Total.Elapsed); + + fprintf(stderr, " "); + + if (Total.MaxRSS) + std::cerr << MaxRSS << "\t"; + std::cerr << PassName << "\n"; +} + + // Create method. If Timing is enabled, this creates and returns a new timing // object, otherwise it returns null. // @@ -99,70 +164,75 @@ TimingInfo *TimingInfo::create() { return EnableTiming ? new TimingInfo() : 0; } -void TimingInfo::passStarted(Pass *P) { TimingData[P] -= getTime(); } -void TimingInfo::passEnded(Pass *P) { TimingData[P] += getTime(); } +void TimingInfo::passStarted(Pass *P) { + TimingData[P].passStart(getTimeRecord()); +} +void TimingInfo::passEnded(Pass *P) { + TimingData[P].passEnd(getTimeRecord()); +} +void TimeRecord::sum(const TimeRecord &TR) { + Elapsed += TR.Elapsed; + UserTime += TR.UserTime; + SystemTime += TR.SystemTime; + MaxRSS += TR.MaxRSS; +} // TimingDtor - Print out information about timing information TimingInfo::~TimingInfo() { // Iterate over all of the data, converting it into the dual of the data map, // so that the data is sorted by amount of time taken, instead of pointer. // - std::vector > Data; - double TotalTime = 0; - for (std::map::iterator I = TimingData.begin(), + std::vector > Data; + TimeRecord Total; + for (std::map::iterator I = TimingData.begin(), E = TimingData.end(); I != E; ++I) // Throw out results for "grouping" pass managers... if (!dynamic_cast(I->first)) { Data.push_back(std::make_pair(I->second, I->first)); - TotalTime += I->second; + Total.sum(I->second); } // Sort the data by time as the primary key, in reverse order... - std::sort(Data.begin(), Data.end(), greater >()); + std::sort(Data.begin(), Data.end(), + std::greater >()); // Print out timing header... - cerr << std::string(79, '=') << "\n" - << " ... Pass execution timing report ...\n" - << std::string(79, '=') << "\n Total Execution Time: " << TotalTime - << " seconds\n\n % Time: Seconds:\tPass Name:\n"; + std::cerr << std::string(79, '=') << "\n" + << " ... Pass execution timing report ...\n" + << std::string(79, '=') << "\n Total Execution Time: " + << (Total.UserTime+Total.SystemTime) << " seconds (" + << Total.Elapsed << " wall clock)\n\n ---User Time--- " + << "--System Time-- --User+System-- ---Wall Time---"; - // Loop through all of the timing data, printing it out... - for (unsigned i = 0, e = Data.size(); i != e; ++i) { - fprintf(stderr, " %6.2f%% %fs\t%s\n", Data[i].first*100 / TotalTime, - Data[i].first, Data[i].second->getPassName()); - } - cerr << " 100.00% " << TotalTime << "s\tTOTAL\n" - << std::string(79, '=') << "\n"; -} + if (Total.MaxRSS) + std::cerr << " ---Mem---"; + std::cerr << " --- Pass Name ---\n"; + // Loop through all of the timing data, printing it out... + for (unsigned i = 0, e = Data.size(); i != e; ++i) + Data[i].first.print(Data[i].second->getPassName(), Total); -//===----------------------------------------------------------------------===// -// Pass debugging information. Often it is useful to find out what pass is -// running when a crash occurs in a utility. When this library is compiled with -// debugging on, a command line option (--debug-pass) is enabled that causes the -// pass name to be printed before it executes. -// + Total.print("TOTAL", Total); +} -// Different debug levels that can be enabled... -enum PassDebugLevel { - None, PassStructure, PassExecutions, PassDetails -}; -static cl::Enum PassDebugging("debug-pass", cl::Hidden, - "Print PassManager debugging information", - clEnumVal(None , "disable debug output"), - clEnumVal(PassStructure , "print pass structure before run()"), - clEnumVal(PassExecutions, "print pass name before it is executed"), - clEnumVal(PassDetails , "print pass details when it is executed"), 0); +void PMDebug::PrintArgumentInformation(const Pass *P) { + // Print out passes in pass manager... + if (const AnalysisResolver *PM = dynamic_cast(P)) { + for (unsigned i = 0, e = PM->getNumContainedPasses(); i != e; ++i) + PrintArgumentInformation(PM->getContainedPass(i)); -void PMDebug::PrintPassStructure(Pass *P) { - if (PassDebugging >= PassStructure) - P->dumpPassStructure(); + } else { // Normal pass. Print argument information... + // Print out arguments for registered passes that are _optimizations_ + if (const PassInfo *PI = P->getPassInfo()) + if (PI->getPassType() & PassInfo::Optimization) + std::cerr << " -" << PI->getPassArgument(); + } } void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, Pass *P, Annotable *V) { - if (PassDebugging >= PassExecutions) { + if (PassDebugging >= Executions) { std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" << P->getPassName(); if (V) { @@ -183,23 +253,16 @@ void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg, Pass *P, const std::vector &Set){ - if (PassDebugging >= PassDetails && !Set.empty()) { + if (PassDebugging >= Details && !Set.empty()) { std::cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:"; for (unsigned i = 0; i != Set.size(); ++i) { - Pass *P = Set[i].createPass(); // Good thing this is just debug code... - std::cerr << " " << P->getPassName(); - delete P; + if (i) std::cerr << ","; + std::cerr << " " << Set[i]->getPassName(); } std::cerr << "\n"; } } -// dumpPassStructure - Implement the -debug-passes=PassStructure option -void Pass::dumpPassStructure(unsigned Offset = 0) { - std::cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; -} - - //===----------------------------------------------------------------------===// // Pass Implementation // @@ -208,10 +271,31 @@ void Pass::addToPassManager(PassManagerT *PM, AnalysisUsage &AU) { PM->addPass(this, AU); } +// dumpPassStructure - Implement the -debug-passes=Structure option +void Pass::dumpPassStructure(unsigned Offset) { + std::cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; +} // getPassName - Use C++ RTTI to get a SOMEWHAT intelligable name for the pass. // -const char *Pass::getPassName() const { return typeid(*this).name(); } +const char *Pass::getPassName() const { + if (const PassInfo *PI = getPassInfo()) + return PI->getPassName(); + return typeid(*this).name(); +} + +// print - Print out the internal state of the pass. This is called by Analyse +// to print out the contents of an analysis. Otherwise it is not neccesary to +// implement this method. +// +void Pass::print(std::ostream &O) const { + O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; +} + +// dump - call print(std::cerr); +void Pass::dump() const { + print(std::cerr, 0); +} //===----------------------------------------------------------------------===// // FunctionPass Implementation @@ -220,11 +304,11 @@ const char *Pass::getPassName() const { return typeid(*this).name(); } // run - On a module, we run this pass by initializing, runOnFunction'ing once // for every function in the module, then by finalizing. // -bool FunctionPass::run(Module *M) { +bool FunctionPass::run(Module &M) { bool Changed = doInitialization(M); - for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) - if (!(*I)->isExternal()) // Passes are not run on external functions! + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + if (!I->isExternal()) // Passes are not run on external functions! Changed |= runOnFunction(*I); return Changed | doFinalization(M); @@ -232,11 +316,11 @@ bool FunctionPass::run(Module *M) { // run - On a function, we simply initialize, run the function, then finalize. // -bool FunctionPass::run(Function *F) { - if (F->isExternal()) return false;// Passes are not run on external functions! +bool FunctionPass::run(Function &F) { + if (F.isExternal()) return false;// Passes are not run on external functions! - return doInitialization(F->getParent()) | runOnFunction(F) - | doFinalization(F->getParent()); + return doInitialization(*F.getParent()) | runOnFunction(F) + | doFinalization(*F.getParent()); } void FunctionPass::addToPassManager(PassManagerT *PM, @@ -256,9 +340,9 @@ void FunctionPass::addToPassManager(PassManagerT *PM, // To run this pass on a function, we simply call runOnBasicBlock once for each // function. // -bool BasicBlockPass::runOnFunction(Function *F) { +bool BasicBlockPass::runOnFunction(Function &F) { bool Changed = false; - for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) + for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) Changed |= runOnBasicBlock(*I); return Changed; } @@ -266,8 +350,8 @@ bool BasicBlockPass::runOnFunction(Function *F) { // To run directly on the basic block, we initialize, runOnBasicBlock, then // finalize. // -bool BasicBlockPass::run(BasicBlock *BB) { - Module *M = BB->getParent()->getParent(); +bool BasicBlockPass::run(BasicBlock &BB) { + Module &M = *BB.getParent()->getParent(); return doInitialization(M) | runOnBasicBlock(BB) | doFinalization(M); } @@ -281,3 +365,187 @@ void BasicBlockPass::addToPassManager(PassManagerT *PM, PM->addPass(this, AU); } + +//===----------------------------------------------------------------------===// +// Pass Registration mechanism +// +static std::map *PassInfoMap = 0; +static std::vector *Listeners = 0; + +// getPassInfo - Return the PassInfo data structure that corresponds to this +// pass... +const PassInfo *Pass::getPassInfo() const { + if (PassInfoCache) return PassInfoCache; + return lookupPassInfo(typeid(*this)); +} + +const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) { + if (PassInfoMap == 0) return 0; + std::map::iterator I = PassInfoMap->find(TI); + return (I != PassInfoMap->end()) ? I->second : 0; +} + +void RegisterPassBase::registerPass(PassInfo *PI) { + if (PassInfoMap == 0) + PassInfoMap = new std::map(); + + assert(PassInfoMap->find(PI->getTypeInfo()) == PassInfoMap->end() && + "Pass already registered!"); + PIObj = PI; + PassInfoMap->insert(std::make_pair(TypeInfo(PI->getTypeInfo()), PI)); + + // Notify any listeners... + if (Listeners) + for (std::vector::iterator + I = Listeners->begin(), E = Listeners->end(); I != E; ++I) + (*I)->passRegistered(PI); +} + +void RegisterPassBase::unregisterPass(PassInfo *PI) { + assert(PassInfoMap && "Pass registered but not in map!"); + std::map::iterator I = + PassInfoMap->find(PI->getTypeInfo()); + assert(I != PassInfoMap->end() && "Pass registered but not in map!"); + + // Remove pass from the map... + PassInfoMap->erase(I); + if (PassInfoMap->empty()) { + delete PassInfoMap; + PassInfoMap = 0; + } + + // Notify any listeners... + if (Listeners) + for (std::vector::iterator + I = Listeners->begin(), E = Listeners->end(); I != E; ++I) + (*I)->passUnregistered(PI); + + // Delete the PassInfo object itself... + delete PI; +} + +//===----------------------------------------------------------------------===// +// Analysis Group Implementation Code +//===----------------------------------------------------------------------===// + +struct AnalysisGroupInfo { + const PassInfo *DefaultImpl; + std::set Implementations; + AnalysisGroupInfo() : DefaultImpl(0) {} +}; + +static std::map *AnalysisGroupInfoMap = 0; + +// RegisterAGBase implementation +// +RegisterAGBase::RegisterAGBase(const std::type_info &Interface, + const std::type_info *Pass, bool isDefault) + : ImplementationInfo(0), isDefaultImplementation(isDefault) { + + InterfaceInfo = const_cast(Pass::lookupPassInfo(Interface)); + if (InterfaceInfo == 0) { // First reference to Interface, add it now. + InterfaceInfo = // Create the new PassInfo for the interface... + new PassInfo("", "", Interface, PassInfo::AnalysisGroup, 0, 0); + registerPass(InterfaceInfo); + PIObj = 0; + } + assert(InterfaceInfo->getPassType() == PassInfo::AnalysisGroup && + "Trying to join an analysis group that is a normal pass!"); + + if (Pass) { + ImplementationInfo = Pass::lookupPassInfo(*Pass); + assert(ImplementationInfo && + "Must register pass before adding to AnalysisGroup!"); + + // Make sure we keep track of the fact that the implementation implements + // the interface. + PassInfo *IIPI = const_cast(ImplementationInfo); + IIPI->addInterfaceImplemented(InterfaceInfo); + + // Lazily allocate to avoid nasty initialization order dependencies + if (AnalysisGroupInfoMap == 0) + AnalysisGroupInfoMap = new std::map(); + + AnalysisGroupInfo &AGI = (*AnalysisGroupInfoMap)[InterfaceInfo]; + assert(AGI.Implementations.count(ImplementationInfo) == 0 && + "Cannot add a pass to the same analysis group more than once!"); + AGI.Implementations.insert(ImplementationInfo); + if (isDefault) { + assert(AGI.DefaultImpl == 0 && InterfaceInfo->getNormalCtor() == 0 && + "Default implementation for analysis group already specified!"); + assert(ImplementationInfo->getNormalCtor() && + "Cannot specify pass as default if it does not have a default ctor"); + AGI.DefaultImpl = ImplementationInfo; + InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); + } + } +} + +void RegisterAGBase::setGroupName(const char *Name) { + assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!"); + InterfaceInfo->setPassName(Name); +} + +RegisterAGBase::~RegisterAGBase() { + if (ImplementationInfo) { + assert(AnalysisGroupInfoMap && "Inserted into map, but map doesn't exist?"); + AnalysisGroupInfo &AGI = (*AnalysisGroupInfoMap)[InterfaceInfo]; + + assert(AGI.Implementations.count(ImplementationInfo) && + "Pass not a member of analysis group?"); + + if (AGI.DefaultImpl == ImplementationInfo) + AGI.DefaultImpl = 0; + + AGI.Implementations.erase(ImplementationInfo); + + // Last member of this analysis group? Unregister PassInfo, delete map entry + if (AGI.Implementations.empty()) { + assert(AGI.DefaultImpl == 0 && + "Default implementation didn't unregister?"); + AnalysisGroupInfoMap->erase(InterfaceInfo); + if (AnalysisGroupInfoMap->empty()) { // Delete map if empty + delete AnalysisGroupInfoMap; + AnalysisGroupInfoMap = 0; + } + + unregisterPass(InterfaceInfo); + } + } +} + + +//===----------------------------------------------------------------------===// +// PassRegistrationListener implementation +// + +// PassRegistrationListener ctor - Add the current object to the list of +// PassRegistrationListeners... +PassRegistrationListener::PassRegistrationListener() { + if (!Listeners) Listeners = new std::vector(); + Listeners->push_back(this); +} + +// dtor - Remove object from list of listeners... +PassRegistrationListener::~PassRegistrationListener() { + std::vector::iterator I = + std::find(Listeners->begin(), Listeners->end(), this); + assert(Listeners && I != Listeners->end() && + "PassRegistrationListener not registered!"); + Listeners->erase(I); + + if (Listeners->empty()) { + delete Listeners; + Listeners = 0; + } +} + +// enumeratePasses - Iterate over the registered passes, calling the +// passEnumerate callback on each PassInfo object. +// +void PassRegistrationListener::enumeratePasses() { + if (PassInfoMap) + for (std::map::iterator I = PassInfoMap->begin(), + E = PassInfoMap->end(); I != E; ++I) + passEnumerate(I->second); +}