[LAA-memchecks 1/3] Split out NumComparisons checks. NFC

[anemet]

Summary

The check for the number of memchecks will be moved to the client of
this analysis. Besides allowing for transform-specific thresholds, this
also lets Loop Distribution post-process the memchecks; Loop
Distribution only needs memchecks between pointers of different
partitions.

The motivation for this first patch is to untangle the CanDoRT check
from the NumComparison check before moving the NumComparison part.
CanDoRT means that we couldn't determine the bounds for the pointer.
Note that NumComparison is set independent of this flag.

[hfinkel]

LGTM.

lib/Analysis/LoopAccessAnalysis.cpp

1083

I know you did not change the terminology here, but I'm not quite sure what 'unsizable pointer' means. Could we say 'unknown dependence' or 'unknown bounds'?

1127

Same comment here about 'unsizable pointer'

[anemet]

lib/Analysis/LoopAccessAnalysis.cpp

1083

Sure, I think 'unknown bounds' is better.

Thanks very much for the reviews!

[anemet]

r231816 and r231821 (for the comment improvement).

Thanks, Hal!

lib/Analysis/LoopAccessAnalysis.cpp

void LoopAccessInfo::analyzeLoop(const ValueToValueMap &Strides) {
   DEBUG(dbgs() << "LAA: We need to do " << NumComparisons <<
         " pointer comparisons.\n");
 
   // If we only have one set of dependences to check pointers among we don't
   // need a runtime check.
   if (NumComparisons == 0 && NeedRTCheck)
     NeedRTCheck = false;
 
-  // Check that we did not collect too many pointers or found an unsizeable
-  // pointer.
-  if (!CanDoRT || NumComparisons > RuntimeMemoryCheckThreshold) {
-    PtrRtCheck.reset();
-    CanDoRT = false;
-  }
-
-  if (CanDoRT) {
+  // Check that we did not find an unsizeable pointer.
+  if (CanDoRT)
     DEBUG(dbgs() << "LAA: We can perform a memory runtime check if needed.\n");
-  }
-
-  if (NeedRTCheck && !CanDoRT) {
+  else if (NeedRTCheck) {
     emitAnalysis(LoopAccessReport() << "cannot identify array bounds");
     DEBUG(dbgs() << "LAA: We can't vectorize because we can't find " <<
           "the array bounds.\n");
     PtrRtCheck.reset();
     CanVecMem = false;
     return;
   }
 
+  if (NumComparisons > RuntimeMemoryCheckThreshold) {
+    emitAnalysis(LoopAccessReport()
+                 << NumComparisons << " exceeds limit of "
+                 << RuntimeMemoryCheckThreshold
+                 << " dependent memory operations checked at runtime");
+    DEBUG(dbgs() << "LAA: Too many memory checks needed.\n");
+    PtrRtCheck.reset();
+    CanVecMem = false;
+    return;
+  }
+
   PtrRtCheck.Need = NeedRTCheck;
 
   CanVecMem = true;
   if (Accesses.isDependencyCheckNeeded()) {
     DEBUG(dbgs() << "LAA: Checking memory dependencies\n");
     CanVecMem = DepChecker.areDepsSafe(
         DependentAccesses, Accesses.getDependenciesToCheck(), Strides);
     MaxSafeDepDistBytes = DepChecker.getMaxSafeDepDistBytes();
 
     if (!CanVecMem && DepChecker.shouldRetryWithRuntimeCheck()) {
       DEBUG(dbgs() << "LAA: Retrying with memory checks\n");
       NeedRTCheck = true;
 
       // Clear the dependency checks. We assume they are not needed.
       Accesses.resetDepChecks();
 
       PtrRtCheck.reset();
       PtrRtCheck.Need = true;
 
       CanDoRT = Accesses.canCheckPtrAtRT(PtrRtCheck, NumComparisons, SE,
                                          TheLoop, Strides, true);
-      // Check that we did not collect too many pointers or found an unsizeable
-      // pointer.
-      if (!CanDoRT || NumComparisons > RuntimeMemoryCheckThreshold) {
-        if (!CanDoRT && NumComparisons > 0)
-          emitAnalysis(LoopAccessReport()
-                       << "cannot check memory dependencies at runtime");
-        else
-          emitAnalysis(LoopAccessReport()
-                       << NumComparisons << " exceeds limit of "
-                       << RuntimeMemoryCheckThreshold
-                       << " dependent memory operations checked at runtime");
+      // Check that we didn't find an unsizeable pointer.
+      if (!CanDoRT && NumComparisons > 0) {
+        DEBUG(dbgs() << "LAA: Can't vectorize with memory checks\n");
+        PtrRtCheck.reset();
+        CanVecMem = false;
+        return;
+      }
+
+      // Check that we did not collect too many pointers.
+      if (NumComparisons > RuntimeMemoryCheckThreshold) {
         DEBUG(dbgs() << "LAA: Can't vectorize with memory checks\n");
         PtrRtCheck.reset();
         CanVecMem = false;
         return;
       }
 
       CanVecMem = true;
     }