RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-24 20:29:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert r108794, "Separate PassInfo into two classes: a constructor-free

Browse Source 
superclass (StaticPassInfo) and a constructor-ful subclass (PassInfo).", it is
breaking teh everything.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@108805 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Dunbar 2010-07-20 03:06:07 +00:00
parent 8ba15cb709
commit e8a469cdb4
23 changed files with 135 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/llvm/Pass.h
View File

@ -41,7 +41,6 @@ class BasicBlock;
class Function;
class Module;
class AnalysisUsage;
class StaticPassInfo;
class PassInfo;
class ImmutablePass;
class PMStack;
@ -51,7 +50,7 @@ class raw_ostream;
class StringRef;
// AnalysisID - Use the PassInfo to identify a pass...
typedef const StaticPassInfo* AnalysisID;
typedef const PassInfo* AnalysisID;
/// Different types of internal pass managers. External pass managers
/// (PassManager and FunctionPassManager) are not represented here.
@ -105,7 +104,7 @@ public:
/// getPassInfo - Return the PassInfo data structure that corresponds to this
/// pass... If the pass has not been registered, this will return null.
///
const StaticPassInfo *getPassInfo() const;
const PassInfo *getPassInfo() const;
/// 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
@ -160,7 +159,7 @@ public:
/// an analysis interface through multiple inheritance. If needed, it should
/// override this to adjust the this pointer as needed for the specified pass
/// info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *);
virtual void *getAdjustedAnalysisPointer(const PassInfo *);
virtual ImmutablePass *getAsImmutablePass();
virtual PMDataManager *getAsPMDataManager();
@ -172,17 +171,17 @@ public:
virtual void dumpPassStructure(unsigned Offset = 0);
template<typename AnalysisClass>
static const StaticPassInfo *getClassPassInfo() {
static const PassInfo *getClassPassInfo() {
return lookupPassInfo(intptr_t(&AnalysisClass::ID));
}
// lookupPassInfo - Return the pass info object for the specified pass class,
// or null if it is not known.
static const StaticPassInfo *lookupPassInfo(intptr_t TI);
static const PassInfo *lookupPassInfo(intptr_t TI);
// lookupPassInfo - Return the pass info object for the pass with the given
// argument string, or null if it is not known.
static const StaticPassInfo *lookupPassInfo(StringRef Arg);
static const PassInfo *lookupPassInfo(StringRef Arg);
/// getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to
/// get analysis information that might be around, for example to update it.
@ -214,10 +213,10 @@ public:
AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
template<typename AnalysisType>
AnalysisType &getAnalysisID(const StaticPassInfo *PI) const;
AnalysisType &getAnalysisID(const PassInfo *PI) const;
template<typename AnalysisType>
AnalysisType &getAnalysisID(const StaticPassInfo *PI, Function &F);
AnalysisType &getAnalysisID(const PassInfo *PI, Function &F);
};

18
include/llvm/PassAnalysisSupport.h
View File

