llvm.noalias - Pointer comparison folding should look through them

[hfinkel]

Summary

This is part of the series started by D9375, and makes sure that pointer comparison folding that look though calls to llvm.noalias.

[reames]

This patch appears to either be missing pieces, or I'm not aware of a dependency.

[reames]

Resigning as a reviewer to get a very stale review off my list of blocking tasks in phabricator. Please reopen when desired.

[hfinkel]

Rebased.

[majnemer]

LGTM

lib/Analysis/InstructionSimplify.cpp

if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
       V = GEP->getPointerOperand();
     } else if (Operator::getOpcode(V) == Instruction::BitCast) {
       V = cast<Operator>(V)->getOperand(0);
     } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
       if (GA->mayBeOverridden())
         break;
       V = GA->getAliasee();
     } else {
+      if (IntrinsicInst *I = dyn_cast<IntrinsicInst>(V))
+        if (I->getIntrinsicID() == Intrinsic::noalias) {
+          V = I->getOperand(0);
+          continue;
+        }
+
       break;
     }
     assert(V->getType()->getScalarType()->isPointerTy() &&
            "Unexpected operand type!");
   } while (Visited.insert(V).second);
 
   Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset);
   if (V->getType()->isVectorTy())

 // If the C and C++ standards are ever made sufficiently restrictive in this
 // area, it may be possible to update LLVM's semantics accordingly and reinstate
 // this optimization.
 static Constant *computePointerICmp(const DataLayout &DL,
                                     const TargetLibraryInfo *TLI,
                                     CmpInst::Predicate Pred, Value *LHS,
                                     Value *RHS) {
   // First, skip past any trivial no-ops.
-  LHS = LHS->stripPointerCasts();
-  RHS = RHS->stripPointerCasts();
+  LHS = LHS->stripPointerCasts(/*LookThroughNoAlias*/true);
+  RHS = RHS->stripPointerCasts(/*LookThroughNoAlias*/true);
 
   // A non-null pointer is not equal to a null pointer.
   if (llvm::isKnownNonNull(LHS, TLI) && isa<ConstantPointerNull>(RHS) &&
       (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE))
     return ConstantInt::get(GetCompareTy(LHS),
                             !CmpInst::isTrueWhenEqual(Pred));
 
   // We can only fold certain predicates on pointer comparisons.

test/Transforms/InstSimplify/noalias.ll

define i8* @test2() {
   %v = call i8* @llvm.noalias.p0i8(i8* undef, metadata !1)
   ret i8* %v
 
 ; CHECK-LABEL: @test2
 ; CHECK-NOT: llvm.noalias.p0i8
 ; CHECK: ret i8* undef
 }
 
+define i1 @bitcast() {
+; CHECK-LABEL: @bitcast(
+  %a = alloca i32
+  %b = alloca i64
+  %x = bitcast i32* %a to i8*
+  %z = bitcast i64* %b to i8*
+  %y = call i8* @llvm.noalias.p0i8(i8* %z, metadata !1)
+  %cmp = icmp eq i8* %x, %y
+  ret i1 %cmp
+; CHECK-NEXT: ret i1 false
+}
+
+%gept = type { i32, i32 }
+
+define i1 @gep3() {
+; CHECK-LABEL: @gep3(
+  %x = alloca %gept, align 8
+  %a = getelementptr %gept, %gept* %x, i64 0, i32 0
+  %y = call %gept* @llvm.noalias.p0gept(%gept* %x, metadata !1)
+  %b = getelementptr %gept, %gept* %y, i64 0, i32 1
+  %equal = icmp eq i32* %a, %b
+  ret i1 %equal
+; CHECK-NEXT: ret i1 false
+}
+
 declare i8* @llvm.noalias.p0i8(i8*, metadata) nounwind
+declare %gept* @llvm.noalias.p0gept(%gept*, metadata) nounwind
 
 !0 = !{!0, !"some domain"}
 !1 = !{!1, !0, !"some scope"}