[ConstantFold] Fold the comparison of bitcasted global values

[scui]

Summary

This is to simplify icmp instructions in the form like:

%cmp = icmp eq i32 (i8*, i8*)* bitcast (i32 (i32**, i32**)* @f32 to i32 (i8*, i8*)), bitcast (i32 (i64**, i64**) @f64 to i32 (i8*, i8*)*)

Here @f32 and @f64 are two functions.

[scui]

Revert 2004-11-27-SetCCForCastLargerAndConstant.ll and PR17073.ll

[scui]

Fix previous reverion of 2004-11-27-SetCCForCastLargerAndConstant.ll and PR17073.ll

[scui]

Anyone has any comments for this patch? Any comments or suggestions are appreciated.

[efriedma]

llvm/lib/IR/ConstantFold.cpp

1759

I guess this handles the case where both operands are bitcasts due to other folds?

Is it possible to end up in a situation where one operand is a bitcast, and the other is a GEP? I guess we could leave that as an area for future improvement.

llvm/test/Transforms/InstCombine/pr32686.ll

12

I think this test needs a constant expression that won't fold to exercise the right codepath; please adjust the expression so it doesn't fold.

Same applies to the SCCP tests.

[scui]

llvm/lib/IR/ConstantFold.cpp

1759

I guess this handles the case where both operands are bitcasts due to other folds?

Yes, that's right.

Is it possible to end up in a situation where one operand is a bitcast, and the other is a GEP? I guess we could leave that as an area for future improvement.

Yes. I'll leave this for the future improvement.

llvm/test/Transforms/InstCombine/pr32686.ll

12

Thanks for the suggestion. I'll make the variables common.

[scui]

Adjust the test cases.

[efriedma]

llvm/test/Transforms/InstCombine/pr32686.ll

30

The "extra" version of this testcase isn't really helpful in this context; the version that folds will be folded away before instcombine can see it, so it's only testing constant folding itself.

If you want test coverage for additional constant expressions, please add them to the icmp folding test.

[scui]

Remove the added extra cases from the existing test files

[scui]

llvm/test/Transforms/InstCombine/pr32686.ll

30

The added test cases in this file and the sccp tests are removed. One extra test case is added in the new test file.

[efriedma]

LGTM

Do you have commit access? If not, I can commit it for you; what should I put in the git "Author" line?

[scui]

In D87850#2322762, @efriedma wrote:

LGTM

Do you have commit access? If not, I can commit it for you; what should I put in the git "Author" line?

Thanks. I don't have commit access. The author line should be --author="Shimin Cui <[e-mail]>".

llvm/lib/IR/ConstantFold.cpp

if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1) &&
     switch (CE1->getOpcode()) {
     case Instruction::Trunc:
     case Instruction::FPTrunc:
     case Instruction::FPExt:
     case Instruction::FPToUI:
     case Instruction::FPToSI:
       break; // We can't evaluate floating point casts or truncations.
 
+    case Instruction::BitCast:
+      // If this is a global value cast, check to see if the RHS is also a
+      // GlobalValue.
+      if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0))
+        if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2))
+          return areGlobalsPotentiallyEqual(GV, GV2);
+      LLVM_FALLTHROUGH;
     case Instruction::UIToFP:
     case Instruction::SIToFP:
-    case Instruction::BitCast:
     case Instruction::ZExt:
     case Instruction::SExt:
       // We can't evaluate floating point casts or truncations.
       if (CE1Op0->getType()->isFPOrFPVectorTy())
         break;
 
       // If the cast is not actually changing bits, and the second operand is a
       // null pointer, do the comparison with the pre-casted value.

llvm/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll

;
   ret i1 %C
 }
 
 ; PR28011 - https://llvm.org/bugs/show_bug.cgi?id=28011
 ; The above transform only applies to scalar integers; it shouldn't be attempted for constant expressions or vectors.
 
 @a = common global i32** null
 @b = common global [1 x i32] zeroinitializer
