reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/Analysis/AliasSetTracker.h
   40 class MemorySSA;

References

include/llvm/Analysis/AliasSetTracker.h
  347   MemorySSA *MSSA;
  361   explicit AliasSetTracker(AliasAnalysis &aa, MemorySSA *mssa, Loop *l)
include/llvm/Analysis/LoopAnalysisManager.h
   61   MemorySSA *MSSA;
include/llvm/Analysis/MemorySSA.h
  709   MemorySSA(MemorySSA &&) = delete;
  936     Result(std::unique_ptr<MemorySSA> &&MSSA) : MSSA(std::move(MSSA)) {}
  938     MemorySSA &getMSSA() { return *MSSA.get(); }
  940     std::unique_ptr<MemorySSA> MSSA;
  973   MemorySSA &getMSSA() { return *MSSA; }
  974   const MemorySSA &getMSSA() const { return *MSSA; }
  982   std::unique_ptr<MemorySSA> MSSA;
  998   MemorySSAWalker(MemorySSA *);
 1059   MemorySSA *MSSA;
include/llvm/Analysis/MemorySSAUpdater.h
   72   MemorySSA *MSSA;
   82   MemorySSAUpdater(MemorySSA *MSSA) : MSSA(MSSA) {}
  144                    MemorySSA::InsertionPlace Where);
  205                                        MemorySSA::InsertionPlace Point);
  260   MemorySSA* getMemorySSA() const { return MSSA; }
include/llvm/Transforms/Scalar/LoopPassManager.h
  298     MemorySSA *MSSA = UseMemorySSA
lib/Analysis/LoopInfo.cpp
  108       MSSAU->moveToPlace(MUD, InsertPt->getParent(), MemorySSA::End);
lib/Analysis/MemorySSA.cpp
  101   const MemorySSA *MSSA;
  104   MemorySSAAnnotatedWriter(const MemorySSA *M) : MSSA(M) {}
  400                    const MemoryLocation &StartLoc, const MemorySSA &MSSA,
  514   const MemorySSA &MSSA;
  925   ClobberWalker(const MemorySSA &MSSA, AliasAnalysisType &AA, DominatorTree &DT)
  991   MemorySSA *MSSA;
  994   ClobberWalkerBase(MemorySSA *M, AliasAnalysisType *A, DominatorTree *D)
 1017   CachingWalker(MemorySSA *M, ClobberWalkerBase<AliasAnalysisType> *W)
 1053   SkipSelfWalker(MemorySSA *M, ClobberWalkerBase<AliasAnalysisType> *W)
 1248 MemorySSA::AccessList *MemorySSA::getOrCreateAccessList(const BasicBlock *BB) {
 1256 MemorySSA::DefsList *MemorySSA::getOrCreateDefsList(const BasicBlock *BB) {
 1275   OptimizeUses(MemorySSA *MSSA, CachingWalker<BatchAAResults> *Walker,
 1304   MemorySSA *MSSA;
 1330   MemorySSA::AccessList *Accesses = MSSA->getWritableBlockAccesses(BB);
 1563 MemorySSA::CachingWalker<AliasAnalysis> *MemorySSA::getWalkerImpl() {
 2259   auto &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
 2272   return MemorySSAAnalysis::Result(std::make_unique<MemorySSA>(F, &AA, &DT));
 2316   MSSA.reset(new MemorySSA(F, &AA, &DT));
 2326 MemorySSAWalker::MemorySSAWalker(MemorySSA *M) : MSSA(M) {}
lib/Analysis/MemorySSAUpdater.cpp
  549                                                   MemorySSA *MSSA) {
  586   const MemorySSA::AccessList *Acc = MSSA->getBlockAccesses(BB);
  608           MSSA->insertIntoListsForBlock(NewUseOrDef, NewBB, MemorySSA::End);
  825       MemorySSA::DefsList *Defs = MSSA->getWritableBlockDefs(BB);
 1161                                    MemorySSA::InsertionPlace Where) {
 1169   MemorySSA::AccessList *Accs = MSSA->getWritableBlockAccesses(From);
 1185       MSSA->moveTo(MUD, To, MemorySSA::End);
 1247     MSSA->moveTo(Phi, New, MemorySSA::Beginning);
 1352     if (MemorySSA::AccessList *Acc = MSSA->getWritableBlockAccesses(BB))
 1359     MemorySSA::AccessList *Acc = MSSA->getWritableBlockAccesses(BB);
 1416     MemorySSA::InsertionPlace Point) {
lib/CodeGen/InterleavedLoadCombinePass.cpp
   65   InterleavedLoadCombineImpl(Function &F, DominatorTree &DT, MemorySSA &MSSA,
   83   MemorySSA &MSSA;
lib/Transforms/Scalar/EarlyCSE.cpp
  449   MemorySSA *MSSA;
  528            AssumptionCache &AC, MemorySSA *MSSA)
 1322   auto *MSSA =
 1367     auto *MSSA =
lib/Transforms/Scalar/GVNHoist.cpp
  258            MemoryDependenceResults *MD, MemorySSA *MSSA)
  334   MemorySSA *MSSA;
  386     const MemorySSA::AccessList *Acc = MSSA->getBlockAccesses(BB);
  959         MSSAUpdater->moveToPlace(NewMemAcc, DestBB, MemorySSA::End);
 1156     auto &MSSA = getAnalysis<MemorySSAWrapperPass>().getMSSA();
 1181   MemorySSA &MSSA = AM.getResult<MemorySSAAnalysis>(F).getMSSA();
lib/Transforms/Scalar/LICM.cpp
  153 static bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU,
  172                  ScalarEvolution *SE, MemorySSA *MSSA,
  212     MemorySSA *MSSA = EnableMSSALoopDependency
  329     MemorySSA *MSSA, OptimizationRemarkEmitter *ORE, bool DeleteAST) {
 1090   MemorySSA *MSSA = MSSAU ? MSSAU->getMemorySSA() : nullptr;
 1399         New, nullptr, New->getParent(), MemorySSA::Beginning);
 1451       MSSAU->moveToPlace(OldMemAcc, Dest.getParent(), MemorySSA::End);
 1813               NewSI, nullptr, NewSI->getParent(), MemorySSA::Beginning);
 2130         PreheaderLoad, nullptr, PreheaderLoad->getParent(), MemorySSA::End);
 2201   auto *MSSA = MSSAU->getMemorySSA();
 2284 static bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU,