@ -86,7 +86,7 @@ public:
// linked in. Be careful about spelling!
//
AnalysisUsage &addPreserved(StringRef Arg) {
const StaticPassInfo *PI = Pass::lookupPassInfo(Arg);
const PassInfo *PI = Pass::lookupPassInfo(Arg);
// If the pass exists, preserve it. Otherwise silently do nothing.
if (PI) Preserved.push_back(PI);
return *this;
@ -130,7 +130,7 @@ public:
inline PMDataManager &getPMDataManager() { return PM; }
// Find pass that is implementing PI.
Pass *findImplPass(const StaticPassInfo *PI) {
Pass *findImplPass(const PassInfo *PI) {
Pass *ResultPass = 0;
for (unsigned i = 0; i < AnalysisImpls.size() ; ++i) {
if (AnalysisImpls[i].first == PI) {
@ -142,10 +142,10 @@ public:
}
// Find pass that is implementing PI. Initialize pass for Function F.
Pass *findImplPass(Pass *P, const StaticPassInfo *PI, Function &F);
Pass *findImplPass(Pass *P, const PassInfo *PI, Function &F);
void addAnalysisImplsPair(const StaticPassInfo *PI, Pass *P) {
std::pair<const StaticPassInfo*, Pass*> pir = std::make_pair(PI,P);
void addAnalysisImplsPair(const PassInfo *PI, Pass *P) {
std::pair<const PassInfo*, Pass*> pir = std::make_pair(PI,P);
AnalysisImpls.push_back(pir);
}
@ -160,7 +160,7 @@ public:
// AnalysisImpls - This keeps track of which passes implements the interfaces
// that are required by the current pass (to implement getAnalysis()).
std::vector<std::pair<const StaticPassInfo*, Pass*> > AnalysisImpls;
std::vector<std::pair<const PassInfo*, Pass*> > AnalysisImpls;
private:
// PassManager that is used to resolve analysis info
@ -179,7 +179,7 @@ template<typename AnalysisType>
AnalysisType *Pass::getAnalysisIfAvailable() const {
assert(Resolver && "Pass not resident in a PassManager object!");
const StaticPassInfo *PI = getClassPassInfo<AnalysisType>();
const PassInfo *PI = getClassPassInfo<AnalysisType>();
if (PI == 0) return 0;
Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
@ -203,7 +203,7 @@ AnalysisType &Pass::getAnalysis() const {
}
template<typename AnalysisType>
AnalysisType &Pass::getAnalysisID(const StaticPassInfo *PI) const {
AnalysisType &Pass::getAnalysisID(const PassInfo *PI) const {
assert(PI && "getAnalysis for unregistered pass!");
assert(Resolver&&"Pass has not been inserted into a PassManager object!");
// PI *must* appear in AnalysisImpls. Because the number of passes used
@ -233,7 +233,7 @@ AnalysisType &Pass::getAnalysis(Function &F) {
}
template<typename AnalysisType>
AnalysisType &Pass::getAnalysisID(const StaticPassInfo *PI, Function &F) {
AnalysisType &Pass::getAnalysisID(const PassInfo *PI, Function &F) {
assert(PI && "getAnalysis for unregistered pass!");
assert(Resolver && "Pass has not been inserted into a PassManager object!");
// PI *must* appear in AnalysisImpls. Because the number of passes used

2
include/llvm/PassManagers.h
View File

@ -302,7 +302,7 @@ public:
/// through getAnalysis interface.
virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass);
virtual Pass *getOnTheFlyPass(Pass *P, const StaticPassInfo *PI, Function &F);
virtual Pass *getOnTheFlyPass(Pass *P, const PassInfo *PI, Function &F);
/// Initialize available analysis information.
void initializeAnalysisInfo() {

90
include/llvm/PassSupport.h
View File

@ -22,7 +22,6 @@
#define LLVM_PASS_SUPPORT_H
#include "Pass.h"
#include "llvm/Config/config.h"
namespace llvm {
@ -34,24 +33,45 @@ class TargetMachine;
/// getPassInfo() method. These objects are set up by the RegisterPass<>
/// template, defined below.
///
struct StaticPassInfo {
class PassInfo {
public:
typedef Pass* (*NormalCtor_t)();
struct InterfaceInfo {
const StaticPassInfo *interface;
const PassInfo *interface;
const InterfaceInfo *next;
};
const char *PassName; // Nice name for Pass
const char *PassArgument; // Command Line argument to run this pass
intptr_t PassID;
bool IsCFGOnlyPass; // Pass only looks at the CFG.
bool IsAnalysis; // True if an analysis pass.
bool IsAnalysisGroup; // True if an analysis group.
InterfaceInfo *ItfImpl;// Interfaces implemented by this pass
private:
const char *const PassName; // Nice name for Pass
const char *const PassArgument; // Command Line argument to run this pass
const intptr_t PassID;
const bool IsCFGOnlyPass; // Pass only looks at the CFG.
const bool IsAnalysis; // True if an analysis pass.
const bool IsAnalysisGroup; // True if an analysis group.
const InterfaceInfo *ItfImpl;// Interfaces implemented by this pass
NormalCtor_t NormalCtor;
public:
/// PassInfo ctor - Do not call this directly, this should only be invoked
/// through RegisterPass.
PassInfo(const char *name, const char *arg, intptr_t pi,
NormalCtor_t normal = 0,
bool isCFGOnly = false, bool is_analysis = false)
: PassName(name), PassArgument(arg), PassID(pi),
IsCFGOnlyPass(isCFGOnly),
IsAnalysis(is_analysis), IsAnalysisGroup(false), NormalCtor(normal) {
registerPass();
}
/// PassInfo ctor - Do not call this directly, this should only be invoked
/// through RegisterPass. This version is for use by analysis groups; it
/// does not auto-register the pass.
PassInfo(const char *name, intptr_t pi)
: PassName(name), PassArgument(""), PassID(pi),
IsCFGOnlyPass(false),
IsAnalysis(false), IsAnalysisGroup(true), NormalCtor(0) {
}
/// getPassName - Return the friendly name for the pass, never returns null
///
const char *getPassName() const { return PassName; }
@ -70,7 +90,7 @@ struct StaticPassInfo {
bool isPassID(void *IDPtr) const {
return PassID == (intptr_t)IDPtr;
}
/// isAnalysisGroup - Return true if this is an analysis group, not a normal
/// pass.
///
@ -80,7 +100,7 @@ struct StaticPassInfo {
/// isCFGOnlyPass - return true if this pass only looks at the CFG for the
/// function.
bool isCFGOnlyPass() const { return IsCFGOnlyPass; }
/// getNormalCtor - Return a pointer to a function, that when called, creates
/// an instance of the pass and returns it. This pointer may be null if there
/// is no default constructor for the pass.
@ -92,11 +112,14 @@ struct StaticPassInfo {
NormalCtor = Ctor;
}
/// createPass() - Use this method to create an instance of this pass.
Pass *createPass() const;
/// addInterfaceImplemented - This method is called when this pass is
/// registered as a member of an analysis group with the RegisterAnalysisGroup
/// template.
///
void addInterfaceImplemented(const StaticPassInfo *ItfPI) {
void addInterfaceImplemented(const PassInfo *ItfPI) {
InterfaceInfo *NewInfo = new InterfaceInfo();
NewInfo->interface = ItfPI;
NewInfo->next = ItfImpl;
@ -110,39 +133,6 @@ struct StaticPassInfo {
return ItfImpl;
}
/// createPass() - Use this method to create an instance of this pass.
Pass *createPass() const;
};
class PassInfo : public StaticPassInfo {
public:
/// PassInfo ctor - Do not call this directly, this should only be invoked
/// through RegisterPass.
PassInfo(const char *name, const char *arg, intptr_t pi,
NormalCtor_t normal = 0,
bool isCFGOnly = false, bool is_analysis = false) {
this->PassName = name;
this->PassArgument = arg;
this->PassID = pi;
this->IsCFGOnlyPass = isCFGOnly;
this->IsAnalysis = is_analysis;
this->IsAnalysisGroup = false;
this->NormalCtor = normal;
registerPass();
}
/// PassInfo ctor - Do not call this directly, this should only be invoked
/// through RegisterPass. This version is for use by analysis groups; it
/// does not auto-register the pass.
PassInfo(const char *name, intptr_t pi) {
this->PassName = name;
this->PassArgument = "";
this->PassID = pi;
this->IsCFGOnlyPass = false;
this->IsAnalysis = false;
this->IsAnalysisGroup = true;
this->NormalCtor = 0;
}
protected:
void registerPass();
void unregisterPass();
@ -250,7 +240,7 @@ struct PassRegistrationListener {
/// Callback functions - These functions are invoked whenever a pass is loaded
/// or removed from the current executable.
///
virtual void passRegistered(const StaticPassInfo *) {}
virtual void passRegistered(const PassInfo *) {}
/// enumeratePasses - Iterate over the registered passes, calling the
/// passEnumerate callback on each PassInfo object.
@ -260,7 +250,7 @@ struct PassRegistrationListener {
/// passEnumerate - Callback function invoked when someone calls
/// enumeratePasses on this PassRegistrationListener object.
///
virtual void passEnumerate(const StaticPassInfo *) {}
virtual void passEnumerate(const PassInfo *) {}
};

12
include/llvm/Support/PassNameParser.h
View File

@ -55,11 +55,9 @@ public:
// ignorablePassImpl - Can be overriden in subclasses to refine the list of
// which passes we want to include.
//
virtual bool ignorablePassImpl(const StaticPassInfo *P) const {
return false;
}
virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
inline bool ignorablePass(const StaticPassInfo *P) const {
inline bool ignorablePass(const PassInfo *P) const {
// Ignore non-selectable and non-constructible passes! Ignore
// non-optimizations.
return P->getPassArgument() == 0 || *P->getPassArgument() == 0 ||
@ -68,7 +66,7 @@ public:
// Implement the PassRegistrationListener callbacks used to populate our map
//
virtual void passRegistered(const StaticPassInfo *P) {
virtual void passRegistered(const PassInfo *P) {
if (ignorablePass(P) || !Opt) return;
if (findOption(P->getPassArgument()) != getNumOptions()) {
errs() << "Two passes with the same argument (-"
@ -77,7 +75,7 @@ public:
}
addLiteralOption(P->getPassArgument(), P, P->getPassName());
}
virtual void passEnumerate(const StaticPassInfo *P) { passRegistered(P); }
virtual void passEnumerate(const PassInfo *P) { passRegistered(P); }
// ValLessThan - Provide a sorting comparator for Values elements...
typedef std::pair<const char*,
@ -107,7 +105,7 @@ private:
Filter filter;
public:
bool ignorablePassImpl(const StaticPassInfo *P) const { return !filter(*P); }
bool ignorablePassImpl(const PassInfo *P) const { return !filter(*P); }
};
///===----------------------------------------------------------------------===//

2
lib/Analysis/AliasAnalysisCounter.cpp
View File

@ -87,7 +87,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it
/// should override this to adjust the this pointer as needed for the
/// specified pass info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&AliasAnalysis::ID))
return (AliasAnalysis*)this;
return this;

2
lib/Analysis/AliasDebugger.cpp
View File

@ -83,7 +83,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it
/// should override this to adjust the this pointer as needed for the
/// specified pass info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&AliasAnalysis::ID))
return (AliasAnalysis*)this;
return this;

4
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -172,7 +172,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it should
/// override this to adjust the this pointer as needed for the specified pass
/// info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&AliasAnalysis::ID))
return (AliasAnalysis*)this;
return this;
@ -243,7 +243,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it should
/// override this to adjust the this pointer as needed for the specified pass
/// info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&AliasAnalysis::ID))
return (AliasAnalysis*)this;
return this;

2
lib/Analysis/IPA/CallGraph.cpp
View File

@ -86,7 +86,7 @@ public:
/// an analysis interface through multiple inheritance. If needed, it should
/// override this to adjust the this pointer as needed for the specified pass
/// info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&CallGraph::ID))
return (CallGraph*)this;
return this;

2
lib/Analysis/IPA/GlobalsModRef.cpp
View File

@ -149,7 +149,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it
/// should override this to adjust the this pointer as needed for the
/// specified pass info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&AliasAnalysis::ID))
return (AliasAnalysis*)this;
return this;

2
lib/Analysis/ProfileEstimatorPass.cpp
View File

@ -59,7 +59,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it
/// should override this to adjust the this pointer as needed for the
/// specified pass info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&ProfileInfo::ID))
return (ProfileInfo*)this;
return this;

2
lib/Analysis/ProfileInfoLoaderPass.cpp
View File

@ -67,7 +67,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it
/// should override this to adjust the this pointer as needed for the
/// specified pass info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&ProfileInfo::ID))
return (ProfileInfo*)this;
return this;

2
lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
View File

@ -40,7 +40,7 @@ namespace {
/// an analysis interface through multiple inheritance. If needed, it
/// should override this to adjust the this pointer as needed for the
/// specified pass info.
virtual void *getAdjustedAnalysisPointer(const StaticPassInfo *PI) {
virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
if (PI->isPassID(&AliasAnalysis::ID))
return (AliasAnalysis*)this;
return this;

42
lib/VMCore/Pass.cpp
View File

@ -75,7 +75,7 @@ void Pass::dumpPassStructure(unsigned Offset) {
/// Registration templates, but can be overloaded directly.
///
const char *Pass::getPassName() const {
if (const StaticPassInfo *PI = getPassInfo())
if (const PassInfo *PI = getPassInfo())
return PI->getPassName();
return "Unnamed pass: implement Pass::getPassName()";
}
@ -101,7 +101,7 @@ void Pass::verifyAnalysis() const {
// By default, don't do anything.
}
void *Pass::getAdjustedAnalysisPointer(const StaticPassInfo *) {
void *Pass::getAdjustedAnalysisPointer(const PassInfo *) {
return this;
}
@ -243,35 +243,35 @@ class PassRegistrar {
/// PassInfoMap - Keep track of the passinfo object for each registered llvm
/// pass.
typedef std::map<intptr_t, const StaticPassInfo*> MapType;
typedef std::map<intptr_t, const PassInfo*> MapType;
MapType PassInfoMap;
typedef StringMap<const StaticPassInfo*> StringMapType;
typedef StringMap<const PassInfo*> StringMapType;
StringMapType PassInfoStringMap;
/// AnalysisGroupInfo - Keep track of information for each analysis group.
struct AnalysisGroupInfo {
std::set<const StaticPassInfo *> Implementations;
std::set<const PassInfo *> Implementations;
};
/// AnalysisGroupInfoMap - Information for each analysis group.
std::map<const StaticPassInfo *, AnalysisGroupInfo> AnalysisGroupInfoMap;
std::map<const PassInfo *, AnalysisGroupInfo> AnalysisGroupInfoMap;
public:
const StaticPassInfo *GetPassInfo(intptr_t TI) const {
const PassInfo *GetPassInfo(intptr_t TI) const {
sys::SmartScopedLock<true> Guard(Lock);
MapType::const_iterator I = PassInfoMap.find(TI);
return I != PassInfoMap.end() ? I->second : 0;
}
const StaticPassInfo *GetPassInfo(StringRef Arg) const {
const PassInfo *GetPassInfo(StringRef Arg) const {
sys::SmartScopedLock<true> Guard(Lock);
StringMapType::const_iterator I = PassInfoStringMap.find(Arg);
return I != PassInfoStringMap.end() ? I->second : 0;
}
void RegisterPass(const StaticPassInfo &PI) {
void RegisterPass(const PassInfo &PI) {
sys::SmartScopedLock<true> Guard(Lock);
bool Inserted =
PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second;
@ -279,7 +279,7 @@ public:
PassInfoStringMap[PI.getPassArgument()] = &PI;
}
void UnregisterPass(const StaticPassInfo &PI) {
void UnregisterPass(const PassInfo &PI) {
sys::SmartScopedLock<true> Guard(Lock);
MapType::iterator I = PassInfoMap.find(PI.getTypeInfo());
assert(I != PassInfoMap.end() && "Pass registered but not in map!");
@ -298,8 +298,8 @@ public:
/// Analysis Group Mechanisms.
void RegisterAnalysisGroup(StaticPassInfo *InterfaceInfo,
const StaticPassInfo *ImplementationInfo,
void RegisterAnalysisGroup(PassInfo *InterfaceInfo,
const PassInfo *ImplementationInfo,
bool isDefault) {
sys::SmartScopedLock<true> Guard(Lock);
AnalysisGroupInfo &AGI = AnalysisGroupInfoMap[InterfaceInfo];
@ -363,15 +363,15 @@ ManagedCleanup<&cleanupPassRegistrar> registrarCleanup ATTRIBUTE_USED;
// getPassInfo - Return the PassInfo data structure that corresponds to this
// pass...
const StaticPassInfo *Pass::getPassInfo() const {
const PassInfo *Pass::getPassInfo() const {
return lookupPassInfo(PassID);
}
const StaticPassInfo *Pass::lookupPassInfo(intptr_t TI) {
const PassInfo *Pass::lookupPassInfo(intptr_t TI) {
return getPassRegistrar()->GetPassInfo(TI);
}
const StaticPassInfo *Pass::lookupPassInfo(StringRef Arg) {
const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
return getPassRegistrar()->GetPassInfo(Arg);
}
@ -390,7 +390,7 @@ void PassInfo::unregisterPass() {
getPassRegistrar()->UnregisterPass(*this);
}
Pass *StaticPassInfo::createPass() const {
Pass *PassInfo::createPass() const {
assert((!isAnalysisGroup() || NormalCtor) &&
"No default implementation found for analysis group!");
assert(NormalCtor &&
@ -408,8 +408,8 @@ RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID,
intptr_t PassID, bool isDefault)
: PassInfo(Name, InterfaceID) {
StaticPassInfo *InterfaceInfo =
const_cast<StaticPassInfo*>(Pass::lookupPassInfo(InterfaceID));
PassInfo *InterfaceInfo =
const_cast<PassInfo*>(Pass::lookupPassInfo(InterfaceID));
if (InterfaceInfo == 0) {
// First reference to Interface, register it now.
registerPass();
@ -419,13 +419,13 @@ RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID,
"Trying to join an analysis group that is a normal pass!");
if (PassID) {
const StaticPassInfo *ImplementationInfo = Pass::lookupPassInfo(PassID);
const PassInfo *ImplementationInfo = Pass::lookupPassInfo(PassID);
assert(ImplementationInfo &&
"Must register pass before adding to AnalysisGroup!");
// Make sure we keep track of the fact that the implementation implements
// the interface.
StaticPassInfo *IIPI = const_cast<StaticPassInfo*>(ImplementationInfo);
PassInfo *IIPI = const_cast<PassInfo*>(ImplementationInfo);
IIPI->addInterfaceImplemented(InterfaceInfo);
getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault);
@ -479,7 +479,7 @@ namespace {
VectorType &CFGOnlyList;
GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
void passEnumerate(const StaticPassInfo *P) {
void passEnumerate(const PassInfo *P) {
if (P->isCFGOnlyPass())
CFGOnlyList.push_back(P);
}

19
lib/VMCore/PassManager.cpp
View File

@ -332,8 +332,7 @@ public:
/// Return function pass corresponding to PassInfo PI, that is
/// required by module pass MP. Instantiate analysis pass, by using
/// its runOnFunction() for function F.
virtual Pass* getOnTheFlyPass(Pass *MP, const StaticPassInfo *PI,
Function &F);
virtual Pass* getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F);
virtual const char *getPassName() const {
return "Module Pass Manager";
@ -633,7 +632,7 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) {
for (SmallVector<ImmutablePass *, 8>::iterator I = ImmutablePasses.begin(),
E = ImmutablePasses.end(); P == NULL && I != E; ++I) {
const StaticPassInfo *PI = (*I)->getPassInfo();
const PassInfo *PI = (*I)->getPassInfo();
if (PI == AID)
P = *I;
@ -729,7 +728,7 @@ PMTopLevelManager::~PMTopLevelManager() {
/// Augement AvailableAnalysis by adding analysis made available by pass P.
void PMDataManager::recordAvailableAnalysis(Pass *P) {
const StaticPassInfo *PI = P->getPassInfo();
const PassInfo *PI = P->getPassInfo();
if (PI == 0) return;
AvailableAnalysis[PI] = P;
@ -868,7 +867,7 @@ void PMDataManager::freePass(Pass *P, StringRef Msg,
P->releaseMemory();
}
if (const StaticPassInfo *PI = P->getPassInfo()) {
if (const PassInfo *PI = P->getPassInfo()) {
// Remove the pass itself (if it is not already removed).
AvailableAnalysis.erase(PI);
@ -1052,7 +1051,7 @@ void PMDataManager::dumpPassArguments() const {
if (PMDataManager *PMD = (*I)->getAsPMDataManager())
PMD->dumpPassArguments();
else
if (const StaticPassInfo *PI = (*I)->getPassInfo())
if (const PassInfo *PI = (*I)->getPassInfo())
if (!PI->isAnalysisGroup())
dbgs() << " -" << PI->getPassArgument();
}
@ -1155,8 +1154,7 @@ void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
llvm_unreachable("Unable to schedule pass");
}
Pass *PMDataManager::getOnTheFlyPass(Pass *P, const StaticPassInfo *PI,
Function &F) {
Pass *PMDataManager::getOnTheFlyPass(Pass *P, const PassInfo *PI, Function &F) {
assert(0 && "Unable to find on the fly pass");
return NULL;
}
@ -1175,7 +1173,7 @@ Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID, bool dir) const {
return PM.findAnalysisPass(ID, dir);
}
Pass *AnalysisResolver::findImplPass(Pass *P, const StaticPassInfo *AnalysisPI,
Pass *AnalysisResolver::findImplPass(Pass *P, const PassInfo *AnalysisPI,
Function &F) {
return PM.getOnTheFlyPass(P, AnalysisPI, F);
}
@ -1570,8 +1568,7 @@ void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) {
/// Return function pass corresponding to PassInfo PI, that is
/// required by module pass MP. Instantiate analysis pass, by using
/// its runOnFunction() for function F.
Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const StaticPassInfo *PI,
Function &F){
Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F){
FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
assert(FPP && "Unable to find on the fly pass");

3
tools/bugpoint/BugDriver.cpp
View File

@ -56,8 +56,7 @@ void BugDriver::setNewProgram(Module *M) {
/// getPassesString - Turn a list of passes into a string which indicates the
/// command line options that must be passed to add the passes.
///
std::string
llvm::getPassesString(const std::vector<const StaticPassInfo*> &Passes) {
std::string llvm::getPassesString(const std::vector<const PassInfo*> &Passes) {
std::string Result;
for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
if (i) Result += " ";

23
tools/bugpoint/BugDriver.h
View File

@ -23,7 +23,7 @@
namespace llvm {
class Value;
class StaticPassInfo;
class PassInfo;
class Module;
class GlobalVariable;
class Function;
@ -47,7 +47,7 @@ class BugDriver {
const char *ToolName; // argv[0] of bugpoint
std::string ReferenceOutputFile; // Name of `good' output file
Module *Program; // The raw program, linked together
std::vector<const StaticPassInfo*> PassesToRun;
std::vector<const PassInfo*> PassesToRun;
AbstractInterpreter *Interpreter; // How to run the program
AbstractInterpreter *SafeInterpreter; // To generate reference output, etc.
GCC *gcc;
@ -77,10 +77,10 @@ public:
bool addSources(const std::vector<std::string> &FileNames);
template<class It>
void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
void setPassesToRun(const std::vector<const StaticPassInfo*> &PTR) {
void setPassesToRun(const std::vector<const PassInfo*> &PTR) {
PassesToRun = PTR;
}
const std::vector<const StaticPassInfo*> &getPassesToRun() const {
const std::vector<const PassInfo*> &getPassesToRun() const {
return PassesToRun;
}
@ -112,7 +112,7 @@ public:
/// ReferenceOutput contains the filename of the file containing the output we
/// are to match.
///
bool debugPassMiscompilation(const StaticPassInfo *ThePass,
bool debugPassMiscompilation(const PassInfo *ThePass,
const std::string &ReferenceOutput);
/// compileSharedObject - This method creates a SharedObject from a given
@ -243,8 +243,7 @@ public:
/// failure. If AutoDebugCrashes is set to true, then bugpoint will
/// automatically attempt to track down a crashing pass if one exists, and
/// this method will never return null.
Module *runPassesOn(Module *M,
const std::vector<const StaticPassInfo*> &Passes,
Module *runPassesOn(Module *M, const std::vector<const PassInfo*> &Passes,
bool AutoDebugCrashes = false, unsigned NumExtraArgs = 0,
const char * const *ExtraArgs = NULL);
@ -257,7 +256,7 @@ public:
/// or failed, unless Quiet is set. ExtraArgs specifies additional arguments
/// to pass to the child bugpoint instance.
///
bool runPasses(const std::vector<const StaticPassInfo*> &PassesToRun,
bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
std::string &OutputFilename, bool DeleteOutput = false,
bool Quiet = false, unsigned NumExtraArgs = 0,
const char * const *ExtraArgs = NULL) const;
@ -269,7 +268,7 @@ public:
/// If the passes did not compile correctly, output the command required to
/// recreate the failure. This returns true if a compiler error is found.
///
bool runManyPasses(const std::vector<const StaticPassInfo*> &AllPasses,
bool runManyPasses(const std::vector<const PassInfo*> &AllPasses,
std::string &ErrMsg);
/// writeProgramToFile - This writes the current "Program" to the named
@ -282,14 +281,14 @@ private:
/// false indicating whether or not the optimizer crashed on the specified
/// input (true = crashed).
///
bool runPasses(const std::vector<const StaticPassInfo*> &PassesToRun,
bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
bool DeleteOutput = true) const {
std::string Filename;
return runPasses(PassesToRun, Filename, DeleteOutput);
}
/// runAsChild - The actual "runPasses" guts that runs in a child process.
int runPassesAsChild(const std::vector<const StaticPassInfo*> &PassesToRun);
int runPassesAsChild(const std::vector<const PassInfo*> &PassesToRun);
/// initializeExecutionEnvironment - This method is used to set up the
/// environment for executing LLVM programs.
@ -307,7 +306,7 @@ Module *ParseInputFile(const std::string &InputFilename,
/// getPassesString - Turn a list of passes into a string which indicates the
/// command line options that must be passed to add the passes.
///
std::string getPassesString(const std::vector<const StaticPassInfo*> &Passes);
std::string getPassesString(const std::vector<const PassInfo*> &Passes);
/// PrintFunctionList - prints out list of problematic functions
///

10
tools/bugpoint/CrashDebugger.cpp
View File

@ -43,7 +43,7 @@ namespace {
}
namespace llvm {
class ReducePassList : public ListReducer<const StaticPassInfo*> {
class ReducePassList : public ListReducer<const PassInfo*> {
BugDriver &BD;
public:
ReducePassList(BugDriver &bd) : BD(bd) {}
@ -52,15 +52,15 @@ namespace llvm {
// running the "Kept" passes fail when run on the output of the "removed"
// passes. If we return true, we update the current module of bugpoint.
//
virtual TestResult doTest(std::vector<const StaticPassInfo*> &Removed,
std::vector<const StaticPassInfo*> &Kept,
virtual TestResult doTest(std::vector<const PassInfo*> &Removed,
std::vector<const PassInfo*> &Kept,
std::string &Error);
};
}
ReducePassList::TestResult
ReducePassList::doTest(std::vector<const StaticPassInfo*> &Prefix,
std::vector<const StaticPassInfo*> &Suffix,
ReducePassList::doTest(std::vector<const PassInfo*> &Prefix,
std::vector<const PassInfo*> &Suffix,
std::string &Error) {
sys::Path PrefixOutput;
Module *OrigProgram = 0;

10
tools/bugpoint/ExtractFunction.cpp
View File

@ -99,8 +99,8 @@ Module *BugDriver::deleteInstructionFromProgram(const Instruction *I,
return Result;
}
static const StaticPassInfo *getPI(Pass *P) {
const StaticPassInfo *PI = P->getPassInfo();
static const PassInfo *getPI(Pass *P) {
const PassInfo *PI = P->getPassInfo();
delete P;
return PI;
}
@ -114,7 +114,7 @@ Module *BugDriver::performFinalCleanups(Module *M, bool MayModifySemantics) {
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
I->setLinkage(GlobalValue::ExternalLinkage);
std::vector<const StaticPassInfo*> CleanupPasses;
std::vector<const PassInfo*> CleanupPasses;
CleanupPasses.push_back(getPI(createGlobalDCEPass()));
if (MayModifySemantics)
@ -138,7 +138,7 @@ Module *BugDriver::performFinalCleanups(Module *M, bool MayModifySemantics) {
/// function. This returns null if there are no extractable loops in the
/// program or if the loop extractor crashes.
Module *BugDriver::ExtractLoop(Module *M) {
std::vector<const StaticPassInfo*> LoopExtractPasses;
std::vector<const PassInfo*> LoopExtractPasses;
LoopExtractPasses.push_back(getPI(createSingleLoopExtractorPass()));
Module *NewM = runPassesOn(M, LoopExtractPasses);
@ -359,7 +359,7 @@ Module *BugDriver::ExtractMappedBlocksFromModule(const
std::string uniqueFN = "--extract-blocks-file=" + uniqueFilename.str();
const char *ExtraArg = uniqueFN.c_str();
std::vector<const StaticPassInfo*> PI;
std::vector<const PassInfo*> PI;
std::vector<BasicBlock *> EmptyBBs; // This parameter is ignored.
PI.push_back(getPI(createBlockExtractorPass(EmptyBBs)));
Module *Ret = runPassesOn(M, PI, false, 1, &ExtraArg);

3
tools/bugpoint/FindBugs.cpp
View File

@ -29,8 +29,7 @@ using namespace llvm;
/// If the passes did not compile correctly, output the command required to
/// recreate the failure. This returns true if a compiler error is found.
///
bool
BugDriver::runManyPasses(const std::vector<const StaticPassInfo*> &AllPasses,
bool BugDriver::runManyPasses(const std::vector<const PassInfo*> &AllPasses,
std::string &ErrMsg) {
setPassesToRun(AllPasses);
outs() << "Starting bug finding procedure...\n\n";

10
tools/bugpoint/Miscompilation.cpp
View File

@ -43,13 +43,13 @@ namespace {
cl::desc("Don't extract blocks when searching for miscompilations"),
cl::init(false));
class ReduceMiscompilingPasses : public ListReducer<const StaticPassInfo*> {
class ReduceMiscompilingPasses : public ListReducer<const PassInfo*> {
BugDriver &BD;
public:
ReduceMiscompilingPasses(BugDriver &bd) : BD(bd) {}
virtual TestResult doTest(std::vector<const StaticPassInfo*> &Prefix,
std::vector<const StaticPassInfo*> &Suffix,
virtual TestResult doTest(std::vector<const PassInfo*> &Prefix,
std::vector<const PassInfo*> &Suffix,
std::string &Error);
};
}
@ -58,8 +58,8 @@ namespace {
/// group, see if they still break the program.
///
ReduceMiscompilingPasses::TestResult
ReduceMiscompilingPasses::doTest(std::vector<const StaticPassInfo*> &Prefix,
std::vector<const StaticPassInfo*> &Suffix,
ReduceMiscompilingPasses::doTest(std::vector<const PassInfo*> &Prefix,
std::vector<const PassInfo*> &Suffix,
std::string &Error) {
// First, run the program with just the Suffix passes. If it is still broken
// with JUST the kept passes, discard the prefix passes.

8
tools/bugpoint/OptimizerDriver.cpp
View File

@ -83,7 +83,7 @@ void BugDriver::EmitProgressBitcode(const std::string &ID, bool NoFlyer) {
outs() << getPassesString(PassesToRun) << "\n";
}
int BugDriver::runPassesAsChild(const std::vector<const StaticPassInfo*> &Passes) {
int BugDriver::runPassesAsChild(const std::vector<const PassInfo*> &Passes) {
std::string ErrInfo;
raw_fd_ostream OutFile(ChildOutput.c_str(), ErrInfo,
raw_fd_ostream::F_Binary);
@ -124,7 +124,7 @@ cl::opt<bool> SilencePasses("silence-passes", cl::desc("Suppress output of runni
/// outs() a single line message indicating whether compilation was successful
/// or failed.
///
bool BugDriver::runPasses(const std::vector<const StaticPassInfo*> &Passes,
bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
std::string &OutputFilename, bool DeleteOutput,
bool Quiet, unsigned NumExtraArgs,
const char * const *ExtraArgs) const {
@ -178,7 +178,7 @@ bool BugDriver::runPasses(const std::vector<const StaticPassInfo*> &Passes,
pass_args.push_back( std::string("-load"));
pass_args.push_back( PluginLoader::getPlugin(i));
}
for (std::vector<const StaticPassInfo*>::const_iterator I = Passes.begin(),
for (std::vector<const PassInfo*>::const_iterator I = Passes.begin(),
E = Passes.end(); I != E; ++I )
pass_args.push_back( std::string("-") + (*I)->getPassArgument() );
for (std::vector<std::string>::const_iterator I = pass_args.begin(),
@ -235,7 +235,7 @@ bool BugDriver::runPasses(const std::vector<const StaticPassInfo*> &Passes,
/// module, returning the transformed module on success, or a null pointer on
/// failure.
Module *BugDriver::runPassesOn(Module *M,
const std::vector<const StaticPassInfo*> &Passes,
const std::vector<const PassInfo*> &Passes,
bool AutoDebugCrashes, unsigned NumExtraArgs,
const char * const *ExtraArgs) {
Module *OldProgram = swapProgramIn(M);

4
tools/bugpoint/bugpoint.cpp
View File

@ -61,7 +61,7 @@ UseValgrind("enable-valgrind",
// The AnalysesList is automatically populated with registered Passes by the
// PassNameParser.
//
static cl::list<const StaticPassInfo*, bool, PassNameParser>
static cl::list<const PassInfo*, bool, PassNameParser>
PassList(cl::desc("Passes available:"), cl::ZeroOrMore);
static cl::opt<bool>
@ -90,7 +90,7 @@ namespace {
AddToDriver(BugDriver &_D) : D(_D) {}
virtual void add(Pass *P) {
const StaticPassInfo *PI = P->getPassInfo();
const PassInfo *PI = P->getPassInfo();
D.addPasses(&PI, &PI + 1);
}
};