2003-10-13 05:33:01 +00:00
|
|
|
//===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// 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.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-01-21 07:37:31 +00:00
|
|
|
//
|
|
|
|
// This file implements the LLVM Pass infrastructure. It is primarily
|
|
|
|
// responsible with ensuring that passes are executed and batched together
|
|
|
|
// optimally.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-01-31 00:45:31 +00:00
|
|
|
#include "llvm/PassManager.h"
|
|
|
|
#include "llvm/Module.h"
|
2003-10-14 21:38:42 +00:00
|
|
|
#include "llvm/ModuleProvider.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2006-12-01 23:27:45 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/TypeInfo.h"
|
2007-03-05 00:00:42 +00:00
|
|
|
#include <algorithm>
|
2002-08-21 22:17:09 +00:00
|
|
|
#include <set>
|
2003-11-21 20:23:48 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2002-01-31 00:45:31 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pass Implementation
|
|
|
|
//
|
2002-01-23 05:49:41 +00:00
|
|
|
|
2006-12-22 22:49:00 +00:00
|
|
|
// Force out-of-line virtual method.
|
|
|
|
ModulePass::~ModulePass() { }
|
2002-01-21 07:37:31 +00:00
|
|
|
|
2003-03-21 21:41:02 +00:00
|
|
|
bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const {
|
2007-01-05 22:47:07 +00:00
|
|
|
return Resolver->getAnalysisToUpdate(AnalysisID, true) != 0;
|
2003-03-21 21:41:02 +00:00
|
|
|
}
|
|
|
|
|
2002-07-30 16:27:02 +00:00
|
|
|
// dumpPassStructure - Implement the -debug-passes=Structure option
|
|
|
|
void Pass::dumpPassStructure(unsigned Offset) {
|
2006-12-07 20:04:42 +00:00
|
|
|
cerr << std::string(Offset*2, ' ') << getPassName() << "\n";
|
2002-07-30 16:27:02 +00:00
|
|
|
}
|
2002-04-29 14:57:45 +00:00
|
|
|
|
2004-02-28 21:55:18 +00:00
|
|
|
// getPassName - Use C++ RTTI to get a SOMEWHAT intelligible name for the pass.
|
2002-04-29 14:57:45 +00:00
|
|
|
//
|
2002-07-29 21:02:31 +00:00
|
|
|
const char *Pass::getPassName() const {
|
|
|
|
if (const PassInfo *PI = getPassInfo())
|
|
|
|
return PI->getPassName();
|
|
|
|
return typeid(*this).name();
|
|
|
|
}
|
2002-04-29 14:57:45 +00:00
|
|
|
|
2003-10-14 21:38:42 +00:00
|
|
|
// print - Print out the internal state of the pass. This is called by Analyze
|
2003-08-18 14:43:39 +00:00
|
|
|
// to print out the contents of an analysis. Otherwise it is not necessary to
|
2002-07-27 01:12:17 +00:00
|
|
|
// implement this method.
|
|
|
|
//
|
2004-12-07 04:03:45 +00:00
|
|
|
void Pass::print(std::ostream &O,const Module*) const {
|
2002-07-27 01:12:17 +00:00
|
|
|
O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
|
|
|
|
}
|
|
|
|
|
2006-12-07 20:04:42 +00:00
|
|
|
// dump - call print(cerr);
|
2002-07-27 01:12:17 +00:00
|
|
|
void Pass::dump() const {
|
2006-12-07 20:04:42 +00:00
|
|
|
print(*cerr.stream(), 0);
|
2002-07-27 01:12:17 +00:00
|
|
|
}
|
|
|
|
|
2002-09-25 21:59:11 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ImmutablePass Implementation
|
|
|
|
//
|
2006-12-22 22:49:00 +00:00
|
|
|
// Force out-of-line virtual method.
|
|
|
|
ImmutablePass::~ImmutablePass() { }
|
2002-09-25 21:59:11 +00:00
|
|
|
|
2002-01-31 00:45:31 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-04-27 06:56:12 +00:00
|
|
|
// FunctionPass Implementation
|
2002-01-31 00:45:31 +00:00
|
|
|
//
|
2002-01-22 00:17:48 +00:00
|
|
|
|
2002-04-27 06:56:12 +00:00
|
|
|
// run - On a module, we run this pass by initializing, runOnFunction'ing once
|
|
|
|
// for every function in the module, then by finalizing.
|
2002-01-31 00:45:31 +00:00
|
|
|
//
|
2004-09-20 04:47:19 +00:00
|
|
|
bool FunctionPass::runOnModule(Module &M) {
|
2002-01-31 00:45:31 +00:00
|
|
|
bool Changed = doInitialization(M);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
|
2007-01-30 20:08:39 +00:00
|
|
|
if (!I->isDeclaration()) // Passes are not run on external functions!
|
2002-04-27 06:56:12 +00:00
|
|
|
Changed |= runOnFunction(*I);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-01-31 00:45:31 +00:00
|
|
|
return Changed | doFinalization(M);
|
|
|
|
}
|
2002-01-21 07:37:31 +00:00
|
|
|
|
2002-04-27 06:56:12 +00:00
|
|
|
// run - On a function, we simply initialize, run the function, then finalize.
|
2002-01-31 00:45:31 +00:00
|
|
|
//
|
2002-06-25 16:13:24 +00:00
|
|
|
bool FunctionPass::run(Function &F) {
|
2007-01-30 20:08:39 +00:00
|
|
|
if (F.isDeclaration()) return false;// Passes are not run on external functions!
|
2002-01-21 07:37:31 +00:00
|
|
|
|
2004-09-20 04:47:19 +00:00
|
|
|
bool Changed = doInitialization(*F.getParent());
|
|
|
|
Changed |= runOnFunction(F);
|
|
|
|
return Changed | doFinalization(*F.getParent());
|
2002-01-31 00:45:31 +00:00
|
|
|
}
|
2002-01-21 07:37:31 +00:00
|
|
|
|
2002-01-31 00:45:31 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// BasicBlockPass Implementation
|
|
|
|
//
|
2002-01-21 07:37:31 +00:00
|
|
|
|
2002-04-27 06:56:12 +00:00
|
|
|
// To run this pass on a function, we simply call runOnBasicBlock once for each
|
|
|
|
// function.
|
2002-01-21 07:37:31 +00:00
|
|
|
//
|
2002-06-25 16:13:24 +00:00
|
|
|
bool BasicBlockPass::runOnFunction(Function &F) {
|
2002-09-12 17:06:40 +00:00
|
|
|
bool Changed = doInitialization(F);
|
2002-06-25 16:13:24 +00:00
|
|
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
|
2002-01-31 00:45:31 +00:00
|
|
|
Changed |= runOnBasicBlock(*I);
|
2002-09-12 17:06:40 +00:00
|
|
|
return Changed | doFinalization(F);
|
2002-01-21 07:37:31 +00:00
|
|
|
}
|
|
|
|
|
2002-01-31 00:45:31 +00:00
|
|
|
// To run directly on the basic block, we initialize, runOnBasicBlock, then
|
|
|
|
// finalize.
|
|
|
|
//
|
2004-09-20 04:47:19 +00:00
|
|
|
bool BasicBlockPass::runPass(BasicBlock &BB) {
|
2002-09-12 17:06:40 +00:00
|
|
|
Function &F = *BB.getParent();
|
|
|
|
Module &M = *F.getParent();
|
2004-09-20 04:47:19 +00:00
|
|
|
bool Changed = doInitialization(M);
|
|
|
|
Changed |= doInitialization(F);
|
|
|
|
Changed |= runOnBasicBlock(BB);
|
|
|
|
Changed |= doFinalization(F);
|
|
|
|
Changed |= doFinalization(M);
|
|
|
|
return Changed;
|
2002-01-21 07:37:31 +00:00
|
|
|
}
|
2002-01-23 05:49:41 +00:00
|
|
|
|
2002-07-23 18:08:00 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pass Registration mechanism
|
|
|
|
//
|
2006-12-01 23:46:50 +00:00
|
|
|
namespace {
|
2006-12-01 23:27:45 +00:00
|
|
|
class PassRegistrar {
|
2006-12-01 23:46:50 +00:00
|
|
|
/// PassInfoMap - Keep track of the passinfo object for each registered llvm
|
|
|
|
/// pass.
|
2006-12-01 23:27:45 +00:00
|
|
|
std::map<TypeInfo, PassInfo*> PassInfoMap;
|
2006-12-01 23:46:50 +00:00
|
|
|
|
|
|
|
/// AnalysisGroupInfo - Keep track of information for each analysis group.
|
|
|
|
struct AnalysisGroupInfo {
|
|
|
|
const PassInfo *DefaultImpl;
|
|
|
|
std::set<const PassInfo *> Implementations;
|
|
|
|
AnalysisGroupInfo() : DefaultImpl(0) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// AnalysisGroupInfoMap - Information for each analysis group.
|
|
|
|
std::map<const PassInfo *, AnalysisGroupInfo> AnalysisGroupInfoMap;
|
|
|
|
|
2006-12-01 23:27:45 +00:00
|
|
|
public:
|
|
|
|
|
|
|
|
const PassInfo *GetPassInfo(const std::type_info &TI) const {
|
|
|
|
std::map<TypeInfo, PassInfo*>::const_iterator I = PassInfoMap.find(TI);
|
|
|
|
return I != PassInfoMap.end() ? I->second : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RegisterPass(PassInfo &PI) {
|
|
|
|
bool Inserted =
|
|
|
|
PassInfoMap.insert(std::make_pair(TypeInfo(PI.getTypeInfo()),&PI)).second;
|
|
|
|
assert(Inserted && "Pass registered multiple times!");
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnregisterPass(PassInfo &PI) {
|
|
|
|
std::map<TypeInfo, PassInfo*>::iterator I =
|
|
|
|
PassInfoMap.find(PI.getTypeInfo());
|
|
|
|
assert(I != PassInfoMap.end() && "Pass registered but not in map!");
|
|
|
|
|
|
|
|
// Remove pass from the map.
|
|
|
|
PassInfoMap.erase(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void EnumerateWith(PassRegistrationListener *L) {
|
|
|
|
for (std::map<TypeInfo, PassInfo*>::const_iterator I = PassInfoMap.begin(),
|
|
|
|
E = PassInfoMap.end(); I != E; ++I)
|
|
|
|
L->passEnumerate(I->second);
|
|
|
|
}
|
2006-12-01 23:46:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
/// Analysis Group Mechanisms.
|
|
|
|
void RegisterAnalysisGroup(PassInfo *InterfaceInfo,
|
|
|
|
const PassInfo *ImplementationInfo,
|
|
|
|
bool isDefault) {
|
|
|
|
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());
|
|
|
|
}
|
|
|
|
}
|
2006-12-01 23:27:45 +00:00
|
|
|
};
|
2006-12-01 23:46:50 +00:00
|
|
|
}
|
2006-12-01 23:27:45 +00:00
|
|
|
|
2002-07-23 18:08:00 +00:00
|
|
|
static std::vector<PassRegistrationListener*> *Listeners = 0;
|
|
|
|
|
2007-04-21 00:12:18 +00:00
|
|
|
// FIXME: This should use ManagedStatic to manage the pass registrar.
|
|
|
|
// Unfortunately, we can't do this, because passes are registered with static
|
|
|
|
// ctors, and having llvm_shutdown clear this map prevents successful
|
|
|
|
// ressurection after llvm_shutdown is run.
|
|
|
|
static PassRegistrar *getPassRegistrar() {
|
|
|
|
static PassRegistrar *PassRegistrarObj = 0;
|
|
|
|
if (!PassRegistrarObj)
|
|
|
|
PassRegistrarObj = new PassRegistrar();
|
|
|
|
return PassRegistrarObj;
|
|
|
|
}
|
|
|
|
|
2002-07-23 18:08:00 +00:00
|
|
|
// getPassInfo - Return the PassInfo data structure that corresponds to this
|
|
|
|
// pass...
|
|
|
|
const PassInfo *Pass::getPassInfo() const {
|
2002-07-29 21:02:31 +00:00
|
|
|
if (PassInfoCache) return PassInfoCache;
|
2002-08-21 17:08:37 +00:00
|
|
|
return lookupPassInfo(typeid(*this));
|
|
|
|
}
|
|
|
|
|
|
|
|
const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) {
|
2007-04-21 00:12:18 +00:00
|
|
|
return getPassRegistrar()->GetPassInfo(TI);
|
2002-07-23 18:08:00 +00:00
|
|
|
}
|
|
|
|
|
2006-01-23 01:01:04 +00:00
|
|
|
void RegisterPassBase::registerPass() {
|
2007-04-21 00:12:18 +00:00
|
|
|
getPassRegistrar()->RegisterPass(PIObj);
|
2002-07-23 18:08:00 +00:00
|
|
|
|
2006-12-01 23:27:45 +00:00
|
|
|
// Notify any listeners.
|
2002-07-23 18:08:00 +00:00
|
|
|
if (Listeners)
|
|
|
|
for (std::vector<PassRegistrationListener*>::iterator
|
|
|
|
I = Listeners->begin(), E = Listeners->end(); I != E; ++I)
|
2006-01-23 01:01:04 +00:00
|
|
|
(*I)->passRegistered(&PIObj);
|
2002-07-23 18:08:00 +00:00
|
|
|
}
|
|
|
|
|
2006-01-23 01:01:04 +00:00
|
|
|
void RegisterPassBase::unregisterPass() {
|
2007-04-21 00:12:18 +00:00
|
|
|
getPassRegistrar()->UnregisterPass(PIObj);
|
2002-07-23 18:08:00 +00:00
|
|
|
}
|
|
|
|
|
2002-08-21 22:17:09 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Analysis Group Implementation Code
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// RegisterAGBase implementation
|
|
|
|
//
|
|
|
|
RegisterAGBase::RegisterAGBase(const std::type_info &Interface,
|
|
|
|
const std::type_info *Pass, bool isDefault)
|
2006-08-27 22:21:55 +00:00
|
|
|
: RegisterPassBase(Interface),
|
2006-01-23 01:01:04 +00:00
|
|
|
ImplementationInfo(0), isDefaultImplementation(isDefault) {
|
2002-08-21 22:17:09 +00:00
|
|
|
|
|
|
|
InterfaceInfo = const_cast<PassInfo*>(Pass::lookupPassInfo(Interface));
|
2006-01-23 01:01:04 +00:00
|
|
|
if (InterfaceInfo == 0) {
|
|
|
|
// First reference to Interface, register it now.
|
|
|
|
registerPass();
|
|
|
|
InterfaceInfo = &PIObj;
|
2002-08-21 22:17:09 +00:00
|
|
|
}
|
2006-08-27 22:21:55 +00:00
|
|
|
assert(PIObj.isAnalysisGroup() &&
|
2002-08-21 22:17:09 +00:00
|
|
|
"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!");
|
|
|
|
|
2002-08-30 20:23:45 +00:00
|
|
|
// Make sure we keep track of the fact that the implementation implements
|
|
|
|
// the interface.
|
|
|
|
PassInfo *IIPI = const_cast<PassInfo*>(ImplementationInfo);
|
|
|
|
IIPI->addInterfaceImplemented(InterfaceInfo);
|
2006-12-01 23:46:50 +00:00
|
|
|
|
2007-04-21 00:12:18 +00:00
|
|
|
getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault);
|
2002-08-21 22:17:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RegisterAGBase::setGroupName(const char *Name) {
|
|
|
|
assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!");
|
|
|
|
InterfaceInfo->setPassName(Name);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-07-23 18:08:00 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PassRegistrationListener implementation
|
|
|
|
//
|
|
|
|
|
|
|
|
// PassRegistrationListener ctor - Add the current object to the list of
|
|
|
|
// PassRegistrationListeners...
|
|
|
|
PassRegistrationListener::PassRegistrationListener() {
|
|
|
|
if (!Listeners) Listeners = new std::vector<PassRegistrationListener*>();
|
|
|
|
Listeners->push_back(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
// dtor - Remove object from list of listeners...
|
|
|
|
PassRegistrationListener::~PassRegistrationListener() {
|
|
|
|
std::vector<PassRegistrationListener*>::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() {
|
2007-04-21 00:12:18 +00:00
|
|
|
getPassRegistrar()->EnumerateWith(this);
|
2002-07-23 18:08:00 +00:00
|
|
|
}
|
2005-04-25 01:01:35 +00:00
|
|
|
|
2006-12-01 22:21:11 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AnalysisUsage Class Implementation
|
|
|
|
//
|
|
|
|
|
2006-12-01 23:27:45 +00:00
|
|
|
namespace {
|
|
|
|
struct GetCFGOnlyPasses : public PassRegistrationListener {
|
|
|
|
std::vector<AnalysisID> &CFGOnlyList;
|
|
|
|
GetCFGOnlyPasses(std::vector<AnalysisID> &L) : CFGOnlyList(L) {}
|
|
|
|
|
|
|
|
void passEnumerate(const PassInfo *P) {
|
|
|
|
if (P->isCFGOnlyPass())
|
|
|
|
CFGOnlyList.push_back(P);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2006-12-01 22:21:11 +00:00
|
|
|
// setPreservesCFG - This function should be called to by the pass, iff they do
|
|
|
|
// not:
|
|
|
|
//
|
|
|
|
// 1. Add or remove basic blocks from the function
|
|
|
|
// 2. Modify terminator instructions in any way.
|
|
|
|
//
|
|
|
|
// This function annotates the AnalysisUsage info object to say that analyses
|
|
|
|
// that only depend on the CFG are preserved by this pass.
|
|
|
|
//
|
|
|
|
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...)
|
2006-12-01 23:27:45 +00:00
|
|
|
GetCFGOnlyPasses(Preserved).enumeratePasses();
|
2006-12-01 22:21:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|