+@aa = alias i32**, i32*** @a
 
 define i1 @PR28011(i16 %a) {
 ; CHECK-LABEL: @PR28011(
 ; CHECK-NEXT:    [[CONV:%.*]] = sext i16 [[A:%.*]] to i32
-; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[CONV]], or (i32 zext (i1 icmp ne (i32*** bitcast ([1 x i32]* @b to i32***), i32*** @a) to i32), i32 1)
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[CONV]], or (i32 zext (i1 icmp ne (i32*** bitcast ([1 x i32]* @b to i32***), i32*** @aa) to i32), i32 1)
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+  %conv = sext i16 %a to i32
+  %cmp = icmp ne i32 %conv, or (i32 zext (i1 icmp ne (i32*** bitcast ([1 x i32]* @b to i32***), i32*** @aa) to i32), i32 1)
+  ret i1 %cmp
+}
+
+define i1 @PR28011a(i16 %a) {
+; CHECK-LABEL: @PR28011a(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i16  [[A:%.*]], 1
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %conv = sext i16 %a to i32
   %cmp = icmp ne i32 %conv, or (i32 zext (i1 icmp ne (i32*** bitcast ([1 x i32]* @b to i32***), i32*** @a) to i32), i32 1)
   ret i1 %cmp
 }
 
 define <2 x i1> @lt_signed_to_large_unsigned_vec(<2 x i8> %SB) {

llvm/test/Transforms/InstCombine/icmp-bitcast-func.ll

+; RUN: opt < %s -instcombine -S | FileCheck %s
+
+declare i32 @f32(i32**, i32**)
+
+declare i32 @f64(i64**, i64**)
+
+define i1 @icmp_func() {
+; CHECK-LABEL: @icmp_func(
+; CHECK: ret i1 false
+  %cmp = icmp eq i32 (i8*, i8*)* bitcast (i32 (i32**, i32**)* @f32 to i32 (i8*, i8*)*), bitcast (i32 (i64**, i64**)* @f64 to i32 (i8*, i8*)*)
+  ret i1 %cmp
+}
+
+define i1 @icmp_fptr(i32 (i8*, i8*)*) {
+; CHECK-LABEL: @icmp_fptr(
+; CHECK: %cmp = icmp ne i32 (i8*, i8*)* %0, bitcast (i32 (i32**, i32**)* @f32 to i32 (i8*, i8*)*)
+; CHECK: ret i1 %cmp
+  %cmp = icmp ne i32 (i8*, i8*)* bitcast (i32 (i32**, i32**)* @f32 to i32 (i8*, i8*)*), %0
+  ret i1 %cmp
+}

llvm/test/Transforms/InstCombine/pr32686.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine %s | FileCheck %s
 
 @a = external global i8
 @b = external global i32
 
 define void @tinkywinky() {
 ; CHECK-LABEL: @tinkywinky(
-; CHECK-NEXT:    [[PATATINO:%.*]] = load i8, i8* @a, align 1
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i8 [[PATATINO]], 0
-; CHECK-NEXT:    [[TMP1:%.*]] = zext i1 [[TOBOOL]] to i32
-; CHECK-NEXT:    [[OR1:%.*]] = or i32 [[TMP1]], or (i32 zext (i1 icmp ne (i32* bitcast (i8* @a to i32*), i32* @b) to i32), i32 2)
-; CHECK-NEXT:    store i32 [[OR1]], i32* @b, align 4
+; CHECK-NEXT:    store i32 3, i32* @b, align 4
 ; CHECK-NEXT:    ret void
 ;
   %patatino = load i8, i8* @a
   %tobool = icmp ne i8 %patatino, 0
   %lnot = xor i1 %tobool, true
   %lnot.ext = zext i1 %lnot to i32
   %or = or i32 xor (i32 zext (i1 icmp ne (i32* bitcast (i8* @a to i32*), i32* @b) to i32), i32 2), %lnot.ext
   store i32 %or, i32* @b, align 4
   ret void
 }

llvm/test/Transforms/SCCP/ip-ranges-select.ll

;
   %res = and i1 %call.1, %call.2
   ret i1 %res
 }
 
 @GV = external global i32
 
 define i32 @f3_constantexpr_cond(i32 %x, i32 %y) {
 ; CHECK-LABEL: define i32 @f3_constantexpr_cond(i32 %x, i32 %y)
-; CHECK-NEXT:   %sel.1 = select i1 icmp eq (i32* bitcast (i32 (i32, i32)* @f3_constantexpr_cond to i32*), i32* @GV), i32 %x, i32 %y
+; CHECK-NEXT:   %sel.1 = select i1 false, i32 %x, i32 %y
 ; CHECK-NEXT:   ret i32 %sel.1
 ;
   %sel.1 = select i1 icmp eq (i32* bitcast (i32 (i32, i32)* @f3_constantexpr_cond to i32*), i32* @GV), i32 %x, i32 %y
   ret i32 %sel.1
 }
 
 define i32 @caller3(i32 %y) {
 ; CHECK-LABEL:  define i32 @caller3(i32 %y) {

llvm/test/Transforms/SCCP/undef-resolve.ll

entry:
   ret i64 %e
 }
 
 @GV = external global i32
 
 define i32 @test11(i1 %tobool) {
 ; CHECK-LABEL: @test11(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[SHR4:%.*]] = ashr i32 undef, zext (i1 icmp eq (i32* bitcast (i32 (i1)* @test11 to i32*), i32* @GV) to i32)
+; CHECK-NEXT:    [[SHR4:%.*]] = ashr i32 undef, 0
 ; CHECK-NEXT:    ret i32 [[SHR4]]
 ;
 entry:
   %shr4 = ashr i32 undef, zext (i1 icmp eq (i32* bitcast (i32 (i1)* @test11 to i32*), i32* @GV) to i32)
   ret i32 %shr4
 }
 
 ; Test unary ops
 define double @test12(double %x) {
 ; CHECK-LABEL: @test12(
 ; CHECK-NEXT:    [[T:%.*]] = fneg double undef
 ; CHECK-NEXT:    ret double [[T]]
 ;
   %t = fneg double undef
   ret double %t
 }

llvm/test/Transforms/SimplifyCFG/PR17073.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 
 ; In PR17073 ( http://llvm.org/pr17073 ), we illegally hoisted an operation that can trap.
 ; The first test confirms that we don't do that when the trapping op is reached by the current BB (block1).
 ; The second test confirms that we don't do that when the trapping op is reached by the previous BB (entry).
 ; The third test confirms that we can still do this optimization for an operation (add) that doesn't trap.
 ; The tests must be complicated enough to prevent previous SimplifyCFG actions from optimizing away
 ; the instructions that we're checking for.
 
 target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
 target triple = "i386-apple-macosx10.9.0"
 
-@a = common global i32 0, align 4
+@g = common global i32 0, align 4
 @b = common global i8 0, align 1
+@a = alias i32, i32* @g
 
 define i32* @can_trap1() {
 ; CHECK-LABEL: @can_trap1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[EXIT:%.*]], label [[BLOCK1:%.*]]
 ; CHECK:       block1:

 
 block2:
   br label %exit
 
 exit:
   %storemerge = phi i32* [ null, %entry ],[ null, %block2 ], [ select (i1 icmp eq (i64 add (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @a) to i64)), i64 0), i32* null, i32* @a), %block1 ]
   ret i32* %storemerge
 }
+
+; The following are the original test cases using global @g, and can be simplified now.
+
+define i32* @no_trap1() {
+; CHECK-LABEL: @no_trap1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @g, align 4
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
+; CHECK-NEXT:    ret i32* null
+;
+entry:
+  %0 = load i32, i32* @g, align 4
+  %tobool = icmp eq i32 %0, 0
+  br i1 %tobool, label %exit, label %block1
+
+block1:
+  br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @g), label %exit, label %block2
+
+block2:
+  br label %exit
+
+exit:
+  %storemerge = phi i32* [ null, %entry ],[ null, %block2 ], [ select (i1 icmp eq (i64 urem (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @g) to i64)), i64 0), i32* null, i32* @g), %block1 ]
+  ret i32* %storemerge
+}
+
+define i32* @no_trap2() {
+; CHECK-LABEL: @no_trap2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @g, align 4
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
+; CHECK-NEXT:    [[STOREMERGE:%.*]] = select i1 [[TOBOOL]], i32* @g, i32* null
+; CHECK-NEXT:    ret i32* [[STOREMERGE]]
+;
+entry:
+  %0 = load i32, i32* @g, align 4
+  %tobool = icmp eq i32 %0, 0
+  br i1 %tobool, label %exit, label %block1
+
+block1:
+  br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @g), label %exit, label %block2
+
+block2:
+  br label %exit
+
+exit:
+  %storemerge = phi i32* [ select (i1 icmp eq (i64 urem (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @g) to i64)), i64 0), i32* null, i32* @g), %entry ],[ null, %block2 ], [ null, %block1 ]
+  ret i32* %storemerge
+}
+
+define i32* @no_trap3() {
+; CHECK-LABEL: @no_trap3(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @g, align 4
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
+; CHECK-NEXT:    ret i32* null
+;
+entry:
+  %0 = load i32, i32* @g, align 4
+  %tobool = icmp eq i32 %0, 0
+  br i1 %tobool, label %exit, label %block1
+
+block1:
+  br i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @g), label %exit, label %block2
+
+block2:
+  br label %exit
+
+exit:
+  %storemerge = phi i32* [ null, %entry ],[ null, %block2 ], [ select (i1 icmp eq (i64 add (i64 2, i64 zext (i1 icmp eq (i32* bitcast (i8* @b to i32*), i32* @g) to i64)), i64 0), i32* null, i32* @g), %block1 ]
+  ret i32* %storemerge
+}