[BasicAA] Add simple depth limit to avoid stack overflow (PR49151)

[nikic]

Summary

This is a simpler variant on D96647. It just adds a straightforward depth limit with a high cutoff, without introducing complex logic for BatchAA consistency. It accepts that we may cache a sub-optimal result if the depth limit is hit.

Eventually this should be more fully addressed by D96647 or similar, but in the meantime this avoids stack overflows in a cheap way.

[asbirlea]

sgtm.

llvm/lib/Analysis/BasicAliasAnalysis.cpp

AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
   // disjoint. We do this so that the rest of BasicAA does not have to deal
   // with accesses before the base pointer, and to improve cache utilization by
   // merging equivalent states.
   if (V1Size.mayBeBeforePointer() || V2Size.mayBeBeforePointer()) {
     V1Size = LocationSize::afterPointer();
     V2Size = LocationSize::afterPointer();
   }
 
+  // FIXME: If this depth limit is hit, then we may cache sub-optimal results
+  // for recursive queries. For this reason, this limit is chosen to be large
+  // enough to be very rarely hit, while still being small enough to avoid
+  // stack overflows.
+  if (AAQI.Depth >= 512)
+    return MayAlias;
+
   // Check the cache before climbing up use-def chains. This also terminates
   // otherwise infinitely recursive queries.
   AAQueryInfo::LocPair Locs(MemoryLocation(V1, V1Size, V1AAInfo),
                             MemoryLocation(V2, V2Size, V2AAInfo));
   if (V1 > V2)
     std::swap(Locs.first, Locs.second);
   const auto &Pair = AAQI.AliasCache.try_emplace(
       Locs, AAQueryInfo::CacheEntry{NoAlias, 0});