185     : High(RtCheck.Pointers[Index].End), Low(RtCheck.Pointers[Index].Start),  in RuntimeCheckingPtrGroup()
186       AddressSpace(RtCheck.Pointers[Index]  in RuntimeCheckingPtrGroup()
189       NeedsFreeze(RtCheck.Pointers[Index].NeedsFreeze) {  in RuntimeCheckingPtrGroup()
271   Pointers.emplace_back(Ptr, ScStart, ScEnd, WritePtr, DepSetId, ASId, PtrExpr,  in insert()
277   // If either group contains multiple different pointers, bail out.  in tryToCreateDiffCheck()
278   // TODO: Support multiple pointers by using the minimum or maximum pointer,  in tryToCreateDiffCheck()
283   PointerInfo *Src = &Pointers[CGI.Members[0]];  in tryToCreateDiffCheck()
284   PointerInfo *Sink = &Pointers[CGJ.Members[0]];  in tryToCreateDiffCheck()
426       Index, RtCheck.Pointers[Index].Start, RtCheck.Pointers[Index].End,  in addPointer()
427       RtCheck.Pointers[Index].PointerValue->getType()->getPointerAddressSpace(),  in addPointer()
428       RtCheck.Pointers[Index].NeedsFreeze, *RtCheck.SE);  in addPointer()
436          "all pointers in a checking group must be in the same address space");  in addPointer()
466   //    - We know that pointers in the same equivalence class share  in groupChecks()
468   //      that we can compare pointers  in groupChecks()
469   //    - We wouldn't be able to merge two pointers for which we need  in groupChecks()
471   //      conveniently built such that no two pointers in the same  in groupChecks()
483   // If we need to check two pointers to the same underlying object  in groupChecks()
485   // grouping with those pointers. This is because we can easily get  in groupChecks()
502   // separate checking groups for all pointers.  in groupChecks()
507   // pointers to the same underlying object.  in groupChecks()
509     for (unsigned I = 0; I < Pointers.size(); ++I)  in groupChecks()
517   for (unsigned Index = 0; Index < Pointers.size(); ++Index) {  in groupChecks()
518     auto [It, _] = PositionMap.insert({Pointers[Index].PointerValue, {}});  in groupChecks()
522   // We need to keep track of what pointers we've already seen so we  in groupChecks()
528   // appear in 'Pointers' to enforce determinism.  in groupChecks()
529   for (unsigned I = 0; I < Pointers.size(); ++I) {  in groupChecks()
535     MemoryDepChecker::MemAccessInfo Access(Pointers[I].PointerValue,  in groupChecks()
536                                            Pointers[I].IsWritePtr);  in groupChecks()
560           // This should limit the cost of grouping the pointers to something  in groupChecks()
562           // will create separate groups for all remaining pointers.  in groupChecks()
596   const PointerInfo &PointerI = Pointers[I];  in needsChecking()
597   const PointerInfo &PointerJ = Pointers[J];  in needsChecking()
599   // No need to check if two readonly pointers intersect.  in needsChecking()
603   // Only need to check pointers between two different dependency sets.  in needsChecking()
607   // Only need to check pointers in the same alias set.  in needsChecking()
625       OS.indent(Depth + 2) << *Pointers[K].PointerValue << "\n";  in printChecks()
629       OS.indent(Depth + 2) << *Pointers[K].PointerValue << "\n";  in printChecks()
644       OS.indent(Depth + 6) << "Member: " << *Pointers[Member].Expr << "\n";  in print()
701   /// Check whether we can check the pointers at runtime for
705   /// (i.e. the pointers have computable bounds).
774   /// Set of pointers that are read only.
1084     // we don't have wrapping pointers.  in createCheckForAccess()
1086       // Skip wrap checking when translating pointers.  in createCheckForAccess()
1131   // Find pointers with computable bounds. We are going to use this information  in canCheckPtrAtRT()
1210     // We need to perform run-time alias checks, but some pointers had bounds  in canCheckPtrAtRT()
1233   // If the pointers that we would use for the bounds comparison have different  in canCheckPtrAtRT()
1238   unsigned NumPointers = RtCheck.Pointers.size();  in canCheckPtrAtRT()
1241       // Only need to check pointers between two different dependency sets.  in canCheckPtrAtRT()
1242       if (RtCheck.Pointers[i].DependencySetId ==  in canCheckPtrAtRT()
1243           RtCheck.Pointers[j].DependencySetId)  in canCheckPtrAtRT()
1245       // Only need to check pointers in the same alias set.  in canCheckPtrAtRT()
1246       if (RtCheck.Pointers[i].AliasSetId != RtCheck.Pointers[j].AliasSetId)  in canCheckPtrAtRT()
1249       Value *PtrI = RtCheck.Pointers[i].PointerValue;  in canCheckPtrAtRT()
1250       Value *PtrJ = RtCheck.Pointers[j].PointerValue;  in canCheckPtrAtRT()
1270   // are needed. This can happen when all pointers point to the same underlying  in canCheckPtrAtRT()
1281   // We process the set twice: first we process read-write pointers, last we  in processMemAccesses()
1282   // process read-only pointers. This allows us to skip dependence tests for  in processMemAccesses()
1283   // read-only pointers.  in processMemAccesses()
1297   // The AliasSetTracker has nicely partitioned our pointers by metadata  in processMemAccesses()
1309     // Map of pointers to last access encountered.  in processMemAccesses()
1316     // Iterate over each alias set twice, once to process read/write pointers,  in processMemAccesses()
1317     // and then to process read-only pointers.  in processMemAccesses()
1347           // Memorize read-only pointers for later processing and skip them in  in processMemAccesses()
1349           // write pointers). Note: we also mark pointer that are not  in processMemAccesses()
1350           // consecutive as "read-only" pointers (so that we check  in processMemAccesses()
1371           // Create sets of pointers connected by a shared alias set and  in processMemAccesses()
1562   assert(PtrA && PtrB && "Expected non-nullptr pointers.");  in getPointersDiff()
1564   // Make sure that A and B are different pointers.  in getPointersDiff()
1590     // Check that the address spaces match and that the pointers are valid.  in getPointersDiff()
1601     // Otherwise compute the distance with SCEV between the base pointers.  in getPointersDiff()
1614   // the bitcasts removal in the provided pointers.  in getPointersDiff()
1626   // Walk over the pointers, and map each of them to an offset relative to  in sortPtrAccesses()
1915   // We cannot check pointers in different address spaces.  in getDependenceDistanceStrideAndSize()
2408   PtrRtChecking->Pointers.clear();  in analyzeLoop()
2512   // Next, we find the pointers that they use.  in analyzeLoop()
2515   // care if the pointers are *restrict*.  in analyzeLoop()
2525   // Holds the analyzed pointers. We don't want to call getUnderlyingObjects  in analyzeLoop()
2625   // Find pointers with computable bounds. We are going to use this information  in analyzeLoop()