lib/Transforms/Scalar/LoopInstSimplify.cpp
   79   MemorySSA *MSSA = MSSAU ? MSSAU->getMemorySSA() : nullptr;
  197     MemorySSA *MSSA = nullptr;
lib/Transforms/Scalar/LoopLoadElimination.cpp
  702   MemorySSA *MSSA = EnableMSSALoopDependency
lib/Transforms/Scalar/LoopRotation.cpp
  102       MemorySSA *MSSA = &getAnalysis<MemorySSAWrapperPass>().getMSSA();
lib/Transforms/Scalar/LoopSimplifyCFG.cpp
  727       MemorySSA *MSSA = &getAnalysis<MemorySSAWrapperPass>().getMSSA();
lib/Transforms/Scalar/LoopUnswitch.cpp
  185     MemorySSA *MSSA = nullptr;
lib/Transforms/Scalar/NewGVN.cpp
  495   MemorySSA *MSSA;
  658          TargetLibraryInfo *TLI, AliasAnalysis *AA, MemorySSA *MSSA,
 4233   auto &MSSA = AM.getResult<MemorySSAAnalysis>(F).getMSSA();
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp
 2429     MSSAU->moveToPlace(MD, DeoptBlock, MemorySSA::End);
 2935   MemorySSA *MSSA = nullptr;
lib/Transforms/Utils/LoopSimplify.cpp
  805   MemorySSA *MSSA = nullptr;
  841     auto *MSSA = &MSSAAnalysis->getMSSA();
lib/Transforms/Vectorize/LoopVectorize.cpp
 7879     MemorySSA *MSSA = EnableMSSALoopDependency
unittests/Analysis/MemorySSATest.cpp
   47     std::unique_ptr<MemorySSA> MSSA;
   54       MSSA = std::make_unique<MemorySSA>(*Test.F, &AA, &DT);
   91   MemorySSA &MSSA = *Analyses->MSSA;
  103       LoadInst, MP, Merge, MemorySSA::Beginning));
  130   MemorySSA &MSSA = *Analyses->MSSA;
  136       EntryStore, nullptr, Entry, MemorySSA::Beginning);
  149       FirstLoad, nullptr, Merge, MemorySSA::Beginning));
  160       LeftStore, nullptr, Left, MemorySSA::Beginning);
  173       SecondLoad, nullptr, Merge, MemorySSA::Beginning));
  185       SecondEntryStore, nullptr, Entry, MemorySSA::End);
  220   MemorySSA &MSSA = *Analyses->MSSA;
  226       Updater.createMemoryAccessInBB(SI, nullptr, Left, MemorySSA::Beginning);
  239       LoadInst, nullptr, Merge, MemorySSA::Beginning));
  271   MemorySSA &MSSA = *Analyses->MSSA;
  285                                      MemorySSA::Beginning);
  315   MemorySSA &MSSA = *Analyses->MSSA;
  351   MemorySSA &MSSA = *Analyses->MSSA;
  397   MemorySSA &MSSA = *Analyses->MSSA;
  441   MemorySSA &MSSA = *Analyses->MSSA;
  462   Updater.moveToPlace(SideStoreAccess, Right, MemorySSA::Beginning);
  496   MemorySSA &MSSA = *Analyses->MSSA;
  541   MemorySSA &MSSA = *Analyses->MSSA;
  607   MemorySSA &MSSA = *Analyses->MSSA;
  637   MemorySSA &MSSA = *Analyses->MSSA;
  666   MemorySSA &MSSA = *Analyses->MSSA;
  730   MemorySSA &MSSA = *Analyses->MSSA;
  777   MemorySSA &MSSA = *Analyses->MSSA;
  806   MemorySSA &MSSA = *Analyses->MSSA;
  818       LIA, MSSA.getMemoryAccess(SIB), LIA->getParent(), MemorySSA::End));
  844   MemorySSA &MSSA = *Analyses->MSSA;
  902   MemorySSA &MSSA = *Analyses->MSSA;
  907       LoadInst, nullptr, AfterLoopBB, MemorySSA::Beginning));
  936   MemorySSA &MSSA = *Analyses->MSSA;
  983   MemorySSA &MSSA = *Analyses->MSSA;
 1024   MemorySSA &MSSA = *Analyses->MSSA;
 1061   MemorySSA &MSSA = *Analyses->MSSA;
 1115   MemorySSA &MSSA = *Analyses->MSSA;
 1165   MemorySSA &MSSA = *Analyses->MSSA;
 1248   MemorySSA &MSSA = *Analyses->MSSA;
 1305   MemorySSA &MSSA = *Analyses->MSSA;
 1326                                       MemorySSA::InsertionPlace::End);
 1347   MemorySSA &MSSA = *Analyses->MSSA;
 1431   MemorySSA &MSSA = *Analyses->MSSA;
 1493   MemorySSA &MSSA = *Analyses->MSSA;
 1566   MemorySSA &MSSA = *Analyses->MSSA;
usr/include/c++/7.4.0/bits/unique_ptr.h
   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>