This is an archive of the discontinued LLVM Phabricator instance.

Differential D119080

[test] Use -passes=instsimplify instead of -instsimplify in a number of tests. NFC
ClosedPublic

Authored by bjope on Feb 6 2022, 7:25 AM.

Details

Reviewers
aeubanks
Commits
rGb280ee1dd7e9: [test] Use -passes=instsimplify instead of -instsimplify in a number of tests.
Summary

Another step moving away from the deprecated syntax of specifying
pass pipeline in opt.

Diff Detail

Event Timeline

bjope created this revision.Feb 6 2022, 7:25 AM
Herald added subscribers: kerbowa, dmgreen, jgravelle-google and 3 others. · View Herald TranscriptFeb 6 2022, 7:25 AM
bjope requested review of this revision.Feb 6 2022, 7:25 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 6 2022, 7:25 AM
Herald added a subscriber: aheejin. · View Herald Transcript
Harbormaster completed remote builds in B147821: Diff 406251.Feb 6 2022, 8:04 AM
aeubanks accepted this revision.Feb 6 2022, 1:22 PM

I think trivial changes like this one don't need a review and should be good to go

This revision is now accepted and ready to land.Feb 6 2022, 1:22 PM
bjope added a comment.Feb 7 2022, 1:49 AM
In D119080#3299594, @aeubanks wrote:

I think trivial changes like this one don't need a review and should be good to go

Ok, got it. Thanks for trusting that I don't mess up things.
(Usually I want someone from another organization to review my patches, but as you say, for trivial patches like this one I guess it could be OK to just let someone from my own team to make a quick review.)

This revision was landed with ongoing or failed builds.Feb 7 2022, 5:27 AM
Closed by commit rGb280ee1dd7e9: [test] Use -passes=instsimplify instead of -instsimplify in a number of tests. (authored by bjope). · Explain Why
This revision was automatically updated to reflect the committed changes.
bjope added a commit: rGb280ee1dd7e9: [test] Use -passes=instsimplify instead of -instsimplify in a number of tests..

Revision Contents

PathSize
llvm/
test/
Transforms/
InstSimplify/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ConstProp/
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
AArch64/
2 lines
AMDGPU/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ARM/
2 lines
2 lines
2 lines
WebAssembly/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
X86/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 406407

llvm/test/Transforms/InstSimplify/2010-12-20-Boolean.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @add(i1 %x) { define i1 @add(i1 %x) {
; CHECK-LABEL: @add( ; CHECK-LABEL: @add(
; CHECK: ret i1 false ; CHECK: ret i1 false
; ;
%z = add i1 %x, %x %z = add i1 %x, %x
ret i1 %z ret i1 %z
} }
Show All 24 Lines

llvm/test/Transforms/InstSimplify/2011-01-14-Thread.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @shift_select(i1 %cond) { define i32 @shift_select(i1 %cond) {
; CHECK-LABEL: @shift_select( ; CHECK-LABEL: @shift_select(
%s = select i1 %cond, i32 0, i32 1 %s = select i1 %cond, i32 0, i32 1
%r = lshr i32 %s, 1 %r = lshr i32 %s, 1
ret i32 %r ret i32 %r
; CHECK: ret i32 0 ; CHECK: ret i32 0
} }

llvm/test/Transforms/InstSimplify/2011-02-01-Vector.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <2 x i32> @sdiv(<2 x i32> %x) { define <2 x i32> @sdiv(<2 x i32> %x) {
; CHECK-LABEL: @sdiv( ; CHECK-LABEL: @sdiv(
%div = sdiv <2 x i32> %x, <i32 1, i32 1> %div = sdiv <2 x i32> %x, <i32 1, i32 1>
ret <2 x i32> %div ret <2 x i32> %div
; CHECK: ret <2 x i32> %x ; CHECK: ret <2 x i32> %x
} }

llvm/test/Transforms/InstSimplify/2011-09-05-InsertExtractValue.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare void @bar() declare void @bar()
define void @test1() personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 { define void @test1() personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: invoke void @bar() ; CHECK-NEXT: invoke void @bar()
; CHECK-NEXT: to label [[CONT:%.*]] unwind label [[LPAD:%.*]] ; CHECK-NEXT: to label [[CONT:%.*]] unwind label [[LPAD:%.*]]
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/2011-11-23-MaskedBitsCrash.ll

; RUN: opt < %s -instsimplify ; RUN: opt < %s -passes=instsimplify
; The mul can be proved to always overflow (turning a negative value ; The mul can be proved to always overflow (turning a negative value
; into a positive one) and thus results in undefined behaviour. At ; into a positive one) and thus results in undefined behaviour. At
; the same time we were deducing from the nsw flag that that mul could ; the same time we were deducing from the nsw flag that that mul could
; be assumed to have a negative value (since if not it has an undefined ; be assumed to have a negative value (since if not it has an undefined
; value, which can be taken to be negative). We were reporting the mul ; value, which can be taken to be negative). We were reporting the mul
; as being both positive and negative, firing an assertion! ; as being both positive and negative, firing an assertion!
define i1 @test1(i32 %a) { define i1 @test1(i32 %a) {
entry: entry:
%0 = or i32 %a, 1 %0 = or i32 %a, 1
%1 = shl i32 %0, 31 %1 = shl i32 %0, 31
%2 = mul nsw i32 %1, 4 %2 = mul nsw i32 %1, 4
%3 = and i32 %2, -4 %3 = and i32 %2, -4
%4 = icmp ne i32 %3, 0 %4 = icmp ne i32 %3, 0
ret i1 %4 ret i1 %4
} }

llvm/test/Transforms/InstSimplify/2013-04-19-ConstantFoldingCrash.ll

; RUN: opt < %s -instsimplify ; RUN: opt < %s -passes=instsimplify
target datalayout = "e-p: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-S128" target datalayout = "e-p: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-S128"
; PR15791 ; PR15791
define <2 x i64> @test1() { define <2 x i64> @test1() {
%a = and <2 x i64> undef, bitcast (<4 x i32> <i32 undef, i32 undef, i32 undef, i32 2147483647> to <2 x i64>) %a = and <2 x i64> undef, bitcast (<4 x i32> <i32 undef, i32 undef, i32 undef, i32 2147483647> to <2 x i64>)
ret <2 x i64> %a ret <2 x i64> %a
} }

llvm/test/Transforms/InstSimplify/AndOrXor.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i32 @llvm.smax.i32(i32, i32) declare i32 @llvm.smax.i32(i32, i32)
declare <2 x i32> @llvm.umin.v2i32(<2 x i32>, <2 x i32>) declare <2 x i32> @llvm.umin.v2i32(<2 x i32>, <2 x i32>)
define i8 @and0(i8 %x) { define i8 @and0(i8 %x) {
; CHECK-LABEL: @and0( ; CHECK-LABEL: @and0(
; CHECK-NEXT: ret i8 0 ; CHECK-NEXT: ret i8 0
; ;
▲ Show 20 Lines • Show All 1,118 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/2002-03-11-ConstPropCrash.ll

; When constant propogating terminator instructions, the basic block iterator ; When constant propogating terminator instructions, the basic block iterator
; was not updated to refer to the final position of the new terminator. This ; was not updated to refer to the final position of the new terminator. This
; can be bad, f.e. because constproping a terminator can lead to the ; can be bad, f.e. because constproping a terminator can lead to the
; destruction of PHI nodes, which invalidates the iterator! ; destruction of PHI nodes, which invalidates the iterator!
; ;
; Fixed by adding new arguments to ConstantFoldTerminator ; Fixed by adding new arguments to ConstantFoldTerminator
; ;
; RUN: opt < %s -instsimplify ; RUN: opt < %s -passes=instsimplify
define void @build_tree(i32 %ml) { define void @build_tree(i32 %ml) {
; <label>:0 ; <label>:0
br label %bb2 br label %bb2
bb2: ; preds = %bb2, %0 bb2: ; preds = %bb2, %0
%reg137 = phi i32 [ %reg140, %bb2 ], [ 12, %0 ] ; <i32> [#uses=1] %reg137 = phi i32 [ %reg140, %bb2 ], [ 12, %0 ] ; <i32> [#uses=1]
%reg138 = phi i32 [ %reg139, %bb2 ], [ 0, %0 ] ; <i32> [#uses=1] %reg138 = phi i32 [ %reg139, %bb2 ], [ 0, %0 ] ; <i32> [#uses=1]
%reg139 = add i32 %reg138, 1 ; <i32> [#uses=1] %reg139 = add i32 %reg138, 1 ; <i32> [#uses=1]
%reg140 = add i32 %reg137, -1 ; <i32> [#uses=1] %reg140 = add i32 %reg137, -1 ; <i32> [#uses=1]
br i1 false, label %bb2, label %bb3 br i1 false, label %bb2, label %bb3
bb3: ; preds = %bb2 bb3: ; preds = %bb2
ret void ret void
} }

llvm/test/Transforms/InstSimplify/ConstProp/2002-05-03-DivideByZeroException.ll

; Make sure that the constant propogator doesn't divide by zero! ; Make sure that the constant propogator doesn't divide by zero!
; ;
; RUN: opt < %s -instsimplify ; RUN: opt < %s -passes=instsimplify
; ;
define i32 @test() { define i32 @test() {
%R = sdiv i32 12, 0 ; <i32> [#uses=1] %R = sdiv i32 12, 0 ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }
define i32 @test2() { define i32 @test2() {
%R = srem i32 12, 0 ; <i32> [#uses=1] %R = srem i32 12, 0 ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }

llvm/test/Transforms/InstSimplify/ConstProp/2002-05-03-NotOperator.ll

; This bug has to do with the fact that constant propagation was implemented in ; This bug has to do with the fact that constant propagation was implemented in
; terms of _logical_ not (! in C) instead of _bitwise_ not (~ in C). This was ; terms of _logical_ not (! in C) instead of _bitwise_ not (~ in C). This was
; due to a spec change. ; due to a spec change.
; Fix #2: The unary not instruction now no longer exists. Change to xor. ; Fix #2: The unary not instruction now no longer exists. Change to xor.
; RUN: opt < %s -instsimplify -S | \ ; RUN: opt < %s -passes=instsimplify -S | \
; RUN: not grep "i32 0" ; RUN: not grep "i32 0"
define i32 @test1() { define i32 @test1() {
%R = xor i32 123, -1 ; <i32> [#uses=1] %R = xor i32 123, -1 ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }
define i32 @test2() { define i32 @test2() {
%R = xor i32 -123, -1 ; <i32> [#uses=1] %R = xor i32 -123, -1 ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }

llvm/test/Transforms/InstSimplify/ConstProp/2003-05-12-DivideError.ll

; Make sure that the constant propagator doesn't cause a sigfpe ; Make sure that the constant propagator doesn't cause a sigfpe
; ;
; RUN: opt < %s -instsimplify ; RUN: opt < %s -passes=instsimplify
; ;
define i32 @test() { define i32 @test() {
%R = sdiv i32 -2147483648, -1 ; <i32> [#uses=1] %R = sdiv i32 -2147483648, -1 ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }
define i32 @test2() { define i32 @test2() {
%R = srem i32 -2147483648, -1 ; <i32> [#uses=1] %R = srem i32 -2147483648, -1 ; <i32> [#uses=1]
ret i32 %R ret i32 %R
} }

llvm/test/Transforms/InstSimplify/ConstProp/2005-01-28-SetCCGEP.ll

; RUN: opt < %s -instsimplify -S | \ ; RUN: opt < %s -passes=instsimplify -S | \
; RUN: not grep "ret i1 false" ; RUN: not grep "ret i1 false"
@b = external global [2 x { }] ; <[2 x { }]*> [#uses=2] @b = external global [2 x { }] ; <[2 x { }]*> [#uses=2]
define i1 @f() { define i1 @f() {
%tmp.2 = icmp eq { }* getelementptr ([2 x { }], [2 x { }]* @b, i32 0, i32 0), getelementptr ([2 x { }], [2 x { }]* @b, i32 0, i32 1) ; <i1> [#uses=1] %tmp.2 = icmp eq { }* getelementptr ([2 x { }], [2 x { }]* @b, i32 0, i32 0), getelementptr ([2 x { }], [2 x { }]* @b, i32 0, i32 1) ; <i1> [#uses=1]
ret i1 %tmp.2 ret i1 %tmp.2
} }

llvm/test/Transforms/InstSimplify/ConstProp/2006-11-30-vector-cast.ll

; RUN: opt < %s -instsimplify -S | \ ; RUN: opt < %s -passes=instsimplify -S | \
; RUN: grep "i32 -1" ; RUN: grep "i32 -1"
; RUN: opt < %s -instsimplify -S | \ ; RUN: opt < %s -passes=instsimplify -S | \
; RUN: not grep zeroinitializer ; RUN: not grep zeroinitializer
define <4 x i32> @test() { define <4 x i32> @test() {
%tmp40 = bitcast <2 x i64> bitcast (<4 x i32> < i32 0, i32 0, i32 -1, i32 0 > to <2 x i64>) to <4 x i32>; <<4 x i32>> [#uses=1] %tmp40 = bitcast <2 x i64> bitcast (<4 x i32> < i32 0, i32 0, i32 -1, i32 0 > to <2 x i64>) to <4 x i32>; <<4 x i32>> [#uses=1]
ret <4 x i32> %tmp40 ret <4 x i32> %tmp40
} }

llvm/test/Transforms/InstSimplify/ConstProp/2006-12-01-bool-casts.ll

; RUN: opt < %s -instsimplify -S | \ ; RUN: opt < %s -passes=instsimplify -S | \
; RUN: grep "ret i32 -1" ; RUN: grep "ret i32 -1"
; RUN: opt < %s -instsimplify -S | \ ; RUN: opt < %s -passes=instsimplify -S | \
; RUN: grep "ret i32 1" ; RUN: grep "ret i32 1"
define i32 @test1() { define i32 @test1() {
%A = sext i1 true to i32 ; <i32> [#uses=1] %A = sext i1 true to i32 ; <i32> [#uses=1]
ret i32 %A ret i32 %A
} }
define i32 @test2() { define i32 @test2() {
%A = zext i1 true to i32 ; <i32> [#uses=1] %A = zext i1 true to i32 ; <i32> [#uses=1]
ret i32 %A ret i32 %A
} }

llvm/test/Transforms/InstSimplify/ConstProp/2007-02-05-BitCast.ll

; RUN: opt < %s -instsimplify -S | grep 1065353216 ; RUN: opt < %s -passes=instsimplify -S | grep 1065353216
define i32 @test() { define i32 @test() {
%A = bitcast float 1.000000e+00 to i32 ; <i32> [#uses=1] %A = bitcast float 1.000000e+00 to i32 ; <i32> [#uses=1]
ret i32 %A ret i32 %A
} }

llvm/test/Transforms/InstSimplify/ConstProp/2008-07-07-VectorCompare.ll

; RUN: opt < %s -instsimplify -disable-output ; RUN: opt < %s -passes=instsimplify -disable-output
; PR2529 ; PR2529
define <4 x i1> @test1(i32 %argc, i8** %argv) { define <4 x i1> @test1(i32 %argc, i8** %argv) {
entry: entry:
%foo = icmp slt <4 x i32> undef, <i32 14, i32 undef, i32 undef, i32 undef> %foo = icmp slt <4 x i32> undef, <i32 14, i32 undef, i32 undef, i32 undef>
ret <4 x i1> %foo ret <4 x i1> %foo
} }
define <4 x i1> @test2(i32 %argc, i8** %argv) { define <4 x i1> @test2(i32 %argc, i8** %argv) {
Show All 19 Lines

llvm/test/Transforms/InstSimplify/ConstProp/2009-09-01-GEP-Crash.ll

; RUN: opt < %s -instsimplify | llvm-dis ; RUN: opt < %s -passes=instsimplify | llvm-dis
; PR4848 ; PR4848
target datalayout = "e-p: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" target datalayout = "e-p: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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%0 = type { %struct.anon } %0 = type { %struct.anon }
%1 = type { %0, %2, [24 x i8] } %1 = type { %0, %2, [24 x i8] }
%2 = type <{ %3, %3 }> %2 = type <{ %3, %3 }>
%3 = type { %struct.hrtimer_cpu_base*, i32, %struct.rb_root, %struct.rb_node*, %struct.pgprot, i64 ()*, [16 x i8] } %3 = type { %struct.hrtimer_cpu_base*, i32, %struct.rb_root, %struct.rb_node*, %struct.pgprot, i64 ()*, [16 x i8] }
Show All 15 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AArch64/aarch64-sve-convert-from-svbool.ll

; RUN: opt -instsimplify -S -o - < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S -o - < %s | FileCheck %s
define <vscale x 2 x i1> @reinterpret_zero() { define <vscale x 2 x i1> @reinterpret_zero() {
; CHECK-LABEL: @reinterpret_zero( ; CHECK-LABEL: @reinterpret_zero(
; CHECK: ret <vscale x 2 x i1> zeroinitializer ; CHECK: ret <vscale x 2 x i1> zeroinitializer
%pg = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> zeroinitializer) %pg = tail call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> zeroinitializer)
ret <vscale x 2 x i1> %pg ret <vscale x 2 x i1> %pg
} }
declare <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1>) declare <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1>)

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cos.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare half @llvm.amdgcn.cos.f16(half) #0 declare half @llvm.amdgcn.cos.f16(half) #0
declare float @llvm.amdgcn.cos.f32(float) #0 declare float @llvm.amdgcn.cos.f32(float) #0
declare double @llvm.amdgcn.cos.f64(double) #0 declare double @llvm.amdgcn.cos.f64(double) #0
define void @test_f16(half* %p) { define void @test_f16(half* %p) {
; CHECK-LABEL: @test_f16( ; CHECK-LABEL: @test_f16(
; CHECK-NEXT: store volatile half 0xH3C00, half* [[P:%.*]], align 2 ; CHECK-NEXT: store volatile half 0xH3C00, half* [[P:%.*]], align 2
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubeid.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.amdgcn.cubeid(float, float, float) declare float @llvm.amdgcn.cubeid(float, float, float)
define void @test(float* %p) { define void @test(float* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P:%.*]] ; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P:%.*]]
; CHECK-NEXT: store volatile float 2.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 2.000000e+00, float* [[P]]
; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]]
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubema.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.amdgcn.cubema(float, float, float) declare float @llvm.amdgcn.cubema(float, float, float)
define void @test(float* %p) { define void @test(float* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P:%.*]] ; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P:%.*]]
; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P]] ; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P]]
; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P]] ; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P]]
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubesc.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.amdgcn.cubesc(float, float, float) declare float @llvm.amdgcn.cubesc(float, float, float)
define void @test(float* %p) { define void @test(float* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile float 3.000000e+00, float* [[P:%.*]] ; CHECK-NEXT: store volatile float 3.000000e+00, float* [[P:%.*]]
; CHECK-NEXT: store volatile float 3.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 3.000000e+00, float* [[P]]
; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]]
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubetc.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.amdgcn.cubetc(float, float, float) declare float @llvm.amdgcn.cubetc(float, float, float)
define void @test(float* %p) { define void @test(float* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile float -4.000000e+00, float* [[P:%.*]] ; CHECK-NEXT: store volatile float -4.000000e+00, float* [[P:%.*]]
; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]]
; CHECK-NEXT: store volatile float -3.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float -3.000000e+00, float* [[P]]
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/fma_legacy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.amdgcn.fma.legacy(float, float, float) declare float @llvm.amdgcn.fma.legacy(float, float, float)
define void @test(float* %p) { define void @test(float* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P:%.*]], align 4 ; CHECK-NEXT: store volatile float 1.000000e+01, float* [[P:%.*]], align 4
; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]], align 4 ; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]], align 4
; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]], align 4 ; CHECK-NEXT: store volatile float 4.000000e+00, float* [[P]], align 4
Show All 34 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/fmul_legacy.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.amdgcn.fmul.legacy(float, float) declare float @llvm.amdgcn.fmul.legacy(float, float)
define void @test(float* %p) { define void @test(float* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile float 6.000000e+00, float* [[P:%.*]] ; CHECK-NEXT: store volatile float 6.000000e+00, float* [[P:%.*]]
; CHECK-NEXT: store volatile float 0.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 0.000000e+00, float* [[P]]
; CHECK-NEXT: store volatile float 0.000000e+00, float* [[P]] ; CHECK-NEXT: store volatile float 0.000000e+00, float* [[P]]
Show All 34 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/fract.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare half @llvm.amdgcn.fract.f16(half) declare half @llvm.amdgcn.fract.f16(half)
declare float @llvm.amdgcn.fract.f32(float) declare float @llvm.amdgcn.fract.f32(float)
declare double @llvm.amdgcn.fract.f64(double) declare double @llvm.amdgcn.fract.f64(double)
define void @test_f16(half* %p) { define void @test_f16(half* %p) {
; CHECK-LABEL: @test_f16( ; CHECK-LABEL: @test_f16(
; CHECK-NEXT: store volatile half 0xH0000, half* [[P:%.*]] ; CHECK-NEXT: store volatile half 0xH0000, half* [[P:%.*]]
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/perm.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i32 @llvm.amdgcn.perm(i32, i32, i32) declare i32 @llvm.amdgcn.perm(i32, i32, i32)
; src1 = 0x19203a4b (421542475), src2 = 0x5c6d7e8f (1550679695) ; src1 = 0x19203a4b (421542475), src2 = 0x5c6d7e8f (1550679695)
define void @test(i32* %p) { define void @test(i32* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: store volatile i32 undef, i32* [[P:%.*]], align 4 ; CHECK-NEXT: store volatile i32 undef, i32* [[P:%.*]], align 4
; CHECK-NEXT: store volatile i32 -1887539876, i32* [[P]], align 4 ; CHECK-NEXT: store volatile i32 -1887539876, i32* [[P]], align 4
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/sin.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare half @llvm.amdgcn.sin.f16(half) #0 declare half @llvm.amdgcn.sin.f16(half) #0
declare float @llvm.amdgcn.sin.f32(float) #0 declare float @llvm.amdgcn.sin.f32(float) #0
declare double @llvm.amdgcn.sin.f64(double) #0 declare double @llvm.amdgcn.sin.f64(double) #0
define void @test_f16(half* %p) { define void @test_f16(half* %p) {
; CHECK-LABEL: @test_f16( ; CHECK-LABEL: @test_f16(
; CHECK-NEXT: store volatile half 0xH0000, half* [[P:%.*]], align 2 ; CHECK-NEXT: store volatile half 0xH0000, half* [[P:%.*]], align 2
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/ARM/mve-vctp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S -o - %s | FileCheck %s ; RUN: opt -passes=instsimplify -S -o - %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
define <16 x i1> @vctp8_0() { define <16 x i1> @vctp8_0() {
; CHECK-LABEL: @vctp8_0( ; CHECK-LABEL: @vctp8_0(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret <16 x i1> zeroinitializer ; CHECK-NEXT: ret <16 x i1> zeroinitializer
; ;
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/InsertElement-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @test1() { define i32 @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i32 2139171423 ; CHECK-NEXT: ret i32 2139171423
; ;
%A = bitcast i32 2139171423 to float %A = bitcast i32 2139171423 to float
%B = insertelement <1 x float> poison, float %A, i32 0 %B = insertelement <1 x float> poison, float %A, i32 0
%C = extractelement <1 x float> %B, i32 0 %C = extractelement <1 x float> %B, i32 0
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/InsertElement.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @test1() { define i32 @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i32 2139171423 ; CHECK-NEXT: ret i32 2139171423
; ;
%A = bitcast i32 2139171423 to float %A = bitcast i32 2139171423 to float
%B = insertelement <1 x float> undef, float %A, i32 0 %B = insertelement <1 x float> undef, float %A, i32 0
%C = extractelement <1 x float> %B, i32 0 %C = extractelement <1 x float> %B, i32 0
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/WebAssembly/trunc.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
declare i32 @llvm.wasm.trunc.signed.i32.f32(float) declare i32 @llvm.wasm.trunc.signed.i32.f32(float)
declare i32 @llvm.wasm.trunc.unsigned.i32.f32(float) declare i32 @llvm.wasm.trunc.unsigned.i32.f32(float)
declare i32 @llvm.wasm.trunc.signed.i32.f64(double) declare i32 @llvm.wasm.trunc.signed.i32.f64(double)
declare i32 @llvm.wasm.trunc.unsigned.i32.f64(double) declare i32 @llvm.wasm.trunc.unsigned.i32.f64(double)
▲ Show 20 Lines • Show All 676 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/abs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i8 @llvm.abs.i8(i8, i1) declare i8 @llvm.abs.i8(i8, i1)
declare <8 x i8> @llvm.abs.v8i8(<8 x i8>, i1) declare <8 x i8> @llvm.abs.v8i8(<8 x i8>, i1)
define i8 @undef_val_min_poison() { define i8 @undef_val_min_poison() {
; CHECK-LABEL: @undef_val_min_poison( ; CHECK-LABEL: @undef_val_min_poison(
; CHECK-NEXT: ret i8 undef ; CHECK-NEXT: ret i8 undef
; ;
Show All 35 Lines

llvm/test/Transforms/InstSimplify/ConstProp/active-lane-mask.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S -o - %s | FileCheck %s ; RUN: opt -passes=instsimplify -S -o - %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
define <16 x i1> @v16i1_0() { define <16 x i1> @v16i1_0() {
; CHECK-LABEL: @v16i1_0( ; CHECK-LABEL: @v16i1_0(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret <16 x i1> zeroinitializer ; CHECK-NEXT: ret <16 x i1> zeroinitializer
; ;
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/avx512.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
define i1 @test_avx512_cvts_exact() nounwind readnone { define i1 @test_avx512_cvts_exact() nounwind readnone {
; CHECK-LABEL: @test_avx512_cvts_exact( ; CHECK-LABEL: @test_avx512_cvts_exact(
; CHECK-NOT: call ; CHECK-NOT: call
; CHECK: ret i1 true ; CHECK: ret i1 true
entry: entry:
%i0 = tail call i32 @llvm.x86.avx512.vcvtss2si32(<4 x float> <float 3.0, float undef, float undef, float undef>, i32 4) nounwind %i0 = tail call i32 @llvm.x86.avx512.vcvtss2si32(<4 x float> <float 3.0, float undef, float undef, float undef>, i32 4) nounwind
▲ Show 20 Lines • Show All 481 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/binop-identity-undef.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S %s | FileCheck %s ; RUN: opt -passes=instsimplify -S %s | FileCheck %s
define i32 @and1() { define i32 @and1() {
; CHECK-LABEL: @and1( ; CHECK-LABEL: @and1(
; CHECK-NEXT: ret i32 undef ; CHECK-NEXT: ret i32 undef
; ;
%r = and i32 undef, -1 %r = and i32 undef, -1
ret i32 %r ret i32 %r
} }
Show All 40 Lines

llvm/test/Transforms/InstSimplify/ConstProp/bitcast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; PR2165 ; PR2165
define <1 x i64> @test1() { define <1 x i64> @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret <1 x i64> <i64 63> ; CHECK-NEXT: ret <1 x i64> <i64 63>
; ;
%A = bitcast i64 63 to <1 x i64> %A = bitcast i64 63 to <1 x i64>
ret <1 x i64> %A ret <1 x i64> %A
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/bitcount.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i31 @llvm.ctpop.i31(i31 %val) declare i31 @llvm.ctpop.i31(i31 %val)
declare i32 @llvm.cttz.i32(i32 %val, i1) declare i32 @llvm.cttz.i32(i32 %val, i1)
declare i33 @llvm.ctlz.i33(i33 %val, i1) declare i33 @llvm.ctlz.i33(i33 %val, i1)
declare <2 x i31> @llvm.ctpop.v2i31(<2 x i31> %val) declare <2 x i31> @llvm.ctpop.v2i31(<2 x i31> %val)
declare <2 x i32> @llvm.cttz.v2i32(<2 x i32> %val, i1) declare <2 x i32> @llvm.cttz.v2i32(<2 x i32> %val, i1)
declare <2 x i33> @llvm.ctlz.v2i33(<2 x i33> %val, i1) declare <2 x i33> @llvm.ctlz.v2i33(<2 x i33> %val, i1)
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/bswap.ll

; bswap should be constant folded when it is passed a constant argument ; bswap should be constant folded when it is passed a constant argument
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i16 @llvm.bswap.i16(i16) declare i16 @llvm.bswap.i16(i16)
declare i32 @llvm.bswap.i32(i32) declare i32 @llvm.bswap.i32(i32)
declare i64 @llvm.bswap.i64(i64) declare i64 @llvm.bswap.i64(i64)
declare i80 @llvm.bswap.i80(i80) declare i80 @llvm.bswap.i80(i80)
Show All 30 Lines

llvm/test/Transforms/InstSimplify/ConstProp/calls-math-finite.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; RUN: opt < %s -instsimplify -S -mtriple=unknown-unknown-linux-musl | FileCheck -check-prefix=MUSL %s ; RUN: opt < %s -passes=instsimplify -S -mtriple=unknown-unknown-linux-musl | FileCheck -check-prefix=MUSL %s
; Test to verify constant folding can occur when math routines are mapped ; Test to verify constant folding can occur when math routines are mapped
; to the __<func>_finite versions of functions due to __FINITE_MATH_ONLY__ ; to the __<func>_finite versions of functions due to __FINITE_MATH_ONLY__
; being enabled on headers on Linux. All calls should constant fold away ; being enabled on headers on Linux. All calls should constant fold away
; in this test. ; in this test.
target triple = "unknown-unknown-linux-gnu" target triple = "unknown-unknown-linux-gnu"
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/calls.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; RUN: opt < %s -instsimplify -disable-simplify-libcalls -S | FileCheck %s --check-prefix=FNOBUILTIN ; RUN: opt < %s -passes=instsimplify -disable-simplify-libcalls -S | FileCheck %s --check-prefix=FNOBUILTIN
declare double @acos(double) readnone nounwind willreturn declare double @acos(double) readnone nounwind willreturn
declare double @asin(double) readnone nounwind willreturn declare double @asin(double) readnone nounwind willreturn
declare double @atan(double) readnone nounwind willreturn declare double @atan(double) readnone nounwind willreturn
declare double @atan2(double, double) readnone nounwind willreturn declare double @atan2(double, double) readnone nounwind willreturn
declare double @ceil(double) readnone nounwind willreturn declare double @ceil(double) readnone nounwind willreturn
declare double @cos(double) readnone nounwind willreturn declare double @cos(double) readnone nounwind willreturn
declare double @cosh(double) readnone nounwind willreturn declare double @cosh(double) readnone nounwind willreturn
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/cast-vector.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Test constant fold of constant expression GEP used by ptrtoint (the ; Test constant fold of constant expression GEP used by ptrtoint (the
; "offsetof-like expression" case). ; "offsetof-like expression" case).
; This used to hit an assert due to not supporting vectors in ; This used to hit an assert due to not supporting vectors in
; llvm::ConstantFoldCastInstruction when handling ptrtoint. ; llvm::ConstantFoldCastInstruction when handling ptrtoint.
define <2 x i16> @test1() { define <2 x i16> @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 22 Lines

llvm/test/Transforms/InstSimplify/ConstProp/cast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Overflow on a float to int or int to float conversion is undefined (PR21130). ; Overflow on a float to int or int to float conversion is undefined (PR21130).
define i8 @overflow_fptosi() { define i8 @overflow_fptosi() {
; CHECK-LABEL: @overflow_fptosi( ; CHECK-LABEL: @overflow_fptosi(
; CHECK-NEXT: ret i8 poison ; CHECK-NEXT: ret i8 poison
; ;
%i = fptosi double 1.56e+02 to i8 %i = fptosi double 1.56e+02 to i8
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/convert-from-fp16.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
; Verify that we don't crash with an assertion failure when constant folding ; Verify that we don't crash with an assertion failure when constant folding
; a call to intrinsic 'convert.from.fp16' if the return type is not 'float'. ; a call to intrinsic 'convert.from.fp16' if the return type is not 'float'.
define float @fold_from_fp16_to_fp32() { define float @fold_from_fp16_to_fp32() {
; CHECK-LABEL: @fold_from_fp16_to_fp32 ; CHECK-LABEL: @fold_from_fp16_to_fp32
; CHECK: ret float 0.000000e+00 ; CHECK: ret float 0.000000e+00
entry: entry:
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/copysign.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
declare float @llvm.copysign.f32(float, float) declare float @llvm.copysign.f32(float, float)
declare double @llvm.copysign.f64(double, double) declare double @llvm.copysign.f64(double, double)
declare bfloat @llvm.copysign.bf16(bfloat, bfloat) declare bfloat @llvm.copysign.bf16(bfloat, bfloat)
declare fp128 @llvm.copysign.f128(fp128, fp128) declare fp128 @llvm.copysign.f128(fp128, fp128)
declare ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128, ppc_fp128) declare ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128, ppc_fp128)
define float @f32_01() { define float @f32_01() {
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/extractelement-vscale.ll

; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
; CHECK-LABEL: definitely_in_bounds ; CHECK-LABEL: definitely_in_bounds
; CHECK: ret i8 0 ; CHECK: ret i8 0
define i8 @definitely_in_bounds() { define i8 @definitely_in_bounds() {
ret i8 extractelement (<vscale x 16 x i8> zeroinitializer, i64 15) ret i8 extractelement (<vscale x 16 x i8> zeroinitializer, i64 15)
} }
; CHECK-LABEL: maybe_in_bounds ; CHECK-LABEL: maybe_in_bounds
Show All 36 Lines

llvm/test/Transforms/InstSimplify/ConstProp/extractvalue.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
%struct = type { i32, [4 x i8] } %struct = type { i32, [4 x i8] }
define i32 @test1() { define i32 @test1() {
%A = extractvalue %struct { i32 2, [4 x i8] c"foo\00" }, 0 %A = extractvalue %struct { i32 2, [4 x i8] c"foo\00" }, 0
ret i32 %A ret i32 %A
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: ret i32 2 ; CHECK: ret i32 2
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/float-to-ptr-cast.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32* @test1() { define i32* @test1() {
%X = inttoptr i64 0 to i32* ; <i32*> [#uses=1] %X = inttoptr i64 0 to i32* ; <i32*> [#uses=1]
ret i32* %X ret i32* %X
} }
; CHECK: ret i32* null ; CHECK: ret i32* null
define i32* @test2() { define i32* @test2() {
ret i32* null ret i32* null
} }
; CHECK: ret i32* null ; CHECK: ret i32* null

llvm/test/Transforms/InstSimplify/ConstProp/fma.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
; Fixes PR20832 ; Fixes PR20832
; Make sure that we correctly fold a fused multiply-add where operands ; Make sure that we correctly fold a fused multiply-add where operands
; are all finite constants and addend is zero. ; are all finite constants and addend is zero.
declare double @llvm.fma.f64(double, double, double) declare double @llvm.fma.f64(double, double, double)
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/fneg.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define float @fneg_constant() { define float @fneg_constant() {
; CHECK-LABEL: @fneg_constant( ; CHECK-LABEL: @fneg_constant(
; CHECK-NEXT: ret float 0.000000e+00 ; CHECK-NEXT: ret float 0.000000e+00
; ;
%r = fneg float -0.0 %r = fneg float -0.0
ret float %r ret float %r
} }
Show All 32 Lines

llvm/test/Transforms/InstSimplify/ConstProp/fp-undef.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare <2 x double> @llvm.minnum.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.minnum.v2f64(<2 x double>, <2 x double>)
declare <2 x double> @llvm.maxnum.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.maxnum.v2f64(<2 x double>, <2 x double>)
declare <2 x double> @llvm.minimum.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.minimum.v2f64(<2 x double>, <2 x double>)
declare <2 x double> @llvm.maximum.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.maximum.v2f64(<2 x double>, <2 x double>)
; Constant folding - undef undef. ; Constant folding - undef undef.
▲ Show 20 Lines • Show All 593 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/freeze.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
@g = external global i16, align 1 @g = external global i16, align 1
@g2 = external global i16, align 1 @g2 = external global i16, align 1
define i64 @ptrdiff1() { define i64 @ptrdiff1() {
; CHECK-LABEL: @ptrdiff1( ; CHECK-LABEL: @ptrdiff1(
; CHECK-NEXT: ret i64 sub (i64 ptrtoint (i16* @g to i64), i64 ptrtoint (i16* @g2 to i64)) ; CHECK-NEXT: ret i64 sub (i64 ptrtoint (i16* @g to i64), i64 ptrtoint (i16* @g2 to i64))
; ;
Show All 18 Lines

llvm/test/Transforms/InstSimplify/ConstProp/funnel-shift.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S -o - | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S -o - | FileCheck %s
declare i32 @llvm.fshl.i32(i32, i32, i32) declare i32 @llvm.fshl.i32(i32, i32, i32)
declare i32 @llvm.fshr.i32(i32, i32, i32) declare i32 @llvm.fshr.i32(i32, i32, i32)
declare i7 @llvm.fshl.i7(i7, i7, i7) declare i7 @llvm.fshl.i7(i7, i7, i7)
declare i7 @llvm.fshr.i7(i7, i7, i7) declare i7 @llvm.fshr.i7(i7, i7, i7)
declare <4 x i8> @llvm.fshl.v4i8(<4 x i8>, <4 x i8>, <4 x i8>) declare <4 x i8> @llvm.fshl.v4i8(<4 x i8>, <4 x i8>, <4 x i8>)
declare <4 x i8> @llvm.fshr.v4i8(<4 x i8>, <4 x i8>, <4 x i8>) declare <4 x i8> @llvm.fshr.v4i8(<4 x i8>, <4 x i8>, <4 x i8>)
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/gep-zeroinit-vector.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S -o - | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S -o - | FileCheck %s
; Testcase that verify that we don't get a faulty bitcast that cast between ; Testcase that verify that we don't get a faulty bitcast that cast between
; different sizes. ; different sizes.
%rec8 = type { i16 } %rec8 = type { i16 }
@a = global [1 x %rec8] zeroinitializer @a = global [1 x %rec8] zeroinitializer
define <2 x i16*> @test_gep() { define <2 x i16*> @test_gep() {
Show All 19 Lines

llvm/test/Transforms/InstSimplify/ConstProp/insertvalue.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
%struct = type { i32, [4 x i8] } %struct = type { i32, [4 x i8] }
define %struct @test1() { define %struct @test1() {
%A = insertvalue %struct { i32 2, [4 x i8] c"foo\00" }, i32 1, 0 %A = insertvalue %struct { i32 2, [4 x i8] c"foo\00" }, i32 1, 0
ret %struct %A ret %struct %A
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: ret %struct { i32 1, [4 x i8] c"foo\00" } ; CHECK: ret %struct { i32 1, [4 x i8] c"foo\00" }
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/libfunc.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; This is not the mathlib call you were looking for. ; This is not the mathlib call you were looking for.
declare double @sin(x86_fp80) declare double @sin(x86_fp80)
define double @PR50960(x86_fp80 %0) { define double @PR50960(x86_fp80 %0) {
; CHECK-LABEL: @PR50960( ; CHECK-LABEL: @PR50960(
; CHECK-NEXT: [[CALL:%.*]] = call double @sin(x86_fp80 0xK3FFF8000000000000000) ; CHECK-NEXT: [[CALL:%.*]] = call double @sin(x86_fp80 0xK3FFF8000000000000000)
; CHECK-NEXT: ret double [[CALL]] ; CHECK-NEXT: ret double [[CALL]]
; ;
%call = call double @sin(x86_fp80 0xK3FFF8000000000000000) %call = call double @sin(x86_fp80 0xK3FFF8000000000000000)
ret double %call ret double %call
} }

llvm/test/Transforms/InstSimplify/ConstProp/loads.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -data-layout="e-p:64:64:64-p1:16:16:16-p2: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-ni:2" -instsimplify -S | FileCheck %s --check-prefixes=CHECK,LE ; RUN: opt < %s -data-layout="e-p:64:64:64-p1:16:16:16-p2: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-ni:2" -passes=instsimplify -S | FileCheck %s --check-prefixes=CHECK,LE
; RUN: opt < %s -data-layout="E-p:64:64:64-p1:16:16:16-p2: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-ni:2" -instsimplify -S | FileCheck %s --check-prefixes=CHECK,BE ; RUN: opt < %s -data-layout="E-p:64:64:64-p1:16:16:16-p2: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-ni:2" -passes=instsimplify -S | FileCheck %s --check-prefixes=CHECK,BE
; {{ 0xDEADBEEF, 0xBA }, 0xCAFEBABE} ; {{ 0xDEADBEEF, 0xBA }, 0xCAFEBABE}
@g1 = constant {{i32,i8},i32} {{i32,i8} { i32 -559038737, i8 186 }, i32 -889275714 } @g1 = constant {{i32,i8},i32} {{i32,i8} { i32 -559038737, i8 186 }, i32 -889275714 }
@g2 = constant double 1.0 @g2 = constant double 1.0
; { 0x7B, 0x06B1BFF8 } ; { 0x7B, 0x06B1BFF8 }
@g3 = constant {i64, i64} { i64 123, i64 112312312 } @g3 = constant {i64, i64} { i64 123, i64 112312312 }
; Simple load ; Simple load
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/min-max.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
declare float @llvm.minnum.f32(float, float) declare float @llvm.minnum.f32(float, float)
declare bfloat @llvm.minnum.bf16(bfloat, bfloat) declare bfloat @llvm.minnum.bf16(bfloat, bfloat)
declare half @llvm.minnum.f16(half, half) declare half @llvm.minnum.f16(half, half)
declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>) declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>)
declare <4 x bfloat> @llvm.minnum.v4bf16(<4 x bfloat>, <4 x bfloat>) declare <4 x bfloat> @llvm.minnum.v4bf16(<4 x bfloat>, <4 x bfloat>)
declare <4 x half> @llvm.minnum.v4f16(<4 x half>, <4 x half>) declare <4 x half> @llvm.minnum.v4f16(<4 x half>, <4 x half>)
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/overflow-ops.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare {i8, i1} @llvm.uadd.with.overflow.i8(i8, i8) declare {i8, i1} @llvm.uadd.with.overflow.i8(i8, i8)
declare {i8, i1} @llvm.usub.with.overflow.i8(i8, i8) declare {i8, i1} @llvm.usub.with.overflow.i8(i8, i8)
declare {i8, i1} @llvm.umul.with.overflow.i8(i8, i8) declare {i8, i1} @llvm.umul.with.overflow.i8(i8, i8)
declare {i8, i1} @llvm.sadd.with.overflow.i8(i8, i8) declare {i8, i1} @llvm.sadd.with.overflow.i8(i8, i8)
declare {i8, i1} @llvm.ssub.with.overflow.i8(i8, i8) declare {i8, i1} @llvm.ssub.with.overflow.i8(i8, i8)
declare {i8, i1} @llvm.smul.with.overflow.i8(i8, i8) declare {i8, i1} @llvm.smul.with.overflow.i8(i8, i8)
▲ Show 20 Lines • Show All 240 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/poison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare void @use(...) declare void @use(...)
define void @casts() { define void @casts() {
; CHECK-LABEL: @casts( ; CHECK-LABEL: @casts(
; CHECK-NEXT: call void (...) @use(i8 poison, i8 poison, i8 poison, i8 poison, i8 poison, i32 poison, i8 poison, float poison, float poison, float poison, float poison) ; CHECK-NEXT: call void (...) @use(i8 poison, i8 poison, i8 poison, i8 poison, i8 poison, i32 poison, i8 poison, float poison, float poison, float poison, float poison)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/saturating-add-sub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i8 @llvm.uadd.sat.i8(i8, i8) declare i8 @llvm.uadd.sat.i8(i8, i8)
declare i8 @llvm.sadd.sat.i8(i8, i8) declare i8 @llvm.sadd.sat.i8(i8, i8)
declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8>, <2 x i8>)
declare i8 @llvm.usub.sat.i8(i8, i8) declare i8 @llvm.usub.sat.i8(i8, i8)
declare i8 @llvm.ssub.sat.i8(i8, i8) declare i8 @llvm.ssub.sat.i8(i8, i8)
▲ Show 20 Lines • Show All 356 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/shift.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; CHECK-LABEL: shift_undef_64 ; CHECK-LABEL: shift_undef_64
define void @shift_undef_64(i64* %p) { define void @shift_undef_64(i64* %p) {
%r1 = lshr i64 -1, 4294967296 ; 2^32 %r1 = lshr i64 -1, 4294967296 ; 2^32
; CHECK: store i64 poison ; CHECK: store i64 poison
store i64 %r1, i64* %p store i64 %r1, i64* %p
%r2 = ashr i64 -1, 4294967297 ; 2^32 + 1 %r2 = ashr i64 -1, 4294967297 ; 2^32 + 1
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/smul-fix-sat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
; Simple test using scalar layout. ; Simple test using scalar layout.
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
declare i32 @llvm.smul.fix.sat.i32(i32, i32, i32) declare i32 @llvm.smul.fix.sat.i32(i32, i32, i32)
define i32 @test_smul_fix_sat_i32_0() { define i32 @test_smul_fix_sat_i32_0() {
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/smul-fix.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
; Simple test using scalar layout. ; Simple test using scalar layout.
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
declare i32 @llvm.smul.fix.i32(i32, i32, i32) declare i32 @llvm.smul.fix.i32(i32, i32, i32)
define i32 @test_smul_fix_i32_0() { define i32 @test_smul_fix_i32_0() {
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/sse.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
define i1 @test_sse_cvts_exact() nounwind readnone { define i1 @test_sse_cvts_exact() nounwind readnone {
; CHECK-LABEL: @test_sse_cvts_exact( ; CHECK-LABEL: @test_sse_cvts_exact(
; CHECK-NOT: call ; CHECK-NOT: call
; CHECK: ret i1 true ; CHECK: ret i1 true
entry: entry:
%i0 = tail call i32 @llvm.x86.sse.cvtss2si(<4 x float> <float 3.0, float undef, float undef, float undef>) nounwind %i0 = tail call i32 @llvm.x86.sse.cvtss2si(<4 x float> <float 3.0, float undef, float undef, float undef>) nounwind
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/trunc_vec.ll

; RUN: opt -instsimplify < %s ; RUN: opt -passes=instsimplify < %s
; Make sure we don't crash on this one ; Make sure we don't crash on this one
define <8 x i8> @test_truc_vec() { define <8 x i8> @test_truc_vec() {
%x = bitcast <2 x i64> <i64 1, i64 2> to <8 x i16> %x = bitcast <2 x i64> <i64 1, i64 2> to <8 x i16>
%y = trunc <8 x i16> %x to <8 x i8> %y = trunc <8 x i16> %x to <8 x i8>
ret <8 x i8> %y ret <8 x i8> %y
} }

llvm/test/Transforms/InstSimplify/ConstProp/vecreduce.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i32 @llvm.vector.reduce.add.v1i32(<1 x i32> %a) declare i32 @llvm.vector.reduce.add.v1i32(<1 x i32> %a)
declare i32 @llvm.vector.reduce.add.v8i32(<8 x i32> %a) declare i32 @llvm.vector.reduce.add.v8i32(<8 x i32> %a)
declare i32 @llvm.vector.reduce.mul.v1i32(<1 x i32> %a) declare i32 @llvm.vector.reduce.mul.v1i32(<1 x i32> %a)
declare i32 @llvm.vector.reduce.mul.v8i32(<8 x i32> %a) declare i32 @llvm.vector.reduce.mul.v8i32(<8 x i32> %a)
declare i32 @llvm.vector.reduce.and.v1i32(<1 x i32> %a) declare i32 @llvm.vector.reduce.and.v1i32(<1 x i32> %a)
declare i32 @llvm.vector.reduce.and.v8i32(<8 x i32> %a) declare i32 @llvm.vector.reduce.and.v8i32(<8 x i32> %a)
declare i32 @llvm.vector.reduce.or.v1i32(<1 x i32> %a) declare i32 @llvm.vector.reduce.or.v1i32(<1 x i32> %a)
▲ Show 20 Lines • Show All 615 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/vector-undef-elts-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S -o - | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S -o - | FileCheck %s
; When both operands are undef in a lane, that lane should produce an undef result. ; When both operands are undef in a lane, that lane should produce an undef result.
define <3 x i8> @shl() { define <3 x i8> @shl() {
; CHECK-LABEL: @shl( ; CHECK-LABEL: @shl(
; CHECK-NEXT: ret <3 x i8> <i8 poison, i8 0, i8 0> ; CHECK-NEXT: ret <3 x i8> <i8 poison, i8 0, i8 0>
; ;
%c = shl <3 x i8> undef, <i8 undef, i8 4, i8 1> %c = shl <3 x i8> undef, <i8 undef, i8 4, i8 1>
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/ConstProp/vector-undef-elts.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S -o - | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S -o - | FileCheck %s
; When both operands are undef in a lane, that lane should produce an undef result. ; When both operands are undef in a lane, that lane should produce an undef result.
define <3 x i8> @shl() { define <3 x i8> @shl() {
; CHECK-LABEL: @shl( ; CHECK-LABEL: @shl(
; CHECK-NEXT: ret <3 x i8> <i8 poison, i8 0, i8 0> ; CHECK-NEXT: ret <3 x i8> <i8 poison, i8 0, i8 0>
; ;
%c = shl <3 x i8> undef, <i8 undef, i8 4, i8 1> %c = shl <3 x i8> undef, <i8 undef, i8 4, i8 1>
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/X86/fp-nan-strictfp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -mtriple=x86_64-- -instsimplify -S | FileCheck %s ; RUN: opt < %s -mtriple=x86_64-- -passes=instsimplify -S | FileCheck %s
; ;
; constrained fadd ; constrained fadd
; ;
define float @fadd_nan_op0_strict(float %x) #0 { define float @fadd_nan_op0_strict(float %x) #0 {
; CHECK-LABEL: @fadd_nan_op0_strict( ; CHECK-LABEL: @fadd_nan_op0_strict(
; CHECK-NEXT: [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]] ; CHECK-NEXT: [[R:%.*]] = call float @llvm.experimental.constrained.fadd.f32(float 0x7FF8000000000000, float [[X:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0:[0-9]+]]
▲ Show 20 Lines • Show All 454 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/abs_intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare i8 @llvm.abs.i8(i8, i1) declare i8 @llvm.abs.i8(i8, i1)
declare i32 @llvm.abs.i32(i32, i1) declare i32 @llvm.abs.i32(i32, i1)
declare <3 x i82> @llvm.abs.v3i82(<3 x i82>, i1) declare <3 x i82> @llvm.abs.v3i82(<3 x i82>, i1)
declare <4 x i32> @llvm.abs.v4i32(<4 x i32>, i1) declare <4 x i32> @llvm.abs.v4i32(<4 x i32>, i1)
define i32 @test_abs_abs_0(i32 %x) { define i32 @test_abs_abs_0(i32 %x) {
; CHECK-LABEL: @test_abs_abs_0( ; CHECK-LABEL: @test_abs_abs_0(
▲ Show 20 Lines • Show All 282 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/add-mask.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
define i1 @test1(i32 %a) { define i1 @test1(i32 %a) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%rhs = add i32 %a, -1 %rhs = add i32 %a, -1
%and = and i32 %a, %rhs %and = and i32 %a, %rhs
%res = icmp eq i32 %and, 1 %res = icmp eq i32 %and, 1
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/add.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @common_sub_operand(i32 %X, i32 %Y) { define i32 @common_sub_operand(i32 %X, i32 %Y) {
; CHECK-LABEL: @common_sub_operand( ; CHECK-LABEL: @common_sub_operand(
; CHECK-NEXT: ret i32 [[X:%.*]] ; CHECK-NEXT: ret i32 [[X:%.*]]
; ;
%Z = sub i32 %X, %Y %Z = sub i32 %X, %Y
%Q = add i32 %Z, %Y %Q = add i32 %Z, %Y
ret i32 %Q ret i32 %Q
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/addsub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @test1(i1 %a) { define i1 @test1(i1 %a) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%b = xor i1 %a, true %b = xor i1 %a, true
%res = sub i1 %a, %b %res = sub i1 %a, %b
ret i1 %res ret i1 %res
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/and-icmps-same-ops.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; There are 10 * 10 combinations of icmp predicates that can be AND'd together. ; There are 10 * 10 combinations of icmp predicates that can be AND'd together.
; The majority of these can be simplified to always false or just one of the icmps. ; The majority of these can be simplified to always false or just one of the icmps.
define i1 @eq_eq(i8 %a, i8 %b) { define i1 @eq_eq(i8 %a, i8 %b) {
; CHECK-LABEL: @eq_eq( ; CHECK-LABEL: @eq_eq(
; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i8 %a, %b ; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i8 %a, %b
; CHECK-NEXT: ret i1 [[CMP1]] ; CHECK-NEXT: ret i1 [[CMP1]]
▲ Show 20 Lines • Show All 1,229 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/and-or-icmp-min-max.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; There are 12 basic patterns (or 6 with DeMorganized equivalent) with ; There are 12 basic patterns (or 6 with DeMorganized equivalent) with
; 2 (commute logic op) * ; 2 (commute logic op) *
; 2 (swap compare operands) * ; 2 (swap compare operands) *
; 2 (signed/unsigned) * ; 2 (signed/unsigned) *
; 2 (not of input operand) ; 2 (not of input operand)
; variations for a total of 192 tests. ; variations for a total of 192 tests.
▲ Show 20 Lines • Show All 2,663 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/and-or-icmp-nullptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; This is a specialization of generic folds for min/max values targeted to the ; This is a specialization of generic folds for min/max values targeted to the
; 'null' ptr constant. ; 'null' ptr constant.
; Related tests for non-pointer types should be included in another file. ; Related tests for non-pointer types should be included in another file.
; There are 6 basic patterns (or 3 with DeMorganized equivalent) with ; There are 6 basic patterns (or 3 with DeMorganized equivalent) with
; 2 (commute logic op) * ; 2 (commute logic op) *
; 2 (swap compare operands) * ; 2 (swap compare operands) *
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/and-or-icmp-zero.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; In the next 16 tests (4 commutes * 2 (and/or) * 2 optional ptrtoint casts), ; In the next 16 tests (4 commutes * 2 (and/or) * 2 optional ptrtoint casts),
; eliminate the simple (not) null check because that compare is implied by the ; eliminate the simple (not) null check because that compare is implied by the
; masked compare of the same operand. ; masked compare of the same operand.
; Vary types between scalar and vector and weird for extra coverage. ; Vary types between scalar and vector and weird for extra coverage.
; or (icmp eq (and X, ?), 0), (icmp eq X, 0) --> icmp eq (and X, ?), 0 ; or (icmp eq (and X, ?), 0), (icmp eq X, 0) --> icmp eq (and X, ?), 0
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/and.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @poison(i32 %x) { define i32 @poison(i32 %x) {
; CHECK-LABEL: @poison( ; CHECK-LABEL: @poison(
; CHECK-NEXT: ret i32 poison ; CHECK-NEXT: ret i32 poison
; ;
%v = and i32 %x, poison %v = and i32 %x, poison
ret i32 %v ret i32 %v
} }
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/assume-non-zero.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @llvm.assume(i1) #1 declare void @llvm.assume(i1) #1
define i1 @nonnull0_true(i8* %x) { define i1 @nonnull0_true(i8* %x) {
; CHECK-LABEL: @nonnull0_true( ; CHECK-LABEL: @nonnull0_true(
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/assume_icmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare void @use(i1) declare void @use(i1)
define void @basic_ugt(i32 %x, i32 %y) { define void @basic_ugt(i32 %x, i32 %y) {
; CHECK-LABEL: @basic_ugt( ; CHECK-LABEL: @basic_ugt(
; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP1]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP1]])
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/bitcast-vector-fold.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-f64:32:64-v64:64:64-v128:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-f64:32:64-v64:64:64-v128:128:128"
define <2 x i64> @test1() { define <2 x i64> @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret <2 x i64> <i64 4294967296, i64 12884901890> ; CHECK-NEXT: ret <2 x i64> <i64 4294967296, i64 12884901890>
; ;
%tmp3 = bitcast <4 x i32> < i32 0, i32 1, i32 2, i32 3 > to <2 x i64> %tmp3 = bitcast <4 x i32> < i32 0, i32 1, i32 2, i32 3 > to <2 x i64>
ret <2 x i64> %tmp3 ret <2 x i64> %tmp3
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/bitreverse-fold.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @identity_bitreverse_i32(i32 %p) { define i32 @identity_bitreverse_i32(i32 %p) {
; CHECK-LABEL: @identity_bitreverse_i32( ; CHECK-LABEL: @identity_bitreverse_i32(
; CHECK-NEXT: ret i32 %p ; CHECK-NEXT: ret i32 %p
%a = call i32 @llvm.bitreverse.i32(i32 %p) %a = call i32 @llvm.bitreverse.i32(i32 %p)
%b = call i32 @llvm.bitreverse.i32(i32 %a) %b = call i32 @llvm.bitreverse.i32(i32 %a)
ret i32 %b ret i32 %b
} }
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/bitreverse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -instsimplify | FileCheck %s ; RUN: opt < %s -S -passes=instsimplify | FileCheck %s
declare i32 @llvm.bitreverse.i32(i32) declare i32 @llvm.bitreverse.i32(i32)
declare <2 x i32> @llvm.bitreverse.v2i32(<2 x i32>) declare <2 x i32> @llvm.bitreverse.v2i32(<2 x i32>)
define i1 @test1(i32 %arg) { define i1 @test1(i32 %arg) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/bswap.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -instsimplify | FileCheck %s ; RUN: opt < %s -S -passes=instsimplify | FileCheck %s
declare i16 @llvm.bswap.i16(i16) declare i16 @llvm.bswap.i16(i16)
declare <2 x i16> @llvm.bswap.v2i16(<2 x i16>) declare <2 x i16> @llvm.bswap.v2i16(<2 x i16>)
define i1 @test1(i16 %arg) { define i1 @test1(i16 %arg) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/call.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; RUN: opt < %s -passes=instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare {i8, i1} @llvm.uadd.with.overflow.i8(i8 %a, i8 %b) declare {i8, i1} @llvm.uadd.with.overflow.i8(i8 %a, i8 %b)
declare {i8, i1} @llvm.sadd.with.overflow.i8(i8 %a, i8 %b) declare {i8, i1} @llvm.sadd.with.overflow.i8(i8 %a, i8 %b)
declare {i8, i1} @llvm.usub.with.overflow.i8(i8 %a, i8 %b) declare {i8, i1} @llvm.usub.with.overflow.i8(i8 %a, i8 %b)
declare {i8, i1} @llvm.ssub.with.overflow.i8(i8 %a, i8 %b) declare {i8, i1} @llvm.ssub.with.overflow.i8(i8 %a, i8 %b)
declare {i8, i1} @llvm.umul.with.overflow.i8(i8 %a, i8 %b) declare {i8, i1} @llvm.umul.with.overflow.i8(i8 %a, i8 %b)
declare {i8, i1} @llvm.smul.with.overflow.i8(i8 %a, i8 %b) declare {i8, i1} @llvm.smul.with.overflow.i8(i8 %a, i8 %b)
▲ Show 20 Lines • Show All 1,555 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/cast-unsigned-icmp-cmp-0.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; This is related to https://bugs.llvm.org/show_bug.cgi?id=36682 ; This is related to https://bugs.llvm.org/show_bug.cgi?id=36682
; All of these can be simplified to a constant true or false value. ; All of these can be simplified to a constant true or false value.
; * slt i32 %b, 0 -> false ; * slt i32 %b, 0 -> false
; * sgt i32 %b, -1 -> true ; * sgt i32 %b, -1 -> true
define i1 @i32_cast_cmp_slt_int_0_uitofp_float(i32 %i) { define i1 @i32_cast_cmp_slt_int_0_uitofp_float(i32 %i) {
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/cast.ll

; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
target datalayout = "p:32:32" target datalayout = "p:32:32"
define i1 @test1(i1 %V) { define i1 @test1(i1 %V) {
entry: entry:
%Z = zext i1 %V to i32 %Z = zext i1 %V to i32
%T = trunc i32 %Z to i1 %T = trunc i32 %Z to i1
ret i1 %T ret i1 %T
; CHECK-LABEL: define i1 @test1( ; CHECK-LABEL: define i1 @test1(
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/cmp-vec-fast-path.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Check that cmp's of scalable vector splats are simplified ; Check that cmp's of scalable vector splats are simplified
; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
define <2 x i1> @i32cmp_eq_fixed_zero() { define <2 x i1> @i32cmp_eq_fixed_zero() {
; CHECK-LABEL: @i32cmp_eq_fixed_zero( ; CHECK-LABEL: @i32cmp_eq_fixed_zero(
; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true> ; CHECK-NEXT: ret <2 x i1> <i1 true, i1 true>
; ;
%res = icmp eq <2 x i32> zeroinitializer, zeroinitializer %res = icmp eq <2 x i32> zeroinitializer, zeroinitializer
ret <2 x i1> %res ret <2 x i1> %res
} }
▲ Show 20 Lines • Show All 825 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/cmp_ext.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @zext_uge_sext(i32 %x) { define i1 @zext_uge_sext(i32 %x) {
; CHECK-LABEL: @zext_uge_sext( ; CHECK-LABEL: @zext_uge_sext(
; CHECK-NEXT: [[SEXT:%.*]] = sext i32 [[X:%.*]] to i64 ; CHECK-NEXT: [[SEXT:%.*]] = sext i32 [[X:%.*]] to i64
; CHECK-NEXT: [[ZEXT:%.*]] = zext i32 [[X]] to i64 ; CHECK-NEXT: [[ZEXT:%.*]] = zext i32 [[X]] to i64
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i64 [[ZEXT]], [[SEXT]] ; CHECK-NEXT: [[CMP:%.*]] = icmp uge i64 [[ZEXT]], [[SEXT]]
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/cmp_of_min_max.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @test_umax1(i32 %n) { define i1 @test_umax1(i32 %n) {
; CHECK-LABEL: @test_umax1( ; CHECK-LABEL: @test_umax1(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%c1 = icmp ugt i32 %n, 10 %c1 = icmp ugt i32 %n, 10
%s = select i1 %c1, i32 %n, i32 10 %s = select i1 %c1, i32 %n, i32 10
%c2 = icmp ugt i32 %s, 9 %c2 = icmp ugt i32 %s, 9
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/compare.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "p:32:32-p1:64:64" target datalayout = "p:32:32-p1:64:64"
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define i1 @ptrtoint() { define i1 @ptrtoint() {
; CHECK-LABEL: @ptrtoint( ; CHECK-LABEL: @ptrtoint(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
▲ Show 20 Lines • Show All 2,693 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/constantfold-add-nuw-allones-to-allones.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; %ret = add nuw i8 %x, C ; %ret = add nuw i8 %x, C
; nuw means no unsigned wrap, from -1 to 0. ; nuw means no unsigned wrap, from -1 to 0.
; So if C is -1, %x can only be 0, and the result is always -1. ; So if C is -1, %x can only be 0, and the result is always -1.
define i8 @add_nuw (i8 %x) { define i8 @add_nuw (i8 %x) {
; CHECK-LABEL: @add_nuw( ; CHECK-LABEL: @add_nuw(
; CHECK-NEXT: ret i8 -1 ; CHECK-NEXT: ret i8 -1
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/constantfold-shl-nuw-C-to-C.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; %r = shl nuw i8 C, %x ; %r = shl nuw i8 C, %x
; As per langref: If the nuw keyword is present, then the shift produces ; As per langref: If the nuw keyword is present, then the shift produces
; a poison value if it shifts out any non-zero bits. ; a poison value if it shifts out any non-zero bits.
; Thus, if the sign bit is set on C, then %x can only be 0, which means that ; Thus, if the sign bit is set on C, then %x can only be 0, which means that
; %r can only be C. ; %r can only be C.
define i8 @shl_nuw (i8 %x) { define i8 @shl_nuw (i8 %x) {
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/constfold-constrained.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Verify that floor(10.1) is folded to 10.0 when the exception behavior is 'ignore'. ; Verify that floor(10.1) is folded to 10.0 when the exception behavior is 'ignore'.
define double @floor_01() #0 { define double @floor_01() #0 {
; CHECK-LABEL: @floor_01( ; CHECK-LABEL: @floor_01(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret double 1.000000e+01 ; CHECK-NEXT: ret double 1.000000e+01
; ;
▲ Show 20 Lines • Show All 538 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/dead-code-removal.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
define void @foo() nounwind { define void @foo() nounwind {
br i1 undef, label %1, label %4 br i1 undef, label %1, label %4
; <label>:1 ; preds = %1, %0 ; <label>:1 ; preds = %1, %0
; CHECK-NOT: phi ; CHECK-NOT: phi
; CHECK-NOT: sub ; CHECK-NOT: sub
%2 = phi i32 [ %3, %1 ], [ undef, %0 ] %2 = phi i32 [ %3, %1 ], [ undef, %0 ]
%3 = sub i32 0, undef %3 = sub i32 0, undef
br label %1 br label %1
; <label>:4 ; preds = %0 ; <label>:4 ; preds = %0
ret void ret void
} }

llvm/test/Transforms/InstSimplify/distribute.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; %result = x & (1 ^ sel) = (x & 1) ^ (x & sel) ; %result = x & (1 ^ sel) = (x & 1) ^ (x & sel)
; = x ^ (select cond, false, false) ; = x ^ (select cond, false, false)
; = x ^ false = x ; = x ^ false = x
; ;
define i1 @f(i1 %cond, i1 noundef %x, i1 %y, i1 %z) { define i1 @f(i1 %cond, i1 noundef %x, i1 %y, i1 %z) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: ret i1 [[X:%.*]] ; CHECK-NEXT: ret i1 [[X:%.*]]
Show All 22 Lines

llvm/test/Transforms/InstSimplify/div-by-0-guard-before-smul_ov-not.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
declare { i4, i1 } @llvm.smul.with.overflow.i4(i4, i4) #1 declare { i4, i1 } @llvm.smul.with.overflow.i4(i4, i4) #1
define i1 @t0_umul(i4 %size, i4 %nmemb) { define i1 @t0_umul(i4 %size, i4 %nmemb) {
; CHECK-LABEL: @t0_umul( ; CHECK-LABEL: @t0_umul(
; CHECK-NEXT: [[SMUL:%.*]] = tail call { i4, i1 } @llvm.smul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]]) ; CHECK-NEXT: [[SMUL:%.*]] = tail call { i4, i1 } @llvm.smul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]])
; CHECK-NEXT: [[SMUL_OV:%.*]] = extractvalue { i4, i1 } [[SMUL]], 1 ; CHECK-NEXT: [[SMUL_OV:%.*]] = extractvalue { i4, i1 } [[SMUL]], 1
; CHECK-NEXT: [[PHITMP:%.*]] = xor i1 [[SMUL_OV]], true ; CHECK-NEXT: [[PHITMP:%.*]] = xor i1 [[SMUL_OV]], true
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/div-by-0-guard-before-smul_ov.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
declare { i4, i1 } @llvm.smul.with.overflow.i4(i4, i4) #1 declare { i4, i1 } @llvm.smul.with.overflow.i4(i4, i4) #1
define i1 @t0_smul(i4 %size, i4 %nmemb) { define i1 @t0_smul(i4 %size, i4 %nmemb) {
; CHECK-LABEL: @t0_smul( ; CHECK-LABEL: @t0_smul(
; CHECK-NEXT: [[SMUL:%.*]] = tail call { i4, i1 } @llvm.smul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]]) ; CHECK-NEXT: [[SMUL:%.*]] = tail call { i4, i1 } @llvm.smul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]])
; CHECK-NEXT: [[SMUL_OV:%.*]] = extractvalue { i4, i1 } [[SMUL]], 1 ; CHECK-NEXT: [[SMUL_OV:%.*]] = extractvalue { i4, i1 } [[SMUL]], 1
; CHECK-NEXT: ret i1 [[SMUL_OV]] ; CHECK-NEXT: ret i1 [[SMUL_OV]]
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/div-by-0-guard-before-umul_ov-not.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
declare { i4, i1 } @llvm.umul.with.overflow.i4(i4, i4) #1 declare { i4, i1 } @llvm.umul.with.overflow.i4(i4, i4) #1
define i1 @t0_umul(i4 %size, i4 %nmemb) { define i1 @t0_umul(i4 %size, i4 %nmemb) {
; CHECK-LABEL: @t0_umul( ; CHECK-LABEL: @t0_umul(
; CHECK-NEXT: [[UMUL:%.*]] = tail call { i4, i1 } @llvm.umul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]]) ; CHECK-NEXT: [[UMUL:%.*]] = tail call { i4, i1 } @llvm.umul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]])
; CHECK-NEXT: [[UMUL_OV:%.*]] = extractvalue { i4, i1 } [[UMUL]], 1 ; CHECK-NEXT: [[UMUL_OV:%.*]] = extractvalue { i4, i1 } [[UMUL]], 1
; CHECK-NEXT: [[PHITMP:%.*]] = xor i1 [[UMUL_OV]], true ; CHECK-NEXT: [[PHITMP:%.*]] = xor i1 [[UMUL_OV]], true
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/div-by-0-guard-before-umul_ov.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
declare { i4, i1 } @llvm.umul.with.overflow.i4(i4, i4) #1 declare { i4, i1 } @llvm.umul.with.overflow.i4(i4, i4) #1
define i1 @t0_umul(i4 %size, i4 %nmemb) { define i1 @t0_umul(i4 %size, i4 %nmemb) {
; CHECK-LABEL: @t0_umul( ; CHECK-LABEL: @t0_umul(
; CHECK-NEXT: [[UMUL:%.*]] = tail call { i4, i1 } @llvm.umul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]]) ; CHECK-NEXT: [[UMUL:%.*]] = tail call { i4, i1 } @llvm.umul.with.overflow.i4(i4 [[SIZE:%.*]], i4 [[NMEMB:%.*]])
; CHECK-NEXT: [[UMUL_OV:%.*]] = extractvalue { i4, i1 } [[UMUL]], 1 ; CHECK-NEXT: [[UMUL_OV:%.*]] = extractvalue { i4, i1 } [[UMUL]], 1
; CHECK-NEXT: ret i1 [[UMUL_OV]] ; CHECK-NEXT: ret i1 [[UMUL_OV]]
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/div.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @zero_dividend(i32 %A) { define i32 @zero_dividend(i32 %A) {
; CHECK-LABEL: @zero_dividend( ; CHECK-LABEL: @zero_dividend(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%B = sdiv i32 0, %A %B = sdiv i32 0, %A
ret i32 %B ret i32 %B
} }
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/exact-nsw-nuw.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; PR8862 ; PR8862
define i32 @shift1(i32 %A, i32 %B) { define i32 @shift1(i32 %A, i32 %B) {
; CHECK-LABEL: @shift1( ; CHECK-LABEL: @shift1(
; CHECK-NEXT: ret i32 %A ; CHECK-NEXT: ret i32 %A
; ;
%C = lshr exact i32 %A, %B %C = lshr exact i32 %A, %B
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/extract-element.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Weird Types ; Weird Types
define i129 @vec_extract_negidx(<3 x i129> %a) { define i129 @vec_extract_negidx(<3 x i129> %a) {
; CHECK-LABEL: @vec_extract_negidx( ; CHECK-LABEL: @vec_extract_negidx(
; CHECK-NEXT: ret i129 poison ; CHECK-NEXT: ret i129 poison
; ;
%E1 = extractelement <3 x i129> %a, i129 -1 %E1 = extractelement <3 x i129> %a, i129 -1
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/extract-vector.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <16 x i8> @redundant_insert_extract_chain(<16 x i8> %x) { define <16 x i8> @redundant_insert_extract_chain(<16 x i8> %x) {
; CHECK-LABEL: @redundant_insert_extract_chain( ; CHECK-LABEL: @redundant_insert_extract_chain(
; CHECK-NEXT: ret <16 x i8> [[X:%.*]] ; CHECK-NEXT: ret <16 x i8> [[X:%.*]]
; ;
%inserted = call <vscale x 32 x i8> @llvm.experimental.vector.insert.nxv32i8.v16i8(<vscale x 32 x i8> undef, <16 x i8> %x, i64 0) %inserted = call <vscale x 32 x i8> @llvm.experimental.vector.insert.nxv32i8.v16i8(<vscale x 32 x i8> undef, <16 x i8> %x, i64 0)
%extracted = call <16 x i8> @llvm.experimental.vector.extract.v16i8.nxv32i8(<vscale x 32 x i8> %inserted, i64 0) %extracted = call <16 x i8> @llvm.experimental.vector.extract.v16i8.nxv32i8(<vscale x 32 x i8> %inserted, i64 0)
ret <16 x i8> %extracted ret <16 x i8> %extracted
Show All 16 Lines

llvm/test/Transforms/InstSimplify/fast-math-strictfp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
;; x * 0 ==> 0 when no-nans and no-signed-zero ;; x * 0 ==> 0 when no-nans and no-signed-zero
define float @mul_zero_1(float %a) #0 { define float @mul_zero_1(float %a) #0 {
; CHECK-LABEL: @mul_zero_1( ; CHECK-LABEL: @mul_zero_1(
; CHECK-NEXT: ret float 0.000000e+00 ; CHECK-NEXT: ret float 0.000000e+00
; ;
%b = call nsz nnan float @llvm.experimental.constrained.fmul.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0 %b = call nsz nnan float @llvm.experimental.constrained.fmul.f32(float %a, float 0.0, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
ret float %b ret float %b
▲ Show 20 Lines • Show All 572 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fast-math.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
;; x * 0 ==> 0 when no-nans and no-signed-zero ;; x * 0 ==> 0 when no-nans and no-signed-zero
define float @mul_zero_1(float %a) { define float @mul_zero_1(float %a) {
; CHECK-LABEL: @mul_zero_1( ; CHECK-LABEL: @mul_zero_1(
; CHECK-NEXT: ret float 0.000000e+00 ; CHECK-NEXT: ret float 0.000000e+00
; ;
%b = fmul nsz nnan float %a, 0.0 %b = fmul nsz nnan float %a, 0.0
ret float %b ret float %b
▲ Show 20 Lines • Show All 520 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fcmp-select.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; X == 42.0 ? X : 42.0 --> 42.0 ; X == 42.0 ? X : 42.0 --> 42.0
define double @oeq(double %x) { define double @oeq(double %x) {
; CHECK-LABEL: @oeq( ; CHECK-LABEL: @oeq(
; CHECK-NEXT: ret double 4.200000e+01 ; CHECK-NEXT: ret double 4.200000e+01
; ;
%cmp = fcmp oeq double %x, 42.0 %cmp = fcmp oeq double %x, 42.0
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fcmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @poison(float %x) { define i1 @poison(float %x) {
; CHECK-LABEL: @poison( ; CHECK-LABEL: @poison(
; CHECK-NEXT: ret i1 poison ; CHECK-NEXT: ret i1 poison
; ;
%v = fcmp oeq float %x, poison %v = fcmp oeq float %x, poison
ret i1 %v ret i1 %v
} }
define i1 @poison2(float %x) { define i1 @poison2(float %x) {
; CHECK-LABEL: @poison2( ; CHECK-LABEL: @poison2(
; CHECK-NEXT: ret i1 poison ; CHECK-NEXT: ret i1 poison
; ;
%v = fcmp ueq float %x, poison %v = fcmp ueq float %x, poison
ret i1 %v ret i1 %v
} }

llvm/test/Transforms/InstSimplify/fdiv-strictfp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define float @fdiv_constant_fold() #0 { define float @fdiv_constant_fold() #0 {
; CHECK-LABEL: @fdiv_constant_fold( ; CHECK-LABEL: @fdiv_constant_fold(
; CHECK-NEXT: ret float 1.500000e+00 ; CHECK-NEXT: ret float 1.500000e+00
; ;
%f = call float @llvm.experimental.constrained.fdiv.f32(float 3.0, float 2.0, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0 %f = call float @llvm.experimental.constrained.fdiv.f32(float 3.0, float 2.0, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
ret float %f ret float %f
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fdiv.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define float @fdiv_constant_fold() { define float @fdiv_constant_fold() {
; CHECK-LABEL: @fdiv_constant_fold( ; CHECK-LABEL: @fdiv_constant_fold(
; CHECK-NEXT: ret float 1.500000e+00 ; CHECK-NEXT: ret float 1.500000e+00
; ;
%f = fdiv float 3.0, 2.0 %f = fdiv float 3.0, 2.0
ret float %f ret float %f
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/floating-point-arithmetic-strictfp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; fneg (fsub -0.0, X) ==> X ; fneg (fsub -0.0, X) ==> X
define float @fsub_-0_x(float %a) #0 { define float @fsub_-0_x(float %a) #0 {
; CHECK-LABEL: @fsub_-0_x( ; CHECK-LABEL: @fsub_-0_x(
; CHECK-NEXT: [[T1:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float -0.000000e+00, float [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0:[0-9]+]] ; CHECK-NEXT: [[T1:%.*]] = call float @llvm.experimental.constrained.fsub.f32(float -0.000000e+00, float [[A:%.*]], metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0:[0-9]+]]
; CHECK-NEXT: [[RET:%.*]] = fneg float [[T1]] ; CHECK-NEXT: [[RET:%.*]] = fneg float [[T1]]
; CHECK-NEXT: ret float [[RET]] ; CHECK-NEXT: ret float [[RET]]
; ;
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/floating-point-arithmetic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; fneg (fneg X) ==> X ; fneg (fneg X) ==> X
define float @fneg_fneg_var(float %a) { define float @fneg_fneg_var(float %a) {
; CHECK-LABEL: @fneg_fneg_var( ; CHECK-LABEL: @fneg_fneg_var(
; CHECK-NEXT: ret float [[A:%.*]] ; CHECK-NEXT: ret float [[A:%.*]]
; ;
%r = fneg float %a %r = fneg float %a
%r1 = fneg float %r %r1 = fneg float %r
▲ Show 20 Lines • Show All 751 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/floating-point-compare.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Infinity ; Infinity
define i1 @inf0(double %arg) { define i1 @inf0(double %arg) {
; CHECK-LABEL: @inf0( ; CHECK-LABEL: @inf0(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%tmp = fcmp ogt double %arg, 0x7FF0000000000000 %tmp = fcmp ogt double %arg, 0x7FF0000000000000
▲ Show 20 Lines • Show All 1,222 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fminmax-folds.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.minnum.f32(float, float) declare float @llvm.minnum.f32(float, float)
declare float @llvm.maxnum.f32(float, float) declare float @llvm.maxnum.f32(float, float)
declare float @llvm.minimum.f32(float, float) declare float @llvm.minimum.f32(float, float)
declare float @llvm.maximum.f32(float, float) declare float @llvm.maximum.f32(float, float)
declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>) declare <2 x float> @llvm.minnum.v2f32(<2 x float>, <2 x float>)
declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>) declare <2 x float> @llvm.maxnum.v2f32(<2 x float>, <2 x float>)
declare <2 x float> @llvm.minimum.v2f32(<2 x float>, <2 x float>) declare <2 x float> @llvm.minimum.v2f32(<2 x float>, <2 x float>)
▲ Show 20 Lines • Show All 1,191 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fold-intrinsics.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare float @llvm.powi.f32.i16(float, i16) nounwind readonly declare float @llvm.powi.f32.i16(float, i16) nounwind readonly
declare double @llvm.powi.f64.i32(double, i32) nounwind readonly declare double @llvm.powi.f64.i32(double, i32) nounwind readonly
declare i32 @llvm.bswap.i32(i32) declare i32 @llvm.bswap.i32(i32)
; A ; A
define i32 @test_bswap(i32 %a) nounwind { define i32 @test_bswap(i32 %a) nounwind {
; CHECK-LABEL: @test_bswap( ; CHECK-LABEL: @test_bswap(
Show All 32 Lines

llvm/test/Transforms/InstSimplify/fold-vscale.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i64 @vscale_i64_range_none() #0 { define i64 @vscale_i64_range_none() #0 {
; CHECK-LABEL: @vscale_i64_range_none( ; CHECK-LABEL: @vscale_i64_range_none(
; CHECK-NEXT: [[OUT:%.*]] = call i64 @llvm.vscale.i64() ; CHECK-NEXT: [[OUT:%.*]] = call i64 @llvm.vscale.i64()
; CHECK-NEXT: ret i64 [[OUT]] ; CHECK-NEXT: ret i64 [[OUT]]
; ;
%out = call i64 @llvm.vscale.i64() %out = call i64 @llvm.vscale.i64()
ret i64 %out ret i64 %out
Show All 39 Lines

llvm/test/Transforms/InstSimplify/fp-nan.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Default NaN constant ; Default NaN constant
define double @fadd_nan_op0(double %x) { define double @fadd_nan_op0(double %x) {
; CHECK-LABEL: @fadd_nan_op0( ; CHECK-LABEL: @fadd_nan_op0(
; CHECK-NEXT: ret double 0x7FF8000000000000 ; CHECK-NEXT: ret double 0x7FF8000000000000
; ;
%r = fadd double 0x7FF8000000000000, %x %r = fadd double 0x7FF8000000000000, %x
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fp-undef-poison-strictfp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; TODO: the instructions with poison operands should return poison ; TODO: the instructions with poison operands should return poison
; ;
; constrained fadd ; constrained fadd
; ;
define float @fadd_undef_op0_strict(float %x) #0 { define float @fadd_undef_op0_strict(float %x) #0 {
▲ Show 20 Lines • Show All 911 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fp-undef-poison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define float @fadd_undef_op0(float %x) { define float @fadd_undef_op0(float %x) {
; CHECK-LABEL: @fadd_undef_op0( ; CHECK-LABEL: @fadd_undef_op0(
; CHECK-NEXT: ret float 0x7FF8000000000000 ; CHECK-NEXT: ret float 0x7FF8000000000000
; ;
%r = fadd float undef, %x %r = fadd float undef, %x
ret float %r ret float %r
} }
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fptoi-range.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
define i1 @f16_si_max1(half %f) { define i1 @f16_si_max1(half %f) {
; CHECK-LABEL: @f16_si_max1( ; CHECK-LABEL: @f16_si_max1(
; CHECK-NEXT: [[I:%.*]] = fptosi half [[F:%.*]] to i32 ; CHECK-NEXT: [[I:%.*]] = fptosi half [[F:%.*]] to i32
; CHECK-NEXT: [[C:%.*]] = icmp sge i32 [[I]], 65504 ; CHECK-NEXT: [[C:%.*]] = icmp sge i32 [[I]], 65504
; CHECK-NEXT: ret i1 [[C]] ; CHECK-NEXT: ret i1 [[C]]
; ;
%i = fptosi half %f to i32 %i = fptosi half %f to i32
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/fptoi-sat.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
declare i32 @llvm.fptosi.sat.i32.f64(double) declare i32 @llvm.fptosi.sat.i32.f64(double)
declare i32 @llvm.fptoui.sat.i32.f64(double) declare i32 @llvm.fptoui.sat.i32.f64(double)
declare i32 @llvm.fptosi.sat.i32.f32(float) declare i32 @llvm.fptosi.sat.i32.f32(float)
declare i32 @llvm.fptoui.sat.i32.f32(float) declare i32 @llvm.fptoui.sat.i32.f32(float)
declare <2 x i32> @llvm.fptosi.sat.v2i32.v2f64(<2 x double>) declare <2 x i32> @llvm.fptosi.sat.v2i32.v2f64(<2 x double>)
declare <2 x i32> @llvm.fptoui.sat.v2i32.v2f64(<2 x double>) declare <2 x i32> @llvm.fptoui.sat.v2i32.v2f64(<2 x double>)
▲ Show 20 Lines • Show All 602 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/freeze-noundef.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i8 @noundef(i8 noundef %x) { define i8 @noundef(i8 noundef %x) {
; CHECK-LABEL: @noundef( ; CHECK-LABEL: @noundef(
; CHECK-NEXT: ret i8 [[X:%.*]] ; CHECK-NEXT: ret i8 [[X:%.*]]
; ;
%y = freeze i8 %x %y = freeze i8 %x
ret i8 %y ret i8 %y
} }
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/freeze.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @fold(i32 %x) { define i32 @fold(i32 %x) {
; CHECK-LABEL: @fold( ; CHECK-LABEL: @fold(
; CHECK-NEXT: [[Y:%.*]] = freeze i32 [[X:%.*]] ; CHECK-NEXT: [[Y:%.*]] = freeze i32 [[X:%.*]]
; CHECK-NEXT: ret i32 [[Y]] ; CHECK-NEXT: ret i32 [[Y]]
; ;
%y = freeze i32 %x %y = freeze i32 %x
%z = freeze i32 %y %z = freeze i32 %y
▲ Show 20 Lines • Show All 496 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/gc_relocate.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
declare void @func() declare void @func()
define void @dead_relocate(i32 addrspace(1)* %in) gc "statepoint-example" { define void @dead_relocate(i32 addrspace(1)* %in) gc "statepoint-example" {
; CHECK-LABEL: @dead_relocate( ; CHECK-LABEL: @dead_relocate(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) @func, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[IN:%.*]]) ] ; CHECK-NEXT: [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* elementtype(void ()) @func, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[IN:%.*]]) ]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 9 Lines

llvm/test/Transforms/InstSimplify/gep.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
%struct.A = type { [7 x i8] } %struct.A = type { [7 x i8] }
define %struct.A* @test1(%struct.A* %b, %struct.A* %e) { define %struct.A* @test1(%struct.A* %b, %struct.A* %e) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[E_PTR:%.*]] = ptrtoint %struct.A* [[E:%.*]] to i64 ; CHECK-NEXT: [[E_PTR:%.*]] = ptrtoint %struct.A* [[E:%.*]] to i64
▲ Show 20 Lines • Show All 350 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/icmp-abs-nabs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; This is canonical form for this IR. ; This is canonical form for this IR.
define i1 @abs_nsw_is_positive(i32 %x) { define i1 @abs_nsw_is_positive(i32 %x) {
; CHECK-LABEL: @abs_nsw_is_positive( ; CHECK-LABEL: @abs_nsw_is_positive(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%cmp = icmp slt i32 %x, 0 %cmp = icmp slt i32 %x, 0
▲ Show 20 Lines • Show All 410 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/icmp-bool-constant.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Test all integer predicates with bool types and true/false constants. ; Test all integer predicates with bool types and true/false constants.
; Use vectors to provide test coverage that is not duplicated in other folds. ; Use vectors to provide test coverage that is not duplicated in other folds.
define <2 x i1> @eq_t(<2 x i1> %a) { define <2 x i1> @eq_t(<2 x i1> %a) {
; CHECK-LABEL: @eq_t( ; CHECK-LABEL: @eq_t(
; CHECK-NEXT: ret <2 x i1> %a ; CHECK-NEXT: ret <2 x i1> %a
; ;
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/icmp-constant.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Fold icmp with a constant operand. ; Fold icmp with a constant operand.
define i1 @tautological_ule(i8 %x) { define i1 @tautological_ule(i8 %x) {
; CHECK-LABEL: @tautological_ule( ; CHECK-LABEL: @tautological_ule(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%cmp = icmp ule i8 %x, 255 %cmp = icmp ule i8 %x, 255
▲ Show 20 Lines • Show All 1,132 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/icmp-not-bool-constant.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Test all integer predicates with bool types and true/false constants, ; Test all integer predicates with bool types and true/false constants,
; with not on LHS (icmp pred not(X), true|false). ; with not on LHS (icmp pred not(X), true|false).
; Use vectors to provide test coverage that is not duplicated in other folds. ; Use vectors to provide test coverage that is not duplicated in other folds.
define <2 x i1> @eq_t_not(<2 x i1> %a) { define <2 x i1> @eq_t_not(<2 x i1> %a) {
; CHECK-LABEL: @eq_t_not( ; CHECK-LABEL: @eq_t_not(
; CHECK-NEXT: [[NOT:%.*]] = xor <2 x i1> [[A:%.*]], <i1 true, i1 true> ; CHECK-NEXT: [[NOT:%.*]] = xor <2 x i1> [[A:%.*]], <i1 true, i1 true>
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/icmp-ranges.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Cycle through all pairs of predicates to test ; Cycle through all pairs of predicates to test
; simplification of range-intersection or range-union. ; simplification of range-intersection or range-union.
; eq ; eq
; x == 13 && x == 17 ; x == 13 && x == 17
define i1 @and_eq_eq(i8 %x) { define i1 @and_eq_eq(i8 %x) {
▲ Show 20 Lines • Show All 5,461 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/icmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
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" 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"
declare void @usei8ptr(i8* %ptr) declare void @usei8ptr(i8* %ptr)
; Ensure that we do not crash when looking at such a weird bitcast. ; Ensure that we do not crash when looking at such a weird bitcast.
define i1 @bitcast_from_single_element_pointer_vector_to_pointer(<1 x i8*> %ptr1vec, i8* %ptr2) { define i1 @bitcast_from_single_element_pointer_vector_to_pointer(<1 x i8*> %ptr1vec, i8* %ptr2) {
; CHECK-LABEL: @bitcast_from_single_element_pointer_vector_to_pointer( ; CHECK-LABEL: @bitcast_from_single_element_pointer_vector_to_pointer(
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/implies.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt -S %s -instsimplify | FileCheck %s ; RUN: opt -S %s -passes=instsimplify | FileCheck %s
; A ==> A -> true ; A ==> A -> true
define i1 @test(i32 %length.i, i32 %i) { define i1 @test(i32 %length.i, i32 %i) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: ret i1 true ; CHECK: ret i1 true
; ;
%var29 = icmp slt i32 %i, %length.i %var29 = icmp slt i32 %i, %length.i
%res = icmp uge i1 %var29, %var29 %res = icmp uge i1 %var29, %var29
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/insert-vector.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <vscale x 16 x i8> @redundant_extract_insert_chain(<vscale x 16 x i8> %x) { define <vscale x 16 x i8> @redundant_extract_insert_chain(<vscale x 16 x i8> %x) {
; CHECK-LABEL: @redundant_extract_insert_chain( ; CHECK-LABEL: @redundant_extract_insert_chain(
; CHECK-NEXT: ret <vscale x 16 x i8> [[X:%.*]] ; CHECK-NEXT: ret <vscale x 16 x i8> [[X:%.*]]
; ;
%extracted = call <32 x i8> @llvm.experimental.vector.extract.v32i8.nxv16i8(<vscale x 16 x i8> %x, i64 0) %extracted = call <32 x i8> @llvm.experimental.vector.extract.v32i8.nxv16i8(<vscale x 16 x i8> %x, i64 0)
%inserted = call <vscale x 16 x i8> @llvm.experimental.vector.insert.nxv16i8.v32i8(<vscale x 16 x i8> undef, <32 x i8> %extracted, i64 0) %inserted = call <vscale x 16 x i8> @llvm.experimental.vector.insert.nxv16i8.v32i8(<vscale x 16 x i8> undef, <32 x i8> %extracted, i64 0)
ret <vscale x 16 x i8> %inserted ret <vscale x 16 x i8> %inserted
Show All 27 Lines

llvm/test/Transforms/InstSimplify/insertelement.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
define <4 x i32> @test1(<4 x i32> %A) { define <4 x i32> @test1(<4 x i32> %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret <4 x i32> poison ; CHECK-NEXT: ret <4 x i32> poison
; ;
%I = insertelement <4 x i32> %A, i32 5, i64 4294967296 %I = insertelement <4 x i32> %A, i32 5, i64 4294967296
ret <4 x i32> %I ret <4 x i32> %I
} }
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/insertvalue.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define {i32, i32} @poison({i32, i32} %x) { define {i32, i32} @poison({i32, i32} %x) {
; CHECK-LABEL: @poison( ; CHECK-LABEL: @poison(
; CHECK-NEXT: ret { i32, i32 } [[X:%.*]] ; CHECK-NEXT: ret { i32, i32 } [[X:%.*]]
; ;
%v = insertvalue {i32, i32} %x, i32 poison, 0 %v = insertvalue {i32, i32} %x, i32 poison, 0
ret {i32, i32} %v ret {i32, i32} %v
} }
Show All 9 Lines

llvm/test/Transforms/InstSimplify/known-never-nan.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -instsimplify | FileCheck %s ; RUN: opt < %s -S -passes=instsimplify | FileCheck %s
declare double @func() declare double @func()
define i1 @nnan_call() { define i1 @nnan_call() {
; CHECK-LABEL: @nnan_call( ; CHECK-LABEL: @nnan_call(
; CHECK-NEXT: [[OP:%.*]] = call nnan double @func() ; CHECK-NEXT: [[OP:%.*]] = call nnan double @func()
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
▲ Show 20 Lines • Show All 419 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/known-non-zero-opaque-ptrs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify -opaque-pointers < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify -opaque-pointers < %s | FileCheck %s
declare void @zero_args() declare void @zero_args()
declare void @two_args(ptr, ptr) declare void @two_args(ptr, ptr)
; TODO: Could be non-null based on call-site attributes. ; TODO: Could be non-null based on call-site attributes.
define i1 @test_zero_args_nonnull(ptr %p) { define i1 @test_zero_args_nonnull(ptr %p) {
; CHECK-LABEL: @test_zero_args_nonnull( ; CHECK-LABEL: @test_zero_args_nonnull(
; CHECK-NEXT: call void @zero_args(ptr noundef nonnull [[P:%.*]]) ; CHECK-NEXT: call void @zero_args(ptr noundef nonnull [[P:%.*]])
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/known-non-zero.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i64 @test0(i64 %x) { define i64 @test0(i64 %x) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: start: ; CHECK-NEXT: start:
; CHECK-NEXT: [[A:%.*]] = icmp eq i64 [[X:%.*]], 0 ; CHECK-NEXT: [[A:%.*]] = icmp eq i64 [[X:%.*]], 0
; CHECK-NEXT: br i1 [[A]], label [[EXIT:%.*]], label [[NON_ZERO:%.*]] ; CHECK-NEXT: br i1 [[A]], label [[EXIT:%.*]], label [[NON_ZERO:%.*]]
; CHECK: non_zero: ; CHECK: non_zero:
; CHECK-NEXT: br i1 false, label [[UNREACHABLE:%.*]], label [[EXIT]] ; CHECK-NEXT: br i1 false, label [[UNREACHABLE:%.*]], label [[EXIT]]
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/load-relative-32.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
target triple = "i386-unknown-linux-gnu" target triple = "i386-unknown-linux-gnu"
@a = external global i8 @a = external global i8
@c1 = constant [3 x i32] [i32 0, i32 0, @c1 = constant [3 x i32] [i32 0, i32 0,
i32 sub (i32 ptrtoint (i8* @a to i32), i32 ptrtoint (i32* getelementptr ([3 x i32], [3 x i32]* @c1, i32 0, i32 2) to i32)) i32 sub (i32 ptrtoint (i8* @a to i32), i32 ptrtoint (i32* getelementptr ([3 x i32], [3 x i32]* @c1, i32 0, i32 2) to i32))
Show All 10 Lines

llvm/test/Transforms/InstSimplify/load-relative.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@a = external global i8 @a = external global i8
@b = external global i8 @b = external global i8
@c1 = constant i32 trunc (i64 sub (i64 ptrtoint (i8* @a to i64), i64 ptrtoint (i32* @c1 to i64)) to i32) @c1 = constant i32 trunc (i64 sub (i64 ptrtoint (i8* @a to i64), i64 ptrtoint (i32* @c1 to i64)) to i32)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
@zeroinit = constant {} zeroinitializer @zeroinit = constant {} zeroinitializer
@undef = constant {} undef @undef = constant {} undef
define i32 @crash_on_zeroinit() { define i32 @crash_on_zeroinit() {
; CHECK-LABEL: @crash_on_zeroinit( ; CHECK-LABEL: @crash_on_zeroinit(
; CHECK-NEXT: ret i32 undef ; CHECK-NEXT: ret i32 undef
; ;
Show All 32 Lines

llvm/test/Transforms/InstSimplify/log-exp-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
declare double @llvm.log.f64(double) declare double @llvm.log.f64(double)
declare double @llvm.exp.f64(double) declare double @llvm.exp.f64(double)
declare double @llvm.log2.f64(double) declare double @llvm.log2.f64(double)
declare double @llvm.exp2.f64(double) declare double @llvm.exp2.f64(double)
define double @log_reassoc_exp_strict(double %a) { define double @log_reassoc_exp_strict(double %a) {
; CHECK-LABEL: @log_reassoc_exp_strict( ; CHECK-LABEL: @log_reassoc_exp_strict(
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/log10-pow10-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
declare double @llvm.log10.f64(double) declare double @llvm.log10.f64(double)
declare double @llvm.pow.f64(double, double) declare double @llvm.pow.f64(double, double)
define double @log10_pow10(double %x) { define double @log10_pow10(double %x) {
; CHECK-LABEL: @log10_pow10( ; CHECK-LABEL: @log10_pow10(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.pow.f64(double 1.000000e+01, double [[X:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.pow.f64(double 1.000000e+01, double [[X:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log10.f64(double [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.log10.f64(double [[TMP1]])
Show All 35 Lines

llvm/test/Transforms/InstSimplify/log2-pow2-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
declare double @llvm.log2.f64(double) declare double @llvm.log2.f64(double)
declare double @llvm.pow.f64(double, double) declare double @llvm.pow.f64(double, double)
define double @log2_pow2(double %x) { define double @log2_pow2(double %x) {
; CHECK-LABEL: @log2_pow2( ; CHECK-LABEL: @log2_pow2(
; CHECK-NEXT: [[TMP:%.*]] = call double @llvm.pow.f64(double 2.000000e+00, double [[X:%.*]]) ; CHECK-NEXT: [[TMP:%.*]] = call double @llvm.pow.f64(double 2.000000e+00, double [[X:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.log2.f64(double [[TMP]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.log2.f64(double [[TMP]])
Show All 35 Lines

llvm/test/Transforms/InstSimplify/logic-of-fcmps.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; Cycle through commuted variants where one operand of fcmp ord/uno is ; Cycle through commuted variants where one operand of fcmp ord/uno is
; known not-a-NAN and the other is repeated in the logically-connected fcmp. ; known not-a-NAN and the other is repeated in the logically-connected fcmp.
define i1 @ord1(float %x, float %y) { define i1 @ord1(float %x, float %y) {
; CHECK-LABEL: @ord1( ; CHECK-LABEL: @ord1(
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ord float %x, %y ; CHECK-NEXT: [[CMP2:%.*]] = fcmp ord float %x, %y
; CHECK-NEXT: ret i1 [[CMP2]] ; CHECK-NEXT: ret i1 [[CMP2]]
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/maxmin.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i8 @smax_min_limit(i8 %x) { define i8 @smax_min_limit(i8 %x) {
; CHECK-LABEL: @smax_min_limit( ; CHECK-LABEL: @smax_min_limit(
; CHECK-NEXT: ret i8 [[X:%.*]] ; CHECK-NEXT: ret i8 [[X:%.*]]
; ;
%cmp = icmp sgt i8 %x, -128 %cmp = icmp sgt i8 %x, -128
%sel = select i1 %cmp, i8 %x, i8 -128 %sel = select i1 %cmp, i8 %x, i8 -128
ret i8 %sel ret i8 %sel
▲ Show 20 Lines • Show All 354 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/maxmin_intrinsics.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; TODO: the instructions with poison operands should return poison ; TODO: the instructions with poison operands should return poison
declare i81 @llvm.smax.i81(i81, i81) declare i81 @llvm.smax.i81(i81, i81)
declare i8 @llvm.smax.i8(i8, i8) declare i8 @llvm.smax.i8(i8, i8)
declare <2 x i8> @llvm.smax.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.smax.v2i8(<2 x i8>, <2 x i8>)
declare i3 @llvm.smin.i3(i3, i3) declare i3 @llvm.smin.i3(i3, i3)
declare i8 @llvm.smin.i8(i8, i8) declare i8 @llvm.smin.i8(i8, i8)
▲ Show 20 Lines • Show All 2,306 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/mul.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <2 x i1> @test1(<2 x i1> %a) { define <2 x i1> @test1(<2 x i1> %a) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret <2 x i1> zeroinitializer ; CHECK-NEXT: ret <2 x i1> zeroinitializer
; ;
%b = and <2 x i1> %a, <i1 true, i1 false> %b = and <2 x i1> %a, <i1 true, i1 false>
%res = mul <2 x i1> %b, <i1 false, i1 true> %res = mul <2 x i1> %b, <i1 false, i1 true>
ret <2 x i1> %res ret <2 x i1> %res
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/named-vector-shuffle-reverse.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
; Test back to back reverse shuffles are eliminated. ; Test back to back reverse shuffles are eliminated.
define <vscale x 4 x i32> @shuffle_b2b_reverse(<vscale x 4 x i32> %a) { define <vscale x 4 x i32> @shuffle_b2b_reverse(<vscale x 4 x i32> %a) {
; CHECK-LABEL: @shuffle_b2b_reverse( ; CHECK-LABEL: @shuffle_b2b_reverse(
; CHECK: ret <vscale x 4 x i32> %a ; CHECK: ret <vscale x 4 x i32> %a
%rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %a) %rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %a)
%rev.rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %rev) %rev.rev = tail call <vscale x 4 x i32> @llvm.experimental.vector.reverse.nxv4i32(<vscale x 4 x i32> %rev)
ret <vscale x 4 x i32> %rev.rev ret <vscale x 4 x i32> %rev.rev
Show All 16 Lines

llvm/test/Transforms/InstSimplify/negate.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @negate_nuw(i32 %x) { define i32 @negate_nuw(i32 %x) {
; CHECK-LABEL: @negate_nuw( ; CHECK-LABEL: @negate_nuw(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%neg = sub nuw i32 0, %x %neg = sub nuw i32 0, %x
ret i32 %neg ret i32 %neg
} }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/noalias-ptr.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@g1 = global i32 0, align 4 @g1 = global i32 0, align 4
@g2 = internal global i32 0, align 4 @g2 = internal global i32 0, align 4
@g3 = unnamed_addr global i32 0, align 4 @g3 = unnamed_addr global i32 0, align 4
@g4 = hidden global i32 0, align 4 @g4 = hidden global i32 0, align 4
@g5 = protected global i32 0, align 4 @g5 = protected global i32 0, align 4
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/null-ptr-is-valid-attribute.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
; A 0 valued byval pointer may be valid ; A 0 valued byval pointer may be valid
define i1 @byval_may_be_zero(i32* byval(i32) %ptr) null_pointer_is_valid { define i1 @byval_may_be_zero(i32* byval(i32) %ptr) null_pointer_is_valid {
; CHECK-LABEL: @byval_may_be_zero( ; CHECK-LABEL: @byval_may_be_zero(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[PTR:%.*]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[PTR:%.*]], null
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp eq i32* %ptr, null %cmp = icmp eq i32* %ptr, null
Show All 10 Lines

llvm/test/Transforms/InstSimplify/null-ptr-is-valid.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
target datalayout = "A5" target datalayout = "A5"
; A 0 valued byval pointer may be valid ; A 0 valued byval pointer may be valid
define i1 @byval_may_be_zero(i32 addrspace(5)* byval(i32) %ptr) { define i1 @byval_may_be_zero(i32 addrspace(5)* byval(i32) %ptr) {
; CHECK-LABEL: @byval_may_be_zero( ; CHECK-LABEL: @byval_may_be_zero(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 addrspace(5)* [[PTR:%.*]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 addrspace(5)* [[PTR:%.*]], null
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
Show All 14 Lines

llvm/test/Transforms/InstSimplify/or-icmps-same-ops.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; There are 10 * 10 combinations of icmp predicates that can be OR'd together. ; There are 10 * 10 combinations of icmp predicates that can be OR'd together.
; The majority of these can be simplified to always true or just one of the icmps. ; The majority of these can be simplified to always true or just one of the icmps.
define i1 @eq_eq(i8 %a, i8 %b) { define i1 @eq_eq(i8 %a, i8 %b) {
; CHECK-LABEL: @eq_eq( ; CHECK-LABEL: @eq_eq(
; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i8 %a, %b ; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i8 %a, %b
; CHECK-NEXT: ret i1 [[CMP2]] ; CHECK-NEXT: ret i1 [[CMP2]]
▲ Show 20 Lines • Show All 1,229 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/or.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @test1(i32 %A) { define i32 @test1(i32 %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i32 [[A:%.*]] ; CHECK-NEXT: ret i32 [[A:%.*]]
; ;
%B = or i32 %A, 0 %B = or i32 %A, 0
ret i32 %B ret i32 %B
} }
▲ Show 20 Lines • Show All 1,031 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/past-the-end.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "p:32:32" target datalayout = "p:32:32"
; Check some past-the-end subtleties. ; Check some past-the-end subtleties.
@opte_a = global i32 0 @opte_a = global i32 0
@opte_b = global i32 0 @opte_b = global i32 0
; Comparing base addresses of two distinct globals. Never equal. ; Comparing base addresses of two distinct globals. Never equal.
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/phi-cse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
; All these are negative cases, we are not allowed to perform this ; All these are negative cases, we are not allowed to perform this
; simplification in InstSimplify, because the PHI's aren't def-reachable ; simplification in InstSimplify, because the PHI's aren't def-reachable
; from one another. ; from one another.
; Most basic case, fully identical PHI nodes ; Most basic case, fully identical PHI nodes
define void @test0(i32 %v0, i32 %v1, i1 %c, i32* %d0, i32* %d1) { define void @test0(i32 %v0, i32 %v1, i1 %c, i32* %d0, i32* %d1) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
▲ Show 20 Lines • Show All 323 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; PR12189 ; PR12189
define i1 @test1(i32 %x) { define i1 @test1(i32 %x) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: br i1 true, label [[A:%.*]], label [[B:%.*]] ; CHECK-NEXT: br i1 true, label [[A:%.*]], label [[B:%.*]]
; CHECK: a: ; CHECK: a:
; CHECK-NEXT: [[AA:%.*]] = or i32 [[X:%.*]], 10 ; CHECK-NEXT: [[AA:%.*]] = or i32 [[X:%.*]], 10
; CHECK-NEXT: br label [[C:%.*]] ; CHECK-NEXT: br label [[C:%.*]]
Show All 20 Linesc:
%cc = phi i32 [ %bb, %b ], [%aa, %a ] %cc = phi i32 [ %bb, %b ], [%aa, %a ]
%d = urem i32 %cc, 2 %d = urem i32 %cc, 2
%e = icmp eq i32 %d, 0 %e = icmp eq i32 %d, 0
ret i1 %e ret i1 %e
} }
; D63489 - https://reviews.llvm.org/D63489 ; D63489 - https://reviews.llvm.org/D63489
; If this single-value phi form needs to be preserved to enable ; If this single-value phi form needs to be preserved to enable
; further analysis, then -instsimplify should not be running? ; further analysis, then -passes=instsimplify should not be running?
define i32 @lcssa-phi(i32 %x) { define i32 @lcssa-phi(i32 %x) {
; CHECK-LABEL: @lcssa-phi( ; CHECK-LABEL: @lcssa-phi(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[END:%.*]] ; CHECK-NEXT: br label [[END:%.*]]
; CHECK: end: ; CHECK: end:
; CHECK-NEXT: ret i32 [[X:%.*]] ; CHECK-NEXT: ret i32 [[X:%.*]]
; ;
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/pr28725.ll

; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
%S = type { i16, i32 } %S = type { i16, i32 }
define <2 x i16> @test1() { define <2 x i16> @test1() {
entry: entry:
%b = insertelement <2 x i16> <i16 undef, i16 0>, i16 extractvalue (%S select (i1 icmp eq (i16 extractelement (<2 x i16> bitcast (<1 x i32> <i32 1> to <2 x i16>), i32 0), i16 0), %S zeroinitializer, %S { i16 0, i32 1 }), 0), i32 0 %b = insertelement <2 x i16> <i16 undef, i16 0>, i16 extractvalue (%S select (i1 icmp eq (i16 extractelement (<2 x i16> bitcast (<1 x i32> <i32 1> to <2 x i16>), i32 0), i16 0), %S zeroinitializer, %S { i16 0, i32 1 }), 0), i32 0
ret <2 x i16> %b ret <2 x i16> %b
} }
; InstCombine will be able to fold this into zeroinitializer ; InstCombine will be able to fold this into zeroinitializer
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: ret <2 x i16> <i16 extractvalue (%S select (i1 icmp eq (i16 extractelement (<2 x i16> bitcast (<1 x i32> <i32 1> to <2 x i16>), i32 0), i16 0), %S zeroinitializer, %S { i16 0, i32 1 }), 0), i16 0> ; CHECK: ret <2 x i16> <i16 extractvalue (%S select (i1 icmp eq (i16 extractelement (<2 x i16> bitcast (<1 x i32> <i32 1> to <2 x i16>), i32 0), i16 0), %S zeroinitializer, %S { i16 0, i32 1 }), 0), i16 0>

llvm/test/Transforms/InstSimplify/pr49495.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; The first comparison (a != b) should not be dropped ; The first comparison (a != b) should not be dropped
define i1 @test1(i8* %a, i8* %b) { define i1 @test1(i8* %a, i8* %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[COND1:%.*]] = icmp ne i8* [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[COND1:%.*]] = icmp ne i8* [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 -1 ; CHECK-NEXT: [[A2:%.*]] = getelementptr inbounds i8, i8* [[A]], i64 -1
; CHECK-NEXT: [[COND2:%.*]] = icmp ugt i8* [[A2]], [[B]] ; CHECK-NEXT: [[COND2:%.*]] = icmp ugt i8* [[A2]], [[B]]
; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND1]], i1 [[COND2]], i1 false ; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND1]], i1 [[COND2]], i1 false
Show All 24 Lines

llvm/test/Transforms/InstSimplify/ptr_diff.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
target datalayout = "e-p: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-S128" target datalayout = "e-p: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-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i64 @ptrdiff1(i8* %ptr) { define i64 @ptrdiff1(i8* %ptr) {
; CHECK-LABEL: @ptrdiff1( ; CHECK-LABEL: @ptrdiff1(
; CHECK: ret i64 42 ; CHECK: ret i64 42
; ;
%first = getelementptr inbounds i8, i8* %ptr, i32 0 %first = getelementptr inbounds i8, i8* %ptr, i32 0
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/reassociate.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @add1(i32 %x) { define i32 @add1(i32 %x) {
; CHECK-LABEL: @add1( ; CHECK-LABEL: @add1(
; CHECK-NEXT: ret i32 [[X:%.*]] ; CHECK-NEXT: ret i32 [[X:%.*]]
; ;
; (X + -1) + 1 -> X ; (X + -1) + 1 -> X
%l = add i32 %x, -1 %l = add i32 %x, -1
%r = add i32 %l, 1 %r = add i32 %l, 1
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/redundant-null-check-in-uadd_with_overflow-of-nonnull-ptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
; Here we have add some offset to a non-null pointer, ; Here we have add some offset to a non-null pointer,
; and check that the result does not overflow and is not a null pointer. ; and check that the result does not overflow and is not a null pointer.
; But since the base pointer is already non-null, and we check for overflow, ; But since the base pointer is already non-null, and we check for overflow,
; that will already catch the get null pointer, ; that will already catch the get null pointer,
; so the separate null check is redundant and can be dropped. ; so the separate null check is redundant and can be dropped.
define i1 @t0(i8* nonnull %base, i64 %offset) { define i1 @t0(i8* nonnull %base, i64 %offset) {
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/rem.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @zero_dividend(i32 %A) { define i32 @zero_dividend(i32 %A) {
; CHECK-LABEL: @zero_dividend( ; CHECK-LABEL: @zero_dividend(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%B = urem i32 0, %A %B = urem i32 0, %A
ret i32 %B ret i32 %B
} }
▲ Show 20 Lines • Show All 480 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/require-dominator.ll

; RUN: opt < %s -instsimplify ; RUN: opt < %s -passes=instsimplify
; instsimplify pass should explicitly require DominatorTreeAnalysis ; instsimplify pass should explicitly require DominatorTreeAnalysis
; This test will segfault if DominatorTree is not available ; This test will segfault if DominatorTree is not available
target triple = "x86_64-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo(i16 *) #1 align 2 { define void @foo(i16 *) #1 align 2 {
Show All 22 Lines

llvm/test/Transforms/InstSimplify/result-of-add-of-negative-is-non-zero-and-no-underflow.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
; Here we add unsigned two values, check that addition did not underflow AND ; Here we add unsigned two values, check that addition did not underflow AND
; that the result is non-zero. This can be simplified just to a comparison ; that the result is non-zero. This can be simplified just to a comparison
; between the base and negated offset. ; between the base and negated offset.
declare void @use8(i8) declare void @use8(i8)
declare void @use1(i1) declare void @use1(i1)
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/result-of-usub-by-nonzero-is-non-zero-and-no-overflow.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
; Here we subtract two values, check that subtraction did not overflow AND ; Here we subtract two values, check that subtraction did not overflow AND
; that the result is non-zero. This can be simplified just to a comparison ; that the result is non-zero. This can be simplified just to a comparison
; between the base and offset. ; between the base and offset.
define i1 @t0(i64 %base, i64* nonnull %offsetptr) { define i1 @t0(i64 %base, i64* nonnull %offsetptr) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
; CHECK-NEXT: [[OFFSET:%.*]] = ptrtoint i64* [[OFFSETPTR:%.*]] to i64 ; CHECK-NEXT: [[OFFSET:%.*]] = ptrtoint i64* [[OFFSETPTR:%.*]] to i64
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/result-of-usub-is-non-zero-and-no-overflow.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt %s -instsimplify -S | FileCheck %s ; RUN: opt %s -passes=instsimplify -S | FileCheck %s
; Here we subtract two values, check that subtraction did not overflow AND ; Here we subtract two values, check that subtraction did not overflow AND
; that the result is non-zero. This can be simplified just to a comparison ; that the result is non-zero. This can be simplified just to a comparison
; between the base and offset. ; between the base and offset.
declare void @use8(i8) declare void @use8(i8)
declare void @use64(i64) declare void @use64(i64)
declare void @use1(i1) declare void @use1(i1)
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/returned.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
define i1 @bitcast() { define i1 @bitcast() {
; CHECK-LABEL: @bitcast( ; CHECK-LABEL: @bitcast(
%a = alloca i32 %a = alloca i32
%b = alloca i64 %b = alloca i64
%x = bitcast i32* %a to i8* %x = bitcast i32* %a to i8*
%z = bitcast i64* %b to i8* %z = bitcast i64* %b to i8*
%y = call i8* @func1(i8* %z) %y = call i8* @func1(i8* %z)
Show All 21 Lines

llvm/test/Transforms/InstSimplify/round-intrinsics.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instsimplify %s | FileCheck %s ; RUN: opt -S -passes=instsimplify %s | FileCheck %s
define float @sitofp_floor(i32 %arg) { define float @sitofp_floor(i32 %arg) {
; CHECK-LABEL: @sitofp_floor( ; CHECK-LABEL: @sitofp_floor(
; CHECK-NEXT: [[CVT:%.*]] = sitofp i32 [[ARG:%.*]] to float ; CHECK-NEXT: [[CVT:%.*]] = sitofp i32 [[ARG:%.*]] to float
; CHECK-NEXT: ret float [[CVT]] ; CHECK-NEXT: ret float [[CVT]]
; ;
%cvt = sitofp i32 %arg to float %cvt = sitofp i32 %arg to float
%round = call float @llvm.floor.f32(float %cvt) %round = call float @llvm.floor.f32(float %cvt)
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/saturating-add-sub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; TODO: the instructions having poison operands should be folded to poison ; TODO: the instructions having poison operands should be folded to poison
declare i3 @llvm.uadd.sat.i3(i3, i3) declare i3 @llvm.uadd.sat.i3(i3, i3)
declare i8 @llvm.uadd.sat.i8(i8, i8) declare i8 @llvm.uadd.sat.i8(i8, i8)
declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9>, <2 x i9>) declare <2 x i9> @llvm.uadd.sat.v2i9(<2 x i9>, <2 x i9>)
▲ Show 20 Lines • Show All 786 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/sdiv.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @negated_operand(i32 %x) { define i32 @negated_operand(i32 %x) {
; CHECK-LABEL: @negated_operand( ; CHECK-LABEL: @negated_operand(
; CHECK-NEXT: ret i32 -1 ; CHECK-NEXT: ret i32 -1
; ;
%negx = sub nsw i32 0, %x %negx = sub nsw i32 0, %x
%div = sdiv i32 %negx, %x %div = sdiv i32 %negx, %x
ret i32 %div ret i32 %div
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/select-and-cmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @select_and_icmp(i32 %x, i32 %y, i32 %z) { define i32 @select_and_icmp(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: @select_and_icmp( ; CHECK-LABEL: @select_and_icmp(
; CHECK-NEXT: ret i32 [[X:%.*]] ; CHECK-NEXT: ret i32 [[X:%.*]]
; ;
%A = icmp eq i32 %x, %z %A = icmp eq i32 %x, %z
%B = icmp eq i32 %y, %z %B = icmp eq i32 %y, %z
%C = and i1 %A, %B %C = and i1 %A, %B
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/select-implied.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; A == B implies A >u B is false. ; A == B implies A >u B is false.
define void @test1(i32 %a, i32 %b) { define void @test1(i32 %a, i32 %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: br i1 [[CMP1]], label [[TAKEN:%.*]], label [[END:%.*]] ; CHECK-NEXT: br i1 [[CMP1]], label [[TAKEN:%.*]], label [[END:%.*]]
; CHECK: taken: ; CHECK: taken:
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/select-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @bool_true_or_false(i1 %cond) { define i1 @bool_true_or_false(i1 %cond) {
; CHECK-LABEL: @bool_true_or_false( ; CHECK-LABEL: @bool_true_or_false(
; CHECK-NEXT: ret i1 [[COND:%.*]] ; CHECK-NEXT: ret i1 [[COND:%.*]]
; ;
%s = select i1 %cond, i1 true, i1 false %s = select i1 %cond, i1 true, i1 false
ret i1 %s ret i1 %s
} }
▲ Show 20 Lines • Show All 988 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/select-logical.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @logical_and_of_or_commute0(i1 %x, i1 %y) { define i1 @logical_and_of_or_commute0(i1 %x, i1 %y) {
; CHECK-LABEL: @logical_and_of_or_commute0( ; CHECK-LABEL: @logical_and_of_or_commute0(
; CHECK-NEXT: ret i1 [[X:%.*]] ; CHECK-NEXT: ret i1 [[X:%.*]]
; ;
%ynot = xor i1 %y, -1 %ynot = xor i1 %y, -1
%xory = select i1 %x, i1 true, i1 %y %xory = select i1 %x, i1 true, i1 %y
%xorynot = select i1 %x, i1 true, i1 %ynot %xorynot = select i1 %x, i1 true, i1 %ynot
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/select-or-cmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @select_or_icmp(i32 %x, i32 %y, i32 %z) { define i32 @select_or_icmp(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: @select_or_icmp( ; CHECK-LABEL: @select_or_icmp(
; CHECK-NEXT: ret i32 [[Z:%.*]] ; CHECK-NEXT: ret i32 [[Z:%.*]]
; ;
%A = icmp ne i32 %x, %z %A = icmp ne i32 %x, %z
%B = icmp ne i32 %y, %z %B = icmp ne i32 %y, %z
%C = or i1 %A, %B %C = or i1 %A, %B
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/select.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i1 @bool_true_or_false(i1 %cond) { define i1 @bool_true_or_false(i1 %cond) {
; CHECK-LABEL: @bool_true_or_false( ; CHECK-LABEL: @bool_true_or_false(
; CHECK-NEXT: ret i1 [[COND:%.*]] ; CHECK-NEXT: ret i1 [[COND:%.*]]
; ;
%s = select i1 %cond, i1 true, i1 false %s = select i1 %cond, i1 true, i1 false
ret i1 %s ret i1 %s
} }
▲ Show 20 Lines • Show All 1,058 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/shift-128-kb.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
define zeroext i1 @_Z10isNegativemj(i64 %Val, i32 zeroext %IntegerBitWidth) { define zeroext i1 @_Z10isNegativemj(i64 %Val, i32 zeroext %IntegerBitWidth) {
; CHECK-LABEL: @_Z10isNegativemj( ; CHECK-LABEL: @_Z10isNegativemj(
; CHECK: [[CONV:%.*]] = zext i32 %IntegerBitWidth to i64 ; CHECK: [[CONV:%.*]] = zext i32 %IntegerBitWidth to i64
; CHECK-NEXT: [[SUB:%.*]] = sub i64 128, [[CONV]] ; CHECK-NEXT: [[SUB:%.*]] = sub i64 128, [[CONV]]
Show All 20 Lines

llvm/test/Transforms/InstSimplify/shift-knownbits.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S -data-layout="E" | FileCheck %s --check-prefixes=CHECK,BIGENDIAN ; RUN: opt < %s -passes=instsimplify -S -data-layout="E" | FileCheck %s --check-prefixes=CHECK,BIGENDIAN
; RUN: opt < %s -instsimplify -S -data-layout="e" | FileCheck %s --check-prefixes=CHECK,LITTLEENDIAN ; RUN: opt < %s -passes=instsimplify -S -data-layout="e" | FileCheck %s --check-prefixes=CHECK,LITTLEENDIAN
; If any bits of the shift amount are known to make it exceed or equal ; If any bits of the shift amount are known to make it exceed or equal
; the number of bits in the type, the shift causes undefined behavior. ; the number of bits in the type, the shift causes undefined behavior.
define i32 @shl_amount_is_known_bogus(i32 %a, i32 %b) { define i32 @shl_amount_is_known_bogus(i32 %a, i32 %b) {
; CHECK-LABEL: @shl_amount_is_known_bogus( ; CHECK-LABEL: @shl_amount_is_known_bogus(
; CHECK-NEXT: ret i32 poison ; CHECK-NEXT: ret i32 poison
; ;
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/shift.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i47 @shl_by_0(i47 %A) { define i47 @shl_by_0(i47 %A) {
; CHECK-LABEL: @shl_by_0( ; CHECK-LABEL: @shl_by_0(
; CHECK-NEXT: ret i47 [[A:%.*]] ; CHECK-NEXT: ret i47 [[A:%.*]]
; ;
%B = shl i47 %A, 0 %B = shl i47 %A, 0
ret i47 %B ret i47 %B
} }
▲ Show 20 Lines • Show All 332 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/shr-nop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @foo(i32 %x) { define i32 @foo(i32 %x) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[O:%.*]] = and i32 %x, 1 ; CHECK-NEXT: [[O:%.*]] = and i32 %x, 1
; CHECK-NEXT: [[N:%.*]] = add i32 [[O]], -1 ; CHECK-NEXT: [[N:%.*]] = add i32 [[O]], -1
; CHECK-NEXT: ret i32 [[N]] ; CHECK-NEXT: ret i32 [[N]]
; ;
%o = and i32 %x, 1 %o = and i32 %x, 1
▲ Show 20 Lines • Show All 421 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/shr-scalar-vector-consistency.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; This tests checks optimization consistency for scalar and vector code. ; This tests checks optimization consistency for scalar and vector code.
; If m_Zero() is able to match a vector undef, but not a scalar undef, ; If m_Zero() is able to match a vector undef, but not a scalar undef,
; the two cases will simplify differently. ; the two cases will simplify differently.
define i32 @test_scalar(i32 %a, i1 %b) { define i32 @test_scalar(i32 %a, i1 %b) {
; CHECK-LABEL: @test_scalar( ; CHECK-LABEL: @test_scalar(
; CHECK-NEXT: ret i32 undef ; CHECK-NEXT: ret i32 undef
Show All 15 Lines

llvm/test/Transforms/InstSimplify/shufflevector-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <4 x i32> @const_folding(<4 x i32> %x) { define <4 x i32> @const_folding(<4 x i32> %x) {
; CHECK-LABEL: @const_folding( ; CHECK-LABEL: @const_folding(
; CHECK-NEXT: ret <4 x i32> zeroinitializer ; CHECK-NEXT: ret <4 x i32> zeroinitializer
; ;
%shuf = shufflevector <4 x i32> %x, <4 x i32> zeroinitializer, <4 x i32> <i32 5, i32 4, i32 5, i32 4> %shuf = shufflevector <4 x i32> %x, <4 x i32> zeroinitializer, <4 x i32> <i32 5, i32 4, i32 5, i32 4>
ret <4 x i32> %shuf ret <4 x i32> %shuf
} }
▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/shufflevector.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <4 x i32> @const_folding(<4 x i32> %x) { define <4 x i32> @const_folding(<4 x i32> %x) {
; CHECK-LABEL: @const_folding( ; CHECK-LABEL: @const_folding(
; CHECK-NEXT: ret <4 x i32> zeroinitializer ; CHECK-NEXT: ret <4 x i32> zeroinitializer
; ;
%shuf = shufflevector <4 x i32> %x, <4 x i32> zeroinitializer, <4 x i32> <i32 5, i32 4, i32 5, i32 4> %shuf = shufflevector <4 x i32> %x, <4 x i32> zeroinitializer, <4 x i32> <i32 5, i32 4, i32 5, i32 4>
ret <4 x i32> %shuf ret <4 x i32> %shuf
} }
▲ Show 20 Lines • Show All 276 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/signed-div-rem.ll

; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @sdiv_sext_big_divisor(i8 %x) { define i32 @sdiv_sext_big_divisor(i8 %x) {
; CHECK-LABEL: @sdiv_sext_big_divisor( ; CHECK-LABEL: @sdiv_sext_big_divisor(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%conv = sext i8 %x to i32 %conv = sext i8 %x to i32
%div = sdiv i32 %conv, 129 %div = sdiv i32 %conv, 129
ret i32 %div ret i32 %div
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/smul_fix.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -instsimplify | FileCheck %s ; RUN: opt < %s -S -passes=instsimplify | FileCheck %s
declare i16 @llvm.smul.fix.i16(i16, i16, i32) declare i16 @llvm.smul.fix.i16(i16, i16, i32)
declare i16 @llvm.smul.fix.sat.i16(i16, i16, i32) declare i16 @llvm.smul.fix.sat.i16(i16, i16, i32)
declare <2 x i16> @llvm.smul.fix.v2i16(<2 x i16>, <2 x i16>, i32) declare <2 x i16> @llvm.smul.fix.v2i16(<2 x i16>, <2 x i16>, i32)
declare <2 x i16> @llvm.smul.fix.sat.v2i16(<2 x i16>, <2 x i16>, i32) declare <2 x i16> @llvm.smul.fix.sat.v2i16(<2 x i16>, <2 x i16>, i32)
;; ;;
;; llvm.smul.fix (scalar) ;; llvm.smul.fix (scalar)
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/srem.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @negated_operand(i32 %x) { define i32 @negated_operand(i32 %x) {
; CHECK-LABEL: @negated_operand( ; CHECK-LABEL: @negated_operand(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%negx = sub i32 0, %x %negx = sub i32 0, %x
%rem = srem i32 %negx, %x %rem = srem i32 %negx, %x
ret i32 %rem ret i32 %rem
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/strictfp-fadd.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; ;
; constrained fadd ; constrained fadd
; ;
; ;
; fadd X, -0 ==> X ; fadd X, -0 ==> X
; ;
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/strictfp-fsub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; ;
; constrained fsub ; constrained fsub
; ;
; ;
; fsub X, +0 ==> X ; fsub X, +0 ==> X
; ;
▲ Show 20 Lines • Show All 695 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/sub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @sub_self(i32 %A) { define i32 @sub_self(i32 %A) {
; CHECK-LABEL: @sub_self( ; CHECK-LABEL: @sub_self(
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%B = sub i32 %A, %A %B = sub i32 %A, %A
ret i32 %B ret i32 %B
} }
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/undef.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -passes=instsimplify -S < %s | FileCheck %s
define i64 @test0() { define i64 @test0() {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK: ret i64 undef ; CHECK: ret i64 undef
; ;
%r = mul i64 undef, undef %r = mul i64 undef, undef
ret i64 %r ret i64 %r
} }
▲ Show 20 Lines • Show All 353 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/vec-cmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define <2 x i1> @nonzero_vec_splat(<2 x i32> %x) { define <2 x i1> @nonzero_vec_splat(<2 x i32> %x) {
; CHECK-LABEL: @nonzero_vec_splat( ; CHECK-LABEL: @nonzero_vec_splat(
; CHECK-NEXT: ret <2 x i1> zeroinitializer ; CHECK-NEXT: ret <2 x i1> zeroinitializer
; ;
%y = or <2 x i32> %x, <i32 1, i32 1> %y = or <2 x i32> %x, <i32 1, i32 1>
%c = icmp eq <2 x i32> %y, zeroinitializer %c = icmp eq <2 x i32> %y, zeroinitializer
ret <2 x i1> %c ret <2 x i1> %c
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/vector_gep.ll

; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
declare void @helper(<2 x i8*>) declare void @helper(<2 x i8*>)
define void @test(<2 x i8*> %a) { define void @test(<2 x i8*> %a) {
%A = getelementptr i8, <2 x i8*> %a, <2 x i32> <i32 0, i32 0> %A = getelementptr i8, <2 x i8*> %a, <2 x i32> <i32 0, i32 0>
call void @helper(<2 x i8*> %A) call void @helper(<2 x i8*> %A)
ret void ret void
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/vector_ptr_bitcast.ll

; RUN: opt -S -instsimplify < %s | FileCheck %s ; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
%mst = type { i8*, i8* } %mst = type { i8*, i8* }
%mst2 = type { i32*, i32*, i32*, i32* } %mst2 = type { i32*, i32*, i32*, i32* }
@a = private unnamed_addr constant %mst { i8* inttoptr (i64 -1 to i8*), @a = private unnamed_addr constant %mst { i8* inttoptr (i64 -1 to i8*),
i8* inttoptr (i64 -1 to i8*)}, i8* inttoptr (i64 -1 to i8*)},
align 8 align 8
Show All 26 Lines

llvm/test/Transforms/InstSimplify/xor.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instsimplify -S | FileCheck %s ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
define i32 @poison(i32 %x) { define i32 @poison(i32 %x) {
; CHECK-LABEL: @poison( ; CHECK-LABEL: @poison(
; CHECK-NEXT: ret i32 poison ; CHECK-NEXT: ret i32 poison
; ;
%v = xor i32 %x, poison %v = xor i32 %x, poison
ret i32 %v ret i32 %v
} }
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines