[AA] Updates for D95543.

[dfukalov]

Summary

Addressing latter comments in D95543:

• AliasResult::Result renamed to AliasResult::Kind
• Offset printing added for PartialAlias case in -aa-eval
• Removed VisitedPhiBBs check from BasicAA'

[nikic]

llvm/lib/Analysis/AliasAnalysisEvaluator.cpp

56

Why not AR.swap(true);?

[dfukalov]

Addressing comment: using AliasResult::swap().

[dfukalov]

llvm/lib/Analysis/AliasAnalysisEvaluator.cpp

56

Thanks, seems it was my mental fog )

[nikic]

LGTM, thanks!

llvm/lib/Analysis/AliasAnalysisEvaluator.cpp

57

Might make sense to make true the default.

llvm/include/llvm/Analysis/AliasAnalysis.h

private:
   static_assert(AliasBits + 1 + OffsetBits <= 32,
                 "AliasResult size is intended to be 4 bytes!");
 
   unsigned int Alias : AliasBits;
   unsigned int HasOffset : 1;
   signed int Offset : OffsetBits;
 
 public:
-  enum Result : uint8_t {
+  enum Kind : uint8_t {
     /// The two locations do not alias at all.
     ///
     /// This value is arranged to convert to false, while all other values
     /// convert to true. This allows a boolean context to convert the result to
     /// a binary flag indicating whether there is the possibility of aliasing.
     NoAlias = 0,
     /// The two locations may or may not alias. This is the least precise
     /// result.
     MayAlias,
     /// The two locations alias, but only due to a partial overlap.
     PartialAlias,
     /// The two locations precisely alias each other.
     MustAlias,
   };
   static_assert(MustAlias < (1 << AliasBits),
                 "Not enough bit field size for the enum!");
 
   explicit AliasResult() = delete;
-  constexpr AliasResult(const Result &Alias)
+  constexpr AliasResult(const Kind &Alias)
       : Alias(Alias), HasOffset(false), Offset(0) {}
 
-  operator Result() const { return static_cast<Result>(Alias); }
+  operator Kind() const { return static_cast<Kind>(Alias); }
 
   constexpr bool hasOffset() const { return HasOffset; }
   constexpr int32_t getOffset() const {
     assert(HasOffset && "No offset!");
     return Offset;
   }
   void setOffset(int32_t NewOffset) {
     if (isInt<OffsetBits>(NewOffset)) {
       HasOffset = true;
       Offset = NewOffset;
     }
   }
 
   /// Helper for processing AliasResult for swapped memory location pairs.
-  void swap(bool DoSwap) {
+  void swap(bool DoSwap = true) {
     if (DoSwap && hasOffset())
       setOffset(-getOffset());
   }
 };
 
 static_assert(sizeof(AliasResult) == 4,
               "AliasResult size is intended to be 4 bytes!");
 

llvm/lib/Analysis/AliasAnalysis.cpp

raw_ostream &llvm::operator<<(raw_ostream &OS, AliasResult AR) {
   case AliasResult::MustAlias:
     OS << "MustAlias";
     break;
   case AliasResult::MayAlias:
     OS << "MayAlias";
     break;
   case AliasResult::PartialAlias:
     OS << "PartialAlias";
+    if (AR.hasOffset())
+      OS << " (off " << AR.getOffset() << ")";
     break;
   }
   return OS;
 }
 
 //===----------------------------------------------------------------------===//
 // Helper method implementation
 //===----------------------------------------------------------------------===//

llvm/lib/Analysis/AliasAnalysisEvaluator.cpp

