X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPass.cpp;h=5079b4ea65eba147829be64ad571ffa4bbd4b3da;hb=551ccae044b0ff658fe629dd67edd5ffe75d10e8;hp=d0433c740b87141fc44c402be3722209bf168e30;hpb=64339f681a0bc29c21164fc6ea600794a9f49e4b;p=oota-llvm.git diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index d0433c740b8..5079b4ea65e 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -1,4 +1,11 @@ -//===- Pass.cpp - LLVM Pass Infrastructure Impementation ------------------===// +//===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // This file implements the LLVM Pass infrastructure. It is primarily // responsible with ensuring that passes are executed and batched together @@ -9,21 +16,29 @@ #include "llvm/PassManager.h" #include "PassManagerT.h" // PassManagerT implementation #include "llvm/Module.h" -#include "Support/STLExtras.h" -#include "Support/TypeInfo.h" -#include -#include -#include +#include "llvm/ModuleProvider.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/TypeInfo.h" +#include #include +using namespace llvm; + +// IncludeFile - Stub function used to help linking out. +IncludeFile::IncludeFile(void*) {} //===----------------------------------------------------------------------===// // AnalysisID Class Implementation // -static std::vector CFGOnlyAnalyses; +// getCFGOnlyAnalyses - A wrapper around the CFGOnlyAnalyses which make it +// initializer order independent. +static std::vector &getCFGOnlyAnalyses() { + static std::vector CFGOnlyAnalyses; + return CFGOnlyAnalyses; +} -void RegisterPassBase::setPreservesCFG() { - CFGOnlyAnalyses.push_back(PIObj); +void RegisterPassBase::setOnlyUsesCFG() { + getCFGOnlyAnalyses().push_back(PIObj); } //===----------------------------------------------------------------------===// @@ -39,7 +54,7 @@ void AnalysisResolver::setAnalysisResolver(Pass *P, AnalysisResolver *AR) { // AnalysisUsage Class Implementation // -// preservesCFG - This function should be called to by the pass, iff they do +// setPreservesCFG - This function should be called to by the pass, iff they do // not: // // 1. Add or remove basic blocks from the function @@ -48,12 +63,12 @@ void AnalysisResolver::setAnalysisResolver(Pass *P, AnalysisResolver *AR) { // This function annotates the AnalysisUsage info object to say that analyses // that only depend on the CFG are preserved by this pass. // -void AnalysisUsage::preservesCFG() { +void AnalysisUsage::setPreservesCFG() { // Since this transformation doesn't modify the CFG, it preserves all analyses // that only depend on the CFG (like dominators, loop info, etc...) // Preserved.insert(Preserved.end(), - CFGOnlyAnalyses.begin(), CFGOnlyAnalyses.end()); + getCFGOnlyAnalyses().begin(), getCFGOnlyAnalyses().end()); } @@ -66,153 +81,53 @@ PassManager::~PassManager() { delete PM; } void PassManager::add(Pass *P) { PM->add(P); } bool PassManager::run(Module &M) { return PM->run(M); } - //===----------------------------------------------------------------------===// -// TimingInfo Class - This class is used to calculate information about the -// amount of time each pass takes to execute. This only happens with -// -time-passes is enabled on the command line. +// FunctionPassManager implementation - The FunctionPassManager class +// is a simple Pimpl class that wraps the PassManagerT template. It +// is like PassManager, but only deals in FunctionPasses. // -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 +FunctionPassManager::FunctionPassManager(ModuleProvider *P) : + PM(new PassManagerT()), MP(P) {} +FunctionPassManager::~FunctionPassManager() { delete PM; } +void FunctionPassManager::add(FunctionPass *P) { PM->add(P); } +void FunctionPassManager::add(ImmutablePass *IP) { PM->add(IP); } +bool FunctionPassManager::run(Function &F) { + try { + MP->materializeFunction(&F); + } catch (std::string& errstr) { + std::cerr << "Error reading bytecode file: " << errstr << "\n"; + abort(); + } catch (...) { + std::cerr << "Error reading bytecode file!\n"; + abort(); } - - struct rusage RU; - struct timeval T; - gettimeofday(&T, 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"; + return PM->run(F); } -// Create method. If Timing is enabled, this creates and returns a new timing -// object, otherwise it returns null. +//===----------------------------------------------------------------------===// +// TimingInfo Class - This class is used to calculate information about the +// amount of time each pass takes to execute. This only happens with +// -time-passes is enabled on the command line. // -TimingInfo *TimingInfo::create() { - return EnableTiming ? new TimingInfo() : 0; -} - -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; - 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)); - Total.sum(I->second); - } - - // Sort the data by time as the primary key, in reverse order... - std::sort(Data.begin(), Data.end(), - std::greater >()); - - // Print out timing header... - 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---"; - - if (Total.MaxRSS) - std::cerr << " ---Mem---"; - std::cerr << " --- Pass Name ---\n"; +bool llvm::TimePassesIsEnabled = false; +static cl::opt +EnableTiming("time-passes", cl::location(TimePassesIsEnabled), + cl::desc("Time each pass, printing elapsed time for each on exit")); - // 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); +// createTheTimeInfo - This method either initializes the TheTimeInfo pointer to +// a non null value (if the -time-passes option is enabled) or it leaves it +// null. It may be called multiple times. +void TimingInfo::createTheTimeInfo() { + if (!TimePassesIsEnabled || TheTimeInfo) return; - Total.print("TOTAL", Total); + // Constructed the first time this is called, iff -time-passes is enabled. + // This guarantees that the object will be constructed before static globals, + // thus it will be destroyed before them. + static TimingInfo TTI; + TheTimeInfo = &TTI; } - void PMDebug::PrintArgumentInformation(const Pass *P) { // Print out passes in pass manager... if (const AnalysisResolver *PM = dynamic_cast(P)) { @@ -228,22 +143,31 @@ void PMDebug::PrintArgumentInformation(const Pass *P) { } void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, Annotable *V) { + Pass *P, Module *M) { if (PassDebugging >= Executions) { std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" << P->getPassName(); - if (V) { - std::cerr << "' on "; - - if (dynamic_cast(V)) { - std::cerr << "Module\n"; return; - } else if (Function *F = dynamic_cast(V)) - std::cerr << "Function '" << F->getName(); - else if (BasicBlock *BB = dynamic_cast(V)) - std::cerr << "BasicBlock '" << BB->getName(); - else if (Value *Val = dynamic_cast(V)) - std::cerr << typeid(*Val).name() << " '" << Val->getName(); - } + if (M) std::cerr << "' on Module '" << M->getModuleIdentifier() << "'\n"; + std::cerr << "'...\n"; + } +} + +void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, + Pass *P, Function *F) { + if (PassDebugging >= Executions) { + std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" + << P->getPassName(); + if (F) std::cerr << "' on Function '" << F->getName(); + std::cerr << "'...\n"; + } +} + +void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, + Pass *P, BasicBlock *BB) { + if (PassDebugging >= Executions) { + std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" + << P->getPassName(); + if (BB) std::cerr << "' on BasicBlock '" << BB->getName(); std::cerr << "'...\n"; } } @@ -252,8 +176,10 @@ void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg, Pass *P, const std::vector &Set){ if (PassDebugging >= Details && !Set.empty()) { std::cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:"; - for (unsigned i = 0; i != Set.size(); ++i) - std::cerr << " " << Set[i]->getPassName(); + for (unsigned i = 0; i != Set.size(); ++i) { + if (i) std::cerr << ","; + std::cerr << " " << Set[i]->getPassName(); + } std::cerr << "\n"; } } @@ -266,12 +192,16 @@ void Pass::addToPassManager(PassManagerT *PM, AnalysisUsage &AU) { PM->addPass(this, AU); } +bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const { + return Resolver->getAnalysisToUpdate(AnalysisID) != 0; +} + // 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. +// getPassName - Use C++ RTTI to get a SOMEWHAT intelligible name for the pass. // const char *Pass::getPassName() const { if (const PassInfo *PI = getPassInfo()) @@ -279,8 +209,8 @@ const char *Pass::getPassName() const { 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 +// print - Print out the internal state of the pass. This is called by Analyze +// to print out the contents of an analysis. Otherwise it is not necessary to // implement this method. // void Pass::print(std::ostream &O) const { @@ -292,6 +222,15 @@ void Pass::dump() const { print(std::cerr, 0); } +//===----------------------------------------------------------------------===// +// ImmutablePass Implementation +// +void ImmutablePass::addToPassManager(PassManagerT *PM, + AnalysisUsage &AU) { + PM->addPass(this, AU); +} + + //===----------------------------------------------------------------------===// // FunctionPass Implementation // @@ -336,18 +275,20 @@ void FunctionPass::addToPassManager(PassManagerT *PM, // function. // bool BasicBlockPass::runOnFunction(Function &F) { - bool Changed = false; + bool Changed = doInitialization(F); for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) Changed |= runOnBasicBlock(*I); - return Changed; + return Changed | doFinalization(F); } // To run directly on the basic block, we initialize, runOnBasicBlock, then // finalize. // bool BasicBlockPass::run(BasicBlock &BB) { - Module &M = *BB.getParent()->getParent(); - return doInitialization(M) | runOnBasicBlock(BB) | doFinalization(M); + Function &F = *BB.getParent(); + Module &M = *F.getParent(); + return doInitialization(M) | doInitialization(F) | runOnBasicBlock(BB) | + doFinalization(F) | doFinalization(M); } void BasicBlockPass::addToPassManager(PassManagerT *PM, @@ -452,6 +393,11 @@ RegisterAGBase::RegisterAGBase(const std::type_info &Interface, 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(); @@ -505,34 +451,6 @@ RegisterAGBase::~RegisterAGBase() { } -// findAnalysisGroupMember - Return an iterator pointing to one of the elements -// of Map if there is a pass in Map that is a member of the analysis group for -// the specified AnalysisGroupID. -// -static std::map::const_iterator -findAnalysisGroupMember(const PassInfo *AnalysisGroupID, - const std::map &Map) { - assert(AnalysisGroupID->getPassType() == PassInfo::AnalysisGroup && - "AnalysisGroupID is not an analysis group!"); - assert(AnalysisGroupInfoMap && AnalysisGroupInfoMap->count(AnalysisGroupID) && - "Analysis Group does not have any registered members!"); - - // Get the set of all known implementations of this analysis group... - std::set &Impls = - (*AnalysisGroupInfoMap)[AnalysisGroupID].Implementations; - - // Scan over available passes, checking to see if any is a valid analysis - for (std::map::const_iterator I = Map.begin(), - E = Map.end(); I != E; ++I) - if (Impls.count(I->first)) // This is a valid analysis, return it. - return I; - - return Map.end(); // Nothing of use found. -} - - - - //===----------------------------------------------------------------------===// // PassRegistrationListener implementation //