[ValueTracking] Look through ptrmask intrinsics during getUnderlyingObject.

[fhahn]

Add missing attributes to @init argument.

[jdoerfert]

I'd look into this but I have trouble locating the "ptrmask" intrinsic in LLVM/Clang/LangRef. Could you help me out?

[fhahn]

In D61669#1495274, @jdoerfert wrote:

I'd look into this but I have trouble locating the "ptrmask" intrinsic in LLVM/Clang/LangRef. Could you help me out?

This missed the dependency on D59065, which proposes the ptrmask intrinsic.

[aqjune]

llvm/lib/Analysis/ValueTracking.cpp

3702 ↗

(On Diff #198611)

I found that getArgumentAliasingToReturnedPointer (which calls this function) is used at isKnownNonZero with the following pattern:

if (const auto *RP = getArgumentAliasingToReturnedPointer(Call))
  return isKnownNonZero(RP, Depth, Q);

which seems to assume that the non-zeroness of the result of a function call is equivalent to the non-zeroness of the first argument. isKnownNonZero should be fixed, or maybe we can add a boolean flag to isIntrinsicReturningPointerAliasingArgumentWithoutCapturing that allows callers to determine its purpose?

[jdoerfert]

llvm/lib/Analysis/ValueTracking.cpp

3702 ↗

(On Diff #198611)

Value::stripPointerCasts() is sometimes used with the same assumption but there is it also not given (due to address space casts). In D61607 I try to introduce a version that "keeps the bit pattern the same" to fix uses that put the result in to isKnownNonZero-like functions.

That said, I guess you can introduce an
isIntrinsicReturningPointerArgumentWithoutCapturing
to fix this issue?

[fhahn]

Handle nonnullness requirement for the use of getArgumentAliasingToReturnedPointer
in isKnownNonZero, as suggested.

Also simplified the test.

[fhahn]

llvm/lib/Analysis/ValueTracking.cpp

3702 ↗

(On Diff #198611)

Sorry for the long delay! I've added a MustPreserveNullness argument in D64150, to distinguish those 2 cases.

[jdoerfert]

LGTM

llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp

if (!GEPOp) {
         // intrinsics like launder.invariant.group, that can't be expressed with
         // the attributes, but have properties like returning aliasing pointer.
         // Because some analysis may assume that nocaptured pointer is not
         // returned from some special intrinsic (because function would have to
         // be marked with returns attribute), it is crucial to use this function
         // because it should be in sync with CaptureTracking. Not using it may
         // cause weird miscompilations where 2 aliasing pointers are assumed to
         // noalias.
-        if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true)) {
+        if (auto *RP = getArgumentAliasingToReturnedPointer(Call, false)) {
           V = RP;
           continue;
         }
       }
 
       // If it's not a GEP, hand it off to SimplifyInstruction to see if it
       // can come up with something. This matches what GetUnderlyingObject does.
       if (const Instruction *I = dyn_cast<Instruction>(V))

llvm/trunk/lib/Analysis/ValueTracking.cpp

llvm::getArgumentAliasingToReturnedPointer(const CallBase *Call,
   return nullptr;
 }
 
 bool llvm::isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(
     const CallBase *Call, bool MustPreserveNullness) {
   return Call->getIntrinsicID() == Intrinsic::launder_invariant_group ||
          Call->getIntrinsicID() == Intrinsic::strip_invariant_group ||
          Call->getIntrinsicID() == Intrinsic::aarch64_irg ||
-         Call->getIntrinsicID() == Intrinsic::aarch64_tagp;
+         Call->getIntrinsicID() == Intrinsic::aarch64_tagp ||
+         (!MustPreserveNullness &&
+          Call->getIntrinsicID() == Intrinsic::ptrmask);
 }
 
 /// \p PN defines a loop-variant pointer to an object.  Check if the
 /// previous iteration of the loop was referring to the same object as \p PN.
 static bool isSameUnderlyingObjectInLoop(const PHINode *PN,
                                          const LoopInfo *LI) {
   // Find the loop-defined value.
   Loop *L = LI->getLoopFor(PN->getParent());
if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
         // intrinsics like launder.invariant.group, that can't be expressed with
         // the attributes, but have properties like returning aliasing pointer.
         // Because some analysis may assume that nocaptured pointer is not
         // returned from some special intrinsic (because function would have to
         // be marked with returns attribute), it is crucial to use this function
         // because it should be in sync with CaptureTracking. Not using it may
         // cause weird miscompilations where 2 aliasing pointers are assumed to
         // noalias.
-        if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true)) {
+        if (auto *RP = getArgumentAliasingToReturnedPointer(Call, false)) {
           V = RP;
           continue;
         }
       }
 
       // See if InstructionSimplify knows any relevant tricks.
       if (Instruction *I = dyn_cast<Instruction>(V))
         // TODO: Acquire a DominatorTree and AssumptionCache and use them.

llvm/trunk/test/Analysis/BasicAA/ptrmask.ll

+; RUN: opt -basicaa -aa-eval -print-no-aliases -disable-output %s 2>&1 | FileCheck %s
+
+%struct = type <{ [20 x i64] }>
+
+; CHECK-LABEL: Function: test_noalias: 4 pointers, 1 call sites
+; CHECK-NEXT:  NoAlias: %struct* %ptr1, i64* %ptr2
+; CHECK-NEXT:  NoAlias: %struct* %addr.ptr, i64* %ptr2
+; CHECK-NEXT:  NoAlias: i64* %gep, i64* %ptr2
+define void @test_noalias(%struct* noalias %ptr1, i64* %ptr2, i64 %offset) {
+entry:
+  %addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %ptr1, i64 72057594037927928)
+  store i64 10, i64* %ptr2
+  %gep = getelementptr inbounds %struct, %struct* %addr.ptr, i64 0, i32 0, i64 %offset
+  store i64 1, i64* %gep, align 8
+  ret void
+}
+
+; CHECK-NEXT: Function: test_alias: 4 pointers, 1 call sites
+; CHECK-NOT: NoAlias
+define void @test_alias(%struct* %ptr1, i64* %ptr2, i64 %offset) {
+entry:
+  %addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %ptr1, i64 72057594037927928)
+  store i64 10, i64* %ptr2
+  %gep = getelementptr inbounds %struct, %struct* %addr.ptr, i64 0, i32 0, i64 %offset
+  store i64 1, i64* %gep, align 8
+  ret void
+}
+
+declare %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct*, i64)