maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/Transforms/InstCombine/icmp.ll

2474 lines
67 KiB
LLVM
Raw Normal View History

regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
convert to filecheck llvm-svn: 91810
2009-12-21 11:11:05 +08:00
; RUN: opt < %s -instcombine -S | FileCheck %s
new testcase llvm-svn: 35889
2007-04-11 14:52:24 +08:00
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32:32-p3:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
implement the first part of PR8882: when lowering an inbounds gep to explicit addressing, we know that none of the intermediate computation overflows. This could use review: it seems that the shifts certainly wouldn't overflow, but could the intermediate adds overflow if there is a negative index? Previously the testcase would instcombine to: define i1 @test(i64 %i) { %p1.idx.mask = and i64 %i, 4611686018427387903 %cmp = icmp eq i64 %p1.idx.mask, 1000 ret i1 %cmp } now we get: define i1 @test(i64 %i) { %cmp = icmp eq i64 %i, 1000 ret i1 %cmp } llvm-svn: 125271
2011-02-10 15:11:16 +08:00
new testcase llvm-svn: 35889
2007-04-11 14:52:24 +08:00
define i32 @test1(i32 %X) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test1(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[X_LOBIT:%.*]] = lshr i32 %X, 31
; CHECK-NEXT: ret i32 [[X_LOBIT]]
;
%a = icmp slt i32 %X, 0
%b = zext i1 %a to i32
ret i32 %b
new testcase llvm-svn: 35889
2007-04-11 14:52:24 +08:00
}
define i32 @test2(i32 %X) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test2(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[X_LOBIT:%.*]] = lshr i32 %X, 31
; CHECK-NEXT: [[X_LOBIT_NOT:%.*]] = xor i32 [[X_LOBIT]], 1
; CHECK-NEXT: ret i32 [[X_LOBIT_NOT]]
;
%a = icmp ult i32 %X, -2147483648
%b = zext i1 %a to i32
ret i32 %b
new testcase llvm-svn: 35889
2007-04-11 14:52:24 +08:00
}
sext of compares. llvm-svn: 35892
2007-04-11 14:57:54 +08:00
define i32 @test3(i32 %X) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test3(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[X_LOBIT:%.*]] = ashr i32 %X, 31
; CHECK-NEXT: ret i32 [[X_LOBIT]]
;
%a = icmp slt i32 %X, 0
%b = sext i1 %a to i32
ret i32 %b
sext of compares. llvm-svn: 35892
2007-04-11 14:57:54 +08:00
}
define i32 @test4(i32 %X) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test4(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[X_LOBIT:%.*]] = ashr i32 %X, 31
; CHECK-NEXT: [[X_LOBIT_NOT:%.*]] = xor i32 [[X_LOBIT]], -1
; CHECK-NEXT: ret i32 [[X_LOBIT_NOT]]
;
%a = icmp ult i32 %X, -2147483648
%b = sext i1 %a to i32
ret i32 %b
sext of compares. llvm-svn: 35892
2007-04-11 14:57:54 +08:00
}
fix PR4837, some bugs folding vector compares. These return a vector of i1, not i1 itself. llvm-svn: 80761
2009-09-02 13:12:37 +08:00
; PR4837
define <2 x i1> @test5(<2 x i64> %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test5(
; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true>
;
fix PR4837, some bugs folding vector compares. These return a vector of i1, not i1 itself. llvm-svn: 80761
2009-09-02 13:12:37 +08:00
%V = icmp eq <2 x i64> %x, undef
ret <2 x i1> %V
simplify a transformation by making it more general. llvm-svn: 83792
2009-10-12 05:22:21 +08:00
}
define i32 @test6(i32 %a, i32 %b) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test6(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[E:%.*]] = ashr i32 %a, 31
; CHECK-NEXT: [[F:%.*]] = and i32 [[E]], %b
; CHECK-NEXT: ret i32 [[F]]
;
%c = icmp sle i32 %a, -1
%d = zext i1 %c to i32
%e = sub i32 0, %d
%f = and i32 %e, %b
ret i32 %f
simplify a transformation by making it more general. llvm-svn: 83792
2009-10-12 05:22:21 +08:00
}
Optimize all cases of "icmp (X+Cst), X" to something simpler. This triggers a bunch in lencode, ldecod, spass, 176.gcc, 252.eon, among others. It is also the first part of PR5822 llvm-svn: 91811
2009-12-21 11:19:28 +08:00
define i1 @test7(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test7(
; CHECK-NEXT: [[B:%.*]] = icmp ne i32 %x, 0
; CHECK-NEXT: ret i1 [[B]]
;
Optimize all cases of "icmp (X+Cst), X" to something simpler. This triggers a bunch in lencode, ldecod, spass, 176.gcc, 252.eon, among others. It is also the first part of PR5822 llvm-svn: 91811
2009-12-21 11:19:28 +08:00
%a = add i32 %x, -1
%b = icmp ult i32 %a, %x
ret i1 %b
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test8(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test8(
; CHECK-NEXT: ret i1 false
;
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%a = add i32 %x, -1
Optimize all cases of "icmp (X+Cst), X" to something simpler. This triggers a bunch in lencode, ldecod, spass, 176.gcc, 252.eon, among others. It is also the first part of PR5822 llvm-svn: 91811
2009-12-21 11:19:28 +08:00
%b = icmp eq i32 %a, %x
ret i1 %b
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test9(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test9(
; CHECK-NEXT: [[B:%.*]] = icmp ugt i32 %x, 1
; CHECK-NEXT: ret i1 [[B]]
;
Optimize all cases of "icmp (X+Cst), X" to something simpler. This triggers a bunch in lencode, ldecod, spass, 176.gcc, 252.eon, among others. It is also the first part of PR5822 llvm-svn: 91811
2009-12-21 11:19:28 +08:00
%a = add i32 %x, -2
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%b = icmp ugt i32 %x, %a
Optimize all cases of "icmp (X+Cst), X" to something simpler. This triggers a bunch in lencode, ldecod, spass, 176.gcc, 252.eon, among others. It is also the first part of PR5822 llvm-svn: 91811
2009-12-21 11:19:28 +08:00
ret i1 %b
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test10(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test10(
; CHECK-NEXT: [[B:%.*]] = icmp ne i32 %x, -2147483648
; CHECK-NEXT: ret i1 [[B]]
;
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%a = add i32 %x, -1
%b = icmp slt i32 %a, %x
Optimize all cases of "icmp (X+Cst), X" to something simpler. This triggers a bunch in lencode, ldecod, spass, 176.gcc, 252.eon, among others. It is also the first part of PR5822 llvm-svn: 91811
2009-12-21 11:19:28 +08:00
ret i1 %b
}
enhance x-(-A) -> x+A to preserve NUW/NSW. Use the presence of NSW/NUW to fold "icmp (x+cst), x" to a constant in cases where it would otherwise be undefined behavior. Surprisingly (to me at least), this triggers hundreds of the times in a few benchmarks: lencode, ldecode, and 466.h264ref seem to *really* like this. llvm-svn: 91812
2009-12-21 12:04:05 +08:00
define i1 @test11(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test11(
; CHECK-NEXT: ret i1 true
;
enhance x-(-A) -> x+A to preserve NUW/NSW. Use the presence of NSW/NUW to fold "icmp (x+cst), x" to a constant in cases where it would otherwise be undefined behavior. Surprisingly (to me at least), this triggers hundreds of the times in a few benchmarks: lencode, ldecode, and 466.h264ref seem to *really* like this. llvm-svn: 91812
2009-12-21 12:04:05 +08:00
%a = add nsw i32 %x, 8
%b = icmp slt i32 %x, %a
ret i1 %b
}
fix PR6195, a bug constant folding scalar -> vector compares. llvm-svn: 94997
2010-02-02 04:04:40 +08:00
; PR6195
define i1 @test12(i1 %A) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test12(
; CHECK-NEXT: [[NOT_A:%.*]] = xor i1 %A, true
; CHECK-NEXT: ret i1 [[NOT_A]]
;
fix PR6195, a bug constant folding scalar -> vector compares. llvm-svn: 94997
2010-02-02 04:04:40 +08:00
%S = select i1 %A, i64 -4294967295, i64 8589934591
%B = icmp ne i64 bitcast (<2 x i32> <i32 1, i32 -1> to i64), %S
ret i1 %B
}
fix incorrect folding of icmp with undef, PR6481. llvm-svn: 97659
2010-03-04 03:46:03 +08:00
; PR6481
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test13(i8 %X) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test13(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 false
;
%cmp = icmp slt i8 undef, %X
ret i1 %cmp
fix incorrect folding of icmp with undef, PR6481. llvm-svn: 97659
2010-03-04 03:46:03 +08:00
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test14(i8 %X) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test14(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 false
;
%cmp = icmp slt i8 undef, -128
ret i1 %cmp
Constant fold x == undef to undef. llvm-svn: 107074
2010-06-29 05:30:07 +08:00
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test15() {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test15(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 undef
;
%cmp = icmp eq i8 undef, -128
ret i1 %cmp
Constant fold x == undef to undef. llvm-svn: 107074
2010-06-29 05:30:07 +08:00
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test16() {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test16(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 undef
;
%cmp = icmp ne i8 undef, -128
ret i1 %cmp
Constant fold x == undef to undef. llvm-svn: 107074
2010-06-29 05:30:07 +08:00
}
optimize: void a(int x) { if (((1<<x)&8)==0) b(); } into "x != 3", which occurs over 100 times in 403.gcc but in no other program in llvm-test. llvm-svn: 119922
2010-11-21 14:44:42 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test17(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test17(
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 %x, 3
; CHECK-NEXT: ret i1 [[CMP]]
;
optimize: void a(int x) { if (((1<<x)&8)==0) b(); } into "x != 3", which occurs over 100 times in 403.gcc but in no other program in llvm-test. llvm-svn: 119922
2010-11-21 14:44:42 +08:00
%shl = shl i32 1, %x
%and = and i32 %shl, 8
%cmp = icmp eq i32 %and, 0
ret i1 %cmp
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test17a(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test17a(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %x, 2
; CHECK-NEXT: ret i1 [[CMP]]
;
Added inst combine tarnsform for (1 << X) & C pattrens where C is (some PowerOf2 - 1) This patch can handles following cases from http://nondot.org/sabre/LLVMNotes/InstCombine.txt "((1 << X) & 7) == 0" ==> "X > 2" "((1 << X) & 7) != 0" ==> "X < 3". Differential Revision: http://reviews.llvm.org/D3678 llvm-svn: 210007
2014-06-02 15:57:24 +08:00
%shl = shl i32 1, %x
%and = and i32 %shl, 7
%cmp = icmp eq i32 %and, 0
ret i1 %cmp
}
optimize: void a(int x) { if (((1<<x)&8)==0) b(); } into "x != 3", which occurs over 100 times in 403.gcc but in no other program in llvm-test. llvm-svn: 119922
2010-11-21 14:44:42 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test18(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test18(
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 %x, 3
; CHECK-NEXT: ret i1 [[CMP]]
;
optimize: void a(int x) { if (((1<<x)&8)==0) b(); } into "x != 3", which occurs over 100 times in 403.gcc but in no other program in llvm-test. llvm-svn: 119922
2010-11-21 14:44:42 +08:00
%sh = lshr i32 8, %x
%and = and i32 %sh, 1
%cmp = icmp eq i32 %and, 0
ret i1 %cmp
}
add tests for icmp vector folds llvm-svn: 276482
2016-07-23 06:19:52 +08:00
define i1 @test19(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test19(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %x, 3
; CHECK-NEXT: ret i1 [[CMP]]
;
optimize: void a(int x) { if (((1<<x)&8)==0) b(); } into "x != 3", which occurs over 100 times in 403.gcc but in no other program in llvm-test. llvm-svn: 119922
2010-11-21 14:44:42 +08:00
%shl = shl i32 1, %x
%and = and i32 %shl, 8
%cmp = icmp eq i32 %and, 8
ret i1 %cmp
}
add tests for icmp vector folds llvm-svn: 276482
2016-07-23 06:19:52 +08:00
; FIXME: Vectors should fold the same way.
[InstCombine] use m_APInt to allow icmp eq (and X, C1), C2 folds for splat constant vectors llvm-svn: 277762
2016-08-05 04:05:02 +08:00
add tests for icmp vector folds llvm-svn: 276482
2016-07-23 06:19:52 +08:00
define <2 x i1> @test19vec(<2 x i32> %x) {
; CHECK-LABEL: @test19vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %x
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> [[SHL]], <i32 8, i32 8>
[InstCombine] use m_APInt to allow icmp eq (and X, C1), C2 folds for splat constant vectors llvm-svn: 277762
2016-08-05 04:05:02 +08:00
; CHECK-NEXT: [[CMP:%.*]] = icmp ne <2 x i32> [[AND]], zeroinitializer
add tests for icmp vector folds llvm-svn: 276482
2016-07-23 06:19:52 +08:00
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %x
%and = and <2 x i32> %shl, <i32 8, i32 8>
%cmp = icmp eq <2 x i32> %and, <i32 8, i32 8>
ret <2 x i1> %cmp
}
define <2 x i1> @cmp_and_signbit_vec(<2 x i3> %x) {
; CHECK-LABEL: @cmp_and_signbit_vec(
[InstCombine] use m_APInt to allow icmp eq (and X, C1), C2 folds for splat constant vectors llvm-svn: 277762
2016-08-05 04:05:02 +08:00
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i3> %x, zeroinitializer
add tests for icmp vector folds llvm-svn: 276482
2016-07-23 06:19:52 +08:00
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%and = and <2 x i3> %x, <i3 4, i3 4>
%cmp = icmp ne <2 x i3> %and, zeroinitializer
ret <2 x i1> %cmp
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test20(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test20(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %x, 3
; CHECK-NEXT: ret i1 [[CMP]]
;
optimize: void a(int x) { if (((1<<x)&8)==0) b(); } into "x != 3", which occurs over 100 times in 403.gcc but in no other program in llvm-test. llvm-svn: 119922
2010-11-21 14:44:42 +08:00
%shl = shl i32 1, %x
%and = and i32 %shl, 8
%cmp = icmp ne i32 %and, 0
ret i1 %cmp
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test20a(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test20a(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %x, 3
; CHECK-NEXT: ret i1 [[CMP]]
;
Added inst combine tarnsform for (1 << X) & C pattrens where C is (some PowerOf2 - 1) This patch can handles following cases from http://nondot.org/sabre/LLVMNotes/InstCombine.txt "((1 << X) & 7) == 0" ==> "X > 2" "((1 << X) & 7) != 0" ==> "X < 3". Differential Revision: http://reviews.llvm.org/D3678 llvm-svn: 210007
2014-06-02 15:57:24 +08:00
%shl = shl i32 1, %x
%and = and i32 %shl, 7
%cmp = icmp ne i32 %and, 0
ret i1 %cmp
}
Fix a random missed optimization by making InstCombine more aggressive when determining which bits are demanded by a comparison against a constant. llvm-svn: 123203
2011-01-11 08:36:45 +08:00
define i1 @test21(i8 %x, i8 %y) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test21(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[B:%.*]] = icmp ugt i8 %x, 3
; CHECK-NEXT: ret i1 [[B]]
;
Fix a random missed optimization by making InstCombine more aggressive when determining which bits are demanded by a comparison against a constant. llvm-svn: 123203
2011-01-11 08:36:45 +08:00
%A = or i8 %x, 1
%B = icmp ugt i8 %A, 3
ret i1 %B
}
define i1 @test22(i8 %x, i8 %y) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test22(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[B:%.*]] = icmp ult i8 %x, 4
; CHECK-NEXT: ret i1 [[B]]
;
Fix a random missed optimization by making InstCombine more aggressive when determining which bits are demanded by a comparison against a constant. llvm-svn: 123203
2011-01-11 08:36:45 +08:00
%A = or i8 %x, 1
%B = icmp ult i8 %A, 4
ret i1 %B
}
merge two tests. llvm-svn: 125195
2011-02-10 01:06:41 +08:00
; PR2740
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
define i1 @test23(i32 %x) {
Update Transforms tests to use CHECK-LABEL for easier debugging. No functionality change. This update was done with the following bash script: find test/Transforms -name "*.ll" | \ while read NAME; do echo "$NAME" if ! grep -q "^; *RUN: *llc" $NAME; then TEMP=`mktemp -t temp` cp $NAME $TEMP sed -n "s/^define [^@]*@\([A-Za-z0-9_]*\)(.*$/\1/p" < $NAME | \ while read FUNC; do sed -i '' "s/;\(.*\)\([A-Za-z0-9_]*\):\( *\)@$FUNC\([( ]*\)\$/;\1\2-LABEL:\3@$FUNC(/g" $TEMP done mv $TEMP $NAME fi done llvm-svn: 186268
2013-07-14 09:42:54 +08:00
; CHECK-LABEL: @test23(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: [[I4:%.*]] = icmp sgt i32 %x, 1328634634
; CHECK-NEXT: ret i1 [[I4]]
;
%i3 = sdiv i32 %x, -1328634635
%i4 = icmp eq i32 %i3, -1
ret i1 %i4
merge two tests. llvm-svn: 125195
2011-02-10 01:06:41 +08:00
}
implement the first part of PR8882: when lowering an inbounds gep to explicit addressing, we know that none of the intermediate computation overflows. This could use review: it seems that the shifts certainly wouldn't overflow, but could the intermediate adds overflow if there is a negative index? Previously the testcase would instcombine to: define i1 @test(i64 %i) { %p1.idx.mask = and i64 %i, 4611686018427387903 %cmp = icmp eq i64 %p1.idx.mask, 1000 ret i1 %cmp } now we get: define i1 @test(i64 %i) { %cmp = icmp eq i64 %i, 1000 ret i1 %cmp } llvm-svn: 125271
2011-02-10 15:11:16 +08:00
[InstCombine] add test for missing vector icmp fold llvm-svn: 278727
2016-08-16 04:02:40 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @test23vec(<2 x i32> %x) {
; CHECK-LABEL: @test23vec(
; CHECK-NEXT: [[I3:%.*]] = sdiv <2 x i32> %x, <i32 -1328634635, i32 -1328634635>
; CHECK-NEXT: [[I4:%.*]] = icmp eq <2 x i32> [[I3]], <i32 -1, i32 -1>
; CHECK-NEXT: ret <2 x i1> [[I4]]
;
%i3 = sdiv <2 x i32> %x, <i32 -1328634635, i32 -1328634635>
%i4 = icmp eq <2 x i32> %i3, <i32 -1, i32 -1>
ret <2 x i1> %i4
}
implement the first part of PR8882: when lowering an inbounds gep to explicit addressing, we know that none of the intermediate computation overflows. This could use review: it seems that the shifts certainly wouldn't overflow, but could the intermediate adds overflow if there is a negative index? Previously the testcase would instcombine to: define i1 @test(i64 %i) { %p1.idx.mask = and i64 %i, 4611686018427387903 %cmp = icmp eq i64 %p1.idx.mask, 1000 ret i1 %cmp } now we get: define i1 @test(i64 %i) { %cmp = icmp eq i64 %i, 1000 ret i1 %cmp } llvm-svn: 125271
2011-02-10 15:11:16 +08:00
@X = global [1000 x i32] zeroinitializer
; PR8882
define i1 @test24(i64 %i) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test24(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i64 %i, 1000
; CHECK-NEXT: ret i1 [[CMP]]
;
[opaque pointer type] Add textual IR support for explicit type parameter to gep operator Similar to gep (r230786) and load (r230794) changes. Similar migration script can be used to update test cases, which successfully migrated all of LLVM and Polly, but about 4 test cases needed manually changes in Clang. (this script will read the contents of stdin and massage it into stdout - wrap it in the 'apply.sh' script shown in previous commits + xargs to apply it over a large set of test cases) import fileinput import sys import re rep = re.compile(r"(getelementptr(?:\s+inbounds)?\s*\()((<\d*\s+x\s+)?([^@]*?)(|\s*addrspace\(\d+\))\s*\*(?(3)>)\s*)(?=$|%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|zeroinitializer|<|\[\[[a-zA-Z]|\{\{)", re.MULTILINE | re.DOTALL) def conv(match): line = match.group(1) line += match.group(4) line += ", " line += match.group(2) return line line = sys.stdin.read() off = 0 for match in re.finditer(rep, line): sys.stdout.write(line[off:match.start()]) sys.stdout.write(conv(match)) off = match.end() sys.stdout.write(line[off:]) llvm-svn: 232184
2015-03-14 02:20:45 +08:00
%p1 = getelementptr inbounds i32, i32* getelementptr inbounds ([1000 x i32], [1000 x i32]* @X, i64 0, i64 0), i64 %i
%cmp = icmp eq i32* %p1, getelementptr inbounds ([1000 x i32], [1000 x i32]* @X, i64 1, i64 0)
implement the first part of PR8882: when lowering an inbounds gep to explicit addressing, we know that none of the intermediate computation overflows. This could use review: it seems that the shifts certainly wouldn't overflow, but could the intermediate adds overflow if there is a negative index? Previously the testcase would instcombine to: define i1 @test(i64 %i) { %p1.idx.mask = and i64 %i, 4611686018427387903 %cmp = icmp eq i64 %p1.idx.mask, 1000 ret i1 %cmp } now we get: define i1 @test(i64 %i) { %cmp = icmp eq i64 %i, 1000 ret i1 %cmp } llvm-svn: 125271
2011-02-10 15:11:16 +08:00
ret i1 %cmp
}
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
@X_as1 = addrspace(1) global [1000 x i32] zeroinitializer
define i1 @test24_as1(i64 %i) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test24_as1(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 %i to i16
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i16 [[TMP1]], 1000
; CHECK-NEXT: ret i1 [[CMP]]
;
[opaque pointer type] Add textual IR support for explicit type parameter to gep operator Similar to gep (r230786) and load (r230794) changes. Similar migration script can be used to update test cases, which successfully migrated all of LLVM and Polly, but about 4 test cases needed manually changes in Clang. (this script will read the contents of stdin and massage it into stdout - wrap it in the 'apply.sh' script shown in previous commits + xargs to apply it over a large set of test cases) import fileinput import sys import re rep = re.compile(r"(getelementptr(?:\s+inbounds)?\s*\()((<\d*\s+x\s+)?([^@]*?)(|\s*addrspace\(\d+\))\s*\*(?(3)>)\s*)(?=$|%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|zeroinitializer|<|\[\[[a-zA-Z]|\{\{)", re.MULTILINE | re.DOTALL) def conv(match): line = match.group(1) line += match.group(4) line += ", " line += match.group(2) return line line = sys.stdin.read() off = 0 for match in re.finditer(rep, line): sys.stdout.write(line[off:match.start()]) sys.stdout.write(conv(match)) off = match.end() sys.stdout.write(line[off:]) llvm-svn: 232184
2015-03-14 02:20:45 +08:00
%p1 = getelementptr inbounds i32, i32 addrspace(1)* getelementptr inbounds ([1000 x i32], [1000 x i32] addrspace(1)* @X_as1, i64 0, i64 0), i64 %i
%cmp = icmp eq i32 addrspace(1)* %p1, getelementptr inbounds ([1000 x i32], [1000 x i32] addrspace(1)* @X_as1, i64 1, i64 0)
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
ret i1 %cmp
}
Transform "A + B >= A + C" into "B >= C" if the adds do not wrap. Likewise for some variations (some of these were already present so I unified the code). Spotted by my auto-simplifier as occurring a lot. llvm-svn: 125734
2011-02-17 15:46:37 +08:00
define i1 @test25(i32 %x, i32 %y, i32 %z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test25(
; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 %x, %y
; CHECK-NEXT: ret i1 [[C]]
;
Transform "A + B >= A + C" into "B >= C" if the adds do not wrap. Likewise for some variations (some of these were already present so I unified the code). Spotted by my auto-simplifier as occurring a lot. llvm-svn: 125734
2011-02-17 15:46:37 +08:00
%lhs = add nsw i32 %x, %z
%rhs = add nsw i32 %y, %z
%c = icmp sgt i32 %lhs, %rhs
ret i1 %c
}
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
; X + Z > Y + Z -> X > Y if there is no overflow.
Transform "A + B >= A + C" into "B >= C" if the adds do not wrap. Likewise for some variations (some of these were already present so I unified the code). Spotted by my auto-simplifier as occurring a lot. llvm-svn: 125734
2011-02-17 15:46:37 +08:00
define i1 @test26(i32 %x, i32 %y, i32 %z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test26(
; CHECK-NEXT: [[C:%.*]] = icmp ugt i32 %x, %y
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = add nuw i32 %x, %z
%rhs = add nuw i32 %y, %z
%c = icmp ugt i32 %lhs, %rhs
ret i1 %c
}
; X - Z > Y - Z -> X > Y if there is no overflow.
define i1 @test27(i32 %x, i32 %y, i32 %z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test27(
; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 %x, %y
; CHECK-NEXT: ret i1 [[C]]
;
Transform "A + B >= A + C" into "B >= C" if the adds do not wrap. Likewise for some variations (some of these were already present so I unified the code). Spotted by my auto-simplifier as occurring a lot. llvm-svn: 125734
2011-02-17 15:46:37 +08:00
%lhs = sub nsw i32 %x, %z
%rhs = sub nsw i32 %y, %z
%c = icmp sgt i32 %lhs, %rhs
ret i1 %c
}
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
; X - Z > Y - Z -> X > Y if there is no overflow.
define i1 @test28(i32 %x, i32 %y, i32 %z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test28(
; CHECK-NEXT: [[C:%.*]] = icmp ugt i32 %x, %y
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = sub nuw i32 %x, %z
%rhs = sub nuw i32 %y, %z
%c = icmp ugt i32 %lhs, %rhs
ret i1 %c
}
; X + Y > X -> Y > 0 if there is no overflow.
define i1 @test29(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test29(
; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 %y, 0
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = add nsw i32 %x, %y
%c = icmp sgt i32 %lhs, %x
ret i1 %c
}
; X + Y > X -> Y > 0 if there is no overflow.
define i1 @test30(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test30(
; CHECK-NEXT: [[C:%.*]] = icmp ne i32 %y, 0
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = add nuw i32 %x, %y
%c = icmp ugt i32 %lhs, %x
ret i1 %c
}
; X > X + Y -> 0 > Y if there is no overflow.
define i1 @test31(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test31(
; CHECK-NEXT: [[C:%.*]] = icmp slt i32 %y, 0
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%rhs = add nsw i32 %x, %y
%c = icmp sgt i32 %x, %rhs
ret i1 %c
}
; X > X + Y -> 0 > Y if there is no overflow.
define i1 @test32(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test32(
; CHECK-NEXT: ret i1 false
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%rhs = add nuw i32 %x, %y
%c = icmp ugt i32 %x, %rhs
ret i1 %c
}
; X - Y > X -> 0 > Y if there is no overflow.
define i1 @test33(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test33(
; CHECK-NEXT: [[C:%.*]] = icmp slt i32 %y, 0
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = sub nsw i32 %x, %y
%c = icmp sgt i32 %lhs, %x
ret i1 %c
}
; X - Y > X -> 0 > Y if there is no overflow.
define i1 @test34(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test34(
; CHECK-NEXT: ret i1 false
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = sub nuw i32 %x, %y
%c = icmp ugt i32 %lhs, %x
ret i1 %c
}
; X > X - Y -> Y > 0 if there is no overflow.
define i1 @test35(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test35(
; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 %y, 0
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%rhs = sub nsw i32 %x, %y
%c = icmp sgt i32 %x, %rhs
ret i1 %c
}
; X > X - Y -> Y > 0 if there is no overflow.
define i1 @test36(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test36(
; CHECK-NEXT: [[C:%.*]] = icmp ne i32 %y, 0
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%rhs = sub nuw i32 %x, %y
%c = icmp ugt i32 %x, %rhs
ret i1 %c
}
; X - Y > X - Z -> Z > Y if there is no overflow.
define i1 @test37(i32 %x, i32 %y, i32 %z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test37(
; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 %z, %y
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = sub nsw i32 %x, %y
%rhs = sub nsw i32 %x, %z
%c = icmp sgt i32 %lhs, %rhs
ret i1 %c
}
; X - Y > X - Z -> Z > Y if there is no overflow.
define i1 @test38(i32 %x, i32 %y, i32 %z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test38(
; CHECK-NEXT: [[C:%.*]] = icmp ugt i32 %z, %y
; CHECK-NEXT: ret i1 [[C]]
;
Add some transforms of the kind X-Y>X -> 0>Y which are valid when there is no overflow. These subsume some existing equality transforms, so zap those. llvm-svn: 125843
2011-02-19 00:25:37 +08:00
%lhs = sub nuw i32 %x, %y
%rhs = sub nuw i32 %x, %z
%c = icmp ugt i32 %lhs, %rhs
ret i1 %c
}
The sign of an srem instruction is the sign of its dividend (the first argument), regardless of the divisor. Teach instcombine about this and fix test7 in PR9343! llvm-svn: 126635
2011-02-28 14:20:05 +08:00
Teach InstCombine to fold "(shr exact X, Y) == 0" --> X == 0, fixing #1 from PR9343. llvm-svn: 126643
2011-02-28 16:31:40 +08:00
; PR9343 #1
srem doesn't actually have the same resulting sign as its numerator, you could also have a zero when numerator = denominator. Reverts parts of r126635 and r126637. llvm-svn: 126644
2011-02-28 17:17:39 +08:00
define i1 @test39(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test39(
; CHECK-NEXT: [[B:%.*]] = icmp eq i32 %X, 0
; CHECK-NEXT: ret i1 [[B]]
;
Teach InstCombine to fold "(shr exact X, Y) == 0" --> X == 0, fixing #1 from PR9343. llvm-svn: 126643
2011-02-28 16:31:40 +08:00
%A = ashr exact i32 %X, %Y
%B = icmp eq i32 %A, 0
ret i1 %B
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278709
2016-08-16 02:45:10 +08:00
define <2 x i1> @test39vec(<2 x i32> %X, <2 x i32> %Y) {
; CHECK-LABEL: @test39vec(
; CHECK-NEXT: [[A:%.*]] = ashr exact <2 x i32> %X, %Y
; CHECK-NEXT: [[B:%.*]] = icmp eq <2 x i32> [[A]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[B]]
;
%A = ashr exact <2 x i32> %X, %Y
%B = icmp eq <2 x i32> %A, zeroinitializer
ret <2 x i1> %B
}
srem doesn't actually have the same resulting sign as its numerator, you could also have a zero when numerator = denominator. Reverts parts of r126635 and r126637. llvm-svn: 126644
2011-02-28 17:17:39 +08:00
define i1 @test40(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test40(
; CHECK-NEXT: [[B:%.*]] = icmp ne i32 %X, 0
; CHECK-NEXT: ret i1 [[B]]
;
Teach InstCombine to fold "(shr exact X, Y) == 0" --> X == 0, fixing #1 from PR9343. llvm-svn: 126643
2011-02-28 16:31:40 +08:00
%A = lshr exact i32 %X, %Y
%B = icmp ne i32 %A, 0
ret i1 %B
}
Fold "icmp pred (srem X, Y), Y" like we do for urem. Handle signed comparisons in the urem case, though not the other way around. This is enough to get #3 from PR9343! llvm-svn: 126991
2011-03-04 18:06:52 +08:00
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278709
2016-08-16 02:45:10 +08:00
define <2 x i1> @test40vec(<2 x i32> %X, <2 x i32> %Y) {
; CHECK-LABEL: @test40vec(
; CHECK-NEXT: [[A:%.*]] = lshr exact <2 x i32> %X, %Y
; CHECK-NEXT: [[B:%.*]] = icmp ne <2 x i32> [[A]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[B]]
;
%A = lshr exact <2 x i32> %X, %Y
%B = icmp ne <2 x i32> %A, zeroinitializer
ret <2 x i1> %B
}
Fold "icmp pred (srem X, Y), Y" like we do for urem. Handle signed comparisons in the urem case, though not the other way around. This is enough to get #3 from PR9343! llvm-svn: 126991
2011-03-04 18:06:52 +08:00
; PR9343 #3
define i1 @test41(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test41(
; CHECK-NEXT: ret i1 true
;
Fold "icmp pred (srem X, Y), Y" like we do for urem. Handle signed comparisons in the urem case, though not the other way around. This is enough to get #3 from PR9343! llvm-svn: 126991
2011-03-04 18:06:52 +08:00
%A = urem i32 %X, %Y
%B = icmp ugt i32 %Y, %A
ret i1 %B
}
Try once again to optimize "icmp (srem X, Y), Y" by turning the comparison into true/false or "icmp slt/sge Y, 0". llvm-svn: 127063
2011-03-05 12:28:48 +08:00
define i1 @test42(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test42(
; CHECK-NEXT: [[B:%.*]] = icmp sgt i32 %Y, -1
; CHECK-NEXT: ret i1 [[B]]
;
Try once again to optimize "icmp (srem X, Y), Y" by turning the comparison into true/false or "icmp slt/sge Y, 0". llvm-svn: 127063
2011-03-05 12:28:48 +08:00
%A = srem i32 %X, %Y
%B = icmp slt i32 %A, %Y
ret i1 %B
}
define i1 @test43(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test43(
; CHECK-NEXT: [[B:%.*]] = icmp slt i32 %Y, 0
; CHECK-NEXT: ret i1 [[B]]
;
Try once again to optimize "icmp (srem X, Y), Y" by turning the comparison into true/false or "icmp slt/sge Y, 0". llvm-svn: 127063
2011-03-05 12:28:48 +08:00
%A = srem i32 %X, %Y
%B = icmp slt i32 %Y, %A
ret i1 %B
}
Thread comparisons over udiv/sdiv/ashr/lshr exact and lshr nuw/nsw whenever possible. This goes into instcombine and instsimplify because instsimplify doesn't need to check hasOneUse since it returns (almost exclusively) constants. This fixes PR9343 #4 #5 and #8! llvm-svn: 127064
2011-03-05 13:19:11 +08:00
define i1 @test44(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test44(
; CHECK-NEXT: [[B:%.*]] = icmp sgt i32 %Y, -1
; CHECK-NEXT: ret i1 [[B]]
;
Thread comparisons over udiv/sdiv/ashr/lshr exact and lshr nuw/nsw whenever possible. This goes into instcombine and instsimplify because instsimplify doesn't need to check hasOneUse since it returns (almost exclusively) constants. This fixes PR9343 #4 #5 and #8! llvm-svn: 127064
2011-03-05 13:19:11 +08:00
%A = srem i32 %X, %Y
%B = icmp slt i32 %A, %Y
ret i1 %B
}
define i1 @test45(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test45(
; CHECK-NEXT: [[B:%.*]] = icmp slt i32 %Y, 0
; CHECK-NEXT: ret i1 [[B]]
;
Thread comparisons over udiv/sdiv/ashr/lshr exact and lshr nuw/nsw whenever possible. This goes into instcombine and instsimplify because instsimplify doesn't need to check hasOneUse since it returns (almost exclusively) constants. This fixes PR9343 #4 #5 and #8! llvm-svn: 127064
2011-03-05 13:19:11 +08:00
%A = srem i32 %X, %Y
%B = icmp slt i32 %Y, %A
ret i1 %B
}
; PR9343 #4
define i1 @test46(i32 %X, i32 %Y, i32 %Z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test46(
; CHECK-NEXT: [[C:%.*]] = icmp ult i32 %X, %Y
; CHECK-NEXT: ret i1 [[C]]
;
Thread comparisons over udiv/sdiv/ashr/lshr exact and lshr nuw/nsw whenever possible. This goes into instcombine and instsimplify because instsimplify doesn't need to check hasOneUse since it returns (almost exclusively) constants. This fixes PR9343 #4 #5 and #8! llvm-svn: 127064
2011-03-05 13:19:11 +08:00
%A = ashr exact i32 %X, %Z
%B = ashr exact i32 %Y, %Z
%C = icmp ult i32 %A, %B
ret i1 %C
}
; PR9343 #5
define i1 @test47(i32 %X, i32 %Y, i32 %Z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test47(
; CHECK-NEXT: [[C:%.*]] = icmp ugt i32 %X, %Y
; CHECK-NEXT: ret i1 [[C]]
;
Thread comparisons over udiv/sdiv/ashr/lshr exact and lshr nuw/nsw whenever possible. This goes into instcombine and instsimplify because instsimplify doesn't need to check hasOneUse since it returns (almost exclusively) constants. This fixes PR9343 #4 #5 and #8! llvm-svn: 127064
2011-03-05 13:19:11 +08:00
%A = ashr exact i32 %X, %Z
%B = ashr exact i32 %Y, %Z
%C = icmp ugt i32 %A, %B
ret i1 %C
}
; PR9343 #8
define i1 @test48(i32 %X, i32 %Y, i32 %Z) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test48(
; CHECK-NEXT: [[C:%.*]] = icmp eq i32 %X, %Y
; CHECK-NEXT: ret i1 [[C]]
;
Thread comparisons over udiv/sdiv/ashr/lshr exact and lshr nuw/nsw whenever possible. This goes into instcombine and instsimplify because instsimplify doesn't need to check hasOneUse since it returns (almost exclusively) constants. This fixes PR9343 #4 #5 and #8! llvm-svn: 127064
2011-03-05 13:19:11 +08:00
%A = sdiv exact i32 %X, %Z
%B = sdiv exact i32 %Y, %Z
%C = icmp eq i32 %A, %B
ret i1 %C
}
ConstantInt has some getters which return ConstantInt's or ConstantVector's of the value splatted into every element. Extend this to getTrue and getFalse which by providing new overloads that take Types that are either i1 or <N x i1>. Use it in InstCombine to add vector support to some code, fixing PR8469! llvm-svn: 127116
2011-03-06 11:36:19 +08:00
; PR8469
define <2 x i1> @test49(<2 x i32> %tmp3) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test49(
; CHECK-NEXT: entry:
; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true>
;
ConstantInt has some getters which return ConstantInt's or ConstantVector's of the value splatted into every element. Extend this to getTrue and getFalse which by providing new overloads that take Types that are either i1 or <N x i1>. Use it in InstCombine to add vector support to some code, fixing PR8469! llvm-svn: 127116
2011-03-06 11:36:19 +08:00
entry:
%tmp11 = and <2 x i32> %tmp3, <i32 3, i32 3>
%cmp = icmp ult <2 x i32> %tmp11, <i32 4, i32 4>
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
ret <2 x i1> %cmp
ConstantInt has some getters which return ConstantInt's or ConstantVector's of the value splatted into every element. Extend this to getTrue and getFalse which by providing new overloads that take Types that are either i1 or <N x i1>. Use it in InstCombine to add vector support to some code, fixing PR8469! llvm-svn: 127116
2011-03-06 11:36:19 +08:00
}
Add more analysis of the sign bit of an srem instruction. If the LHS is negative then the result could go either way. If it's provably positive then so is the srem. Fixes PR9343 #7! llvm-svn: 127146
2011-03-07 09:50:10 +08:00
; PR9343 #7
define i1 @test50(i16 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test50(
; CHECK-NEXT: ret i1 true
;
Add more analysis of the sign bit of an srem instruction. If the LHS is negative then the result could go either way. If it's provably positive then so is the srem. Fixes PR9343 #7! llvm-svn: 127146
2011-03-07 09:50:10 +08:00
%A = zext i16 %X to i32
%B = srem i32 %A, %Y
%C = icmp sgt i32 %B, -1
ret i1 %C
}
Tweak this test. We can analyze what happens and show that we still do the right thing, instead of merely being unable to analyze and the transform doesn't occur. llvm-svn: 127149
2011-03-07 10:10:18 +08:00
define i1 @test51(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test51(
; CHECK-NEXT: [[A:%.*]] = and i32 %X, -2147483648
; CHECK-NEXT: [[B:%.*]] = srem i32 [[A]], %Y
; CHECK-NEXT: [[C:%.*]] = icmp sgt i32 [[B]], -1
; CHECK-NEXT: ret i1 [[C]]
;
Tweak this test. We can analyze what happens and show that we still do the right thing, instead of merely being unable to analyze and the transform doesn't occur. llvm-svn: 127149
2011-03-07 10:10:18 +08:00
%A = and i32 %X, 2147483648
Add more analysis of the sign bit of an srem instruction. If the LHS is negative then the result could go either way. If it's provably positive then so is the srem. Fixes PR9343 #7! llvm-svn: 127146
2011-03-07 09:50:10 +08:00
%B = srem i32 %A, %Y
%C = icmp sgt i32 %B, -1
ret i1 %C
}
Transform: "icmp eq (trunc (lshr(X, cst1)), cst" to "icmp (and X, mask), cst" when X has multiple uses. This is useful for exposing secondary optimizations, but the X86 backend isn't ready for this when X has a single use. For example, this can disable load folding. This is inching towards resolving PR6627. llvm-svn: 130238
2011-04-27 04:18:20 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test52(i32 %x1) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test52(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 %x1, 16711935
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 4980863
; CHECK-NEXT: ret i1 [[TMP2]]
;
Transform: "icmp eq (trunc (lshr(X, cst1)), cst" to "icmp (and X, mask), cst" when X has multiple uses. This is useful for exposing secondary optimizations, but the X86 backend isn't ready for this when X has a single use. For example, this can disable load folding. This is inching towards resolving PR6627. llvm-svn: 130238
2011-04-27 04:18:20 +08:00
%conv = and i32 %x1, 255
%cmp = icmp eq i32 %conv, 127
%tmp2 = lshr i32 %x1, 16
%tmp3 = trunc i32 %tmp2 to i8
%cmp15 = icmp eq i8 %tmp3, 76
%A = and i1 %cmp, %cmp15
ret i1 %A
}
PR9838: Fix transform introduced in r127064 to not trigger when only one side of the icmp is an exact shift. llvm-svn: 130954
2011-05-06 05:59:18 +08:00
; PR9838
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test53(i32 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test53(
; CHECK-NEXT: [[X:%.*]] = sdiv exact i32 %a, 30
; CHECK-NEXT: [[Y:%.*]] = sdiv i32 %b, 30
; CHECK-NEXT: [[Z:%.*]] = icmp eq i32 [[X]], [[Y]]
; CHECK-NEXT: ret i1 [[Z]]
;
%x = sdiv exact i32 %a, 30
%y = sdiv i32 %b, 30
%z = icmp eq i32 %x, %y
ret i1 %z
PR9838: Fix transform introduced in r127064 to not trigger when only one side of the icmp is an exact shift. llvm-svn: 130954
2011-05-06 05:59:18 +08:00
}
InstCombine: Shrink ((zext X) & C1) == C2 to fold away the cast if the "zext" and the "and" have one use. llvm-svn: 132897
2011-06-13 06:48:00 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test54(i8 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test54(
; CHECK-NEXT: [[AND:%.*]] = and i8 %a, -64
; CHECK-NEXT: [[RET:%.*]] = icmp eq i8 [[AND]], -128
; CHECK-NEXT: ret i1 [[RET]]
;
InstCombine: Shrink ((zext X) & C1) == C2 to fold away the cast if the "zext" and the "and" have one use. llvm-svn: 132897
2011-06-13 06:48:00 +08:00
%ext = zext i8 %a to i32
%and = and i32 %ext, 192
%ret = icmp eq i32 %and, 128
ret i1 %ret
}
InstCombine: Fold A-b == C --> b == A-C if A and C are constants. The backend already knew this trick. llvm-svn: 132915
2011-06-13 23:24:24 +08:00
define i1 @test55(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test55(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %a, -123
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Fold A-b == C --> b == A-C if A and C are constants. The backend already knew this trick. llvm-svn: 132915
2011-06-13 23:24:24 +08:00
%sub = sub i32 0, %a
%cmp = icmp eq i32 %sub, 123
ret i1 %cmp
}
add tests for icmp vector folds llvm-svn: 276475
2016-07-23 05:13:08 +08:00
define <2 x i1> @test55vec(<2 x i32> %a) {
; CHECK-LABEL: @test55vec(
[InstCombine] use m_APInt to allow icmp eq (sub C1, X), C2 folds for splat constant vectors llvm-svn: 277731
2016-08-04 23:19:25 +08:00
; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> %a, <i32 -123, i32 -123>
add tests for icmp vector folds llvm-svn: 276475
2016-07-23 05:13:08 +08:00
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%sub = sub <2 x i32> zeroinitializer, %a
%cmp = icmp eq <2 x i32> %sub, <i32 123, i32 123>
ret <2 x i1> %cmp
}
InstCombine: Fold A-b == C --> b == A-C if A and C are constants. The backend already knew this trick. llvm-svn: 132915
2011-06-13 23:24:24 +08:00
define i1 @test56(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test56(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %a, -113
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Fold A-b == C --> b == A-C if A and C are constants. The backend already knew this trick. llvm-svn: 132915
2011-06-13 23:24:24 +08:00
%sub = sub i32 10, %a
%cmp = icmp eq i32 %sub, 123
ret i1 %cmp
}
PR10267: Don't combine an equality compare with an AND into an inequality compare when the AND has more than one use. This can pessimize code, inequalities are generally more expensive. llvm-svn: 134379
2011-07-05 04:16:36 +08:00
add tests for icmp vector folds llvm-svn: 276475
2016-07-23 05:13:08 +08:00
define <2 x i1> @test56vec(<2 x i32> %a) {
; CHECK-LABEL: @test56vec(
[InstCombine] use m_APInt to allow icmp eq (sub C1, X), C2 folds for splat constant vectors llvm-svn: 277731
2016-08-04 23:19:25 +08:00
; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> %a, <i32 -113, i32 -113>
add tests for icmp vector folds llvm-svn: 276475
2016-07-23 05:13:08 +08:00
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%sub = sub <2 x i32> <i32 10, i32 10>, %a
%cmp = icmp eq <2 x i32> %sub, <i32 123, i32 123>
ret <2 x i1> %cmp
}
PR10267: Don't combine an equality compare with an AND into an inequality compare when the AND has more than one use. This can pessimize code, inequalities are generally more expensive. llvm-svn: 134379
2011-07-05 04:16:36 +08:00
; PR10267 Don't make icmps more expensive when no other inst is subsumed.
declare void @foo(i32)
define i1 @test57(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test57(
; CHECK-NEXT: [[AND:%.*]] = and i32 %a, -2
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[AND]], 0
; CHECK-NEXT: call void @foo(i32 [[AND]])
; CHECK-NEXT: ret i1 [[CMP]]
;
PR10267: Don't combine an equality compare with an AND into an inequality compare when the AND has more than one use. This can pessimize code, inequalities are generally more expensive. llvm-svn: 134379
2011-07-05 04:16:36 +08:00
%and = and i32 %a, -2
%cmp = icmp ne i32 %and, 0
call void @foo(i32 %and)
ret i1 %cmp
}
Removed use of grep from test and moved it to be with other icmp tests llvm-svn: 145570
2011-12-01 12:35:26 +08:00
; rdar://problem/10482509
Improved fix for abs(val) != 0 to check other similar case. Also fixed style issues and confusing comment llvm-svn: 145618
2011-12-02 03:13:26 +08:00
define zeroext i1 @cmpabs1(i64 %val) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @cmpabs1(
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i64 %val, 0
; CHECK-NEXT: ret i1 [[TOBOOL]]
;
Removed use of grep from test and moved it to be with other icmp tests llvm-svn: 145570
2011-12-01 12:35:26 +08:00
%sub = sub nsw i64 0, %val
%cmp = icmp slt i64 %val, 0
%sub.val = select i1 %cmp, i64 %sub, i64 %val
%tobool = icmp ne i64 %sub.val, 0
ret i1 %tobool
}
Improved fix for abs(val) != 0 to check other similar case. Also fixed style issues and confusing comment llvm-svn: 145618
2011-12-02 03:13:26 +08:00
define zeroext i1 @cmpabs2(i64 %val) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @cmpabs2(
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i64 %val, 0
; CHECK-NEXT: ret i1 [[TOBOOL]]
;
Improved fix for abs(val) != 0 to check other similar case. Also fixed style issues and confusing comment llvm-svn: 145618
2011-12-02 03:13:26 +08:00
%sub = sub nsw i64 0, %val
%cmp = icmp slt i64 %val, 0
%sub.val = select i1 %cmp, i64 %val, i64 %sub
%tobool = icmp ne i64 %sub.val, 0
ret i1 %tobool
}
Revert r149110 and add a testcase that was crashing since that revision. Unfortunately I also had to disable constant-pool-sharing.ll the code it tests has been updated to use the IL logic. llvm-svn: 149148
2012-01-28 06:42:48 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define void @test58() {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test58(
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
; CHECK-NEXT: [[CALL:%.*]] = call i32 @test58_d(i64 36029346783166592)
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret void
;
Add r149110 back with a fix for when the vector and the int have the same width. llvm-svn: 149151
2012-01-28 07:33:07 +08:00
%cast = bitcast <1 x i64> <i64 36029346783166592> to i64
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
%call = call i32 @test58_d( i64 %cast)
Revert r149110 and add a testcase that was crashing since that revision. Unfortunately I also had to disable constant-pool-sharing.ll the code it tests has been updated to use the IL logic. llvm-svn: 149148
2012-01-28 06:42:48 +08:00
ret void
}
declare i32 @test58_d(i64)
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
define i1 @test59(i8* %foo) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test59(
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds i8, i8* %foo, i64 8
; CHECK-NEXT: [[USE:%.*]] = ptrtoint i8* [[GEP1]] to i64
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
; CHECK-NEXT: [[CALL:%.*]] = call i32 @test58_d(i64 [[USE]])
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 true
;
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
%bit = bitcast i8* %foo to i32*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32* %bit, i64 2
%gep2 = getelementptr inbounds i8, i8* %foo, i64 10
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
%cast1 = bitcast i32* %gep1 to i8*
%cmp = icmp ult i8* %cast1, %gep2
%use = ptrtoint i8* %cast1 to i64
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
%call = call i32 @test58_d(i64 %use)
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
ret i1 %cmp
}
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
define i1 @test59_as1(i8 addrspace(1)* %foo) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test59_as1(
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* %foo, i16 8
; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint i8 addrspace(1)* [[GEP1]] to i16
; CHECK-NEXT: [[USE:%.*]] = zext i16 [[TMP1]] to i64
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
; CHECK-NEXT: [[CALL:%.*]] = call i32 @test58_d(i64 [[USE]])
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 true
;
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%bit = bitcast i8 addrspace(1)* %foo to i32 addrspace(1)*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32 addrspace(1)* %bit, i64 2
%gep2 = getelementptr inbounds i8, i8 addrspace(1)* %foo, i64 10
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%cast1 = bitcast i32 addrspace(1)* %gep1 to i8 addrspace(1)*
%cmp = icmp ult i8 addrspace(1)* %cast1, %gep2
%use = ptrtoint i8 addrspace(1)* %cast1 to i64
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
%call = call i32 @test58_d(i64 %use)
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
ret i1 %cmp
}
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
define i1 @test60(i8* %foo, i64 %i, i64 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test60(
; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i64 %i, 2
; CHECK-NEXT: [[TMP1:%.*]] = icmp slt i64 [[GEP1_IDX]], %j
; CHECK-NEXT: ret i1 [[TMP1]]
;
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
%bit = bitcast i8* %foo to i32*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32* %bit, i64 %i
%gep2 = getelementptr inbounds i8, i8* %foo, i64 %j
InstCombine: When comparing two GEPs that were derived from the same base pointer but use different types, expand the offset calculation and to the compare on the offset if profitable. This came up in SmallVector code. llvm-svn: 150962
2012-02-20 23:07:47 +08:00
%cast1 = bitcast i32* %gep1 to i8*
%cmp = icmp ult i8* %cast1, %gep2
ret i1 %cmp
}
Test case for r150978. llvm-svn: 150979
2012-02-21 03:00:28 +08:00
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
define i1 @test60_as1(i8 addrspace(1)* %foo, i64 %i, i64 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test60_as1(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 %i to i16
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 %j to i16
; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i16 [[TMP1]], 2
; CHECK-NEXT: [[TMP3:%.*]] = icmp sgt i16 [[TMP2]], [[GEP1_IDX]]
; CHECK-NEXT: ret i1 [[TMP3]]
;
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%bit = bitcast i8 addrspace(1)* %foo to i32 addrspace(1)*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32 addrspace(1)* %bit, i64 %i
%gep2 = getelementptr inbounds i8, i8 addrspace(1)* %foo, i64 %j
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%cast1 = bitcast i32 addrspace(1)* %gep1 to i8 addrspace(1)*
%cmp = icmp ult i8 addrspace(1)* %cast1, %gep2
ret i1 %cmp
}
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
; Same as test60, but look through an addrspacecast instead of a
; bitcast. This uses the same sized addrspace.
define i1 @test60_addrspacecast(i8* %foo, i64 %i, i64 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test60_addrspacecast(
; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i64 %i, 2
; CHECK-NEXT: [[TMP1:%.*]] = icmp slt i64 [[GEP1_IDX]], %j
; CHECK-NEXT: ret i1 [[TMP1]]
;
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
%bit = addrspacecast i8* %foo to i32 addrspace(3)*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32 addrspace(3)* %bit, i64 %i
%gep2 = getelementptr inbounds i8, i8* %foo, i64 %j
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
%cast1 = addrspacecast i32 addrspace(3)* %gep1 to i8*
%cmp = icmp ult i8* %cast1, %gep2
ret i1 %cmp
}
define i1 @test60_addrspacecast_smaller(i8* %foo, i16 %i, i64 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test60_addrspacecast_smaller(
; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i16 %i, 2
; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 %j to i16
; CHECK-NEXT: [[TMP2:%.*]] = icmp sgt i16 [[TMP1]], [[GEP1_IDX]]
; CHECK-NEXT: ret i1 [[TMP2]]
;
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
%bit = addrspacecast i8* %foo to i32 addrspace(1)*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32 addrspace(1)* %bit, i16 %i
%gep2 = getelementptr inbounds i8, i8* %foo, i64 %j
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
%cast1 = addrspacecast i32 addrspace(1)* %gep1 to i8*
%cmp = icmp ult i8* %cast1, %gep2
ret i1 %cmp
}
define i1 @test60_addrspacecast_larger(i8 addrspace(1)* %foo, i32 %i, i16 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test60_addrspacecast_larger(
Revert "Revert "Revert "InstCombine: Reduce trunc (shl x, K) width.""" This seems to be causing an infinite loop / crash in instcombine on some bots. llvm-svn: 273069
2016-06-18 07:36:38 +08:00
; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i32 %i, 2
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[GEP1_IDX]] to i16
; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i16 [[TMP1]], %j
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 [[TMP2]]
;
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
%bit = addrspacecast i8 addrspace(1)* %foo to i32 addrspace(2)*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr inbounds i32, i32 addrspace(2)* %bit, i32 %i
%gep2 = getelementptr inbounds i8, i8 addrspace(1)* %foo, i16 %j
Look through addrspacecasts when turning ptr comparisons into index comparisons. llvm-svn: 210488
2014-06-10 03:20:29 +08:00
%cast1 = addrspacecast i32 addrspace(2)* %gep1 to i8 addrspace(1)*
%cmp = icmp ult i8 addrspace(1)* %cast1, %gep2
ret i1 %cmp
}
Test case for r150978. llvm-svn: 150979
2012-02-21 03:00:28 +08:00
define i1 @test61(i8* %foo, i64 %i, i64 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test61(
; CHECK-NEXT: [[BIT:%.*]] = bitcast i8* %foo to i32*
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr i32, i32* [[BIT]], i64 %i
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i8, i8* %foo, i64 %j
; CHECK-NEXT: [[CAST1:%.*]] = bitcast i32* [[GEP1]] to i8*
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8* [[CAST1]], [[GEP2]]
; CHECK-NEXT: ret i1 [[CMP]]
;
Test case for r150978. llvm-svn: 150979
2012-02-21 03:00:28 +08:00
%bit = bitcast i8* %foo to i32*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr i32, i32* %bit, i64 %i
%gep2 = getelementptr i8, i8* %foo, i64 %j
Test case for r150978. llvm-svn: 150979
2012-02-21 03:00:28 +08:00
%cast1 = bitcast i32* %gep1 to i8*
%cmp = icmp ult i8* %cast1, %gep2
ret i1 %cmp
; Don't transform non-inbounds GEPs.
}
InstCombine: Don't transform a signed icmp of two GEPs into a signed compare of the indices. This transformation is not safe in some pathological cases (signed icmp of pointers should be an extremely rare thing, but it's valid IR!). Add an explanatory comment. Kudos to Duncan for pointing out this edge case (and not giving up explaining it until I finally got it). llvm-svn: 151055
2012-02-21 21:31:09 +08:00
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
define i1 @test61_as1(i8 addrspace(1)* %foo, i16 %i, i16 %j) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test61_as1(
; CHECK-NEXT: [[BIT:%.*]] = bitcast i8 addrspace(1)* %foo to i32 addrspace(1)*
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr i32, i32 addrspace(1)* [[BIT]], i16 %i
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr i8, i8 addrspace(1)* %foo, i16 %j
; CHECK-NEXT: [[CAST1:%.*]] = bitcast i32 addrspace(1)* [[GEP1]] to i8 addrspace(1)*
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 addrspace(1)* [[CAST1]], [[GEP2]]
; CHECK-NEXT: ret i1 [[CMP]]
;
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%bit = bitcast i8 addrspace(1)* %foo to i32 addrspace(1)*
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%gep1 = getelementptr i32, i32 addrspace(1)* %bit, i16 %i
%gep2 = getelementptr i8, i8 addrspace(1)* %foo, i16 %j
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%cast1 = bitcast i32 addrspace(1)* %gep1 to i8 addrspace(1)*
%cmp = icmp ult i8 addrspace(1)* %cast1, %gep2
ret i1 %cmp
; Don't transform non-inbounds GEPs.
}
InstCombine: Don't transform a signed icmp of two GEPs into a signed compare of the indices. This transformation is not safe in some pathological cases (signed icmp of pointers should be an extremely rare thing, but it's valid IR!). Add an explanatory comment. Kudos to Duncan for pointing out this edge case (and not giving up explaining it until I finally got it). llvm-svn: 151055
2012-02-21 21:31:09 +08:00
define i1 @test62(i8* %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test62(
; CHECK-NEXT: ret i1 true
;
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%arrayidx1 = getelementptr inbounds i8, i8* %a, i64 1
%arrayidx2 = getelementptr inbounds i8, i8* %a, i64 10
InstCombine: Don't transform a signed icmp of two GEPs into a signed compare of the indices. This transformation is not safe in some pathological cases (signed icmp of pointers should be an extremely rare thing, but it's valid IR!). Add an explanatory comment. Kudos to Duncan for pointing out this edge case (and not giving up explaining it until I finally got it). llvm-svn: 151055
2012-02-21 21:31:09 +08:00
%cmp = icmp slt i8* %arrayidx1, %arrayidx2
ret i1 %cmp
}
InstCombine: Turn (zext A) == (B & (1<<X)-1) into A == (trunc B), narrowing the compare. This saves a cast, and zext is more expensive on platforms with subreg support than trunc is. This occurs in the BSD implementation of memchr(3), see PR12750. On the synthetic benchmark from that bug stupid_memchr and bsd_memchr have the same performance now when not inlining either function. stupid_memchr: 323.0us bsd_memchr: 321.0us memchr: 479.0us where memchr is the llvm-gcc compiled bsd_memchr from osx lion's libc. When inlining is enabled bsd_memchr still regresses down to llvm-gcc memchr time, I haven't fully understood the issue yet, something is grossly mangling the loop after inlining. llvm-svn: 158297
2012-06-11 04:35:00 +08:00
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
define i1 @test62_as1(i8 addrspace(1)* %a) {
; CHECK-LABEL: @test62_as1(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 true
;
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%arrayidx1 = getelementptr inbounds i8, i8 addrspace(1)* %a, i64 1
%arrayidx2 = getelementptr inbounds i8, i8 addrspace(1)* %a, i64 10
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%cmp = icmp slt i8 addrspace(1)* %arrayidx1, %arrayidx2
ret i1 %cmp
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test63(i8 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test63(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %b to i8
; CHECK-NEXT: [[C:%.*]] = icmp eq i8 [[TMP1]], %a
; CHECK-NEXT: ret i1 [[C]]
;
InstCombine: Turn (zext A) == (B & (1<<X)-1) into A == (trunc B), narrowing the compare. This saves a cast, and zext is more expensive on platforms with subreg support than trunc is. This occurs in the BSD implementation of memchr(3), see PR12750. On the synthetic benchmark from that bug stupid_memchr and bsd_memchr have the same performance now when not inlining either function. stupid_memchr: 323.0us bsd_memchr: 321.0us memchr: 479.0us where memchr is the llvm-gcc compiled bsd_memchr from osx lion's libc. When inlining is enabled bsd_memchr still regresses down to llvm-gcc memchr time, I haven't fully understood the issue yet, something is grossly mangling the loop after inlining. llvm-svn: 158297
2012-06-11 04:35:00 +08:00
%z = zext i8 %a to i32
%t = and i32 %b, 255
%c = icmp eq i32 %z, %t
ret i1 %c
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test64(i8 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test64(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %b to i8
; CHECK-NEXT: [[C:%.*]] = icmp eq i8 [[TMP1]], %a
; CHECK-NEXT: ret i1 [[C]]
;
InstCombine: Turn (zext A) == (B & (1<<X)-1) into A == (trunc B), narrowing the compare. This saves a cast, and zext is more expensive on platforms with subreg support than trunc is. This occurs in the BSD implementation of memchr(3), see PR12750. On the synthetic benchmark from that bug stupid_memchr and bsd_memchr have the same performance now when not inlining either function. stupid_memchr: 323.0us bsd_memchr: 321.0us memchr: 479.0us where memchr is the llvm-gcc compiled bsd_memchr from osx lion's libc. When inlining is enabled bsd_memchr still regresses down to llvm-gcc memchr time, I haven't fully understood the issue yet, something is grossly mangling the loop after inlining. llvm-svn: 158297
2012-06-11 04:35:00 +08:00
%t = and i32 %b, 255
%z = zext i8 %a to i32
%c = icmp eq i32 %t, %z
ret i1 %c
}
Fix PR14361: wrong simplification of A+B==B+A. You may think that the old logic replaced by this patch is equivalent to the new logic, but you'd be wrong, and that's exactly where the bug was. There's a similar bug in instsimplify which manifests itself as instsimplify failing to simplify this, rather than doing it wrong, see next commit. llvm-svn: 168181
2012-11-17 02:55:49 +08:00
define i1 @test65(i64 %A, i64 %B) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test65(
; CHECK-NEXT: ret i1 true
;
Fix PR14361: wrong simplification of A+B==B+A. You may think that the old logic replaced by this patch is equivalent to the new logic, but you'd be wrong, and that's exactly where the bug was. There's a similar bug in instsimplify which manifests itself as instsimplify failing to simplify this, rather than doing it wrong, see next commit. llvm-svn: 168181
2012-11-17 02:55:49 +08:00
%s1 = add i64 %A, %B
%s2 = add i64 %A, %B
%cmp = icmp eq i64 %s1, %s2
ret i1 %cmp
}
define i1 @test66(i64 %A, i64 %B) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test66(
; CHECK-NEXT: ret i1 true
;
Fix PR14361: wrong simplification of A+B==B+A. You may think that the old logic replaced by this patch is equivalent to the new logic, but you'd be wrong, and that's exactly where the bug was. There's a similar bug in instsimplify which manifests itself as instsimplify failing to simplify this, rather than doing it wrong, see next commit. llvm-svn: 168181
2012-11-17 02:55:49 +08:00
%s1 = add i64 %A, %B
%s2 = add i64 %B, %A
%cmp = icmp eq i64 %s1, %s2
ret i1 %cmp
}
Transform (x&C)>V into (x&C)!=0 where possible When the least bit of C is greater than V, (x&C) must be greater than V if it is not zero, so the comparison can be simplified. Although this was suggested in Target/X86/README.txt, it benefits any architecture with a directly testable form of AND. Patch by Kevin Schoedel llvm-svn: 170576
2012-12-20 03:47:13 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test67(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test67(
; CHECK-NEXT: [[AND:%.*]] = and i32 %x, 96
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[AND]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
Transform (x&C)>V into (x&C)!=0 where possible When the least bit of C is greater than V, (x&C) must be greater than V if it is not zero, so the comparison can be simplified. Although this was suggested in Target/X86/README.txt, it benefits any architecture with a directly testable form of AND. Patch by Kevin Schoedel llvm-svn: 170576
2012-12-20 03:47:13 +08:00
%and = and i32 %x, 127
%cmp = icmp sgt i32 %and, 31
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278634
2016-08-15 06:28:50 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @test67vec(<2 x i32> %x) {
; CHECK-LABEL: @test67vec(
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> %x, <i32 127, i32 127>
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt <2 x i32> [[AND]], <i32 31, i32 31>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%and = and <2 x i32> %x, <i32 127, i32 127>
%cmp = icmp sgt <2 x i32> %and, <i32 31, i32 31>
ret <2 x i1> %cmp
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test68(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test68(
; CHECK-NEXT: [[AND:%.*]] = and i32 %x, 127
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 [[AND]], 30
; CHECK-NEXT: ret i1 [[CMP]]
;
Transform (x&C)>V into (x&C)!=0 where possible When the least bit of C is greater than V, (x&C) must be greater than V if it is not zero, so the comparison can be simplified. Although this was suggested in Target/X86/README.txt, it benefits any architecture with a directly testable form of AND. Patch by Kevin Schoedel llvm-svn: 170576
2012-12-20 03:47:13 +08:00
%and = and i32 %x, 127
%cmp = icmp sgt i32 %and, 30
ret i1 %cmp
}
Transform (A == C1 || A == C2) into (A & ~(C1 ^ C2)) == C1 if C1 and C2 differ only with one bit. Fixes PR14708. llvm-svn: 171270
2012-12-31 08:34:55 +08:00
; PR14708
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @test69(i32 %c) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test69(
; CHECK-NEXT: [[TMP1:%.*]] = or i32 %c, 32
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 97
; CHECK-NEXT: ret i1 [[TMP2]]
;
Transform (A == C1 || A == C2) into (A & ~(C1 ^ C2)) == C1 if C1 and C2 differ only with one bit. Fixes PR14708. llvm-svn: 171270
2012-12-31 08:34:55 +08:00
%1 = icmp eq i32 %c, 97
%2 = icmp eq i32 %c, 65
%3 = or i1 %1, %2
ret i1 %3
}
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
InstCombine: Don't just copy known bits from the first operand of an srem. That's obviously wrong. Conservatively restrict it to the sign bit, which matches the original intention of this analysis. Fixes PR15940. llvm-svn: 181518
2013-05-10 00:32:32 +08:00
; PR15940
define i1 @test70(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test70(
; CHECK-NEXT: [[A:%.*]] = srem i32 5, %X
; CHECK-NEXT: [[C:%.*]] = icmp ne i32 [[A]], 2
; CHECK-NEXT: ret i1 [[C]]
;
InstCombine: Don't just copy known bits from the first operand of an srem. That's obviously wrong. Conservatively restrict it to the sign bit, which matches the original intention of this analysis. Fixes PR15940. llvm-svn: 181518
2013-05-10 00:32:32 +08:00
%A = srem i32 5, %X
%B = add i32 %A, 2
%C = icmp ne i32 %B, 4
ret i1 %C
}
add tests for icmp vector folds llvm-svn: 276464
2016-07-23 04:11:08 +08:00
define <2 x i1> @test70vec(<2 x i32> %X) {
; CHECK-LABEL: @test70vec(
[InstCombine] use m_APInt to allow icmp eq (add X, C1), C2 folds for splat constant vectors llvm-svn: 277659
2016-08-04 06:08:44 +08:00
; CHECK-NEXT: [[C:%.*]] = icmp ne <2 x i32> %X, <i32 2, i32 2>
add tests for icmp vector folds llvm-svn: 276464
2016-07-23 04:11:08 +08:00
; CHECK-NEXT: ret <2 x i1> [[C]]
;
%B = add <2 x i32> %X, <i32 2, i32 2>
%C = icmp ne <2 x i32> %B, <i32 4, i32 4>
ret <2 x i1> %C
}
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
define i1 @icmp_sext16trunc(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sext16trunc(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %x to i16
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i16 [[TMP1]], 36
; CHECK-NEXT: ret i1 [[CMP]]
;
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
%trunc = trunc i32 %x to i16
%sext = sext i16 %trunc to i32
%cmp = icmp slt i32 %sext, 36
ret i1 %cmp
}
define i1 @icmp_sext8trunc(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sext8trunc(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %x to i8
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[TMP1]], 36
; CHECK-NEXT: ret i1 [[CMP]]
;
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
%trunc = trunc i32 %x to i8
%sext = sext i8 %trunc to i32
%cmp = icmp slt i32 %sext, 36
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278704
2016-08-16 02:26:56 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_sext8trunc_vec(<2 x i32> %x) {
; CHECK-LABEL: @icmp_sext8trunc_vec(
; CHECK-NEXT: [[SEXT1:%.*]] = shl <2 x i32> %x, <i32 24, i32 24>
; CHECK-NEXT: [[SEXT:%.*]] = ashr <2 x i32> [[SEXT:%.*]]1, <i32 24, i32 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i32> [[SEXT]], <i32 36, i32 36>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%trunc = trunc <2 x i32> %x to <2 x i8>
%sext = sext <2 x i8> %trunc to <2 x i32>
%cmp = icmp slt <2 x i32> %sext, <i32 36, i32 36>
ret <2 x i1> %cmp
}
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
define i1 @icmp_shl16(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl16(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %x to i16
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i16 [[TMP1]], 36
; CHECK-NEXT: ret i1 [[CMP]]
;
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
%shl = shl i32 %x, 16
%cmp = icmp slt i32 %shl, 2359296
ret i1 %cmp
}
define i1 @icmp_shl24(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl24(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %x to i8
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[TMP1]], 36
; CHECK-NEXT: ret i1 [[CMP]]
;
Teach InstCombine to work with smaller legal types in icmp (shl %v, C1), C2 It enables to work with a smaller constant, which is target friendly for those which can compare to immediates. It also avoids inserting a shift in favor of a trunc, which can be free on some targets. This used to work until LLVM-3.1, but regressed with the 3.2 release. llvm-svn: 175270
2013-02-15 22:35:47 +08:00
%shl = shl i32 %x, 24
%cmp = icmp slt i32 %shl, 603979776
ret i1 %cmp
}
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
; If the (shl x, C) preserved the sign and this is a sign test,
; compare the LHS operand instead
define i1 @icmp_shl_nsw_sgt(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_nsw_sgt(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%shl = shl nsw i32 %x, 21
%cmp = icmp sgt i32 %shl, 0
ret i1 %cmp
}
define i1 @icmp_shl_nsw_sge0(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_nsw_sge0(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %x, -1
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%shl = shl nsw i32 %x, 21
%cmp = icmp sge i32 %shl, 0
ret i1 %cmp
}
define i1 @icmp_shl_nsw_sge1(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_nsw_sge1(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%shl = shl nsw i32 %x, 21
%cmp = icmp sge i32 %shl, 1
ret i1 %cmp
}
; Checks for icmp (eq|ne) (shl x, C), 0
define i1 @icmp_shl_nsw_eq(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_nsw_eq(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = shl nsw i32 %x, 5
%cmp = icmp eq i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_shl_eq(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_eq(
; CHECK-NEXT: [[MUL_MASK:%.*]] = and i32 %x, 134217727
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[MUL_MASK]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = shl i32 %x, 5
%cmp = icmp eq i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_shl_nsw_ne(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_nsw_ne(
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = shl nsw i32 %x, 7
%cmp = icmp ne i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_shl_ne(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_ne(
; CHECK-NEXT: [[MUL_MASK:%.*]] = and i32 %x, 33554431
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[MUL_MASK]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = shl i32 %x, 7
%cmp = icmp ne i32 %mul, 0
ret i1 %cmp
}
; If the (mul x, C) preserved the sign and this is sign test,
; compare the LHS operand instead
define i1 @icmp_mul_nsw(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_nsw(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul nsw i32 %x, 12
%cmp = icmp sgt i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_mul_nsw1(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_nsw1(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul nsw i32 %x, 12
%cmp = icmp sle i32 %mul, -1
ret i1 %cmp
}
define i1 @icmp_mul_nsw_neg(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_nsw_neg(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 %x, 1
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul nsw i32 %x, -12
%cmp = icmp sge i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_mul_nsw_neg1(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_nsw_neg1(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul nsw i32 %x, -12
%cmp = icmp sge i32 %mul, 1
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278683
2016-08-16 01:10:35 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_mul_nsw_neg1_vec(<2 x i32> %x) {
; CHECK-LABEL: @icmp_mul_nsw_neg1_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i32> %x, <i32 -12, i32 -12>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i32> [[MUL]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i32> %x, <i32 -12, i32 -12>
%cmp = icmp sge <2 x i32> %mul, <i32 1, i32 1>
ret <2 x i1> %cmp
}
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
define i1 @icmp_mul_nsw_0(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_nsw_0(
; CHECK-NEXT: ret i1 false
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul nsw i32 %x, 0
%cmp = icmp sgt i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_mul(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul(
; CHECK-NEXT: [[MUL:%.*]] = mul i32 %x, -12
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[MUL]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul i32 %x, -12
%cmp = icmp sge i32 %mul, 0
ret i1 %cmp
}
; Checks for icmp (eq|ne) (mul x, C), 0
define i1 @icmp_mul_neq0(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_neq0(
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
Address issues found by Duncan during post-commit review of r177856. llvm-svn: 177863
2013-03-25 19:47:38 +08:00
%mul = mul nsw i32 %x, -12
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%cmp = icmp ne i32 %mul, 0
ret i1 %cmp
}
add tests for icmp vector folds llvm-svn: 276476
2016-07-23 05:28:20 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_mul_neq0_vec(<2 x i32> %x) {
; CHECK-LABEL: @icmp_mul_neq0_vec(
[InstCombine] use m_APInt to allow icmp eq (mul X, C1), C2 folds for splat constant vectors This concludes the splat vector enhancements for foldICmpEqualityWithConstant(). Other commits in this series: https://reviews.llvm.org/rL277762 https://reviews.llvm.org/rL277752 https://reviews.llvm.org/rL277738 https://reviews.llvm.org/rL277731 https://reviews.llvm.org/rL277659 https://reviews.llvm.org/rL277638 https://reviews.llvm.org/rL277629 llvm-svn: 277779
2016-08-05 06:19:27 +08:00
; CHECK-NEXT: [[CMP:%.*]] = icmp ne <2 x i32> %x, zeroinitializer
add tests for icmp vector folds llvm-svn: 276476
2016-07-23 05:28:20 +08:00
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i32> %x, <i32 -12, i32 -12>
%cmp = icmp ne <2 x i32> %mul, zeroinitializer
ret <2 x i1> %cmp
}
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
define i1 @icmp_mul_eq0(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul_eq0(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %x, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
Address issues found by Duncan during post-commit review of r177856. llvm-svn: 177863
2013-03-25 19:47:38 +08:00
%mul = mul nsw i32 %x, 12
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%cmp = icmp eq i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_mul0_eq0(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul0_eq0(
; CHECK-NEXT: ret i1 true
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul i32 %x, 0
%cmp = icmp eq i32 %mul, 0
ret i1 %cmp
}
define i1 @icmp_mul0_ne0(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_mul0_ne0(
; CHECK-NEXT: ret i1 false
;
InstCombine: simplify comparisons to zero of (shl %x, Cst) or (mul %x, Cst) This simplification happens at 2 places : - using the nsw attribute when the shl / mul is used by a sign test - when the shl / mul is compared for (in)equality to zero llvm-svn: 177856
2013-03-25 17:48:49 +08:00
%mul = mul i32 %x, 0
%cmp = icmp ne i32 %mul, 0
ret i1 %cmp
}
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
define i1 @icmp_sub1_sge(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub1_sge(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %x, %y
; CHECK-NEXT: ret i1 [[CMP]]
;
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
%sub = add nsw i32 %x, -1
%cmp = icmp sge i32 %sub, %y
ret i1 %cmp
}
define i1 @icmp_add1_sgt(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_add1_sgt(
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 %x, %y
; CHECK-NEXT: ret i1 [[CMP]]
;
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
%add = add nsw i32 %x, 1
%cmp = icmp sgt i32 %add, %y
ret i1 %cmp
}
define i1 @icmp_sub1_slt(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub1_slt(
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i32 %x, %y
; CHECK-NEXT: ret i1 [[CMP]]
;
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
%sub = add nsw i32 %x, -1
%cmp = icmp slt i32 %sub, %y
ret i1 %cmp
}
define i1 @icmp_add1_sle(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_add1_sle(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 %x, %y
; CHECK-NEXT: ret i1 [[CMP]]
;
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
%add = add nsw i32 %x, 1
%cmp = icmp sle i32 %add, %y
ret i1 %cmp
}
define i1 @icmp_add20_sge_add57(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_add20_sge_add57(
; CHECK-NEXT: [[TMP1:%.*]] = add nsw i32 %y, 37
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i32 [[TMP1]], %x
; CHECK-NEXT: ret i1 [[CMP]]
;
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
%1 = add nsw i32 %x, 20
%2 = add nsw i32 %y, 57
%cmp = icmp sge i32 %1, %2
ret i1 %cmp
}
define i1 @icmp_sub57_sge_sub20(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub57_sge_sub20(
; CHECK-NEXT: [[TMP1:%.*]] = add nsw i32 %x, -37
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[TMP1]], %y
; CHECK-NEXT: ret i1 [[CMP]]
;
Optimize icmp involving addition better Allows LLVM to optimize sequences like the following: %add = add nsw i32 %x, 1 %cmp = icmp sgt i32 %add, %y into: %cmp = icmp sge i32 %x, %y as well as: %add1 = add nsw i32 %x, 20 %add2 = add nsw i32 %y, 57 %cmp = icmp sge i32 %add1, %add2 into: %add = add nsw i32 %y, 37 %cmp = icmp sle i32 %cmp, %x llvm-svn: 179316
2013-04-12 04:05:46 +08:00
%1 = add nsw i32 %x, -57
%2 = add nsw i32 %y, -20
%cmp = icmp sge i32 %1, %2
ret i1 %cmp
}
Simplify (A & ~B) in icmp if A is a power of 2 The transform will execute like so: (A & ~B) == 0 --> (A & B) != 0 (A & ~B) != 0 --> (A & B) == 0 llvm-svn: 179386
2013-04-13 01:25:07 +08:00
define i1 @icmp_and_shl_neg_ne_0(i32 %A, i32 %B) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_and_shl_neg_ne_0(
; CHECK-NEXT: [[SHL:%.*]] = shl i32 1, %B
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[SHL]], %A
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
Simplify (A & ~B) in icmp if A is a power of 2 The transform will execute like so: (A & ~B) == 0 --> (A & B) != 0 (A & ~B) != 0 --> (A & B) == 0 llvm-svn: 179386
2013-04-13 01:25:07 +08:00
%neg = xor i32 %A, -1
%shl = shl i32 1, %B
%and = and i32 %shl, %neg
%cmp = icmp ne i32 %and, 0
ret i1 %cmp
}
define i1 @icmp_and_shl_neg_eq_0(i32 %A, i32 %B) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_and_shl_neg_eq_0(
; CHECK-NEXT: [[SHL:%.*]] = shl i32 1, %B
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[SHL]], %A
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
Simplify (A & ~B) in icmp if A is a power of 2 The transform will execute like so: (A & ~B) == 0 --> (A & B) != 0 (A & ~B) != 0 --> (A & B) == 0 llvm-svn: 179386
2013-04-13 01:25:07 +08:00
%neg = xor i32 %A, -1
%shl = shl i32 1, %B
%and = and i32 %shl, %neg
%cmp = icmp eq i32 %and, 0
ret i1 %cmp
}
Reorders two transforms that collide with each other One performs: (X == 13 | X == 14) -> X-13 <u 2 The other: (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1 The problem is that there are certain values of C1 and C2 that trigger both transforms but the first one blocks out the second, this generates suboptimal code. Reordering the transforms should be better in every case and allows us to do interesting stuff like turn: %shr = lshr i32 %X, 4 %and = and i32 %shr, 15 %add = add i32 %and, -14 %tobool = icmp ne i32 %add, 0 into: %and = and i32 %X, 240 %tobool = icmp ne i32 %and, 224 llvm-svn: 179493
2013-04-15 05:15:43 +08:00
define i1 @icmp_add_and_shr_ne_0(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_add_and_shr_ne_0(
; CHECK-NEXT: [[AND:%.*]] = and i32 %X, 240
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[AND]], 224
; CHECK-NEXT: ret i1 [[TOBOOL]]
;
Reorders two transforms that collide with each other One performs: (X == 13 | X == 14) -> X-13 <u 2 The other: (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1 The problem is that there are certain values of C1 and C2 that trigger both transforms but the first one blocks out the second, this generates suboptimal code. Reordering the transforms should be better in every case and allows us to do interesting stuff like turn: %shr = lshr i32 %X, 4 %and = and i32 %shr, 15 %add = add i32 %and, -14 %tobool = icmp ne i32 %add, 0 into: %and = and i32 %X, 240 %tobool = icmp ne i32 %and, 224 llvm-svn: 179493
2013-04-15 05:15:43 +08:00
%shr = lshr i32 %X, 4
%and = and i32 %shr, 15
%add = add i32 %and, -14
%tobool = icmp ne i32 %add, 0
ret i1 %tobool
}
Add a testcase from pr16244. llvm-svn: 183433
2013-06-07 03:15:23 +08:00
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278632
2016-08-15 05:36:22 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_add_and_shr_ne_0_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_add_and_shr_ne_0_vec(
; CHECK-NEXT: [[SHR:%.*]] = lshr <2 x i32> %X, <i32 4, i32 4>
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> [[SHR]], <i32 15, i32 15>
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne <2 x i32> [[AND]], <i32 14, i32 14>
; CHECK-NEXT: ret <2 x i1> [[TOBOOL]]
;
%shr = lshr <2 x i32> %X, <i32 4, i32 4>
%and = and <2 x i32> %shr, <i32 15, i32 15>
%add = add <2 x i32> %and, <i32 -14, i32 -14>
%tobool = icmp ne <2 x i32> %add, zeroinitializer
ret <2 x i1> %tobool
}
Add a testcase from pr16244. llvm-svn: 183433
2013-06-07 03:15:23 +08:00
; PR16244
define i1 @test71(i8* %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @test71(
; CHECK-NEXT: ret i1 false
;
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%a = getelementptr i8, i8* %x, i64 8
%b = getelementptr inbounds i8, i8* %x, i64 8
Add a testcase from pr16244. llvm-svn: 183433
2013-06-07 03:15:23 +08:00
%c = icmp ugt i8* %a, %b
ret i1 %c
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
define i1 @test71_as1(i8 addrspace(1)* %x) {
; CHECK-LABEL: @test71_as1(
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-NEXT: ret i1 false
;
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction One of several parallel first steps to remove the target type of pointers, replacing them with a single opaque pointer type. This adds an explicit type parameter to the gep instruction so that when the first parameter becomes an opaque pointer type, the type to gep through is still available to the instructions. * This doesn't modify gep operators, only instructions (operators will be handled separately) * Textual IR changes only. Bitcode (including upgrade) and changing the in-memory representation will be in separate changes. * geps of vectors are transformed as: getelementptr <4 x float*> %x, ... ->getelementptr float, <4 x float*> %x, ... Then, once the opaque pointer type is introduced, this will ultimately look like: getelementptr float, <4 x ptr> %x with the unambiguous interpretation that it is a vector of pointers to float. * address spaces remain on the pointer, not the type: getelementptr float addrspace(1)* %x ->getelementptr float, float addrspace(1)* %x Then, eventually: getelementptr float, ptr addrspace(1) %x Importantly, the massive amount of test case churn has been automated by same crappy python code. I had to manually update a few test cases that wouldn't fit the script's model (r228970,r229196,r229197,r229198). The python script just massages stdin and writes the result to stdout, I then wrapped that in a shell script to handle replacing files, then using the usual find+xargs to migrate all the files. update.py: import fileinput import sys import re ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))") def conv(match, line): if not match: return line line = match.groups()[0] if len(match.groups()[5]) == 0: line += match.groups()[2] line += match.groups()[3] line += ", " line += match.groups()[1] line += "\n" return line for line in sys.stdin: if line.find("getelementptr ") == line.find("getelementptr inbounds"): if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("): line = conv(re.match(ibrep, line), line) elif line.find("getelementptr ") != line.find("getelementptr ("): line = conv(re.match(normrep, line), line) sys.stdout.write(line) apply.sh: for name in "$@" do python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name" rm -f "$name.tmp" done The actual commands: From llvm/src: find test/ -name *.ll | xargs ./apply.sh From llvm/src/tools/clang: find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}" From llvm/src/tools/polly: find test/ -name *.ll | xargs ./apply.sh After that, check-all (with llvm, clang, clang-tools-extra, lld, compiler-rt, and polly all checked out). The extra 'rm' in the apply.sh script is due to a few files in clang's test suite using interesting unicode stuff that my python script was throwing exceptions on. None of those files needed to be migrated, so it seemed sufficient to ignore those cases. Reviewers: rafael, dexonsmith, grosser Differential Revision: http://reviews.llvm.org/D7636 llvm-svn: 230786
2015-02-28 03:29:02 +08:00
%a = getelementptr i8, i8 addrspace(1)* %x, i64 8
%b = getelementptr inbounds i8, i8 addrspace(1)* %x, i64 8
Teach InstCombine about address spaces llvm-svn: 188926
2013-08-22 03:53:10 +08:00
%c = icmp ugt i8 addrspace(1)* %a, %b
ret i1 %c
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_ult_32(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_ult_32(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %V, 5
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp ult i32 %shl, 32
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278757
2016-08-16 06:43:52 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_shl_1_V_ult_32_vec(<2 x i32> %V) {
; CHECK-LABEL: @icmp_shl_1_V_ult_32_vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %V
; CHECK-NEXT: [[CMP:%.*]] = icmp ult <2 x i32> [[SHL]], <i32 32, i32 32>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %V
%cmp = icmp ult <2 x i32> %shl, <i32 32, i32 32>
ret <2 x i1> %cmp
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_eq_32(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_eq_32(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %V, 5
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp eq i32 %shl, 32
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278757
2016-08-16 06:43:52 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_shl_1_V_eq_32_vec(<2 x i32> %V) {
; CHECK-LABEL: @icmp_shl_1_V_eq_32_vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %V
; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> [[SHL]], <i32 32, i32 32>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %V
%cmp = icmp eq <2 x i32> %shl, <i32 32, i32 32>
ret <2 x i1> %cmp
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_ult_30(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_ult_30(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %V, 5
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp ult i32 %shl, 30
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278757
2016-08-16 06:43:52 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_shl_1_V_ult_30_vec(<2 x i32> %V) {
; CHECK-LABEL: @icmp_shl_1_V_ult_30_vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %V
; CHECK-NEXT: [[CMP:%.*]] = icmp ult <2 x i32> [[SHL]], <i32 30, i32 30>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %V
%cmp = icmp ult <2 x i32> %shl, <i32 30, i32 30>
ret <2 x i1> %cmp
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_ugt_30(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_ugt_30(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %V, 4
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp ugt i32 %shl, 30
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278757
2016-08-16 06:43:52 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_shl_1_V_ugt_30_vec(<2 x i32> %V) {
; CHECK-LABEL: @icmp_shl_1_V_ugt_30_vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %V
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt <2 x i32> [[SHL]], <i32 30, i32 30>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %V
%cmp = icmp ugt <2 x i32> %shl, <i32 30, i32 30>
ret <2 x i1> %cmp
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_ule_30(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_ule_30(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %V, 5
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp ule i32 %shl, 30
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278757
2016-08-16 06:43:52 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_shl_1_V_ule_30_vec(<2 x i32> %V) {
; CHECK-LABEL: @icmp_shl_1_V_ule_30_vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %V
; CHECK-NEXT: [[CMP:%.*]] = icmp ult <2 x i32> [[SHL]], <i32 31, i32 31>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %V
%cmp = icmp ule <2 x i32> %shl, <i32 30, i32 30>
ret <2 x i1> %cmp
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_uge_30(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_uge_30(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %V, 4
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp uge i32 %shl, 30
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278757
2016-08-16 06:43:52 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_shl_1_V_uge_30_vec(<2 x i32> %V) {
; CHECK-LABEL: @icmp_shl_1_V_uge_30_vec(
; CHECK-NEXT: [[SHL:%.*]] = shl <2 x i32> <i32 1, i32 1>, %V
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt <2 x i32> [[SHL]], <i32 29, i32 29>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%shl = shl <2 x i32> <i32 1, i32 1>, %V
%cmp = icmp uge <2 x i32> %shl, <i32 30, i32 30>
ret <2 x i1> %cmp
}
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
define i1 @icmp_shl_1_V_uge_2147483648(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_uge_2147483648(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %V, 31
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp uge i32 %shl, 2147483648
ret i1 %cmp
}
define i1 @icmp_shl_1_V_ult_2147483648(i32 %V) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_shl_1_V_ult_2147483648(
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 %V, 31
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Optimize (1 << X) Pred CstP2 to X Pred Log2(CstP2) We may, after other optimizations, find ourselves with IR that looks like: %shl = shl i32 1, %y %cmp = icmp ult i32 %shl, 32 Instead, we should just compare the shift count: %cmp = icmp ult i32 %y, 5 llvm-svn: 185242
2013-06-29 07:42:03 +08:00
%shl = shl i32 1, %V
%cmp = icmp ult i32 %shl, 2147483648
ret i1 %cmp
}
InstCombine: (icmp eq B, 0) | (icmp ult A, B) -> (icmp ule A, B-1) This transform allows us to turn IR that looks like: %1 = icmp eq i64 %b, 0 %2 = icmp ult i64 %a, %b %3 = or i1 %1, %2 ret i1 %3 into: %0 = add i64 %b, -1 %1 = icmp uge i64 %0, %a ret i1 %1 which means we go from lowering: cmpq %rsi, %rdi setb %cl testq %rsi, %rsi sete %al orb %cl, %al ret to lowering: decq %rsi cmpq %rdi, %rsi setae %al ret llvm-svn: 185677
2013-07-05 08:31:17 +08:00
define i1 @or_icmp_eq_B_0_icmp_ult_A_B(i64 %a, i64 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @or_icmp_eq_B_0_icmp_ult_A_B(
; CHECK-NEXT: [[TMP1:%.*]] = add i64 %b, -1
; CHECK-NEXT: [[TMP2:%.*]] = icmp uge i64 [[TMP1]], %a
; CHECK-NEXT: ret i1 [[TMP2]]
;
InstCombine: (icmp eq B, 0) | (icmp ult A, B) -> (icmp ule A, B-1) This transform allows us to turn IR that looks like: %1 = icmp eq i64 %b, 0 %2 = icmp ult i64 %a, %b %3 = or i1 %1, %2 ret i1 %3 into: %0 = add i64 %b, -1 %1 = icmp uge i64 %0, %a ret i1 %1 which means we go from lowering: cmpq %rsi, %rdi setb %cl testq %rsi, %rsi sete %al orb %cl, %al ret to lowering: decq %rsi cmpq %rdi, %rsi setae %al ret llvm-svn: 185677
2013-07-05 08:31:17 +08:00
%1 = icmp eq i64 %b, 0
%2 = icmp ult i64 %a, %b
%3 = or i1 %1, %2
ret i1 %3
}
InstCombine: Fold X-C1 <u 2 -> (X & -2) == C1 Back in r179493 we determined that two transforms collided with each other. The fix back then was to reorder the transforms so that the preferred transform would give it a try and then we would try the secondary transform. However, it was noted that the best approach would canonicalize one transform into the other, removing the collision and allowing us to optimize IR given to us in that form. llvm-svn: 185808
2013-07-08 19:53:08 +08:00
define i1 @icmp_add_ult_2(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_add_ult_2(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 %X, -2
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP1]], 14
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: Fold X-C1 <u 2 -> (X & -2) == C1 Back in r179493 we determined that two transforms collided with each other. The fix back then was to reorder the transforms so that the preferred transform would give it a try and then we would try the secondary transform. However, it was noted that the best approach would canonicalize one transform into the other, removing the collision and allowing us to optimize IR given to us in that form. llvm-svn: 185808
2013-07-08 19:53:08 +08:00
%add = add i32 %X, -14
%cmp = icmp ult i32 %add, 2
ret i1 %cmp
}
InstCombine: add more transforms C1-X <u C2 -> (X|(C2-1)) == C1 C1-X >u C2 -> (X|C2) == C1 X-C1 <u C2 -> (X & -C2) == C1 X-C1 >u C2 -> (X & ~C2) == C1 llvm-svn: 185909
2013-07-09 15:50:59 +08:00
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278751
2016-08-16 05:47:50 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_add_X_-14_ult_2_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_add_X_-14_ult_2_vec(
; CHECK-NEXT: [[ADD:%.*]] = add <2 x i32> %X, <i32 -14, i32 -14>
; CHECK-NEXT: [[CMP:%.*]] = icmp ult <2 x i32> [[ADD]], <i32 2, i32 2>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
;
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278751
2016-08-16 05:47:50 +08:00
%add = add <2 x i32> %X, <i32 -14, i32 -14>
%cmp = icmp ult <2 x i32> %add, <i32 2, i32 2>
ret <2 x i1> %cmp
InstCombine: add more transforms C1-X <u C2 -> (X|(C2-1)) == C1 C1-X >u C2 -> (X|C2) == C1 X-C1 <u C2 -> (X & -C2) == C1 X-C1 >u C2 -> (X & ~C2) == C1 llvm-svn: 185909
2013-07-09 15:50:59 +08:00
}
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
define i1 @icmp_sub_3_X_ult_2(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub_3_X_ult_2(
; CHECK-NEXT: [[TMP1:%.*]] = or i32 %X, 1
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP1]], 3
; CHECK-NEXT: ret i1 [[CMP]]
;
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
%add = sub i32 3, %X
%cmp = icmp ult i32 %add, 2
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278737
2016-08-16 04:56:11 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_sub_3_X_ult_2_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_sub_3_X_ult_2_vec(
; CHECK-NEXT: [[ADD:%.*]] = sub <2 x i32> <i32 3, i32 3>, %X
; CHECK-NEXT: [[CMP:%.*]] = icmp ult <2 x i32> [[ADD]], <i32 2, i32 2>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%add = sub <2 x i32> <i32 3, i32 3>, %X
%cmp = icmp ult <2 x i32> %add, <i32 2, i32 2>
ret <2 x i1> %cmp
}
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
define i1 @icmp_add_X_-14_uge_2(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_add_X_-14_uge_2(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 %X, -2
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP1]], 14
; CHECK-NEXT: ret i1 [[CMP]]
;
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
%add = add i32 %X, -14
%cmp = icmp uge i32 %add, 2
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278751
2016-08-16 05:47:50 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_add_X_-14_uge_2_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_add_X_-14_uge_2_vec(
; CHECK-NEXT: [[ADD:%.*]] = add <2 x i32> %X, <i32 -14, i32 -14>
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt <2 x i32> [[ADD]], <i32 1, i32 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%add = add <2 x i32> %X, <i32 -14, i32 -14>
%cmp = icmp uge <2 x i32> %add, <i32 2, i32 2>
ret <2 x i1> %cmp
}
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
define i1 @icmp_sub_3_X_uge_2(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub_3_X_uge_2(
; CHECK-NEXT: [[TMP1:%.*]] = or i32 %X, 1
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP1]], 3
; CHECK-NEXT: ret i1 [[CMP]]
;
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
%add = sub i32 3, %X
%cmp = icmp uge i32 %add, 2
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278737
2016-08-16 04:56:11 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_sub_3_X_uge_2_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_sub_3_X_uge_2_vec(
; CHECK-NEXT: [[ADD:%.*]] = sub <2 x i32> <i32 3, i32 3>, %X
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt <2 x i32> [[ADD]], <i32 1, i32 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%add = sub <2 x i32> <i32 3, i32 3>, %X
%cmp = icmp uge <2 x i32> %add, <i32 2, i32 2>
ret <2 x i1> %cmp
}
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
define i1 @icmp_and_X_-16_eq-16(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_and_X_-16_eq-16(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %X, -17
; CHECK-NEXT: ret i1 [[CMP]]
;
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
%and = and i32 %X, -16
%cmp = icmp eq i32 %and, -16
ret i1 %cmp
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278634
2016-08-15 06:28:50 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_and_X_-16_eq-16_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_and_X_-16_eq-16_vec(
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> %X, <i32 -16, i32 -16>
; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> [[AND]], <i32 -16, i32 -16>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%and = and <2 x i32> %X, <i32 -16, i32 -16>
%cmp = icmp eq <2 x i32> %and, <i32 -16, i32 -16>
ret <2 x i1> %cmp
}
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
define i1 @icmp_and_X_-16_ne-16(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_and_X_-16_ne-16(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %X, -16
; CHECK-NEXT: ret i1 [[CMP]]
;
Commit r185909 was a misapplied patch, fix it llvm-svn: 185910
2013-07-09 15:58:32 +08:00
%and = and i32 %X, -16
%cmp = icmp ne i32 %and, -16
ret i1 %cmp
}
InstCombine: variations on 0xffffffff - x >= 4 The following transforms are valid if -C is a power of 2: (icmp ugt (xor X, C), ~C) -> (icmp ult X, C) (icmp ult (xor X, C), -C) -> (icmp uge X, C) These are nice, they get rid of the xor. llvm-svn: 185915
2013-07-09 17:20:58 +08:00
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278634
2016-08-15 06:28:50 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_and_X_-16_ne-16_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_and_X_-16_ne-16_vec(
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> %X, <i32 -16, i32 -16>
; CHECK-NEXT: [[CMP:%.*]] = icmp ne <2 x i32> [[AND]], <i32 -16, i32 -16>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%and = and <2 x i32> %X, <i32 -16, i32 -16>
%cmp = icmp ne <2 x i32> %and, <i32 -16, i32 -16>
ret <2 x i1> %cmp
}
InstCombine: variations on 0xffffffff - x >= 4 The following transforms are valid if -C is a power of 2: (icmp ugt (xor X, C), ~C) -> (icmp ult X, C) (icmp ult (xor X, C), -C) -> (icmp uge X, C) These are nice, they get rid of the xor. llvm-svn: 185915
2013-07-09 17:20:58 +08:00
define i1 @icmp_sub_-1_X_ult_4(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub_-1_X_ult_4(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %X, -5
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: variations on 0xffffffff - x >= 4 The following transforms are valid if -C is a power of 2: (icmp ugt (xor X, C), ~C) -> (icmp ult X, C) (icmp ult (xor X, C), -C) -> (icmp uge X, C) These are nice, they get rid of the xor. llvm-svn: 185915
2013-07-09 17:20:58 +08:00
%sub = sub i32 -1, %X
%cmp = icmp ult i32 %sub, 4
ret i1 %cmp
}
add tests for missing vector icmp folds llvm-svn: 278132
2016-08-10 00:39:05 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_sub_neg1_X_ult_4_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_sub_neg1_X_ult_4_vec(
; CHECK-NEXT: [[SUB:%.*]] = xor <2 x i32> %X, <i32 -1, i32 -1>
; CHECK-NEXT: [[CMP:%.*]] = icmp ult <2 x i32> [[SUB]], <i32 4, i32 4>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%sub = sub <2 x i32> <i32 -1, i32 -1>, %X
%cmp = icmp ult <2 x i32> %sub, <i32 4, i32 4>
ret <2 x i1> %cmp
}
InstCombine: variations on 0xffffffff - x >= 4 The following transforms are valid if -C is a power of 2: (icmp ugt (xor X, C), ~C) -> (icmp ult X, C) (icmp ult (xor X, C), -C) -> (icmp uge X, C) These are nice, they get rid of the xor. llvm-svn: 185915
2013-07-09 17:20:58 +08:00
define i1 @icmp_sub_-1_X_uge_4(i32 %X) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sub_-1_X_uge_4(
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %X, -4
; CHECK-NEXT: ret i1 [[CMP]]
;
InstCombine: variations on 0xffffffff - x >= 4 The following transforms are valid if -C is a power of 2: (icmp ugt (xor X, C), ~C) -> (icmp ult X, C) (icmp ult (xor X, C), -C) -> (icmp uge X, C) These are nice, they get rid of the xor. llvm-svn: 185915
2013-07-09 17:20:58 +08:00
%sub = sub i32 -1, %X
%cmp = icmp uge i32 %sub, 4
ret i1 %cmp
}
[InstCombiner] Expose opportunities to merge subtract and comparison. Several architectures use the same instruction to perform both a comparison and a subtract. The instruction selection framework does not allow to consider different basic blocks to expose such fusion opportunities. Therefore, these instructions are “merged” by CSE at MI IR level. To increase the likelihood of CSE to apply in such situation, we reorder the operands of the comparison, when they have the same complexity, so that they matches the order of the most frequent subtract. E.g., icmp A, B ... sub B, A <rdar://problem/14514580> llvm-svn: 190352
2013-09-10 04:56:48 +08:00
add tests for missing vector icmp folds llvm-svn: 278132
2016-08-10 00:39:05 +08:00
; FIXME: Vectors should fold too.
define <2 x i1> @icmp_sub_neg1_X_uge_4_vec(<2 x i32> %X) {
; CHECK-LABEL: @icmp_sub_neg1_X_uge_4_vec(
; CHECK-NEXT: [[SUB:%.*]] = xor <2 x i32> %X, <i32 -1, i32 -1>
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt <2 x i32> [[SUB]], <i32 3, i32 3>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%sub = sub <2 x i32> <i32 -1, i32 -1>, %X
%cmp = icmp uge <2 x i32> %sub, <i32 4, i32 4>
ret <2 x i1> %cmp
}
[InstCombiner] Expose opportunities to merge subtract and comparison. Several architectures use the same instruction to perform both a comparison and a subtract. The instruction selection framework does not allow to consider different basic blocks to expose such fusion opportunities. Therefore, these instructions are “merged” by CSE at MI IR level. To increase the likelihood of CSE to apply in such situation, we reorder the operands of the comparison, when they have the same complexity, so that they matches the order of the most frequent subtract. E.g., icmp A, B ... sub B, A <rdar://problem/14514580> llvm-svn: 190352
2013-09-10 04:56:48 +08:00
define i1 @icmp_swap_operands_for_cse(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_swap_operands_for_cse(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[SUB:%.*]] = sub i32 %X, %Y
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %X, %Y
; CHECK-NEXT: br i1 [[CMP]], label %true, label %false
; CHECK: true:
; CHECK-NEXT: [[TMP0:%.*]] = and i32 [[SUB]], 1
; CHECK-NEXT: br label %end
; CHECK: false:
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[SUB]], 16
; CHECK-NEXT: br label %end
; CHECK: end:
; CHECK-NEXT: [[RES_IN:%.*]] = phi i32 [ [[TMP0]], %true ], [ [[TMP1]], %false ]
; CHECK-NEXT: [[RES:%.*]] = icmp ne i32 [[RES:%.*]].in, 0
; CHECK-NEXT: ret i1 [[RES]]
;
[InstCombiner] Expose opportunities to merge subtract and comparison. Several architectures use the same instruction to perform both a comparison and a subtract. The instruction selection framework does not allow to consider different basic blocks to expose such fusion opportunities. Therefore, these instructions are “merged” by CSE at MI IR level. To increase the likelihood of CSE to apply in such situation, we reorder the operands of the comparison, when they have the same complexity, so that they matches the order of the most frequent subtract. E.g., icmp A, B ... sub B, A <rdar://problem/14514580> llvm-svn: 190352
2013-09-10 04:56:48 +08:00
entry:
%sub = sub i32 %X, %Y
%cmp = icmp ugt i32 %Y, %X
br i1 %cmp, label %true, label %false
true:
%restrue = trunc i32 %sub to i1
br label %end
false:
%shift = lshr i32 %sub, 4
%resfalse = trunc i32 %shift to i1
br label %end
end:
%res = phi i1 [%restrue, %true], [%resfalse, %false]
ret i1 %res
}
define i1 @icmp_swap_operands_for_cse2(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_swap_operands_for_cse2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 %X, %Y
; CHECK-NEXT: br i1 [[CMP]], label %true, label %false
; CHECK: true:
; CHECK-NEXT: [[SUB:%.*]] = sub i32 %X, %Y
; CHECK-NEXT: [[SUB1:%.*]] = sub i32 %X, %Y
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[SUB]], [[SUB1]]
; CHECK-NEXT: br label %end
; CHECK: false:
; CHECK-NEXT: [[SUB2:%.*]] = sub i32 %Y, %X
; CHECK-NEXT: br label %end
; CHECK: end:
; CHECK-NEXT: [[RES_IN_IN:%.*]] = phi i32 [ [[ADD]], %true ], [ [[SUB2]], %false ]
; CHECK-NEXT: [[RES_IN:%.*]] = and i32 [[RES_IN:%.*]].in, 1
; CHECK-NEXT: [[RES:%.*]] = icmp ne i32 [[RES:%.*]].in, 0
; CHECK-NEXT: ret i1 [[RES]]
;
[InstCombiner] Expose opportunities to merge subtract and comparison. Several architectures use the same instruction to perform both a comparison and a subtract. The instruction selection framework does not allow to consider different basic blocks to expose such fusion opportunities. Therefore, these instructions are “merged” by CSE at MI IR level. To increase the likelihood of CSE to apply in such situation, we reorder the operands of the comparison, when they have the same complexity, so that they matches the order of the most frequent subtract. E.g., icmp A, B ... sub B, A <rdar://problem/14514580> llvm-svn: 190352
2013-09-10 04:56:48 +08:00
entry:
%cmp = icmp ugt i32 %Y, %X
br i1 %cmp, label %true, label %false
true:
%sub = sub i32 %X, %Y
%sub1 = sub i32 %X, %Y
%add = add i32 %sub, %sub1
%restrue = trunc i32 %add to i1
br label %end
false:
%sub2 = sub i32 %Y, %X
%resfalse = trunc i32 %sub2 to i1
br label %end
end:
%res = phi i1 [%restrue, %true], [%resfalse, %false]
ret i1 %res
}
define i1 @icmp_do_not_swap_operands_for_cse(i32 %X, i32 %Y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_do_not_swap_operands_for_cse(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %Y, %X
; CHECK-NEXT: br i1 [[CMP]], label %true, label %false
; CHECK: true:
; CHECK-NEXT: [[SUB:%.*]] = sub i32 %X, %Y
; CHECK-NEXT: br label %end
; CHECK: false:
; CHECK-NEXT: [[SUB2:%.*]] = sub i32 %Y, %X
; CHECK-NEXT: br label %end
; CHECK: end:
; CHECK-NEXT: [[RES_IN_IN:%.*]] = phi i32 [ [[SUB]], %true ], [ [[SUB2]], %false ]
; CHECK-NEXT: [[RES_IN:%.*]] = and i32 [[RES_IN:%.*]].in, 1
; CHECK-NEXT: [[RES:%.*]] = icmp ne i32 [[RES:%.*]].in, 0
; CHECK-NEXT: ret i1 [[RES]]
;
[InstCombiner] Expose opportunities to merge subtract and comparison. Several architectures use the same instruction to perform both a comparison and a subtract. The instruction selection framework does not allow to consider different basic blocks to expose such fusion opportunities. Therefore, these instructions are “merged” by CSE at MI IR level. To increase the likelihood of CSE to apply in such situation, we reorder the operands of the comparison, when they have the same complexity, so that they matches the order of the most frequent subtract. E.g., icmp A, B ... sub B, A <rdar://problem/14514580> llvm-svn: 190352
2013-09-10 04:56:48 +08:00
entry:
%cmp = icmp ugt i32 %Y, %X
br i1 %cmp, label %true, label %false
true:
%sub = sub i32 %X, %Y
%restrue = trunc i32 %sub to i1
br label %end
false:
%sub2 = sub i32 %Y, %X
%resfalse = trunc i32 %sub2 to i1
br label %end
end:
%res = phi i1 [%restrue, %true], [%resfalse, %false]
ret i1 %res
}
InstCombine: fold (A >> C) == (B >> C) --> (A^B) < (1 << C) for constant Cs. This is common in bitfield code. llvm-svn: 194925
2013-11-17 00:00:48 +08:00
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @icmp_lshr_lshr_eq(i32 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_lshr_lshr_eq(
; CHECK-NEXT: [[Z_UNSHIFTED:%.*]] = xor i32 %a, %b
; CHECK-NEXT: [[Z:%.*]] = icmp ult i32 [[Z:%.*]].unshifted, 1073741824
; CHECK-NEXT: ret i1 [[Z]]
;
%x = lshr i32 %a, 30
%y = lshr i32 %b, 30
%z = icmp eq i32 %x, %y
ret i1 %z
InstCombine: fold (A >> C) == (B >> C) --> (A^B) < (1 << C) for constant Cs. This is common in bitfield code. llvm-svn: 194925
2013-11-17 00:00:48 +08:00
}
[InstCombine] remove unnecessary function attributes from tests llvm-svn: 278633
2016-08-15 05:48:21 +08:00
define i1 @icmp_ashr_ashr_ne(i32 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_ashr_ashr_ne(
; CHECK-NEXT: [[Z_UNSHIFTED:%.*]] = xor i32 %a, %b
; CHECK-NEXT: [[Z:%.*]] = icmp ugt i32 [[Z:%.*]].unshifted, 255
; CHECK-NEXT: ret i1 [[Z]]
;
%x = ashr i32 %a, 8
%y = ashr i32 %b, 8
%z = icmp ne i32 %x, %y
ret i1 %z
InstCombine: fold (A >> C) == (B >> C) --> (A^B) < (1 << C) for constant Cs. This is common in bitfield code. llvm-svn: 194925
2013-11-17 00:00:48 +08:00
}
InstCombine: Optimize -x s< cst Summary: This gets rid of a sub instruction by moving the negation to the constant when valid. Reviewers: nicholas Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D3773 llvm-svn: 208827
2014-05-15 08:02:20 +08:00
define i1 @icmp_neg_cst_slt(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_neg_cst_slt(
; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i32 %a, 10
; CHECK-NEXT: ret i1 [[TMP1]]
;
InstCombine: Optimize -x s< cst Summary: This gets rid of a sub instruction by moving the negation to the constant when valid. Reviewers: nicholas Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D3773 llvm-svn: 208827
2014-05-15 08:02:20 +08:00
%1 = sub nsw i32 0, %a
%2 = icmp slt i32 %1, -10
ret i1 %2
}
InstCombine: Properly optimize or'ing bittests together CFE, with -03, would turn: bool f(unsigned x) { bool a = x & 1; bool b = x & 2; return a | b; } into: %1 = lshr i32 %x, 1 %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 This sort of thing exposes a nasty pathology in GCC, ICC and LLVM. Instead, we would rather want: %1 = and i32 %x, 3 %2 = icmp ne i32 %1, 0 Things get a bit more interesting in the following case: %1 = lshr i32 %x, %y %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 Replacing it with the following sequence is better: %1 = shl nuw i32 1, %y %2 = or i32 %1, 1 %3 = and i32 %2, %x %4 = icmp ne i32 %3, 0 This sequence is preferable because %1 doesn't involve %x and could potentially be hoisted out of loops if it is invariant; only perform this transform in the non-constant case if we know we won't increase register pressure. llvm-svn: 216343
2014-08-24 17:10:57 +08:00
define i1 @icmp_and_or_lshr(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_and_or_lshr(
; CHECK-NEXT: [[SHF1:%.*]] = shl nuw i32 1, %y
; CHECK-NEXT: [[OR2:%.*]] = or i32 [[SHF1]], 1
; CHECK-NEXT: [[AND3:%.*]] = and i32 [[OR2]], %x
; CHECK-NEXT: [[RET:%.*]] = icmp ne i32 [[AND3]], 0
; CHECK-NEXT: ret i1 [[RET]]
;
InstCombine: Properly optimize or'ing bittests together CFE, with -03, would turn: bool f(unsigned x) { bool a = x & 1; bool b = x & 2; return a | b; } into: %1 = lshr i32 %x, 1 %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 This sort of thing exposes a nasty pathology in GCC, ICC and LLVM. Instead, we would rather want: %1 = and i32 %x, 3 %2 = icmp ne i32 %1, 0 Things get a bit more interesting in the following case: %1 = lshr i32 %x, %y %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 Replacing it with the following sequence is better: %1 = shl nuw i32 1, %y %2 = or i32 %1, 1 %3 = and i32 %2, %x %4 = icmp ne i32 %3, 0 This sequence is preferable because %1 doesn't involve %x and could potentially be hoisted out of loops if it is invariant; only perform this transform in the non-constant case if we know we won't increase register pressure. llvm-svn: 216343
2014-08-24 17:10:57 +08:00
%shf = lshr i32 %x, %y
%or = or i32 %shf, %x
%and = and i32 %or, 1
%ret = icmp ne i32 %and, 0
ret i1 %ret
}
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278632
2016-08-15 05:36:22 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_and_or_lshr_vec(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: @icmp_and_or_lshr_vec(
; CHECK-NEXT: [[SHF:%.*]] = lshr <2 x i32> %x, %y
; CHECK-NEXT: [[OR:%.*]] = or <2 x i32> [[SHF]], %x
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> [[OR]], <i32 1, i32 1>
; CHECK-NEXT: [[RET:%.*]] = icmp ne <2 x i32> [[AND]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[RET]]
;
%shf = lshr <2 x i32> %x, %y
%or = or <2 x i32> %shf, %x
%and = and <2 x i32> %or, <i32 1, i32 1>
%ret = icmp ne <2 x i32> %and, zeroinitializer
ret <2 x i1> %ret
}
InstCombine: Properly optimize or'ing bittests together CFE, with -03, would turn: bool f(unsigned x) { bool a = x & 1; bool b = x & 2; return a | b; } into: %1 = lshr i32 %x, 1 %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 This sort of thing exposes a nasty pathology in GCC, ICC and LLVM. Instead, we would rather want: %1 = and i32 %x, 3 %2 = icmp ne i32 %1, 0 Things get a bit more interesting in the following case: %1 = lshr i32 %x, %y %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 Replacing it with the following sequence is better: %1 = shl nuw i32 1, %y %2 = or i32 %1, 1 %3 = and i32 %2, %x %4 = icmp ne i32 %3, 0 This sequence is preferable because %1 doesn't involve %x and could potentially be hoisted out of loops if it is invariant; only perform this transform in the non-constant case if we know we won't increase register pressure. llvm-svn: 216343
2014-08-24 17:10:57 +08:00
define i1 @icmp_and_or_lshr_cst(i32 %x) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_and_or_lshr_cst(
; CHECK-NEXT: [[AND1:%.*]] = and i32 %x, 3
; CHECK-NEXT: [[RET:%.*]] = icmp ne i32 [[AND1]], 0
; CHECK-NEXT: ret i1 [[RET]]
;
InstCombine: Properly optimize or'ing bittests together CFE, with -03, would turn: bool f(unsigned x) { bool a = x & 1; bool b = x & 2; return a | b; } into: %1 = lshr i32 %x, 1 %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 This sort of thing exposes a nasty pathology in GCC, ICC and LLVM. Instead, we would rather want: %1 = and i32 %x, 3 %2 = icmp ne i32 %1, 0 Things get a bit more interesting in the following case: %1 = lshr i32 %x, %y %2 = or i32 %1, %x %3 = and i32 %2, 1 %4 = icmp ne i32 %3, 0 Replacing it with the following sequence is better: %1 = shl nuw i32 1, %y %2 = or i32 %1, 1 %3 = and i32 %2, %x %4 = icmp ne i32 %3, 0 This sequence is preferable because %1 doesn't involve %x and could potentially be hoisted out of loops if it is invariant; only perform this transform in the non-constant case if we know we won't increase register pressure. llvm-svn: 216343
2014-08-24 17:10:57 +08:00
%shf = lshr i32 %x, 1
%or = or i32 %shf, %x
%and = and i32 %or, 1
%ret = icmp ne i32 %and, 0
ret i1 %ret
}
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
[InstCombine] add tests for missing vector icmp folds llvm-svn: 278632
2016-08-15 05:36:22 +08:00
; FIXME: Vectors should fold the same way.
define <2 x i1> @icmp_and_or_lshr_cst_vec(<2 x i32> %x) {
; CHECK-LABEL: @icmp_and_or_lshr_cst_vec(
; CHECK-NEXT: [[SHF:%.*]] = lshr <2 x i32> %x, <i32 1, i32 1>
; CHECK-NEXT: [[OR:%.*]] = or <2 x i32> [[SHF]], %x
; CHECK-NEXT: [[AND:%.*]] = and <2 x i32> [[OR]], <i32 1, i32 1>
; CHECK-NEXT: [[RET:%.*]] = icmp ne <2 x i32> [[AND]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[RET]]
;
%shf = lshr <2 x i32> %x, <i32 1, i32 1>
%or = or <2 x i32> %shf, %x
%and = and <2 x i32> %or, <i32 1, i32 1>
%ret = icmp ne <2 x i32> %and, zeroinitializer
ret <2 x i1> %ret
}
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
define i1 @shl_ap1_zero_ap2_non_zero_2(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_zero_ap2_non_zero_2(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %a, 29
; CHECK-NEXT: ret i1 [[CMP]]
;
%shl = shl i32 4, %a
%cmp = icmp eq i32 %shl, 0
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
define i1 @shl_ap1_zero_ap2_non_zero_4(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_zero_ap2_non_zero_4(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32 %a, 30
; CHECK-NEXT: ret i1 [[CMP]]
;
%shl = shl i32 -2, %a
%cmp = icmp eq i32 %shl, 0
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
define i1 @shl_ap1_non_zero_ap2_non_zero_both_positive(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_non_zero_ap2_non_zero_both_positive(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %a, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%shl = shl i32 50, %a
%cmp = icmp eq i32 %shl, 50
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
define i1 @shl_ap1_non_zero_ap2_non_zero_both_negative(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_non_zero_ap2_non_zero_both_negative(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %a, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%shl = shl i32 -50, %a
%cmp = icmp eq i32 %shl, -50
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
define i1 @shl_ap1_non_zero_ap2_non_zero_ap1_1(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_non_zero_ap2_non_zero_ap1_1(
; CHECK-NEXT: ret i1 false
;
%shl = shl i32 50, %a
%cmp = icmp eq i32 %shl, 25
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
define i1 @shl_ap1_non_zero_ap2_non_zero_ap1_2(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_non_zero_ap2_non_zero_ap1_2(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 %a, 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%shl = shl i32 25, %a
%cmp = icmp eq i32 %shl, 50
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
define i1 @shl_ap1_non_zero_ap2_non_zero_ap1_3(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @shl_ap1_non_zero_ap2_non_zero_ap1_3(
; CHECK-NEXT: ret i1 false
;
%shl = shl i32 26, %a
%cmp = icmp eq i32 %shl, 50
ret i1 %cmp
InstCombine: Optimize icmp eq/ne (shl Const2, A), Const1 The following implements the optimization for sequences of the form: icmp eq/ne (shl Const2, A), Const1 Such sequences can be transformed to: icmp eq/ne A, (TrailingZeros(Const1) - TrailingZeros(Const2)) This handles only the equality operators for now. Other operators need to be handled. Patch by Ankur Garg! llvm-svn: 220162
2014-10-19 16:23:08 +08:00
}
InstCombine: Combine (X+cst) < 0 --> X < -cst This can happen pretty often in code that looks like: int foo = bar - 1; if (foo < 0) do stuff In this case, bar < 1 is an equivalent condition. This transform requires that the add instruction be annotated with nsw. llvm-svn: 221045
2014-11-01 17:09:51 +08:00
define i1 @icmp_sgt_zero_add_nsw(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sgt_zero_add_nsw(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %a, -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%add = add nsw i32 %a, 1
%cmp = icmp sgt i32 %add, 0
ret i1 %cmp
InstCombine: Combine (X+cst) < 0 --> X < -cst This can happen pretty often in code that looks like: int foo = bar - 1; if (foo < 0) do stuff In this case, bar < 1 is an equivalent condition. This transform requires that the add instruction be annotated with nsw. llvm-svn: 221045
2014-11-01 17:09:51 +08:00
}
define i1 @icmp_sge_zero_add_nsw(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sge_zero_add_nsw(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 %a, -2
; CHECK-NEXT: ret i1 [[CMP]]
;
%add = add nsw i32 %a, 1
%cmp = icmp sge i32 %add, 0
ret i1 %cmp
InstCombine: Combine (X+cst) < 0 --> X < -cst This can happen pretty often in code that looks like: int foo = bar - 1; if (foo < 0) do stuff In this case, bar < 1 is an equivalent condition. This transform requires that the add instruction be annotated with nsw. llvm-svn: 221045
2014-11-01 17:09:51 +08:00
}
define i1 @icmp_slt_zero_add_nsw(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_slt_zero_add_nsw(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 %a, -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%add = add nsw i32 %a, 1
%cmp = icmp slt i32 %add, 0
ret i1 %cmp
InstCombine: Combine (X+cst) < 0 --> X < -cst This can happen pretty often in code that looks like: int foo = bar - 1; if (foo < 0) do stuff In this case, bar < 1 is an equivalent condition. This transform requires that the add instruction be annotated with nsw. llvm-svn: 221045
2014-11-01 17:09:51 +08:00
}
define i1 @icmp_sle_zero_add_nsw(i32 %a) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_sle_zero_add_nsw(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 %a, 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%add = add nsw i32 %a, 1
%cmp = icmp sle i32 %add, 0
ret i1 %cmp
InstCombine: Combine (X+cst) < 0 --> X < -cst This can happen pretty often in code that looks like: int foo = bar - 1; if (foo < 0) do stuff In this case, bar < 1 is an equivalent condition. This transform requires that the add instruction be annotated with nsw. llvm-svn: 221045
2014-11-01 17:09:51 +08:00
}
InstCombine: Rely on cmpxchg's return code when it's strong Comparing the result of a cmpxchg instruction can be replaced with an extractvalue of the cmpxchg success indicator. llvm-svn: 221498
2014-11-07 07:23:30 +08:00
define zeroext i1 @icmp_cmpxchg_strong(i32* %sc, i32 %old_val, i32 %new_val) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @icmp_cmpxchg_strong(
; CHECK-NEXT: [[XCHG:%.*]] = cmpxchg i32* %sc, i32 %old_val, i32 %new_val seq_cst seq_cst
; CHECK-NEXT: [[ICMP:%.*]] = extractvalue { i32, i1
;
InstCombine: Rely on cmpxchg's return code when it's strong Comparing the result of a cmpxchg instruction can be replaced with an extractvalue of the cmpxchg success indicator. llvm-svn: 221498
2014-11-07 07:23:30 +08:00
%xchg = cmpxchg i32* %sc, i32 %old_val, i32 %new_val seq_cst seq_cst
%xtrc = extractvalue { i32, i1 } %xchg, 0
%icmp = icmp eq i32 %xtrc, %old_val
ret i1 %icmp
}
InstCombine: try to transform A-B < 0 into A < B We are allowed to move the 'B' to the right hand side if we an prove there is no signed overflow and if the comparison itself is signed. llvm-svn: 225034
2014-12-31 12:21:41 +08:00
define i1 @f1(i64 %a, i64 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f1(
; CHECK-NEXT: [[V:%.*]] = icmp sge i64 %a, %b
; CHECK-NEXT: ret i1 [[V]]
;
InstCombine: try to transform A-B < 0 into A < B We are allowed to move the 'B' to the right hand side if we an prove there is no signed overflow and if the comparison itself is signed. llvm-svn: 225034
2014-12-31 12:21:41 +08:00
%t = sub nsw i64 %a, %b
%v = icmp sge i64 %t, 0
ret i1 %v
}
define i1 @f2(i64 %a, i64 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f2(
; CHECK-NEXT: [[V:%.*]] = icmp sgt i64 %a, %b
; CHECK-NEXT: ret i1 [[V]]
;
InstCombine: try to transform A-B < 0 into A < B We are allowed to move the 'B' to the right hand side if we an prove there is no signed overflow and if the comparison itself is signed. llvm-svn: 225034
2014-12-31 12:21:41 +08:00
%t = sub nsw i64 %a, %b
%v = icmp sgt i64 %t, 0
ret i1 %v
}
define i1 @f3(i64 %a, i64 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f3(
; CHECK-NEXT: [[V:%.*]] = icmp slt i64 %a, %b
; CHECK-NEXT: ret i1 [[V]]
;
InstCombine: try to transform A-B < 0 into A < B We are allowed to move the 'B' to the right hand side if we an prove there is no signed overflow and if the comparison itself is signed. llvm-svn: 225034
2014-12-31 12:21:41 +08:00
%t = sub nsw i64 %a, %b
%v = icmp slt i64 %t, 0
ret i1 %v
}
define i1 @f4(i64 %a, i64 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f4(
; CHECK-NEXT: [[V:%.*]] = icmp sle i64 %a, %b
; CHECK-NEXT: ret i1 [[V]]
;
InstCombine: try to transform A-B < 0 into A < B We are allowed to move the 'B' to the right hand side if we an prove there is no signed overflow and if the comparison itself is signed. llvm-svn: 225034
2014-12-31 12:21:41 +08:00
%t = sub nsw i64 %a, %b
%v = icmp sle i64 %t, 0
ret i1 %v
}
InstCombine: Don't take A-B<0 into A<B if A-B has other uses This fixes PR22226. llvm-svn: 226023
2015-01-15 03:26:56 +08:00
define i32 @f5(i8 %a, i8 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f5(
; CHECK-NEXT: [[CONV:%.*]] = zext i8 %a to i32
; CHECK-NEXT: [[CONV3:%.*]] = zext i8 %b to i32
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i32 [[CONV]], [[CONV3]]
; CHECK-NEXT: [[CMP4:%.*]] = icmp slt i32 [[SUB]], 0
; CHECK-NEXT: [[SUB7:%.*]] = sub nsw i32 0, [[SUB]]
; CHECK-NEXT: [[SUB7_SUB:%.*]] = select i1 [[CMP4]], i32 [[SUB7]], i32 [[SUB]]
; CHECK-NEXT: ret i32 [[SUB7_SUB]]
;
InstCombine: Don't take A-B<0 into A<B if A-B has other uses This fixes PR22226. llvm-svn: 226023
2015-01-15 03:26:56 +08:00
%conv = zext i8 %a to i32
%conv3 = zext i8 %b to i32
%sub = sub nsw i32 %conv, %conv3
%cmp4 = icmp slt i32 %sub, 0
%sub7 = sub nsw i32 0, %sub
%sub7.sub = select i1 %cmp4, i32 %sub7, i32 %sub
ret i32 %sub7.sub
}
InstCombine: fold (A << C) == (B << C) --> ((A^B) & (~0U >> C)) == 0 Anding and comparing with zero can be done in a single instruction on most archs so this is a bit cheaper. llvm-svn: 233291
2015-03-27 01:12:06 +08:00
define i32 @f6(i32 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f6(
; CHECK-NEXT: [[CMP_UNSHIFTED:%.*]] = xor i32 %a, %b
; CHECK-NEXT: [[CMP_MASK:%.*]] = and i32 [[CMP_UNSHIFTED]], 255
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[CMP:%.*]].mask, 0
; CHECK-NEXT: [[S:%.*]] = select i1 [[CMP]], i32 10000, i32 0
; CHECK-NEXT: ret i32 [[S]]
;
InstCombine: fold (A << C) == (B << C) --> ((A^B) & (~0U >> C)) == 0 Anding and comparing with zero can be done in a single instruction on most archs so this is a bit cheaper. llvm-svn: 233291
2015-03-27 01:12:06 +08:00
%sext = shl i32 %a, 24
%conv = ashr i32 %sext, 24
%sext6 = shl i32 %b, 24
%conv4 = ashr i32 %sext6, 24
%cmp = icmp eq i32 %conv, %conv4
%s = select i1 %cmp, i32 10000, i32 0
ret i32 %s
}
define i32 @f7(i32 %a, i32 %b) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f7(
; CHECK-NEXT: [[CMP_UNSHIFTED:%.*]] = xor i32 %a, %b
; CHECK-NEXT: [[CMP_MASK:%.*]] = and i32 [[CMP_UNSHIFTED]], 511
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[CMP:%.*]].mask, 0
; CHECK-NEXT: [[S:%.*]] = select i1 [[CMP]], i32 10000, i32 0
; CHECK-NEXT: ret i32 [[S]]
;
InstCombine: fold (A << C) == (B << C) --> ((A^B) & (~0U >> C)) == 0 Anding and comparing with zero can be done in a single instruction on most archs so this is a bit cheaper. llvm-svn: 233291
2015-03-27 01:12:06 +08:00
%sext = shl i32 %a, 23
%sext6 = shl i32 %b, 23
%cmp = icmp ne i32 %sext, %sext6
%s = select i1 %cmp, i32 10000, i32 0
ret i32 %s
}
Re-apply r245635, "[InstCombine] Transform A & (L - 1) u< L --> L != 0" The original checkin was buggy, this change has a fix. Original commit message: [InstCombine] Transform A & (L - 1) u< L --> L != 0 Summary: This transform is never a pessimization at the IR level (since it replaces an `icmp` with another), and has potentiall payoffs: 1. It may make the `icmp` fold away or become loop invariant. 2. It may make the `A & (L - 1)` computation dead. This shows up in Java, in range checks generated by array accesses of the form `a[i & (a.length - 1)]`. Reviewers: reames, majnemer Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D12210 llvm-svn: 245753
2015-08-22 06:22:37 +08:00
define i1 @f8(i32 %val, i32 %lim) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f8(
; CHECK-NEXT: [[R:%.*]] = icmp ne i32 %lim, 0
; CHECK-NEXT: ret i1 [[R]]
;
Re-apply r245635, "[InstCombine] Transform A & (L - 1) u< L --> L != 0" The original checkin was buggy, this change has a fix. Original commit message: [InstCombine] Transform A & (L - 1) u< L --> L != 0 Summary: This transform is never a pessimization at the IR level (since it replaces an `icmp` with another), and has potentiall payoffs: 1. It may make the `icmp` fold away or become loop invariant. 2. It may make the `A & (L - 1)` computation dead. This shows up in Java, in range checks generated by array accesses of the form `a[i & (a.length - 1)]`. Reviewers: reames, majnemer Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D12210 llvm-svn: 245753
2015-08-22 06:22:37 +08:00
%lim.sub = add i32 %lim, -1
%val.and = and i32 %val, %lim.sub
%r = icmp ult i32 %val.and, %lim
ret i1 %r
}
define i1 @f9(i32 %val, i32 %lim) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f9(
; CHECK-NEXT: [[R:%.*]] = icmp ne i32 %lim, 0
; CHECK-NEXT: ret i1 [[R]]
;
Re-apply r245635, "[InstCombine] Transform A & (L - 1) u< L --> L != 0" The original checkin was buggy, this change has a fix. Original commit message: [InstCombine] Transform A & (L - 1) u< L --> L != 0 Summary: This transform is never a pessimization at the IR level (since it replaces an `icmp` with another), and has potentiall payoffs: 1. It may make the `icmp` fold away or become loop invariant. 2. It may make the `A & (L - 1)` computation dead. This shows up in Java, in range checks generated by array accesses of the form `a[i & (a.length - 1)]`. Reviewers: reames, majnemer Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D12210 llvm-svn: 245753
2015-08-22 06:22:37 +08:00
%lim.sub = sub i32 %lim, 1
%val.and = and i32 %val, %lim.sub
%r = icmp ult i32 %val.and, %lim
ret i1 %r
}
[InstCombine] Don't assume m_Mul gives back an Instruction This fixes PR24713. llvm-svn: 246933
2015-09-06 04:44:56 +08:00
define i1 @f10(i16 %p) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @f10(
; CHECK-NEXT: [[CMP580:%.*]] = icmp uge i16 %p, mul (i16 zext (i8 ptrtoint (i1 (i16)* @f10 to i8) to i16), i16 zext (i8 ptrtoint (i1 (i16)* @f10 to i8) to i16))
; CHECK-NEXT: ret i1 [[CMP580]]
;
[InstCombine] Don't assume m_Mul gives back an Instruction This fixes PR24713. llvm-svn: 246933
2015-09-06 04:44:56 +08:00
%cmp580 = icmp ule i16 mul (i16 zext (i8 ptrtoint (i1 (i16)* @f10 to i8) to i16), i16 zext (i8 ptrtoint (i1 (i16)* @f10 to i8) to i16)), %p
ret i1 %cmp580
}
[InstCombine] Optimize icmp of inc/dec at RHS Allow LLVM to optimize the sequence like the following: %inc = add nsw i32 %i, 1 %cmp = icmp slt %n, %inc into: %cmp = icmp sle i32 %n, %i The case is not handled previously due to the complexity of compuation of %n. Hence, LLVM cannot swap operands of icmp accordingly. llvm-svn: 250746
2015-10-20 06:08:14 +08:00
define i1 @cmp_sgt_rhs_dec(float %x, i32 %i) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @cmp_sgt_rhs_dec(
; CHECK-NEXT: [[CONV:%.*]] = fptosi float %x to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[CONV]], %i
; CHECK-NEXT: ret i1 [[CMP]]
;
[InstCombine] Optimize icmp of inc/dec at RHS Allow LLVM to optimize the sequence like the following: %inc = add nsw i32 %i, 1 %cmp = icmp slt %n, %inc into: %cmp = icmp sle i32 %n, %i The case is not handled previously due to the complexity of compuation of %n. Hence, LLVM cannot swap operands of icmp accordingly. llvm-svn: 250746
2015-10-20 06:08:14 +08:00
%conv = fptosi float %x to i32
%dec = sub nsw i32 %i, 1
%cmp = icmp sgt i32 %conv, %dec
ret i1 %cmp
}
define i1 @cmp_sle_rhs_dec(float %x, i32 %i) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @cmp_sle_rhs_dec(
; CHECK-NEXT: [[CONV:%.*]] = fptosi float %x to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[CONV]], %i
; CHECK-NEXT: ret i1 [[CMP]]
;
[InstCombine] Optimize icmp of inc/dec at RHS Allow LLVM to optimize the sequence like the following: %inc = add nsw i32 %i, 1 %cmp = icmp slt %n, %inc into: %cmp = icmp sle i32 %n, %i The case is not handled previously due to the complexity of compuation of %n. Hence, LLVM cannot swap operands of icmp accordingly. llvm-svn: 250746
2015-10-20 06:08:14 +08:00
%conv = fptosi float %x to i32
%dec = sub nsw i32 %i, 1
%cmp = icmp sle i32 %conv, %dec
ret i1 %cmp
}
define i1 @cmp_sge_rhs_inc(float %x, i32 %i) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @cmp_sge_rhs_inc(
; CHECK-NEXT: [[CONV:%.*]] = fptosi float %x to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[CONV]], %i
; CHECK-NEXT: ret i1 [[CMP]]
;
[InstCombine] Optimize icmp of inc/dec at RHS Allow LLVM to optimize the sequence like the following: %inc = add nsw i32 %i, 1 %cmp = icmp slt %n, %inc into: %cmp = icmp sle i32 %n, %i The case is not handled previously due to the complexity of compuation of %n. Hence, LLVM cannot swap operands of icmp accordingly. llvm-svn: 250746
2015-10-20 06:08:14 +08:00
%conv = fptosi float %x to i32
%inc = add nsw i32 %i, 1
%cmp = icmp sge i32 %conv, %inc
ret i1 %cmp
}
define i1 @cmp_slt_rhs_inc(float %x, i32 %i) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @cmp_slt_rhs_inc(
; CHECK-NEXT: [[CONV:%.*]] = fptosi float %x to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i32 [[CONV]], %i
; CHECK-NEXT: ret i1 [[CMP]]
;
[InstCombine] Optimize icmp of inc/dec at RHS Allow LLVM to optimize the sequence like the following: %inc = add nsw i32 %i, 1 %cmp = icmp slt %n, %inc into: %cmp = icmp sle i32 %n, %i The case is not handled previously due to the complexity of compuation of %n. Hence, LLVM cannot swap operands of icmp accordingly. llvm-svn: 250746
2015-10-20 06:08:14 +08:00
%conv = fptosi float %x to i32
%inc = add nsw i32 %i, 1
%cmp = icmp slt i32 %conv, %inc
ret i1 %cmp
}
[InstCombine] Don't transform (X+INT_MAX)>=(Y+INT_MAX) -> (X<=Y) This miscompile came about because we tried to use a transform which was only appropriate for xor operators when addition was present. This fixes PR26407. llvm-svn: 259375
2016-02-02 01:37:56 +08:00
define i1 @PR26407(i32 %x, i32 %y) {
regenerate checks llvm-svn: 265591
2016-04-07 03:58:06 +08:00
; CHECK-LABEL: @PR26407(
; CHECK-NEXT: [[ADDX:%.*]] = add i32 %x, 2147483647
; CHECK-NEXT: [[ADDY:%.*]] = add i32 %y, 2147483647
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i32 [[ADDX]], [[ADDY]]
; CHECK-NEXT: ret i1 [[CMP]]
;
[InstCombine] Don't transform (X+INT_MAX)>=(Y+INT_MAX) -> (X<=Y) This miscompile came about because we tried to use a transform which was only appropriate for xor operators when addition was present. This fixes PR26407. llvm-svn: 259375
2016-02-02 01:37:56 +08:00
%addx = add i32 %x, 2147483647
%addy = add i32 %y, 2147483647
%cmp = icmp uge i32 %addx, %addy
ret i1 %cmp
}
[InstCombine] remove constant by inverting compare + logic (PR27105) https://llvm.org/bugs/show_bug.cgi?id=27105 We can check if all bits outside of a constant mask are set with a single constant. As noted in the bug report, although this form should be considered the canonical IR, backends may want to transform this into an 'andn' / 'andc' comparison against zero because that could be a single machine instruction. Differential Revision: http://reviews.llvm.org/D18842 llvm-svn: 266362
2016-04-15 04:17:40 +08:00
define i1 @cmp_inverse_mask_bits_set_eq(i32 %x) {
; CHECK-LABEL: @cmp_inverse_mask_bits_set_eq(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 %x, -43
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP1]], -43
; CHECK-NEXT: ret i1 [[CMP]]
;
%or = or i32 %x, 42
%cmp = icmp eq i32 %or, -1
ret i1 %cmp
}
add tests for icmp vector folds llvm-svn: 276476
2016-07-23 05:28:20 +08:00
define <2 x i1> @cmp_inverse_mask_bits_set_eq_vec(<2 x i32> %x) {
; CHECK-LABEL: @cmp_inverse_mask_bits_set_eq_vec(
[InstCombine] use m_APInt to allow icmp eq (or X, C1), C2 folds for splat constant vectors llvm-svn: 277752
2016-08-05 03:12:12 +08:00
; CHECK-NEXT: [[TMP1:%.*]] = and <2 x i32> %x, <i32 -43, i32 -43>
; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> [[TMP1]], <i32 -43, i32 -43>
add tests for icmp vector folds llvm-svn: 276476
2016-07-23 05:28:20 +08:00
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%or = or <2 x i32> %x, <i32 42, i32 42>
%cmp = icmp eq <2 x i32> %or, <i32 -1, i32 -1>
ret <2 x i1> %cmp
}
[InstCombine] remove constant by inverting compare + logic (PR27105) https://llvm.org/bugs/show_bug.cgi?id=27105 We can check if all bits outside of a constant mask are set with a single constant. As noted in the bug report, although this form should be considered the canonical IR, backends may want to transform this into an 'andn' / 'andc' comparison against zero because that could be a single machine instruction. Differential Revision: http://reviews.llvm.org/D18842 llvm-svn: 266362
2016-04-15 04:17:40 +08:00
define i1 @cmp_inverse_mask_bits_set_ne(i32 %x) {
; CHECK-LABEL: @cmp_inverse_mask_bits_set_ne(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 %x, -43
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[TMP1]], -43
; CHECK-NEXT: ret i1 [[CMP]]
;
%or = or i32 %x, 42
%cmp = icmp ne i32 %or, -1
ret i1 %cmp
}
"Reapply r268521 "[InstCombine] Canonicalize icmp instructions based on dominating conditions."" This reapplies commit r268521, that was reverted in r268530 due to a test failure in select-implied.ll Modified the test case to reflect the new change. llvm-svn: 268557
2016-05-05 05:32:14 +08:00
; CHECK-LABEL: @idom_sign_bit_check_edge_dominates
define void @idom_sign_bit_check_edge_dominates(i64 %a) {
entry:
%cmp = icmp slt i64 %a, 0
br i1 %cmp, label %land.lhs.true, label %lor.rhs
land.lhs.true: ; preds = %entry
br label %lor.end
; CHECK-LABEL: lor.rhs:
; CHECK-NOT: icmp sgt i64 %a, 0
; CHECK: icmp eq i64 %a, 0
lor.rhs: ; preds = %entry
%cmp2 = icmp sgt i64 %a, 0
br i1 %cmp2, label %land.rhs, label %lor.end
land.rhs: ; preds = %lor.rhs
br label %lor.end
lor.end: ; preds = %land.rhs, %lor.rhs, %land.lhs.true
ret void
}
; CHECK-LABEL: @idom_sign_bit_check_edge_not_dominates
define void @idom_sign_bit_check_edge_not_dominates(i64 %a) {
entry:
%cmp = icmp slt i64 %a, 0
br i1 %cmp, label %land.lhs.true, label %lor.rhs
land.lhs.true: ; preds = %entry
br i1 undef, label %lor.end, label %lor.rhs
; CHECK-LABEL: lor.rhs:
; CHECK: icmp sgt i64 %a, 0
; CHECK-NOT: icmp eq i64 %a, 0
lor.rhs: ; preds = %land.lhs.true, %entry
%cmp2 = icmp sgt i64 %a, 0
br i1 %cmp2, label %land.rhs, label %lor.end
land.rhs: ; preds = %lor.rhs
br label %lor.end
lor.end: ; preds = %land.rhs, %lor.rhs, %land.lhs.true
ret void
}
; CHECK-LABEL: @idom_sign_bit_check_edge_dominates_select
define void @idom_sign_bit_check_edge_dominates_select(i64 %a, i64 %b) {
entry:
%cmp = icmp slt i64 %a, 5
br i1 %cmp, label %land.lhs.true, label %lor.rhs
land.lhs.true: ; preds = %entry
br label %lor.end
; CHECK-LABEL: lor.rhs:
; CHECK-NOT: [[B:%.*]] = icmp sgt i64 %a, 5
; CHECK: [[C:%.*]] = icmp eq i64 %a, %b
; CHECK-NOT: [[D:%.*]] = select i1 [[B]], i64 %a, i64 5
; CHECK-NOT: icmp ne i64 [[D]], %b
; CHECK-NEXT: br i1 [[C]], label %lor.end, label %land.rhs
lor.rhs: ; preds = %entry
%cmp2 = icmp sgt i64 %a, 5
%select = select i1 %cmp2, i64 %a, i64 5
%cmp3 = icmp ne i64 %select, %b
br i1 %cmp3, label %land.rhs, label %lor.end
land.rhs: ; preds = %lor.rhs
br label %lor.end
lor.end: ; preds = %land.rhs, %lor.rhs, %land.lhs.true
ret void
}
; CHECK-LABEL: @idom_zbranch
define void @idom_zbranch(i64 %a) {
entry:
%cmp = icmp sgt i64 %a, 0
br i1 %cmp, label %lor.end, label %lor.rhs
; CHECK-LABEL: lor.rhs:
; CHECK: icmp slt i64 %a, 0
; CHECK-NOT: icmp eq i64 %a, 0
lor.rhs: ; preds = %entry
%cmp2 = icmp slt i64 %a, 0
br i1 %cmp2, label %land.rhs, label %lor.end
land.rhs: ; preds = %lor.rhs
br label %lor.end
lor.end: ; preds = %land.rhs, %lor.rhs
ret void
}
; CHECK-LABEL: @idom_not_zbranch
define void @idom_not_zbranch(i32 %a, i32 %b) {
entry:
%cmp = icmp sgt i32 %a, 0
br i1 %cmp, label %return, label %if.end
; CHECK-LABEL: if.end:
; CHECK-NOT: [[B:%.*]] = icmp slt i32 %a, 0
; CHECK: [[C:%.*]] = icmp eq i32 %a, %b
; CHECK-NOT: [[D:%.*]] = select i1 [[B]], i32 %a, i32 0
; CHECK-NOT: icmp ne i32 [[D]], %b
; CHECK-NEXT: br i1 [[C]], label %return, label %if.then3
if.end: ; preds = %entry
%cmp1 = icmp slt i32 %a, 0
%a. = select i1 %cmp1, i32 %a, i32 0
%cmp2 = icmp ne i32 %a., %b
br i1 %cmp2, label %if.then3, label %return
if.then3: ; preds = %if.end
br label %return
return: ; preds = %if.end, %entry, %if.then3
ret void
}
[InstCombine] add test for wrong icmp constant (PR27792) The code fix for this was checked in at r269797. llvm-svn: 269803
2016-05-18 03:25:55 +08:00
[InstCombine] add another test for wrong icmp constant (PR27792) It doesn't matter if the comparison is unsigned; the inc/dec is always signed. llvm-svn: 269831
2016-05-18 04:20:40 +08:00
; When canonicalizing to 'gt/lt', make sure the constant is correct.
[InstCombine] add test for wrong icmp constant (PR27792) The code fix for this was checked in at r269797. llvm-svn: 269803
2016-05-18 03:25:55 +08:00
define i1 @PR27792(i128 %a) {
; CHECK-LABEL: @PR27792(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i128 %a, -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%cmp = icmp sge i128 %a, 0
ret i1 %cmp
}
[InstCombine] add another test for wrong icmp constant (PR27792) It doesn't matter if the comparison is unsigned; the inc/dec is always signed. llvm-svn: 269831
2016-05-18 04:20:40 +08:00
define i1 @PR27792_2(i128 %a) {
; CHECK-LABEL: @PR27792_2(
; CHECK-NEXT: [[B:%.*]] = icmp ne i128 %a, 0
; CHECK-NEXT: ret i1 [[B]]
;
%b = icmp uge i128 %a, 1
ret i1 %b
}