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/intrinsics.ll

515 lines
16 KiB
LLVM
Raw Normal View History

Tests: rewrite 'opt ... %s' to 'opt ... < %s' so that opt does not emit a ModuleID This is done to avoid odd test failures, like the one fixed in r171243. My previous regex was not good enough to find these. llvm-svn: 171343
2013-01-01 21:57:25 +08:00
; RUN: opt -instcombine -S < %s | FileCheck %s
if a 'with overflow' intrinsic just has the normal result used, simplify it to a normal binop. Patch by Alastair Lynn, testcase by me. llvm-svn: 86524
2009-11-09 15:07:56 +08:00
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%overflow.result = type {i8, i1}
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
%ov.result.32 = type { i32, i1 }
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
declare %overflow.result @llvm.uadd.with.overflow.i8(i8, i8) nounwind readnone
declare %overflow.result @llvm.umul.with.overflow.i8(i8, i8) nounwind readnone
declare %ov.result.32 @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone
declare %ov.result.32 @llvm.uadd.with.overflow.i32(i32, i32) nounwind readnone
declare %ov.result.32 @llvm.ssub.with.overflow.i32(i32, i32) nounwind readnone
declare %ov.result.32 @llvm.usub.with.overflow.i32(i32, i32) nounwind readnone
declare %ov.result.32 @llvm.smul.with.overflow.i32(i32, i32) nounwind readnone
declare %ov.result.32 @llvm.umul.with.overflow.i32(i32, i32) nounwind readnone
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
declare double @llvm.powi.f64(double, i32) nounwind readonly
Manually upgrade the test suite to specify the flag to cttz and ctlz. I followed three heuristics for deciding whether to set 'true' or 'false': - Everything target independent got 'true' as that is the expected common output of the GCC builtins. - If the target arch only has one way of implementing this operation, set the flag in the way that exercises the most of codegen. For most architectures this is also the likely path from a GCC builtin, with 'true' being set. It will (eventually) require lowering away that difference, and then lowering to the architecture's operation. - Otherwise, set the flag differently dependending on which target operation should be tested. Let me know if anyone has any issue with this pattern or would like specific tests of another form. This should allow the x86 codegen to just iteratively improve as I teach the backend how to differentiate between the two forms, and everything else should remain exactly the same. llvm-svn: 146370
2011-12-12 19:59:10 +08:00
declare i32 @llvm.cttz.i32(i32, i1) nounwind readnone
declare i32 @llvm.ctlz.i32(i32, i1) nounwind readnone
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
declare i32 @llvm.ctpop.i32(i32) nounwind readnone
Manually upgrade the test suite to specify the flag to cttz and ctlz. I followed three heuristics for deciding whether to set 'true' or 'false': - Everything target independent got 'true' as that is the expected common output of the GCC builtins. - If the target arch only has one way of implementing this operation, set the flag in the way that exercises the most of codegen. For most architectures this is also the likely path from a GCC builtin, with 'true' being set. It will (eventually) require lowering away that difference, and then lowering to the architecture's operation. - Otherwise, set the flag differently dependending on which target operation should be tested. Let me know if anyone has any issue with this pattern or would like specific tests of another form. This should allow the x86 codegen to just iteratively improve as I teach the backend how to differentiate between the two forms, and everything else should remain exactly the same. llvm-svn: 146370
2011-12-12 19:59:10 +08:00
declare i8 @llvm.ctlz.i8(i8, i1) nounwind readnone
Allow constfolding of llvm.sin.* and llvm.cos.* intrinsics This patch const folds llvm.sin.* and llvm.cos.* intrinsics whenever feasible. Differential Revision: http://reviews.llvm.org/D10836 llvm-svn: 241665
2015-07-08 11:55:47 +08:00
declare double @llvm.cos.f64(double %Val) nounwind readonly
declare double @llvm.sin.f64(double %Val) nounwind readonly
Constfold trunc,rint,nearbyint,ceil and floor using APFloat A patch by Chakshu Grover! This patch allows constfolding of trunc,rint,nearbyint,ceil and floor intrinsics using APFloat class. Differential Revision: http://reviews.llvm.org/D11144 llvm-svn: 242763
2015-07-21 16:52:23 +08:00
declare double @llvm.floor.f64(double %Val) nounwind readonly
declare double @llvm.ceil.f64(double %Val) nounwind readonly
declare double @llvm.trunc.f64(double %Val) nounwind readonly
declare double @llvm.rint.f64(double %Val) nounwind readonly
declare double @llvm.nearbyint.f64(double %Val) nounwind readonly
if a 'with overflow' intrinsic just has the normal result used, simplify it to a normal binop. Patch by Alastair Lynn, testcase by me. llvm-svn: 86524
2009-11-09 15:07:56 +08:00
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @uaddtest1(i8 %A, i8 %B) {
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 %B)
%y = extractvalue %overflow.result %x, 0
if a 'with overflow' intrinsic just has the normal result used, simplify it to a normal binop. Patch by Alastair Lynn, testcase by me. llvm-svn: 86524
2009-11-09 15:07:56 +08:00
ret 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: @uaddtest1(
if a 'with overflow' intrinsic just has the normal result used, simplify it to a normal binop. Patch by Alastair Lynn, testcase by me. llvm-svn: 86524
2009-11-09 15:07:56 +08:00
; CHECK-NEXT: %y = add i8 %A, %B
; CHECK-NEXT: ret i8 %y
}
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @uaddtest2(i8 %A, i8 %B, i1* %overflowPtr) {
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%and.A = and i8 %A, 127
%and.B = and i8 %B, 127
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %and.A, i8 %and.B)
%y = extractvalue %overflow.result %x, 0
%z = extractvalue %overflow.result %x, 1
store i1 %z, i1* %overflowPtr
ret 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: @uaddtest2(
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: %and.A = and i8 %A, 127
; CHECK-NEXT: %and.B = and i8 %B, 127
More instcombine cleanup aimed towards improving debug line info. llvm-svn: 131559
2011-05-19 03:57:14 +08:00
; CHECK-NEXT: %x = add nuw i8 %and.A, %and.B
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: store i1 false, i1* %overflowPtr
More instcombine cleanup aimed towards improving debug line info. llvm-svn: 131559
2011-05-19 03:57:14 +08:00
; CHECK-NEXT: ret i8 %x
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
}
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @uaddtest3(i8 %A, i8 %B, i1* %overflowPtr) {
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%or.A = or i8 %A, -128
%or.B = or i8 %B, -128
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %or.A, i8 %or.B)
%y = extractvalue %overflow.result %x, 0
%z = extractvalue %overflow.result %x, 1
store i1 %z, i1* %overflowPtr
ret 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: @uaddtest3(
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: %or.A = or i8 %A, -128
; CHECK-NEXT: %or.B = or i8 %B, -128
More instcombine cleanup aimed towards improving debug line info. llvm-svn: 131559
2011-05-19 03:57:14 +08:00
; CHECK-NEXT: %x = add i8 %or.A, %or.B
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: store i1 true, i1* %overflowPtr
More instcombine cleanup aimed towards improving debug line info. llvm-svn: 131559
2011-05-19 03:57:14 +08:00
; CHECK-NEXT: ret i8 %x
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
}
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @uaddtest4(i8 %A, i1* %overflowPtr) {
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 undef, i8 %A)
%y = extractvalue %overflow.result %x, 0
%z = extractvalue %overflow.result %x, 1
store i1 %z, i1* %overflowPtr
ret 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: @uaddtest4(
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: ret i8 undef
}
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @uaddtest5(i8 %A, i1* %overflowPtr) {
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 0, i8 %A)
%y = extractvalue %overflow.result %x, 0
%z = extractvalue %overflow.result %x, 1
store i1 %z, i1* %overflowPtr
ret 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: @uaddtest5(
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
; CHECK: ret i8 %A
}
optimize uadd(x, cst) into a comparison when the normal result is dead. This is required for my next patch to not regress the testsuite. llvm-svn: 122181
2010-12-20 03:35:32 +08:00
define i1 @uaddtest6(i8 %A, i8 %B) {
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 -4)
%z = extractvalue %overflow.result %x, 1
ret i1 %z
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: @uaddtest6(
optimize uadd(x, cst) into a comparison when the normal result is dead. This is required for my next patch to not regress the testsuite. llvm-svn: 122181
2010-12-20 03:35:32 +08:00
; CHECK-NEXT: %z = icmp ugt i8 %A, 3
; CHECK-NEXT: ret i1 %z
}
X86 supports i8/i16 overflow ops (except i8 multiplies), we should generate them. Now we compile: define zeroext i8 @X(i8 signext %a, i8 signext %b) nounwind ssp { entry: %0 = tail call %0 @llvm.sadd.with.overflow.i8(i8 %a, i8 %b) %cmp = extractvalue %0 %0, 1 br i1 %cmp, label %if.then, label %if.end into: _X: ## @X ## BB#0: ## %entry subl $12, %esp movb 16(%esp), %al addb 20(%esp), %al jo LBB0_2 Before we were generating: _X: ## @X ## BB#0: ## %entry pushl %ebp movl %esp, %ebp subl $8, %esp movb 12(%ebp), %al testb %al, %al setge %cl movb 8(%ebp), %dl testb %dl, %dl setge %ah cmpb %cl, %ah sete %cl addb %al, %dl testb %dl, %dl setge %al cmpb %al, %ah setne %al andb %cl, %al testb %al, %al jne LBB0_2 llvm-svn: 122186
2010-12-20 04:03:11 +08:00
define i8 @uaddtest7(i8 %A, i8 %B) {
%x = call %overflow.result @llvm.uadd.with.overflow.i8(i8 %A, i8 %B)
%z = extractvalue %overflow.result %x, 0
ret i8 %z
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: @uaddtest7(
X86 supports i8/i16 overflow ops (except i8 multiplies), we should generate them. Now we compile: define zeroext i8 @X(i8 signext %a, i8 signext %b) nounwind ssp { entry: %0 = tail call %0 @llvm.sadd.with.overflow.i8(i8 %a, i8 %b) %cmp = extractvalue %0 %0, 1 br i1 %cmp, label %if.then, label %if.end into: _X: ## @X ## BB#0: ## %entry subl $12, %esp movb 16(%esp), %al addb 20(%esp), %al jo LBB0_2 Before we were generating: _X: ## @X ## BB#0: ## %entry pushl %ebp movl %esp, %ebp subl $8, %esp movb 12(%ebp), %al testb %al, %al setge %cl movb 8(%ebp), %dl testb %dl, %dl setge %ah cmpb %cl, %ah sete %cl addb %al, %dl testb %dl, %dl setge %al cmpb %al, %ah setne %al andb %cl, %al testb %al, %al jne LBB0_2 llvm-svn: 122186
2010-12-20 04:03:11 +08:00
; CHECK-NEXT: %z = add i8 %A, %B
; CHECK-NEXT: ret i8 %z
}
InstCombine: Strength reduce sadd.with.overflow into a regular nsw add if we can prove that it cannot overflow. PR20194 llvm-svn: 212331
2014-07-04 18:22:21 +08:00
; PR20194
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
define %ov.result.32 @saddtest_nsw(i8 %a, i8 %b) {
InstCombine: Strength reduce sadd.with.overflow into a regular nsw add if we can prove that it cannot overflow. PR20194 llvm-svn: 212331
2014-07-04 18:22:21 +08:00
%A = sext i8 %a to i32
%B = sext i8 %b to i32
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
%x = call %ov.result.32 @llvm.sadd.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @saddtest_nsw
InstCombine: Strength reduce sadd.with.overflow into a regular nsw add if we can prove that it cannot overflow. PR20194 llvm-svn: 212331
2014-07-04 18:22:21 +08:00
; CHECK: %x = add nsw i32 %A, %B
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
InstCombine: Strength reduce sadd.with.overflow into a regular nsw add if we can prove that it cannot overflow. PR20194 llvm-svn: 212331
2014-07-04 18:22:21 +08:00
}
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
define %ov.result.32 @uaddtest_nuw(i32 %a, i32 %b) {
%A = and i32 %a, 2147483647
%B = and i32 %b, 2147483647
%x = call %ov.result.32 @llvm.uadd.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @uaddtest_nuw
; CHECK: %x = add nuw i32 %A, %B
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
define %ov.result.32 @ssubtest_nsw(i8 %a, i8 %b) {
%A = sext i8 %a to i32
%B = sext i8 %b to i32
%x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @ssubtest_nsw
; CHECK: %x = sub nsw i32 %A, %B
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
define %ov.result.32 @usubtest_nuw(i32 %a, i32 %b) {
%A = or i32 %a, 2147483648
%B = and i32 %b, 2147483647
%x = call %ov.result.32 @llvm.usub.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @usubtest_nuw
; CHECK: %x = sub nuw i32 %A, %B
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
define %ov.result.32 @smultest1_nsw(i32 %a, i32 %b) {
%A = and i32 %a, 4095 ; 0xfff
%B = and i32 %b, 524287; 0x7ffff
%x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @smultest1_nsw
InstCombine: Infer nuw for multiplies A multiply cannot unsigned wrap if there are bitwidth, or more, leading zero bits between the two operands. llvm-svn: 224849
2014-12-26 17:50:35 +08:00
; CHECK: %x = mul nuw nsw i32 %A, %B
Strength reduce intrinsics with overflow into regular arithmetic operations if possible. Some intrinsics, like s/uadd.with.overflow and umul.with.overflow, are already strength reduced. This change adds other arithmetic intrinsics: s/usub.with.overflow, smul.with.overflow. It completes the work on PR20194. llvm-svn: 224417
2014-12-17 15:29:19 +08:00
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
define %ov.result.32 @smultest2_nsw(i32 %a, i32 %b) {
%A = ashr i32 %a, 16
%B = ashr i32 %b, 16
%x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @smultest2_nsw
; CHECK: %x = mul nsw i32 %A, %B
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
define %ov.result.32 @smultest3_sw(i32 %a, i32 %b) {
%A = ashr i32 %a, 16
%B = ashr i32 %b, 15
%x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @smultest3_sw
; CHECK: %x = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %A, i32 %B)
; CHECK-NEXT: ret %ov.result.32 %x
}
define %ov.result.32 @umultest_nuw(i32 %a, i32 %b) {
%A = and i32 %a, 65535 ; 0xffff
%B = and i32 %b, 65535 ; 0xffff
%x = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %A, i32 %B)
ret %ov.result.32 %x
; CHECK-LABEL: @umultest_nuw
; CHECK: %x = mul nuw i32 %A, %B
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
optimize uadd(x, cst) into a comparison when the normal result is dead. This is required for my next patch to not regress the testsuite. llvm-svn: 122181
2010-12-20 03:35:32 +08:00
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @umultest1(i8 %A, i1* %overflowPtr) {
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%x = call %overflow.result @llvm.umul.with.overflow.i8(i8 0, i8 %A)
%y = extractvalue %overflow.result %x, 0
%z = extractvalue %overflow.result %x, 1
store i1 %z, i1* %overflowPtr
ret 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: @umultest1(
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: store i1 false, i1* %overflowPtr
; CHECK-NEXT: ret i8 0
}
PR7853: fix a silly mistake introduced in r101899, and add a test to make sure it doesn't regress again. llvm-svn: 110597
2010-08-10 04:49:43 +08:00
define i8 @umultest2(i8 %A, i1* %overflowPtr) {
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
%x = call %overflow.result @llvm.umul.with.overflow.i8(i8 1, i8 %A)
%y = extractvalue %overflow.result %x, 0
%z = extractvalue %overflow.result %x, 1
store i1 %z, i1* %overflowPtr
ret 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: @umultest2(
add testcases for the foo_with_overflow op xforms added recently and fix bugs exposed by the tests. Testcases from Alastair Lynn! llvm-svn: 90056
2009-11-29 10:57:29 +08:00
; CHECK-NEXT: store i1 false, i1* %overflowPtr
; CHECK-NEXT: ret i8 %A
}
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
InstCombine: Turn umul_with_overflow into mul nuw if we can prove that it cannot overflow. This happens a lot in clang-compiled C++ code because it adds overflow checks to operator new[]: unsigned *foo(unsigned n) { return new unsigned[n]; } We can optimize away the overflow check on 64 bit targets because (uint64_t)n*4 cannot overflow. llvm-svn: 127418
2011-03-11 02:40:14 +08:00
define i32 @umultest3(i32 %n) nounwind {
%shr = lshr i32 %n, 2
%mul = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %shr, i32 3)
%ov = extractvalue %ov.result.32 %mul, 1
%res = extractvalue %ov.result.32 %mul, 0
%ret = select i1 %ov, i32 -1, i32 %res
ret i32 %ret
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: @umultest3(
InstCombine: Turn umul_with_overflow into mul nuw if we can prove that it cannot overflow. This happens a lot in clang-compiled C++ code because it adds overflow checks to operator new[]: unsigned *foo(unsigned n) { return new unsigned[n]; } We can optimize away the overflow check on 64 bit targets because (uint64_t)n*4 cannot overflow. llvm-svn: 127418
2011-03-11 02:40:14 +08:00
; CHECK-NEXT: shr
; CHECK-NEXT: mul nuw
; CHECK-NEXT: ret
}
define i32 @umultest4(i32 %n) nounwind {
%shr = lshr i32 %n, 1
%mul = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %shr, i32 4)
%ov = extractvalue %ov.result.32 %mul, 1
%res = extractvalue %ov.result.32 %mul, 0
%ret = select i1 %ov, i32 -1, i32 %res
ret i32 %ret
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: @umultest4(
InstCombine: Turn umul_with_overflow into mul nuw if we can prove that it cannot overflow. This happens a lot in clang-compiled C++ code because it adds overflow checks to operator new[]: unsigned *foo(unsigned n) { return new unsigned[n]; } We can optimize away the overflow check on 64 bit targets because (uint64_t)n*4 cannot overflow. llvm-svn: 127418
2011-03-11 02:40:14 +08:00
; CHECK: umul.with.overflow
}
InstCombine: Detect when llvm.umul.with.overflow always overflows We know overflow always occurs if both ~LHSKnownZero * ~RHSKnownZero and LHSKnownOne * RHSKnownOne overflow. llvm-svn: 225077
2015-01-02 15:29:47 +08:00
define %ov.result.32 @umultest5(i32 %x, i32 %y) nounwind {
%or_x = or i32 %x, 2147483648
%or_y = or i32 %y, 2147483648
%mul = call %ov.result.32 @llvm.umul.with.overflow.i32(i32 %or_x, i32 %or_y)
ret %ov.result.32 %mul
; CHECK-LABEL: @umultest5(
; CHECK-NEXT: %[[or_x:.*]] = or i32 %x, -2147483648
; CHECK-NEXT: %[[or_y:.*]] = or i32 %y, -2147483648
; CHECK-NEXT: %[[mul:.*]] = mul i32 %[[or_x]], %[[or_y]]
; CHECK-NEXT: %[[ret:.*]] = insertvalue %ov.result.32 { i32 undef, i1 true }, i32 %[[mul]], 0
; CHECK-NEXT: ret %ov.result.32 %[[ret]]
}
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
define void @powi(double %V, double *%P) {
entry:
%A = tail call double @llvm.powi.f64(double %V, i32 -1) nounwind
Upgrade syntax of tests using volatile instructions to use 'load volatile' instead of 'volatile load', which is archaic. llvm-svn: 145171
2011-11-27 14:54:59 +08:00
store volatile double %A, double* %P
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
%B = tail call double @llvm.powi.f64(double %V, i32 0) nounwind
Upgrade syntax of tests using volatile instructions to use 'load volatile' instead of 'volatile load', which is archaic. llvm-svn: 145171
2011-11-27 14:54:59 +08:00
store volatile double %B, double* %P
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
%C = tail call double @llvm.powi.f64(double %V, i32 1) nounwind
Upgrade syntax of tests using volatile instructions to use 'load volatile' instead of 'volatile load', which is archaic. llvm-svn: 145171
2011-11-27 14:54:59 +08:00
store volatile double %C, double* %P
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
ret void
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: @powi(
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
; CHECK: %A = fdiv double 1.0{{.*}}, %V
Revert "Have InstCombine call SipmlifyCall when handling calls. Test case included." This reverts commit 3854a5d90fee52af1065edbed34521fff6cdc18d. This causes a clang unit test to hang: vtable-available-externally.cpp. llvm-svn: 174692
2013-02-08 09:55:39 +08:00
; CHECK: store volatile double %A,
; CHECK: store volatile double 1.0
Move "atomic" and "volatile" designations on instructions after the opcode of the instruction. Note that this change affects the existing non-atomic load and store instructions; the parser now accepts both forms, and the change is noted in the release notes. llvm-svn: 137527
2011-08-13 06:50:01 +08:00
; CHECK: store volatile double %V
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
}
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
define i32 @cttz(i32 %a) {
optimize cttz and ctlz when we can prove something about the leading/trailing bits. Patch by Alastair Lynn! llvm-svn: 92706
2010-01-05 15:23:56 +08:00
entry:
%or = or i32 %a, 8
%and = and i32 %or, -8
Manually upgrade the test suite to specify the flag to cttz and ctlz. I followed three heuristics for deciding whether to set 'true' or 'false': - Everything target independent got 'true' as that is the expected common output of the GCC builtins. - If the target arch only has one way of implementing this operation, set the flag in the way that exercises the most of codegen. For most architectures this is also the likely path from a GCC builtin, with 'true' being set. It will (eventually) require lowering away that difference, and then lowering to the architecture's operation. - Otherwise, set the flag differently dependending on which target operation should be tested. Let me know if anyone has any issue with this pattern or would like specific tests of another form. This should allow the x86 codegen to just iteratively improve as I teach the backend how to differentiate between the two forms, and everything else should remain exactly the same. llvm-svn: 146370
2011-12-12 19:59:10 +08:00
%count = tail call i32 @llvm.cttz.i32(i32 %and, i1 true) nounwind readnone
optimize cttz and ctlz when we can prove something about the leading/trailing bits. Patch by Alastair Lynn! llvm-svn: 92706
2010-01-05 15:23:56 +08:00
ret i32 %count
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: @cttz(
optimize cttz and ctlz when we can prove something about the leading/trailing bits. Patch by Alastair Lynn! llvm-svn: 92706
2010-01-05 15:23:56 +08:00
; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 3
}
add a few trivial instcombines for llvm.powi. llvm-svn: 92383
2010-01-01 09:52:15 +08:00
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
define i8 @ctlz(i8 %a) {
optimize cttz and ctlz when we can prove something about the leading/trailing bits. Patch by Alastair Lynn! llvm-svn: 92706
2010-01-05 15:23:56 +08:00
entry:
%or = or i8 %a, 32
%and = and i8 %or, 63
Manually upgrade the test suite to specify the flag to cttz and ctlz. I followed three heuristics for deciding whether to set 'true' or 'false': - Everything target independent got 'true' as that is the expected common output of the GCC builtins. - If the target arch only has one way of implementing this operation, set the flag in the way that exercises the most of codegen. For most architectures this is also the likely path from a GCC builtin, with 'true' being set. It will (eventually) require lowering away that difference, and then lowering to the architecture's operation. - Otherwise, set the flag differently dependending on which target operation should be tested. Let me know if anyone has any issue with this pattern or would like specific tests of another form. This should allow the x86 codegen to just iteratively improve as I teach the backend how to differentiate between the two forms, and everything else should remain exactly the same. llvm-svn: 146370
2011-12-12 19:59:10 +08:00
%count = tail call i8 @llvm.ctlz.i8(i8 %and, i1 true) nounwind readnone
optimize cttz and ctlz when we can prove something about the leading/trailing bits. Patch by Alastair Lynn! llvm-svn: 92706
2010-01-05 15:23:56 +08:00
ret i8 %count
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: @ctlz(
optimize cttz and ctlz when we can prove something about the leading/trailing bits. Patch by Alastair Lynn! llvm-svn: 92706
2010-01-05 15:23:56 +08:00
; CHECK-NEXT: entry:
; CHECK-NEXT: ret i8 2
}
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
define void @cmp.simplify(i32 %a, i32 %b, i1* %c) {
entry:
ComputeMaskedBits: Make knownzero computation more aggressive for ctlz with undef zero. unsigned foo(unsigned x) { return 31 - __builtin_clz(x); } now compiles into a single "bsrl" instruction on x86. llvm-svn: 147255
2011-12-25 01:31:46 +08:00
%lz = tail call i32 @llvm.ctlz.i32(i32 %a, i1 false) nounwind readnone
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
%lz.cmp = icmp eq i32 %lz, 32
Upgrade syntax of tests using volatile instructions to use 'load volatile' instead of 'volatile load', which is archaic. llvm-svn: 145171
2011-11-27 14:54:59 +08:00
store volatile i1 %lz.cmp, i1* %c
ComputeMaskedBits: Make knownzero computation more aggressive for ctlz with undef zero. unsigned foo(unsigned x) { return 31 - __builtin_clz(x); } now compiles into a single "bsrl" instruction on x86. llvm-svn: 147255
2011-12-25 01:31:46 +08:00
%tz = tail call i32 @llvm.cttz.i32(i32 %a, i1 false) nounwind readnone
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
%tz.cmp = icmp ne i32 %tz, 32
Upgrade syntax of tests using volatile instructions to use 'load volatile' instead of 'volatile load', which is archaic. llvm-svn: 145171
2011-11-27 14:54:59 +08:00
store volatile i1 %tz.cmp, i1* %c
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
%pop = tail call i32 @llvm.ctpop.i32(i32 %b) nounwind readnone
%pop.cmp = icmp eq i32 %pop, 0
Upgrade syntax of tests using volatile instructions to use 'load volatile' instead of 'volatile load', which is archaic. llvm-svn: 145171
2011-11-27 14:54:59 +08:00
store volatile i1 %pop.cmp, i1* %c
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
ret void
; CHECK: @cmp.simplify
; CHECK-NEXT: entry:
; CHECK-NEXT: %lz.cmp = icmp eq i32 %a, 0
Move "atomic" and "volatile" designations on instructions after the opcode of the instruction. Note that this change affects the existing non-atomic load and store instructions; the parser now accepts both forms, and the change is noted in the release notes. llvm-svn: 137527
2011-08-13 06:50:01 +08:00
; CHECK-NEXT: store volatile i1 %lz.cmp, i1* %c
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
; CHECK-NEXT: %tz.cmp = icmp ne i32 %a, 0
Move "atomic" and "volatile" designations on instructions after the opcode of the instruction. Note that this change affects the existing non-atomic load and store instructions; the parser now accepts both forms, and the change is noted in the release notes. llvm-svn: 137527
2011-08-13 06:50:01 +08:00
; CHECK-NEXT: store volatile i1 %tz.cmp, i1* %c
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
; CHECK-NEXT: %pop.cmp = icmp eq i32 %b, 0
Move "atomic" and "volatile" designations on instructions after the opcode of the instruction. Note that this change affects the existing non-atomic load and store instructions; the parser now accepts both forms, and the change is noted in the release notes. llvm-svn: 137527
2011-08-13 06:50:01 +08:00
; CHECK-NEXT: store volatile i1 %pop.cmp, i1* %c
optimize comparisons against cttz/ctlz/ctpop, patch by Alastair Lynn! llvm-svn: 92745
2010-01-06 02:09:56 +08:00
}
implement a simple instcombine xform that has been in the readme forever. llvm-svn: 94318
2010-01-24 02:49:30 +08:00
Add an explicit test that we now fold cttz.i32(..., true) >> 5 -> 0. This is a result of Benjamin's work on ValueTracking. llvm-svn: 147259
2011-12-25 06:34:15 +08:00
define i32 @cttz_simplify1a(i32 %x) nounwind readnone ssp {
%tmp1 = tail call i32 @llvm.ctlz.i32(i32 %x, i1 false)
%shr3 = lshr i32 %tmp1, 5
implement a simple instcombine xform that has been in the readme forever. llvm-svn: 94318
2010-01-24 02:49:30 +08:00
ret i32 %shr3
Add an explicit test that we now fold cttz.i32(..., true) >> 5 -> 0. This is a result of Benjamin's work on ValueTracking. llvm-svn: 147259
2011-12-25 06:34:15 +08:00
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: @cttz_simplify1a(
implement a simple instcombine xform that has been in the readme forever. llvm-svn: 94318
2010-01-24 02:49:30 +08:00
; CHECK: icmp eq i32 %x, 0
Add an explicit test that we now fold cttz.i32(..., true) >> 5 -> 0. This is a result of Benjamin's work on ValueTracking. llvm-svn: 147259
2011-12-25 06:34:15 +08:00
; CHECK-NEXT: zext i1
implement a simple instcombine xform that has been in the readme forever. llvm-svn: 94318
2010-01-24 02:49:30 +08:00
; CHECK-NEXT: ret i32
}
Add an explicit test that we now fold cttz.i32(..., true) >> 5 -> 0. This is a result of Benjamin's work on ValueTracking. llvm-svn: 147259
2011-12-25 06:34:15 +08:00
define i32 @cttz_simplify1b(i32 %x) nounwind readnone ssp {
%tmp1 = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
%shr3 = lshr i32 %tmp1, 5
ret i32 %shr3
implement a simple instcombine xform that has been in the readme forever. llvm-svn: 94318
2010-01-24 02:49:30 +08:00
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: @cttz_simplify1b(
Add an explicit test that we now fold cttz.i32(..., true) >> 5 -> 0. This is a result of Benjamin's work on ValueTracking. llvm-svn: 147259
2011-12-25 06:34:15 +08:00
; CHECK-NEXT: ret i32 0
}
ConstantFolding: Add a missing folding that leads to a miscompile. We use constant folding to see if an intrinsic evaluates to the same value as a constant that we know. If we don't take the undefinedness into account we get a value that doesn't match the actual implementation, and miscompiled code. This was uncovered by Chandler's simplifycfg changes. llvm-svn: 173356
2013-01-25 00:28:28 +08:00
define i32 @ctlz_undef(i32 %Value) nounwind {
%ctlz = call i32 @llvm.ctlz.i32(i32 0, i1 true)
ret i32 %ctlz
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: @ctlz_undef(
ConstantFolding: Add a missing folding that leads to a miscompile. We use constant folding to see if an intrinsic evaluates to the same value as a constant that we know. If we don't take the undefinedness into account we get a value that doesn't match the actual implementation, and miscompiled code. This was uncovered by Chandler's simplifycfg changes. llvm-svn: 173356
2013-01-25 00:28:28 +08:00
; CHECK-NEXT: ret i32 undef
}
define i32 @cttz_undef(i32 %Value) nounwind {
%cttz = call i32 @llvm.cttz.i32(i32 0, i1 true)
ret i32 %cttz
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: @cttz_undef(
ConstantFolding: Add a missing folding that leads to a miscompile. We use constant folding to see if an intrinsic evaluates to the same value as a constant that we know. If we don't take the undefinedness into account we get a value that doesn't match the actual implementation, and miscompiled code. This was uncovered by Chandler's simplifycfg changes. llvm-svn: 173356
2013-01-25 00:28:28 +08:00
; CHECK-NEXT: ret i32 undef
}
define i32 @ctlz_select(i32 %Value) nounwind {
%tobool = icmp ne i32 %Value, 0
%ctlz = call i32 @llvm.ctlz.i32(i32 %Value, i1 true)
%s = select i1 %tobool, i32 %ctlz, i32 32
ret i32 %s
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: @ctlz_select(
[InstCombine] Teach how to fold a select into a cttz/ctlz with the 'is_zero_undef' flag. This patch teaches the Instruction Combiner how to fold a cttz/ctlz followed by a icmp plus select into a single cttz/ctlz with flag 'is_zero_undef' cleared. Added test InstCombine/select-cmp-cttz-ctlz.ll. llvm-svn: 227197
2015-01-27 23:58:14 +08:00
; CHECK-NEXT: call i32 @llvm.ctlz.i32(i32 %Value, i1 false)
; CHECK-NEXT: ret i32
ConstantFolding: Add a missing folding that leads to a miscompile. We use constant folding to see if an intrinsic evaluates to the same value as a constant that we know. If we don't take the undefinedness into account we get a value that doesn't match the actual implementation, and miscompiled code. This was uncovered by Chandler's simplifycfg changes. llvm-svn: 173356
2013-01-25 00:28:28 +08:00
}
define i32 @cttz_select(i32 %Value) nounwind {
%tobool = icmp ne i32 %Value, 0
%cttz = call i32 @llvm.cttz.i32(i32 %Value, i1 true)
%s = select i1 %tobool, i32 %cttz, i32 32
ret i32 %s
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: @cttz_select(
[InstCombine] Teach how to fold a select into a cttz/ctlz with the 'is_zero_undef' flag. This patch teaches the Instruction Combiner how to fold a cttz/ctlz followed by a icmp plus select into a single cttz/ctlz with flag 'is_zero_undef' cleared. Added test InstCombine/select-cmp-cttz-ctlz.ll. llvm-svn: 227197
2015-01-27 23:58:14 +08:00
; CHECK-NEXT: call i32 @llvm.cttz.i32(i32 %Value, i1 false)
; CHECK-NEXT: ret i32
ConstantFolding: Add a missing folding that leads to a miscompile. We use constant folding to see if an intrinsic evaluates to the same value as a constant that we know. If we don't take the undefinedness into account we get a value that doesn't match the actual implementation, and miscompiled code. This was uncovered by Chandler's simplifycfg changes. llvm-svn: 173356
2013-01-25 00:28:28 +08:00
}
Teach ComputeNumSignBits about signed divisions. http://reviews.llvm.org/D8028 rdar://20023136 llvm-svn: 231140
2015-03-04 05:39:02 +08:00
; CHECK-LABEL: @overflow_div_add(
; CHECK: ret i1 false
define i1 @overflow_div_add(i32 %v1, i32 %v2) nounwind {
entry:
%div = sdiv i32 %v1, 2
%t = call %ov.result.32 @llvm.sadd.with.overflow.i32(i32 %div, i32 1)
%obit = extractvalue %ov.result.32 %t, 1
ret i1 %obit
}
; CHECK-LABEL: @overflow_div_sub(
; CHECK: ret i1 false
define i1 @overflow_div_sub(i32 %v1, i32 %v2) nounwind {
entry:
; Check cases where the known sign bits are larger than the word size.
%a = ashr i32 %v1, 18
%div = sdiv i32 %a, 65536
%t = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %div, i32 1)
%obit = extractvalue %ov.result.32 %t, 1
ret i1 %obit
}
Teach ComputeNumSignBits about signed reminder. This optimization a continuation of r231140 that reasoned about signed div. llvm-svn: 231433
2015-03-06 08:23:58 +08:00
; CHECK-LABEL: @overflow_mod_mul(
; CHECK: ret i1 false
define i1 @overflow_mod_mul(i32 %v1, i32 %v2) nounwind {
entry:
%rem = srem i32 %v1, 1000
%t = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %rem, i32 %rem)
%obit = extractvalue %ov.result.32 %t, 1
ret i1 %obit
}
; CHECK-LABEL: @overflow_mod_overflow_mul(
; CHECK-NOT: ret i1 false
define i1 @overflow_mod_overflow_mul(i32 %v1, i32 %v2) nounwind {
entry:
%rem = srem i32 %v1, 65537
; This may overflow because the result of the mul operands may be greater than 16bits
; and the result greater than 32.
%t = call %ov.result.32 @llvm.smul.with.overflow.i32(i32 %rem, i32 %rem)
%obit = extractvalue %ov.result.32 %t, 1
ret i1 %obit
}
Subtraction is not commutative. Fixes PR23212! llvm-svn: 234780
2015-04-14 03:17:37 +08:00
define %ov.result.32 @ssubtest_reorder(i8 %a) {
%A = sext i8 %a to i32
%x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 0, i32 %A)
ret %ov.result.32 %x
; CHECK-LABEL: @ssubtest_reorder
; CHECK: %x = sub nsw i32 0, %A
; CHECK-NEXT: %1 = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %x, 0
; CHECK-NEXT: ret %ov.result.32 %1
}
[InstCombine] X - 0 is equal to X, not undef A refactoring made @llvm.ssub.with.overflow.i32(i32 %X, i32 0) transform into undef instead of %X. This fixes PR23624. llvm-svn: 237968
2015-05-22 07:04:21 +08:00
[InstSimplify] Handle some overflow intrinsics in InstSimplify This change does a few things: - Move some InstCombine transforms to InstSimplify - Run SimplifyCall from within InstCombine::visitCallInst - Teach InstSimplify to fold [us]mul_with_overflow(X, undef) to 0. llvm-svn: 237995
2015-05-22 11:56:46 +08:00
define %ov.result.32 @never_overflows_ssub_test0(i32 %a) {
[InstCombine] X - 0 is equal to X, not undef A refactoring made @llvm.ssub.with.overflow.i32(i32 %X, i32 0) transform into undef instead of %X. This fixes PR23624. llvm-svn: 237968
2015-05-22 07:04:21 +08:00
%x = call %ov.result.32 @llvm.ssub.with.overflow.i32(i32 %a, i32 0)
ret %ov.result.32 %x
[InstSimplify] Handle some overflow intrinsics in InstSimplify This change does a few things: - Move some InstCombine transforms to InstSimplify - Run SimplifyCall from within InstCombine::visitCallInst - Teach InstSimplify to fold [us]mul_with_overflow(X, undef) to 0. llvm-svn: 237995
2015-05-22 11:56:46 +08:00
; CHECK-LABEL: @never_overflows_ssub_test0
[InstCombine] X - 0 is equal to X, not undef A refactoring made @llvm.ssub.with.overflow.i32(i32 %X, i32 0) transform into undef instead of %X. This fixes PR23624. llvm-svn: 237968
2015-05-22 07:04:21 +08:00
; CHECK-NEXT: %[[x:.*]] = insertvalue %ov.result.32 { i32 undef, i1 false }, i32 %a, 0
; CHECK-NEXT: ret %ov.result.32 %[[x]]
}
Allow constfolding of llvm.sin.* and llvm.cos.* intrinsics This patch const folds llvm.sin.* and llvm.cos.* intrinsics whenever feasible. Differential Revision: http://reviews.llvm.org/D10836 llvm-svn: 241665
2015-07-08 11:55:47 +08:00
define void @cos(double *%P) {
entry:
%B = tail call double @llvm.cos.f64(double 0.0) nounwind
store volatile double %B, double* %P
ret void
; CHECK-LABEL: @cos(
; CHECK: store volatile double 1.000000e+00, double* %P
}
define void @sin(double *%P) {
entry:
%B = tail call double @llvm.sin.f64(double 0.0) nounwind
store volatile double %B, double* %P
ret void
; CHECK-LABEL: @sin(
; CHECK: store volatile double 0.000000e+00, double* %P
}
Constfold trunc,rint,nearbyint,ceil and floor using APFloat A patch by Chakshu Grover! This patch allows constfolding of trunc,rint,nearbyint,ceil and floor intrinsics using APFloat class. Differential Revision: http://reviews.llvm.org/D11144 llvm-svn: 242763
2015-07-21 16:52:23 +08:00
define void @floor(double *%P) {
entry:
%B = tail call double @llvm.floor.f64(double 1.5) nounwind
store volatile double %B, double* %P
%C = tail call double @llvm.floor.f64(double -1.5) nounwind
store volatile double %C, double* %P
ret void
; CHECK-LABEL: @floor(
; CHECK: store volatile double 1.000000e+00, double* %P, align 8
; CHECK: store volatile double -2.000000e+00, double* %P, align 8
}
define void @ceil(double *%P) {
entry:
%B = tail call double @llvm.ceil.f64(double 1.5) nounwind
store volatile double %B, double* %P
%C = tail call double @llvm.ceil.f64(double -1.5) nounwind
store volatile double %C, double* %P
ret void
; CHECK-LABEL: @ceil(
; CHECK: store volatile double 2.000000e+00, double* %P, align 8
; CHECK: store volatile double -1.000000e+00, double* %P, align 8
}
define void @trunc(double *%P) {
entry:
%B = tail call double @llvm.trunc.f64(double 1.5) nounwind
store volatile double %B, double* %P
%C = tail call double @llvm.trunc.f64(double -1.5) nounwind
store volatile double %C, double* %P
ret void
; CHECK-LABEL: @trunc(
; CHECK: store volatile double 1.000000e+00, double* %P, align 8
; CHECK: store volatile double -1.000000e+00, double* %P, align 8
}
define void @rint(double *%P) {
entry:
%B = tail call double @llvm.rint.f64(double 1.5) nounwind
store volatile double %B, double* %P
%C = tail call double @llvm.rint.f64(double -1.5) nounwind
store volatile double %C, double* %P
ret void
; CHECK-LABEL: @rint(
; CHECK: store volatile double 2.000000e+00, double* %P, align 8
; CHECK: store volatile double -2.000000e+00, double* %P, align 8
}
define void @nearbyint(double *%P) {
entry:
%B = tail call double @llvm.nearbyint.f64(double 1.5) nounwind
store volatile double %B, double* %P
%C = tail call double @llvm.nearbyint.f64(double -1.5) nounwind
store volatile double %C, double* %P
ret void
; CHECK-LABEL: @nearbyint(
; CHECK: store volatile double 2.000000e+00, double* %P, align 8
; CHECK: store volatile double -2.000000e+00, double* %P, align 8
}