Lines Matching defs:MemoryAccess

274 // For memory, we also track a representative MemoryAccess, and a set of memory
336   const MemoryAccess *getMemoryLeader() const { return RepMemoryAccess; }
337   void setMemoryLeader(const MemoryAccess *Leader) { RepMemoryAccess = Leader; }
418   const MemoryAccess *RepMemoryAccess = nullptr;
568   // Map from temporary operation to MemoryAccess.
595   mutable DenseMap<const MemoryAccess *, SmallPtrSet<MemoryAccess *, 2>>
600   // We could use the congruence class machinery, but the MemoryAccess's are
603   DenseMap<const MemoryAccess *, CongruenceClass *> MemoryAccessToClass;
738                                                const MemoryAccess *) const;
740                                        const MemoryAccess *) const;
742                                              const MemoryAccess *) const;
766   CongruenceClass *createMemoryClass(MemoryAccess *MA) {
772   CongruenceClass *ensureLeaderOfMemoryClass(MemoryAccess *MA) {
791                            MemoryAccess *MemAccess, Instruction *OrigInst,
808                                                 MemoryAccess *) const;
827   void moveMemoryToNewCongruenceClass(Instruction *, MemoryAccess *,
830   const MemoryAccess *getNextMemoryLeader(CongruenceClass *) const;
831   bool setMemoryClass(const MemoryAccess *From, CongruenceClass *To);
832   CongruenceClass *getMemoryClass(const MemoryAccess *MA) const;
833   const MemoryAccess *lookupMemoryLeader(const MemoryAccess *) const;
834   bool isMemoryAccessTOP(const MemoryAccess *) const;
867   void markMemoryUsersTouched(const MemoryAccess *);
868   void markMemoryDefTouched(const MemoryAccess *);
873   void addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const;
887   bool singleReachablePHIPath(SmallPtrSet<const MemoryAccess *, 8> &,
888                               const MemoryAccess *, const MemoryAccess *) const;
900   unsigned InstrToDFSNum(const MemoryAccess *MA) const {
906   // Given a MemoryAccess, return the relevant instruction DFS number.  Note:
908   // auto-convert to Value's but not to MemoryAccess's.
910     assert(isa<MemoryAccess>(MA) &&
973 // Get a MemoryAccess for an instruction, fake or real.
1314 NewGVN::createCallExpression(CallInst *CI, const MemoryAccess *MA) const {
1381 const MemoryAccess *NewGVN::lookupMemoryLeader(const MemoryAccess *MA) const {
1384          "Every MemoryAccess should be mapped to a congruence class with a "
1389 // Return true if the MemoryAccess is really equivalent to everything. This is
1392 bool NewGVN::isMemoryAccessTOP(const MemoryAccess *MA) const {
1398                                              const MemoryAccess *MA) const {
1415 NewGVN::createStoreExpression(StoreInst *SI, const MemoryAccess *MA) const {
1438   const MemoryAccess *StoreRHS = StoreAccess->getDefiningAccess();
1486                                     MemoryAccess *DefiningAccess) const {
1569   MemoryAccess *OriginalAccess = getMemoryAccess(I);
1570   MemoryAccess *DefiningAccess =
1682 // Retrieve the memory class for a given MemoryAccess.
1683 CongruenceClass *NewGVN::getMemoryClass(const MemoryAccess *MA) const {
1689 // Update the MemoryAccess equivalence table to say that From is equal to To,
1691 bool NewGVN::setMemoryClass(const MemoryAccess *From,
1694          "Every MemoryAccess should be getting mapped to a non-null class");
1698                     << " with current MemoryAccess leader ");
2122 void NewGVN::addMemoryUsers(const MemoryAccess *To, MemoryAccess *U) const {
2127 void NewGVN::markMemoryDefTouched(const MemoryAccess *MA) {
2131 void NewGVN::markMemoryUsersTouched(const MemoryAccess *MA) {
2173 // This function returns the MemoryAccess that should be the next leader of
2176 const MemoryAccess *NewGVN::getNextMemoryLeader(CongruenceClass *CC) const {
2220 // Move a MemoryAccess, currently in OldClass, to NewClass, including updates to
2230                                             MemoryAccess *InstMA,
2233   // If the leader is I, and we had a representative MemoryAccess, it should
2234   // be the MemoryAccess of OldClass.
2239          "Representative MemoryAccess mismatch");
2310       // We rely on the code below handling the MemoryAccess change.
2317   // If it's not a memory use, set the MemoryAccess equivalence
2441     if (MemoryAccess *MA = getMemoryAccess(I))
2486       if (MemoryAccess *MemPhi = getMemoryAccess(To))
2691                                  MemoryAccess *MemAccess, Instruction *OrigInst,
2910   // MemoryAccess, it is *not* the same as the actual live on entry def. We
2912   // should be checking whether the MemoryAccess is top if we want to know if it
3029   if (MemoryAccess *MemPhi = getMemoryAccess(B)) {
3077     return cast<MemoryAccess>(U) != MP &&
3078            !isMemoryAccessTOP(cast<MemoryAccess>(U)) &&
3093     return lookupMemoryLeader(cast<MemoryAccess>(U));
3104       [&AllSameValue](const MemoryAccess *V) { return V == AllSameValue; });
3174     SmallPtrSet<const MemoryAccess *, 8> &Visited, const MemoryAccess *First,
3175     const MemoryAccess *Second) const {
3185   // MemoryAccess and return true when we hit a cycle.
3207     return singleReachablePHIPath(Visited, cast<MemoryAccess>(OperandList[0]),
3233              "Representative MemoryAccess does not appear to be reverse "
3240   // Anything equivalent in the MemoryAccess table should be in the same
3246       [&](const std::pair<const MemoryAccess *, CongruenceClass *> Pair) {
3274         SmallPtrSet<const MemoryAccess *, 8> VisitedMAS;