static void PrintResults(AliasResult AR, bool P, const Value *V1,
   if (PrintAll || P) {
     std::string o1, o2;
     {
       raw_string_ostream os1(o1), os2(o2);
       V1->printAsOperand(os1, true, M);
       V2->printAsOperand(os2, true, M);
     }
 
-    if (o2 < o1)
+    if (o2 < o1) {
       std::swap(o1, o2);
+      // Change offset sign for the local AR, for printing only.
+      AR.swap();
+    }
     errs() << "  " << AR << ":\t" << o1 << ", " << o2 << "\n";
   }
 }
 
 static inline void PrintModRefResults(const char *Msg, bool P, Instruction *I,
                                       Value *Ptr, Module *M) {
   if (PrintAll || P) {
     errs() << "  " << Msg << ":  Ptr: ";

llvm/lib/Analysis/BasicAliasAnalysis.cpp

if (DecompGEP1.Offset != 0 && DecompGEP1.VarIndices.empty()) {
     }
 
     if (VLeftSize.hasValue()) {
       const uint64_t LSize = VLeftSize.getValue();
       if (Off.ult(LSize)) {
         // Conservatively drop processing if a phi was visited and/or offset is
         // too big.
         AliasResult AR = AliasResult::PartialAlias;
-        if (VisitedPhiBBs.empty() && VRightSize.hasValue() &&
-            Off.ule(INT32_MAX) && (Off + VRightSize.getValue()).ule(LSize)) {
+        if (VRightSize.hasValue() && Off.ule(INT32_MAX) &&
+            (Off + VRightSize.getValue()).ule(LSize)) {
           // Memory referenced by right pointer is nested. Save the offset in
           // cache. Note that originally offset estimated as GEP1-V2, but
           // AliasResult contains the shift that represents GEP1+Offset=V2.
           AR.setOffset(-Off.getSExtValue());
           AR.swap(Swapped);
         }
         return AR;
       }

llvm/test/Analysis/BasicAA/gep-modulo.ll

-; RUN: opt -basic-aa -aa-eval -print-all-alias-modref-info %s 2>&1 | FileCheck %s
+; RUN: opt -basic-aa -aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s
 
 target datalayout = "p:64:64:64"
 
 ; %gep.idx and %gep.6 must-alias if %mul overflows (e.g. %idx == 52).
 define void @may_overflow_mul_add_i8([16 x i8]* %ptr, i8 %idx) {
 ; CHECK-LABEL: Function: may_overflow_mul_add_i8: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.6
+; CHECK-NEXT:    PartialAlias (off 6): [16 x i8]* %ptr, i8* %gep.6
 ; CHECK-NEXT:    MayAlias:  i8* %gep.6, i8* %gep.idx
 ;
   %mul = mul i8 %idx, 5
   %add = add i8 %mul, 2
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %add
   store i8 0, i8* %gep.idx, align 1
   %gep.6 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 6
   store i8 1, i8* %gep.6, align 1
   ret void
 }
 
 define void @nuw_nsw_mul_add_i8([16 x i8]* %ptr, i8 %idx) {
 ; CHECK-LABEL: Function: nuw_nsw_mul_add_i8: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias: [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.6
+; CHECK-NEXT:    PartialAlias (off 6): [16 x i8]* %ptr, i8* %gep.6
 ; CHECK-NEXT:    NoAlias:  i8* %gep.6, i8* %gep.idx
 ;
   %mul = mul nuw nsw i8 %idx, 5
   %add = add nuw nsw i8 %mul, 2
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %add
   store i8 0, i8* %gep.idx, align 1
   %gep.6 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 6
   store i8 1, i8* %gep.6, align 1
   ret void
 }
 
 ; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 52).
 define void @may_overflow_mul_sub_i8([16 x i8]* %ptr, i8 %idx) {
 ; CHECK-LABEL: Function: may_overflow_mul_sub_i8: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    MayAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul i8 %idx, 5
   %sub = sub i8 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @nuw_nsw_mul_sub_i8([16 x i8]* %ptr, i8 %idx) {
 ; CHECK-LABEL: Function: nuw_nsw_mul_sub_i8: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul nuw nsw i8 %idx, 5
   %sub = sub nuw nsw i8 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 ; %gep.idx and %gep.3 must-alias if %mul overflows
 ; (e.g. %idx == 3689348814741910323).
 define void @may_overflow_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: may_overflow_mul_sub_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul i64 %idx, 5
   %sub = sub i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @nuw_nsw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: nuw_nsw_mul_sub_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul nuw nsw i64 %idx, 5
   %sub = sub nuw nsw i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @only_nsw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: only_nsw_mul_sub_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul nsw i64 %idx, 5
   %sub = sub nsw i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @only_nuw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: only_nuw_mul_sub_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul nuw i64 %idx, 5
   %sub = sub nuw i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @may_overflow_mul_pow2_sub_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: may_overflow_mul_pow2_sub_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul i64 %idx, 8
   %sub = sub i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 ; Multiplies by power-of-2 preserves modulo and the sub does not wrap.
 define void @mul_pow2_sub_nsw_nuw_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: mul_pow2_sub_nsw_nuw_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul i64 %idx, 8
   %sub = sub nuw nsw i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @may_overflow_shl_sub_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: may_overflow_shl_sub_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    MayAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = shl i64 %idx, 2
   %sub = sub i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @shl_sub_nsw_nuw_i64([16 x i8]* %ptr, i64 %idx) {
 ; CHECK-LABEL: Function: shl_sub_nsw_nuw_i64: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias: [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = shl i64 %idx, 3
   %sub = sub nsw nuw i64 %mul, 1
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 ; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 110).
 define void @may_overflow_i32_sext([16 x i8]* %ptr, i32 %idx) {
 ; CHECK-LABEL: Function: may_overflow_i32_sext: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias:  [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3):  [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    MayAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul i32 %idx, 678152731
   %sub = sub i32 %mul, 1582356375
   %sub.ext = sext i32 %sub to i64
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @nuw_nsw_i32_sext([16 x i8]* %ptr, i32 %idx) {
 ; CHECK-LABEL: Function: nuw_nsw_i32_sext: 3 pointers, 0 call sites
 ; CHECK-NEXT:    NoAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias:  [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3):  [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias: i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul nuw nsw i32 %idx, 678152731
   %sub = sub nuw nsw i32 %mul, 1582356375
   %sub.ext = sext i32 %sub to i64
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 ; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 110).
 define void @may_overflow_i32_zext([16 x i8]* %ptr, i32 %idx) {
 ; CHECK-LABEL: Function: may_overflow_i32_zext: 3 pointers, 0 call sites
 ; CHECK-NEXT:    MayAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias:  [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3):  [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    MayAlias:  i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul i32 %idx, 678152731
   %sub = sub i32 %mul, 1582356375
   %sub.ext = zext i32 %sub to i64
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }
 
 define void @nuw_nsw_i32_zext([16 x i8]* %ptr, i32 %idx) {
 ; CHECK-LABEL: Function: nuw_nsw_i32_zext: 3 pointers, 0 call sites
 ; CHECK-NEXT:    NoAlias:  [16 x i8]* %ptr, i8* %gep.idx
-; CHECK-NEXT:    PartialAlias:  [16 x i8]* %ptr, i8* %gep.3
+; CHECK-NEXT:    PartialAlias (off 3):  [16 x i8]* %ptr, i8* %gep.3
 ; CHECK-NEXT:    NoAlias: i8* %gep.3, i8* %gep.idx
 ;
   %mul = mul nuw nsw i32 %idx, 678152731
   %sub = sub nuw nsw i32 %mul, 1582356375
   %sub.ext = zext i32 %sub to i64
   %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
   store i8 0, i8* %gep.idx, align 1
   %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
   store i8 1, i8* %gep.3, align 1
   ret void
 }

llvm/test/Analysis/BasicAA/invariant_group.ll

 ; }
 
 %struct.A = type <{ i8*, i8 }>
 
 ; CHECK: testLaunderInvariantGroupIsNotEscapeSource
 ; CHECK-GVN: testLaunderInvariantGroupIsNotEscapeSource
 define i8 @testLaunderInvariantGroupIsNotEscapeSource() {
 ; CHECK-DAG: MustAlias: %struct.A* %a, i8* %a.bitcast
-; CHECK-DAG: PartialAlias: %struct.A* %a, i8* %n
+; CHECK-DAG: PartialAlias (off {{[0-9]+}}): %struct.A* %a, i8* %n
 ; CHECK-DAG: NoAlias: i8* %a.bitcast, i8* %n
 ; CHECK-DAG: MustAlias: %struct.A* %a, i8* %a.laundered
 ; CHECK-DAG: MustAlias: i8* %a.bitcast, i8* %a.laundered
 ; CHECK-DAG: NoAlias: i8* %a.laundered, i8* %n
-; CHECK-DAG: PartialAlias: %struct.A* %a, i8* %n.laundered
+; CHECK-DAG: PartialAlias (off {{[0-9]+}}): %struct.A* %a, i8* %n.laundered
 ; CHECK-DAG: NoAlias: i8* %a.bitcast, i8* %n.laundered
 ; CHECK-DAG: MustAlias: i8* %n, i8* %n.laundered
 ; CHECK-DAG: NoAlias: i8* %a.laundered, i8* %n.laundered
 ; CHECK-DAG: NoModRef: Ptr: %struct.A* %a <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
 ; CHECK-DAG: NoModRef: Ptr: i8* %a.bitcast <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
 ; CHECK-DAG: NoModRef: Ptr: i8* %n <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
 ; CHECK-DAG: NoModRef: Ptr: i8* %a.laundered <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
 ; CHECK-DAG: NoModRef: Ptr: i8* %n.laundered <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)

llvm/test/Analysis/BasicAA/recphi.ll

loop:
   br i1 %cmp5, label %end, label %loop
 
 end:
   ret void
 }
 
 ; CHECK-LABEL: Function: notmust: 6 pointers, 0 call sites
 ; CHECK:        MustAlias:    [2 x i32]* %tab, i8* %0
-; CHECK:        PartialAlias: [2 x i32]* %tab, i32* %arrayidx
+; CHECK:        PartialAlias (off 4): [2 x i32]* %tab, i32* %arrayidx
 ; CHECK:        NoAlias:      i32* %arrayidx, i8* %0
 ; CHECK:        MustAlias:    [2 x i32]* %tab, i32* %arrayidx1
 ; CHECK:        MustAlias:    i32* %arrayidx1, i8* %0
 ; CHECK:        NoAlias:      i32* %arrayidx, i32* %arrayidx1
 ; CHECK:        MayAlias:     [2 x i32]* %tab, i32* %p.addr.05.i
 ; CHECK:        MayAlias:     i32* %p.addr.05.i, i8* %0
 ; CHECK:        MayAlias:     i32* %arrayidx, i32* %p.addr.05.i
 ; CHECK:        MayAlias:     i32* %arrayidx1, i32* %p.addr.05.i

 if.end: ; preds = %f.exit
   ret i32 0
 }
 
 ; CHECK-LABEL: Function: reverse: 6 pointers, 0 call sites
 ; CHECK:         MustAlias:    [10 x i32]* %tab, i8* %0
 ; CHECK:         MustAlias:    [10 x i32]* %tab, i32* %arrayidx
 ; CHECK:         MustAlias:    i32* %arrayidx, i8* %0
-; CHECK:         PartialAlias: [10 x i32]* %tab, i32* %arrayidx1
+; CHECK:         PartialAlias (off 36): [10 x i32]* %tab, i32* %arrayidx1
 ; CHECK:         NoAlias:      i32* %arrayidx1, i8* %0
 ; CHECK:         NoAlias:      i32* %arrayidx, i32* %arrayidx1
 ; CHECK:         MayAlias:     [10 x i32]* %tab, i32* %p.addr.05.i
 ; CHECK:         MayAlias:     i32* %p.addr.05.i, i8* %0
 ; CHECK:         MayAlias:     i32* %arrayidx, i32* %p.addr.05.i
 ; CHECK:         MayAlias:     i32* %arrayidx1, i32* %p.addr.05.i
 ; CHECK:         MayAlias:     [10 x i32]* %tab, i32* %incdec.ptr.i
 ; CHECK:         MayAlias:     i32* %incdec.ptr.i, i8* %0

 
 if.end: ; preds = %f.exit
   ret i32 0
 }
 
 ; CHECK-LABEL: Function: negative: 6 pointers, 1 call sites
 ; CHECK:         NoAlias:      [3 x i16]* %int_arr.10, i16** %argv.6.par
 ; CHECK:         NoAlias:      i16* %_tmp1, i16** %argv.6.par
-; CHECK:         PartialAlias: [3 x i16]* %int_arr.10, i16* %_tmp1
+; CHECK:         PartialAlias (off 4): [3 x i16]* %int_arr.10, i16* %_tmp1
 ; CHECK:         NoAlias:      i16* %ls1.9.0, i16** %argv.6.par
 ; CHECK:         MayAlias:     [3 x i16]* %int_arr.10, i16* %ls1.9.0
 ; CHECK:         MayAlias:     i16* %_tmp1, i16* %ls1.9.0
 ; CHECK:         NoAlias:      i16* %_tmp7, i16** %argv.6.par
 ; CHECK:         MayAlias:     [3 x i16]* %int_arr.10, i16* %_tmp7
 ; CHECK:         MayAlias:     i16* %_tmp1, i16* %_tmp7
 ; CHECK:         NoAlias:      i16* %_tmp7, i16* %ls1.9.0
 ; CHECK:         NoAlias:      i16* %_tmp11, i16** %argv.6.par
-; CHECK:         PartialAlias: [3 x i16]* %int_arr.10, i16* %_tmp11
+; CHECK:         PartialAlias (off 2): [3 x i16]* %int_arr.10, i16* %_tmp11
 ; CHECK:         NoAlias:      i16* %_tmp1, i16* %_tmp11
 ; CHECK:         MayAlias:     i16* %_tmp11, i16* %ls1.9.0
 ; CHECK:         MayAlias:     i16* %_tmp11, i16* %_tmp7
 ; CHECK:         Both ModRef:  Ptr: i16** %argv.6.par  <->  %_tmp16 = call i16 @call(i32 %_tmp13)
 ; CHECK:         NoModRef:  Ptr: [3 x i16]* %int_arr.10        <->  %_tmp16 = call i16 @call(i32 %_tmp13)
 ; CHECK:         NoModRef:  Ptr: i16* %_tmp1   <->  %_tmp16 = call i16 @call(i32 %_tmp13)
 ; CHECK:         Both ModRef:  Ptr: i16* %ls1.9.0      <->  %_tmp16 = call i16 @call(i32 %_tmp13)
 ; CHECK:         Both ModRef:  Ptr: i16* %_tmp7        <->  %_tmp16 = call i16 @call(i32 %_tmp13)