From 28e215ba63164f201292f8c77bf038b4282aa052 Mon Sep 17 00:00:00 2001
From: Nick Lewycky <nicholas@mxc.ca>
Date: Sat, 25 Feb 2012 20:19:07 +0000
Subject: [PATCH] An argument and a local identified object (eg. a noalias
 call) could turn out equal if both are null. In the test, scope type %t and
 global @y by adding a 'gep' prefix to them.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@151452 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Analysis/InstructionSimplify.cpp    | 25 +++++++++++-----------
 test/Transforms/InstSimplify/compare.ll | 38 +++++++++++++++++++++------------
 2 files changed, 37 insertions(+), 26 deletions(-)

diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp
index 11afa851597..93f55684c24 100644
--- a/lib/Analysis/InstructionSimplify.cpp
+++ b/lib/Analysis/InstructionSimplify.cpp
@@ -1626,21 +1626,22 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
   LHSPtr = stripPointerAdjustments(LHSPtr);
   if (llvm::isIdentifiedObject(LHSPtr)) {
     RHSPtr = stripPointerAdjustments(RHSPtr);
-    // If both sides are different identified objects, they aren't equal unless
-    // they're null.
-    if (LHSPtr != RHSPtr && llvm::isIdentifiedObject(RHSPtr) &&
-        (llvm::isKnownNonNull(LHSPtr) || llvm::isKnownNonNull(RHSPtr)))
-      return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
+    if (llvm::isKnownNonNull(LHSPtr) || llvm::isKnownNonNull(RHSPtr)) {
+      // If both sides are different identified objects, they aren't equal
+      // unless they're null.
+      if (LHSPtr != RHSPtr && llvm::isIdentifiedObject(RHSPtr))
+        return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
+
+      // A local identified object (alloca or noalias call) can't equal any
+      // incoming argument, unless they're both null.
+      if ((isa<Instruction>(LHSPtr) && isa<Argument>(RHSPtr)) ||
+          (isa<Instruction>(RHSPtr) && isa<Argument>(LHSPtr)))
+        return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
+    }
 
-    // Assume that the null is on the right.
+    // Assume that the constant null is on the right.
     if (llvm::isKnownNonNull(LHSPtr) && isa<ConstantPointerNull>(RHSPtr))
       return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
-
-    // A local instruction (alloca or noalias call) can't equal any incoming
-    // argument.
-    if ((isa<Instruction>(LHSPtr) && isa<Argument>(RHSPtr)) ||
-        (isa<Instruction>(RHSPtr) && isa<Argument>(LHSPtr)))
-      return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
   }
 
   // If we are comparing with zero then try hard since this is a common case.
diff --git a/test/Transforms/InstSimplify/compare.ll b/test/Transforms/InstSimplify/compare.ll
index 85aea19e695..ea43f5fa45d 100644
--- a/test/Transforms/InstSimplify/compare.ll
+++ b/test/Transforms/InstSimplify/compare.ll
@@ -41,14 +41,15 @@ define i1 @gep2() {
 }
 
 ; PR11238
-%t = type { i32, i32 }
-@y = global %t zeroinitializer, align 8
+%gept = type { i32, i32 }
+@gepy = global %gept zeroinitializer, align 8
+@gepz = extern_weak global %gept
 
 define i1 @gep3() {
 ; CHECK: @gep3
-  %x = alloca %t, align 8
-  %a = getelementptr %t* %x, i64 0, i32 0
-  %b = getelementptr %t* %x, i64 0, i32 1
+  %x = alloca %gept, align 8
+  %a = getelementptr %gept* %x, i64 0, i32 0
+  %b = getelementptr %gept* %x, i64 0, i32 1
   %equal = icmp eq i32* %a, %b
   ret i1 %equal
 ; CHECK-NEXT: ret i1 false
@@ -56,9 +57,9 @@ define i1 @gep3() {
 
 define i1 @gep4() {
 ; CHECK: @gep4
-  %x = alloca %t, align 8
-  %a = getelementptr %t* @y, i64 0, i32 0
-  %b = getelementptr %t* @y, i64 0, i32 1
+  %x = alloca %gept, align 8
+  %a = getelementptr %gept* @gepy, i64 0, i32 0
+  %b = getelementptr %gept* @gepy, i64 0, i32 1
   %equal = icmp eq i32* %a, %b
   ret i1 %equal
 ; CHECK-NEXT: ret i1 false
@@ -66,24 +67,33 @@ define i1 @gep4() {
 
 define i1 @gep5() {
 ; CHECK: @gep5
-  %x = alloca %t, align 8
-  %a = getelementptr inbounds %t* %x, i64 0, i32 1
-  %b = getelementptr %t* @y, i64 0, i32 0
+  %x = alloca %gept, align 8
+  %a = getelementptr inbounds %gept* %x, i64 0, i32 1
+  %b = getelementptr %gept* @gepy, i64 0, i32 0
   %equal = icmp eq i32* %a, %b
   ret i1 %equal
 ; CHECK-NEXT: ret i1 false
 }
 
-define i1 @gep6(%t* %x) {
+define i1 @gep6(%gept* %x) {
 ; Same as @gep3 but potentially null.
 ; CHECK: @gep6
-  %a = getelementptr %t* %x, i64 0, i32 0
-  %b = getelementptr %t* %x, i64 0, i32 1
+  %a = getelementptr %gept* %x, i64 0, i32 0
+  %b = getelementptr %gept* %x, i64 0, i32 1
   %equal = icmp eq i32* %a, %b
   ret i1 %equal
 ; CHECK-NEXT: ret i1 false
 }
 
+define i1 @gep7(%gept* %x) {
+; CHECK: @gep7
+  %a = getelementptr %gept* %x, i64 0, i32 0
+  %b = getelementptr %gept* @gepz, i64 0, i32 0
+  %equal = icmp eq i32* %a, %b
+  ret i1 %equal
+; CHECK: ret i1 %equal
+}
+
 define i1 @zext(i32 %x) {
 ; CHECK: @zext
   %e1 = zext i32 %x to i64
-- 
2.11.0