Lines Matching full:accesses
71 #define DEBUG_TYPE "loop-accesses"
112 /// accesses in code like the following.
475 // the accesses are safe.
487 // accesses to the same underlying object. This cannot happen unless
513 // and add them to the overall solution. We use the order in which accesses
527 // Because DepCands is constructed by visiting accesses in the order in
621 OS.indent(Depth) << "Grouped accesses:\n";
634 /// Analyses memory accesses in a loop.
658 Accesses[MemAccessInfo(Ptr, false)].insert(AccessTy);
667 Accesses[MemAccessInfo(Ptr, true)].insert(AccessTy);
693 /// Goes over all memory accesses, checks whether a RT check is needed
694 /// and builds sets of dependent accesses.
699 /// Initial processing of memory accesses determined that we need to
717 /// Adjust the MemoryLocation so that it represents accesses to this
747 /// Map of all accesses. Values are the types used to access memory pointed to
749 PtrAccessMap Accesses;
754 /// List of accesses that need a further dependence check.
770 /// Sets of potentially dependent accesses - members of one set share an
775 /// Initial processing of memory accesses determined that we may need
781 /// cleared while this remains set if we have potentially dependent accesses.
840 // can be analyzed by adding separate accesses for each incoming pointer
1118 // Accesses between different groups doesn't need to be checked.
1128 // Accesses within the same set don't need a runtime check.
1134 // First, count how many write and read accesses are in the alias set. Also
1139 bool IsWrite = Accesses.count(MemAccessInfo(Ptr, true));
1164 for (const auto &AccessTy : Accesses[Access]) {
1190 // Reset the CanDoSetRt flag and retry all accesses that have failed.
1262 LLVM_DEBUG(dbgs() << "LAA: Processing memory accesses...\n");
1264 LLVM_DEBUG(dbgs() << "LAA: Accesses(" << Accesses.size() << "):\n");
1266 for (const auto &[A, _] : Accesses)
1297 PtrAccessMap &S = UseDeferred ? DeferredAccesses : Accesses;
1302 // For a single memory access in AliasSetTracker, Accesses may contain
1657 Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
1666 Accesses[MemAccessInfo(Ptr, false)].push_back(AccessIdx);
1779 /// memory accesses, that have strides in the same direction whose absolute
1783 /// distance is larger than the range that the accesses will travel through the
1797 // where Step is the absolute stride of the memory accesses in bytes,
1842 /// Check the dependence for two accesses with the same stride \p Stride.
1864 // Two accesses in memory (scaled distance is 2, stride is 4):
1872 // Two accesses in memory (scaled distance is 4, stride is 3):
1925 // Check if we can prove that Sink only accesses memory after Src's end or
1955 // Need accesses with constant strides and the same direction for further
1972 // invariant. We can generate a runtime check to disambiguate the accesses.
2039 // upper bound of the number of iterations), the accesses are independet, i.e.
2040 // they are far enough appart that accesses won't access the same location
2049 // Attempt to prove strided accesses independent.
2053 // If the distance between accesses and their strides are known constants,
2054 // check whether the accesses interlace each other.
2057 LLVM_DEBUG(dbgs() << "LAA: Strided accesses are independent\n");
2158 // Two accesses in memory (stride is 2):
2211 // analyze the two accesses on array B, the max safe dependence distance
2212 // is 2. Then we analyze the accesses on array A, the minimum distance needed
2262 // Check accesses within this set.
2278 for (std::vector<unsigned>::iterator I1 = Accesses[*AI].begin(),
2279 I1E = Accesses[*AI].end(); I1 != I1E; ++I1)
2280 // Scan all accesses of another equivalence class, but only the next
2281 // accesses of the same equivalent class.
2283 I2 = (OI == AI ? std::next(I1) : Accesses[*OI].begin()),
2284 I2E = (OI == AI ? I1E : Accesses[*OI].end());
2328 auto &IndexVector = Accesses.find(Access)->second;
2401 // Holds all the different accesses in the loop.
2531 AccessAnalysis Accesses(TheLoop, AA, LI, DependentAccesses, *PSE,
2569 [&Accesses, AccessTy, Loc](Value *Ptr) {
2571 Accesses.addStore(NewLoc, AccessTy);
2617 [&Accesses, AccessTy, Loc, IsReadOnlyPtr](Value *Ptr) {
2619 Accesses.addLoad(NewLoc, AccessTy, IsReadOnlyPtr);
2632 Accesses.buildDependenceSets();
2638 Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(), TheLoop,
2653 if (Accesses.isDependencyCheckNeeded()) {
2656 Accesses.getDependenciesToCheck());
2662 Accesses.resetDepChecks(*DepChecker);
2669 CanDoRTIfNeeded = Accesses.canCheckPtrAtRT(
2962 // versioning does not help resolving memory accesses/dependences, the
3058 // List the pair of accesses need run-time checks to prove independence.