[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

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

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

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

[jdoerfert]

LGTM

llvm/lib/Analysis/ValueTracking.cpp

const Value *llvm::getArgumentAliasingToReturnedPointer(const CallBase *Call) {
   if (isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(Call))
     return Call->getArgOperand(0);
   return nullptr;
 }
 
 bool llvm::isIntrinsicReturningPointerAliasingArgumentWithoutCapturing(
     const CallBase *Call) {
   return Call->getIntrinsicID() == Intrinsic::launder_invariant_group ||
-         Call->getIntrinsicID() == Intrinsic::strip_invariant_group;
+         Call->getIntrinsicID() == Intrinsic::strip_invariant_group ||
+         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 (PN->getNumIncomingValues() != 2)

llvm/test/Analysis/BasicAA/ptrmask.ll

+; RUN: opt -basicaa -aa-eval -print-no-aliases -disable-output %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p0:48:64:128-p1:56:64:64"
+
+%struct = type <{ [20 x i64] }>
+
+; CHECK-LABEL: Function: test1: 5 pointers, 2 call sites
+; CHECK-NEXT:   NoAlias: %struct** %loc, i64* %offset.addr
+; CHECK-NEXT:   NoAlias:  %struct* %addr, %struct** %loc
+; CHECK-NEXT:   NoAlias:  %struct* %addr.ptr, %struct** %loc
+; CHECK-NEXT:   NoAlias:  %struct** %loc, i64* %gep
+define void @test1(i64* %offset.addr) {
+entry:
+  %loc = alloca %struct*, align 8
+  call void @init(i64 0, %struct** nocapture nonnull %loc)
+  %addr = load %struct*, %struct** %loc, align 8
+  %addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %addr, i64 72057594037927928)
+  %offset = load i64, i64* %offset.addr, align 8
+  %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)
+declare void @init(i64, %struct**)