PreservedAnalyses(const PreservedAnalyses &Arg)
: PreservedPassIDs(Arg.PreservedPassIDs) {}
PreservedAnalyses(PreservedAnalyses &&Arg)
- : PreservedPassIDs(Arg.PreservedPassIDs) {}
+ : PreservedPassIDs(std::move(Arg.PreservedPassIDs)) {}
+ friend void swap(PreservedAnalyses &LHS, PreservedAnalyses &RHS) {
+ using std::swap;
+ swap(LHS.PreservedPassIDs, RHS.PreservedPassIDs);
+ }
PreservedAnalyses &operator=(PreservedAnalyses RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
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;
+ static const uintptr_t AllPassesID = (intptr_t)(-3);
- bool areAllPreserved() const { return PreservedPassIDs.count((void *)AllPassesID); }
+ bool areAllPreserved() const {
+ return PreservedPassIDs.count((void *)AllPassesID);
+ }
SmallPtrSet<void *, 2> PreservedPassIDs;
};
typename ResultT>
class PassRunAcceptsAnalysisManager {
typedef char SmallType;
- struct BigType { char a, b; };
+ struct BigType {
+ char a, b;
+ };
template <typename T, ResultT (T::*)(IRUnitT, AnalysisManagerT *)>
struct Checker;
/// \brief Specialization of \c PassModel for passes that accept an analyis
/// manager.
template <typename IRUnitT, typename AnalysisManagerT, typename PassT>
-struct PassModel<IRUnitT, AnalysisManagerT, PassT,
- true> : PassConcept<IRUnitT, AnalysisManagerT> {
+struct PassModel<IRUnitT, AnalysisManagerT, PassT, true>
+ : PassConcept<IRUnitT, AnalysisManagerT> {
explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
PassModel(const PassModel &Arg) : Pass(Arg.Pass) {}
- PassModel(PassModel &&Arg) : Pass(Arg.Pass) {}
+ PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
+ friend void swap(PassModel &LHS, PassModel &RHS) {
+ using std::swap;
+ swap(LHS.Pass, RHS.Pass);
+ }
PassModel &operator=(PassModel RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
/// \brief Specialization of \c PassModel for passes that accept an analyis
/// manager.
template <typename IRUnitT, typename AnalysisManagerT, typename PassT>
-struct PassModel<IRUnitT, AnalysisManagerT, PassT,
- false> : PassConcept<IRUnitT, AnalysisManagerT> {
+struct PassModel<IRUnitT, AnalysisManagerT, PassT, false>
+ : PassConcept<IRUnitT, AnalysisManagerT> {
explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
PassModel(const PassModel &Arg) : Pass(Arg.Pass) {}
- PassModel(PassModel &&Arg) : Pass(Arg.Pass) {}
+ PassModel(PassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
+ friend void swap(PassModel &LHS, PassModel &RHS) {
+ using std::swap;
+ swap(LHS.Pass, RHS.Pass);
+ }
PassModel &operator=(PassModel RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
/// \c invalidate member function.
template <typename IRUnitT, typename ResultT> class ResultHasInvalidateMethod {
typedef char SmallType;
- struct BigType { char a, b; };
+ struct BigType {
+ char a, b;
+ };
template <typename T, bool (T::*)(IRUnitT, const PreservedAnalyses &)>
struct Checker;
/// \brief Specialization of \c AnalysisResultModel which provides the default
/// invalidate functionality.
template <typename IRUnitT, typename PassT, typename ResultT>
-struct AnalysisResultModel<IRUnitT, PassT, ResultT,
- false> : AnalysisResultConcept<IRUnitT> {
+struct AnalysisResultModel<IRUnitT, PassT, ResultT, false>
+ : AnalysisResultConcept<IRUnitT> {
explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
- AnalysisResultModel(AnalysisResultModel &&Arg) : Result(Arg.Result) {}
+ AnalysisResultModel(AnalysisResultModel &&Arg)
+ : Result(std::move(Arg.Result)) {}
+ friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {
+ using std::swap;
+ swap(LHS.Result, RHS.Result);
+ }
AnalysisResultModel &operator=(AnalysisResultModel RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
/// \brief Specialization of \c AnalysisResultModel which delegates invalidate
/// handling to \c ResultT.
template <typename IRUnitT, typename PassT, typename ResultT>
-struct AnalysisResultModel<IRUnitT, PassT, ResultT,
- true> : AnalysisResultConcept<IRUnitT> {
+struct AnalysisResultModel<IRUnitT, PassT, ResultT, true>
+ : AnalysisResultConcept<IRUnitT> {
explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
AnalysisResultModel(const AnalysisResultModel &Arg) : Result(Arg.Result) {}
- AnalysisResultModel(AnalysisResultModel &&Arg) : Result(Arg.Result) {}
+ AnalysisResultModel(AnalysisResultModel &&Arg)
+ : Result(std::move(Arg.Result)) {}
+ friend void swap(AnalysisResultModel &LHS, AnalysisResultModel &RHS) {
+ using std::swap;
+ swap(LHS.Result, RHS.Result);
+ }
AnalysisResultModel &operator=(AnalysisResultModel RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
/// \returns A unique_ptr to the analysis result object to be queried by
/// users.
virtual std::unique_ptr<AnalysisResultConcept<IRUnitT>>
- run(IRUnitT IR, AnalysisManagerT *AM) = 0;
+ run(IRUnitT IR, AnalysisManagerT *AM) = 0;
};
/// \brief Wrapper to model the analysis pass concept.
/// wrapped in a \c AnalysisResultModel.
template <typename IRUnitT, typename AnalysisManagerT, typename PassT,
bool AcceptsAnalysisManager = PassRunAcceptsAnalysisManager<
- IRUnitT, AnalysisManagerT, PassT,
- typename PassT::Result>::Value> struct AnalysisPassModel;
+ IRUnitT, AnalysisManagerT, PassT, typename PassT::Result>::Value>
+struct AnalysisPassModel;
/// \brief Specialization of \c AnalysisPassModel which passes an
/// \c AnalysisManager to PassT's run method.
template <typename IRUnitT, typename AnalysisManagerT, typename PassT>
-struct AnalysisPassModel<IRUnitT, AnalysisManagerT, PassT,
- true> : AnalysisPassConcept<IRUnitT,
- AnalysisManagerT> {
+struct AnalysisPassModel<IRUnitT, AnalysisManagerT, PassT, true>
+ : AnalysisPassConcept<IRUnitT, AnalysisManagerT> {
explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {}
- AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(Arg.Pass) {}
+ AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
+ friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) {
+ using std::swap;
+ swap(LHS.Pass, RHS.Pass);
+ }
AnalysisPassModel &operator=(AnalysisPassModel RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
/// \brief Specialization of \c AnalysisPassModel which does not pass an
/// \c AnalysisManager to PassT's run method.
template <typename IRUnitT, typename AnalysisManagerT, typename PassT>
-struct AnalysisPassModel<IRUnitT, AnalysisManagerT, PassT,
- false> : AnalysisPassConcept<IRUnitT,
- AnalysisManagerT> {
+struct AnalysisPassModel<IRUnitT, AnalysisManagerT, PassT, false>
+ : AnalysisPassConcept<IRUnitT, AnalysisManagerT> {
explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
AnalysisPassModel(const AnalysisPassModel &Arg) : Pass(Arg.Pass) {}
- AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(Arg.Pass) {}
+ AnalysisPassModel(AnalysisPassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
+ friend void swap(AnalysisPassModel &LHS, AnalysisPassModel &RHS) {
+ using std::swap;
+ swap(LHS.Pass, RHS.Pass);
+ }
AnalysisPassModel &operator=(AnalysisPassModel RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
PassT Pass;
};
-}
+} // End namespace detail
class ModuleAnalysisManager;
///
/// This method should only be called for a single module as there is the
/// expectation that the lifetime of a pass is bounded to that of a module.
- PreservedAnalyses run(Module *M, ModuleAnalysisManager *AM = 0);
+ PreservedAnalyses run(Module *M, ModuleAnalysisManager *AM = nullptr);
template <typename ModulePassT> void addPass(ModulePassT Pass) {
Passes.emplace_back(new ModulePassModel<ModulePassT>(std::move(Pass)));
private:
// Pull in the concept type and model template specialized for modules.
- typedef detail::PassConcept<Module *, ModuleAnalysisManager> ModulePassConcept;
+ typedef detail::PassConcept<Module *, ModuleAnalysisManager>
+ ModulePassConcept;
template <typename PassT>
struct ModulePassModel
: detail::PassModel<Module *, ModuleAnalysisManager, PassT> {
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
FunctionPassManager() {}
- FunctionPassManager(FunctionPassManager &&Arg) : Passes(std::move(Arg.Passes)) {}
+ FunctionPassManager(FunctionPassManager &&Arg)
+ : Passes(std::move(Arg.Passes)) {}
FunctionPassManager &operator=(FunctionPassManager &&RHS) {
Passes = std::move(RHS.Passes);
return *this;
Passes.emplace_back(new FunctionPassModel<FunctionPassT>(std::move(Pass)));
}
- PreservedAnalyses run(Function *F, FunctionAnalysisManager *AM = 0);
+ PreservedAnalyses run(Function *F, FunctionAnalysisManager *AM = nullptr);
static StringRef name() { return "FunctionPassManager"; }
private:
// Pull in the concept type and model template specialized for functions.
typedef detail::PassConcept<Function *, FunctionAnalysisManager>
- FunctionPassConcept;
+ FunctionPassConcept;
template <typename PassT>
struct FunctionPassModel
: detail::PassModel<Function *, FunctionAnalysisManager, PassT> {
/// - invalidateImpl
///
/// The details of the call pattern are within.
-template <typename DerivedT, typename IRUnitT>
-class AnalysisManagerBase {
+template <typename DerivedT, typename IRUnitT> class AnalysisManagerBase {
DerivedT *derived_this() { return static_cast<DerivedT *>(this); }
- const DerivedT *derived_this() const { return static_cast<const DerivedT *>(this); }
+ const DerivedT *derived_this() const {
+ return static_cast<const DerivedT *>(this);
+ }
AnalysisManagerBase(const AnalysisManagerBase &) LLVM_DELETED_FUNCTION;
AnalysisManagerBase &
AnalysisPassMapT AnalysisPasses;
};
-}
+} // End namespace detail
/// \brief A module analysis pass manager with lazy running and caching of
/// results.
/// \brief Invalidate results across a module.
void invalidateImpl(Module *M, const PreservedAnalyses &PA);
- /// \brief Map type from module analysis pass ID to pass result concept pointer.
+ /// \brief Map type from module analysis pass ID to pass result concept
+ /// pointer.
typedef DenseMap<void *,
std::unique_ptr<detail::AnalysisResultConcept<Module *>>>
ModuleAnalysisResultMapT;
class FunctionAnalysisManager
: public detail::AnalysisManagerBase<FunctionAnalysisManager, Function *> {
friend class detail::AnalysisManagerBase<FunctionAnalysisManager, Function *>;
- typedef detail::AnalysisManagerBase<FunctionAnalysisManager, Function *> BaseT;
+ typedef detail::AnalysisManagerBase<FunctionAnalysisManager, Function *>
+ BaseT;
typedef BaseT::ResultConceptT ResultConceptT;
typedef BaseT::PassConceptT PassConceptT;
void clear();
private:
- FunctionAnalysisManager(const FunctionAnalysisManager &) LLVM_DELETED_FUNCTION;
+ FunctionAnalysisManager(const FunctionAnalysisManager &)
+ LLVM_DELETED_FUNCTION;
FunctionAnalysisManager &
operator=(const FunctionAnalysisManager &) LLVM_DELETED_FUNCTION;
/// half of a bijection and provides storage for the actual result concept.
typedef std::list<std::pair<
void *, std::unique_ptr<detail::AnalysisResultConcept<Function *>>>>
- FunctionAnalysisResultListT;
+ FunctionAnalysisResultListT;
/// \brief Map type from function pointer to our custom list type.
typedef DenseMap<Function *, FunctionAnalysisResultListT>
- FunctionAnalysisResultListMapT;
+ FunctionAnalysisResultListMapT;
/// \brief Map from function to a list of function analysis results.
///
static void *ID() { return (void *)&PassID; }
explicit FunctionAnalysisManagerModuleProxy(FunctionAnalysisManager &FAM)
- : FAM(FAM) {}
+ : FAM(&FAM) {}
+ // We have to explicitly define all the special member functions because MSVC
+ // refuses to generate them.
FunctionAnalysisManagerModuleProxy(
const FunctionAnalysisManagerModuleProxy &Arg)
: FAM(Arg.FAM) {}
FunctionAnalysisManagerModuleProxy(FunctionAnalysisManagerModuleProxy &&Arg)
- : FAM(Arg.FAM) {}
+ : FAM(std::move(Arg.FAM)) {}
FunctionAnalysisManagerModuleProxy &
operator=(FunctionAnalysisManagerModuleProxy RHS) {
- std::swap(*this, RHS);
+ std::swap(FAM, RHS.FAM);
return *this;
}
private:
static char PassID;
- FunctionAnalysisManager &FAM;
+ FunctionAnalysisManager *FAM;
};
/// \brief The result proxy object for the
/// See its documentation for more information.
class FunctionAnalysisManagerModuleProxy::Result {
public:
- explicit Result(FunctionAnalysisManager &FAM) : FAM(FAM) {}
+ explicit Result(FunctionAnalysisManager &FAM) : FAM(&FAM) {}
// We have to explicitly define all the special member functions because MSVC
// refuses to generate them.
Result(const Result &Arg) : FAM(Arg.FAM) {}
- Result(Result &&Arg) : FAM(Arg.FAM) {}
+ Result(Result &&Arg) : FAM(std::move(Arg.FAM)) {}
Result &operator=(Result RHS) {
- std::swap(*this, RHS);
+ std::swap(FAM, RHS.FAM);
return *this;
}
~Result();
/// \brief Accessor for the \c FunctionAnalysisManager.
- FunctionAnalysisManager &getManager() { return FAM; }
+ FunctionAnalysisManager &getManager() { return *FAM; }
/// \brief Handler for invalidation of the module.
///
bool invalidate(Module *M, const PreservedAnalyses &PA);
private:
- FunctionAnalysisManager &FAM;
+ FunctionAnalysisManager *FAM;
};
/// \brief A function analysis which acts as a proxy for a module analysis
/// \brief Result proxy object for \c ModuleAnalysisManagerFunctionProxy.
class Result {
public:
- explicit Result(const ModuleAnalysisManager &MAM) : MAM(MAM) {}
+ explicit Result(const ModuleAnalysisManager &MAM) : MAM(&MAM) {}
// We have to explicitly define all the special member functions because
// MSVC refuses to generate them.
Result(const Result &Arg) : MAM(Arg.MAM) {}
- Result(Result &&Arg) : MAM(Arg.MAM) {}
+ Result(Result &&Arg) : MAM(std::move(Arg.MAM)) {}
Result &operator=(Result RHS) {
- std::swap(*this, RHS);
+ std::swap(MAM, RHS.MAM);
return *this;
}
- const ModuleAnalysisManager &getManager() const { return MAM; }
+ const ModuleAnalysisManager &getManager() const { return *MAM; }
/// \brief Handle invalidation by ignoring it, this pass is immutable.
bool invalidate(Function *) { return false; }
private:
- const ModuleAnalysisManager &MAM;
+ const ModuleAnalysisManager *MAM;
};
static void *ID() { return (void *)&PassID; }
ModuleAnalysisManagerFunctionProxy(const ModuleAnalysisManager &MAM)
- : MAM(MAM) {}
+ : MAM(&MAM) {}
+ // We have to explicitly define all the special member functions because MSVC
+ // refuses to generate them.
+ ModuleAnalysisManagerFunctionProxy(
+ const ModuleAnalysisManagerFunctionProxy &Arg)
+ : MAM(Arg.MAM) {}
+ ModuleAnalysisManagerFunctionProxy(ModuleAnalysisManagerFunctionProxy &&Arg)
+ : MAM(std::move(Arg.MAM)) {}
+ ModuleAnalysisManagerFunctionProxy &
+ operator=(ModuleAnalysisManagerFunctionProxy RHS) {
+ std::swap(MAM, RHS.MAM);
+ return *this;
+ }
/// \brief Run the analysis pass and create our proxy result object.
/// Nothing to see here, it just forwards the \c MAM reference into the
/// result.
- Result run(Function *) { return Result(MAM); }
+ Result run(Function *) { return Result(*MAM); }
private:
static char PassID;
- const ModuleAnalysisManager &MAM;
+ const ModuleAnalysisManager *MAM;
};
/// \brief Trivial adaptor that maps from a module to its functions.
/// \c FunctionAnalysisManagerModuleProxy analysis prior to running the function
/// pass over the module to enable a \c FunctionAnalysisManager to be used
/// within this run safely.
-template <typename FunctionPassT>
-class ModuleToFunctionPassAdaptor {
+template <typename FunctionPassT> class ModuleToFunctionPassAdaptor {
public:
explicit ModuleToFunctionPassAdaptor(FunctionPassT Pass)
: Pass(std::move(Pass)) {}
: Pass(Arg.Pass) {}
ModuleToFunctionPassAdaptor(ModuleToFunctionPassAdaptor &&Arg)
: Pass(std::move(Arg.Pass)) {}
+ friend void swap(ModuleToFunctionPassAdaptor &LHS, ModuleToFunctionPassAdaptor &RHS) {
+ using std::swap;
+ swap(LHS.Pass, RHS.Pass);
+ }
ModuleToFunctionPassAdaptor &operator=(ModuleToFunctionPassAdaptor RHS) {
- std::swap(*this, RHS);
+ swap(*this, RHS);
return *this;
}
/// \brief Runs the function pass across every function in the module.
PreservedAnalyses run(Module *M, ModuleAnalysisManager *AM) {
- FunctionAnalysisManager *FAM = 0;
+ FunctionAnalysisManager *FAM = nullptr;
if (AM)
// Setup the function analysis manager from its proxy.
FAM = &AM->getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
projects / oota-llvm.git / blobdiff