|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/Analysis/MemorySSA.h 247 class MemoryUseOrDef : public MemoryAccess {
481 class MemoryPhi final : public MemoryAccess {
Declarations
include/llvm/Analysis/MemorySSA.h 112 class MemoryAccess;
include/llvm/Analysis/MemorySSAUpdater.h 60 class MemoryAccess;
include/llvm/Transforms/Utils/LoopUtils.h 43 class MemoryAccess;
include/llvm/Transforms/Utils/PredicateInfo.h 91 class MemoryAccess;
References
include/llvm/ADT/ilist.h 65 void addNodeToList(NodeTy *) {}
66 void removeNodeFromList(NodeTy *) {}
82 struct ilist_node_traits : ilist_alloc_traits<NodeTy>,
83 ilist_callback_traits<NodeTy> {};
89 struct ilist_traits : public ilist_node_traits<NodeTy> {};
96 template <class T> T &make();
106 static Yes &test(U *I, decltype(I->getNext(&make<NodeT>())) * = 0);
136 static Yes &test(U *I, decltype(I->createNode(make<NodeT>())) * = 0);
144 static const bool value = HasGetNext<TraitsT, NodeT>::value ||
146 HasCreateNode<TraitsT, NodeT>::value;
389 : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
389 : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
include/llvm/ADT/ilist_node.h 150 typename ilist_detail::compute_node_options<T, Options...>::type> {
include/llvm/ADT/ilist_node_options.h 108 typedef T value_type;
109 typedef T *pointer;
110 typedef T &reference;
111 typedef const T *const_pointer;
112 typedef const T &const_reference;
122 typedef node_options<T, extract_sentinel_tracking<Options...>::value,
include/llvm/ADT/iterator.h 68 : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT,
include/llvm/ADT/simple_ilist.h 79 : ilist_detail::compute_node_options<T, Options...>::type::list_base_type,
81 typename ilist_detail::compute_node_options<T, Options...>::type> {
85 typename ilist_detail::compute_node_options<T, Options...>::type;
include/llvm/Analysis/MemorySSA.h 131 using memoryaccess_def_iterator = memoryaccess_def_iterator_base<MemoryAccess>;
133 memoryaccess_def_iterator_base<const MemoryAccess>;
139 public ilist_node<MemoryAccess, ilist_tag<MSSAHelpers::AllAccessTag>>,
140 public ilist_node<MemoryAccess, ilist_tag<MSSAHelpers::DefsOnlyTag>> {
143 ilist_node<MemoryAccess, ilist_tag<MSSAHelpers::AllAccessTag>>;
145 ilist_node<MemoryAccess, ilist_tag<MSSAHelpers::DefsOnlyTag>>;
147 MemoryAccess(const MemoryAccess &) = delete;
148 MemoryAccess &operator=(const MemoryAccess &) = delete;
148 MemoryAccess &operator=(const MemoryAccess &) = delete;
232 static void deleteNode(MemoryAccess *MA) { MA->deleteValue(); }
235 inline raw_ostream &operator<<(raw_ostream &OS, const MemoryAccess &MA) {
247 class MemoryUseOrDef : public MemoryAccess {
257 MemoryAccess *getDefiningAccess() const { return getOperand(0); }
266 inline MemoryAccess *getOptimized() const;
267 inline void setOptimized(MemoryAccess *);
284 MemoryUseOrDef(LLVMContext &C, MemoryAccess *DMA, unsigned Vty,
299 void setDefiningAccess(MemoryAccess *DMA, bool Optimized = false,
323 MemoryUse(LLVMContext &C, MemoryAccess *DMA, Instruction *MI, BasicBlock *BB)
336 void setOptimized(MemoryAccess *DMA) {
345 MemoryAccess *getOptimized() const {
381 MemoryDef(LLVMContext &C, MemoryAccess *DMA, Instruction *MI, BasicBlock *BB,
394 void setOptimized(MemoryAccess *MA) {
399 MemoryAccess *getOptimized() const {
400 return cast_or_null<MemoryAccess>(getOperand(1));
481 class MemoryPhi final : public MemoryAccess {
533 MemoryAccess *getIncomingValue(unsigned I) const { return getOperand(I); }
534 void setIncomingValue(unsigned I, MemoryAccess *V) {
554 BasicBlock *getIncomingBlock(MemoryAccess::const_user_iterator I) const {
564 void addIncoming(MemoryAccess *V, BasicBlock *BB) {
582 MemoryAccess *getIncomingValueForBlock(const BasicBlock *BB) const {
624 void unorderedDeleteIncomingValue(const MemoryAccess *MA) {
678 inline MemoryAccess *MemoryUseOrDef::getOptimized() const {
684 inline void MemoryUseOrDef::setOptimized(MemoryAccess *MA) {
738 inline bool isLiveOnEntryDef(const MemoryAccess *MA) const {
742 inline MemoryAccess *getLiveOnEntryDef() const {
751 using AccessList = iplist<MemoryAccess, ilist_tag<MSSAHelpers::AllAccessTag>>;
753 simple_ilist<MemoryAccess, ilist_tag<MSSAHelpers::DefsOnlyTag>>;
772 bool locallyDominates(const MemoryAccess *A, const MemoryAccess *B) const;
772 bool locallyDominates(const MemoryAccess *A, const MemoryAccess *B) const;
776 bool dominates(const MemoryAccess *A, const MemoryAccess *B) const;
776 bool dominates(const MemoryAccess *A, const MemoryAccess *B) const;
780 bool dominates(const MemoryAccess *A, const Use &B) const;
819 void moveTo(MemoryAccess *What, BasicBlock *BB, InsertionPlace Point);
822 void renamePass(BasicBlock *BB, MemoryAccess *IncomingVal,
827 void removeFromLookups(MemoryAccess *);
828 void removeFromLists(MemoryAccess *, bool ShouldDelete = true);
829 void insertIntoListsForBlock(MemoryAccess *, const BasicBlock *,
831 void insertIntoListsBefore(MemoryAccess *, const BasicBlock *,
833 MemoryUseOrDef *createDefinedAccess(Instruction *, MemoryAccess *,
847 void prepareForMoveTo(MemoryAccess *, BasicBlock *);
848 void verifyUseInDefs(MemoryAccess *, MemoryAccess *) const;
848 void verifyUseInDefs(MemoryAccess *, MemoryAccess *) const;
856 bool dominatesUse(const MemoryAccess *, const MemoryAccess *) const;
856 bool dominatesUse(const MemoryAccess *, const MemoryAccess *) const;
861 MemoryAccess *findDominatingDef(BasicBlock *, enum InsertionPlace);
863 MemoryAccess *renameBlock(BasicBlock *, MemoryAccess *, bool);
863 MemoryAccess *renameBlock(BasicBlock *, MemoryAccess *, bool);
864 void renameSuccessorPhis(BasicBlock *, MemoryAccess *, bool);
865 void renamePass(DomTreeNode *, MemoryAccess *IncomingVal,
876 DenseMap<const Value *, MemoryAccess *> ValueToMemoryAccess;
886 std::unique_ptr<MemoryAccess, ValueDeleter> LiveOnEntryDef;
892 mutable DenseMap<const MemoryAccess *, unsigned long> BlockNumbering;
1001 using MemoryAccessSet = SmallVector<MemoryAccess *, 8>;
1025 MemoryAccess *getClobberingMemoryAccess(const Instruction *I) {
1026 MemoryAccess *MA = MSSA->getMemoryAccess(I);
1033 virtual MemoryAccess *getClobberingMemoryAccess(MemoryAccess *) = 0;
1033 virtual MemoryAccess *getClobberingMemoryAccess(MemoryAccess *) = 0;
1046 virtual MemoryAccess *getClobberingMemoryAccess(MemoryAccess *,
1046 virtual MemoryAccess *getClobberingMemoryAccess(MemoryAccess *,
1054 virtual void invalidateInfo(MemoryAccess *) {}
1070 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *) override;
1070 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *) override;
1071 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *,
1071 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *,
1075 using MemoryAccessPair = std::pair<MemoryAccess *, MemoryLocation>;
1076 using ConstMemoryAccessPair = std::pair<const MemoryAccess *, MemoryLocation>;
1082 : public iterator_facade_base<memoryaccess_def_iterator_base<T>,
1083 std::forward_iterator_tag, T, ptrdiff_t, T *,
1083 std::forward_iterator_tag, T, ptrdiff_t, T *,
1084 T *> {
1088 memoryaccess_def_iterator_base(T *Start) : Access(Start) {}
1131 T *Access = nullptr;
1154 using NodeRef = MemoryAccess *;
1163 using NodeRef = MemoryAccess *;
1164 using ChildIteratorType = MemoryAccess::iterator;
1240 MemoryAccess *OriginalAccess = nullptr;
1271 std::forward_iterator_tag, MemoryAccess *> {
1299 def_chain(T MA, MemoryAccess *UpTo = nullptr) {
include/llvm/Analysis/MemorySSAUpdater.h 65 using PhiToDefMap = SmallDenseMap<MemoryPhi *, MemoryAccess *>;
203 MemoryAccess *createMemoryAccessInBB(Instruction *I, MemoryAccess *Definition,
203 MemoryAccess *createMemoryAccessInBB(Instruction *I, MemoryAccess *Definition,
218 MemoryAccess *Definition,
221 MemoryAccess *Definition,
222 MemoryAccess *InsertPt);
230 void removeMemoryAccess(MemoryAccess *, bool OptimizePhis = false);
236 if (MemoryAccess *MA = MSSA->getMemoryAccess(I))
269 MemoryAccess *getPreviousDef(MemoryAccess *);
269 MemoryAccess *getPreviousDef(MemoryAccess *);
270 MemoryAccess *getPreviousDefInBlock(MemoryAccess *);
270 MemoryAccess *getPreviousDefInBlock(MemoryAccess *);
271 MemoryAccess *
273 DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &);
274 MemoryAccess *
276 DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &);
277 MemoryAccess *recursePhi(MemoryAccess *Phi);
277 MemoryAccess *recursePhi(MemoryAccess *Phi);
278 MemoryAccess *tryRemoveTrivialPhi(MemoryPhi *Phi);
280 MemoryAccess *tryRemoveTrivialPhi(MemoryPhi *Phi, RangeType &Operands);
include/llvm/IR/ValueHandle.h 331 ValueTy *getValPtr() const {
341 return cast<ValueTy>(InnerHandle);
344 void setValPtr(ValueTy *P) {
357 TrackingVH(ValueTy *P) { setValPtr(P); }
359 operator ValueTy*() const {
363 ValueTy *operator=(ValueTy *RHS) {
363 ValueTy *operator=(ValueTy *RHS) {
368 ValueTy *operator->() const { return getValPtr(); }
369 ValueTy &operator*() const { return *getValPtr(); }
include/llvm/Support/Casting.h 34 using SimpleType = From; // The real type this represents...
37 static SimpleType &getSimplifiedValue(From &Val) { return Val; }
41 using NonConstSimpleType = typename simplify_type<From>::SimpleType;
47 static RetType getSimplifiedValue(const From& Val) {
57 static inline bool doit(const From &Val) {
58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
76 static inline bool doit(const From &Val) {
77 return isa_impl<To, From>::doit(Val);
90 static inline bool doit(const From *Val) {
92 return isa_impl<To, From>::doit(*Val);
92 return isa_impl<To, From>::doit(*Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
142 return isa_impl_wrap<X, const Y,
142 return isa_impl_wrap<X, const Y,
143 typename simplify_type<const Y>::SimpleType>::doit(Val);
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
218 static typename cast_retty<To, From>::ret_type doit(From &Val) {
219 return cast_convert_val<To, SimpleFrom,
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
248 typename cast_retty<X, const Y>::ret_type>::type
252 X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
309 return cast<X>(Val);
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
352 typename cast_retty<X, const Y>::ret_type>::type
354 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
354 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
360 typename cast_retty<X, Y>::ret_type>::type
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/type_traits.h 55 struct add_const_past_pointer { using type = const T; };
include/llvm/Transforms/Scalar/GVNExpression.h 265 const MemoryAccess *MemoryLeader;
269 const MemoryAccess *MemoryLeader)
292 const MemoryAccess *getMemoryLeader() const { return MemoryLeader; }
293 void setMemoryLeader(const MemoryAccess *ML) { MemoryLeader = ML; }
302 const MemoryAccess *MemoryLeader)
330 const MemoryAccess *MemoryLeader)
334 const MemoryAccess *MemoryLeader)
379 const MemoryAccess *MemoryLeader)
include/llvm/Transforms/Utils/LoopUtils.h 162 SmallVectorImpl<Instruction *> &, SmallVectorImpl<MemoryAccess *> &,
lib/Analysis/MemorySSA.cpp 108 if (MemoryAccess *MA = MSSA->getMemoryAccess(BB))
114 if (MemoryAccess *MA = MSSA->getMemoryAccess(I))
344 const MemoryAccess *OriginalAccess = nullptr;
350 UpwardsMemoryQuery(const Instruction *Inst, const MemoryAccess *Access)
399 checkClobberSanity(const MemoryAccess *Start, MemoryAccess *ClobberAt,
399 checkClobberSanity(const MemoryAccess *Start, MemoryAccess *ClobberAt,
424 for (const auto *MA : def_chain(MAP.first)) {
501 MemoryAccess *First;
502 MemoryAccess *Last;
505 DefPath(const MemoryLocation &Loc, MemoryAccess *First, MemoryAccess *Last,
505 DefPath(const MemoryLocation &Loc, MemoryAccess *First, MemoryAccess *Last,
509 DefPath(const MemoryLocation &Loc, MemoryAccess *Init,
525 const MemoryAccess *getWalkTarget(const MemoryPhi *From) const {
529 MemoryAccess *Result = MSSA.getLiveOnEntryDef();
543 MemoryAccess *Result;
554 walkToPhiOrClobber(DefPath &Desc, const MemoryAccess *StopAt = nullptr,
555 const MemoryAccess *SkipStopAt = nullptr) const {
568 for (MemoryAccess *Current : def_chain(Desc.Last)) {
609 MemoryAccess *Clobber;
622 getBlockingAccess(const MemoryAccess *StopWhere,
655 const MemoryAccess *SkipStopWhere = nullptr;
764 OptznResult tryOptimizePhi(MemoryPhi *Phi, MemoryAccess *Start,
798 const auto *Target = getWalkTarget(Current);
859 MemoryAccess *DefChainEnd = nullptr;
874 for (auto *MA : def_chain(const_cast<MemoryAccess *>(Target)))
931 MemoryAccess *findClobber(MemoryAccess *Start, UpwardsMemoryQuery &Q,
931 MemoryAccess *findClobber(MemoryAccess *Start, UpwardsMemoryQuery &Q,
939 MemoryAccess *Current = Start;
949 MemoryAccess *Result;
972 MemoryAccess *IncomingVal;
975 MemoryAccess *M)
997 MemoryAccess *getClobberingMemoryAccessBase(MemoryAccess *,
997 MemoryAccess *getClobberingMemoryAccessBase(MemoryAccess *,
1006 MemoryAccess *getClobberingMemoryAccessBase(MemoryAccess *, unsigned &, bool);
1006 MemoryAccess *getClobberingMemoryAccessBase(MemoryAccess *, unsigned &, bool);
1023 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA, unsigned &UWL) {
1023 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA, unsigned &UWL) {
1026 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1026 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1032 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA) override {
1032 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA) override {
1036 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1036 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1042 void invalidateInfo(MemoryAccess *MA) override {
1059 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA, unsigned &UWL) {
1059 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA, unsigned &UWL) {
1062 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1062 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1068 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA) override {
1068 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA) override {
1072 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1072 MemoryAccess *getClobberingMemoryAccess(MemoryAccess *MA,
1078 void invalidateInfo(MemoryAccess *MA) override {
1086 void MemorySSA::renameSuccessorPhis(BasicBlock *BB, MemoryAccess *IncomingVal,
1113 MemoryAccess *MemorySSA::renameBlock(BasicBlock *BB, MemoryAccess *IncomingVal,
1113 MemoryAccess *MemorySSA::renameBlock(BasicBlock *BB, MemoryAccess *IncomingVal,
1119 for (MemoryAccess &L : *Accesses) {
1137 void MemorySSA::renamePass(DomTreeNode *Root, MemoryAccess *IncomingVal,
1244 for (MemoryAccess &MA : *Pair.second)
1301 SmallVectorImpl<MemoryAccess *> &,
1326 SmallVectorImpl<MemoryAccess *> &VersionStack,
1348 for (MemoryAccess &MA : *Accesses) {
1427 MemoryAccess *Result =
1479 SmallVector<MemoryAccess *, 16> VersionStack;
1593 void MemorySSA::insertIntoListsForBlock(MemoryAccess *NewAccess,
1625 void MemorySSA::insertIntoListsBefore(MemoryAccess *What, const BasicBlock *BB,
1653 void MemorySSA::prepareForMoveTo(MemoryAccess *What, BasicBlock *BB) {
1675 void MemorySSA::moveTo(MemoryAccess *What, BasicBlock *BB,
1701 MemoryAccess *Definition,
1790 bool MemorySSA::dominatesUse(const MemoryAccess *Replacer,
1791 const MemoryAccess *Replacee) const {
1807 void MemorySSA::removeFromLookups(MemoryAccess *MA) {
1834 void MemorySSA::removeFromLists(MemoryAccess *MA, bool ShouldDelete) {
1943 for (const MemoryAccess &MA : *Accesses) {
1967 SmallVector<MemoryAccess *, 32> ActualAccesses;
1968 SmallVector<MemoryAccess *, 32> ActualDefs;
1972 MemoryAccess *Phi = getMemoryAccess(&B);
1979 MemoryAccess *MA = getMemoryAccess(&I);
2036 MemoryAccess *MD = dyn_cast_or_null<MemoryDef>(getMemoryAccess(&I));
2049 void MemorySSA::verifyUseInDefs(MemoryAccess *Def, MemoryAccess *Use) const {
2049 void MemorySSA::verifyUseInDefs(MemoryAccess *Def, MemoryAccess *Use) const {
2100 for (const auto &I : *AL)
2108 bool MemorySSA::locallyDominates(const MemoryAccess *Dominator,
2109 const MemoryAccess *Dominatee) const {
2139 bool MemorySSA::dominates(const MemoryAccess *Dominator,
2140 const MemoryAccess *Dominatee) const {
2152 bool MemorySSA::dominates(const MemoryAccess *Dominator,
2160 return locallyDominates(Dominator, cast<MemoryAccess>(Dominatee));
2163 return dominates(Dominator, cast<MemoryAccess>(Dominatee.getUser()));
2178 MemoryAccess *UO = getDefiningAccess();
2205 MemoryAccess *MA = cast<MemoryAccess>(Op);
2205 MemoryAccess *MA = cast<MemoryAccess>(Op);
2227 MemoryAccess *UO = getDefiningAccess();
2333 MemoryAccess *
2335 MemoryAccess *StartingAccess, const MemoryLocation &Loc,
2360 MemoryAccess *DefiningAccess = isa<MemoryUse>(StartingUseOrDef)
2364 MemoryAccess *Clobber =
2374 MemoryAccess *
2376 MemoryAccess *MA, unsigned &UpwardWalkLimit, bool SkipSelf) {
2403 MemoryAccess *LiveOnEntry = MSSA->getLiveOnEntryDef();
2409 MemoryAccess *OptimizedAccess;
2412 MemoryAccess *DefiningAccess = StartingAccess->getDefiningAccess();
2436 MemoryAccess *Result;
2451 MemoryAccess *
2452 DoNothingMemorySSAWalker::getClobberingMemoryAccess(MemoryAccess *MA) {
2458 MemoryAccess *DoNothingMemorySSAWalker::getClobberingMemoryAccess(
2459 MemoryAccess *StartingAccess, const MemoryLocation &) {
lib/Analysis/MemorySSAUpdater.cpp 41 MemoryAccess *MemorySSAUpdater::getPreviousDefRecursive(
43 DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &CachedPreviousDef) {
57 MemoryAccess *Result = getPreviousDefFromEnd(Pred, CachedPreviousDef);
66 MemoryAccess *Result = MSSA->createMemoryPhi(BB);
73 SmallVector<TrackingVH<MemoryAccess>, 8> PhiOps;
79 MemoryAccess *SingleAccess = nullptr;
82 auto *IncomingAccess = getPreviousDefFromEnd(Pred, CachedPreviousDef);
97 auto *Result = tryRemoveTrivialPhi(Phi, PhiOps);
142 MemoryAccess *MemorySSAUpdater::getPreviousDef(MemoryAccess *MA) {
142 MemoryAccess *MemorySSAUpdater::getPreviousDef(MemoryAccess *MA) {
143 if (auto *LocalResult = getPreviousDefInBlock(MA))
145 DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> CachedPreviousDef;
152 MemoryAccess *MemorySSAUpdater::getPreviousDefInBlock(MemoryAccess *MA) {
152 MemoryAccess *MemorySSAUpdater::getPreviousDefInBlock(MemoryAccess *MA) {
166 for (auto &U : make_range(++MA->getReverseIterator(), End))
168 return cast<MemoryAccess>(&U);
177 MemoryAccess *MemorySSAUpdater::getPreviousDefFromEnd(
179 DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &CachedPreviousDef) {
190 MemoryAccess *MemorySSAUpdater::recursePhi(MemoryAccess *Phi) {
190 MemoryAccess *MemorySSAUpdater::recursePhi(MemoryAccess *Phi) {
193 TrackingVH<MemoryAccess> Res(Phi);
207 MemoryAccess *MemorySSAUpdater::tryRemoveTrivialPhi(MemoryPhi *Phi) {
213 MemoryAccess *MemorySSAUpdater::tryRemoveTrivialPhi(MemoryPhi *Phi,
220 MemoryAccess *Same = nullptr;
228 Same = cast<MemoryAccess>(&*Op);
272 MemoryAccess *FirstDef = &*Defs->begin();
290 MemoryAccess *NewDef) {
316 MemoryAccess *DefBefore = getPreviousDef(MD);
396 DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> CachedPreviousDef;
435 MemoryAccess *FirstDef = &*MSSA->getWritableBlockDefs(StartBlock)->begin();
456 MemoryAccess *NewDef = dyn_cast_or_null<MemoryAccess>(Var);
456 MemoryAccess *NewDef = dyn_cast_or_null<MemoryAccess>(Var);
489 auto *FirstDef = &*Defs->begin();
545 static MemoryAccess *getNewDefiningAccessForClone(MemoryAccess *MA,
545 static MemoryAccess *getNewDefiningAccessForClone(MemoryAccess *MA,
550 MemoryAccess *InsnDefining = MA;
575 if (MemoryAccess *NewDefPhi = MPhiMap.lookup(DefPhi))
589 for (const MemoryAccess &MA : *Acc) {
601 MemoryAccess *NewUseOrDef = MSSA->createDefinedAccess(
624 MemoryAccess *UniqueValue = nullptr;
627 MemoryAccess *IV = MPhi->getIncomingValue(I);
641 auto *AccFromPreheader = MPhi->getIncomingValueForBlock(Preheader);
665 MemoryAccess *IncomingAccess = Phi->getIncomingValue(It);
695 if (MemoryAccess *NewDefPhi = MPhiMap.lookup(IncPhi))
725 if (MemoryAccess *NewPhi = MPhiMap.lookup(MPhi))
980 SmallDenseMap<BasicBlock *, MemoryAccess *> LastDefAddedPred;
982 auto *DefPn = GetLastDef(AddedPred);
992 auto *LastDefForPred = LastDefAddedPred[Pred];
1000 MemoryAccess *DefP1 = GetLastDef(P1);
1023 auto *LastDefForPred = LastDefAddedPred[Pred];
1092 for (auto &DefToReplaceUses : *DefsList) {
1099 MemoryAccess *Usr = cast<MemoryAccess>(U.getUser());
1099 MemoryAccess *Usr = cast<MemoryAccess>(U.getUser());
1174 MemoryAccess *FirstInNew = nullptr;
1224 static MemoryAccess *onlySingleValue(MemoryPhi *MP) {
1225 MemoryAccess *MA = nullptr;
1229 MA = cast<MemoryAccess>(Arg);
1273 void MemorySSAUpdater::removeMemoryAccess(MemoryAccess *MA, bool OptimizePhis) {
1278 MemoryAccess *NewDefTarget = nullptr;
1353 for (MemoryAccess &MA : *Acc)
1363 MemoryAccess *MA = &*AB;
1414 MemoryAccess *MemorySSAUpdater::createMemoryAccessInBB(
1415 Instruction *I, MemoryAccess *Definition, const BasicBlock *BB,
1423 Instruction *I, MemoryAccess *Definition, MemoryUseOrDef *InsertPt) {
1433 Instruction *I, MemoryAccess *Definition, MemoryAccess *InsertPt) {
1433 Instruction *I, MemoryAccess *Definition, MemoryAccess *InsertPt) {
lib/Transforms/Scalar/EarlyCSE.cpp 780 MemoryAccess *LaterDef;
lib/Transforms/Scalar/GVNHoist.cpp 395 for (const MemoryAccess &MA : *Acc)
528 MemoryAccess *D = U->getDefiningAccess();
920 MemoryAccess *OldMA = MSSA->getMemoryAccess(I);
lib/Transforms/Scalar/LICM.cpp 355 for (const auto &MA : *Accesses) {
416 SmallVector<MemoryAccess *, 8> MSSAInsertPts;
1068 for (const auto &Acc : *Accs) {
1239 for (const auto &MA : *Accesses)
1241 auto *MD = MU->getDefiningAccess();
1269 auto *Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(SI);
1398 MemoryAccess *NewMemAcc = MSSAU->createMemoryAccessInBB(
1738 SmallVectorImpl<MemoryAccess *> &MSSAInsertPts;
1809 MemoryAccess *MSSAInsertPoint = MSSAInsertPts[i];
1810 MemoryAccess *NewMemAcc;
2129 MemoryAccess *PreheaderLoadMemoryAccess = MSSAU->createMemoryAccessInBB(
2289 MemoryAccess *Source;
2322 for (const auto &MA : *Accesses)
lib/Transforms/Scalar/LoopInstSimplify.cpp 138 if (MemoryAccess *MA = MSSA->getMemoryAccess(&I))
139 if (MemoryAccess *ReplacementMA = MSSA->getMemoryAccess(SimpleI))
lib/Transforms/Scalar/NewGVN.cpp 328 const MemoryAccess *getMemoryLeader() const { return RepMemoryAccess; }
329 void setMemoryLeader(const MemoryAccess *Leader) { RepMemoryAccess = Leader; }
409 const MemoryAccess *RepMemoryAccess = nullptr;
581 mutable DenseMap<const MemoryAccess *, SmallPtrSet<MemoryAccess *, 2>>
581 mutable DenseMap<const MemoryAccess *, SmallPtrSet<MemoryAccess *, 2>>
589 DenseMap<const MemoryAccess *, CongruenceClass *> MemoryAccessToClass;
685 const MemoryAccess *) const;
687 const MemoryAccess *) const;
689 const MemoryAccess *) const;
701 CongruenceClass *createMemoryClass(MemoryAccess *MA) {
707 CongruenceClass *ensureLeaderOfMemoryClass(MemoryAccess *MA) {
726 MemoryAccess *MemAccess, Instruction *OrigInst,
747 MemoryAccess *) const;
766 void moveMemoryToNewCongruenceClass(Instruction *, MemoryAccess *,
769 const MemoryAccess *getNextMemoryLeader(CongruenceClass *) const;
770 bool setMemoryClass(const MemoryAccess *From, CongruenceClass *To);
771 CongruenceClass *getMemoryClass(const MemoryAccess *MA) const;
772 const MemoryAccess *lookupMemoryLeader(const MemoryAccess *) const;
772 const MemoryAccess *lookupMemoryLeader(const MemoryAccess *) const;
773 bool isMemoryAccessTOP(const MemoryAccess *) const;
809 void markMemoryUsersTouched(const MemoryAccess *);
810 void markMemoryDefTouched(const MemoryAccess *);
816 void addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const;
816 void addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const;
829 bool singleReachablePHIPath(SmallPtrSet<const MemoryAccess *, 8> &,
830 const MemoryAccess *, const MemoryAccess *) const;
830 const MemoryAccess *, const MemoryAccess *) const;
834 MemoryAccess *getDefiningAccess(const MemoryAccess *) const;
834 MemoryAccess *getDefiningAccess(const MemoryAccess *) const;
843 unsigned InstrToDFSNum(const MemoryAccess *MA) const {
1251 NewGVN::createCallExpression(CallInst *CI, const MemoryAccess *MA) const {
1310 const MemoryAccess *NewGVN::lookupMemoryLeader(const MemoryAccess *MA) const {
1310 const MemoryAccess *NewGVN::lookupMemoryLeader(const MemoryAccess *MA) const {
1321 bool NewGVN::isMemoryAccessTOP(const MemoryAccess *MA) const {
1327 const MemoryAccess *MA) const {
1346 NewGVN::createStoreExpression(StoreInst *SI, const MemoryAccess *MA) const {
1369 const MemoryAccess *StoreRHS = StoreAccess->getDefiningAccess();
1417 MemoryAccess *DefiningAccess) const {
1502 MemoryAccess *OriginalAccess = getMemoryAccess(I);
1503 MemoryAccess *DefiningAccess =
1643 auto *DefiningAccess = MSSAWalker->getClobberingMemoryAccess(MA);
1652 CongruenceClass *NewGVN::getMemoryClass(const MemoryAccess *MA) const {
1660 bool NewGVN::setMemoryClass(const MemoryAccess *From,
2080 void NewGVN::addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const {
2080 void NewGVN::addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const {
2085 void NewGVN::markMemoryDefTouched(const MemoryAccess *MA) {
2089 void NewGVN::markMemoryUsersTouched(const MemoryAccess *MA) {
2146 const MemoryAccess *NewGVN::getNextMemoryLeader(CongruenceClass *CC) const {
2200 MemoryAccess *InstMA,
2405 if (MemoryAccess *MA = getMemoryAccess(I))
2450 if (MemoryAccess *MemPhi = getMemoryAccess(To))
2653 MemoryAccess *MemAccess, Instruction *OrigInst,
2880 for (const auto &Def : *MemoryBlockDefs) {
2979 if (MemoryAccess *MemPhi = getMemoryAccess(B)) {
3027 return cast<MemoryAccess>(U) != MP &&
3028 !isMemoryAccessTOP(cast<MemoryAccess>(U)) &&
3043 return lookupMemoryLeader(cast<MemoryAccess>(U));
3050 const auto *AllSameValue = *MappedBegin;
3121 SmallPtrSet<const MemoryAccess *, 8> &Visited, const MemoryAccess *First,
3121 SmallPtrSet<const MemoryAccess *, 8> &Visited, const MemoryAccess *First,
3122 const MemoryAccess *Second) const {
3137 const auto *EndDef = First;
3155 return singleReachablePHIPath(Visited, cast<MemoryAccess>(OperandList[0]),
3222 SmallPtrSet<const MemoryAccess *, 8> VisitedMAS;
unittests/Analysis/MemorySSATest.cpp 104 MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
135 MemoryAccess *EntryStoreAccess = Updater.createMemoryAccessInBB(
159 MemoryAccess *LeftStoreAccess = Updater.createMemoryAccessInBB(
184 MemoryAccess *SecondEntryStoreAccess = Updater.createMemoryAccessInBB(
225 MemoryAccess *StoreAccess =
241 MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
282 MemoryAccess * NewLoadAccess =
319 MemoryAccess *EntryStoreAccess = MSSA.getMemoryAccess(EntryStore);
320 MemoryAccess *SideStoreAccess = MSSA.getMemoryAccess(SideStore);
321 MemoryAccess *NewStoreAccess = Updater.createMemoryAccessAfter(
502 MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
549 MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
573 MemoryAccess *Operand = cast<MemoryAccess>(&*Op);
573 MemoryAccess *Operand = cast<MemoryAccess>(&*Op);
613 MemoryAccess *DefiningAccess = MSSA.getMemoryAccess(V)->getDefiningAccess();
614 MemoryAccess *WalkerClobber = Walker->getClobberingMemoryAccess(V);
640 MemoryAccess *LoadClobber = Walker->getClobberingMemoryAccess(LI);
669 MemoryAccess *StoreAccess = MSSA.getMemoryAccess(SI);
671 MemoryAccess *Clobber =
673 MemoryAccess *LiveOnEntry = Walker->getClobberingMemoryAccess(SI);
744 MemoryAccess *Load0Clobber = Walker->getClobberingMemoryAccess(ALoad0);
750 MemoryAccess *BottomClobber = Walker->getClobberingMemoryAccess(BelowPhi);
751 MemoryAccess *Phi = MSSA.getMemoryAccess(IfEnd);
756 MemoryAccess *UseClobber = Walker->getClobberingMemoryAccess(ALoad);
789 MemoryAccess *LoadClobber = Walker->getClobberingMemoryAccess(LoadMA);
810 MemoryAccess *LoadClobber = Walker->getClobberingMemoryAccess(LIA);
941 MemoryAccess *BClobber = MSSA.getWalker()->getClobberingMemoryAccess(DefB);
990 MemoryAccess *X2Clobber = MSSA.getWalker()->getClobberingMemoryAccess(DefX2);
1075 MemoryAccess *Def = MemDef->getDefiningAccess();
1076 MemoryAccess *Clob = Walker->getClobberingMemoryAccess(V);
1250 MemoryAccess *LifetimeStartAccess = MSSA.getMemoryAccess(LifetimeStart);
1253 MemoryAccess *FooAccess = MSSA.getMemoryAccess(FooStore);
1256 MemoryAccess *BarAccess = MSSA.getMemoryAccess(BarStore);
1259 MemoryAccess *FooClobber =
1263 MemoryAccess *BarClobber =
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 123 typedef _Tp value_type;
usr/include/c++/7.4.0/bits/unique_ptr.h 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;
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_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; };
1558 { 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>
1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {