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/CorrelatedValuePropagation/abs.ll

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

378 lines
10 KiB
LLVM
Raw Normal View History

[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
[test] Use -passes syntax when specifying pipeline in some more tests The legacy PM is deprecated, so update a bunch of lit tests running opt to use the new PM syntax when specifying the pipeline. In this patch focus has been put on test cases for ConstantMerge, ConstraintElimination, CorrelatedValuePropagation, GlobalDCE, GlobalOpt, SCCP, TailCallElim and PredicateInfo. Differential Revision: https://reviews.llvm.org/D114516
2021-11-18 17:14:04 +08:00
; RUN: opt < %s -passes=correlated-propagation -S | FileCheck %s
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
declare void @llvm.assume(i1)
declare i8 @llvm.abs(i8, i1)
; If we don't know anything about the argument, we can't do anything.
define i8 @test0(i8 %x) {
; CHECK-LABEL: @test0(
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 false)
; CHECK-NEXT: ret i8 [[R]]
;
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test1(i8 %x) {
; CHECK-LABEL: @test1(
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X:%.*]], i1 true)
; CHECK-NEXT: ret i8 [[R]]
;
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
; But if we know that the argument is always positive, we can bypass @llvm.abs.
define i8 @test2(i8 %x) {
; CHECK-LABEL: @test2(
; CHECK-NEXT: [[LIM:%.*]] = icmp sge i8 [[X:%.*]], -1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp sge i8 %x, -1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test3(i8 %x) {
; CHECK-LABEL: @test3(
; CHECK-NEXT: [[LIM:%.*]] = icmp sge i8 [[X:%.*]], -1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp sge i8 %x, -1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test4(i8 %x) {
; CHECK-LABEL: @test4(
; CHECK-NEXT: [[LIM:%.*]] = icmp sge i8 [[X:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sge i8 %x, 0
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test5(i8 %x) {
; CHECK-LABEL: @test5(
; CHECK-NEXT: [[LIM:%.*]] = icmp sge i8 [[X:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sge i8 %x, 0
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test6(i8 %x) {
; CHECK-LABEL: @test6(
; CHECK-NEXT: [[LIM:%.*]] = icmp sge i8 [[X:%.*]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sge i8 %x, 1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test7(i8 %x) {
; CHECK-LABEL: @test7(
; CHECK-NEXT: [[LIM:%.*]] = icmp sge i8 [[X:%.*]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sge i8 %x, 1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
; Likewise, INT_MIN is fine for otherwise-positive value.
define i8 @test8(i8 %x) {
; CHECK-LABEL: @test8(
; CHECK-NEXT: [[LIM:%.*]] = icmp ule i8 [[X:%.*]], 127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp ule i8 %x, 127
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test9(i8 %x) {
; CHECK-LABEL: @test9(
; CHECK-NEXT: [[LIM:%.*]] = icmp ule i8 [[X:%.*]], 127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp ule i8 %x, 127
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test10(i8 %x) {
; CHECK-LABEL: @test10(
; CHECK-NEXT: [[LIM:%.*]] = icmp ule i8 [[X:%.*]], -128
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp ule i8 %x, 128
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test11(i8 %x) {
; CHECK-LABEL: @test11(
; CHECK-NEXT: [[LIM:%.*]] = icmp ule i8 [[X:%.*]], -128
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: ret i8 [[X]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp ule i8 %x, 128
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test12(i8 %x) {
; CHECK-LABEL: @test12(
; CHECK-NEXT: [[LIM:%.*]] = icmp ule i8 [[X:%.*]], -127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp ule i8 %x, 129
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test13(i8 %x) {
; CHECK-LABEL: @test13(
; CHECK-NEXT: [[LIM:%.*]] = icmp ule i8 [[X:%.*]], -127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp ule i8 %x, 129
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
; Likewise, if we know that argument is always negative,
; we can expand @llvm.abs into a direct negation.
; For negative arguments, we must be careful to include 0 though.
define i8 @test14(i8 %x) {
; CHECK-LABEL: @test14(
; CHECK-NEXT: [[LIM:%.*]] = icmp sle i8 [[X:%.*]], -1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sle i8 %x, -1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test15(i8 %x) {
; CHECK-LABEL: @test15(
; CHECK-NEXT: [[LIM:%.*]] = icmp sle i8 [[X:%.*]], -1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub nsw i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sle i8 %x, -1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test16(i8 %x) {
; CHECK-LABEL: @test16(
; CHECK-NEXT: [[LIM:%.*]] = icmp sle i8 [[X:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sle i8 %x, 0
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test17(i8 %x) {
; CHECK-LABEL: @test17(
; CHECK-NEXT: [[LIM:%.*]] = icmp sle i8 [[X:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub nsw i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp sle i8 %x, 0
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test18(i8 %x) {
; CHECK-LABEL: @test18(
; CHECK-NEXT: [[LIM:%.*]] = icmp sle i8 [[X:%.*]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp sle i8 %x, 1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test19(i8 %x) {
; CHECK-LABEL: @test19(
; CHECK-NEXT: [[LIM:%.*]] = icmp sle i8 [[X:%.*]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp sle i8 %x, 1
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
; And again, INT_MIN is also fine for otherwise-negative range.
define i8 @test20(i8 %x) {
; CHECK-LABEL: @test20(
; CHECK-NEXT: [[LIM:%.*]] = icmp uge i8 [[X:%.*]], 127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 false)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp uge i8 %x, 127
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test21(i8 %x) {
; CHECK-LABEL: @test21(
; CHECK-NEXT: [[LIM:%.*]] = icmp uge i8 [[X:%.*]], 127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp uge i8 %x, 127
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test22(i8 %x) {
; CHECK-LABEL: @test22(
; CHECK-NEXT: [[LIM:%.*]] = icmp uge i8 [[X:%.*]], -128
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp uge i8 %x, 128
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test23(i8 %x) {
; CHECK-LABEL: @test23(
; CHECK-NEXT: [[LIM:%.*]] = icmp uge i8 [[X:%.*]], -128
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub nsw i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp uge i8 %x, 128
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
define i8 @test24(i8 %x) {
; CHECK-LABEL: @test24(
; CHECK-NEXT: [[LIM:%.*]] = icmp uge i8 [[X:%.*]], -127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub nsw i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp uge i8 %x, 129
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test25(i8 %x) {
; CHECK-LABEL: @test25(
; CHECK-NEXT: [[LIM:%.*]] = icmp uge i8 [[X:%.*]], -127
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R1:%.*]] = sub nsw i8 0, [[X]]
; CHECK-NEXT: ret i8 [[R1]]
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
;
%lim = icmp uge i8 %x, 129
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}
; If all else fails, we can sometimes at least inferr NSW.
define i8 @test26(i8 %x) {
; CHECK-LABEL: @test26(
; CHECK-NEXT: [[LIM:%.*]] = icmp ne i8 [[X:%.*]], -128
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
[CVP] @llvm.abs() handling Iff we know the sigdness domain of the argument, we can either skip @llvm.abs, or do negation directly. Notably, INT_MIN can belong to either domain: * X u<= INT_MIN --> X is always fine https://alive2.llvm.org/ce/z/QB8j-C https://alive2.llvm.org/ce/z/7sFKpS * X s<= 0 --> -X is always fine https://alive2.llvm.org/ce/z/QbGSyq https://alive2.llvm.org/ce/z/APsN84 If all else fails, try to inferr NSW flag: https://alive2.llvm.org/ce/z/qCJfYm
2021-04-10 20:52:28 +08:00
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
[NFC][CVP] Add `@llvm.abs` test cases
2021-04-10 20:41:43 +08:00
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp ne i8 %x, 128
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 0)
ret i8 %r
}
define i8 @test27(i8 %x) {
; CHECK-LABEL: @test27(
; CHECK-NEXT: [[LIM:%.*]] = icmp ne i8 [[X:%.*]], -128
; CHECK-NEXT: call void @llvm.assume(i1 [[LIM]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.abs.i8(i8 [[X]], i1 true)
; CHECK-NEXT: ret i8 [[R]]
;
%lim = icmp ne i8 %x, 128
call void @llvm.assume(i1 %lim)
%r = call i8 @llvm.abs(i8 %x, i1 1)
ret i8 %r
}