class MemorySSA {
public:
MemorySSA(Function &, AliasAnalysis *, DominatorTree *);
- MemorySSA(MemorySSA &&);
~MemorySSA();
MemorySSAWalker *getWalker();
static char PassID;
public:
- typedef MemorySSA Result;
+ typedef std::unique_ptr<MemorySSA> Result;
- MemorySSA run(Function &F, AnalysisManager<Function> &AM);
+ Result run(Function &F, AnalysisManager<Function> &AM);
};
/// \brief Printer pass for \c MemorySSA.
/// the walker it uses or returns.
virtual void invalidateInfo(MemoryAccess *) {}
+ virtual void verify(const MemorySSA *MSSA) { assert(MSSA == this->MSSA); }
+
protected:
friend class MemorySSA; // For updating MSSA pointer in MemorySSA move
// constructor.
#endif
return Result;
}
+
+ void verify(const MemorySSA *MSSA) { assert(MSSA == &this->MSSA); }
};
struct RenamePassData {
/// earliest-MemoryAccess-we-can-optimize-to". This is necessary if we're
/// going to have DT updates, if we remove MemoryAccesses, etc.
void resetClobberWalker() { Walker.reset(); }
+
+ void verify(const MemorySSA *MSSA) override {
+ MemorySSAWalker::verify(MSSA);
+ Walker.verify(MSSA);
+ }
};
/// \brief Rename a single basic block into MemorySSA form.
buildMemorySSA();
}
-MemorySSA::MemorySSA(MemorySSA &&MSSA)
- : AA(MSSA.AA), DT(MSSA.DT), F(MSSA.F),
- ValueToMemoryAccess(std::move(MSSA.ValueToMemoryAccess)),
- PerBlockAccesses(std::move(MSSA.PerBlockAccesses)),
- LiveOnEntryDef(std::move(MSSA.LiveOnEntryDef)),
- BlockNumberingValid(std::move(MSSA.BlockNumberingValid)),
- BlockNumbering(std::move(MSSA.BlockNumbering)),
- Walker(std::move(MSSA.Walker)), NextID(MSSA.NextID) {
- // Update the Walker MSSA pointer so it doesn't point to the moved-from MSSA
- // object any more.
- Walker->MSSA = this;
-}
-
MemorySSA::~MemorySSA() {
// Drop all our references
for (const auto &Pair : PerBlockAccesses)
verifyDefUses(F);
verifyDomination(F);
verifyOrdering(F);
+ Walker->verify(this);
}
/// \brief Verify that the order and existence of MemoryAccesses matches the
char MemorySSAAnalysis::PassID;
-MemorySSA MemorySSAAnalysis::run(Function &F, AnalysisManager<Function> &AM) {
+std::unique_ptr<MemorySSA>
+MemorySSAAnalysis::run(Function &F, AnalysisManager<Function> &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F);
- return MemorySSA(F, &AA, &DT);
+ return make_unique<MemorySSA>(F, &AA, &DT);
}
PreservedAnalyses MemorySSAPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
OS << "MemorySSA for function: " << F.getName() << "\n";
- AM.getResult<MemorySSAAnalysis>(F).print(OS);
+ AM.getResult<MemorySSAAnalysis>(F)->print(OS);
return PreservedAnalyses::all();
}
PreservedAnalyses MemorySSAVerifierPass::run(Function &F,
FunctionAnalysisManager &AM) {
- AM.getResult<MemorySSAAnalysis>(F).verifyMemorySSA();
+ AM.getResult<MemorySSAAnalysis>(F)->verifyMemorySSA();
return PreservedAnalyses::all();
}