private:
friend AnalysisInfoMixin<AAManager>;
- static char PassID;
+ static AnalysisKey Key;
SmallVector<void (*)(Function &F, FunctionAnalysisManager &AM,
AAResults &AAResults),
/// assumption caches for a given function.
class AssumptionAnalysis : public AnalysisInfoMixin<AssumptionAnalysis> {
friend AnalysisInfoMixin<AssumptionAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef AssumptionCache Result;
/// Analysis pass providing a never-invalidated alias analysis result.
class BasicAA : public AnalysisInfoMixin<BasicAA> {
friend AnalysisInfoMixin<BasicAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef BasicAAResult Result;
class BlockFrequencyAnalysis
: public AnalysisInfoMixin<BlockFrequencyAnalysis> {
friend AnalysisInfoMixin<BlockFrequencyAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
class BranchProbabilityAnalysis
: public AnalysisInfoMixin<BranchProbabilityAnalysis> {
friend AnalysisInfoMixin<BranchProbabilityAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
/// in particular to leverage invalidation to trigger re-computation.
class CFLAndersAA : public AnalysisInfoMixin<CFLAndersAA> {
friend AnalysisInfoMixin<CFLAndersAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef CFLAndersAAResult Result;
/// in particular to leverage invalidation to trigger re-computation of sets.
class CFLSteensAA : public AnalysisInfoMixin<CFLSteensAA> {
friend AnalysisInfoMixin<CFLSteensAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef CFLSteensAAResult Result;
/// resulting data.
class CallGraphAnalysis : public AnalysisInfoMixin<CallGraphAnalysis> {
friend AnalysisInfoMixin<CallGraphAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief A formulaic typedef to inform clients of the result type.
/// An analysis that produces \c DemandedBits for a function.
class DemandedBitsAnalysis : public AnalysisInfoMixin<DemandedBitsAnalysis> {
friend AnalysisInfoMixin<DemandedBitsAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
Result run(Function &F, FunctionAnalysisManager &FAM);
private:
- static char PassID;
+ static AnalysisKey Key;
friend struct AnalysisInfoMixin<DependenceAnalysis>;
}; // class DependenceAnalysis
class DominanceFrontierAnalysis
: public AnalysisInfoMixin<DominanceFrontierAnalysis> {
friend AnalysisInfoMixin<DominanceFrontierAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
/// Analysis pass providing a never-invalidated alias analysis result.
class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
friend AnalysisInfoMixin<GlobalsAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef GlobalsAAResult Result;
/// Analysis pass that exposes the \c IVUsers for a loop.
class IVUsersAnalysis : public AnalysisInfoMixin<IVUsersAnalysis> {
friend AnalysisInfoMixin<IVUsersAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef IVUsers Result;
/// An analysis pass which computes the call graph for a module.
class LazyCallGraphAnalysis : public AnalysisInfoMixin<LazyCallGraphAnalysis> {
friend AnalysisInfoMixin<LazyCallGraphAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// Inform generic clients of the result type.
Result run(Function &F, FunctionAnalysisManager &FAM);
private:
- static char PassID;
+ static AnalysisKey Key;
friend struct AnalysisInfoMixin<LazyValueAnalysis>;
};
class LoopAccessAnalysis
: public AnalysisInfoMixin<LoopAccessAnalysis> {
friend AnalysisInfoMixin<LoopAccessAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef LoopAccessInfo Result;
/// \brief Analysis pass that exposes the \c LoopInfo for a function.
class LoopAnalysis : public AnalysisInfoMixin<LoopAnalysis> {
friend AnalysisInfoMixin<LoopAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef LoopInfo Result;
class MemoryDependenceAnalysis
: public AnalysisInfoMixin<MemoryDependenceAnalysis> {
friend AnalysisInfoMixin<MemoryDependenceAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef MemoryDependenceResults Result;
class ModuleSummaryIndexAnalysis
: public AnalysisInfoMixin<ModuleSummaryIndexAnalysis> {
friend AnalysisInfoMixin<ModuleSummaryIndexAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef ModuleSummaryIndex Result;
/// Analysis pass providing a never-invalidated alias analysis result.
class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> {
friend AnalysisInfoMixin<ObjCARCAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef ObjCARCAAResult Result;
class OptimizationRemarkEmitterAnalysis
: public AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis> {
friend AnalysisInfoMixin<OptimizationRemarkEmitterAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
class PostDominatorTreeAnalysis
: public AnalysisInfoMixin<PostDominatorTreeAnalysis> {
friend AnalysisInfoMixin<PostDominatorTreeAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
private:
friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
};
/// \brief Printer pass that uses \c ProfileSummaryAnalysis.
/// \brief Analysis pass that exposes the \c RegionInfo for a function.
class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> {
friend AnalysisInfoMixin<RegionInfoAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef RegionInfo Result;
class ScalarEvolutionAnalysis
: public AnalysisInfoMixin<ScalarEvolutionAnalysis> {
friend AnalysisInfoMixin<ScalarEvolutionAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef ScalarEvolution Result;
/// Analysis pass providing a never-invalidated alias analysis result.
class SCEVAA : public AnalysisInfoMixin<SCEVAA> {
friend AnalysisInfoMixin<SCEVAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef SCEVAAResult Result;
/// Analysis pass providing a never-invalidated alias analysis result.
class ScopedNoAliasAA : public AnalysisInfoMixin<ScopedNoAliasAA> {
friend AnalysisInfoMixin<ScopedNoAliasAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef ScopedNoAliasAAResult Result;
private:
friend AnalysisInfoMixin<TargetLibraryAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
Optional<TargetLibraryInfoImpl> PresetInfoImpl;
private:
friend AnalysisInfoMixin<TargetIRAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
/// \brief The callback used to produce a result.
///
/// Analysis pass providing a never-invalidated alias analysis result.
class TypeBasedAA : public AnalysisInfoMixin<TypeBasedAA> {
friend AnalysisInfoMixin<TypeBasedAA>;
- static char PassID;
+ static AnalysisKey Key;
public:
typedef TypeBasedAAResult Result;
/// \brief Analysis pass which computes a \c DominatorTree.
class DominatorTreeAnalysis : public AnalysisInfoMixin<DominatorTreeAnalysis> {
friend AnalysisInfoMixin<DominatorTreeAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
/// \brief Provide the result typedef for this analysis pass.
namespace llvm {
+/// A special type used by analysis passes to provide an address that
+/// identifies that particular analysis pass type.
+///
+/// Analysis passes should have a static data member of this type and derive
+/// from the \c AnalysisInfoMixin to get a static ID method used to identify
+/// the analysis in the pass management infrastructure.
+struct alignas(8) AnalysisKey {};
+
/// \brief An abstract set of preserved analyses following a transformation pass
/// run.
///
/// \brief Construct a special preserved set that preserves all passes.
static PreservedAnalyses all() {
PreservedAnalyses PA;
- PA.PreservedPassIDs.insert((void *)AllPassesID);
+ PA.PreservedAnalysisIDs.insert(&AllAnalysesKey);
return PA;
}
/// \brief Mark a particular pass as preserved, adding it to the set.
template <typename PassT> void preserve() { preserve(PassT::ID()); }
- /// \brief Mark an abstract PassID as preserved, adding it to the set.
- void preserve(void *PassID) {
+ /// \brief Mark an abstract ID as preserved, adding it to the set.
+ void preserve(AnalysisKey *ID) {
if (!areAllPreserved())
- PreservedPassIDs.insert(PassID);
+ PreservedAnalysisIDs.insert(ID);
}
/// \brief Intersect this set with another in place.
if (Arg.areAllPreserved())
return;
if (areAllPreserved()) {
- PreservedPassIDs = Arg.PreservedPassIDs;
+ PreservedAnalysisIDs = Arg.PreservedAnalysisIDs;
return;
}
- for (void *P : PreservedPassIDs)
- if (!Arg.PreservedPassIDs.count(P))
- PreservedPassIDs.erase(P);
+ for (auto ID : PreservedAnalysisIDs)
+ if (!Arg.PreservedAnalysisIDs.count(ID))
+ PreservedAnalysisIDs.erase(ID);
}
/// \brief Intersect this set with a temporary other set in place.
if (Arg.areAllPreserved())
return;
if (areAllPreserved()) {
- PreservedPassIDs = std::move(Arg.PreservedPassIDs);
+ PreservedAnalysisIDs = std::move(Arg.PreservedAnalysisIDs);
return;
}
- for (void *P : PreservedPassIDs)
- if (!Arg.PreservedPassIDs.count(P))
- PreservedPassIDs.erase(P);
+ for (auto ID : PreservedAnalysisIDs)
+ if (!Arg.PreservedAnalysisIDs.count(ID))
+ PreservedAnalysisIDs.erase(ID);
}
/// \brief Query whether a pass is marked as preserved by this set.
/// \brief Query whether an abstract pass ID is marked as preserved by this
/// set.
- bool preserved(void *PassID) const {
- return PreservedPassIDs.count((void *)AllPassesID) ||
- PreservedPassIDs.count(PassID);
+ bool preserved(AnalysisKey *ID) const {
+ return PreservedAnalysisIDs.count(&AllAnalysesKey) ||
+ PreservedAnalysisIDs.count(ID);
}
/// \brief Query whether all of the analyses in the set are preserved.
bool preserved(PreservedAnalyses Arg) {
if (Arg.areAllPreserved())
return areAllPreserved();
- for (void *P : Arg.PreservedPassIDs)
- if (!preserved(P))
+ for (auto ID : Arg.PreservedAnalysisIDs)
+ if (!preserved(ID))
return false;
return true;
}
/// This is used primarily to optimize for the case of no changes which will
/// common in many scenarios.
bool areAllPreserved() const {
- return PreservedPassIDs.count((void *)AllPassesID);
+ return PreservedAnalysisIDs.count(&AllAnalysesKey);
}
private:
- // Note that this must not be -1 or -2 as those are already used by the
- // SmallPtrSet.
- static const uintptr_t AllPassesID = (intptr_t)(-3);
+ // A special key used to indicate all analyses.
+ static AnalysisKey AllAnalysesKey;
- SmallPtrSet<void *, 2> PreservedPassIDs;
+ SmallPtrSet<AnalysisKey *, 2> PreservedAnalysisIDs;
};
// Forward declare the analysis manager template.
/// specifically used for analyses.
template <typename DerivedT>
struct AnalysisInfoMixin : PassInfoMixin<DerivedT> {
- /// Returns an opaque, unique ID for this pass type.
+ /// Returns an opaque, unique ID for this analysis type.
+ ///
+ /// This ID is a pointer type that is guaranteed to be 8-byte aligned and
+ /// thus suitable for use in sets, maps, and other data structures optimized
+ /// for pointer-like types using the alignment-provided low bits.
///
- /// Note that this requires the derived type provide a static member whose
- /// address can be converted to a void pointer.
+ /// Note that this requires the derived type provide a static \c AnalysisKey
+ /// member called \c Key.
///
/// FIXME: The only reason the derived type needs to provide this rather than
/// this mixin providing it is due to broken implementations which cannot
/// instantiation. The only currently known platform with this limitation are
/// Windows DLL builds, specifically building each part of LLVM as a DLL. If
/// we ever remove that build configuration, this mixin can provide the
- /// static PassID as well.
- static void *ID() { return (void *)&DerivedT::PassID; }
+ /// static key as well.
+ static AnalysisKey *ID() { return &DerivedT::Key; }
};
/// A class template to provide analysis sets for IR units.
///
/// Note that you must provide an explicit instantiation declaration and
/// definition for this template in order to get the correct behavior on
-/// Windows. Otherwise, the address of SetID will not be stable.
+/// Windows. Otherwise, the address of SetKey will not be stable.
template <typename IRUnitT>
class AllAnalysesOn {
public:
- static void *ID() { return (void *)&SetID; }
+ static AnalysisKey *ID() { return &SetKey; }
private:
- static char SetID;
+ static AnalysisKey SetKey;
};
-template <typename IRUnitT> char AllAnalysesOn<IRUnitT>::SetID;
+template <typename IRUnitT> AnalysisKey AllAnalysesOn<IRUnitT>::SetKey;
extern template class AllAnalysesOn<Module>;
extern template class AllAnalysesOn<Function>;
// Clear all the invalidated results associated specifically with this
// function.
- SmallVector<void *, 8> InvalidatedPassIDs;
+ SmallVector<AnalysisKey *, 8> InvalidatedIDs;
auto ResultsListI = AnalysisResultLists.find(&IR);
if (ResultsListI == AnalysisResultLists.end())
return;
// Clear the map pointing into the results list.
- for (auto &PassIDAndResult : ResultsListI->second)
- AnalysisResults.erase(std::make_pair(PassIDAndResult.first, &IR));
+ for (auto &IDAndResult : ResultsListI->second)
+ AnalysisResults.erase(std::make_pair(IDAndResult.first, &IR));
// And actually destroy and erase the results associated with this IR.
AnalysisResultLists.erase(ResultsListI);
// Clear all the invalidated results associated specifically with this
// function.
- SmallVector<void *, 8> InvalidatedPassIDs;
+ SmallVector<AnalysisKey *, 8> InvalidatedIDs;
AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];
for (typename AnalysisResultListT::iterator I = ResultsList.begin(),
E = ResultsList.end();
I != E;) {
- void *PassID = I->first;
+ AnalysisKey *ID = I->first;
// Pass the invalidation down to the pass itself to see if it thinks it is
// necessary. The analysis pass can return false if no action on the part
// of the analysis manager is required for this invalidation event.
if (I->second->invalidate(IR, PA)) {
if (DebugLogging)
- dbgs() << "Invalidating analysis: " << this->lookupPass(PassID).name()
+ dbgs() << "Invalidating analysis: " << this->lookupPass(ID).name()
<< "\n";
- InvalidatedPassIDs.push_back(I->first);
+ InvalidatedIDs.push_back(I->first);
I = ResultsList.erase(I);
} else {
++I;
// After handling each pass, we mark it as preserved. Once we've
// invalidated any stale results, the rest of the system is allowed to
// start preserving this analysis again.
- PA.preserve(PassID);
+ PA.preserve(ID);
}
- while (!InvalidatedPassIDs.empty())
- AnalysisResults.erase(
- std::make_pair(InvalidatedPassIDs.pop_back_val(), &IR));
+ while (!InvalidatedIDs.empty())
+ AnalysisResults.erase(std::make_pair(InvalidatedIDs.pop_back_val(), &IR));
if (ResultsList.empty())
AnalysisResultLists.erase(&IR);
private:
/// \brief Lookup a registered analysis pass.
- PassConceptT &lookupPass(void *PassID) {
- typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(PassID);
+ PassConceptT &lookupPass(AnalysisKey *ID) {
+ typename AnalysisPassMapT::iterator PI = AnalysisPasses.find(ID);
assert(PI != AnalysisPasses.end() &&
"Analysis passes must be registered prior to being queried!");
return *PI->second;
}
/// \brief Lookup a registered analysis pass.
- const PassConceptT &lookupPass(void *PassID) const {
- typename AnalysisPassMapT::const_iterator PI = AnalysisPasses.find(PassID);
+ const PassConceptT &lookupPass(AnalysisKey *ID) const {
+ typename AnalysisPassMapT::const_iterator PI = AnalysisPasses.find(ID);
assert(PI != AnalysisPasses.end() &&
"Analysis passes must be registered prior to being queried!");
return *PI->second;
}
/// \brief Get an analysis result, running the pass if necessary.
- ResultConceptT &getResultImpl(void *PassID, IRUnitT &IR,
+ ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,
ExtraArgTs... ExtraArgs) {
typename AnalysisResultMapT::iterator RI;
bool Inserted;
std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair(
- std::make_pair(PassID, &IR), typename AnalysisResultListT::iterator()));
+ std::make_pair(ID, &IR), typename AnalysisResultListT::iterator()));
// If we don't have a cached result for this function, look up the pass and
// run it to produce a result, which we then add to the cache.
if (Inserted) {
- auto &P = this->lookupPass(PassID);
+ auto &P = this->lookupPass(ID);
if (DebugLogging)
dbgs() << "Running analysis: " << P.name() << "\n";
AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
- ResultList.emplace_back(PassID, P.run(IR, *this, ExtraArgs...));
+ ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
// P.run may have inserted elements into AnalysisResults and invalidated
// RI.
- RI = AnalysisResults.find(std::make_pair(PassID, &IR));
+ RI = AnalysisResults.find(std::make_pair(ID, &IR));
assert(RI != AnalysisResults.end() && "we just inserted it!");
RI->second = std::prev(ResultList.end());
}
/// \brief Get a cached analysis result or return null.
- ResultConceptT *getCachedResultImpl(void *PassID, IRUnitT &IR) const {
+ ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
typename AnalysisResultMapT::const_iterator RI =
- AnalysisResults.find(std::make_pair(PassID, &IR));
+ AnalysisResults.find(std::make_pair(ID, &IR));
return RI == AnalysisResults.end() ? nullptr : &*RI->second->second;
}
/// \brief Invalidate a function pass result.
- void invalidateImpl(void *PassID, IRUnitT &IR) {
+ void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) {
typename AnalysisResultMapT::iterator RI =
- AnalysisResults.find(std::make_pair(PassID, &IR));
+ AnalysisResults.find(std::make_pair(ID, &IR));
if (RI == AnalysisResults.end())
return;
if (DebugLogging)
- dbgs() << "Invalidating analysis: " << this->lookupPass(PassID).name()
+ dbgs() << "Invalidating analysis: " << this->lookupPass(ID).name()
<< "\n";
AnalysisResultLists[&IR].erase(RI->second);
AnalysisResults.erase(RI);
}
/// \brief Map type from module analysis pass ID to pass concept pointer.
- typedef DenseMap<
void *, std::unique_ptr<PassConceptT>> AnalysisPassMapT;
+ typedef DenseMap<
AnalysisKey *, std::unique_ptr<PassConceptT>> AnalysisPassMapT;
/// \brief Collection of module analysis passes, indexed by ID.
AnalysisPassMapT AnalysisPasses;
/// erases. Provides both the pass ID and concept pointer such that it is
/// half of a bijection and provides storage for the actual result concept.
typedef std::list<std::pair<
- void *, std::unique_ptr<detail::AnalysisResultConcept<IRUnitT>>>>
+ AnalysisKey *, std::unique_ptr<detail::AnalysisResultConcept<IRUnitT>>>>
AnalysisResultListT;
/// \brief Map type from function pointer to our custom list type.
/// \brief Map type from a pair of analysis ID and function pointer to an
/// iterator into a particular result list.
- typedef DenseMap<std::pair<void *, IRUnitT *>,
+ typedef DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
typename AnalysisResultListT::iterator>
AnalysisResultMapT;
private:
friend AnalysisInfoMixin<
InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
- static char PassID;
+ static AnalysisKey Key;
AnalysisManagerT *AM;
};
template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
-char
- InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::PassID;
+AnalysisKey
+ InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::Key;
extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
Module>;
private:
friend AnalysisInfoMixin<
OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
- static char PassID;
+ static AnalysisKey Key;
const AnalysisManagerT *AM;
};
template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
-char
- OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::PassID;
+AnalysisKey
+ OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::Key;
extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
Function>;
/// and debug info errors.
class VerifierAnalysis : public AnalysisInfoMixin<VerifierAnalysis> {
friend AnalysisInfoMixin<VerifierAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
struct Result {
bool IRBroken, DebugInfoBroken;
};
- static void *ID() { return (void *)&PassID; }
Result run(Module &M, ModuleAnalysisManager &);
Result run(Function &F, FunctionAnalysisManager &);
};
///
class MemorySSAAnalysis : public AnalysisInfoMixin<MemorySSAAnalysis> {
friend AnalysisInfoMixin<MemorySSAAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
// Wrap MemorySSA result to ensure address stability of internal MemorySSA
AAResults::Concept::~Concept() {}
// Provide a definition for the static object used to identify passes.
-char AAManager::PassID;
+AnalysisKey AAManager::Key;
namespace {
/// A wrapper pass for external alias analyses. This just squirrels away the
#endif
}
-char AssumptionAnalysis::PassID;
+AnalysisKey AssumptionAnalysis::Key;
PreservedAnalyses AssumptionPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
// BasicAliasAnalysis Pass
//===----------------------------------------------------------------------===//
-char BasicAA::PassID;
+AnalysisKey BasicAA::Key;
BasicAAResult BasicAA::run(Function &F, FunctionAnalysisManager &AM) {
return BasicAAResult(F.getParent()->getDataLayout(),
return false;
}
-char BlockFrequencyAnalysis::PassID;
+AnalysisKey BlockFrequencyAnalysis::Key;
BlockFrequencyInfo BlockFrequencyAnalysis::run(Function &F,
FunctionAnalysisManager &AM) {
BlockFrequencyInfo BFI;
BPI.print(OS);
}
-char BranchProbabilityAnalysis::PassID;
+AnalysisKey BranchProbabilityAnalysis::Key;
BranchProbabilityInfo
BranchProbabilityAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
BranchProbabilityInfo BPI;
return QueryResult;
}
-char CFLAndersAA::PassID;
+AnalysisKey CFLAndersAA::Key;
CFLAndersAAResult CFLAndersAA::run(Function &F, FunctionAnalysisManager &AM) {
return CFLAndersAAResult(AM.getResult<TargetLibraryAnalysis>(F));
return NoAlias;
}
-char CFLSteensAA::PassID;
+AnalysisKey CFLSteensAA::Key;
CFLSteensAAResult CFLSteensAA::run(Function &F, FunctionAnalysisManager &AM) {
return CFLSteensAAResult(AM.getResult<TargetLibraryAnalysis>(F));
}
// Provide an explicit template instantiation for the static ID.
-char CallGraphAnalysis::PassID;
+AnalysisKey CallGraphAnalysis::Key;
PreservedAnalyses CallGraphPrinterPass::run(Module &M,
ModuleAnalysisManager &AM) {
return new DemandedBitsWrapperPass();
}
-char DemandedBitsAnalysis::PassID;
+AnalysisKey DemandedBitsAnalysis::Key;
DemandedBits DemandedBitsAnalysis::run(Function &F,
FunctionAnalysisManager &AM) {
return DependenceInfo(&F, &AA, &SE, &LI);
}
-char DependenceAnalysis::PassID;
+AnalysisKey DependenceAnalysis::Key;
INITIALIZE_PASS_BEGIN(DependenceAnalysisWrapperPass, "da",
"Dependence Analysis", true, true)
}
#endif
-char DominanceFrontierAnalysis::PassID;
+AnalysisKey DominanceFrontierAnalysis::Key;
DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
FunctionAnalysisManager &AM) {
return Result;
}
-char GlobalsAA::PassID;
+AnalysisKey GlobalsAA::Key;
GlobalsAAResult GlobalsAA::run(Module &M, ModuleAnalysisManager &AM) {
return GlobalsAAResult::analyzeModule(M,
#define DEBUG_TYPE "iv-users"
-char IVUsersAnalysis::PassID;
+AnalysisKey IVUsersAnalysis::Key;
IVUsers IVUsersAnalysis::run(Loop &L, LoopAnalysisManager &AM) {
const auto &FAM =
}
}
-char LazyCallGraphAnalysis::PassID;
+AnalysisKey LazyCallGraphAnalysis::Key;
LazyCallGraphPrinterPass::LazyCallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
FunctionPass *createLazyValueInfoPass() { return new LazyValueInfoWrapperPass(); }
}
-char LazyValueAnalysis::PassID;
+AnalysisKey LazyValueAnalysis::Key;
//===----------------------------------------------------------------------===//
// LVILatticeVal
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(LoopAccessLegacyAnalysis, LAA_NAME, laa_name, false, true)
-char LoopAccessAnalysis::PassID;
+AnalysisKey LoopAccessAnalysis::Key;
LoopAccessInfo LoopAccessAnalysis::run(Loop &L, LoopAnalysisManager &AM) {
const FunctionAnalysisManager &FAM =
}
}
-char LoopAnalysis::PassID;
+AnalysisKey LoopAnalysis::Key;
LoopInfo LoopAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
// FIXME: Currently we create a LoopInfo from scratch for every function.
#endif
}
-char MemoryDependenceAnalysis::PassID;
+AnalysisKey MemoryDependenceAnalysis::Key;
MemoryDependenceResults
MemoryDependenceAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
return Index;
}
-char ModuleSummaryIndexAnalysis::PassID;
+AnalysisKey ModuleSummaryIndexAnalysis::Key;
ModuleSummaryIndex
ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
AU.setPreservesAll();
}
-char OptimizationRemarkEmitterAnalysis::PassID;
+AnalysisKey OptimizationRemarkEmitterAnalysis::Key;
OptimizationRemarkEmitter
OptimizationRemarkEmitterAnalysis::run(Function &F,
return new PostDominatorTreeWrapperPass();
}
-char PostDominatorTreeAnalysis::PassID;
+AnalysisKey PostDominatorTreeAnalysis::Key;
PostDominatorTree PostDominatorTreeAnalysis::run(Function &F,
FunctionAnalysisManager &) {
return false;
}
-char ProfileSummaryAnalysis::PassID;
+AnalysisKey ProfileSummaryAnalysis::Key;
ProfileSummaryInfo ProfileSummaryAnalysis::run(Module &M,
ModuleAnalysisManager &) {
return ProfileSummaryInfo(M);
// RegionInfoAnalysis implementation
//
-char RegionInfoAnalysis::PassID;
+AnalysisKey RegionInfoAnalysis::Key;
RegionInfo RegionInfoAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
RegionInfo RI;
// TODO: Verify more things.
}
-char ScalarEvolutionAnalysis::PassID;
+AnalysisKey ScalarEvolutionAnalysis::Key;
ScalarEvolution ScalarEvolutionAnalysis::run(Function &F,
FunctionAnalysisManager &AM) {
return nullptr;
}
-char SCEVAA::PassID;
+AnalysisKey SCEVAA::Key;
SCEVAAResult SCEVAA::run(Function &F, FunctionAnalysisManager &AM) {
return SCEVAAResult(AM.getResult<ScalarEvolutionAnalysis>(F));
return true;
}
-char ScopedNoAliasAA::PassID;
+AnalysisKey ScopedNoAliasAA::Key;
ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F,
FunctionAnalysisManager &AM) {
initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
}
-char TargetLibraryAnalysis::PassID;
+AnalysisKey TargetLibraryAnalysis::Key;
// Register the basic pass.
INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
return TTICallback(F);
}
-char TargetIRAnalysis::PassID;
+AnalysisKey TargetIRAnalysis::Key;
TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
return Result(F.getParent()->getDataLayout());
return false;
}
-char TypeBasedAA::PassID;
+AnalysisKey TypeBasedAA::Key;
TypeBasedAAResult TypeBasedAA::run(Function &F, FunctionAnalysisManager &AM) {
return TypeBasedAAResult();
return DT;
}
-char DominatorTreeAnalysis::PassID;
+AnalysisKey DominatorTreeAnalysis::Key;
DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {}
template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>;
}
+
+AnalysisKey PreservedAnalyses::AllAnalysesKey;
return new VerifierLegacyPass(FatalErrors);
}
-char VerifierAnalysis::PassID;
+AnalysisKey VerifierAnalysis::Key;
VerifierAnalysis::Result VerifierAnalysis::run(Module &M,
ModuleAnalysisManager &) {
Result Res;
/// \brief No-op module analysis.
class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> {
friend AnalysisInfoMixin<NoOpModuleAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
struct Result {};
/// \brief No-op CGSCC analysis.
class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
friend AnalysisInfoMixin<NoOpCGSCCAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
struct Result {};
/// \brief No-op function analysis.
class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> {
friend AnalysisInfoMixin<NoOpFunctionAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
struct Result {};
/// \brief No-op loop analysis.
class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> {
friend AnalysisInfoMixin<NoOpLoopAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
public:
struct Result {};
static StringRef name() { return "NoOpLoopAnalysis"; }
};
-char NoOpModuleAnalysis::PassID;
-char NoOpCGSCCAnalysis::PassID;
-char NoOpFunctionAnalysis::PassID;
-char NoOpLoopAnalysis::PassID;
+AnalysisKey NoOpModuleAnalysis::Key;
+AnalysisKey NoOpCGSCCAnalysis::Key;
+AnalysisKey NoOpFunctionAnalysis::Key;
+AnalysisKey NoOpLoopAnalysis::Key;
} // End anonymous namespace.
return false;
}
-char MemorySSAAnalysis::PassID;
+AnalysisKey MemorySSAAnalysis::Key;
MemorySSAAnalysis::Result MemorySSAAnalysis::run(Function &F,
FunctionAnalysisManager &AM) {
namespace {
-class TestModuleAnalysis {
+class TestModuleAnalysis : public AnalysisInfoMixin<TestModuleAnalysis> {
public:
struct Result {
Result(int Count) : FunctionCount(Count) {}
int FunctionCount;
};
- static void *ID() { return (void *)&PassID; }
- static StringRef name() { return "TestModuleAnalysis"; }
-
TestModuleAnalysis(int &Runs) : Runs(Runs) {}
Result run(Module &M, ModuleAnalysisManager &AM) {
}
private:
- static char PassID;
+ friend AnalysisInfoMixin<TestModuleAnalysis>;
+ static AnalysisKey Key;
int &Runs;
};
-char TestModuleAnalysis::PassID;
+AnalysisKey TestModuleAnalysis::Key;
-class TestSCCAnalysis {
+class TestSCCAnalysis : public AnalysisInfoMixin<TestSCCAnalysis> {
public:
struct Result {
Result(int Count) : FunctionCount(Count) {}
int FunctionCount;
};
- static void *ID() { return (void *)&PassID; }
- static StringRef name() { return "TestSCCAnalysis"; }
-
TestSCCAnalysis(int &Runs) : Runs(Runs) {}
Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &) {
}
private:
- static char PassID;
+ friend AnalysisInfoMixin<TestSCCAnalysis>;
+ static AnalysisKey Key;
int &Runs;
};
-char TestSCCAnalysis::PassID;
+AnalysisKey TestSCCAnalysis::Key;
-class TestFunctionAnalysis {
+class TestFunctionAnalysis : public AnalysisInfoMixin<TestFunctionAnalysis> {
public:
struct Result {
Result(int Count) : InstructionCount(Count) {}
int InstructionCount;
};
- static void *ID() { return (void *)&PassID; }
- static StringRef name() { return "TestFunctionAnalysis"; }
-
TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
Result run(Function &F, FunctionAnalysisManager &AM) {
}
private:
- static char PassID;
+ friend AnalysisInfoMixin<TestFunctionAnalysis>;
+ static AnalysisKey Key;
int &Runs;
};
-char TestFunctionAnalysis::PassID;
+AnalysisKey TestFunctionAnalysis::Key;
-class TestImmutableFunctionAnalysis {
+class TestImmutableFunctionAnalysis
+ : public AnalysisInfoMixin<TestImmutableFunctionAnalysis> {
public:
struct Result {
bool invalidate(Function &, const PreservedAnalyses &) { return false; }
};
- static void *ID() { return (void *)&PassID; }
- static StringRef name() { return "TestImmutableFunctionAnalysis"; }
-
TestImmutableFunctionAnalysis(int &Runs) : Runs(Runs) {}
Result run(Function &F, FunctionAnalysisManager &AM) {
}
private:
- static char PassID;
+ friend AnalysisInfoMixin<TestImmutableFunctionAnalysis>;
+ static AnalysisKey Key;
int &Runs;
};
-char TestImmutableFunctionAnalysis::PassID;
+AnalysisKey TestImmutableFunctionAnalysis::Key;
struct LambdaSCCPass : public PassInfoMixin<LambdaSCCPass> {
template <typename T> LambdaSCCPass(T &&Arg) : Func(std::forward<T>(Arg)) {}
namespace {
-class TestLoopAnalysis {
- /// \brief Private static data to provide unique ID.
- static char PassID;
+class TestLoopAnalysis : public AnalysisInfoMixin<TestLoopAnalysis> {
+ friend AnalysisInfoMixin<TestLoopAnalysis>;
+ static AnalysisKey Key;
int &Runs;
int BlockCount;
};
- /// \brief Returns an opaque, unique ID for this pass type.
- static void *ID() { return (void *)&PassID; }
-
- /// \brief Returns the name of the analysis.
- static StringRef name() { return "TestLoopAnalysis"; }
-
TestLoopAnalysis(int &Runs) : Runs(Runs) {}
/// \brief Run the analysis pass over the loop and return a result.
}
};
-char TestLoopAnalysis::PassID;
+AnalysisKey TestLoopAnalysis::Key;
class TestLoopPass {
std::vector<StringRef> &VisitedLoops;
private:
friend AnalysisInfoMixin<TestFunctionAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
int &Runs;
};
-char TestFunctionAnalysis::PassID;
+AnalysisKey TestFunctionAnalysis::Key;
class TestModuleAnalysis : public AnalysisInfoMixin<TestModuleAnalysis> {
public:
private:
friend AnalysisInfoMixin<TestModuleAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
int &Runs;
};
-char TestModuleAnalysis::PassID;
+AnalysisKey TestModuleAnalysis::Key;
struct TestModulePass : PassInfoMixin<TestModulePass> {
TestModulePass(int &RunCount) : RunCount(RunCount) {}
private:
friend AnalysisInfoMixin<CustomizedAnalysis>;
- static char PassID;
+ static AnalysisKey Key;
};
-char CustomizedAnalysis::PassID;
+AnalysisKey CustomizedAnalysis::Key;
struct CustomizedPass : PassInfoMixin<CustomizedPass> {
std::function<void(CustomizedAnalysis::Result &, int &)> Callback;
projects / llvm / commitdiff