Drop nuw flag in some cases when subtracting GEPs

Author: hazzlim

llvm/include/llvm/Analysis/BasicAliasAnalysis.h

@@ -122,8 +122,7 @@ class BasicAAResult : public AAResultBase {
   bool isValueEqualInPotentialCycles(const Value *V1, const Value *V2,
                                      const AAQueryInfo &AAQI);
 
-  void subtractDecomposedGEPs(DecomposedGEP &DestGEP,
-                              const DecomposedGEP &SrcGEP,
+  void subtractDecomposedGEPs(DecomposedGEP &DestGEP, DecomposedGEP &SrcGEP,
                               const AAQueryInfo &AAQI);
 
   AliasResult aliasGEP(const GEPOperator *V1, LocationSize V1Size,

llvm/lib/Analysis/BasicAliasAnalysis.cpp

@@ -527,6 +527,8 @@ struct VariableGEPIndex {
     return Scale == Other.Scale;
   }
 
+  bool isSubtracted() const { return IsNegated || Scale.isNegative(); }
+
   void dump() const {
     print(dbgs());
     dbgs() << "\n";
@@ -561,8 +563,8 @@ struct BasicAAResult::DecomposedGEP {
     dbgs() << "\n";
   }
   void print(raw_ostream &OS) const {
-    OS << "(DecomposedGEP Base=" << Base->getName()
-       << ", Offset=" << Offset
+    OS << "(DecomposedGEP Base=" << Base->getName() << ", Offset=" << Offset
+       << ", nuw=" << ((NWFlags && NWFlags->hasNoUnsignedWrap()) ? "1" : "0")
        << ", VarIndices=[";
     for (size_t i = 0; i < VarIndices.size(); i++) {
       if (i != 0)
@@ -1238,27 +1240,26 @@ AliasResult BasicAAResult::aliasGEP(
     }
   }
 
-  // If the difference between pointers is Offset +<nuw> Indices (the variable
-  // indices all come from nuw GEPs) then we know that the addition does not
-  // wrap the pointer index type (add nuw) and the constant Offset is a lower
-  // bound on the distance between the pointers. We can then prove NoAlias via
-  // Offset u>= VLeftSize.
+  // If the difference between pointers is Offset +<nuw> Indices then we know
+  // that the addition does not wrap the pointer index type (add nuw) and the
+  // constant Offset is a lower bound on the distance between the pointers. We
+  // can then prove NoAlias via Offset u>= VLeftSize.
   //    +                +                     +
   //    | BaseOffset     |   +<nuw> Indices    |
   //    ---------------->|-------------------->|
   //    |-->VLeftSize    |                     |-------> VRightSize
   //   LHS                                    RHS
   if (!DecompGEP1.VarIndices.empty() &&
       llvm::all_of(DecompGEP1.VarIndices, [&](const VariableGEPIndex &V) {
-        return V.IsNegated == DecompGEP1.VarIndices.front().IsNegated;
+        return V.isSubtracted() == DecompGEP1.VarIndices.front().isSubtracted();
       })) {
-    APInt Off = DecompGEP1.Offset;
+    const APInt &Off = DecompGEP1.Offset;
     bool Swapped = Off.isNegative();
     LocationSize VLeftSize = Swapped ? V1Size : V2Size;
-    DecomposedGEP &DecompRight = Swapped ? DecompGEP2 : DecompGEP1;
+    const DecomposedGEP &DecompRight = Swapped ? DecompGEP2 : DecompGEP1;
 
-    bool IndicesFromRight = DecompGEP1.VarIndices.front().IsNegated == Swapped;
-    if (IndicesFromRight && DecompRight.NWFlags->hasNoUnsignedWrap())
+    bool IndicesAdded = DecompGEP1.VarIndices.front().isSubtracted() == Swapped;
+    if (IndicesAdded && DecompRight.NWFlags->hasNoUnsignedWrap())
       if (VLeftSize.hasValue() && !VLeftSize.isScalable() &&
           Off.abs().uge(VLeftSize.getValue()))
         return AliasResult::NoAlias;
@@ -1866,8 +1867,15 @@ bool BasicAAResult::isValueEqualInPotentialCycles(const Value *V,
 
 /// Computes the symbolic difference between two de-composed GEPs.
 void BasicAAResult::subtractDecomposedGEPs(DecomposedGEP &DestGEP,
-                                           const DecomposedGEP &SrcGEP,
+                                           DecomposedGEP &SrcGEP,
                                            const AAQueryInfo &AAQI) {
+  // Drop nuw flag from GEP if subtraction of constant offsets overflows in an
+  // unsigned sense.
+  if (DestGEP.Offset.ult(SrcGEP.Offset))
+    DestGEP.NWFlags = DestGEP.NWFlags->withoutNoUnsignedWrap();
+  else if (SrcGEP.Offset.ult(DestGEP.Offset) && SrcGEP.NWFlags)
+    SrcGEP.NWFlags = SrcGEP.NWFlags->withoutNoUnsignedWrap();
+
   DestGEP.Offset -= SrcGEP.Offset;
   for (const VariableGEPIndex &Src : SrcGEP.VarIndices) {
     // Find V in Dest.  This is N^2, but pointer indices almost never have more
@@ -1890,6 +1898,13 @@ void BasicAAResult::subtractDecomposedGEPs(DecomposedGEP &DestGEP,
       // If we found it, subtract off Scale V's from the entry in Dest.  If it
       // goes to zero, remove the entry.
       if (Dest.Scale != Src.Scale) {
+        // Drop nuw flag from GEP if subtraction of V's Scale overflows in an
+        // unsigned sense.
+        if (Dest.Scale.ult(Src.Scale))
+          DestGEP.NWFlags = DestGEP.NWFlags->withoutNoUnsignedWrap();
+        else if (SrcGEP.NWFlags)
+          SrcGEP.NWFlags = SrcGEP.NWFlags->withoutNoUnsignedWrap();
+
         Dest.Scale -= Src.Scale;
         Dest.IsNSW = false;
       } else {

llvm/test/Analysis/BasicAA/gep-nuw-alias.ll

@@ -140,3 +140,95 @@ define void @test_struct_nuw(ptr %st, i64 %i) {
   ret void
 }
 
+; CHECK-LABEL: constant_offset_overflow
+;
+; If subtraction of constant offsets could overflow in an unsigned sense, we
+; cannot prove the lower bound between the GEPs and so they may still alias.
+;
+; CHECK-DAG: MayAlias: i32* %a, i32* %b
+
+define void @constant_offset_overflow(ptr %p, i64 %i) {
+  %a = getelementptr i8, ptr %p, i64 -8
+  %add = getelementptr nuw i8, ptr %p, i64 4
+  %b = getelementptr nuw i8, ptr %add, i64 %i
+
+  load i32, ptr %a
+  load i32, ptr %b
+
+  ret void
+}
+
+; CHECK-LABEL: constant_offset_overflow_rev_order
+;
+; Same as above test, just verifying correct behaviour when GEPs encountered
+; in the reverse order;
+;
+; CHECK-DAG: MayAlias: i32* %a, i32* %b
+
+define void @constant_offset_overflow_rev_order(ptr %p, i64 %i) {
+  %a = getelementptr i8, ptr %p, i64 -8
+  %add = getelementptr nuw i8, ptr %p, i64 4
+  %b = getelementptr nuw i8, ptr %add, i64 %i
+
+  load i32, ptr %b
+  load i32, ptr %a
+
+  ret void
+}
+
+; CHECK-LABEL: equal_var_idx_noalias
+;
+; If GEPs have equal variable indices, we can prove NoAlias when the Scale of
+; the RHS GEP is greater, as in this scenario the constant lower bound holds.
+;
+; CHECK-DAG: NoAlias: i32* %a, i32* %b
+
+define void @equal_var_idx_noalias(ptr %p, i64 %i) {
+  %a = getelementptr i8, ptr %p, i64 %i
+
+  %add = getelementptr nuw i8, ptr %p, i64 4
+  %b = getelementptr nuw i16, ptr %add, i64 %i
+
+  load i32, ptr %a
+  load i32, ptr %b
+
+  ret void
+}
+
+; CHECK-LABEL: equal_var_idx_alias
+;
+; If GEPs have equal variable indices, we cannot prove NoAlias when the Scale of
+; the RHS GEP is ult Scale of the LHS GEP.
+;
+; CHECK-DAG: MayAlias: i32* %a, i32* %b
+
+define void @equal_var_idx_alias(ptr %p, i64 %i) {
+  %a = getelementptr i32, ptr %p, i64 %i
+
+  %add = getelementptr nuw i8, ptr %p, i64 4
+  %b = getelementptr nuw i16, ptr %add, i64 %i
+
+  load i32, ptr %b
+  load i32, ptr %a
+
+  ret void
+}
+
+; CHECK-LABEL: both_var_idx
+;
+; If the RHS GEP has unmatched variable indices, we cannot prove a constant
+; lower bound between GEPs.
+;
+; CHECK-DAG: MayAlias: i32* %a, i32* %b
+
+define void @both_var_idx(ptr %p, i64 %i, i64 %j) {
+  %a = getelementptr i8, ptr %p, i64 %i
+
+  %add = getelementptr nuw i8, ptr %p, i64 4
+  %b = getelementptr nuw i8, ptr %add, i64 %j
+
+  load i32, ptr %a
+  load i32, ptr %b
+
+  ret void
+}