Propagate nonnull and dereferenceable throught launder

[Prazek]

Summary

invariant.group.launder should not stop propagation
of nonnull and dereferenceable, because e.g. we would not be
able to hoist loads speculatively.

[xbolva00]

Looks good

[hfinkel]

I also think that this is fine. Regarding hoisting, will we hoist the intrinsic itself or is further work necessary to enable that?

[Prazek]

In D46972#1102314, @hfinkel wrote:

I also think that this is fine. Regarding hoisting, will we hoist the intrinsic itself or is further work necessary to enable that?

define void @foo(i8* %ptr) {
entry:
  br label %loop
 
loop:
  %x = phi i8 [ 0, %entry ], [ %x.inc, %loop ]
  %p = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
  %val = load i8, i8* %p
  %x.inc = add i8 %x, %val
  br label %loop
}

is not curently hoisted by LICM, so I guess we will have to fix it.
But I have working patch for hoisting invariant.group loads:
https://reviews.llvm.org/D45151

llvm/lib/Analysis/Loads.cpp

static bool isDereferenceableAndAlignedPointer(
   if (const GCRelocateInst *RelocateInst = dyn_cast<GCRelocateInst>(V))
     return isDereferenceableAndAlignedPointer(
         RelocateInst->getDerivedPtr(), Align, Size, DL, CtxI, DT, Visited);
 
   if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V))
     return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align, Size,
                                               DL, CtxI, DT, Visited);
 
-  if (auto CS = ImmutableCallSite(V))
+  if (auto CS = ImmutableCallSite(V)) {
     if (const Value *RV = CS.getReturnedArgOperand())
       return isDereferenceableAndAlignedPointer(RV, Align, Size, DL, CtxI, DT,
                                                 Visited);
-
+    if (CS.getIntrinsicID() == Intrinsic::launder_invariant_group)
+      return isDereferenceableAndAlignedPointer(CS->getOperand(0), Align, Size,
+                                                DL, CtxI, DT, Visited);
+  }
   // If we don't know, assume the worst.
   return false;
 }
 
 bool llvm::isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
                                               const APInt &Size,
                                               const DataLayout &DL,
                                               const Instruction *CtxI,

llvm/lib/Analysis/ValueTracking.cpp

if (const Argument *A = dyn_cast<Argument>(V))
       if (A->hasByValOrInAllocaAttr() || A->hasNonNullAttr())
         return true;
 
     // A Load tagged with nonnull metadata is never null.
     if (const LoadInst *LI = dyn_cast<LoadInst>(V))
       if (LI->getMetadata(LLVMContext::MD_nonnull))
         return true;
 
-    if (auto CS = ImmutableCallSite(V))
+    if (auto CS = ImmutableCallSite(V)) {
       if (CS.isReturnNonNull())
         return true;
+      if (CS.getIntrinsicID() == Intrinsic::ID::launder_invariant_group)
+        return isKnownNonZero(CS->getOperand(0), Depth + 1, Q);
+    }
   }
 
   // The remaining tests are all recursive, so bail out if we hit the limit.
   if (Depth++ >= MaxDepth)
     return false;
 
   // Check for recursive pointer simplifications.
   if (V->getType()->isPointerTy()) {

llvm/test/Analysis/ValueTracking/deref-bitcast-of-gep.ll

loop:
   call void @use(i32 0)
   %val = load i32, i32* %ptr.i32, !invariant.load !{}
   call void @use(i32 %val)
   br label %loop
 
 leave:
   ret void
 }
+
+define void @checkLaunder(i8* align 4 dereferenceable(1024) %p) {
+; CHECK-LABEL: @checkLaunder(
+; CHECK: entry:
+; CHECK:  %l = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
+; CHECK:  %val = load i8, i8* %l
+; CHECK:  br label %loop
+; CHECK: loop:
+; CHECK:  call void @use(i32 0)
+; CHECK-NEXT:  call void @use8(i8 %val)
+
+entry:
+  %l = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
+  br label %loop
+
+loop:
+  call void @use(i32 0)
+  %val = load i8, i8* %l, !invariant.load !{}
+  call void @use8(i8 %val)
+  br label %loop
+}
+
+declare i8* @llvm.launder.invariant.group.p0i8(i8*)
+
+declare void @use8(i8)

llvm/test/Analysis/ValueTracking/invariant.group.ll

+; RUN: opt -S -instsimplify -instcombine < %s | FileCheck %s
+
+; CHECK-LABEL: define void @checkNonnull()
+define void @checkNonnull() {
+; CHECK:   %p = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %0)
+; CHECK:   %p2 = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %p)
+; CHECK:   call void @use(i8* nonnull %p2)
+entry:
+  %0 = alloca i8, align 8
+
+  %p = call i8* @llvm.launder.invariant.group.p0i8(i8* %0)
+  %p2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
+  call void @use(i8* %p2)
+
+  ret void
+}
+
+declare i8* @llvm.launder.invariant.group.p0i8(i8*)
+declare void @use(i8*)