//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_PASSMANAGERS_H
-#define LLVM_PASSMANAGERS_H
+#ifndef LLVM_IR_LEGACYPASSMANAGERS_H
+#define LLVM_IR_LEGACYPASSMANAGERS_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
//
// [o] class FunctionPassManager;
//
-// This is a external interface used by JIT to manage FunctionPasses. This
+// This is a external interface used to manage FunctionPasses. This
// interface relies on FunctionPassManagerImpl to do all the tasks.
//
// [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager,
Pass *P;
Value *V;
Module *M;
+
public:
explicit PassManagerPrettyStackEntry(Pass *p)
- : P(p), V(0), M(0) {} // When P is releaseMemory'd.
+ : P(p), V(nullptr), M(nullptr) {} // When P is releaseMemory'd.
PassManagerPrettyStackEntry(Pass *p, Value &v)
- : P(p), V(&v), M(0) {} // When P is run on V
+ : P(p), V(&v), M(nullptr) {} // When P is run on V
PassManagerPrettyStackEntry(Pass *p, Module &m)
- : P(p), V(0), M(&m) {} // When P is run on M
+ : P(p), V(nullptr), M(&m) {} // When P is run on M
/// print - Emit information about this stack frame to OS.
void print(raw_ostream &OS) const override;
};
-
//===----------------------------------------------------------------------===//
// PMStack
//
std::vector<PMDataManager *> S;
};
-
//===----------------------------------------------------------------------===//
// PMTopLevelManager
//
/// then return NULL.
Pass *findAnalysisPass(AnalysisID AID);
+ /// Retrieve the PassInfo for an analysis.
+ const PassInfo *findAnalysisPassInfo(AnalysisID AID) const;
+
/// Find analysis usage information for the pass P.
AnalysisUsage *findAnalysisUsage(Pass *P);
virtual ~PMTopLevelManager();
/// Add immutable pass and initialize it.
- inline void addImmutablePass(ImmutablePass *P) {
- P->initializePass();
- ImmutablePasses.push_back(P);
- }
+ void addImmutablePass(ImmutablePass *P);
inline SmallVectorImpl<ImmutablePass *>& getImmutablePasses() {
return ImmutablePasses;
PMStack activeStack;
protected:
-
/// Collection of pass managers
SmallVector<PMDataManager *, 8> PassManagers;
private:
-
/// Collection of pass managers that are not directly maintained
/// by this pass manager
SmallVector<PMDataManager *, 8> IndirectPassManagers;
DenseMap<Pass *, SmallPtrSet<Pass *, 8> > InversedLastUser;
/// Immutable passes are managed by top level manager.
- SmallVector<ImmutablePass *, 8> ImmutablePasses;
+ SmallVector<ImmutablePass *, 16> ImmutablePasses;
- DenseMap<Pass *, AnalysisUsage *> AnUsageMap;
-};
+ /// Map from ID to immutable passes.
+ SmallDenseMap<AnalysisID, ImmutablePass *, 8> ImmutablePassMap;
+ DenseMap<Pass *, AnalysisUsage *> AnUsageMap;
+ /// Collection of PassInfo objects found via analysis IDs and in this top
+ /// level manager. This is used to memoize queries to the pass registry.
+ /// FIXME: This is an egregious hack because querying the pass registry is
+ /// either slow or racy.
+ mutable DenseMap<AnalysisID, const PassInfo *> AnalysisPassInfos;
+};
//===----------------------------------------------------------------------===//
// PMDataManager
/// used by pass managers.
class PMDataManager {
public:
-
- explicit PMDataManager() : TPM(NULL), Depth(0) {
+ explicit PMDataManager() : TPM(nullptr), Depth(0) {
initializeAnalysisInfo();
}
void initializeAnalysisInfo() {
AvailableAnalysis.clear();
for (unsigned i = 0; i < PMT_Last; ++i)
- InheritedAnalysis[i] = NULL;
+ InheritedAnalysis[i] = nullptr;
}
// Return true if P preserves high level analysis used by other
// passes that are managed by this manager.
bool preserveHigherLevelAnalysis(Pass *P);
-
- /// Populate RequiredPasses with analysis pass that are required by
- /// pass P and are available. Populate ReqPassNotAvailable with analysis
- /// pass that are required by pass P but are not available.
- void collectRequiredAnalysis(SmallVectorImpl<Pass *> &RequiredPasses,
- SmallVectorImpl<AnalysisID> &ReqPassNotAvailable,
- Pass *P);
+ /// Populate UsedPasses with analysis pass that are used or required by pass
+ /// P and are available. Populate ReqPassNotAvailable with analysis pass that
+ /// are required by pass P but are not available.
+ void collectRequiredAndUsedAnalyses(
+ SmallVectorImpl<Pass *> &UsedPasses,
+ SmallVectorImpl<AnalysisID> &ReqPassNotAvailable, Pass *P);
/// All Required analyses should be available to the pass as it runs! Here
/// we fill in the AnalysisImpls member of the pass so that it can
enum PassDebuggingString S2, StringRef Msg);
void dumpRequiredSet(const Pass *P) const;
void dumpPreservedSet(const Pass *P) const;
+ void dumpUsedSet(const Pass *P) const;
unsigned getNumContainedPasses() const {
return (unsigned)PassVector.size();
}
protected:
-
// Top level manager.
PMTopLevelManager *TPM;
// Collection of higher level analysis used by the pass managed by
// this manager.
- SmallVector<Pass *, 8> HigherLevelAnalysis;
+ SmallVector<Pass *, 16> HigherLevelAnalysis;
unsigned Depth;
};
/// doFinalization - Overrides ModulePass doFinalization for global
/// finalization tasks
- ///
+ ///
using ModulePass::doFinalization;
-
+
/// doFinalization - Run all of the finalizers for the function passes.
///
bool doFinalization(Module &M) override;
Pass *getAsPass() override { return this; }
/// Pass Manager itself does not invalidate any analysis info.
- void getAnalysisUsage(AnalysisUsage &Info) const override{
+ void getAnalysisUsage(AnalysisUsage &Info) const override {
Info.setPreservesAll();
}
};
Timer *getPassTimer(Pass *);
-
}
#endif
projects / oota-llvm.git / blobdiff