This is an archive of the discontinued LLVM Phabricator instance.

Differential D119084

[test] Use -passes=instcombine instead of -instcombine in some tests (4/4). NFC
AbandonedPublic

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

Details

Reviewers
aeubanks
lebedev.ri
Summary

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

Diff Detail

Unit TestsFailed

TimeTest
60,220 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vloxseg.c
60,150 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vlseg.c
60,180 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vlsegff.c
60,210 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vluxseg.c
60,120 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vsoxseg.c
View Full Test Results (17 Failed)

Event Timeline

bjope created this revision.Feb 6 2022, 7:27 AM
Herald added a reviewer: lebedev.ri. · View Herald TranscriptFeb 6 2022, 7:27 AM
Herald added subscribers: lebedev.ri, mstorsjo. · View Herald Transcript
bjope requested review of this revision.Feb 6 2022, 7:27 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 6 2022, 7:27 AM
Harbormaster completed remote builds in B147826: Diff 406255.Feb 6 2022, 8:41 AM
bjope abandoned this revision.Feb 7 2022, 5:29 AM

This was squashed into D119081.

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
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
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
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
2 lines
12 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
14 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
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
4 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
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

Diff 406255

llvm/test/Transforms/InstCombine/range-check.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Check simplification of ; Check simplification of
; (icmp sgt x, -1) & (icmp sgt/sge n, x) --> icmp ugt/uge n, x ; (icmp sgt x, -1) & (icmp sgt/sge n, x) --> icmp ugt/uge n, x
define i1 @test_and1(i32 %x, i32 %n) { define i1 @test_and1(i32 %x, i32 %n) {
; CHECK-LABEL: @test_and1( ; CHECK-LABEL: @test_and1(
; CHECK-NEXT: [[NN:%.*]] = and i32 [[N:%.*]], 2147483647 ; CHECK-NEXT: [[NN:%.*]] = and i32 [[N:%.*]], 2147483647
; CHECK-NEXT: [[TMP1:%.*]] = icmp ugt i32 [[NN]], [[X:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = icmp ugt i32 [[NN]], [[X:%.*]]
▲ Show 20 Lines • Show All 360 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/readnone-maythrow.ll

; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare void @readnone_but_may_throw() readnone declare void @readnone_but_may_throw() readnone
define void @f_0(i32* %ptr) { define void @f_0(i32* %ptr) {
; CHECK-LABEL: @f_0( ; CHECK-LABEL: @f_0(
entry: entry:
; CHECK: store i32 10, i32* %ptr ; CHECK: store i32 10, i32* %ptr
; CHECK-NEXT: call void @readnone_but_may_throw() ; CHECK-NEXT: call void @readnone_but_may_throw()
Show All 25 Lines

llvm/test/Transforms/InstCombine/realloc-free.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --scrub-attributes ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --scrub-attributes
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define dso_local void @_Z3fooPv(i8* nocapture %0) local_unnamed_addr #0 { define dso_local void @_Z3fooPv(i8* nocapture %0) local_unnamed_addr #0 {
; CHECK-LABEL: @_Z3fooPv( ; CHECK-LABEL: @_Z3fooPv(
; CHECK-NEXT: tail call void @free(i8* [[TMP0:%.*]]) ; CHECK-NEXT: tail call void @free(i8* [[TMP0:%.*]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%2 = tail call align 16 dereferenceable_or_null(6) i8* @realloc(i8* %0, i64 6) #2 %2 = tail call align 16 dereferenceable_or_null(6) i8* @realloc(i8* %0, i64 6) #2
tail call void @free(i8* %2) #2 tail call void @free(i8* %2) #2
Show All 9 Lines

llvm/test/Transforms/InstCombine/realloc.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i8* @realloc(i8*, i64) #1 declare i8* @realloc(i8*, i64) #1
declare noalias i8* @malloc(i64) #1 declare noalias i8* @malloc(i64) #1
define i8* @realloc_null_ptr() #0 { define i8* @realloc_null_ptr() #0 {
; CHECK-LABEL: @realloc_null_ptr( ; CHECK-LABEL: @realloc_null_ptr(
; CHECK-NEXT: [[MALLOC:%.*]] = call dereferenceable_or_null(100) i8* @malloc(i64 100) ; CHECK-NEXT: [[MALLOC:%.*]] = call dereferenceable_or_null(100) i8* @malloc(i64 100)
Show All 14 Lines

llvm/test/Transforms/InstCombine/reassociate-nuw.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 -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
define i32 @reassoc_add_nuw(i32 %x) { define i32 @reassoc_add_nuw(i32 %x) {
; CHECK-LABEL: @reassoc_add_nuw( ; CHECK-LABEL: @reassoc_add_nuw(
; CHECK-NEXT: [[ADD1:%.*]] = add nuw i32 [[X:%.*]], 68 ; CHECK-NEXT: [[ADD1:%.*]] = add nuw i32 [[X:%.*]], 68
; CHECK-NEXT: ret i32 [[ADD1]] ; CHECK-NEXT: ret i32 [[ADD1]]
; ;
%add0 = add nuw i32 %x, 4 %add0 = add nuw i32 %x, 4
%add1 = add nuw i32 %add0, 64 %add1 = add nuw i32 %add0, 64
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/recurrence.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i64 @test_or(i64 %a) { define i64 @test_or(i64 %a) {
; CHECK-LABEL: @test_or( ; CHECK-LABEL: @test_or(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[TMP0:%.*]] = or i64 [[A:%.*]], 15 ; CHECK-NEXT: [[TMP0:%.*]] = or i64 [[A:%.*]], 15
; CHECK-NEXT: tail call void @use(i64 [[TMP0]]) ; CHECK-NEXT: tail call void @use(i64 [[TMP0]])
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-add-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_add_self(<8 x i1> %x) { define i1 @reduce_add_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_add_self( ; CHECK-LABEL: @reduce_add_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = call i8 @llvm.ctpop.i8(i8 [[TMP1]]), !range [[RNG0:![0-9]+]] ; CHECK-NEXT: [[TMP2:%.*]] = call i8 @llvm.ctpop.i8(i8 [[TMP1]]), !range [[RNG0:![0-9]+]]
; CHECK-NEXT: [[TMP3:%.*]] = and i8 [[TMP2]], 1 ; CHECK-NEXT: [[TMP3:%.*]] = and i8 [[TMP2]], 1
; CHECK-NEXT: [[TMP4:%.*]] = icmp ne i8 [[TMP3]], 0 ; CHECK-NEXT: [[TMP4:%.*]] = icmp ne i8 [[TMP3]], 0
; CHECK-NEXT: ret i1 [[TMP4]] ; CHECK-NEXT: ret i1 [[TMP4]]
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-and-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
define i1 @reduce_and_self(<8 x i1> %x) { define i1 @reduce_and_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_and_self( ; CHECK-LABEL: @reduce_and_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1 ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-mul-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_mul_self(<8 x i1> %x) { define i1 @reduce_mul_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_mul_self( ; CHECK-LABEL: @reduce_mul_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1 ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%res = call i1 @llvm.vector.reduce.mul.v8i32(<8 x i1> %x) %res = call i1 @llvm.vector.reduce.mul.v8i32(<8 x i1> %x)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-or-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
define i1 @reduce_or_self(<8 x i1> %x) { define i1 @reduce_or_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_or_self( ; CHECK-LABEL: @reduce_or_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0 ; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @reduce_add(<4 x i32> %x) { define i32 @reduce_add(<4 x i32> %x) {
; CHECK-LABEL: @reduce_add( ; CHECK-LABEL: @reduce_add(
; CHECK-NEXT: [[RES:%.*]] = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> [[X:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> [[X:%.*]])
; CHECK-NEXT: ret i32 [[RES]] ; CHECK-NEXT: ret i32 [[RES]]
; ;
%shuf = shufflevector <4 x i32> %x, <4 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3> %shuf = shufflevector <4 x i32> %x, <4 x i32> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%res = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %shuf) %res = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %shuf)
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-smax-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_smax_self(<8 x i1> %x) { define i1 @reduce_smax_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_smax_self( ; CHECK-LABEL: @reduce_smax_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1 ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%res = call i1 @llvm.vector.reduce.smax.v8i32(<8 x i1> %x) %res = call i1 @llvm.vector.reduce.smax.v8i32(<8 x i1> %x)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-smin-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_smin_self(<8 x i1> %x) { define i1 @reduce_smin_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_smin_self( ; CHECK-LABEL: @reduce_smin_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0 ; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%res = call i1 @llvm.vector.reduce.smin.v8i32(<8 x i1> %x) %res = call i1 @llvm.vector.reduce.smin.v8i32(<8 x i1> %x)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-umax-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_umax_self(<8 x i1> %x) { define i1 @reduce_umax_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_umax_self( ; CHECK-LABEL: @reduce_umax_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0 ; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i8 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%res = call i1 @llvm.vector.reduce.umax.v8i32(<8 x i1> %x) %res = call i1 @llvm.vector.reduce.umax.v8i32(<8 x i1> %x)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-umin-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_umin_self(<8 x i1> %x) { define i1 @reduce_umin_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_umin_self( ; CHECK-LABEL: @reduce_umin_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1 ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i8 [[TMP1]], -1
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%res = call i1 @llvm.vector.reduce.umin.v8i32(<8 x i1> %x) %res = call i1 @llvm.vector.reduce.umin.v8i32(<8 x i1> %x)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reduction-xor-sext-zext-i1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduce_xor_self(<8 x i1> %x) { define i1 @reduce_xor_self(<8 x i1> %x) {
; CHECK-LABEL: @reduce_xor_self( ; CHECK-LABEL: @reduce_xor_self(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <8 x i1> [[X:%.*]] to i8
; CHECK-NEXT: [[TMP2:%.*]] = call i8 @llvm.ctpop.i8(i8 [[TMP1]]), !range [[RNG0:![0-9]+]] ; CHECK-NEXT: [[TMP2:%.*]] = call i8 @llvm.ctpop.i8(i8 [[TMP1]]), !range [[RNG0:![0-9]+]]
; CHECK-NEXT: [[TMP3:%.*]] = and i8 [[TMP2]], 1 ; CHECK-NEXT: [[TMP3:%.*]] = and i8 [[TMP2]], 1
; CHECK-NEXT: [[TMP4:%.*]] = icmp ne i8 [[TMP3]], 0 ; CHECK-NEXT: [[TMP4:%.*]] = icmp ne i8 [[TMP3]], 0
; CHECK-NEXT: ret i1 [[TMP4]] ; CHECK-NEXT: ret i1 [[TMP4]]
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-after-truncation-variant-a.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, we can combine those two shifts into a shift+mask. ; left-shift of those bits, we can combine those two shifts into a shift+mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; a) (trunc (x & ((1 << maskNbits) - 1))) << shiftNbits ; a) (trunc (x & ((1 << maskNbits) - 1))) << shiftNbits
; simplify to: ; simplify to:
; (trunc(x)) << shiftNbits ; (trunc(x)) << shiftNbits
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-after-truncation-variant-b.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, we can combine those two shifts into a shift+mask. ; left-shift of those bits, we can combine those two shifts into a shift+mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; b) (trunc ((x & (~(-1 << maskNbits))))) << shiftNbits ; b) (trunc ((x & (~(-1 << maskNbits))))) << shiftNbits
; simplify to: ; simplify to:
; ((trunc(x)) << shiftNbits) & (~(-1 << (maskNbits+shiftNbits))) ; ((trunc(x)) << shiftNbits) & (~(-1 << (maskNbits+shiftNbits)))
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-after-truncation-variant-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, we can combine those two shifts into a shift+mask. ; left-shift of those bits, we can combine those two shifts into a shift+mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; c) (trunc ((x & (-1 >> maskNbits)))) << shiftNbits ; c) (trunc ((x & (-1 >> maskNbits)))) << shiftNbits
; simplify to: ; simplify to:
; (trunc(x)) << shiftNbits ; (trunc(x)) << shiftNbits
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-after-truncation-variant-d.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, we can combine those two shifts into a shift+mask. ; left-shift of those bits, we can combine those two shifts into a shift+mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; d) (trunc ((x & ((-1 << maskNbits) >> maskNbits)))) << shiftNbits ; d) (trunc ((x & ((-1 << maskNbits) >> maskNbits)))) << shiftNbits
; simplify to: ; simplify to:
; (trunc(x)) << shiftNbits ; (trunc(x)) << shiftNbits
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-after-truncation-variant-e.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, lshr then performs ; If we have some pattern that leaves only some low bits set, lshr then performs
; left-shift of those bits, we can combine those two shifts into a shift+mask. ; left-shift of those bits, we can combine those two shifts into a shift+mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; e) (trunc (((x << maskNbits) l>> maskNbits))) << shiftNbits ; e) (trunc (((x << maskNbits) l>> maskNbits))) << shiftNbits
; simplify to: ; simplify to:
; ((trunc(x)) << shiftNbits) & (-1 >> ((-(maskNbits+shiftNbits))+32)) ; ((trunc(x)) << shiftNbits) & (-1 >> ((-(maskNbits+shiftNbits))+32))
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-after-truncation-variant-f.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, ashr then performs ; If we have some pattern that leaves only some low bits set, ashr then performs
; left-shift of those bits, we can combine those two shifts into a shift+mask. ; left-shift of those bits, we can combine those two shifts into a shift+mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; e) (trunc (((x << maskNbits) a>> maskNbits))) << shiftNbits ; e) (trunc (((x << maskNbits) a>> maskNbits))) << shiftNbits
; simplify to: ; simplify to:
; (trunc(x)) << shiftNbits ; (trunc(x)) << shiftNbits
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-pr49778.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; PR49778: this should not be folded to 0. ; PR49778: this should not be folded to 0.
define i32 @src(i1 %x2) { define i32 @src(i1 %x2) {
; CHECK-LABEL: @src( ; CHECK-LABEL: @src(
; CHECK-NEXT: [[X13:%.*]] = zext i1 [[X2:%.*]] to i32 ; CHECK-NEXT: [[X13:%.*]] = zext i1 [[X2:%.*]] to i32
; CHECK-NEXT: [[_7:%.*]] = shl i32 -1, [[X13]] ; CHECK-NEXT: [[_7:%.*]] = shl i32 -1, [[X13]]
; CHECK-NEXT: [[MASK:%.*]] = xor i32 [[_7]], -1 ; CHECK-NEXT: [[MASK:%.*]] = xor i32 [[_7]], -1
; CHECK-NEXT: [[_8:%.*]] = and i32 [[MASK]], [[X13]] ; CHECK-NEXT: [[_8:%.*]] = and i32 [[MASK]], [[X13]]
Show All 10 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-variant-a.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, if none of the bits that are left after the final ; left-shift of those bits, if none of the bits that are left after the final
; shift are modified by the mask, we can omit the mask. ; shift are modified by the mask, we can omit the mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; a) (x & ((1 << maskNbits) - 1)) << shiftNbits ; a) (x & ((1 << maskNbits) - 1)) << shiftNbits
; simplify to: ; simplify to:
▲ Show 20 Lines • Show All 399 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-variant-b.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, if none of the bits that are left after the final ; left-shift of those bits, if none of the bits that are left after the final
; shift are modified by the mask, we can omit the mask. ; shift are modified by the mask, we can omit the mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; b) (x & (~(-1 << maskNbits))) << shiftNbits ; b) (x & (~(-1 << maskNbits))) << shiftNbits
; simplify to: ; simplify to:
▲ Show 20 Lines • Show All 374 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-variant-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, if none of the bits that are left after the final ; left-shift of those bits, if none of the bits that are left after the final
; shift are modified by the mask, we can omit the mask. ; shift are modified by the mask, we can omit the mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; c) (x & (-1 >> maskNbits)) << shiftNbits ; c) (x & (-1 >> maskNbits)) << shiftNbits
; simplify to: ; simplify to:
▲ Show 20 Lines • Show All 273 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-variant-d.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, if none of the bits that are left after the final ; left-shift of those bits, if none of the bits that are left after the final
; shift are modified by the mask, we can omit the mask. ; shift are modified by the mask, we can omit the mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; d) (x & ((-1 << maskNbits) >> maskNbits)) << shiftNbits ; d) (x & ((-1 << maskNbits) >> maskNbits)) << shiftNbits
; simplify to: ; simplify to:
▲ Show 20 Lines • Show All 353 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-variant-e.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, if none of the bits that are left after the final ; left-shift of those bits, if none of the bits that are left after the final
; shift are modified by the mask, we can omit the mask. ; shift are modified by the mask, we can omit the mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; e) ((x << maskNbits) l>> maskNbits) << shiftNbits ; e) ((x << maskNbits) l>> maskNbits) << shiftNbits
; simplify to: ; simplify to:
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-left-shift-input-masking-variant-f.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have some pattern that leaves only some low bits set, and then performs ; If we have some pattern that leaves only some low bits set, and then performs
; left-shift of those bits, if none of the bits that are left after the final ; left-shift of those bits, if none of the bits that are left after the final
; shift are modified by the mask, we can omit the mask. ; shift are modified by the mask, we can omit the mask.
; There are many variants to this pattern: ; There are many variants to this pattern:
; f) ((x << maskNbits) a>> maskNbits) << shiftNbits ; f) ((x << maskNbits) a>> maskNbits) << shiftNbits
; simplify to: ; simplify to:
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/redundant-right-shift-input-masking.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have: ; If we have:
; (data & (-1 << nbits)) outer>> nbits ; (data & (-1 << nbits)) outer>> nbits
; Or ; Or
; ((data inner>> nbits) << nbits) outer>> nbits ; ((data inner>> nbits) << nbits) outer>> nbits
; The mask is redundant, and can be dropped: ; The mask is redundant, and can be dropped:
; data outer>> nbits ; data outer>> nbits
; This is valid for both lshr and ashr in both positions and any combination. ; This is valid for both lshr and ashr in both positions and any combination.
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i64 @rem_signed(i64 %x1, i64 %y2) { define i64 @rem_signed(i64 %x1, i64 %y2) {
; CHECK-LABEL: @rem_signed( ; CHECK-LABEL: @rem_signed(
; CHECK-NEXT: [[TMP1:%.*]] = srem i64 [[X1:%.*]], [[Y2:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = srem i64 [[X1:%.*]], [[Y2:%.*]]
; CHECK-NEXT: ret i64 [[TMP1]] ; CHECK-NEXT: ret i64 [[TMP1]]
; ;
▲ Show 20 Lines • Show All 982 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use8(i8) declare void @use8(i8)
declare void @use1(i1) declare void @use1(i1)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
; Here we don't know that at least one of the values being added is non-zero ; Here we don't know that at least one of the values being added is non-zero
define i1 @t0_bad(i8 %base, i8 %offset) { define i1 @t0_bad(i8 %base, i8 %offset) {
▲ Show 20 Lines • Show All 475 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/result-of-add-of-negative-or-zero-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use8(i8) declare void @use8(i8)
declare void @use1(i1) declare void @use1(i1)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define i1 @t0(i8 %base, i8 %offset) { define i1 @t0(i8 %base, i8 %offset) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
▲ Show 20 Lines • Show All 306 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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 831 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/reuse-constant-from-select-in-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have a relational comparison with a constant, and said comparison is ; If we have a relational comparison with a constant, and said comparison is
; used in a select, and there is a constant in select, see if we can make ; used in a select, and there is a constant in select, see if we can make
; those constants match. ; those constants match.
; We can't ever get non-canonical scalar predicates. ; We can't ever get non-canonical scalar predicates.
; Likewise, while we can get non-canonical vector predicates, there must be an ; Likewise, while we can get non-canonical vector predicates, there must be an
▲ Show 20 Lines • Show All 353 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/rotate.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
; Canonicalize rotate by constant to funnel shift intrinsics. ; Canonicalize rotate by constant to funnel shift intrinsics.
; This should help cost modeling for vectorization, inlining, etc. ; This should help cost modeling for vectorization, inlining, etc.
; If a target does not have a rotate instruction, the expansion will ; If a target does not have a rotate instruction, the expansion will
; be exactly these same 3 basic ops (shl/lshr/or). ; be exactly these same 3 basic ops (shl/lshr/or).
▲ Show 20 Lines • Show All 949 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sadd-with-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { <2 x i32>, <2 x i1> } @llvm.sadd.with.overflow.v2i32(<2 x i32>, <2 x i32>) declare { <2 x i32>, <2 x i1> } @llvm.sadd.with.overflow.v2i32(<2 x i32>, <2 x i32>)
declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32) declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32)
declare { i8, i1 } @llvm.sadd.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.sadd.with.overflow.i8(i8, i8)
define { i32, i1 } @simple_fold(i32 %x) { define { i32, i1 } @simple_fold(i32 %x) {
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sadd_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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 i32 @sadd_sat32(i32 %a, i32 %b) { define i32 @sadd_sat32(i32 %a, i32 %b) {
; CHECK-LABEL: @sadd_sat32( ; CHECK-LABEL: @sadd_sat32(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = call i32 @llvm.sadd.sat.i32(i32 [[B:%.*]], i32 [[A:%.*]]) ; CHECK-NEXT: [[TMP0:%.*]] = call i32 @llvm.sadd.sat.i32(i32 [[B:%.*]], i32 [[A:%.*]])
; CHECK-NEXT: ret i32 [[TMP0]] ; CHECK-NEXT: ret i32 [[TMP0]]
▲ Show 20 Lines • Show All 879 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/saddo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64)
declare { i8, i1 } @llvm.sadd.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.sadd.with.overflow.i8(i8, i8)
define i1 @test_generic(i64 %a, i64 %b) { define i1 @test_generic(i64 %a, i64 %b) {
; CHECK-LABEL: @test_generic( ; CHECK-LABEL: @test_generic(
; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]])
; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1 ; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/salvage-dbg-declare.ll

; RUN: opt -instcombine -S -o - %s | FileCheck %s ; RUN: opt -passes=instcombine -S -o - %s | FileCheck %s
declare dso_local i32 @bar(i8*) declare dso_local i32 @bar(i8*)
; Function Attrs: nounwind ; Function Attrs: nounwind
define internal i32 @foo() #0 !dbg !1 { define internal i32 @foo() #0 !dbg !1 {
; CHECK: %[[VLA:.*]] = alloca [2 x i32] ; CHECK: %[[VLA:.*]] = alloca [2 x i32]
; CHECK: call void @llvm.dbg.declare(metadata [2 x i32]* %[[VLA]], {{.*}}, metadata !DIExpression()) ; CHECK: call void @llvm.dbg.declare(metadata [2 x i32]* %[[VLA]], {{.*}}, metadata !DIExpression())
Show All 40 Lines

llvm/test/Transforms/InstCombine/scalable-bitcast-inseltpoison.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; We shouldn't fold bitcast(insert <vscale x 1 x iX> .., iX %val, i32 0) ; We shouldn't fold bitcast(insert <vscale x 1 x iX> .., iX %val, i32 0)
; into bitcast(iX %val) for scalable vectors. ; into bitcast(iX %val) for scalable vectors.
define <vscale x 2 x i8> @bitcast_of_insert_i8_i16(i16 %val) #0 { define <vscale x 2 x i8> @bitcast_of_insert_i8_i16(i16 %val) #0 {
; CHECK-LABEL: @bitcast_of_insert_i8_i16( ; CHECK-LABEL: @bitcast_of_insert_i8_i16(
; CHECK-NOT: bitcast i16 %val to <vscale x 2 x i8> ; CHECK-NOT: bitcast i16 %val to <vscale x 2 x i8>
; CHECK: bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8> ; CHECK: bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8>
entry: entry:
%op2 = insertelement <vscale x 1 x i16> poison, i16 %val, i32 0 %op2 = insertelement <vscale x 1 x i16> poison, i16 %val, i32 0
%0 = bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8> %0 = bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8>
ret <vscale x 2 x i8> %0 ret <vscale x 2 x i8> %0
} }

llvm/test/Transforms/InstCombine/scalable-bitcast.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; We shouldn't fold bitcast(insert <vscale x 1 x iX> .., iX %val, i32 0) ; We shouldn't fold bitcast(insert <vscale x 1 x iX> .., iX %val, i32 0)
; into bitcast(iX %val) for scalable vectors. ; into bitcast(iX %val) for scalable vectors.
define <vscale x 2 x i8> @bitcast_of_insert_i8_i16(i16 %val) #0 { define <vscale x 2 x i8> @bitcast_of_insert_i8_i16(i16 %val) #0 {
; CHECK-LABEL: @bitcast_of_insert_i8_i16( ; CHECK-LABEL: @bitcast_of_insert_i8_i16(
; CHECK-NOT: bitcast i16 %val to <vscale x 2 x i8> ; CHECK-NOT: bitcast i16 %val to <vscale x 2 x i8>
; CHECK: bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8> ; CHECK: bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8>
entry: entry:
%op2 = insertelement <vscale x 1 x i16> undef, i16 %val, i32 0 %op2 = insertelement <vscale x 1 x i16> undef, i16 %val, i32 0
%0 = bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8> %0 = bitcast <vscale x 1 x i16> %op2 to <vscale x 2 x i8>
ret <vscale x 2 x i8> %0 ret <vscale x 2 x i8> %0
} }

llvm/test/Transforms/InstCombine/scalable-cast-of-alloc.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define void @fixed_array16i32_to_scalable4i32(<vscale x 4 x i32>* %out) { define void @fixed_array16i32_to_scalable4i32(<vscale x 4 x i32>* %out) {
; CHECK-LABEL: @fixed_array16i32_to_scalable4i32( ; CHECK-LABEL: @fixed_array16i32_to_scalable4i32(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP:%.*]] = alloca [16 x i32], align 16 ; CHECK-NEXT: [[TMP:%.*]] = alloca [16 x i32], align 16
; CHECK-NEXT: [[CAST:%.*]] = bitcast [16 x i32]* [[TMP]] to <vscale x 4 x i32>* ; CHECK-NEXT: [[CAST:%.*]] = bitcast [16 x i32]* [[TMP]] to <vscale x 4 x i32>*
; CHECK-NEXT: store volatile <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* [[CAST]], align 16 ; CHECK-NEXT: store volatile <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* [[CAST]], align 16
; CHECK-NEXT: [[RELOAD:%.*]] = load volatile <vscale x 4 x i32>, <vscale x 4 x i32>* [[CAST]], align 16 ; CHECK-NEXT: [[RELOAD:%.*]] = load volatile <vscale x 4 x i32>, <vscale x 4 x i32>* [[CAST]], align 16
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/scalable-const-fp-splat.ll

; RUN: opt -instcombine -S -o - < %s | FileCheck %s ; RUN: opt -passes=instcombine -S -o - < %s | FileCheck %s
define <vscale x 2 x float> @shrink_splat_scalable_extend(<vscale x 2 x float> %a) { define <vscale x 2 x float> @shrink_splat_scalable_extend(<vscale x 2 x float> %a) {
; CHECK-LABEL: @shrink_splat_scalable_extend ; CHECK-LABEL: @shrink_splat_scalable_extend
; CHECK-NEXT: %[[FADD:.*]] = fadd <vscale x 2 x float> %a, shufflevector (<vscale x 2 x float> insertelement (<vscale x 2 x float> undef, float -1.000000e+00, i32 0), <vscale x 2 x float> undef, <vscale x 2 x i32> zeroinitializer) ; CHECK-NEXT: %[[FADD:.*]] = fadd <vscale x 2 x float> %a, shufflevector (<vscale x 2 x float> insertelement (<vscale x 2 x float> undef, float -1.000000e+00, i32 0), <vscale x 2 x float> undef, <vscale x 2 x i32> zeroinitializer)
; CHECK-NEXT: ret <vscale x 2 x float> %[[FADD]] ; CHECK-NEXT: ret <vscale x 2 x float> %[[FADD]]
%1 = shufflevector <vscale x 2 x float> insertelement (<vscale x 2 x float> undef, float -1.000000e+00, i32 0), <vscale x 2 x float> undef, <vscale x 2 x i32> zeroinitializer %1 = shufflevector <vscale x 2 x float> insertelement (<vscale x 2 x float> undef, float -1.000000e+00, i32 0), <vscale x 2 x float> undef, <vscale x 2 x i32> zeroinitializer
%2 = fpext <vscale x 2 x float> %a to <vscale x 2 x double> %2 = fpext <vscale x 2 x float> %a to <vscale x 2 x double>
%3 = fpext <vscale x 2 x float> %1 to <vscale x 2 x double> %3 = fpext <vscale x 2 x float> %1 to <vscale x 2 x double>
%4 = fadd <vscale x 2 x double> %2, %3 %4 = fadd <vscale x 2 x double> %2, %3
%5 = fptrunc <vscale x 2 x double> %4 to <vscale x 2 x float> %5 = fptrunc <vscale x 2 x double> %4 to <vscale x 2 x float>
ret <vscale x 2 x float> %5 ret <vscale x 2 x float> %5
} }

llvm/test/Transforms/InstCombine/scalable-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; This test checks a regression in the select operand folding combine, in which ; This test checks a regression in the select operand folding combine, in which
; Constant::getUniqueInteger would crash for a scalable-vector zeroinitializer. ; Constant::getUniqueInteger would crash for a scalable-vector zeroinitializer.
define <vscale x 1 x i32> @select_opt(<vscale x 1 x i32> %b, <vscale x 1 x i1> %m) { define <vscale x 1 x i32> @select_opt(<vscale x 1 x i32> %b, <vscale x 1 x i1> %m) {
; CHECK-LABEL: @select_opt( ; CHECK-LABEL: @select_opt(
; CHECK-NEXT: [[C:%.*]] = add nsw <vscale x 1 x i32> [[B:%.*]], shufflevector (<vscale x 1 x i32> insertelement (<vscale x 1 x i32> undef, i32 2, i32 0), <vscale x 1 x i32> undef, <vscale x 1 x i32> zeroinitializer) ; CHECK-NEXT: [[C:%.*]] = add nsw <vscale x 1 x i32> [[B:%.*]], shufflevector (<vscale x 1 x i32> insertelement (<vscale x 1 x i32> undef, i32 2, i32 0), <vscale x 1 x i32> undef, <vscale x 1 x i32> zeroinitializer)
; CHECK-NEXT: [[D:%.*]] = select <vscale x 1 x i1> [[M:%.*]], <vscale x 1 x i32> [[C]], <vscale x 1 x i32> [[B]] ; CHECK-NEXT: [[D:%.*]] = select <vscale x 1 x i1> [[M:%.*]], <vscale x 1 x i32> [[C]], <vscale x 1 x i32> [[B]]
; CHECK-NEXT: ret <vscale x 1 x i32> [[D]] ; CHECK-NEXT: ret <vscale x 1 x i32> [[D]]
; ;
%head = insertelement <vscale x 1 x i32> undef, i32 2, i32 0 %head = insertelement <vscale x 1 x i32> undef, i32 2, i32 0
%splat = shufflevector <vscale x 1 x i32> %head, <vscale x 1 x i32> undef, <vscale x 1 x i32> zeroinitializer %splat = shufflevector <vscale x 1 x i32> %head, <vscale x 1 x i32> undef, <vscale x 1 x i32> zeroinitializer
%c = add nsw <vscale x 1 x i32> %b, %splat %c = add nsw <vscale x 1 x i32> %b, %splat
%d = select <vscale x 1 x i1> %m, <vscale x 1 x i32> %c, <vscale x 1 x i32> %b %d = select <vscale x 1 x i1> %m, <vscale x 1 x i32> %c, <vscale x 1 x i32> %b
ret <vscale x 1 x i32> %d ret <vscale x 1 x i32> %d
} }

llvm/test/Transforms/InstCombine/scalable-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define void @trunc_nxv2i64_to_nxv2i32(i32* %ptr, <vscale x 4 x i32> %v) { define void @trunc_nxv2i64_to_nxv2i32(i32* %ptr, <vscale x 4 x i32> %v) {
; CHECK-LABEL: @trunc_nxv2i64_to_nxv2i32( ; CHECK-LABEL: @trunc_nxv2i64_to_nxv2i32(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 31) ; CHECK-NEXT: [[TMP0:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 31)
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <vscale x 4 x i32> [[V:%.*]] to <vscale x 2 x i64> ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <vscale x 4 x i32> [[V:%.*]] to <vscale x 2 x i64>
; CHECK-NEXT: [[TMP2:%.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[TMP0]]) ; CHECK-NEXT: [[TMP2:%.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> [[TMP0]])
; CHECK-NEXT: [[TMP3:%.*]] = trunc <vscale x 2 x i64> [[TMP1]] to <vscale x 2 x i32> ; CHECK-NEXT: [[TMP3:%.*]] = trunc <vscale x 2 x i64> [[TMP1]] to <vscale x 2 x i32>
Show All 15 Lines

llvm/test/Transforms/InstCombine/scalarization-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i32 @extract_load(<4 x i32>* %p) { define i32 @extract_load(<4 x i32>* %p) {
; ;
; CHECK-LABEL: @extract_load( ; CHECK-LABEL: @extract_load(
; CHECK-NEXT: [[X:%.*]] = load <4 x i32>, <4 x i32>* [[P:%.*]], align 4 ; CHECK-NEXT: [[X:%.*]] = load <4 x i32>, <4 x i32>* [[P:%.*]], align 4
; CHECK-NEXT: [[EXT:%.*]] = extractelement <4 x i32> [[X]], i64 1 ; CHECK-NEXT: [[EXT:%.*]] = extractelement <4 x i32> [[X]], i64 1
; CHECK-NEXT: ret i32 [[EXT]] ; CHECK-NEXT: ret i32 [[EXT]]
; ;
▲ Show 20 Lines • Show All 350 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/scalarization.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i32 @extract_load(<4 x i32>* %p) { define i32 @extract_load(<4 x i32>* %p) {
; ;
; CHECK-LABEL: @extract_load( ; CHECK-LABEL: @extract_load(
; CHECK-NEXT: [[X:%.*]] = load <4 x i32>, <4 x i32>* [[P:%.*]], align 4 ; CHECK-NEXT: [[X:%.*]] = load <4 x i32>, <4 x i32>* [[P:%.*]], align 4
; CHECK-NEXT: [[EXT:%.*]] = extractelement <4 x i32> [[X]], i64 1 ; CHECK-NEXT: [[EXT:%.*]] = extractelement <4 x i32> [[X]], i64 1
; CHECK-NEXT: ret i32 [[EXT]] ; CHECK-NEXT: ret i32 [[EXT]]
; ;
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sdiv-2.ll

; RUN: opt < %s -instcombine -disable-output ; RUN: opt < %s -passes=instcombine -disable-output
; PR3144 ; PR3144
define fastcc i32 @func(i32 %length) nounwind { define fastcc i32 @func(i32 %length) nounwind {
entry: entry:
%0 = icmp ne i32 %length, -1 ; <i1> [#uses=1] %0 = icmp ne i32 %length, -1 ; <i1> [#uses=1]
%iftmp.13.0 = select i1 %0, i128 0, i128 200000000 ; <i128> [#uses=2] %iftmp.13.0 = select i1 %0, i128 0, i128 200000000 ; <i128> [#uses=2]
%1 = sdiv i128 %iftmp.13.0, 10 ; <i128> [#uses=1] %1 = sdiv i128 %iftmp.13.0, 10 ; <i128> [#uses=1]
br label %bb5 br label %bb5
Show All 19 Lines

llvm/test/Transforms/InstCombine/sdiv-canonicalize.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(i32) declare void @use(i32)
declare i32 @llvm.abs.i32(i32, i1) declare i32 @llvm.abs.i32(i32, 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_sdiv_canonicalize_op0(i32 %x, i32 %y) { define i32 @test_sdiv_canonicalize_op0(i32 %x, i32 %y) {
; CHECK-LABEL: @test_sdiv_canonicalize_op0( ; CHECK-LABEL: @test_sdiv_canonicalize_op0(
; CHECK-NEXT: [[SDIV1:%.*]] = sdiv i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[SDIV1:%.*]] = sdiv i32 [[X:%.*]], [[Y:%.*]]
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sdiv-exact-by-negative-power-of-two.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; x s/EXACT (-1 << y) ; x s/EXACT (-1 << y)
; to ; to
; -(x a>>EXACT y) ; -(x a>>EXACT y)
define i8 @t0(i8 %x) { define i8 @t0(i8 %x) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sdiv-exact-by-power-of-two.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; x s/EXACT (1 << y) ; x s/EXACT (1 << y)
; to ; to
; x a>>EXACT y ; x a>>EXACT y
; iff 1<<y is non-negative ; iff 1<<y is non-negative
define i8 @t0(i8 %x) { define i8 @t0(i8 %x) {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sdiv-guard.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
; Regression test. If %flag is false then %s == 0 and guard should be triggered. ; Regression test. If %flag is false then %s == 0 and guard should be triggered.
define i32 @a(i1 %flag, i32 %X) nounwind readnone { define i32 @a(i1 %flag, i32 %X) nounwind readnone {
; CHECK-LABEL: @a( ; CHECK-LABEL: @a(
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[X:%.*]], 0
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) #2 [ "deopt"() ] ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) #2 [ "deopt"() ]
Show All 9 Lines

llvm/test/Transforms/InstCombine/sdiv-of-non-negative-by-negative-power-of-two.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; x s/ (-1 << y) ; x s/ (-1 << y)
; to ; to
; -(x >> y) ; -(x >> y)
; iff x is known non-negative. ; iff x is known non-negative.
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
Show All 38 Lines

llvm/test/Transforms/InstCombine/select-2.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Make sure instcombine don't fold select into operands. We don't want to emit ; Make sure instcombine don't fold select into operands. We don't want to emit
; select of two integers unless it's selecting 0 / 1. ; select of two integers unless it's selecting 0 / 1.
define i32 @t1(i32 %c, i32 %x) { define i32 @t1(i32 %c, i32 %x) {
; CHECK-LABEL: @t1( ; CHECK-LABEL: @t1(
; CHECK-NEXT: [[T1:%.*]] = icmp eq i32 [[C:%.*]], 0 ; CHECK-NEXT: [[T1:%.*]] = icmp eq i32 [[C:%.*]], 0
; CHECK-NEXT: [[T2:%.*]] = lshr i32 [[X:%.*]], 18 ; CHECK-NEXT: [[T2:%.*]] = lshr i32 [[X:%.*]], 18
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-and-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare void @use(i1) declare void @use(i1)
; Should not be converted to "and", which has different poison semantics. ; Should not be converted to "and", which has different poison semantics.
define i1 @logical_and(i1 %a, i1 %b) { define i1 @logical_and(i1 %a, i1 %b) {
; CHECK-LABEL: @logical_and( ; CHECK-LABEL: @logical_and(
; CHECK-NEXT: [[RES:%.*]] = select i1 [[A:%.*]], i1 [[B:%.*]], i1 false ; CHECK-NEXT: [[RES:%.*]] = select i1 [[A:%.*]], i1 [[B:%.*]], i1 false
; CHECK-NEXT: ret i1 [[RES]] ; CHECK-NEXT: ret i1 [[RES]]
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-binop-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(<2 x i1>) declare void @use(<2 x i1>)
declare void @use2(i1) declare void @use2(i1)
define i32 @select_xor_icmp(i32 %x, i32 %y, i32 %z) { define i32 @select_xor_icmp(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: @select_xor_icmp( ; CHECK-LABEL: @select_xor_icmp(
; CHECK-NEXT: [[A:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[A:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[C:%.*]] = select i1 [[A]], i32 [[Z:%.*]], i32 [[Y:%.*]] ; CHECK-NEXT: [[C:%.*]] = select i1 [[A]], i32 [[Z:%.*]], i32 [[Y:%.*]]
▲ Show 20 Lines • Show All 1,305 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-binop-foldable-floating-point.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define float @select_fadd(i1 %cond, float %A, float %B) { define float @select_fadd(i1 %cond, float %A, float %B) {
; CHECK-LABEL: @select_fadd( ; CHECK-LABEL: @select_fadd(
; CHECK-NEXT: [[C:%.*]] = select i1 [[COND:%.*]], float [[B:%.*]], float -0.000000e+00 ; CHECK-NEXT: [[C:%.*]] = select i1 [[COND:%.*]], float [[B:%.*]], float -0.000000e+00
; CHECK-NEXT: [[D:%.*]] = fadd float [[C]], [[A:%.*]] ; CHECK-NEXT: [[D:%.*]] = fadd float [[C]], [[A:%.*]]
; CHECK-NEXT: ret float [[D]] ; CHECK-NEXT: ret float [[D]]
; ;
%C = fadd float %A, %B %C = fadd float %A, %B
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-bitext-bitwise-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define i64 @sel_false_val_is_a_masked_shl_of_true_val1(i32 %x, i64 %y) { define i64 @sel_false_val_is_a_masked_shl_of_true_val1(i32 %x, i64 %y) {
; CHECK-LABEL: @sel_false_val_is_a_masked_shl_of_true_val1( ; CHECK-LABEL: @sel_false_val_is_a_masked_shl_of_true_val1(
; CHECK-NEXT: [[TMP1:%.*]] = shl i32 [[X:%.*]], 2 ; CHECK-NEXT: [[TMP1:%.*]] = shl i32 [[X:%.*]], 2
; CHECK-NEXT: [[TMP2:%.*]] = and i32 [[TMP1]], 60 ; CHECK-NEXT: [[TMP2:%.*]] = and i32 [[TMP1]], 60
; CHECK-NEXT: [[TMP3:%.*]] = zext i32 [[TMP2]] to i64 ; CHECK-NEXT: [[TMP3:%.*]] = zext i32 [[TMP2]] to i64
; CHECK-NEXT: [[TMP4:%.*]] = ashr i64 [[Y:%.*]], [[TMP3]] ; CHECK-NEXT: [[TMP4:%.*]] = ashr i64 [[Y:%.*]], [[TMP3]]
; CHECK-NEXT: ret i64 [[TMP4]] ; CHECK-NEXT: ret i64 [[TMP4]]
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-bitext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use32(i32) declare void @use32(i32)
; Widen a select of constants to eliminate an extend. ; Widen a select of constants to eliminate an extend.
define i16 @sel_sext_constants(i1 %cmp) { define i16 @sel_sext_constants(i1 %cmp) {
; CHECK-LABEL: @sel_sext_constants( ; CHECK-LABEL: @sel_sext_constants(
; CHECK-NEXT: [[EXT:%.*]] = select i1 [[CMP:%.*]], i16 -1, i16 42 ; CHECK-NEXT: [[EXT:%.*]] = select i1 [[CMP:%.*]], i16 -1, i16 42
▲ Show 20 Lines • Show All 641 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-cmp-br.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Replace a 'select' with 'or' in 'select - cmp [eq|ne] - br' sequence ; Replace a 'select' with 'or' in 'select - cmp [eq|ne] - br' sequence
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
%struct.S = type { i64*, i32, i32 } %struct.S = type { i64*, i32, i32 }
%C = type <{ %struct.S }> %C = type <{ %struct.S }>
declare void @bar(%struct.S*) declare void @bar(%struct.S*)
declare void @foobar() declare void @foobar()
define void @test1(%C* %arg) { define void @test1(%C* %arg) {
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-cmp-cttz-ctlz.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; This test is to verify that the instruction combiner is able to fold ; This test is to verify that the instruction combiner is able to fold
; a cttz/ctlz followed by a icmp + select into a single cttz/ctlz with ; a cttz/ctlz followed by a icmp + select into a single cttz/ctlz with
; the 'is_zero_undef' flag cleared. ; the 'is_zero_undef' flag cleared.
define i16 @test1(i16 %x) { define i16 @test1(i16 %x) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0
▲ Show 20 Lines • Show All 535 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-cmpxchg.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i64 @cmpxchg_0(i64* %ptr, i64 %compare, i64 %new_value) { define i64 @cmpxchg_0(i64* %ptr, i64 %compare, i64 %new_value) {
; CHECK-LABEL: @cmpxchg_0( ; CHECK-LABEL: @cmpxchg_0(
; CHECK-NEXT: %tmp0 = cmpxchg i64* %ptr, i64 %compare, i64 %new_value seq_cst seq_cst ; CHECK-NEXT: %tmp0 = cmpxchg i64* %ptr, i64 %compare, i64 %new_value seq_cst seq_cst
; CHECK-NEXT: %tmp2 = extractvalue { i64, i1 } %tmp0, 0 ; CHECK-NEXT: %tmp2 = extractvalue { i64, i1 } %tmp0, 0
; CHECK-NEXT: ret i64 %tmp2 ; CHECK-NEXT: ret i64 %tmp2
; ;
%tmp0 = cmpxchg i64* %ptr, i64 %compare, i64 %new_value seq_cst seq_cst %tmp0 = cmpxchg i64* %ptr, i64 %compare, i64 %new_value seq_cst seq_cst
Show All 30 Lines

llvm/test/Transforms/InstCombine/select-crash.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Formerly crashed, PR8490. ; Formerly crashed, PR8490.
define fastcc double @gimp_operation_color_balance_map(float %value, double %highlights) nounwind readnone inlinehint { define fastcc double @gimp_operation_color_balance_map(float %value, double %highlights) nounwind readnone inlinehint {
entry: entry:
; CHECK: gimp_operation_color_balance_map ; CHECK: gimp_operation_color_balance_map
; CHECK: fneg double ; CHECK: fneg double
%conv = fpext float %value to double %conv = fpext float %value to double
%div = fdiv double %conv, 1.600000e+01 %div = fdiv double %conv, 1.600000e+01
Show All 23 Lines

llvm/test/Transforms/InstCombine/select-ctlz-to-cttz.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare i3 @llvm.cttz.i3(i3, i1) declare i3 @llvm.cttz.i3(i3, i1)
declare i32 @llvm.cttz.i32(i32, i1 immarg) declare i32 @llvm.cttz.i32(i32, i1 immarg)
declare i32 @llvm.ctlz.i32(i32, i1 immarg) declare i32 @llvm.ctlz.i32(i32, i1 immarg)
declare i64 @llvm.cttz.i64(i64, i1 immarg) declare i64 @llvm.cttz.i64(i64, i1 immarg)
declare i64 @llvm.ctlz.i64(i64, i1 immarg) declare i64 @llvm.ctlz.i64(i64, i1 immarg)
declare <2 x i32> @llvm.ctlz.v2i32(<2 x i32>, i1) declare <2 x i32> @llvm.ctlz.v2i32(<2 x i32>, i1)
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-extractelement-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare void @v4float_user(<4 x float>) #0 declare void @v4float_user(<4 x float>) #0
define float @extract_one_select(<4 x float> %a, <4 x float> %b, i32 %c) #0 { define float @extract_one_select(<4 x float> %a, <4 x float> %b, i32 %c) #0 {
; CHECK-LABEL: @extract_one_select( ; CHECK-LABEL: @extract_one_select(
; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i32 [[C:%.*]], 0 ; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i32 [[C:%.*]], 0
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP_NOT]], <4 x float> [[B:%.*]], <4 x float> [[A:%.*]] ; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP_NOT]], <4 x float> [[B:%.*]], <4 x float> [[A:%.*]]
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SEL]], i64 2 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SEL]], i64 2
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-extractelement.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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare void @v4float_user(<4 x float>) #0 declare void @v4float_user(<4 x float>) #0
define float @extract_one_select(<4 x float> %a, <4 x float> %b, i32 %c) #0 { define float @extract_one_select(<4 x float> %a, <4 x float> %b, i32 %c) #0 {
; CHECK-LABEL: @extract_one_select( ; CHECK-LABEL: @extract_one_select(
; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i32 [[C:%.*]], 0 ; CHECK-NEXT: [[CMP_NOT:%.*]] = icmp eq i32 [[C:%.*]], 0
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP_NOT]], <4 x float> [[B:%.*]], <4 x float> [[A:%.*]] ; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP_NOT]], <4 x float> [[B:%.*]], <4 x float> [[A:%.*]]
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SEL]], i64 2 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SEL]], i64 2
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32* @test1a(i32* %p, i32* %q) { define i32* @test1a(i32* %p, i32* %q) {
; CHECK-LABEL: @test1a( ; CHECK-LABEL: @test1a(
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32* [[P:%.*]], [[Q:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i32* [[P:%.*]], [[Q:%.*]]
; CHECK-NEXT: [[SELECT_V:%.*]] = select i1 [[CMP]], i32* [[P]], i32* [[Q]] ; CHECK-NEXT: [[SELECT_V:%.*]] = select i1 [[CMP]], i32* [[P]], i32* [[Q]]
; CHECK-NEXT: [[SELECT:%.*]] = getelementptr i32, i32* [[SELECT_V]], i64 4 ; CHECK-NEXT: [[SELECT:%.*]] = getelementptr i32, i32* [[SELECT_V]], i64 4
; CHECK-NEXT: ret i32* [[SELECT]] ; CHECK-NEXT: ret i32* [[SELECT]]
; ;
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-icmp-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
;; ((X & 27) ? 27 : 0) ;; ((X & 27) ? 27 : 0)
define i41 @test5(i41 %X) { define i41 @test5(i41 %X) {
; CHECK-LABEL: @test5( ; CHECK-LABEL: @test5(
; CHECK-NEXT: [[Y:%.*]] = and i41 [[X:%.*]], 32 ; CHECK-NEXT: [[Y:%.*]] = and i41 [[X:%.*]], 32
; CHECK-NEXT: ret i41 [[Y]] ; CHECK-NEXT: ret i41 [[Y]]
; ;
▲ Show 20 Lines • Show All 610 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-load-call.ll

; RUN: opt < %s -instcombine -S | grep "ret i32 1" ; RUN: opt < %s -passes=instcombine -S | grep "ret i32 1"
declare void @test2() declare void @test2()
define i32 @test(i1 %cond, i32 *%P) { define i32 @test(i1 %cond, i32 *%P) {
%A = alloca i32 %A = alloca i32
store i32 1, i32* %P store i32 1, i32* %P
store i32 1, i32* %A store i32 1, i32* %A
call void @test2() readonly call void @test2() readonly
%P2 = select i1 %cond, i32 *%P, i32* %A %P2 = select i1 %cond, i32 *%P, i32* %A
%V = load i32, i32* %P2 %V = load i32, i32* %P2
ret i32 %V ret i32 %V
} }

llvm/test/Transforms/InstCombine/select-masked_load.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold zeroing of inactive lanes into the load's passthrough parameter. ; Fold zeroing of inactive lanes into the load's passthrough parameter.
define <4 x float> @masked_load_and_zero_inactive_1(<4 x float>* %ptr, <4 x i1> %mask) { define <4 x float> @masked_load_and_zero_inactive_1(<4 x float>* %ptr, <4 x i1> %mask) {
; CHECK-LABEL: @masked_load_and_zero_inactive_1( ; CHECK-LABEL: @masked_load_and_zero_inactive_1(
; CHECK: %load = call <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>* %ptr, i32 4, <4 x i1> %mask, <4 x float> zeroinitializer) ; CHECK: %load = call <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>* %ptr, i32 4, <4 x i1> %mask, <4 x float> zeroinitializer)
; CHECK-NEXT: ret <4 x float> %load ; CHECK-NEXT: ret <4 x float> %load
%load = call <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>* %ptr, i32 4, <4 x i1> %mask, <4 x float> undef) %load = call <4 x float> @llvm.masked.load.v4f32.p0v4f32(<4 x float>* %ptr, i32 4, <4 x i1> %mask, <4 x float> undef)
%masked = select <4 x i1> %mask, <4 x float> %load, <4 x float> zeroinitializer %masked = select <4 x i1> %mask, <4 x float> %load, <4 x float> zeroinitializer
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i5 @llvm.smin.i5(i5, i5) declare i5 @llvm.smin.i5(i5, i5)
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 i5 @llvm.umin.i5(i5, i5) declare i5 @llvm.umin.i5(i5, i5)
declare <3 x i5> @llvm.umax.v3i5(<3 x i5>, <3 x i5>) declare <3 x i5> @llvm.umax.v3i5(<3 x i5>, <3 x i5>)
define i5 @smin_smin_common_op_00(i1 %cond, i5 %x, i5 %y, i5 %z) { define i5 @smin_smin_common_op_00(i1 %cond, i5 %x, i5 %y, i5 %z) {
; CHECK-LABEL: @smin_smin_common_op_00( ; CHECK-LABEL: @smin_smin_common_op_00(
▲ Show 20 Lines • Show All 245 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-obo-peo-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define i64 @test_shl_nuw_nsw__all_are_safe(i32 %x, i64 %y) { define i64 @test_shl_nuw_nsw__all_are_safe(i32 %x, i64 %y) {
; CHECK-LABEL: @test_shl_nuw_nsw__all_are_safe( ; CHECK-LABEL: @test_shl_nuw_nsw__all_are_safe(
; CHECK-NEXT: [[TMP1:%.*]] = shl i32 [[X:%.*]], 2 ; CHECK-NEXT: [[TMP1:%.*]] = shl i32 [[X:%.*]], 2
; CHECK-NEXT: [[TMP2:%.*]] = and i32 [[TMP1]], 60 ; CHECK-NEXT: [[TMP2:%.*]] = and i32 [[TMP1]], 60
; CHECK-NEXT: [[TMP3:%.*]] = zext i32 [[TMP2]] to i64 ; CHECK-NEXT: [[TMP3:%.*]] = zext i32 [[TMP2]] to i64
; CHECK-NEXT: [[TMP4:%.*]] = ashr i64 [[Y:%.*]], [[TMP3]] ; CHECK-NEXT: [[TMP4:%.*]] = ashr i64 [[Y:%.*]], [[TMP3]]
; CHECK-NEXT: ret i64 [[TMP4]] ; CHECK-NEXT: ret i64 [[TMP4]]
▲ Show 20 Lines • Show All 1,001 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-of-bittest.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; https://bugs.llvm.org/show_bug.cgi?id=36950 ; https://bugs.llvm.org/show_bug.cgi?id=36950
; These all should be just and+icmp, there should be no select. ; These all should be just and+icmp, there should be no select.
define i32 @and_lshr_and(i32 %arg) { define i32 @and_lshr_and(i32 %arg) {
; CHECK-LABEL: @and_lshr_and( ; CHECK-LABEL: @and_lshr_and(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[ARG:%.*]], 3 ; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[ARG:%.*]], 3
▲ Show 20 Lines • Show All 646 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-pr39595.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @foo(i32 %x, i32 %y) { define i32 @foo(i32 %x, i32 %y) {
; CHECK-LABEL: foo ; CHECK-LABEL: foo
; CHECK: [[TMP1:%.*]] = icmp ugt i32 %x, %y ; CHECK: [[TMP1:%.*]] = icmp ugt i32 %x, %y
; CHECK-NEXT: [[TMP2:%.*]] = select i1 [[TMP1]], i32 %x, i32 %y, !prof ![[$MD0:[0-9]+]] ; CHECK-NEXT: [[TMP2:%.*]] = select i1 [[TMP1]], i32 %x, i32 %y, !prof ![[$MD0:[0-9]+]]
; CHECK-NEXT: [[TMP3:%.*]] = xor i32 [[TMP2]], -1 ; CHECK-NEXT: [[TMP3:%.*]] = xor i32 [[TMP2]], -1
; CHECK-NEXT: ret i32 [[TMP3:%.*]] ; CHECK-NEXT: ret i32 [[TMP3:%.*]]
; CHECK-DAG: !0 = !{!"branch_weights", i32 6, i32 1} ; CHECK-DAG: !0 = !{!"branch_weights", i32 6, i32 1}
Show All 9 Lines

llvm/test/Transforms/InstCombine/select-safe-bool-transforms.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; TODO: All of these should be optimized to less than or equal to a single ; TODO: All of these should be optimized to less than or equal to a single
; instruction of select/and/or. ; instruction of select/and/or.
; --- (A op B) op' A / (B op A) op' A --- ; --- (A op B) op' A / (B op A) op' A ---
; (A land B) land A ; (A land B) land A
define i1 @land_land_left1(i1 %A, i1 %B) { define i1 @land_land_left1(i1 %A, i1 %B) {
▲ Show 20 Lines • Show All 485 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-safe-impliedcond-transforms.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @a_true_implies_b_true(i8 %z, i1 %X, i1 %Y) { define i1 @a_true_implies_b_true(i8 %z, i1 %X, i1 %Y) {
; CHECK-LABEL: @a_true_implies_b_true( ; CHECK-LABEL: @a_true_implies_b_true(
; CHECK-NEXT: [[A:%.*]] = icmp ugt i8 [[Z:%.*]], 20 ; CHECK-NEXT: [[A:%.*]] = icmp ugt i8 [[Z:%.*]], 20
; CHECK-NEXT: [[RES:%.*]] = select i1 [[A]], i1 [[X:%.*]], i1 false ; CHECK-NEXT: [[RES:%.*]] = select i1 [[A]], i1 [[X:%.*]], i1 false
; CHECK-NEXT: ret i1 [[RES]] ; CHECK-NEXT: ret i1 [[RES]]
; ;
%a = icmp ugt i8 %z, 20 %a = icmp ugt i8 %z, 20
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-safe-transforms.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @cond_eq_and(i8 %X, i8 %Y, i8 noundef %C) { define i1 @cond_eq_and(i8 %X, i8 %Y, i8 noundef %C) {
; CHECK-LABEL: @cond_eq_and( ; CHECK-LABEL: @cond_eq_and(
; CHECK-NEXT: [[COND:%.*]] = icmp eq i8 [[X:%.*]], [[C:%.*]] ; CHECK-NEXT: [[COND:%.*]] = icmp eq i8 [[X:%.*]], [[C:%.*]]
; CHECK-NEXT: [[LHS:%.*]] = icmp ult i8 [[X]], [[Y:%.*]] ; CHECK-NEXT: [[LHS:%.*]] = icmp ult i8 [[X]], [[Y:%.*]]
; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND]], i1 [[LHS]], i1 false ; CHECK-NEXT: [[RES:%.*]] = select i1 [[COND]], i1 [[LHS]], i1 false
; CHECK-NEXT: ret i1 [[RES]] ; CHECK-NEXT: ret i1 [[RES]]
; ;
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define float @foo1(float %a) { define float @foo1(float %a) {
; CHECK-LABEL: @foo1( ; CHECK-LABEL: @foo1(
; CHECK-NEXT: [[B:%.*]] = fcmp ogt float [[A:%.*]], 0.000000e+00 ; CHECK-NEXT: [[B:%.*]] = fcmp ogt float [[A:%.*]], 0.000000e+00
; CHECK-NEXT: [[C:%.*]] = select i1 [[B]], float [[A]], float 0.000000e+00 ; CHECK-NEXT: [[C:%.*]] = select i1 [[B]], float [[A]], float 0.000000e+00
; CHECK-NEXT: [[D:%.*]] = fcmp olt float [[C]], 1.000000e+00 ; CHECK-NEXT: [[D:%.*]] = fcmp olt float [[C]], 1.000000e+00
; CHECK-NEXT: [[F:%.*]] = select i1 [[D]], float [[C]], float 1.000000e+00 ; CHECK-NEXT: [[F:%.*]] = select i1 [[D]], float [[C]], float 1.000000e+00
; CHECK-NEXT: ret float [[F]] ; CHECK-NEXT: ret float [[F]]
▲ Show 20 Lines • Show All 167 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-with-bitwise-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "n8:16:32:64" target datalayout = "n8:16:32:64"
declare void @use(i8) declare void @use(i8)
declare void @use_vec(<2 x i8>) declare void @use_vec(<2 x i8>)
define i32 @select_icmp_eq_and_1_0_or_2(i32 %x, i32 %y) { define i32 @select_icmp_eq_and_1_0_or_2(i32 %x, i32 %y) {
; CHECK-LABEL: @select_icmp_eq_and_1_0_or_2( ; CHECK-LABEL: @select_icmp_eq_and_1_0_or_2(
▲ Show 20 Lines • Show All 1,564 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; PR1822 ; PR1822
target datalayout = "e-p:64:64-p1:16:16-p2:32:32:32-p3:64:64:64" target datalayout = "e-p:64:64-p1:16:16-p2:32:32:32-p3:64:64:64"
define i1 @test5(i1 %C) { define i1 @test5(i1 %C) {
; CHECK-LABEL: @test5( ; CHECK-LABEL: @test5(
; CHECK-NEXT: [[NOT_C:%.*]] = xor i1 [[C:%.*]], true ; CHECK-NEXT: [[NOT_C:%.*]] = xor i1 [[C:%.*]], true
▲ Show 20 Lines • Show All 3,004 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
; Tests folding constants from two similar selects that feed a add ; Tests folding constants from two similar selects that feed a add
define float @test1a(i1 zeroext %arg) #0 { define float @test1a(i1 zeroext %arg) #0 {
; CHECK-LABEL: @test1a( ; CHECK-LABEL: @test1a(
; CHECK-NEXT: [[TMP2:%.*]] = select i1 [[ARG:%.*]], float 6.000000e+00, float 1.500000e+01 ; CHECK-NEXT: [[TMP2:%.*]] = select i1 [[ARG:%.*]], float 6.000000e+00, float 1.500000e+01
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select_meta.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; and enhanced to include metadata checking. ; and enhanced to include metadata checking.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @foo(i32) local_unnamed_addr #0 { define i32 @foo(i32) local_unnamed_addr #0 {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP0:%.*]], 2 ; CHECK-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP0:%.*]], 2
; CHECK-NEXT: [[DOTV:%.*]] = select i1 [[TMP2]], i32 20, i32 -20, !prof !0 ; CHECK-NEXT: [[DOTV:%.*]] = select i1 [[TMP2]], i32 20, i32 -20, !prof !0
; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[DOTV]], [[TMP0]] ; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[DOTV]], [[TMP0]]
; CHECK-NEXT: ret i32 [[TMP3]] ; CHECK-NEXT: ret i32 [[TMP3]]
; ;
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/set-lowbits-mask-canonicalize.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; https://bugs.llvm.org/show_bug.cgi?id=37603 ; https://bugs.llvm.org/show_bug.cgi?id=37603
; Pattern: ; Pattern:
; (1 << NBits) - 1 ; (1 << NBits) - 1
; Should be transformed into: ; Should be transformed into:
; ~(-(1 << NBits)) ; ~(-(1 << NBits))
; The `not` may end up being folded into `and` ; The `not` may end up being folded into `and`
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/set.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; This test makes sure that all icmp instructions are eliminated. ; This test makes sure that all icmp instructions are eliminated.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@X = external global i32 @X = external global i32
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
; ;
%B = icmp eq i32 %A, %A %B = icmp eq i32 %A, %A
▲ Show 20 Lines • Show All 442 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/setcc-strength-reduce.ll

; This test ensures that "strength reduction" of conditional expressions are ; This test ensures that "strength reduction" of conditional expressions are
; working. Basically this boils down to converting setlt,gt,le,ge instructions ; working. Basically this boils down to converting setlt,gt,le,ge instructions
; into equivalent setne,eq instructions. ; into equivalent setne,eq instructions.
; ;
; RUN: opt < %s -instcombine -S | \ ; RUN: opt < %s -passes=instcombine -S | \
; RUN: grep -v "icmp eq" | grep -v "icmp ne" | not grep icmp ; RUN: grep -v "icmp eq" | grep -v "icmp ne" | not grep icmp
; END. ; END.
define i1 @test1(i32 %A) { define i1 @test1(i32 %A) {
; setne %A, 0 ; setne %A, 0
%B = icmp uge i32 %A, 1 ; <i1> [#uses=1] %B = icmp uge i32 %A, 1 ; <i1> [#uses=1]
ret i1 %B ret i1 %B
} }
Show All 24 Lines

llvm/test/Transforms/InstCombine/sext-of-trunc-nsw.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Iff we know that trunc only chops off the sign bits, ; Iff we know that trunc only chops off the sign bits,
; and not all of them, then we can bypass said trunc ; and not all of them, then we can bypass said trunc
; for the purpose of sign extension. ; for the purpose of sign extension.
declare void @use8(i8) declare void @use8(i8)
declare void @use4(i4) declare void @use4(i4)
declare void @usevec(<2 x i8>) declare void @usevec(<2 x i8>)
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
declare i32 @llvm.ctpop.i32(i32) declare i32 @llvm.ctpop.i32(i32)
declare i32 @llvm.ctlz.i32(i32, i1) declare i32 @llvm.ctlz.i32(i32, i1)
declare i32 @llvm.cttz.i32(i32, i1) declare i32 @llvm.cttz.i32(i32, i1)
declare void @use(i8) declare void @use(i8)
declare void @use_vec(<2 x i5>) declare void @use_vec(<2 x i5>)
▲ Show 20 Lines • Show All 388 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-add-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; This test makes sure that these instructions are properly eliminated. ; This test makes sure that these instructions are properly eliminated.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @shl_C1_add_A_C2_i32(i16 %A) { define i32 @shl_C1_add_A_C2_i32(i16 %A) {
; CHECK-LABEL: @shl_C1_add_A_C2_i32( ; CHECK-LABEL: @shl_C1_add_A_C2_i32(
; CHECK-NEXT: [[B:%.*]] = zext i16 [[A:%.*]] to i32 ; CHECK-NEXT: [[B:%.*]] = zext i16 [[A:%.*]] to i32
; CHECK-NEXT: [[D:%.*]] = shl i32 192, [[B]] ; CHECK-NEXT: [[D:%.*]] = shl i32 192, [[B]]
; CHECK-NEXT: ret i32 [[D]] ; CHECK-NEXT: ret i32 [[D]]
; ;
%B = zext i16 %A to i32 %B = zext i16 %A to i32
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-add.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; This test makes sure that these instructions are properly eliminated. ; This test makes sure that these instructions are properly eliminated.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @shl_C1_add_A_C2_i32(i16 %A) { define i32 @shl_C1_add_A_C2_i32(i16 %A) {
; CHECK-LABEL: @shl_C1_add_A_C2_i32( ; CHECK-LABEL: @shl_C1_add_A_C2_i32(
; CHECK-NEXT: [[B:%.*]] = zext i16 [[A:%.*]] to i32 ; CHECK-NEXT: [[B:%.*]] = zext i16 [[A:%.*]] to i32
; CHECK-NEXT: [[D:%.*]] = shl i32 192, [[B]] ; CHECK-NEXT: [[D:%.*]] = shl i32 192, [[B]]
; CHECK-NEXT: ret i32 [[D]] ; CHECK-NEXT: ret i32 [[D]]
; ;
%B = zext i16 %A to i32 %B = zext i16 %A to i32
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation-in-bittest-with-truncation-lshr.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Given pattern: ; Given pattern:
; icmp eq/ne (and ((x shift Q), (y oppositeshift K))), 0 ; icmp eq/ne (and ((x shift Q), (y oppositeshift K))), 0
; we should move shifts to the same hand of 'and', i.e. e.g. rewrite as ; we should move shifts to the same hand of 'and', i.e. e.g. rewrite as
; icmp eq/ne (and (((x shift Q) shift K), y)), 0 ; icmp eq/ne (and (((x shift Q) shift K), y)), 0
; We are only interested in opposite logical shifts here. ; We are only interested in opposite logical shifts here.
; We still can handle the case where there is a truncation between a shift ; We still can handle the case where there is a truncation between a shift
; and an 'and', thought the legality check isn't obvious. ; and an 'and', thought the legality check isn't obvious.
▲ Show 20 Lines • Show All 458 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation-in-bittest-with-truncation-shl.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Given pattern: ; Given pattern:
; icmp eq/ne (and ((x shift Q), (y oppositeshift K))), 0 ; icmp eq/ne (and ((x shift Q), (y oppositeshift K))), 0
; we should move shifts to the same hand of 'and', i.e. e.g. rewrite as ; we should move shifts to the same hand of 'and', i.e. e.g. rewrite as
; icmp eq/ne (and (((x shift Q) shift K), y)), 0 ; icmp eq/ne (and (((x shift Q) shift K), y)), 0
; We are only interested in opposite logical shifts here. ; We are only interested in opposite logical shifts here.
; We still can handle the case where there is a truncation between a shift and ; We still can handle the case where there is a truncation between a shift and
; an 'and'. If it's trunc-of-shl - no extra legality check is needed. ; an 'and'. If it's trunc-of-shl - no extra legality check is needed.
▲ Show 20 Lines • Show All 451 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation-in-bittest.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Given pattern: ; Given pattern:
; icmp eq/ne (and ((x shift Q), (y oppositeshift K))), 0 ; icmp eq/ne (and ((x shift Q), (y oppositeshift K))), 0
; we should move shifts to the same hand of 'and', i.e. e.g. rewrite as ; we should move shifts to the same hand of 'and', i.e. e.g. rewrite as
; icmp eq/ne (and (((x shift Q) shift K), y)), 0 ; icmp eq/ne (and (((x shift Q) shift K), y)), 0
; We are only interested in opposite logical shifts here. ; We are only interested in opposite logical shifts here.
; Basic scalar test with constants ; Basic scalar test with constants
▲ Show 20 Lines • Show All 699 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation-with-truncation-ashr.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Given pattern: ; Given pattern:
; (trunc (iSrc x a>> Q) to iDst) a>> K ; (trunc (iSrc x a>> Q) to iDst) a>> K
; we should rewrite it as ; we should rewrite it as
; (trunc (iSrc x a>> (Q+K)) to iDst) ; (trunc (iSrc x a>> (Q+K)) to iDst)
; iff (Q+K) is bitwidth(iSrc)-1 ; iff (Q+K) is bitwidth(iSrc)-1
; THIS FOLD DOES *NOT* REQUIRE ANY 'nuw'/`nsw` FLAGS! ; THIS FOLD DOES *NOT* REQUIRE ANY 'nuw'/`nsw` FLAGS!
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation-with-truncation-lshr.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Given pattern: ; Given pattern:
; (trunc (iSrc x l>> Q) to iDst) l>> K ; (trunc (iSrc x l>> Q) to iDst) l>> K
; we should rewrite it as ; we should rewrite it as
; (trunc (iSrc x l>> (Q+K)) to iDst) ; (trunc (iSrc x l>> (Q+K)) to iDst)
; iff (Q+K) is bitwidth(iSrc)-1 ; iff (Q+K) is bitwidth(iSrc)-1
; THIS FOLD DOES *NOT* REQUIRE ANY 'nuw'/`nsw` FLAGS! ; THIS FOLD DOES *NOT* REQUIRE ANY 'nuw'/`nsw` FLAGS!
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation-with-truncation-shl.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "n8:16:32" target datalayout = "n8:16:32"
; Given pattern: ; Given pattern:
; (trunc (x << Q) to iDst) << K ; (trunc (x << Q) to iDst) << K
; we should rewrite it as ; we should rewrite it as
; (trunc (x << (Q+K)) to iDst) iff (Q+K) u< iDst ; (trunc (x << (Q+K)) to iDst) iff (Q+K) u< iDst
; This is only valid for shl. ; This is only valid for shl.
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-amount-reassociation.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Given pattern: ; Given pattern:
; (x shiftopcode Q) shiftopcode K ; (x shiftopcode Q) shiftopcode K
; we should rewrite it as ; we should rewrite it as
; x shiftopcode (Q+K) iff (Q+K) u< bitwidth(x) ; x shiftopcode (Q+K) iff (Q+K) u< bitwidth(x)
; This is valid for any shift, but they must be identical. ; This is valid for any shift, but they must be identical.
; THIS FOLD DOES *NOT* REQUIRE ANY 'exact'/'nuw'/`nsw` FLAGS! ; THIS FOLD DOES *NOT* REQUIRE ANY 'exact'/'nuw'/`nsw` FLAGS!
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-by-signext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have a shift by sign-extended value, we can replace sign-extension ; If we have a shift by sign-extended value, we can replace sign-extension
; with zero-extension. ; with zero-extension.
define i32 @t0_shl(i32 %x, i8 %shamt) { define i32 @t0_shl(i32 %x, i8 %shamt) {
; CHECK-LABEL: @t0_shl( ; CHECK-LABEL: @t0_shl(
; CHECK-NEXT: [[SHAMT_WIDE1:%.*]] = zext i8 [[SHAMT:%.*]] to i32 ; CHECK-NEXT: [[SHAMT_WIDE1:%.*]] = zext i8 [[SHAMT:%.*]] to i32
; CHECK-NEXT: [[R:%.*]] = shl i32 [[X:%.*]], [[SHAMT_WIDE1]] ; CHECK-NEXT: [[R:%.*]] = shl i32 [[X:%.*]], [[SHAMT_WIDE1]]
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-direction-in-bit-test.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; The pattern: ; The pattern:
; icmp eq/ne (and (X shift Y), Z), 0 ; icmp eq/ne (and (X shift Y), Z), 0
; is equivalent to pattern ; is equivalent to pattern
; icmp eq/ne (and (Z oppositeshift Y), X), 0 ; icmp eq/ne (and (Z oppositeshift Y), X), 0
; We should canonicalize to one of them. ; We should canonicalize to one of them.
; Let's go with 'lshr'. ; Let's go with 'lshr'.
; Exception: unless it's a shift of constant, then don't touch it. ; Exception: unless it's a shift of constant, then don't touch it.
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-logic.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i8 @shl_and(i8 %x, i8 %y) { define i8 @shl_and(i8 %x, i8 %y) {
; CHECK-LABEL: @shl_and( ; CHECK-LABEL: @shl_and(
; CHECK-NEXT: [[TMP1:%.*]] = shl i8 [[X:%.*]], 5 ; CHECK-NEXT: [[TMP1:%.*]] = shl i8 [[X:%.*]], 5
; CHECK-NEXT: [[TMP2:%.*]] = shl i8 [[Y:%.*]], 2 ; CHECK-NEXT: [[TMP2:%.*]] = shl i8 [[Y:%.*]], 2
; CHECK-NEXT: [[SH1:%.*]] = and i8 [[TMP1]], [[TMP2]] ; CHECK-NEXT: [[SH1:%.*]] = and i8 [[TMP1]], [[TMP2]]
; CHECK-NEXT: ret i8 [[SH1]] ; CHECK-NEXT: ret i8 [[SH1]]
; ;
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use8(i8) declare void @use8(i8)
declare void @use32(i32) declare void @use32(i32)
; These would crash if we didn't check for a negative shift. ; These would crash if we didn't check for a negative shift.
; https://llvm.org/bugs/show_bug.cgi?id=12967 ; https://llvm.org/bugs/show_bug.cgi?id=12967
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shift-sra.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @test1(i32 %X, i8 %A) { define i32 @test1(i32 %X, i8 %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[SHIFT_UPGRD_1:%.*]] = zext i8 %A to i32 ; CHECK-NEXT: [[SHIFT_UPGRD_1:%.*]] = zext i8 %A to i32
; CHECK-NEXT: [[Y1:%.*]] = lshr i32 %X, [[SHIFT_UPGRD_1]] ; CHECK-NEXT: [[Y1:%.*]] = lshr i32 %X, [[SHIFT_UPGRD_1]]
; CHECK-NEXT: [[Z:%.*]] = and i32 [[Y1]], 1 ; CHECK-NEXT: [[Z:%.*]] = and i32 [[Y1]], 1
; CHECK-NEXT: ret i32 [[Z]] ; CHECK-NEXT: ret i32 [[Z]]
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <4 x i32> @lshr_non_splat_vector(<4 x i32> %A) { define <4 x i32> @lshr_non_splat_vector(<4 x i32> %A) {
; CHECK-LABEL: @lshr_non_splat_vector( ; CHECK-LABEL: @lshr_non_splat_vector(
; CHECK-NEXT: [[B:%.*]] = lshr <4 x i32> [[A:%.*]], <i32 32, i32 1, i32 2, i32 3> ; CHECK-NEXT: [[B:%.*]] = lshr <4 x i32> [[A:%.*]], <i32 32, i32 1, i32 2, i32 3>
; CHECK-NEXT: ret <4 x i32> [[B]] ; CHECK-NEXT: ret <4 x i32> [[B]]
; ;
%B = lshr <4 x i32> %A, <i32 32, i32 1, i32 2, i32 3> %B = lshr <4 x i32> %A, <i32 32, i32 1, i32 2, i32 3>
ret <4 x i32> %B ret <4 x i32> %B
▲ Show 20 Lines • Show All 1,843 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-and-negC-icmpeq-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; For pattern ((X << Y) & ~C) ==/!= 0; when C+1 is power of 2 ; For pattern ((X << Y) & ~C) ==/!= 0; when C+1 is power of 2
; it may be optimal to fold into (X << Y) </>= C+1 ; it may be optimal to fold into (X << Y) </>= C+1
; rather than X & (~C l>> Y) ==/!= 0 ; rather than X & (~C l>> Y) ==/!= 0
; Scalar tests ; Scalar tests
define i1 @scalar_i8_shl_and_negC_eq(i8 %x, i8 %y) { define i1 @scalar_i8_shl_and_negC_eq(i8 %x, i8 %y) {
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-and-signbit-icmpeq-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; For pattern ((X << Y) & signbit) ==/!= 0 ; For pattern ((X << Y) & signbit) ==/!= 0
; it may be optimal to fold into (X << Y) >=/< 0 ; it may be optimal to fold into (X << Y) >=/< 0
; rather than X & (signbit l>> Y) ==/!= 0 ; rather than X & (signbit l>> Y) ==/!= 0
; Scalar tests ; Scalar tests
define i1 @scalar_i8_shl_and_signbit_eq(i8 %x, i8 %y) { define i1 @scalar_i8_shl_and_signbit_eq(i8 %x, i8 %y) {
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-bo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(i8) declare void @use(i8)
define i8 @lshr_add(i8 %a, i8 %y) { define i8 @lshr_add(i8 %a, i8 %y) {
; CHECK-LABEL: @lshr_add( ; CHECK-LABEL: @lshr_add(
; CHECK-NEXT: [[X:%.*]] = srem i8 [[A:%.*]], 42 ; CHECK-NEXT: [[X:%.*]] = srem i8 [[A:%.*]], 42
; CHECK-NEXT: [[B1:%.*]] = shl i8 [[X]], 5 ; CHECK-NEXT: [[B1:%.*]] = shl i8 [[X]], 5
; CHECK-NEXT: [[R2:%.*]] = add i8 [[B1]], [[Y:%.*]] ; CHECK-NEXT: [[R2:%.*]] = add i8 [[B1]], [[Y:%.*]]
▲ Show 20 Lines • Show All 615 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-demand.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i16 @sext_shl_trunc_same_size(i16 %x, i32 %y) { define i16 @sext_shl_trunc_same_size(i16 %x, i32 %y) {
; CHECK-LABEL: @sext_shl_trunc_same_size( ; CHECK-LABEL: @sext_shl_trunc_same_size(
; CHECK-NEXT: [[CONV1:%.*]] = zext i16 [[X:%.*]] to i32 ; CHECK-NEXT: [[CONV1:%.*]] = zext i16 [[X:%.*]] to i32
; CHECK-NEXT: [[SHL:%.*]] = shl i32 [[CONV1]], [[Y:%.*]] ; CHECK-NEXT: [[SHL:%.*]] = shl i32 [[CONV1]], [[Y:%.*]]
; CHECK-NEXT: [[T:%.*]] = trunc i32 [[SHL]] to i16 ; CHECK-NEXT: [[T:%.*]] = trunc i32 [[SHL]] to i16
; CHECK-NEXT: ret i16 [[T]] ; CHECK-NEXT: ret i16 [[T]]
; ;
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-factor.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use8(i8) declare void @use8(i8)
define i6 @add_shl_same_amount(i6 %x, i6 %y, i6 %z) { define i6 @add_shl_same_amount(i6 %x, i6 %y, i6 %z) {
; CHECK-LABEL: @add_shl_same_amount( ; CHECK-LABEL: @add_shl_same_amount(
; CHECK-NEXT: [[TMP1:%.*]] = add i6 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = add i6 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[DIFF:%.*]] = shl i6 [[TMP1]], [[Z:%.*]] ; CHECK-NEXT: [[DIFF:%.*]] = shl i6 [[TMP1]], [[Z:%.*]]
; CHECK-NEXT: ret i6 [[DIFF]] ; CHECK-NEXT: ret i6 [[DIFF]]
▲ Show 20 Lines • Show All 257 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i32 @shl_sub_i32(i32 %x) { define i32 @shl_sub_i32(i32 %x) {
; CHECK-LABEL: @shl_sub_i32( ; CHECK-LABEL: @shl_sub_i32(
; CHECK-NEXT: [[R:%.*]] = lshr i32 -2147483648, [[X:%.*]] ; CHECK-NEXT: [[R:%.*]] = lshr i32 -2147483648, [[X:%.*]]
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shl-unsigned-cmp-const.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Simplify 'shl' inequality test into 'and' equality test. ; Simplify 'shl' inequality test into 'and' equality test.
; (X l<< C2) u</u>= C1 iff C1 is power of 2 -> X & (-C1 l>> C2) ==/!= 0 ; (X l<< C2) u</u>= C1 iff C1 is power of 2 -> X & (-C1 l>> C2) ==/!= 0
; Scalar tests ; Scalar tests
; C2 Shift amount smaller than C1 trailing zeros. ; C2 Shift amount smaller than C1 trailing zeros.
define i1 @scalar_i8_shl_ult_const_1(i8 %x) { define i1 @scalar_i8_shl_ult_const_1(i8 %x) {
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/should-change-type.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "n64" target datalayout = "n64"
; Tests for removing zext/trunc from/to i8, i16 and i32, even if it is ; Tests for removing zext/trunc from/to i8, i16 and i32, even if it is
; not a legal type. ; not a legal type.
define i8 @test1(i8 %x, i8 %y) { define i8 @test1(i8 %x, i8 %y) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[C:%.*]] = add i8 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[C:%.*]] = add i8 [[X:%.*]], [[Y:%.*]]
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle-cast-dist.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <2 x float> @vtrn1(<2 x i32> %v) define <2 x float> @vtrn1(<2 x i32> %v)
; CHECK-LABEL: @vtrn1( ; CHECK-LABEL: @vtrn1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i32> [[V:%.*]] to <2 x float> ; CHECK-NEXT: [[TMP0:%.*]] = bitcast <2 x i32> [[V:%.*]] to <2 x float>
; CHECK-NEXT: [[R:%.*]] = shufflevector <2 x float> [[TMP0]], <2 x float> poison, <2 x i32> zeroinitializer ; CHECK-NEXT: [[R:%.*]] = shufflevector <2 x float> [[TMP0]], <2 x float> poison, <2 x i32> zeroinitializer
; CHECK-NEXT: ret <2 x float> [[R]] ; CHECK-NEXT: ret <2 x float> [[R]]
; ;
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle-cast-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 -instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE
; RUN: opt < %s -instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE
define <4 x i16> @trunc_little_endian(<4 x i32> %x) { define <4 x i16> @trunc_little_endian(<4 x i32> %x) {
; LE-LABEL: @trunc_little_endian( ; LE-LABEL: @trunc_little_endian(
; LE-NEXT: [[R:%.*]] = trunc <4 x i32> [[X:%.*]] to <4 x i16> ; LE-NEXT: [[R:%.*]] = trunc <4 x i32> [[X:%.*]] to <4 x i16>
; LE-NEXT: ret <4 x i16> [[R]] ; LE-NEXT: ret <4 x i16> [[R]]
; ;
; BE-LABEL: @trunc_little_endian( ; BE-LABEL: @trunc_little_endian(
; BE-NEXT: [[B:%.*]] = bitcast <4 x i32> [[X:%.*]] to <8 x i16> ; BE-NEXT: [[B:%.*]] = bitcast <4 x i32> [[X:%.*]] to <8 x i16>
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle-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 -instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE
; RUN: opt < %s -instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE
define <4 x i16> @trunc_little_endian(<4 x i32> %x) { define <4 x i16> @trunc_little_endian(<4 x i32> %x) {
; LE-LABEL: @trunc_little_endian( ; LE-LABEL: @trunc_little_endian(
; LE-NEXT: [[R:%.*]] = trunc <4 x i32> [[X:%.*]] to <4 x i16> ; LE-NEXT: [[R:%.*]] = trunc <4 x i32> [[X:%.*]] to <4 x i16>
; LE-NEXT: ret <4 x i16> [[R]] ; LE-NEXT: ret <4 x i16> [[R]]
; ;
; BE-LABEL: @trunc_little_endian( ; BE-LABEL: @trunc_little_endian(
; BE-NEXT: [[B:%.*]] = bitcast <4 x i32> [[X:%.*]] to <8 x i16> ; BE-NEXT: [[B:%.*]] = bitcast <4 x i32> [[X:%.*]] to <8 x i16>
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle-select-narrow-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Narrow the select operands to eliminate the existing shuffles and replace a wide select with a narrow select. ; Narrow the select operands to eliminate the existing shuffles and replace a wide select with a narrow select.
define <2 x i8> @narrow_shuffle_of_select(<2 x i1> %cmp, <4 x i8> %x, <4 x i8> %y) { define <2 x i8> @narrow_shuffle_of_select(<2 x i1> %cmp, <4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @narrow_shuffle_of_select( ; CHECK-LABEL: @narrow_shuffle_of_select(
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1> ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1>
; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <4 x i8> [[Y:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1> ; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <4 x i8> [[Y:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1>
; CHECK-NEXT: [[R:%.*]] = select <2 x i1> [[CMP:%.*]], <2 x i8> [[TMP1]], <2 x i8> [[TMP2]] ; CHECK-NEXT: [[R:%.*]] = select <2 x i1> [[CMP:%.*]], <2 x i8> [[TMP1]], <2 x i8> [[TMP2]]
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle-select-narrow.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Narrow the select operands to eliminate the existing shuffles and replace a wide select with a narrow select. ; Narrow the select operands to eliminate the existing shuffles and replace a wide select with a narrow select.
define <2 x i8> @narrow_shuffle_of_select(<2 x i1> %cmp, <4 x i8> %x, <4 x i8> %y) { define <2 x i8> @narrow_shuffle_of_select(<2 x i1> %cmp, <4 x i8> %x, <4 x i8> %y) {
; CHECK-LABEL: @narrow_shuffle_of_select( ; CHECK-LABEL: @narrow_shuffle_of_select(
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1> ; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1>
; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <4 x i8> [[Y:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1> ; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <4 x i8> [[Y:%.*]], <4 x i8> poison, <2 x i32> <i32 0, i32 1>
; CHECK-NEXT: [[R:%.*]] = select <2 x i1> [[CMP:%.*]], <2 x i8> [[TMP1]], <2 x i8> [[TMP2]] ; CHECK-NEXT: [[R:%.*]] = select <2 x i1> [[CMP:%.*]], <2 x i8> [[TMP1]], <2 x i8> [[TMP2]]
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Try to eliminate binops and shuffles when the shuffle is a select in disguise: ; Try to eliminate binops and shuffles when the shuffle is a select in disguise:
; PR37806 - https://bugs.llvm.org/show_bug.cgi?id=37806 ; PR37806 - https://bugs.llvm.org/show_bug.cgi?id=37806
define <4 x i32> @add(<4 x i32> %v) { define <4 x i32> @add(<4 x i32> %v) {
; CHECK-LABEL: @add( ; CHECK-LABEL: @add(
; CHECK-NEXT: [[S:%.*]] = add <4 x i32> [[V:%.*]], <i32 11, i32 0, i32 13, i32 0> ; CHECK-NEXT: [[S:%.*]] = add <4 x i32> [[V:%.*]], <i32 11, i32 0, i32 13, i32 0>
; CHECK-NEXT: ret <4 x i32> [[S]] ; CHECK-NEXT: ret <4 x i32> [[S]]
▲ Show 20 Lines • Show All 1,457 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shuffle_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Try to eliminate binops and shuffles when the shuffle is a select in disguise: ; Try to eliminate binops and shuffles when the shuffle is a select in disguise:
; PR37806 - https://bugs.llvm.org/show_bug.cgi?id=37806 ; PR37806 - https://bugs.llvm.org/show_bug.cgi?id=37806
define <4 x i32> @add(<4 x i32> %v) { define <4 x i32> @add(<4 x i32> %v) {
; CHECK-LABEL: @add( ; CHECK-LABEL: @add(
; CHECK-NEXT: [[S:%.*]] = add <4 x i32> [[V:%.*]], <i32 11, i32 0, i32 13, i32 0> ; CHECK-NEXT: [[S:%.*]] = add <4 x i32> [[V:%.*]], <i32 11, i32 0, i32 13, i32 0>
; CHECK-NEXT: ret <4 x i32> [[S]] ; CHECK-NEXT: ret <4 x i32> [[S]]
▲ Show 20 Lines • Show All 1,472 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shufflevec-bitcast-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(<4 x i16>) declare void @use(<4 x i16>)
define void @test(<16 x i8> %w, i32* %o1, float* %o2) { define void @test(<16 x i8> %w, i32* %o1, float* %o2) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[V_BC:%.*]] = bitcast <16 x i8> [[W:%.*]] to <4 x i32> ; CHECK-NEXT: [[V_BC:%.*]] = bitcast <16 x i8> [[W:%.*]] to <4 x i32>
; CHECK-NEXT: [[V_EXTRACT:%.*]] = extractelement <4 x i32> [[V_BC]], i64 3 ; CHECK-NEXT: [[V_EXTRACT:%.*]] = extractelement <4 x i32> [[V_BC]], i64 3
; CHECK-NEXT: [[V_BC1:%.*]] = bitcast <16 x i8> [[W]] to <4 x float> ; CHECK-NEXT: [[V_BC1:%.*]] = bitcast <16 x i8> [[W]] to <4 x float>
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shufflevec-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(<4 x i16>) declare void @use(<4 x i16>)
define void @test(<16 x i8> %w, i32* %o1, float* %o2) { define void @test(<16 x i8> %w, i32* %o1, float* %o2) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[V_BC:%.*]] = bitcast <16 x i8> [[W:%.*]] to <4 x i32> ; CHECK-NEXT: [[V_BC:%.*]] = bitcast <16 x i8> [[W:%.*]] to <4 x i32>
; CHECK-NEXT: [[V_EXTRACT:%.*]] = extractelement <4 x i32> [[V_BC]], i64 3 ; CHECK-NEXT: [[V_EXTRACT:%.*]] = extractelement <4 x i32> [[V_BC]], i64 3
; CHECK-NEXT: [[V_BC1:%.*]] = bitcast <16 x i8> [[W]] to <4 x float> ; CHECK-NEXT: [[V_BC1:%.*]] = bitcast <16 x i8> [[W]] to <4 x float>
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shufflevec-constant-inseltpoison.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
target triple = "i386-apple-darwin9" target triple = "i386-apple-darwin9"
define <4 x float> @__inff4() nounwind readnone { define <4 x float> @__inff4() nounwind readnone {
; CHECK-LABEL: @__inff4( ; CHECK-LABEL: @__inff4(
; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0x7FF0000000000000, float 0x7FF0000000000000> ; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0x7FF0000000000000, float 0x7FF0000000000000>
; ;
%tmp14 = extractelement <1 x double> bitcast (<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000> to <1 x double>), i32 0 %tmp14 = extractelement <1 x double> bitcast (<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000> to <1 x double>), i32 0
%tmp4 = bitcast double %tmp14 to i64 %tmp4 = bitcast double %tmp14 to i64
%tmp3 = bitcast i64 %tmp4 to <2 x float> %tmp3 = bitcast i64 %tmp4 to <2 x float>
%tmp8 = shufflevector <2 x float> %tmp3, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> %tmp8 = shufflevector <2 x float> %tmp3, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%tmp9 = shufflevector <4 x float> zeroinitializer, <4 x float> %tmp8, <4 x i32> <i32 0, i32 1, i32 4, i32 5> %tmp9 = shufflevector <4 x float> zeroinitializer, <4 x float> %tmp8, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
ret <4 x float> %tmp9 ret <4 x float> %tmp9
} }

llvm/test/Transforms/InstCombine/shufflevec-constant.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
target triple = "i386-apple-darwin9" target triple = "i386-apple-darwin9"
define <4 x float> @__inff4() nounwind readnone { define <4 x float> @__inff4() nounwind readnone {
; CHECK-LABEL: @__inff4( ; CHECK-LABEL: @__inff4(
; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0x7FF0000000000000, float 0x7FF0000000000000> ; CHECK-NEXT: ret <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0x7FF0000000000000, float 0x7FF0000000000000>
; ;
%tmp14 = extractelement <1 x double> bitcast (<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000> to <1 x double>), i32 0 %tmp14 = extractelement <1 x double> bitcast (<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000> to <1 x double>), i32 0
%tmp4 = bitcast double %tmp14 to i64 %tmp4 = bitcast double %tmp14 to i64
%tmp3 = bitcast i64 %tmp4 to <2 x float> %tmp3 = bitcast i64 %tmp4 to <2 x float>
%tmp8 = shufflevector <2 x float> %tmp3, <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> %tmp8 = shufflevector <2 x float> %tmp3, <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%tmp9 = shufflevector <4 x float> zeroinitializer, <4 x float> %tmp8, <4 x i32> <i32 0, i32 1, i32 4, i32 5> %tmp9 = shufflevector <4 x float> zeroinitializer, <4 x float> %tmp8, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
ret <4 x float> %tmp9 ret <4 x float> %tmp9
} }

llvm/test/Transforms/InstCombine/shufflevector-div-rem-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 -instcombine -S -o - | FileCheck %s ; RUN: opt < %s -passes=instcombine -S -o - | FileCheck %s
; This test case was added as a reproducer for a miscompile, where instcombine ; This test case was added as a reproducer for a miscompile, where instcombine
; introduced an ; introduced an
; srem <2 x i16> %1, <i16 undef, i16 2> ; srem <2 x i16> %1, <i16 undef, i16 2>
; instruction, which makes the whole srem undefined (even if we only end up ; instruction, which makes the whole srem undefined (even if we only end up
; extracting the second element in the vector). ; extracting the second element in the vector).
define i16 @test_srem_orig(i16 %a, i1 %cmp) { define i16 @test_srem_orig(i16 %a, i1 %cmp) {
; CHECK-LABEL: @test_srem_orig( ; CHECK-LABEL: @test_srem_orig(
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/shufflevector-div-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 -instcombine -S -o - | FileCheck %s ; RUN: opt < %s -passes=instcombine -S -o - | FileCheck %s
; This test case was added as a reproducer for a miscompile, where instcombine ; This test case was added as a reproducer for a miscompile, where instcombine
; introduced an ; introduced an
; srem <2 x i16> %1, <i16 undef, i16 2> ; srem <2 x i16> %1, <i16 undef, i16 2>
; instruction, which makes the whole srem undefined (even if we only end up ; instruction, which makes the whole srem undefined (even if we only end up
; extracting the second element in the vector). ; extracting the second element in the vector).
define i16 @test_srem_orig(i16 %a, i1 %cmp) { define i16 @test_srem_orig(i16 %a, i1 %cmp) {
; CHECK-LABEL: @test_srem_orig( ; CHECK-LABEL: @test_srem_orig(
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sign-bit-test-via-right-shifting-all-other-bits.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use32(i32) declare void @use32(i32)
declare void @use64(i64) declare void @use64(i64)
define i1 @highest_bit_test_via_lshr(i32 %data, i32 %nbits) { define i1 @highest_bit_test_via_lshr(i32 %data, i32 %nbits) {
; CHECK-LABEL: @highest_bit_test_via_lshr( ; CHECK-LABEL: @highest_bit_test_via_lshr(
; CHECK-NEXT: [[NUM_LOW_BITS_TO_SKIP:%.*]] = sub i32 32, [[NBITS:%.*]] ; CHECK-NEXT: [[NUM_LOW_BITS_TO_SKIP:%.*]] = sub i32 32, [[NBITS:%.*]]
; CHECK-NEXT: [[HIGH_BITS_EXTRACTED:%.*]] = lshr i32 [[DATA:%.*]], [[NUM_LOW_BITS_TO_SKIP]] ; CHECK-NEXT: [[HIGH_BITS_EXTRACTED:%.*]] = lshr i32 [[DATA:%.*]], [[NUM_LOW_BITS_TO_SKIP]]
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sign-test-and-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare void @foo() declare void @foo()
define i1 @test1(i32 %a, i32 %b) { define i1 @test1(i32 %a, i32 %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = or i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP1]], 0 ; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
▲ Show 20 Lines • Show All 388 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signbit-lshr-and-icmpeq-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; For pattern (X & (signbit l>> Y)) ==/!= 0 ; For pattern (X & (signbit l>> Y)) ==/!= 0
; it may be optimal to fold into (X << Y) >=/< 0 ; it may be optimal to fold into (X << Y) >=/< 0
; Scalar tests ; Scalar tests
define i1 @scalar_i8_signbit_lshr_and_eq(i8 %x, i8 %y) { define i1 @scalar_i8_signbit_lshr_and_eq(i8 %x, i8 %y) {
; CHECK-LABEL: @scalar_i8_signbit_lshr_and_eq( ; CHECK-LABEL: @scalar_i8_signbit_lshr_and_eq(
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signbit-shl-and-icmpeq-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; For pattern (X & (signbit << Y)) ==/!= 0 ; For pattern (X & (signbit << Y)) ==/!= 0
; it may be optimal to fold into (X l>> Y) >=/< 0 ; it may be optimal to fold into (X l>> Y) >=/< 0
; Scalar tests ; Scalar tests
define i1 @scalar_i8_signbit_shl_and_eq(i8 %x, i8 %y) { define i1 @scalar_i8_signbit_shl_and_eq(i8 %x, i8 %y) {
; CHECK-LABEL: @scalar_i8_signbit_shl_and_eq( ; CHECK-LABEL: @scalar_i8_signbit_shl_and_eq(
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signed-comparison.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Convert the zext+slt into a simple ult. ; Convert the zext+slt into a simple ult.
define i1 @scalar_zext_slt(i16 %t4) { define i1 @scalar_zext_slt(i16 %t4) {
; CHECK-LABEL: @scalar_zext_slt( ; CHECK-LABEL: @scalar_zext_slt(
; CHECK-NEXT: [[T6:%.*]] = icmp ult i16 %t4, 500 ; CHECK-NEXT: [[T6:%.*]] = icmp ult i16 %t4, 500
; CHECK-NEXT: ret i1 [[T6]] ; CHECK-NEXT: ret i1 [[T6]]
; ;
Show All 15 Lines

llvm/test/Transforms/InstCombine/signed-mul-lack-of-overflow-check-via-mul-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; ((%x * %y) s/ %x) == %y ; ((%x * %y) s/ %x) == %y
; to ; to
; @llvm.smul.with.overflow(%x, %y) + extractvalue + not ; @llvm.smul.with.overflow(%x, %y) + extractvalue + not
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signed-mul-overflow-check-via-mul-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; ((%x * %y) s/ %x) != %y ; ((%x * %y) s/ %x) != %y
; to ; to
; @llvm.smul.with.overflow(%x, %y) + extractvalue ; @llvm.smul.with.overflow(%x, %y) + extractvalue
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signed-truncation-check.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; General pattern: ; General pattern:
; X & Y ; X & Y
; ;
; Where Y is checking that all the high bits (covered by a mask 4294967168) ; Where Y is checking that all the high bits (covered by a mask 4294967168)
; are uniform, i.e. %arg & 4294967168 can be either 4294967168 or 0 ; are uniform, i.e. %arg & 4294967168 can be either 4294967168 or 0
; Pattern can be one of: ; Pattern can be one of:
; %t = add i32 %arg, 128 ; %t = add i32 %arg, 128
▲ Show 20 Lines • Show All 1,008 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "n8:16:32:64" target datalayout = "n8:16:32:64"
declare void @use(i32) declare void @use(i32)
define i32 @sextinreg(i32 %x) { define i32 @sextinreg(i32 %x) {
; CHECK-LABEL: @sextinreg( ; CHECK-LABEL: @sextinreg(
; CHECK-NEXT: [[SEXT:%.*]] = shl i32 [[X:%.*]], 16 ; CHECK-NEXT: [[SEXT:%.*]] = shl i32 [[X:%.*]], 16
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/signmask-of-sext-vs-of-shl-of-zext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we zero-extend some value, and then immediately left-shift-out all the new ; If we zero-extend some value, and then immediately left-shift-out all the new
; sign bits, and apply a mask to keep only the sign bit (which is the original ; sign bits, and apply a mask to keep only the sign bit (which is the original
; sign bit from before zero-extension), we might as well just sign-extend ; sign bit from before zero-extension), we might as well just sign-extend
; and apply the same signmask. ; and apply the same signmask.
declare void @use32(i32) declare void @use32(i32)
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/simplify-demanded-bits-pointer.ll

; RUN: opt < %s -instcombine -disable-output ; RUN: opt < %s -passes=instcombine -disable-output
; SimplifyDemandedBits should cope with pointer types. ; SimplifyDemandedBits should cope with pointer types.
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"
%struct.VEC_rtx_base = type { i32, i32, [1 x %struct.rtx_def*] } %struct.VEC_rtx_base = type { i32, i32, [1 x %struct.rtx_def*] }
%struct.VEC_rtx_gc = type { %struct.VEC_rtx_base } %struct.VEC_rtx_gc = type { %struct.VEC_rtx_base }
%struct.block_symbol = type { [3 x %struct.rtunion], %struct.object_block*, i64 } %struct.block_symbol = type { [3 x %struct.rtunion], %struct.object_block*, i64 }
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/simplify-libcalls-erased.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 -instcombine | FileCheck %s ; RUN: opt -S < %s -passes=instcombine | FileCheck %s
target triple = "x86_64" target triple = "x86_64"
define double @pow_exp(double %x, double %y) { define double @pow_exp(double %x, double %y) {
; CHECK-LABEL: @pow_exp( ; CHECK-LABEL: @pow_exp(
; CHECK-NEXT: [[MUL:%.*]] = fmul fast double [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[MUL:%.*]] = fmul fast double [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[EXP:%.*]] = call fast double @llvm.exp.f64(double [[MUL]]) ; CHECK-NEXT: [[EXP:%.*]] = call fast double @llvm.exp.f64(double [[MUL]])
; CHECK-NEXT: ret double [[EXP]] ; CHECK-NEXT: ret double [[EXP]]
Show All 15 Lines

llvm/test/Transforms/InstCombine/sincospi.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 -instcombine -S < %s -mtriple=x86_64-apple-macosx10.9 | FileCheck %s --check-prefix=CHECK-FLOAT-IN-VEC ; RUN: opt -passes=instcombine -S < %s -mtriple=x86_64-apple-macosx10.9 | FileCheck %s --check-prefix=CHECK-FLOAT-IN-VEC
; RUN: opt -instcombine -S < %s -mtriple=arm-apple-ios7.0 | FileCheck %s ; RUN: opt -passes=instcombine -S < %s -mtriple=arm-apple-ios7.0 | FileCheck %s
; RUN: opt -instcombine -S < %s -mtriple=arm64-apple-ios7.0 | FileCheck %s ; RUN: opt -passes=instcombine -S < %s -mtriple=arm64-apple-ios7.0 | FileCheck %s
; RUN: opt -instcombine -S < %s -mtriple=x86_64-apple-macosx10.8 | FileCheck %s --check-prefix=CHECK-NO-SINCOS ; RUN: opt -passes=instcombine -S < %s -mtriple=x86_64-apple-macosx10.8 | FileCheck %s --check-prefix=CHECK-NO-SINCOS
; RUN: opt -instcombine -S < %s -mtriple=arm-apple-ios6.0 | FileCheck %s --check-prefix=CHECK-NO-SINCOS ; RUN: opt -passes=instcombine -S < %s -mtriple=arm-apple-ios6.0 | FileCheck %s --check-prefix=CHECK-NO-SINCOS
; RUN: opt -instcombine -S < %s -mtriple=x86_64-none-linux-gnu | FileCheck %s --check-prefix=CHECK-NO-SINCOS ; RUN: opt -passes=instcombine -S < %s -mtriple=x86_64-none-linux-gnu | FileCheck %s --check-prefix=CHECK-NO-SINCOS
attributes #0 = { readnone nounwind } attributes #0 = { readnone nounwind }
declare float @__sinpif(float %x) #0 declare float @__sinpif(float %x) #0
declare float @__cospif(float %x) #0 declare float @__cospif(float %x) #0
declare double @__sinpi(double %x) #0 declare double @__sinpi(double %x) #0
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink-alloca.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
target triple = "i686-unknown-linux-gnu" target triple = "i686-unknown-linux-gnu"
; Check that instcombine doesn't sink dynamic allocas across llvm.stacksave. ; Check that instcombine doesn't sink dynamic allocas across llvm.stacksave.
; Helper to generate branch conditions. ; Helper to generate branch conditions.
declare i1 @cond() declare i1 @cond()
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink-into-catchswitch.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc18.0.0" target triple = "x86_64-pc-windows-msvc18.0.0"
%struct.B = type { i64, i64 } %struct.B = type { i64, i64 }
define void @test1(%struct.B* %p) personality i32 (...)* @__CxxFrameHandler3 { define void @test1(%struct.B* %p) personality i32 (...)* @__CxxFrameHandler3 {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink-into-resume-block.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; Check that InstCombine can sink instructions to the landingpad of the invoke. ; Check that InstCombine can sink instructions to the landingpad of the invoke.
define void @t0_noop(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define void @t0_noop(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK-LABEL: @t0_noop( ; CHECK-LABEL: @t0_noop(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[C:%.*]] = call i1 @cond() ; CHECK-NEXT: [[C:%.*]] = call i1 @cond()
; CHECK-NEXT: br i1 [[C]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink-not-into-another-hand-of-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Transform ; Transform
; z = (~x) & y ; z = (~x) & y
; into: ; into:
; z = ~(x | (~y)) ; z = ~(x | (~y))
; iff y is free to invert and all uses of z can be freely updated. ; iff y is free to invert and all uses of z can be freely updated.
declare void @use1(i1) declare void @use1(i1)
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink-not-into-another-hand-of-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Transform ; Transform
; z = (~x) | y ; z = (~x) | y
; into: ; into:
; z = ~(x & (~y)) ; z = ~(x & (~y))
; iff y is free to invert and all uses of z can be freely updated. ; iff y is free to invert and all uses of z can be freely updated.
declare void @use1(i1) declare void @use1(i1)
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink_instruction.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
;; This tests that the instructions in the entry blocks are sunk into each ;; This tests that the instructions in the entry blocks are sunk into each
;; arm of the 'if'. ;; arm of the 'if'.
define i32 @test1(i1 %C, i32 %A, i32 %B) { define i32 @test1(i1 %C, i32 %A, i32 %B) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[THEN:%.*]], label [[ENDIF:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[THEN:%.*]], label [[ENDIF:%.*]]
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sink_sideeffecting_instruction.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; Function Attrs: noinline uwtable ; Function Attrs: noinline uwtable
define i32 @foo(i32* nocapture writeonly %arg) { define i32 @foo(i32* nocapture writeonly %arg) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[VAR:%.*]] = call i32 @baz() ; CHECK-NEXT: [[VAR:%.*]] = call i32 @baz()
; CHECK-NEXT: store i32 [[VAR]], i32* [[ARG:%.*]], align 4 ; CHECK-NEXT: store i32 [[VAR]], i32* [[ARG:%.*]], align 4
; CHECK-NEXT: [[VAR1:%.*]] = call i32 @baz() ; CHECK-NEXT: [[VAR1:%.*]] = call i32 @baz()
▲ Show 20 Lines • Show All 499 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sitofp.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @test1(i8 %A) { define i1 @test1(i8 %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%B = sitofp i8 %A to double %B = sitofp i8 %A to double
%C = fcmp ult double %B, 128.0 %C = fcmp ult double %B, 128.0
ret i1 %C ret i1 %C
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/smax-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; If we have an smax feeding a signed or equality icmp that shares an ; If we have an smax feeding a signed or equality icmp that shares an
; operand with the smax, the compare should always be folded. ; operand with the smax, the compare should always be folded.
; Test all 4 foldable predicates (eq,ne,sgt,sle) * 4 commutation ; Test all 4 foldable predicates (eq,ne,sgt,sle) * 4 commutation
; possibilities for each predicate. Note that folds to true/false ; possibilities for each predicate. Note that folds to true/false
; (predicate = sge/slt) or folds to an existing instruction should be ; (predicate = sge/slt) or folds to an existing instruction should be
; handled by InstSimplify. ; handled by InstSimplify.
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/smin-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; If we have an smin feeding a signed or equality icmp that shares an ; If we have an smin feeding a signed or equality icmp that shares an
; operand with the smin, the compare should always be folded. ; operand with the smin, the compare should always be folded.
; Test all 6 foldable predicates (eq,ne,sge,sgt,sle,slt) * 4 commutation ; Test all 6 foldable predicates (eq,ne,sge,sgt,sle,slt) * 4 commutation
; possibilities for each predicate. Note that folds to true/false or ; possibilities for each predicate. Note that folds to true/false or
; folds to an existing instruction may be handled by InstSimplify. ; folds to an existing instruction may be handled by InstSimplify.
; smin(X, Y) == X --> X <= Y ; smin(X, Y) == X --> X <= Y
▲ Show 20 Lines • Show All 323 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/smulo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { i64, i1 } @llvm.smul.with.overflow.i64(i64, i64) declare { i64, i1 } @llvm.smul.with.overflow.i64(i64, i64)
declare { i8, i1 } @llvm.smul.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.smul.with.overflow.i8(i8, i8)
define i1 @test_generic(i64 %a, i64 %b) { define i1 @test_generic(i64 %a, i64 %b) {
; CHECK-LABEL: @test_generic( ; CHECK-LABEL: @test_generic(
; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]])
; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1 ; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/snprintf.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@.str = private unnamed_addr constant [4 x i8] c"str\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"str\00", align 1
@.str.1 = private unnamed_addr constant [3 x i8] c"%%\00", align 1 @.str.1 = private unnamed_addr constant [3 x i8] c"%%\00", align 1
@.str.2 = private unnamed_addr constant [3 x i8] c"%c\00", align 1 @.str.2 = private unnamed_addr constant [3 x i8] c"%c\00", align 1
@.str.3 = private unnamed_addr constant [3 x i8] c"%s\00", align 1 @.str.3 = private unnamed_addr constant [3 x i8] c"%s\00", align 1
@.str.4 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1 @.str.4 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sprintf-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the sprintf library call simplifier works correctly. ; Test that the sprintf library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; RUN: opt < %s -mtriple xcore-xmos-elf -instcombine -S | FileCheck %s -check-prefixes=CHECK,CHECK-IPRINTF,WITHSTPCPY ; RUN: opt < %s -mtriple xcore-xmos-elf -passes=instcombine -S | FileCheck %s -check-prefixes=CHECK,CHECK-IPRINTF,WITHSTPCPY
; RUN: opt < %s -mtriple=i386-pc-windows-msvc -instcombine -S | FileCheck %s --check-prefixes=CHECK,WIN ; RUN: opt < %s -mtriple=i386-pc-windows-msvc -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,WIN
; RUN: opt < %s -mtriple=i386-mingw32 -instcombine -S | FileCheck %s --check-prefixes=CHECK,WIN,NOSTPCPY ; RUN: opt < %s -mtriple=i386-mingw32 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,WIN,NOSTPCPY
; RUN: opt < %s -mtriple=armv7-none-linux-android16 -instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY ; RUN: opt < %s -mtriple=armv7-none-linux-android16 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY
; RUN: opt < %s -mtriple=armv7-none-linux-android21 -instcombine -S | FileCheck %s --check-prefixes=CHECK,WITHSTPCPY ; RUN: opt < %s -mtriple=armv7-none-linux-android21 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,WITHSTPCPY
; RUN: opt < %s -mtriple=x86_64-scei-ps4 -instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY ; RUN: opt < %s -mtriple=x86_64-scei-ps4 -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,NOSTPCPY
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:128:128" 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:128:128"
@hello_world = constant [13 x i8] c"hello world\0A\00" @hello_world = constant [13 x i8] c"hello world\0A\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@null_hello = constant [7 x i8] c"\00hello\00" @null_hello = constant [7 x i8] c"\00hello\00"
@h = constant [2 x i8] c"h\00" @h = constant [2 x i8] c"h\00"
@percent_c = constant [3 x i8] c"%c\00" @percent_c = constant [3 x i8] c"%c\00"
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sprintf-void.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello_world = constant [13 x i8] c"hello world\0A\00" @hello_world = constant [13 x i8] c"hello world\0A\00"
declare void @sprintf(i8*, i8*, ...) declare void @sprintf(i8*, i8*, ...)
; Check that a sprintf call, that would otherwise be optimized, but with ; Check that a sprintf call, that would otherwise be optimized, but with
Show All 11 Lines

llvm/test/Transforms/InstCombine/sqrt-nofast.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Check that we skip transformations if the attribute unsafe-fp-math ; Check that we skip transformations if the attribute unsafe-fp-math
; is not set. ; is not set.
define float @mysqrt(float %x, float %y) #0 { define float @mysqrt(float %x, float %y) #0 {
; CHECK-LABEL: @mysqrt( ; CHECK-LABEL: @mysqrt(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[MUL:%.*]] = fmul fast float [[X:%.*]], [[X]] ; CHECK-NEXT: [[MUL:%.*]] = fmul fast float [[X:%.*]], [[X]]
Show All 33 Lines

llvm/test/Transforms/InstCombine/sqrt.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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define float @test1(float %x) nounwind readnone ssp { define float @test1(float %x) nounwind readnone ssp {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[X:%.*]]) #3 ; CHECK-NEXT: [[SQRTF:%.*]] = call float @sqrtf(float [[X:%.*]]) #3
; CHECK-NEXT: ret float [[SQRTF]] ; CHECK-NEXT: ret float [[SQRTF]]
; ;
%conv = fpext float %x to double %conv = fpext float %x to double
%call = tail call double @sqrt(double %conv) readnone nounwind %call = tail call double @sqrt(double %conv) readnone nounwind
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/srem-canonicalize.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @test_srem_canonicalize_op0(i32 %x, i32 %y) { define i32 @test_srem_canonicalize_op0(i32 %x, i32 %y) {
; CHECK-LABEL: @test_srem_canonicalize_op0( ; CHECK-LABEL: @test_srem_canonicalize_op0(
; CHECK-NEXT: [[TMP1:%.*]] = srem i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = srem i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[SREM:%.*]] = sub nsw i32 0, [[TMP1]] ; CHECK-NEXT: [[SREM:%.*]] = sub nsw i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[SREM]] ; CHECK-NEXT: ret i32 [[SREM]]
; ;
%neg = sub nsw i32 0, %x %neg = sub nsw i32 0, %x
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/srem-simplify-bug.ll

; RUN: opt < %s -instcombine -S | grep "ret i1 false" ; RUN: opt < %s -passes=instcombine -S | grep "ret i1 false"
; PR2276 ; PR2276
define i1 @f(i32 %x) { define i1 @f(i32 %x) {
%A = or i32 %x, 1 %A = or i32 %x, 1
%B = srem i32 %A, 1 %B = srem i32 %A, 1
%C = icmp ne i32 %B, 0 %C = icmp ne i32 %B, 0
ret i1 %C ret i1 %C
} }

llvm/test/Transforms/InstCombine/srem-via-sdiv-mul-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; x - ((x / y) * y) ; x - ((x / y) * y)
; to ; to
; x % y ; x % y
; Also, ; Also,
; ((x / y) * y) ; ((x / y) * y)
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/srem1.ll

; RUN: opt < %s -instcombine ; RUN: opt < %s -passes=instcombine
; PR2670 ; PR2670
@g_127 = external global i32 ; <i32*> [#uses=1] @g_127 = external global i32 ; <i32*> [#uses=1]
define i32 @func_56(i32 %p_58, i32 %p_59, i32 %p_61, i16 signext %p_62) nounwind { define i32 @func_56(i32 %p_58, i32 %p_59, i32 %p_61, i16 signext %p_62) nounwind {
entry: entry:
%call = call i32 (...) @rshift_s_s( i32 %p_61, i32 1 ) ; <i32> [#uses=1] %call = call i32 (...) @rshift_s_s( i32 %p_61, i32 1 ) ; <i32> [#uses=1]
%conv = sext i32 %call to i64 ; <i64> [#uses=1] %conv = sext i32 %call to i64 ; <i64> [#uses=1]
Show All 9 Lines

llvm/test/Transforms/InstCombine/ssub-with-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { <2 x i32>, <2 x i1> } @llvm.ssub.with.overflow.v2i32(<2 x i32>, <2 x i32>) declare { <2 x i32>, <2 x i1> } @llvm.ssub.with.overflow.v2i32(<2 x i32>, <2 x i32>)
declare { <2 x i8>, <2 x i1> } @llvm.ssub.with.overflow.v2i8(<2 x i8>, <2 x i8>) declare { <2 x i8>, <2 x i1> } @llvm.ssub.with.overflow.v2i8(<2 x i8>, <2 x i8>)
declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32) declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32)
declare { i8, i1 } @llvm.ssub.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.ssub.with.overflow.i8(i8, i8)
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/ssubo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { i64, i1 } @llvm.ssub.with.overflow.i64(i64, i64) declare { i64, i1 } @llvm.ssub.with.overflow.i64(i64, i64)
declare { i8, i1 } @llvm.ssub.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.ssub.with.overflow.i8(i8, i8)
define i1 @test_generic(i64 %a, i64 %b) { define i1 @test_generic(i64 %a, i64 %b) {
; CHECK-LABEL: @test_generic( ; CHECK-LABEL: @test_generic(
; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]])
; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1 ; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/stack-overalign.ll

; RUN: opt < %s -instcombine -S | grep "align 32" | count 2 ; RUN: opt < %s -passes=instcombine -S | grep "align 32" | count 2
; It's tempting to have an instcombine in which the src pointer of a ; It's tempting to have an instcombine in which the src pointer of a
; memcpy is aligned up to the alignment of the destination, however ; memcpy is aligned up to the alignment of the destination, however
; there are pitfalls. If the src is an alloca, aligning it beyond what ; there are pitfalls. If the src is an alloca, aligning it beyond what
; the target's stack pointer is aligned at will require dynamic ; the target's stack pointer is aligned at will require dynamic
; stack realignment, which can require functions that don't otherwise ; stack realignment, which can require functions that don't otherwise
; need a frame pointer to need one. ; need a frame pointer to need one.
; ;
Show All 22 Lines

llvm/test/Transforms/InstCombine/stacksave-debuginfo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; dbg.value instrinsics should not affect peephole combining of stacksave/stackrestore. ; dbg.value instrinsics should not affect peephole combining of stacksave/stackrestore.
; PR37713 ; PR37713
; RUN: opt -instcombine %s -S | FileCheck %s ; RUN: opt -passes=instcombine %s -S | FileCheck %s
declare i8* @llvm.stacksave() #0 declare i8* @llvm.stacksave() #0
declare void @llvm.stackrestore(i8*) #0 declare void @llvm.stackrestore(i8*) #0
define i32* @test1(i32 %P) !dbg !6 { define i32* @test1(i32 %P) !dbg !6 {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: call void @llvm.dbg.value(metadata i8* undef ; CHECK-NEXT: call void @llvm.dbg.value(metadata i8* undef
; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[P:%.*]] to i64, !dbg !13 ; CHECK-NEXT: [[TMP1:%.*]] = zext i32 [[P:%.*]] to i64, !dbg !13
Show All 36 Lines

llvm/test/Transforms/InstCombine/stacksaverestore.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@glob = global i32 0 @glob = global i32 0
declare i8* @llvm.stacksave() declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*) declare void @llvm.stackrestore(i8*)
;; Test that llvm.stackrestore is removed when possible. ;; Test that llvm.stackrestore is removed when possible.
define i32* @test1(i32 %P) { define i32* @test1(i32 %P) {
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/statepoint.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; These tests check the optimizations specific to ; These tests check the optimizations specific to
; pointers being relocated at a statepoint. ; pointers being relocated at a statepoint.
declare i32* @fake_personality_function() declare i32* @fake_personality_function()
declare void @func() declare void @func()
define i1 @test_negative(i32 addrspace(1)* %p) gc "statepoint-example" { define i1 @test_negative(i32 addrspace(1)* %p) gc "statepoint-example" {
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/stdio-custom-dl.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 -instcombine -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s ; RUN: opt < %s -passes=instcombine -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
target datalayout = "e-m:o-p:40:64:64:32-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p:40:64:64:32-i64:64-f80:128-n8:16:32:64-S128"
%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] } %struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] }
%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 } %struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 }
@.str = private unnamed_addr constant [5 x i8] c"file\00", align 1 @.str = private unnamed_addr constant [5 x i8] c"file\00", align 1
@.str.1 = private unnamed_addr constant [2 x i8] c"w\00", align 1 @.str.1 = private unnamed_addr constant [2 x i8] c"w\00", align 1
@.str.2 = private unnamed_addr constant [4 x i8] c"str\00", align 1 @.str.2 = private unnamed_addr constant [4 x i8] c"str\00", align 1
Show All 12 Lines

llvm/test/Transforms/InstCombine/store.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define void @test1(i32* %P) { define void @test1(i32* %P) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: store i32 123, i32* undef, align 4 ; CHECK-NEXT: store i32 123, i32* undef, align 4
; CHECK-NEXT: store i32 poison, i32* null, align 4294967296 ; CHECK-NEXT: store i32 poison, i32* null, align 4294967296
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 undef, i32* %P store i32 undef, i32* %P
▲ Show 20 Lines • Show All 309 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/stpcpy-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the stpcpy library call simplifier works correctly. ; Test that the stpcpy library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; This transformation requires the pointer size, as it assumes that size_t is ; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer. ; the size of a pointer.
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:128:128-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:128:128-n8:16:32"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
@b = common global [32 x i8] zeroinitializer, align 1 @b = common global [32 x i8] zeroinitializer, align 1
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/stpcpy-2.ll

; Test that the stpcpy library call simplifier works correctly. ; Test that the stpcpy library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; This transformation requires the pointer size, as it assumes that size_t is ; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer. ; the size of a pointer.
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:128:128-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:128:128-n8:16:32"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
Show All 12 Lines

llvm/test/Transforms/InstCombine/stpcpy_chk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test lib call simplification of __stpcpy_chk calls with various values ; Test lib call simplification of __stpcpy_chk calls with various values
; for src, dst, and slen. ; for src, dst, and slen.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@a = common global [60 x i8] zeroinitializer, align 1 @a = common global [60 x i8] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
@.str = private constant [12 x i8] c"abcdefghijk\00" @.str = private constant [12 x i8] c"abcdefghijk\00"
; Check cases where slen >= strlen (src). ; Check cases where slen >= strlen (src).
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/stpcpy_chk-2.ll

; Test that lib call simplification doesn't simplify __stpcpy_chk calls ; Test that lib call simplification doesn't simplify __stpcpy_chk calls
; with the wrong prototype. ; with the wrong prototype.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@a = common global [60 x i16] zeroinitializer, align 1 @a = common global [60 x i16] zeroinitializer, align 1
@.str = private constant [8 x i8] c"abcdefg\00" @.str = private constant [8 x i8] c"abcdefg\00"
define void @test_no_simplify() { define void @test_no_simplify() {
; CHECK-LABEL: @test_no_simplify( ; CHECK-LABEL: @test_no_simplify(
Show All 9 Lines

llvm/test/Transforms/InstCombine/str-int-2.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@.str = private unnamed_addr constant [3 x i8] c"12\00", align 1 @.str = private unnamed_addr constant [3 x i8] c"12\00", align 1
@.str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1 @.str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1
@.str.2 = private unnamed_addr constant [11 x i8] c"4294967296\00", align 1 @.str.2 = private unnamed_addr constant [11 x i8] c"4294967296\00", align 1
@.str.3 = private unnamed_addr constant [24 x i8] c"10000000000000000000000\00", align 1 @.str.3 = private unnamed_addr constant [24 x i8] c"10000000000000000000000\00", align 1
@.str.4 = private unnamed_addr constant [20 x i8] c"9923372036854775807\00", align 1 @.str.4 = private unnamed_addr constant [20 x i8] c"9923372036854775807\00", align 1
@.str.5 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1 @.str.5 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1
@.str.6 = private unnamed_addr constant [10 x i8] c"499496729\00", align 1 @.str.6 = private unnamed_addr constant [10 x i8] c"499496729\00", align 1
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/str-int.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@.str = private unnamed_addr constant [3 x i8] c"12\00", align 1 @.str = private unnamed_addr constant [3 x i8] c"12\00", align 1
@.str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1 @.str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1
@.str.2 = private unnamed_addr constant [11 x i8] c"4294967296\00", align 1 @.str.2 = private unnamed_addr constant [11 x i8] c"4294967296\00", align 1
@.str.3 = private unnamed_addr constant [24 x i8] c"10000000000000000000000\00", align 1 @.str.3 = private unnamed_addr constant [24 x i8] c"10000000000000000000000\00", align 1
@.str.4 = private unnamed_addr constant [20 x i8] c"9923372036854775807\00", align 1 @.str.4 = private unnamed_addr constant [20 x i8] c"9923372036854775807\00", align 1
@.str.5 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1 @.str.5 = private unnamed_addr constant [11 x i8] c"4994967295\00", align 1
@.str.6 = private unnamed_addr constant [10 x i8] c"499496729\00", align 1 @.str.6 = private unnamed_addr constant [10 x i8] c"499496729\00", align 1
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcat-1.ll

; Test that the strcat libcall simplifier works correctly per the ; Test that the strcat libcall simplifier works correctly per the
; bug found in PR3661. ; bug found in PR3661.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@null_hello = constant [7 x i8] c"\00hello\00" @null_hello = constant [7 x i8] c"\00hello\00"
declare i8* @strcat(i8*, i8*) declare i8* @strcat(i8*, i8*)
Show All 26 Lines

llvm/test/Transforms/InstCombine/strcat-2.ll

; Test that the strcat libcall simplifier works correctly. ; Test that the strcat libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@empty = constant [1 x i8] c"\00" @empty = constant [1 x i8] c"\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
declare i8* @strcat(i8*, i8*) declare i8* @strcat(i8*, i8*)
Show All 21 Lines

llvm/test/Transforms/InstCombine/strcat-3.ll

; Test that the strcat libcall simplifier works correctly. ; Test that the strcat libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@empty = constant [1 x i8] c"\00" @empty = constant [1 x i8] c"\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
declare i16* @strcat(i8*, i8*) declare i16* @strcat(i8*, i8*)
Show All 11 Lines

llvm/test/Transforms/InstCombine/strchr-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strchr library call simplifier works correctly. ; Test that the strchr library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128-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:128:128-n8:16:32"
@hello = constant [14 x i8] c"hello world\5Cn\00" @hello = constant [14 x i8] c"hello world\5Cn\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@newlines = constant [3 x i8] c"\0D\0A\00" @newlines = constant [3 x i8] c"\0D\0A\00"
@chp = global i8* zeroinitializer @chp = global i8* zeroinitializer
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strchr-2.ll

; Test that the strchr libcall simplifier works correctly. ; Test that the strchr libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [14 x i8] c"hello world\5Cn\00" @hello = constant [14 x i8] c"hello world\5Cn\00"
@chr = global i8 zeroinitializer @chr = global i8 zeroinitializer
declare i8 @strchr(i8*, i32) declare i8 @strchr(i8*, i32)
Show All 10 Lines

llvm/test/Transforms/InstCombine/strcmp-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strcmp library call simplifier works correctly. ; Test that the strcmp library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s --check-prefix=NOBCMP ; RUN: opt < %s -passes=instcombine -S | FileCheck %s --check-prefix=NOBCMP
; RUN: opt < %s -instcombine -mtriple=unknown-unknown-linux-gnu -S | FileCheck %s --check-prefix=BCMP ; RUN: opt < %s -passes=instcombine -mtriple=unknown-unknown-linux-gnu -S | FileCheck %s --check-prefix=BCMP
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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@hell = constant [5 x i8] c"hell\00" @hell = constant [5 x i8] c"hell\00"
@bell = constant [5 x i8] c"bell\00" @bell = constant [5 x i8] c"bell\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcmp-2.ll

; Test that the strcmp library call simplifier works correctly. ; Test that the strcmp library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@hell = constant [5 x i8] c"hell\00" @hell = constant [5 x i8] c"hell\00"
declare i16 @strcmp(i8*, i8*) declare i16 @strcmp(i8*, i8*)
Show All 10 Lines

llvm/test/Transforms/InstCombine/strcmp-memcmp.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@key = constant [4 x i8] c"key\00", align 1 @key = constant [4 x i8] c"key\00", align 1
@abc = constant [8 x i8] c"abc\00de\00\00", align 1 @abc = constant [8 x i8] c"abc\00de\00\00", align 1
declare void @use(i32) declare void @use(i32)
▲ Show 20 Lines • Show All 550 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcpy-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strcpy library call simplifier works correctly. ; Test that the strcpy library call simplifier works correctly.
; rdar://6839935 ; rdar://6839935
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; This transformation requires the pointer size, as it assumes that size_t is ; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer. ; the size of a pointer.
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:128:128-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:128:128-n8:16:32"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
@b = common global [32 x i8] zeroinitializer, align 1 @b = common global [32 x i8] zeroinitializer, align 1
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcpy-2.ll

; Test that the strcpy library call simplifier works correctly. ; Test that the strcpy library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; This transformation requires the pointer size, as it assumes that size_t is ; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer. ; the size of a pointer.
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:128:128-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:128:128-n8:16:32"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
Show All 12 Lines

llvm/test/Transforms/InstCombine/strcpy-nonzero-as.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
; Test that the strcpy library call simplifier also works when the string ; Test that the strcpy library call simplifier also works when the string
; libcall arguments are in a non-zero address space. ; libcall arguments are in a non-zero address space.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-m:e-p200:128:128:128:64-p:64:64-A200-P200-G200" target datalayout = "e-m:e-p200:128:128:128:64-p:64:64-A200-P200-G200"
@str = private unnamed_addr addrspace(200) constant [17 x i8] c"exactly 16 chars\00", align 1 @str = private unnamed_addr addrspace(200) constant [17 x i8] c"exactly 16 chars\00", align 1
declare i8 addrspace(200)* @strcpy(i8 addrspace(200)*, i8 addrspace(200)*) addrspace(200) declare i8 addrspace(200)* @strcpy(i8 addrspace(200)*, i8 addrspace(200)*) addrspace(200)
declare i8 addrspace(200)* @stpcpy(i8 addrspace(200)*, i8 addrspace(200)*) addrspace(200) declare i8 addrspace(200)* @stpcpy(i8 addrspace(200)*, i8 addrspace(200)*) addrspace(200)
declare i8 addrspace(200)* @strncpy(i8 addrspace(200)*, i8 addrspace(200)*, i64) addrspace(200) declare i8 addrspace(200)* @strncpy(i8 addrspace(200)*, i8 addrspace(200)*, i64) addrspace(200)
declare i8 addrspace(200)* @stpncpy(i8 addrspace(200)*, i8 addrspace(200)*, i64) addrspace(200) declare i8 addrspace(200)* @stpncpy(i8 addrspace(200)*, i8 addrspace(200)*, i64) addrspace(200)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcpy_chk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test lib call simplification of __strcpy_chk calls with various values ; Test lib call simplification of __strcpy_chk calls with various values
; for src, dst, and slen. ; for src, dst, and slen.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@a = common global [60 x i8] zeroinitializer, align 1 @a = common global [60 x i8] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
@.str = private constant [12 x i8] c"abcdefghijk\00" @.str = private constant [12 x i8] c"abcdefghijk\00"
; Check cases where slen >= strlen (src). ; Check cases where slen >= strlen (src).
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcpy_chk-2.ll

; Test that lib call simplification doesn't simplify __strcpy_chk calls ; Test that lib call simplification doesn't simplify __strcpy_chk calls
; with the wrong prototype. ; with the wrong prototype.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@a = common global [60 x i16] zeroinitializer, align 1 @a = common global [60 x i16] zeroinitializer, align 1
@.str = private constant [8 x i8] c"abcdefg\00" @.str = private constant [8 x i8] c"abcdefg\00"
define void @test_no_simplify() { define void @test_no_simplify() {
; CHECK-LABEL: @test_no_simplify( ; CHECK-LABEL: @test_no_simplify(
Show All 9 Lines

llvm/test/Transforms/InstCombine/strcpy_chk-64.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
target triple = "x86_64-apple-darwin10.0.0" target triple = "x86_64-apple-darwin10.0.0"
define void @func(i8* %i) nounwind ssp { define void @func(i8* %i) nounwind ssp {
; CHECK-LABEL: @func( ; CHECK-LABEL: @func(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[S:%.*]] = alloca [32 x i8], align 16 ; CHECK-NEXT: [[S:%.*]] = alloca [32 x i8], align 16
; CHECK-NEXT: [[ARRAYDECAY:%.*]] = getelementptr inbounds [32 x i8], [32 x i8]* [[S]], i64 0, i64 0 ; CHECK-NEXT: [[ARRAYDECAY:%.*]] = getelementptr inbounds [32 x i8], [32 x i8]* [[S]], i64 0, i64 0
Show All 34 Lines

llvm/test/Transforms/InstCombine/strcspn-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strcspn library call simplifier works correctly. ; Test that the strcspn library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@abcba = constant [6 x i8] c"abcba\00" @abcba = constant [6 x i8] c"abcba\00"
@abc = constant [4 x i8] c"abc\00" @abc = constant [4 x i8] c"abc\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
declare i64 @strcspn(i8*, i8*) declare i64 @strcspn(i8*, i8*)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strcspn-2.ll

; Test that the strcspn library call simplifier works correctly. ; Test that the strcspn library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
declare double @strcspn(i8*, i8*) declare double @strcspn(i8*, i8*)
; Check that strcspn functions with the wrong prototype aren't simplified. ; Check that strcspn functions with the wrong prototype aren't simplified.
Show All 10 Lines

llvm/test/Transforms/InstCombine/strict-sub-underflow-check-to-comparison-of-sub-operands.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare i8 @gen8() declare i8 @gen8()
declare void @use8(i8) declare void @use8(i8)
define i1 @t0(i8 %base, i8 %offset) { define i1 @t0(i8 %base, i8 %offset) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[OFFSET:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[OFFSET:%.*]], 0
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strlen-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strlen library call simplifier works correctly. ; Test that the strlen library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@longer = constant [7 x i8] c"longer\00" @longer = constant [7 x i8] c"longer\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@null_hello = constant [7 x i8] c"\00hello\00" @null_hello = constant [7 x i8] c"\00hello\00"
@nullstring = constant i8 0 @nullstring = constant i8 0
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strlen-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strlen library call simplifier works correctly. ; Test that the strlen library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
declare i32 @strlen(i8*, i32) declare i32 @strlen(i8*, i32)
define i32 @test_no_simplify1() { define i32 @test_no_simplify1() {
; CHECK-LABEL: @test_no_simplify1( ; CHECK-LABEL: @test_no_simplify1(
; CHECK-NEXT: [[HELLO_L:%.*]] = call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i32 187) ; CHECK-NEXT: [[HELLO_L:%.*]] = call i32 @strlen(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i32 187)
; CHECK-NEXT: ret i32 [[HELLO_L]] ; CHECK-NEXT: ret i32 [[HELLO_L]]
; ;
%hello_p = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0 %hello_p = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
%hello_l = call i32 @strlen(i8* %hello_p, i32 187) %hello_l = call i32 @strlen(i8* %hello_p, i32 187)
ret i32 %hello_l ret i32 %hello_l
} }

llvm/test/Transforms/InstCombine/strlen-3.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "p:64:64" target datalayout = "p:64:64"
; This would crash - PR50836 ; This would crash - PR50836
define i64 @strlen(i32* %s) { define i64 @strlen(i32* %s) {
; CHECK-LABEL: @strlen( ; CHECK-LABEL: @strlen(
; CHECK-NEXT: [[R:%.*]] = call i64 @strlen(i32* noundef nonnull dereferenceable(1) [[S:%.*]]) ; CHECK-NEXT: [[R:%.*]] = call i64 @strlen(i32* noundef nonnull dereferenceable(1) [[S:%.*]])
; CHECK-NEXT: ret i64 0 ; CHECK-NEXT: ret i64 0
; ;
%r = call i64 @strlen(i32* %s) %r = call i64 @strlen(i32* %s)
ret i64 0 ret i64 0
} }

llvm/test/Transforms/InstCombine/strlen_chk.ll

; Test that __strlen_chk simplification works correctly. ; Test that __strlen_chk simplification works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@hello_no_nul = constant [5 x i8] c"hello" @hello_no_nul = constant [5 x i8] c"hello"
declare i32 @__strlen_chk(i8*, i32) declare i32 @__strlen_chk(i8*, i32)
Show All 36 Lines

llvm/test/Transforms/InstCombine/strncat-1.ll

; Test that the strncat libcall simplifier works correctly. ; Test that the strncat libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@null_hello = constant [7 x i8] c"\00hello\00" @null_hello = constant [7 x i8] c"\00hello\00"
declare i8* @strncat(i8*, i8*, i32) declare i8* @strncat(i8*, i8*, i32)
Show All 26 Lines

llvm/test/Transforms/InstCombine/strncat-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strncat libcall simplifier works correctly. ; Test that the strncat libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@empty = constant [1 x i8] c"\00" @empty = constant [1 x i8] c"\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
declare i8* @strncat(i8*, i8*, i32) declare i8* @strncat(i8*, i8*, i32)
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strncat-3.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strncat libcall simplifier works correctly. ; Test that the strncat libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@empty = constant [1 x i8] c"\00" @empty = constant [1 x i8] c"\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
declare i16* @strncat(i8*, i8*, i32) declare i16* @strncat(i8*, i8*, i32)
Show All 12 Lines

llvm/test/Transforms/InstCombine/strncmp-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strncmp library call simplifier works correctly. ; Test that the strncmp library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@hell = constant [5 x i8] c"hell\00" @hell = constant [5 x i8] c"hell\00"
@bell = constant [5 x i8] c"bell\00" @bell = constant [5 x i8] c"bell\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strncmp-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strncmp library call simplifier works correctly. ; Test that the strncmp library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@hell = constant [5 x i8] c"hell\00" @hell = constant [5 x i8] c"hell\00"
declare i16 @strncmp(i8*, i8*, i32) declare i16 @strncmp(i8*, i8*, i32)
Show All 11 Lines

llvm/test/Transforms/InstCombine/strncmp-wrong-datalayout.ll

; Test that the strncpy simplification doesn't crash if datalayout specifies ; Test that the strncpy simplification doesn't crash if datalayout specifies
; 64 bit pointers while length is a 32 bit argument ; 64 bit pointers while length is a 32 bit argument
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
declare i32 @strncmp(i8*, i8*, i32) declare i32 @strncmp(i8*, i8*, i32)
define i32 @test6(i8* %str1, i8* %str2) { define i32 @test6(i8* %str1, i8* %str2) {
; CHECK-LABEL: @test6( ; CHECK-LABEL: @test6(
; CHECK: call i32 @strncmp(i8* %str1, i8* %str2, i32 1) ; CHECK: call i32 @strncmp(i8* %str1, i8* %str2, i32 1)
%temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 1) %temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 1)
ret i32 %temp1 ret i32 %temp1
} }

llvm/test/Transforms/InstCombine/strncpy-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strncpy library call simplifier works correctly. ; Test that the strncpy library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@null_hello = constant [7 x i8] c"\00hello\00" @null_hello = constant [7 x i8] c"\00hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
@b = common global [32 x i8] zeroinitializer, align 1 @b = common global [32 x i8] zeroinitializer, align 1
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strncpy-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strncpy library call simplifier works correctly. ; Test that the strncpy library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@a = common global [32 x i8] zeroinitializer, align 1 @a = common global [32 x i8] zeroinitializer, align 1
declare i16* @strncpy(i8*, i8*, i32) declare i16* @strncpy(i8*, i8*, i32)
Show All 13 Lines

llvm/test/Transforms/InstCombine/strncpy-3.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@str = constant [2 x i8] c"a\00" @str = constant [2 x i8] c"a\00"
@str2 = constant [3 x i8] c"abc" @str2 = constant [3 x i8] c"abc"
@str3 = constant [4 x i8] c"abcd" @str3 = constant [4 x i8] c"abcd"
declare i8* @strncpy(i8*, i8*, i64) declare i8* @strncpy(i8*, i8*, i64)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strncpy_chk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test lib call simplification of __strncpy_chk calls with various values ; Test lib call simplification of __strncpy_chk calls with various values
; for len and dstlen. ; for len and dstlen.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@a = common global [60 x i8] zeroinitializer, align 1 @a = common global [60 x i8] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
@.str = private constant [12 x i8] c"abcdefghijk\00" @.str = private constant [12 x i8] c"abcdefghijk\00"
; Check cases where dstlen >= len ; Check cases where dstlen >= len
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strncpy_chk-2.ll

; Test that lib call simplification doesn't simplify __strncpy_chk calls ; Test that lib call simplification doesn't simplify __strncpy_chk calls
; with the wrong prototype. ; with the wrong prototype.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@a = common global [60 x i16] zeroinitializer, align 1 @a = common global [60 x i16] zeroinitializer, align 1
@b = common global [60 x i8] zeroinitializer, align 1 @b = common global [60 x i8] zeroinitializer, align 1
define void @test_no_simplify() { define void @test_no_simplify() {
; CHECK-LABEL: @test_no_simplify( ; CHECK-LABEL: @test_no_simplify(
Show All 9 Lines

llvm/test/Transforms/InstCombine/strndup.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@hello = constant [6 x i8] c"hello\00" @hello = constant [6 x i8] c"hello\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
declare i8* @strndup(i8*, i32) declare i8* @strndup(i8*, i32)
define i8* @test1() { define i8* @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strpbrk-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strpbrk library call simplifier works correctly. ; Test that the strpbrk library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [12 x i8] c"hello world\00" @hello = constant [12 x i8] c"hello world\00"
@w = constant [2 x i8] c"w\00" @w = constant [2 x i8] c"w\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
declare i8* @strpbrk(i8*, i8*) declare i8* @strpbrk(i8*, i8*)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strpbrk-2.ll

; Test that the strpbrk library call simplifier works correctly. ; Test that the strpbrk library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [12 x i8] c"hello world\00" @hello = constant [12 x i8] c"hello world\00"
@w = constant [2 x i8] c"w\00" @w = constant [2 x i8] c"w\00"
declare i16* @strpbrk(i8*, i8*) declare i16* @strpbrk(i8*, i8*)
Show All 12 Lines

llvm/test/Transforms/InstCombine/strrchr-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strrchr library call simplifier works correctly. ; Test that the strrchr library call simplifier works correctly.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [14 x i8] c"hello world\5Cn\00" @hello = constant [14 x i8] c"hello world\5Cn\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
@chp = global i8* zeroinitializer @chp = global i8* zeroinitializer
declare i8* @strrchr(i8*, i32) declare i8* @strrchr(i8*, i32)
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strrchr-2.ll

; Test that the strrchr libcall simplifier works correctly. ; Test that the strrchr libcall simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@hello = constant [14 x i8] c"hello world\5Cn\00" @hello = constant [14 x i8] c"hello world\5Cn\00"
@chr = global i8 zeroinitializer @chr = global i8 zeroinitializer
declare i8 @strrchr(i8*, i32) declare i8 @strrchr(i8*, i32)
Show All 10 Lines

llvm/test/Transforms/InstCombine/strspn-1.ll

; Test that the strspn library call simplifier works correctly. ; Test that the strspn library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
@abcba = constant [6 x i8] c"abcba\00" @abcba = constant [6 x i8] c"abcba\00"
@abc = constant [4 x i8] c"abc\00" @abc = constant [4 x i8] c"abc\00"
@null = constant [1 x i8] zeroinitializer @null = constant [1 x i8] zeroinitializer
declare i64 @strspn(i8*, i8*) declare i64 @strspn(i8*, i8*)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strstr-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the strstr library call simplifier works correctly. ; Test that the strstr library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@.str = private constant [1 x i8] zeroinitializer @.str = private constant [1 x i8] zeroinitializer
@.str1 = private constant [2 x i8] c"a\00" @.str1 = private constant [2 x i8] c"a\00"
@.str2 = private constant [6 x i8] c"abcde\00" @.str2 = private constant [6 x i8] c"abcde\00"
@.str3 = private constant [4 x i8] c"bcd\00" @.str3 = private constant [4 x i8] c"bcd\00"
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/strstr-2.ll

; Test that the strstr library call simplifier works correctly. ; Test that the strstr library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@null = private constant [1 x i8] zeroinitializer @null = private constant [1 x i8] zeroinitializer
declare i8 @strstr(i8*, i8*) declare i8 @strstr(i8*, i8*)
define i8 @test_no_simplify1(i8* %str) { define i8 @test_no_simplify1(i8* %str) {
; CHECK-LABEL: @test_no_simplify1( ; CHECK-LABEL: @test_no_simplify1(
%pat = getelementptr inbounds [1 x i8], [1 x i8]* @null, i32 0, i32 0 %pat = getelementptr inbounds [1 x i8], [1 x i8]* @null, i32 0, i32 0
%ret = call i8 @strstr(i8* %str, i8* %pat) %ret = call i8 @strstr(i8* %str, i8* %pat)
; CHECK-NEXT: call i8 @strstr ; CHECK-NEXT: call i8 @strstr
ret i8 %ret ret i8 %ret
; CHECK-NEXT: ret i8 %ret ; CHECK-NEXT: ret i8 %ret
} }

llvm/test/Transforms/InstCombine/struct-assign-tbaa-new.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; ;
; Verify that instcombine preserves TBAA tags when converting a memcpy into ; Verify that instcombine preserves TBAA tags when converting a memcpy into
; a scalar load and store. ; a scalar load and store.
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"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/struct-assign-tbaa.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %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"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
; Verify that instcombine preserves TBAA tags when converting a memcpy into ; Verify that instcombine preserves TBAA tags when converting a memcpy into
; a scalar load and store. ; a scalar load and store.
Show All 37 Lines

llvm/test/Transforms/InstCombine/sub-and-or-neg-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i32 @sub_to_xor(i32 %x, i32 %y) { define i32 @sub_to_xor(i32 %x, i32 %y) {
; CHECK-LABEL: @sub_to_xor( ; CHECK-LABEL: @sub_to_xor(
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[TMP1]] ; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[SUB]] ; CHECK-NEXT: ret i32 [[SUB]]
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-ashr-and-to-icmp-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 -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s
; Clamp negative to zero: ; Clamp negative to zero:
; E.g., clamp0 implemented in a shifty way, could be optimized as v > 0 ? v : 0, where sub hasNoSignedWrap. ; E.g., clamp0 implemented in a shifty way, could be optimized as v > 0 ? v : 0, where sub hasNoSignedWrap.
; int32 clamp0(int32 v) { ; int32 clamp0(int32 v) {
; return ((-(v) >> 31) & (v)); ; return ((-(v) >> 31) & (v));
; } ; }
; ;
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-ashr-or-to-icmp-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 -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s
; Clamp positive to allOnes: ; Clamp positive to allOnes:
; E.g., clamp255 implemented in a shifty way, could be optimized as v > 255 ? 255 : v, where sub hasNoSignedWrap. ; E.g., clamp255 implemented in a shifty way, could be optimized as v > 255 ? 255 : v, where sub hasNoSignedWrap.
; int32 clamp255(int32 v) { ; int32 clamp255(int32 v) {
; return (((255 - (v)) >> 31) | (v)) & 255; ; return (((255 - (v)) >> 31) | (v)) & 255;
; } ; }
; ;
▲ Show 20 Lines • Show All 311 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-from-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 -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s
; ((X - Y) - Z) --> X - (Y + Z) because we prefer add's. ; ((X - Y) - Z) --> X - (Y + Z) because we prefer add's.
declare void @use8(i8) declare void @use8(i8)
; Basic test ; Basic test
define i8 @t0(i8 %x, i8 %y, i8 %z) { define i8 @t0(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-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-p1:16:16:16-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"
define i64 @test_inbounds([0 x i32]* %base, i64 %idx) { define i64 @test_inbounds([0 x i32]* %base, i64 %idx) {
; CHECK-LABEL: @test_inbounds( ; CHECK-LABEL: @test_inbounds(
; CHECK-NEXT: [[P2_IDX:%.*]] = shl nsw i64 [[IDX:%.*]], 2 ; CHECK-NEXT: [[P2_IDX:%.*]] = shl nsw i64 [[IDX:%.*]], 2
; CHECK-NEXT: ret i64 [[P2_IDX]] ; CHECK-NEXT: ret i64 [[P2_IDX]]
; ;
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-lshr-or-to-icmp-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 -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s
; Scalar Types ; Scalar Types
define i32 @neg_or_lshr_i32(i32 %x) { define i32 @neg_or_lshr_i32(i32 %x) {
; CHECK-LABEL: @neg_or_lshr_i32( ; CHECK-LABEL: @neg_or_lshr_i32(
; CHECK-NEXT: [[TMP1:%.*]] = icmp ne i32 [[X:%.*]], 0 ; CHECK-NEXT: [[TMP1:%.*]] = icmp ne i32 [[X:%.*]], 0
; CHECK-NEXT: [[SHR:%.*]] = zext i1 [[TMP1]] to i32 ; CHECK-NEXT: [[SHR:%.*]] = zext i1 [[TMP1]] to i32
; CHECK-NEXT: ret i32 [[SHR]] ; CHECK-NEXT: ret i32 [[SHR]]
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-minmax.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i5 @llvm.umin.i5(i5, i5) declare i5 @llvm.umin.i5(i5, i5)
declare <2 x i8> @llvm.umin.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.umin.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i8> @llvm.umax.v2i8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.umax.v2i8(<2 x i8>, <2 x i8>)
declare i8 @llvm.smax.i8(i8, i8) declare i8 @llvm.smax.i8(i8, i8)
declare i8 @llvm.smin.i8(i8, i8) declare i8 @llvm.smin.i8(i8, i8)
declare i8 @llvm.umax.i8(i8, i8) declare i8 @llvm.umax.i8(i8, i8)
▲ Show 20 Lines • Show All 561 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(i8) declare void @use(i8)
define i8 @sub_not(i8 %x, i8 %y) { define i8 @sub_not(i8 %x, i8 %y) {
; CHECK-LABEL: @sub_not( ; CHECK-LABEL: @sub_not(
; CHECK-NEXT: [[TMP1:%.*]] = xor i8 [[X:%.*]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[R:%.*]] = add i8 [[TMP1]], [[Y:%.*]] ; CHECK-NEXT: [[R:%.*]] = add i8 [[TMP1]], [[Y:%.*]]
; CHECK-NEXT: ret i8 [[R]] ; CHECK-NEXT: ret i8 [[R]]
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-of-negatible-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use4(i4) declare void @use4(i4)
declare void @use8(i8) declare void @use8(i8)
declare void @use_v2i4(<2 x i4>) declare void @use_v2i4(<2 x i4>)
declare i1 @use32gen1(i32) declare i1 @use32gen1(i32)
; Constant can be freely negated. ; Constant can be freely negated.
define i8 @t0(i8 %x) { define i8 @t0(i8 %x) {
▲ Show 20 Lines • Show All 1,396 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-of-negatible.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use4(i4) declare void @use4(i4)
declare void @use8(i8) declare void @use8(i8)
declare void @use_v2i4(<2 x i4>) declare void @use_v2i4(<2 x i4>)
declare i1 @use32gen1(i32) declare i1 @use32gen1(i32)
; Constant can be freely negated. ; Constant can be freely negated.
define i8 @t0(i8 %x) { define i8 @t0(i8 %x) {
▲ Show 20 Lines • Show All 1,420 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-or-and-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i32 @sub_to_xor(i32 %x, i32 %y) { define i32 @sub_to_xor(i32 %x, i32 %y) {
; CHECK-LABEL: @sub_to_xor( ; CHECK-LABEL: @sub_to_xor(
; CHECK-NEXT: [[SUB:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[SUB:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret i32 [[SUB]] ; CHECK-NEXT: ret i32 [[SUB]]
; ;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-xor-or-neg-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i32 @sub_to_and(i32 %x, i32 %y) { define i32 @sub_to_and(i32 %x, i32 %y) {
; CHECK-LABEL: @sub_to_and( ; CHECK-LABEL: @sub_to_and(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[TMP1]] ; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[SUB]] ; CHECK-NEXT: ret i32 [[SUB]]
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/sub-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i32 @test1(i32 %x) { define i32 @test1(i32 %x) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], 31 ; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], 31
; CHECK-NEXT: [[SUB:%.*]] = xor i32 [[AND]], 63 ; CHECK-NEXT: [[SUB:%.*]] = xor i32 [[AND]], 63
; CHECK-NEXT: ret i32 [[SUB]] ; CHECK-NEXT: ret i32 [[SUB]]
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-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-p1:16:16:16-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"
define i32 @sub_constant(i32 %x) { define i32 @sub_constant(i32 %x) {
; CHECK-LABEL: @sub_constant( ; CHECK-LABEL: @sub_constant(
; CHECK-NEXT: [[R:%.*]] = add i32 [[X:%.*]], -42 ; CHECK-NEXT: [[R:%.*]] = add i32 [[X:%.*]], -42
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
▲ Show 20 Lines • Show All 1,699 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/subtract-from-one-hand-of-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 < %s -instcombine | FileCheck %s ; RUN: opt -S < %s -passes=instcombine | FileCheck %s
; Fold ; Fold
; sub %Op0, (select %Cond, %TrueVal, %FalseVal) ; sub %Op0, (select %Cond, %TrueVal, %FalseVal)
; to ; to
; select %Cond, (sub %Op0, %TrueVal), (sub %Op0, %FalseVal) ; select %Cond, (sub %Op0, %TrueVal), (sub %Op0, %FalseVal)
; https://bugs.llvm.org/show_bug.cgi?id=44426 ; https://bugs.llvm.org/show_bug.cgi?id=44426
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/subtract-of-one-hand-of-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 < %s -instcombine | FileCheck %s ; RUN: opt -S < %s -passes=instcombine | FileCheck %s
; Fold ; Fold
; sub (select %Cond, %TrueVal, %FalseVal), %Op1 ; sub (select %Cond, %TrueVal, %FalseVal), %Op1
; to ; to
; select %Cond, (sub %TrueVal, %Op1), (sub %FalseVal, %Op1) ; select %Cond, (sub %TrueVal, %Op1), (sub %FalseVal, %Op1)
; https://bugs.llvm.org/show_bug.cgi?id=44426 ; https://bugs.llvm.org/show_bug.cgi?id=44426
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/swifterror-argument-bitcast-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 -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
; The swifterror value can only be loaded, stored or used as swifterror ; The swifterror value can only be loaded, stored or used as swifterror
; argument. Make sure we do not try to turn the function bitcast into an ; argument. Make sure we do not try to turn the function bitcast into an
; argument bitcast. ; argument bitcast.
define swiftcc void @spam(i32** swifterror %arg) { define swiftcc void @spam(i32** swifterror %arg) {
; CHECK-LABEL: @spam( ; CHECK-LABEL: @spam(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: call swiftcc void bitcast (void (i64**)* @widget to void (i32**)*)(i32** swifterror [[ARG:%.*]]) ; CHECK-NEXT: call swiftcc void bitcast (void (i64**)* @widget to void (i32**)*)(i32** swifterror [[ARG:%.*]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
call swiftcc void bitcast (void (i64**)* @widget to void (i32**)*)(i32** swifterror %arg) call swiftcc void bitcast (void (i64**)* @widget to void (i32**)*)(i32** swifterror %arg)
ret void ret void
} }
declare swiftcc void @widget(i64**) declare swiftcc void @widget(i64**)

llvm/test/Transforms/InstCombine/switch-constant-expr.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@g = global i32 0 @g = global i32 0
; PR30486 ; PR30486
define i32 @single_case() { define i32 @single_case() {
; CHECK-LABEL: @single_case( ; CHECK-LABEL: @single_case(
; CHECK-NEXT: switch i32 ptrtoint (i32* @g to i32), label %x [ ; CHECK-NEXT: switch i32 ptrtoint (i32* @g to i32), label %x [
; CHECK-NEXT: ] ; CHECK-NEXT: ]
Show All 34 Lines

llvm/test/Transforms/InstCombine/switch-truncate-crash.ll

; RUN: opt -instcombine < %s ; RUN: opt -passes=instcombine < %s
define void @test() { define void @test() {
switch i32 0, label %out [i32 0, label %out] switch i32 0, label %out [i32 0, label %out]
out: out:
ret void ret void
} }

llvm/test/Transforms/InstCombine/tan-nofastmath.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define float @mytan(float %x) { define float @mytan(float %x) {
entry: entry:
%call = call float @atanf(float %x) %call = call float @atanf(float %x)
%call1 = call float @tanf(float %call) %call1 = call float @tanf(float %call)
ret float %call1 ret float %call1
} }
; CHECK-LABEL: define float @mytan( ; CHECK-LABEL: define float @mytan(
; CHECK: %call = call float @atanf(float %x) ; CHECK: %call = call float @atanf(float %x)
; CHECK-NEXT: %call1 = call float @tanf(float %call) ; CHECK-NEXT: %call1 = call float @tanf(float %call)
; CHECK-NEXT: ret float %call1 ; CHECK-NEXT: ret float %call1
; CHECK-NEXT: } ; CHECK-NEXT: }
declare float @tanf(float) declare float @tanf(float)
declare float @atanf(float) declare float @atanf(float)

llvm/test/Transforms/InstCombine/tan.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define float @mytan(float %x) { define float @mytan(float %x) {
%call = call fast float @atanf(float %x) %call = call fast float @atanf(float %x)
%call1 = call fast float @tanf(float %call) %call1 = call fast float @tanf(float %call)
ret float %call1 ret float %call1
} }
; CHECK-LABEL: define float @mytan( ; CHECK-LABEL: define float @mytan(
Show All 14 Lines

llvm/test/Transforms/InstCombine/tbaa-store-to-load.ll

; RUN: opt -S -instcombine < %s 2>&1 | FileCheck %s ; RUN: opt -S -passes=instcombine < %s 2>&1 | FileCheck %s
define i64 @f(i64* %p1, i64* %p2) { define i64 @f(i64* %p1, i64* %p2) {
top: top:
; check that the tbaa is preserved ; check that the tbaa is preserved
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK: %v1 = load i64, i64* %p1, align 8, !tbaa !0 ; CHECK: %v1 = load i64, i64* %p1, align 8, !tbaa !0
; CHECK: store i64 %v1, i64* %p2, align 8 ; CHECK: store i64 %v1, i64* %p2, align 8
; CHECK: ret i64 %v1 ; CHECK: ret i64 %v1
Show All 9 Lines

llvm/test/Transforms/InstCombine/tmp-alloca-bypass.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; See https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20210412/904154.html ; See https://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20210412/904154.html
; When replacing an allocation that is only modified by a memcpy/memmove from ; When replacing an allocation that is only modified by a memcpy/memmove from
; a constant whose alignment is equal to or exceeds that of the allocation, ; a constant whose alignment is equal to or exceeds that of the allocation,
; we also need to ensure that we actually can replace all uses of an alloca ; we also need to ensure that we actually can replace all uses of an alloca
; with said constant. This matters because it could be e.g. a select between ; with said constant. This matters because it could be e.g. a select between
; two constants, that happens after the first use of an alloca. ; two constants, that happens after the first use of an alloca.
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/toascii-1.ll

; Test that the toascii library call simplifier works correctly. ; Test that the toascii library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
declare i32 @toascii(i32) declare i32 @toascii(i32)
; Check isascii(c) -> c & 0x7f. ; Check isascii(c) -> c & 0x7f.
define i32 @test_simplify1() { define i32 @test_simplify1() {
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/token.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc18.0.0" target triple = "x86_64-pc-windows-msvc18.0.0"
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
define void @test1() personality i32 (...)* @__CxxFrameHandler3 { define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
bb: bb:
unreachable unreachable
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trivial-dse-calls.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
declare void @unknown() declare void @unknown()
declare void @f(i8*) declare void @f(i8*)
declare void @f2(i8*, i8*) declare void @f2(i8*, i8*)
declare i8* @f3(i8*, i8*) declare i8* @f3(i8*, i8*)
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-binop-ext.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i16 @narrow_sext_and(i16 %x16, i32 %y32) { define i16 @narrow_sext_and(i16 %x16, i32 %y32) {
; CHECK-LABEL: @narrow_sext_and( ; CHECK-LABEL: @narrow_sext_and(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %y32 to i16 ; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 %y32 to i16
; CHECK-NEXT: [[R:%.*]] = and i16 [[TMP1]], %x16 ; CHECK-NEXT: [[R:%.*]] = and i16 [[TMP1]], %x16
; CHECK-NEXT: ret i16 [[R]] ; CHECK-NEXT: ret i16 [[R]]
; ;
%x32 = sext i16 %x16 to i32 %x32 = sext i16 %x16 to i32
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-demand.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use6(i6) declare void @use6(i6)
declare void @use8(i8) declare void @use8(i8)
define i6 @trunc_lshr(i8 %x) { define i6 @trunc_lshr(i8 %x) {
; CHECK-LABEL: @trunc_lshr( ; CHECK-LABEL: @trunc_lshr(
; CHECK-NEXT: [[TMP1:%.*]] = trunc i8 [[X:%.*]] to i6 ; CHECK-NEXT: [[TMP1:%.*]] = trunc i8 [[X:%.*]] to i6
; CHECK-NEXT: [[TMP2:%.*]] = lshr i6 [[TMP1]], 2 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i6 [[TMP1]], 2
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-extractelement-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 -instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE
; RUN: opt < %s -instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE
define i32 @shrinkExtractElt_i64_to_i32_0(<3 x i64> %x) { define i32 @shrinkExtractElt_i64_to_i32_0(<3 x i64> %x) {
; LE-LABEL: @shrinkExtractElt_i64_to_i32_0( ; LE-LABEL: @shrinkExtractElt_i64_to_i32_0(
; LE-NEXT: [[TMP1:%.*]] = bitcast <3 x i64> [[X:%.*]] to <6 x i32> ; LE-NEXT: [[TMP1:%.*]] = bitcast <3 x i64> [[X:%.*]] to <6 x i32>
; LE-NEXT: [[T:%.*]] = extractelement <6 x i32> [[TMP1]], i64 0 ; LE-NEXT: [[T:%.*]] = extractelement <6 x i32> [[TMP1]], i64 0
; LE-NEXT: ret i32 [[T]] ; LE-NEXT: ret i32 [[T]]
; ;
; BE-LABEL: @shrinkExtractElt_i64_to_i32_0( ; BE-LABEL: @shrinkExtractElt_i64_to_i32_0(
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-extractelement.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 -instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e" | FileCheck %s --check-prefixes=ANY,LE
; RUN: opt < %s -instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E" | FileCheck %s --check-prefixes=ANY,BE
define i32 @shrinkExtractElt_i64_to_i32_0(<3 x i64> %x) { define i32 @shrinkExtractElt_i64_to_i32_0(<3 x i64> %x) {
; LE-LABEL: @shrinkExtractElt_i64_to_i32_0( ; LE-LABEL: @shrinkExtractElt_i64_to_i32_0(
; LE-NEXT: [[TMP1:%.*]] = bitcast <3 x i64> [[X:%.*]] to <6 x i32> ; LE-NEXT: [[TMP1:%.*]] = bitcast <3 x i64> [[X:%.*]] to <6 x i32>
; LE-NEXT: [[T:%.*]] = extractelement <6 x i32> [[TMP1]], i64 0 ; LE-NEXT: [[T:%.*]] = extractelement <6 x i32> [[TMP1]], i64 0
; LE-NEXT: ret i32 [[T]] ; LE-NEXT: ret i32 [[T]]
; ;
; BE-LABEL: @shrinkExtractElt_i64_to_i32_0( ; BE-LABEL: @shrinkExtractElt_i64_to_i32_0(
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
; Instcombine should be able to eliminate all of these ext casts. ; Instcombine should be able to eliminate all of these ext casts.
declare void @use(i32) declare void @use(i32)
declare void @use_vec(<2 x i32>) declare void @use_vec(<2 x i32>)
define i64 @test1(i64 %a) { define i64 @test1(i64 %a) {
▲ Show 20 Lines • Show All 1,013 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-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 -instcombine -S -data-layout="e-n16:32:64" | FileCheck %s ; RUN: opt < %s -passes=instcombine -S -data-layout="e-n16:32:64" | FileCheck %s
; RUN: opt < %s -instcombine -S -data-layout="E-n16:32:64" | FileCheck %s ; RUN: opt < %s -passes=instcombine -S -data-layout="E-n16:32:64" | FileCheck %s
; Don't narrow if it would lose information about the dereferenceable range of the pointer. ; Don't narrow if it would lose information about the dereferenceable range of the pointer.
define i32 @truncload_no_deref(i64* %ptr) { define i32 @truncload_no_deref(i64* %ptr) {
; CHECK-LABEL: @truncload_no_deref( ; CHECK-LABEL: @truncload_no_deref(
; CHECK-NEXT: [[X:%.*]] = load i64, i64* [[PTR:%.*]], align 4 ; CHECK-NEXT: [[X:%.*]] = load i64, i64* [[PTR:%.*]], align 4
; CHECK-NEXT: [[R:%.*]] = trunc i64 [[X]] to i32 ; CHECK-NEXT: [[R:%.*]] = trunc i64 [[X]] to i32
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/trunc-shift-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
; Perform the shift first and merge the truncs as long as all zero/sign ; Perform the shift first and merge the truncs as long as all zero/sign
; bits created by the shift are removed by the trunc. ; bits created by the shift are removed by the trunc.
declare void @use(i32) declare void @use(i32)
define i8 @trunc_lshr_trunc(i64 %a) { define i8 @trunc_lshr_trunc(i64 %a) {
▲ Show 20 Lines • Show All 173 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
; Instcombine should be able to eliminate all of these ext casts. ; Instcombine should be able to eliminate all of these ext casts.
declare void @use(i32) declare void @use(i32)
declare void @use_vec(<2 x i32>) declare void @use_vec(<2 x i32>)
define i64 @test1(i64 %a) { define i64 @test1(i64 %a) {
▲ Show 20 Lines • Show All 1,013 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/truncating-saturate.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
declare void @use(i32) declare void @use(i32)
declare void @use16(i16) declare void @use16(i16)
declare void @use1(i1) declare void @use1(i1)
define i8 @testi16i8(i16 %add) { define i8 @testi16i8(i16 %add) {
; CHECK-LABEL: @testi16i8( ; CHECK-LABEL: @testi16i8(
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/type_pun-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Ensure that type punning using a union of vector and same-sized array ; Ensure that type punning using a union of vector and same-sized array
; generates an extract instead of a shuffle with an uncommon vector size: ; generates an extract instead of a shuffle with an uncommon vector size:
; ;
; typedef uint32_t v4i32 __attribute__((vector_size(16))); ; typedef uint32_t v4i32 __attribute__((vector_size(16)));
; union { v4i32 v; uint32_t a[4]; }; ; union { v4i32 v; uint32_t a[4]; };
; ;
; This cleans up behind SROA, which inserts the uncommon vector size when ; This cleans up behind SROA, which inserts the uncommon vector size when
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/type_pun.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Ensure that type punning using a union of vector and same-sized array ; Ensure that type punning using a union of vector and same-sized array
; generates an extract instead of a shuffle with an uncommon vector size: ; generates an extract instead of a shuffle with an uncommon vector size:
; ;
; typedef uint32_t v4i32 __attribute__((vector_size(16))); ; typedef uint32_t v4i32 __attribute__((vector_size(16)));
; union { v4i32 v; uint32_t a[4]; }; ; union { v4i32 v; uint32_t a[4]; };
; ;
; This cleans up behind SROA, which inserts the uncommon vector size when ; This cleans up behind SROA, which inserts the uncommon vector size when
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/uadd-with-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { <2 x i32>, <2 x i1> } @llvm.uadd.with.overflow.v2i32(<2 x i32>, <2 x i32>) declare { <2 x i32>, <2 x i1> } @llvm.uadd.with.overflow.v2i32(<2 x i32>, <2 x i32>)
declare { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8>, <2 x i8>) declare { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8>, <2 x i8>)
declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32) declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32)
declare { i8, i1 } @llvm.uadd.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.uadd.with.overflow.i8(i8, i8)
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/uaddo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @uaddo_commute1(i32 %x, i32 %y, i32 %z) { define i32 @uaddo_commute1(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: @uaddo_commute1( ; CHECK-LABEL: @uaddo_commute1(
; CHECK-NEXT: [[NOTY:%.*]] = xor i32 [[Y:%.*]], -1 ; CHECK-NEXT: [[NOTY:%.*]] = xor i32 [[Y:%.*]], -1
; CHECK-NEXT: [[A:%.*]] = add i32 [[X:%.*]], [[Y]] ; CHECK-NEXT: [[A:%.*]] = add i32 [[X:%.*]], [[Y]]
; CHECK-NEXT: [[C:%.*]] = icmp ult i32 [[NOTY]], [[X]] ; CHECK-NEXT: [[C:%.*]] = icmp ult i32 [[NOTY]], [[X]]
; CHECK-NEXT: [[R:%.*]] = select i1 [[C]], i32 [[Z:%.*]], i32 [[A]] ; CHECK-NEXT: [[R:%.*]] = select i1 [[C]], i32 [[Z:%.*]], i32 [[A]]
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/uaddo2.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { i64, i1 } @llvm.uadd.with.overflow.i64(i64, i64) declare { i64, i1 } @llvm.uadd.with.overflow.i64(i64, i64)
declare { i8, i1 } @llvm.uadd.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.uadd.with.overflow.i8(i8, i8)
define i1 @test_generic(i64 %a, i64 %b) { define i1 @test_generic(i64 %a, i64 %b) {
; CHECK-LABEL: @test_generic( ; CHECK-LABEL: @test_generic(
; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]])
; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1 ; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/udiv-pow2-vscale-inseltpoison.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; This vscale udiv with a power-of-2 spalt on the rhs should not crash opt ; This vscale udiv with a power-of-2 spalt on the rhs should not crash opt
; CHECK: define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs) ; CHECK: define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs)
define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs) { define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs) {
%splatter = insertelement <vscale x 2 x i32> poison, i32 2, i32 0 %splatter = insertelement <vscale x 2 x i32> poison, i32 2, i32 0
%rhs = shufflevector <vscale x 2 x i32> %splatter, %rhs = shufflevector <vscale x 2 x i32> %splatter,
<vscale x 2 x i32> undef, <vscale x 2 x i32> undef,
Show All 18 Lines

llvm/test/Transforms/InstCombine/udiv-pow2-vscale.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; This vscale udiv with a power-of-2 spalt on the rhs should not crash opt ; This vscale udiv with a power-of-2 spalt on the rhs should not crash opt
; CHECK: define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs) ; CHECK: define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs)
define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs) { define <vscale x 2 x i32> @udiv_pow2_vscale(<vscale x 2 x i32> %lhs) {
%splatter = insertelement <vscale x 2 x i32> undef, i32 2, i32 0 %splatter = insertelement <vscale x 2 x i32> undef, i32 2, i32 0
%rhs = shufflevector <vscale x 2 x i32> %splatter, %rhs = shufflevector <vscale x 2 x i32> %splatter,
<vscale x 2 x i32> undef, <vscale x 2 x i32> undef,
Show All 18 Lines

llvm/test/Transforms/InstCombine/udiv-simplify.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i64 @test1(i32 %x) nounwind { define i64 @test1(i32 %x) nounwind {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i64 0 ; CHECK-NEXT: ret i64 0
; ;
%y = lshr i32 %x, 1 %y = lshr i32 %x, 1
%r = udiv i32 %y, -1 %r = udiv i32 %y, -1
%z = sext i32 %r to i64 %z = sext i32 %r to i64
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/udiv_select_to_select_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Test that this transform works: ; Test that this transform works:
; udiv X, (Select Cond, C1, C2) --> Select Cond, (shr X, C1), (shr X, C2) ; udiv X, (Select Cond, C1, C2) --> Select Cond, (shr X, C1), (shr X, C2)
define i64 @test(i64 %X, i1 %Cond ) { define i64 @test(i64 %X, i1 %Cond ) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[QUOTIENT1:%.*]] = lshr i64 [[X:%.*]], 4 ; CHECK-NEXT: [[QUOTIENT1:%.*]] = lshr i64 [[X:%.*]], 4
; CHECK-NEXT: [[QUOTIENT2:%.*]] = lshr i64 [[X]], 3 ; CHECK-NEXT: [[QUOTIENT2:%.*]] = lshr i64 [[X]], 3
Show All 28 Lines

llvm/test/Transforms/InstCombine/udivrem-change-width.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "n8:32" target datalayout = "n8:32"
; PR4548 ; PR4548
define i8 @udiv_i8(i8 %a, i8 %b) { define i8 @udiv_i8(i8 %a, i8 %b) {
; CHECK-LABEL: @udiv_i8( ; CHECK-LABEL: @udiv_i8(
; CHECK-NEXT: [[DIV:%.*]] = udiv i8 %a, %b ; CHECK-NEXT: [[DIV:%.*]] = udiv i8 %a, %b
; CHECK-NEXT: ret i8 [[DIV]] ; CHECK-NEXT: ret i8 [[DIV]]
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/umax-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; If we have a umax feeding an unsigned or equality icmp that shares an ; If we have a umax feeding an unsigned or equality icmp that shares an
; operand with the umax, the compare should always be folded. ; operand with the umax, the compare should always be folded.
; Test all 4 foldable predicates (eq,ne,ugt,ule) * 4 commutation ; Test all 4 foldable predicates (eq,ne,ugt,ule) * 4 commutation
; possibilities for each predicate. Note that folds to true/false ; possibilities for each predicate. Note that folds to true/false
; (predicate = uge/ult) or folds to an existing instruction should be ; (predicate = uge/ult) or folds to an existing instruction should be
; handled by InstSimplify. ; handled by InstSimplify.
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/umin-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; If we have a umin feeding an unsigned or equality icmp that shares an ; If we have a umin feeding an unsigned or equality icmp that shares an
; operand with the umin, the compare should always be folded. ; operand with the umin, the compare should always be folded.
; Test all 4 foldable predicates (eq,ne,uge,ult) * 4 commutation ; Test all 4 foldable predicates (eq,ne,uge,ult) * 4 commutation
; possibilities for each predicate. Note that folds to true/false ; possibilities for each predicate. Note that folds to true/false
; (predicate is ule/ugt) or folds to an existing instruction should be ; (predicate is ule/ugt) or folds to an existing instruction should be
; handled by InstSimplify. ; handled by InstSimplify.
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/umul-sign-check.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 -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
; Check that we simplify llvm.umul.with.overflow, if the overflow check is ; Check that we simplify llvm.umul.with.overflow, if the overflow check is
; weakened by or (icmp ne %res, 0) %overflow. This is generated by code using ; weakened by or (icmp ne %res, 0) %overflow. This is generated by code using
; __builtin_mul_overflow with negative integer constants, e.g. ; __builtin_mul_overflow with negative integer constants, e.g.
; bool test(unsigned long long v, unsigned long long *res) { ; bool test(unsigned long long v, unsigned long long *res) {
; return __builtin_mul_overflow(v, -4775807LL, res); ; return __builtin_mul_overflow(v, -4775807LL, res);
; } ; }
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/umulo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { i64, i1 } @llvm.umul.with.overflow.i64(i64, i64) declare { i64, i1 } @llvm.umul.with.overflow.i64(i64, i64)
declare { i8, i1 } @llvm.umul.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.umul.with.overflow.i8(i8, i8)
define i1 @test_generic(i64 %a, i64 %b) { define i1 @test_generic(i64 %a, i64 %b) {
; CHECK-LABEL: @test_generic( ; CHECK-LABEL: @test_generic(
; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.umul.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.umul.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]])
; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1 ; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unavailable-debug.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Make sure to update the debug value after dead code elimination. ; Make sure to update the debug value after dead code elimination.
; CHECK: %call = call signext i8 @b(i32 6), !dbg !39 ; CHECK: %call = call signext i8 @b(i32 6), !dbg !39
; CHECK-NEXT: call void @llvm.dbg.value(metadata i8 %call, metadata !30, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)), !dbg !38 ; CHECK-NEXT: call void @llvm.dbg.value(metadata i8 %call, metadata !30, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)), !dbg !38
@e = common local_unnamed_addr global i8 0, align 1, !dbg !0 @e = common local_unnamed_addr global i8 0, align 1, !dbg !0
@c = common local_unnamed_addr global i32 0, align 4, !dbg !6 @c = common local_unnamed_addr global i32 0, align 4, !dbg !6
@d = common local_unnamed_addr global i32 0, align 4, !dbg !10 @d = common local_unnamed_addr global i32 0, align 4, !dbg !10
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unfold-masked-merge-with-const-mask-scalar.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have a masked merge, in the form of: (M is constant) ; If we have a masked merge, in the form of: (M is constant)
; ((x ^ y) & M) ^ y ; ((x ^ y) & M) ^ y
; Unfold it to ; Unfold it to
; (x & M) | (y & ~M) ; (x & M) | (y & ~M)
define i4 @scalar0 (i4 %x, i4 %y) { define i4 @scalar0 (i4 %x, i4 %y) {
; CHECK-LABEL: @scalar0( ; CHECK-LABEL: @scalar0(
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unfold-masked-merge-with-const-mask-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; If we have a masked merge, in the form of: (M is constant) ; If we have a masked merge, in the form of: (M is constant)
; ((x ^ y) & M) ^ y ; ((x ^ y) & M) ^ y
; Unfold it to ; Unfold it to
; (x & M) | (y & ~M) ; (x & M) | (y & ~M)
define <2 x i4> @splat (<2 x i4> %x, <2 x i4> %y) { define <2 x i4> @splat (<2 x i4> %x, <2 x i4> %y) {
; CHECK-LABEL: @splat( ; CHECK-LABEL: @splat(
▲ Show 20 Lines • Show All 338 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unordered-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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define float @select_max_ugt(float %a, float %b) { define float @select_max_ugt(float %a, float %b) {
; CHECK-LABEL: define {{[^@]+}}@select_max_ugt( ; CHECK-LABEL: define {{[^@]+}}@select_max_ugt(
; CHECK-NEXT: [[CMP_INV:%.*]] = fcmp arcp ole float [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[CMP_INV:%.*]] = fcmp arcp ole float [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP1:%.*]] = select arcp i1 [[CMP_INV]], float [[B]], float [[A]] ; CHECK-NEXT: [[TMP1:%.*]] = select arcp i1 [[CMP_INV]], float [[B]], float [[A]]
; CHECK-NEXT: ret float [[TMP1]] ; CHECK-NEXT: ret float [[TMP1]]
; ;
%cmp = fcmp arcp ugt float %a, %b %cmp = fcmp arcp ugt float %a, %b
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unpack-fca.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64" target datalayout = "e-i64:64-f80:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%A__vtbl = type { i8*, i32 (%A*)* } %A__vtbl = type { i8*, i32 (%A*)* }
%A = type { %A__vtbl* } %A = type { %A__vtbl* }
%B = type { i8*, i64 } %B = type { i8*, i64 }
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unreachable-dbg-info-modified.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; When removing the llvm.dbg.value intrinsic in the unreachable block ; When removing the llvm.dbg.value intrinsic in the unreachable block
; InstCombine would incorrectly return a false Modified status. ; InstCombine would incorrectly return a false Modified status.
; CHECK: cond.true: ; CHECK: cond.true:
; CHECK-NEXT: br label %cond.end ; CHECK-NEXT: br label %cond.end
define i32 @foo() !dbg !7 { define i32 @foo() !dbg !7 {
Show All 32 Lines

llvm/test/Transforms/InstCombine/unrecognized_three-way-comparison.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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:128:128" 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:128:128"
declare void @foo(i32 %x) declare void @foo(i32 %x)
define i32 @compare_against_arbitrary_value(i32 %x, i32 %c) { define i32 @compare_against_arbitrary_value(i32 %x, i32 %c) {
; CHECK-LABEL: @compare_against_arbitrary_value( ; CHECK-LABEL: @compare_against_arbitrary_value(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 671 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-add-lack-of-overflow-check-via-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Should fold ; Should fold
; (%x + %y) u>= %x ; (%x + %y) u>= %x
; or ; or
; (%x + %y) u>= %y ; (%x + %y) u>= %y
; to ; to
; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not ; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not
; ;
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-add-lack-of-overflow-check-via-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Should fold ; Should fold
; (%y ^ -1) u>= %x ; (%y ^ -1) u>= %x
; to ; to
; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not ; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not
; ;
; All tests here have extra uses, to ensure that the pattern isn't perturbed. ; All tests here have extra uses, to ensure that the pattern isn't perturbed.
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-add-lack-of-overflow-check.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Should fold ; Should fold
; (%x + %y) u>= %x ; (%x + %y) u>= %x
; or ; or
; (%x + %y) u>= %y ; (%x + %y) u>= %y
; to ; to
; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not ; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-add-overflow-check-via-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Should fold ; Should fold
; (%x + %y) u< %x ; (%x + %y) u< %x
; or ; or
; (%x + %y) u< %y ; (%x + %y) u< %y
; to ; to
; @llvm.uadd.with.overflow(%x, %y) + extractvalue ; @llvm.uadd.with.overflow(%x, %y) + extractvalue
; ;
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-add-overflow-check-via-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Should fold ; Should fold
; (%y ^ -1) u< %x ; (%y ^ -1) u< %x
; to ; to
; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not ; @llvm.uadd.with.overflow(%x, %y) + extractvalue + not
; ;
; All tests here have extra uses, to ensure that the pattern isn't perturbed. ; All tests here have extra uses, to ensure that the pattern isn't perturbed.
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-add-overflow-check.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Should fold ; Should fold
; (%x + %y) u< %x ; (%x + %y) u< %x
; or ; or
; (%x + %y) u< %y ; (%x + %y) u< %y
; to ; to
; @llvm.uadd.with.overflow(%x, %y) + extractvalue ; @llvm.uadd.with.overflow(%x, %y) + extractvalue
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-mul-lack-of-overflow-check-via-mul-udiv.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; ((%x * %y) u/ %x) == %y ; ((%x * %y) u/ %x) == %y
; to ; to
; @llvm.umul.with.overflow(%x, %y) + extractvalue + not ; @llvm.umul.with.overflow(%x, %y) + extractvalue + not
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-mul-lack-of-overflow-check-via-udiv-of-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; (-1 u/ %x) u>= %y ; (-1 u/ %x) u>= %y
; to ; to
; @llvm.umul.with.overflow(%x, %y) + extractvalue + not ; @llvm.umul.with.overflow(%x, %y) + extractvalue + not
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-mul-overflow-check-via-mul-udiv.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; ((%x * %y) u/ %x) != %y ; ((%x * %y) u/ %x) != %y
; to ; to
; @llvm.umul.with.overflow(%x, %y) + extractvalue ; @llvm.umul.with.overflow(%x, %y) + extractvalue
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-mul-overflow-check-via-udiv-of-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; (-1 u/ %x) u< %y ; (-1 u/ %x) u< %y
; to ; to
; @llvm.umul.with.overflow(%x, %y) + extractvalue ; @llvm.umul.with.overflow(%x, %y) + extractvalue
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-sub-lack-of-overflow-check.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; (%x - %y) u<= %x ; (%x - %y) u<= %x
; to ; to
; @llvm.sub.with.overflow(%x, %y) + extractvalue + not ; @llvm.sub.with.overflow(%x, %y) + extractvalue + not
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned-sub-overflow-check.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; (%x - %y) u> %x ; (%x - %y) u> %x
; to ; to
; @llvm.sub.with.overflow(%x, %y) + extractvalue ; @llvm.sub.with.overflow(%x, %y) + extractvalue
define i1 @t0_basic(i8 %x, i8 %y) { define i1 @t0_basic(i8 %x, i8 %y) {
; CHECK-LABEL: @t0_basic( ; CHECK-LABEL: @t0_basic(
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/unsigned_saturated_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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; Canonicalization of unsigned saturated subtraction idioms to ; Canonicalization of unsigned saturated subtraction idioms to
; usub.sat() intrinsics is tested here. ; usub.sat() intrinsics is tested here.
declare void @use(i64) declare void @use(i64)
declare void @usei32(i32) declare void @usei32(i32)
declare void @usei1(i1) declare void @usei1(i1)
▲ Show 20 Lines • Show All 443 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/urem-simplify-bug.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@.str = internal constant [5 x i8] c"foo\0A\00" @.str = internal constant [5 x i8] c"foo\0A\00"
@.str1 = internal constant [5 x i8] c"bar\0A\00" @.str1 = internal constant [5 x i8] c"bar\0A\00"
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%x = call i32 @func_11() nounwind %x = call i32 @func_11() nounwind
%tmp3 = or i32 %x, -5 %tmp3 = or i32 %x, -5
Show All 27 Lines

llvm/test/Transforms/InstCombine/urem-via-udiv-mul-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Fold ; Fold
; x - ((x / y) * y) ; x - ((x / y) * y)
; to ; to
; x % y ; x % y
; Also, ; Also,
; ((x / y) * y) ; ((x / y) * y)
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/usub-overflow-known-by-implied-cond.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 -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32) declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32)
define i32 @test1(i32 %a, i32 %b) { define i32 @test1(i32 %a, i32 %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[COND_NOT:%.*]] = icmp ult i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[COND_NOT:%.*]] = icmp ult i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: br i1 [[COND_NOT]], label [[BB3:%.*]], label [[BB1:%.*]] ; CHECK-NEXT: br i1 [[COND_NOT]], label [[BB3:%.*]], label [[BB1:%.*]]
; CHECK: bb1: ; CHECK: bb1:
▲ Show 20 Lines • Show All 473 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/usubo.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare { i64, i1 } @llvm.usub.with.overflow.i64(i64, i64) declare { i64, i1 } @llvm.usub.with.overflow.i64(i64, i64)
declare { i8, i1 } @llvm.usub.with.overflow.i8(i8, i8) declare { i8, i1 } @llvm.usub.with.overflow.i8(i8, i8)
define i1 @test_generic(i64 %a, i64 %b) { define i1 @test_generic(i64 %a, i64 %b) {
; CHECK-LABEL: @test_generic( ; CHECK-LABEL: @test_generic(
; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 [[A:%.*]], i64 [[B:%.*]])
; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1 ; CHECK-NEXT: [[OVERFLOW:%.*]] = extractvalue { i64, i1 } [[RES]], 1
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/variable-signext-of-variable-high-bit-extraction.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use16(i16) declare void @use16(i16)
declare void @use32(i32) declare void @use32(i32)
declare void @use64(i64) declare void @use64(i64)
define i32 @t0(i64 %data, i32 %nbits) { define i32 @t0(i64 %data, i32 %nbits) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
; CHECK-NEXT: [[SKIP_HIGH:%.*]] = sub i32 64, [[NBITS:%.*]] ; CHECK-NEXT: [[SKIP_HIGH:%.*]] = sub i32 64, [[NBITS:%.*]]
▲ Show 20 Lines • Show All 565 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec-binop-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Non-canonical mask ; Non-canonical mask
define <4 x i32> @and(<4 x i32> %x, <4 x i32> %y) { define <4 x i32> @and(<4 x i32> %x, <4 x i32> %y) {
; CHECK-LABEL: @and( ; CHECK-LABEL: @and(
; CHECK-NEXT: [[R:%.*]] = and <4 x i32> [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[R:%.*]] = and <4 x i32> [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret <4 x i32> [[R]] ; CHECK-NEXT: ret <4 x i32> [[R]]
; ;
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec-binop-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Non-canonical mask ; Non-canonical mask
define <4 x i32> @and(<4 x i32> %x, <4 x i32> %y) { define <4 x i32> @and(<4 x i32> %x, <4 x i32> %y) {
; CHECK-LABEL: @and( ; CHECK-LABEL: @and(
; CHECK-NEXT: [[R:%.*]] = and <4 x i32> [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[R:%.*]] = and <4 x i32> [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret <4 x i32> [[R]] ; CHECK-NEXT: ret <4 x i32> [[R]]
; ;
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_demanded_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
define i32 @test2(float %f) { define i32 @test2(float %f) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[T5:%.*]] = fmul float [[F:%.*]], [[F]] ; CHECK-NEXT: [[T5:%.*]] = fmul float [[F:%.*]], [[F]]
; CHECK-NEXT: [[T21:%.*]] = bitcast float [[T5]] to i32 ; CHECK-NEXT: [[T21:%.*]] = bitcast float [[T5]] to i32
; CHECK-NEXT: ret i32 [[T21]] ; CHECK-NEXT: ret i32 [[T21]]
; ;
▲ Show 20 Lines • Show All 834 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_demanded_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
define i32 @test2(float %f) { define i32 @test2(float %f) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[T5:%.*]] = fmul float [[F:%.*]], [[F]] ; CHECK-NEXT: [[T5:%.*]] = fmul float [[F:%.*]], [[F]]
; CHECK-NEXT: [[T21:%.*]] = bitcast float [[T5]] to i32 ; CHECK-NEXT: [[T21:%.*]] = bitcast float [[T5]] to i32
; CHECK-NEXT: ret i32 [[T21]] ; CHECK-NEXT: ret i32 [[T21]]
; ;
▲ Show 20 Lines • Show All 834 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_extract_2elts.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define void @test(<4 x i32> %v, i64 *%r1, i64 *%r2) { define void @test(<4 x i32> %v, i64 *%r1, i64 *%r2) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[TMP1:%.*]] = extractelement <4 x i32> [[V:%.*]], i64 0 ; CHECK-NEXT: [[TMP1:%.*]] = extractelement <4 x i32> [[V:%.*]], i64 0
; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64 ; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64
; CHECK-NEXT: store i64 [[TMP2]], i64* [[R1:%.*]], align 4 ; CHECK-NEXT: store i64 [[TMP2]], i64* [[R1:%.*]], align 4
; CHECK-NEXT: store i64 [[TMP2]], i64* [[R2:%.*]], align 4 ; CHECK-NEXT: store i64 [[TMP2]], i64* [[R2:%.*]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%1 = zext <4 x i32> %v to <4 x i64> %1 = zext <4 x i32> %v to <4 x i64>
%2 = extractelement <4 x i64> %1, i32 0 %2 = extractelement <4 x i64> %1, i32 0
store i64 %2, i64 *%r1 store i64 %2, i64 *%r1
store i64 %2, i64 *%r2 store i64 %2, i64 *%r2
ret void ret void
} }

llvm/test/Transforms/InstCombine/vec_extract_var_elt-inseltpoison.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define void @test (float %b, <8 x float> * %p) { define void @test (float %b, <8 x float> * %p) {
; CHECK: extractelement ; CHECK: extractelement
; CHECK: fptosi ; CHECK: fptosi
%1 = load <8 x float> , <8 x float> * %p %1 = load <8 x float> , <8 x float> * %p
%2 = bitcast <8 x float> %1 to <8 x i32> %2 = bitcast <8 x float> %1 to <8 x i32>
%3 = bitcast <8 x i32> %2 to <8 x float> %3 = bitcast <8 x i32> %2 to <8 x float>
%a = fptosi <8 x float> %3 to <8 x i32> %a = fptosi <8 x float> %3 to <8 x i32>
Show All 17 Lines

llvm/test/Transforms/InstCombine/vec_extract_var_elt.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define void @test (float %b, <8 x float> * %p) { define void @test (float %b, <8 x float> * %p) {
; CHECK: extractelement ; CHECK: extractelement
; CHECK: fptosi ; CHECK: fptosi
%1 = load <8 x float> , <8 x float> * %p %1 = load <8 x float> , <8 x float> * %p
%2 = bitcast <8 x float> %1 to <8 x i32> %2 = bitcast <8 x float> %1 to <8 x i32>
%3 = bitcast <8 x i32> %2 to <8 x float> %3 = bitcast <8 x i32> %2 to <8 x float>
%a = fptosi <8 x float> %3 to <8 x i32> %a = fptosi <8 x float> %3 to <8 x i32>
Show All 17 Lines

llvm/test/Transforms/InstCombine/vec_gep_scalar_arg-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define <4 x i16*> @PR41270([4 x i16]* %x) { define <4 x i16*> @PR41270([4 x i16]* %x) {
; CHECK-LABEL: @PR41270( ; CHECK-LABEL: @PR41270(
; CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [4 x i16], [4 x i16]* [[X:%.*]], i64 0, i64 3 ; CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [4 x i16], [4 x i16]* [[X:%.*]], i64 0, i64 3
; CHECK-NEXT: [[INS2:%.*]] = insertelement <4 x i16*> poison, i16* [[T3]], i64 0 ; CHECK-NEXT: [[INS2:%.*]] = insertelement <4 x i16*> poison, i16* [[T3]], i64 0
; CHECK-NEXT: ret <4 x i16*> [[INS2]] ; CHECK-NEXT: ret <4 x i16*> [[INS2]]
; ;
%ins = insertelement <4 x [4 x i16]*> poison, [4 x i16]* %x, i32 0 %ins = insertelement <4 x [4 x i16]*> poison, [4 x i16]* %x, i32 0
%splat = shufflevector <4 x [4 x i16]*> %ins, <4 x [4 x i16]*> poison, <4 x i32> zeroinitializer %splat = shufflevector <4 x [4 x i16]*> %ins, <4 x [4 x i16]*> poison, <4 x i32> zeroinitializer
%t2 = getelementptr inbounds [4 x i16], <4 x [4 x i16]*> %splat, i32 0, i32 3 %t2 = getelementptr inbounds [4 x i16], <4 x [4 x i16]*> %splat, i32 0, i32 3
%t3 = extractelement <4 x i16*> %t2, i32 3 %t3 = extractelement <4 x i16*> %t2, i32 3
%ins2 = insertelement <4 x i16*> poison, i16* %t3, i32 0 %ins2 = insertelement <4 x i16*> poison, i16* %t3, i32 0
ret <4 x i16*> %ins2 ret <4 x i16*> %ins2
} }

llvm/test/Transforms/InstCombine/vec_gep_scalar_arg.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define <4 x i16*> @PR41270([4 x i16]* %x) { define <4 x i16*> @PR41270([4 x i16]* %x) {
; CHECK-LABEL: @PR41270( ; CHECK-LABEL: @PR41270(
; CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [4 x i16], [4 x i16]* [[X:%.*]], i64 0, i64 3 ; CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [4 x i16], [4 x i16]* [[X:%.*]], i64 0, i64 3
; CHECK-NEXT: [[INS2:%.*]] = insertelement <4 x i16*> undef, i16* [[T3]], i64 0 ; CHECK-NEXT: [[INS2:%.*]] = insertelement <4 x i16*> undef, i16* [[T3]], i64 0
; CHECK-NEXT: ret <4 x i16*> [[INS2]] ; CHECK-NEXT: ret <4 x i16*> [[INS2]]
; ;
%ins = insertelement <4 x [4 x i16]*> undef, [4 x i16]* %x, i32 0 %ins = insertelement <4 x [4 x i16]*> undef, [4 x i16]* %x, i32 0
%splat = shufflevector <4 x [4 x i16]*> %ins, <4 x [4 x i16]*> undef, <4 x i32> zeroinitializer %splat = shufflevector <4 x [4 x i16]*> %ins, <4 x [4 x i16]*> undef, <4 x i32> zeroinitializer
%t2 = getelementptr inbounds [4 x i16], <4 x [4 x i16]*> %splat, i32 0, i32 3 %t2 = getelementptr inbounds [4 x i16], <4 x [4 x i16]*> %splat, i32 0, i32 3
%t3 = extractelement <4 x i16*> %t2, i32 3 %t3 = extractelement <4 x i16*> %t2, i32 3
%ins2 = insertelement <4 x i16*> undef, i16* %t3, i32 0 %ins2 = insertelement <4 x i16*> undef, i16* %t3, i32 0
ret <4 x i16*> %ins2 ret <4 x i16*> %ins2
} }

llvm/test/Transforms/InstCombine/vec_phi_extract-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define void @f(i64 %val, i32 %limit, i32 *%ptr) { define void @f(i64 %val, i32 %limit, i32 *%ptr) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[VAL:%.*]] to i32 ; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[VAL:%.*]] to i32
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[ENTRY:%.*]] ], [ [[TMP5:%.*]], [[LOOP]] ] ; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[ENTRY:%.*]] ], [ [[TMP5:%.*]], [[LOOP]] ]
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_phi_extract.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define void @f(i64 %val, i32 %limit, i32 *%ptr) { define void @f(i64 %val, i32 %limit, i32 *%ptr) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[VAL:%.*]] to i32 ; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[VAL:%.*]] to i32
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[ENTRY:%.*]] ], [ [[TMP5:%.*]], [[LOOP]] ] ; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[TMP0]], [[ENTRY:%.*]] ], [ [[TMP5:%.*]], [[LOOP]] ]
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_sext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <4 x i32> @vec_select(<4 x i32> %a, <4 x i32> %b) { define <4 x i32> @vec_select(<4 x i32> %a, <4 x i32> %b) {
; CHECK-LABEL: @vec_select( ; CHECK-LABEL: @vec_select(
; CHECK-NEXT: [[SUB:%.*]] = sub nsw <4 x i32> zeroinitializer, [[A:%.*]] ; CHECK-NEXT: [[SUB:%.*]] = sub nsw <4 x i32> zeroinitializer, [[A:%.*]]
; CHECK-NEXT: [[ISNEG:%.*]] = icmp slt <4 x i32> [[B:%.*]], zeroinitializer ; CHECK-NEXT: [[ISNEG:%.*]] = icmp slt <4 x i32> [[B:%.*]], zeroinitializer
; CHECK-NEXT: [[T2:%.*]] = select <4 x i1> [[ISNEG]], <4 x i32> zeroinitializer, <4 x i32> [[A]] ; CHECK-NEXT: [[T2:%.*]] = select <4 x i1> [[ISNEG]], <4 x i32> zeroinitializer, <4 x i32> [[A]]
; CHECK-NEXT: [[ISNEG1:%.*]] = icmp slt <4 x i32> [[B]], zeroinitializer ; CHECK-NEXT: [[ISNEG1:%.*]] = icmp slt <4 x i32> [[B]], zeroinitializer
; CHECK-NEXT: [[T3:%.*]] = select <4 x i1> [[ISNEG1]], <4 x i32> [[SUB]], <4 x i32> zeroinitializer ; CHECK-NEXT: [[T3:%.*]] = select <4 x i1> [[ISNEG1]], <4 x i32> [[SUB]], <4 x i32> zeroinitializer
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_shuffle-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <4 x float> @test1(<4 x float> %v1) { define <4 x float> @test1(<4 x float> %v1) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret <4 x float> [[V1:%.*]] ; CHECK-NEXT: ret <4 x float> [[V1:%.*]]
; ;
%v2 = shufflevector <4 x float> %v1, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3> %v2 = shufflevector <4 x float> %v1, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
ret <4 x float> %v2 ret <4 x float> %v2
} }
▲ Show 20 Lines • Show All 1,780 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_shuffle.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <4 x float> @test1(<4 x float> %v1) { define <4 x float> @test1(<4 x float> %v1) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret <4 x float> [[V1:%.*]] ; CHECK-NEXT: ret <4 x float> [[V1:%.*]]
; ;
%v2 = shufflevector <4 x float> %v1, <4 x float> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3> %v2 = shufflevector <4 x float> %v1, <4 x float> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
ret <4 x float> %v2 ret <4 x float> %v2
} }
▲ Show 20 Lines • Show All 1,780 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vec_udiv_to_shift.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <8 x i16> @udiv_vec8x16(<8 x i16> %var) { define <8 x i16> @udiv_vec8x16(<8 x i16> %var) {
entry: entry:
; CHECK: lshr <8 x i16> %var, <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5> ; CHECK: lshr <8 x i16> %var, <i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5, i16 5>
%0 = udiv <8 x i16> %var, <i16 32, i16 32, i16 32, i16 32, i16 32, i16 32, i16 32, i16 32> %0 = udiv <8 x i16> %var, <i16 32, i16 32, i16 32, i16 32, i16 32, i16 32, i16 32, i16 32>
ret <8 x i16> %0 ret <8 x i16> %0
} }
define <4 x i32> @udiv_vec4x32(<4 x i32> %var) { define <4 x i32> @udiv_vec4x32(<4 x i32> %var) {
entry: entry:
; CHECK: lshr <4 x i32> %var, <i32 4, i32 4, i32 4, i32 4> ; CHECK: lshr <4 x i32> %var, <i32 4, i32 4, i32 4, i32 4>
%0 = udiv <4 x i32> %var, <i32 16, i32 16, i32 16, i32 16> %0 = udiv <4 x i32> %var, <i32 16, i32 16, i32 16, i32 16>
ret <4 x i32> %0 ret <4 x i32> %0
} }

llvm/test/Transforms/InstCombine/vector-casts-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Can't get smaller than this. ; Can't get smaller than this.
define <2 x i1> @trunc(<2 x i64> %a) { define <2 x i1> @trunc(<2 x i64> %a) {
; CHECK-LABEL: @trunc( ; CHECK-LABEL: @trunc(
; CHECK-NEXT: [[T:%.*]] = trunc <2 x i64> [[A:%.*]] to <2 x i1> ; CHECK-NEXT: [[T:%.*]] = trunc <2 x i64> [[A:%.*]] to <2 x i1>
; CHECK-NEXT: ret <2 x i1> [[T]] ; CHECK-NEXT: ret <2 x i1> [[T]]
; ;
▲ Show 20 Lines • Show All 403 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-casts.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Can't get smaller than this. ; Can't get smaller than this.
define <2 x i1> @trunc(<2 x i64> %a) { define <2 x i1> @trunc(<2 x i64> %a) {
; CHECK-LABEL: @trunc( ; CHECK-LABEL: @trunc(
; CHECK-NEXT: [[T:%.*]] = trunc <2 x i64> [[A:%.*]] to <2 x i1> ; CHECK-NEXT: [[T:%.*]] = trunc <2 x i64> [[A:%.*]] to <2 x i1>
; CHECK-NEXT: ret <2 x i1> [[T]] ; CHECK-NEXT: ret <2 x i1> [[T]]
; ;
▲ Show 20 Lines • Show All 545 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-concat-binop-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 -instcombine %s | FileCheck %s ; RUN: opt -S -passes=instcombine %s | FileCheck %s
define <4 x i8> @add(<2 x i8> %a, <2 x i8> %b, <2 x i8> %c, <2 x i8> %d) { define <4 x i8> @add(<2 x i8> %a, <2 x i8> %b, <2 x i8> %c, <2 x i8> %d) {
; CHECK-LABEL: @add( ; CHECK-LABEL: @add(
; CHECK-NEXT: [[TMP1:%.*]] = and <2 x i8> [[A:%.*]], [[C:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = and <2 x i8> [[A:%.*]], [[C:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = and <2 x i8> [[B:%.*]], [[D:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and <2 x i8> [[B:%.*]], [[D:%.*]]
; CHECK-NEXT: [[R:%.*]] = shufflevector <2 x i8> [[TMP1]], <2 x i8> [[TMP2]], <4 x i32> <i32 0, i32 1, i32 2, i32 3> ; CHECK-NEXT: [[R:%.*]] = shufflevector <2 x i8> [[TMP1]], <2 x i8> [[TMP2]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
; CHECK-NEXT: ret <4 x i8> [[R]] ; CHECK-NEXT: ret <4 x i8> [[R]]
; ;
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-concat-binop.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 -instcombine %s | FileCheck %s ; RUN: opt -S -passes=instcombine %s | FileCheck %s
define <4 x i8> @add(<2 x i8> %a, <2 x i8> %b, <2 x i8> %c, <2 x i8> %d) { define <4 x i8> @add(<2 x i8> %a, <2 x i8> %b, <2 x i8> %c, <2 x i8> %d) {
; CHECK-LABEL: @add( ; CHECK-LABEL: @add(
; CHECK-NEXT: [[TMP1:%.*]] = and <2 x i8> [[A:%.*]], [[C:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = and <2 x i8> [[A:%.*]], [[C:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = and <2 x i8> [[B:%.*]], [[D:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and <2 x i8> [[B:%.*]], [[D:%.*]]
; CHECK-NEXT: [[R:%.*]] = shufflevector <2 x i8> [[TMP1]], <2 x i8> [[TMP2]], <4 x i32> <i32 0, i32 1, i32 2, i32 3> ; CHECK-NEXT: [[R:%.*]] = shufflevector <2 x i8> [[TMP1]], <2 x i8> [[TMP2]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
; CHECK-NEXT: ret <4 x i8> [[R]] ; CHECK-NEXT: ret <4 x i8> [[R]]
; ;
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-logical-reductions.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @reduction_logical_or(<4 x i1> %x) { define i1 @reduction_logical_or(<4 x i1> %x) {
; CHECK-LABEL: @reduction_logical_or( ; CHECK-LABEL: @reduction_logical_or(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <4 x i1> [[X:%.*]] to i4 ; CHECK-NEXT: [[TMP1:%.*]] = bitcast <4 x i1> [[X:%.*]] to i4
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i4 [[TMP1]], 0 ; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i4 [[TMP1]], 0
; CHECK-NEXT: ret i1 [[TMP2]] ; CHECK-NEXT: ret i1 [[TMP2]]
; ;
%r = call i1 @llvm.vector.reduce.or.v4i1(<4 x i1> %x) %r = call i1 @llvm.vector.reduce.or.v4i1(<4 x i1> %x)
Show All 15 Lines

llvm/test/Transforms/InstCombine/vector-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Check that instcombine rewrites multiply by a vector ; Check that instcombine rewrites multiply by a vector
; of known constant power-of-2 elements with vector shift. ; of known constant power-of-2 elements with vector shift.
define <4 x i8> @Zero_i8(<4 x i8> %InVec) { define <4 x i8> @Zero_i8(<4 x i8> %InVec) {
; CHECK-LABEL: @Zero_i8( ; CHECK-LABEL: @Zero_i8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret <4 x i8> zeroinitializer ; CHECK-NEXT: ret <4 x i8> zeroinitializer
▲ Show 20 Lines • Show All 435 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-reductions.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare float @llvm.vector.reduce.fadd.f32.v4f32(float, <4 x float>) declare float @llvm.vector.reduce.fadd.f32.v4f32(float, <4 x float>)
declare float @llvm.vector.reduce.fadd.f32.v8f32(float, <8 x float>) declare float @llvm.vector.reduce.fadd.f32.v8f32(float, <8 x float>)
declare void @use_f32(float) declare void @use_f32(float)
declare i32 @llvm.vector.reduce.add.v4i32(<4 x i32>) declare i32 @llvm.vector.reduce.add.v4i32(<4 x i32>)
declare i32 @llvm.vector.reduce.add.v8i32(<8 x i32>) declare i32 @llvm.vector.reduce.add.v8i32(<8 x i32>)
declare void @use_i32(i32) declare void @use_i32(i32)
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-reverse.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Test that the reverse is eliminated if the output and all the inputs ; Test that the reverse is eliminated if the output and all the inputs
; of the instruction are calls to reverse. ; of the instruction are calls to reverse.
define <vscale x 4 x i32> @binop_reverse(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) { define <vscale x 4 x i32> @binop_reverse(<vscale x 4 x i32> %a, <vscale x 4 x i32> %b) {
; CHECK-LABEL: @binop_reverse( ; CHECK-LABEL: @binop_reverse(
; CHECK-NEXT: [[ADD1:%.*]] = add <vscale x 4 x i32> [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[ADD1:%.*]] = add <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: ret <vscale x 4 x i32> [[ADD1]] ; CHECK-NEXT: ret <vscale x 4 x i32> [[ADD1]]
; ;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-type.ll

; The code in InstCombiner::FoldSelectOpOp was calling ; The code in InstCombiner::FoldSelectOpOp was calling
; Type::getVectorNumElements without checking first if the type was a vector. ; Type::getVectorNumElements without checking first if the type was a vector.
; RUN: opt < %s -instcombine -S ; RUN: opt < %s -passes=instcombine -S
define i32 @vselect1(i32 %a.coerce, i32 %b.coerce, i32 %c.coerce) { define i32 @vselect1(i32 %a.coerce, i32 %b.coerce, i32 %c.coerce) {
entry: entry:
%0 = bitcast i32 %a.coerce to <2 x i16> %0 = bitcast i32 %a.coerce to <2 x i16>
%1 = bitcast i32 %b.coerce to <2 x i16> %1 = bitcast i32 %b.coerce to <2 x i16>
%2 = bitcast i32 %c.coerce to <2 x i16> %2 = bitcast i32 %c.coerce to <2 x i16>
%cmp = icmp sge <2 x i16> %2, zeroinitializer %cmp = icmp sge <2 x i16> %2, zeroinitializer
%or = select <2 x i1> %cmp, <2 x i16> %0, <2 x i16> %1 %or = select <2 x i1> %cmp, <2 x i16> %0, <2 x i16> %1
%3 = bitcast <2 x i16> %or to i32 %3 = bitcast <2 x i16> %or to i32
ret i32 %3 ret i32 %3
} }

llvm/test/Transforms/InstCombine/vector-udiv.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <4 x i32> @test_v4i32_splatconst_pow2(<4 x i32> %a0) { define <4 x i32> @test_v4i32_splatconst_pow2(<4 x i32> %a0) {
; CHECK-LABEL: @test_v4i32_splatconst_pow2( ; CHECK-LABEL: @test_v4i32_splatconst_pow2(
; CHECK-NEXT: [[TMP1:%.*]] = lshr <4 x i32> [[A0:%.*]], <i32 1, i32 1, i32 1, i32 1> ; CHECK-NEXT: [[TMP1:%.*]] = lshr <4 x i32> [[A0:%.*]], <i32 1, i32 1, i32 1, i32 1>
; CHECK-NEXT: ret <4 x i32> [[TMP1]] ; CHECK-NEXT: ret <4 x i32> [[TMP1]]
; ;
%1 = udiv <4 x i32> %a0, <i32 2, i32 2, i32 2, i32 2> %1 = udiv <4 x i32> %a0, <i32 2, i32 2, i32 2, i32 2>
ret <4 x i32> %1 ret <4 x i32> %1
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-urem.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <4 x i32> @test_v4i32_splatconst_pow2(<4 x i32> %a0) { define <4 x i32> @test_v4i32_splatconst_pow2(<4 x i32> %a0) {
; CHECK-LABEL: @test_v4i32_splatconst_pow2( ; CHECK-LABEL: @test_v4i32_splatconst_pow2(
; CHECK-NEXT: [[TMP1:%.*]] = and <4 x i32> [[A0:%.*]], <i32 1, i32 1, i32 1, i32 1> ; CHECK-NEXT: [[TMP1:%.*]] = and <4 x i32> [[A0:%.*]], <i32 1, i32 1, i32 1, i32 1>
; CHECK-NEXT: ret <4 x i32> [[TMP1]] ; CHECK-NEXT: ret <4 x i32> [[TMP1]]
; ;
%1 = urem <4 x i32> %a0, <i32 2, i32 2, i32 2, i32 2> %1 = urem <4 x i32> %a0, <i32 2, i32 2, i32 2, i32 2>
ret <4 x i32> %1 ret <4 x i32> %1
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; (A&B)^(A&C) -> A&(B^C) etc ; (A&B)^(A&C) -> A&(B^C) etc
define <4 x i32> @test_v4i32_xor_repeated_and_0(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c) { define <4 x i32> @test_v4i32_xor_repeated_and_0(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c) {
; CHECK-LABEL: @test_v4i32_xor_repeated_and_0( ; CHECK-LABEL: @test_v4i32_xor_repeated_and_0(
; CHECK-NEXT: [[TMP1:%.*]] = xor <4 x i32> [[B:%.*]], [[C:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = xor <4 x i32> [[B:%.*]], [[C:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = and <4 x i32> [[TMP1]], [[A:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and <4 x i32> [[TMP1]], [[A:%.*]]
; CHECK-NEXT: ret <4 x i32> [[TMP2]] ; CHECK-NEXT: ret <4 x i32> [[TMP2]]
▲ Show 20 Lines • Show All 271 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector_gep1-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@G1 = global i8 zeroinitializer @G1 = global i8 zeroinitializer
define <2 x i1> @test(<2 x i8*> %a, <2 x i8*> %b) { define <2 x i1> @test(<2 x i8*> %a, <2 x i8*> %b) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector_gep1.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
@G1 = global i8 zeroinitializer @G1 = global i8 zeroinitializer
define <2 x i1> @test(<2 x i8*> %a, <2 x i8*> %b) { define <2 x i1> @test(<2 x i8*> %a, <2 x i8*> %b) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector_gep2.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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 <2 x i8*> @testa(<2 x i8*> %a) { define <2 x i8*> @testa(<2 x i8*> %a) {
; CHECK-LABEL: @testa( ; CHECK-LABEL: @testa(
; CHECK-NEXT: [[G:%.*]] = getelementptr i8, <2 x i8*> [[A:%.*]], <2 x i64> <i64 0, i64 1> ; CHECK-NEXT: [[G:%.*]] = getelementptr i8, <2 x i8*> [[A:%.*]], <2 x i64> <i64 0, i64 1>
; CHECK-NEXT: ret <2 x i8*> [[G]] ; CHECK-NEXT: ret <2 x i8*> [[G]]
Show All 34 Lines

llvm/test/Transforms/InstCombine/vector_insertelt_shuffle-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; insertelements should fold to shuffle ; insertelements should fold to shuffle
define <4 x float> @foo(<4 x float> %x) { define <4 x float> @foo(<4 x float> %x) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[INS2:%.*]] = shufflevector <4 x float> [[X:%.*]], <4 x float> <float poison, float 1.000000e+00, float 2.000000e+00, float poison>, <4 x i32> <i32 0, i32 5, i32 6, i32 3> ; CHECK-NEXT: [[INS2:%.*]] = shufflevector <4 x float> [[X:%.*]], <4 x float> <float poison, float 1.000000e+00, float 2.000000e+00, float poison>, <4 x i32> <i32 0, i32 5, i32 6, i32 3>
; CHECK-NEXT: ret <4 x float> [[INS2]] ; CHECK-NEXT: ret <4 x float> [[INS2]]
; ;
%ins1 = insertelement<4 x float> %x, float 1.0, i32 1 %ins1 = insertelement<4 x float> %x, float 1.0, i32 1
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vector_insertelt_shuffle.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; insertelements should fold to shuffle ; insertelements should fold to shuffle
define <4 x float> @foo(<4 x float> %x) { define <4 x float> @foo(<4 x float> %x) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[INS2:%.*]] = shufflevector <4 x float> [[X:%.*]], <4 x float> <float poison, float 1.000000e+00, float 2.000000e+00, float poison>, <4 x i32> <i32 0, i32 5, i32 6, i32 3> ; CHECK-NEXT: [[INS2:%.*]] = shufflevector <4 x float> [[X:%.*]], <4 x float> <float poison, float 1.000000e+00, float 2.000000e+00, float poison>, <4 x i32> <i32 0, i32 5, i32 6, i32 3>
; CHECK-NEXT: ret <4 x float> [[INS2]] ; CHECK-NEXT: ret <4 x float> [[INS2]]
; ;
%ins1 = insertelement<4 x float> %x, float 1.0, i32 1 %ins1 = insertelement<4 x float> %x, float 1.0, i32 1
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/volatile_load_cast.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Ensure that volatile loads followed by a bitcast don't get transformed into a ; Ensure that volatile loads followed by a bitcast don't get transformed into a
; volatile load of the bitcast-target type. This is unlikely to provide much in ; volatile load of the bitcast-target type. This is unlikely to provide much in
; terms of optimizations, and might break the programmer's expectation for code ; terms of optimizations, and might break the programmer's expectation for code
; generation, however brittle that expectation might be. ; generation, however brittle that expectation might be.
; ;
; See llvm.org/D75644 and llvm.org/D75505 ; See llvm.org/D75644 and llvm.org/D75505
target datalayout = "e-p:64:64-i32:32:32-i64:64:64-f32:32:32-f64:64:64" target datalayout = "e-p:64:64-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/volatile_store.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@x = weak global i32 0 @x = weak global i32 0
define void @self_assign_1() { define void @self_assign_1() {
; CHECK-LABEL: @self_assign_1( ; CHECK-LABEL: @self_assign_1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP:%.*]] = load volatile i32, i32* @x, align 4 ; CHECK-NEXT: [[TMP:%.*]] = load volatile i32, i32* @x, align 4
; CHECK-NEXT: store volatile i32 [[TMP]], i32* @x, align 4 ; CHECK-NEXT: store volatile i32 [[TMP]], i32* @x, align 4
Show All 31 Lines

llvm/test/Transforms/InstCombine/vscale_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define <vscale x 2 x i1> @sge(<vscale x 2 x i8> %x) { define <vscale x 2 x i1> @sge(<vscale x 2 x i8> %x) {
; CHECK-LABEL: @sge( ; CHECK-LABEL: @sge(
; CHECK-NEXT: [[CMP:%.*]] = icmp sge <vscale x 2 x i8> [[X:%.*]], zeroinitializer ; CHECK-NEXT: [[CMP:%.*]] = icmp sge <vscale x 2 x i8> [[X:%.*]], zeroinitializer
; CHECK-NEXT: ret <vscale x 2 x i1> [[CMP]] ; CHECK-NEXT: ret <vscale x 2 x i1> [[CMP]]
; ;
%cmp = icmp sge <vscale x 2 x i8> %x, zeroinitializer %cmp = icmp sge <vscale x 2 x i8> %x, zeroinitializer
ret <vscale x 2 x i1> %cmp ret <vscale x 2 x i1> %cmp
Show All 25 Lines

llvm/test/Transforms/InstCombine/vscale_extractelement-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @extractelement_in_range(<vscale x 4 x i32> %a) { define i32 @extractelement_in_range(<vscale x 4 x i32> %a) {
; CHECK-LABEL: @extractelement_in_range( ; CHECK-LABEL: @extractelement_in_range(
; CHECK-NEXT: [[R:%.*]] = extractelement <vscale x 4 x i32> [[A:%.*]], i64 1 ; CHECK-NEXT: [[R:%.*]] = extractelement <vscale x 4 x i32> [[A:%.*]], i64 1
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
%r = extractelement <vscale x 4 x i32> %a, i64 1 %r = extractelement <vscale x 4 x i32> %a, i64 1
ret i32 %r ret i32 %r
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vscale_extractelement.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @extractelement_in_range(<vscale x 4 x i32> %a) { define i32 @extractelement_in_range(<vscale x 4 x i32> %a) {
; CHECK-LABEL: @extractelement_in_range( ; CHECK-LABEL: @extractelement_in_range(
; CHECK-NEXT: [[R:%.*]] = extractelement <vscale x 4 x i32> [[A:%.*]], i64 1 ; CHECK-NEXT: [[R:%.*]] = extractelement <vscale x 4 x i32> [[A:%.*]], i64 1
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
%r = extractelement <vscale x 4 x i32> %a, i64 1 %r = extractelement <vscale x 4 x i32> %a, i64 1
ret i32 %r ret i32 %r
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vscale_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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; This test is used to verify we are not crashing at Assertion `CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!". ; This test is used to verify we are not crashing at Assertion `CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!".
define <vscale x 2 x i8*> @gep_index_type_is_scalable(i8* %p) { define <vscale x 2 x i8*> @gep_index_type_is_scalable(i8* %p) {
; CHECK-LABEL: @gep_index_type_is_scalable( ; CHECK-LABEL: @gep_index_type_is_scalable(
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* [[P:%.*]], <vscale x 2 x i64> undef ; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* [[P:%.*]], <vscale x 2 x i64> undef
; CHECK-NEXT: ret <vscale x 2 x i8*> [[GEP]] ; CHECK-NEXT: ret <vscale x 2 x i8*> [[GEP]]
; ;
%gep = getelementptr i8, i8* %p, <vscale x 2 x i64> undef %gep = getelementptr i8, i8* %p, <vscale x 2 x i64> undef
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vscale_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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; This test checks that bitcast is moved after insertelement when both vector and scalar are ; This test checks that bitcast is moved after insertelement when both vector and scalar are
; bitcast from the same element type. ; bitcast from the same element type.
; inselt (bitcast VecSrc), (bitcast ScalarSrc), IdxOp ; inselt (bitcast VecSrc), (bitcast ScalarSrc), IdxOp
; --> bitcast (inselt VecSrc, ScalarSrc, IdxOp) ; --> bitcast (inselt VecSrc, ScalarSrc, IdxOp)
define <vscale x 4 x float> @insertelement_bitcast(<vscale x 4 x i32> %vec, i32 %x) { define <vscale x 4 x float> @insertelement_bitcast(<vscale x 4 x i32> %vec, i32 %x) {
; CHECK-LABEL: @insertelement_bitcast( ; CHECK-LABEL: @insertelement_bitcast(
; CHECK-NEXT: [[TMP1:%.*]] = insertelement <vscale x 4 x i32> [[VEC:%.*]], i32 [[X:%.*]], i64 0 ; CHECK-NEXT: [[TMP1:%.*]] = insertelement <vscale x 4 x i32> [[VEC:%.*]], i32 [[X:%.*]], i64 0
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vscale_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 -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; This test checks that bitcast is moved after insertelement when both vector and scalar are ; This test checks that bitcast is moved after insertelement when both vector and scalar are
; bitcast from the same element type. ; bitcast from the same element type.
; inselt (bitcast VecSrc), (bitcast ScalarSrc), IdxOp ; inselt (bitcast VecSrc), (bitcast ScalarSrc), IdxOp
; --> bitcast (inselt VecSrc, ScalarSrc, IdxOp) ; --> bitcast (inselt VecSrc, ScalarSrc, IdxOp)
define <vscale x 4 x float> @insertelement_bitcast(<vscale x 4 x i32> %vec, i32 %x) { define <vscale x 4 x float> @insertelement_bitcast(<vscale x 4 x i32> %vec, i32 %x) {
; CHECK-LABEL: @insertelement_bitcast( ; CHECK-LABEL: @insertelement_bitcast(
; CHECK-NEXT: [[TMP1:%.*]] = insertelement <vscale x 4 x i32> [[VEC:%.*]], i32 [[X:%.*]], i64 0 ; CHECK-NEXT: [[TMP1:%.*]] = insertelement <vscale x 4 x i32> [[VEC:%.*]], i32 [[X:%.*]], i64 0
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vscale_sext_and_zext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; Sign-extend ; Sign-extend
; ;
define i32 @vscale_SExt_i8toi32() vscale_range(1, 127) { define i32 @vscale_SExt_i8toi32() vscale_range(1, 127) {
; CHECK-LABEL: @vscale_SExt_i8toi32( ; CHECK-LABEL: @vscale_SExt_i8toi32(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/vscale_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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i8 @vscale_trunc_i32toi8() vscale_range(1, 255) { define i8 @vscale_trunc_i32toi8() vscale_range(1, 255) {
; CHECK-LABEL: @vscale_trunc_i32toi8( ; CHECK-LABEL: @vscale_trunc_i32toi8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = call i8 @llvm.vscale.i8() ; CHECK-NEXT: [[TMP0:%.*]] = call i8 @llvm.vscale.i8()
; CHECK-NEXT: ret i8 [[TMP0]] ; CHECK-NEXT: ret i8 [[TMP0]]
entry: entry:
%0 = call i32 @llvm.vscale.i32() %0 = call i32 @llvm.vscale.i32()
Show All 30 Lines

llvm/test/Transforms/InstCombine/wcslen-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the wcslen library call simplifier works correctly. ; Test that the wcslen library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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 i64 @wcslen(i32*) declare i64 @wcslen(i32*)
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
▲ Show 20 Lines • Show All 210 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/wcslen-2.ll

; Test that the wcslen library call simplifier works correctly. ; Test that the wcslen library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
!0 = !{i32 1, !"wchar_size", i32 4} !0 = !{i32 1, !"wchar_size", i32 4}
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
@hello = constant [6 x i32] [i32 104, i32 101, i32 108, i32 108, i32 111, i32 0] @hello = constant [6 x i32] [i32 104, i32 101, i32 108, i32 108, i32 111, i32 0]
Show All 10 Lines

llvm/test/Transforms/InstCombine/wcslen-3.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test that the wcslen library call simplifier works correctly. ; Test that the wcslen library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
; Test behavior for wchar_size==2 ; Test behavior for wchar_size==2
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!0 = !{i32 1, !"wchar_size", i32 2} !0 = !{i32 1, !"wchar_size", i32 2}
declare i64 @wcslen(i16*) declare i64 @wcslen(i16*)
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/wcslen-4.ll

; Test that the wcslen library call simplifier works correctly. ; Test that the wcslen library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
; Without the wchar_size metadata we should see no optimization happening. ; Without the wchar_size metadata we should see no optimization happening.
@hello = constant [6 x i32] [i32 104, i32 101, i32 108, i32 108, i32 111, i32 0] @hello = constant [6 x i32] [i32 104, i32 101, i32 108, i32 108, i32 111, i32 0]
declare i64 @wcslen(i32*) declare i64 @wcslen(i32*)
Show All 9 Lines

llvm/test/Transforms/InstCombine/weak-symbols.ll

; PR4738 - Test that the library call simplifier doesn't assume anything about ; PR4738 - Test that the library call simplifier doesn't assume anything about
; weak symbols. ; weak symbols.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@real_init = weak_odr constant [2 x i8] c"y\00" @real_init = weak_odr constant [2 x i8] c"y\00"
@fake_init = weak constant [2 x i8] c"y\00" @fake_init = weak constant [2 x i8] c"y\00"
@.str = private constant [2 x i8] c"y\00" @.str = private constant [2 x i8] c"y\00"
define i32 @foo() nounwind { define i32 @foo() nounwind {
; CHECK-LABEL: define i32 @foo( ; CHECK-LABEL: define i32 @foo(
; CHECK: call i32 @strcmp ; CHECK: call i32 @strcmp
Show All 21 Lines

llvm/test/Transforms/InstCombine/widenable-conditions.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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"
define i1 @test1(i1 %a, i1 %b) { define i1 @test1(i1 %a, i1 %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[WC:%.*]] = call i1 @llvm.experimental.widenable.condition() ; CHECK-NEXT: [[WC:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[LHS:%.*]] = and i1 [[WC]], [[B:%.*]] ; CHECK-NEXT: [[LHS:%.*]] = and i1 [[WC]], [[B:%.*]]
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/with_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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare { i8, i1 } @llvm.uadd.with.overflow.i8(i8, i8) nounwind readnone declare { i8, i1 } @llvm.uadd.with.overflow.i8(i8, i8) nounwind readnone
declare { i8, i1 } @llvm.sadd.with.overflow.i8(i8, i8) nounwind readnone declare { i8, i1 } @llvm.sadd.with.overflow.i8(i8, i8) nounwind readnone
declare { i8, i1 } @llvm.usub.with.overflow.i8(i8, i8) nounwind readnone declare { i8, i1 } @llvm.usub.with.overflow.i8(i8, i8) nounwind readnone
declare { i8, i1 } @llvm.ssub.with.overflow.i8(i8, i8) nounwind readnone declare { i8, i1 } @llvm.ssub.with.overflow.i8(i8, i8) nounwind readnone
declare { i8, i1 } @llvm.umul.with.overflow.i8(i8, i8) nounwind readnone declare { i8, i1 } @llvm.umul.with.overflow.i8(i8, i8) nounwind readnone
declare { i8, i1 } @llvm.smul.with.overflow.i8(i8, i8) nounwind readnone declare { i8, i1 } @llvm.smul.with.overflow.i8(i8, i8) nounwind readnone
declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone
▲ Show 20 Lines • Show All 759 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/xor-ashr.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -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" 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"
declare void @use16(i16) declare void @use16(i16)
declare void @use32(i32) declare void @use32(i32)
define i8 @testi8i8(i8 %add) { define i8 @testi8i8(i8 %add) {
; CHECK-LABEL: @testi8i8( ; CHECK-LABEL: @testi8i8(
; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i8 [[ADD:%.*]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i8 [[ADD:%.*]], -1
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/xor-icmps.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @eq_zero(i4 %x, i4 %y) { define i1 @eq_zero(i4 %x, i4 %y) {
; CHECK-LABEL: @eq_zero( ; CHECK-LABEL: @eq_zero(
; CHECK-NEXT: [[I0:%.*]] = icmp eq i4 [[X:%.*]], 0 ; CHECK-NEXT: [[I0:%.*]] = icmp eq i4 [[X:%.*]], 0
; CHECK-NEXT: [[I1:%.*]] = icmp eq i4 [[Y:%.*]], 0 ; CHECK-NEXT: [[I1:%.*]] = icmp eq i4 [[Y:%.*]], 0
; CHECK-NEXT: [[R:%.*]] = xor i1 [[I0]], [[I1]] ; CHECK-NEXT: [[R:%.*]] = xor i1 [[I0]], [[I1]]
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/xor-undef.ll

; RUN: opt < %s -instcombine -S | grep zeroinitializer ; RUN: opt < %s -passes=instcombine -S | grep zeroinitializer
define <2 x i64> @f() { define <2 x i64> @f() {
%tmp = xor <2 x i64> undef, undef %tmp = xor <2 x i64> undef, undef
ret <2 x i64> %tmp ret <2 x i64> %tmp
} }

llvm/test/Transforms/InstCombine/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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
@G1 = global i32 0 @G1 = global i32 0
@G2 = global i32 0 @G2 = global i32 0
declare void @use(i8) declare void @use(i8)
define i1 @test0(i1 %A) { define i1 @test0(i1 %A) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
▲ Show 20 Lines • Show All 1,340 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/xor2.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; PR1253 ; PR1253
define i1 @test0(i32 %A) { define i1 @test0(i32 %A) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[A:%.*]], 0 ; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[A:%.*]], 0
; CHECK-NEXT: ret i1 [[C]] ; CHECK-NEXT: ret i1 [[C]]
; ;
%B = xor i32 %A, -2147483648 %B = xor i32 %A, -2147483648
▲ Show 20 Lines • Show All 511 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/zero-point-zero-add.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare double @fabs(double) readonly declare double @fabs(double) readonly
define double @test(double %X) { define double @test(double %X) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[Y:%.*]] = fadd double %X, 0.000000e+00 ; CHECK-NEXT: [[Y:%.*]] = fadd double %X, 0.000000e+00
; CHECK-NEXT: ret double [[Y]] ; CHECK-NEXT: ret double [[Y]]
; ;
Show All 14 Lines

llvm/test/Transforms/InstCombine/zeroext-and-reduce.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @test1(i8 %X) { define i32 @test1(i8 %X) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP1:%.*]] = and i8 %X, 8 ; CHECK-NEXT: [[TMP1:%.*]] = and i8 %X, 8
; CHECK-NEXT: [[Z:%.*]] = zext i8 [[TMP1]] to i32 ; CHECK-NEXT: [[Z:%.*]] = zext i8 [[TMP1]] to i32
; CHECK-NEXT: ret i32 [[Z]] ; CHECK-NEXT: ret i32 [[Z]]
; ;
%Y = zext i8 %X to i32 %Y = zext i8 %X to i32
%Z = and i32 %Y, 65544 %Z = and i32 %Y, 65544
ret i32 %Z ret i32 %Z
} }

llvm/test/Transforms/InstCombine/zext-bool-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; rdar://11748024 ; rdar://11748024
define i32 @a(i1 zeroext %x, i1 zeroext %y) { define i32 @a(i1 zeroext %x, i1 zeroext %y) {
; CHECK-LABEL: @a( ; CHECK-LABEL: @a(
; CHECK-NEXT: [[CONV3_NEG1:%.*]] = sext i1 [[Y:%.*]] to i32 ; CHECK-NEXT: [[CONV3_NEG1:%.*]] = sext i1 [[Y:%.*]] to i32
; CHECK-NEXT: [[SUB:%.*]] = select i1 [[X:%.*]], i32 2, i32 1 ; CHECK-NEXT: [[SUB:%.*]] = select i1 [[X:%.*]], i32 2, i32 1
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[SUB]], [[CONV3_NEG1]] ; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[SUB]], [[CONV3_NEG1]]
▲ Show 20 Lines • Show All 394 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/zext-ctlz-trunc-to-ctlz-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i3 @llvm.ctlz.i3 (i3 , i1) declare i3 @llvm.ctlz.i3 (i3 , i1)
declare i32 @llvm.ctlz.i32 (i32, i1) declare i32 @llvm.ctlz.i32 (i32, i1)
declare i34 @llvm.ctlz.i34 (i34, i1) declare i34 @llvm.ctlz.i34 (i34, i1)
declare <2 x i33> @llvm.ctlz.v2i33 (<2 x i33>, i1) declare <2 x i33> @llvm.ctlz.v2i33 (<2 x i33>, i1)
declare <2 x i32> @llvm.ctlz.v2i32 (<2 x i32>, i1) declare <2 x i32> @llvm.ctlz.v2i32 (<2 x i32>, i1)
declare <vscale x 2 x i64> @llvm.ctlz.nxv2i64 (<vscale x 2 x i64>, i1) declare <vscale x 2 x i64> @llvm.ctlz.nxv2i64 (<vscale x 2 x i64>, i1)
declare <vscale x 2 x i63> @llvm.ctlz.nxv2i63 (<vscale x 2 x i63>, i1) declare <vscale x 2 x i63> @llvm.ctlz.nxv2i63 (<vscale x 2 x i63>, i1)
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/zext-fold.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; PR1570 ; PR1570
define i32 @test2(float %X, float %Y) { define i32 @test2(float %X, float %Y) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[TMP3:%.*]] = fcmp ord float %X, %Y ; CHECK-NEXT: [[TMP3:%.*]] = fcmp ord float %X, %Y
; CHECK-NEXT: [[TOBOOLNOT5:%.*]] = zext i1 [[TMP3]] to i32 ; CHECK-NEXT: [[TOBOOLNOT5:%.*]] = zext i1 [[TMP3]] to i32
; CHECK-NEXT: ret i32 [[TOBOOLNOT5]] ; CHECK-NEXT: ret i32 [[TOBOOLNOT5]]
; ;
%tmp3 = fcmp uno float %X, %Y %tmp3 = fcmp uno float %X, %Y
%tmp34 = zext i1 %tmp3 to i8 %tmp34 = zext i1 %tmp3 to i8
%tmp = xor i8 %tmp34, 1 %tmp = xor i8 %tmp34, 1
%toBoolnot5 = zext i8 %tmp to i32 %toBoolnot5 = zext i8 %tmp to i32
ret i32 %toBoolnot5 ret i32 %toBoolnot5
} }

llvm/test/Transforms/InstCombine/zext-or-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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i8 @zext_or_icmp_icmp(i8 %a, i8 %b) { define i8 @zext_or_icmp_icmp(i8 %a, i8 %b) {
; CHECK-LABEL: @zext_or_icmp_icmp( ; CHECK-LABEL: @zext_or_icmp_icmp(
; CHECK-NEXT: [[MASK:%.*]] = and i8 [[A:%.*]], 1 ; CHECK-NEXT: [[MASK:%.*]] = and i8 [[A:%.*]], 1
; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i8 [[MASK]], 0 ; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i8 [[MASK]], 0
; CHECK-NEXT: [[TOBOOL2:%.*]] = icmp eq i8 [[B:%.*]], 0 ; CHECK-NEXT: [[TOBOOL2:%.*]] = icmp eq i8 [[B:%.*]], 0
; CHECK-NEXT: [[BOTHCOND:%.*]] = or i1 [[TOBOOL1]], [[TOBOOL2]] ; CHECK-NEXT: [[BOTHCOND:%.*]] = or i1 [[TOBOOL1]], [[TOBOOL2]]
; CHECK-NEXT: [[ZEXT:%.*]] = zext i1 [[BOTHCOND]] to i8 ; CHECK-NEXT: [[ZEXT:%.*]] = zext i1 [[BOTHCOND]] to i8
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/zext-phi.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-m:e-i64:64-n8:16:32:64" target datalayout = "e-m:e-i64:64-n8:16:32:64"
; Although i1 is not in the datalayout, we should treat it ; Although i1 is not in the datalayout, we should treat it
; as a legal type because it is a fundamental type in IR. ; as a legal type because it is a fundamental type in IR.
; This means we should shrink the phi (sink the zexts). ; This means we should shrink the phi (sink the zexts).
define i64 @sink_i1_casts(i1 %cond1, i1 %cond2) { define i64 @sink_i1_casts(i1 %cond1, i1 %cond2) {
Show All 23 Lines

llvm/test/Transforms/InstCombine/zext.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 -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i64 @test_sext_zext(i16 %A) { define i64 @test_sext_zext(i16 %A) {
; CHECK-LABEL: @test_sext_zext( ; CHECK-LABEL: @test_sext_zext(
; CHECK-NEXT: [[C2:%.*]] = zext i16 [[A:%.*]] to i64 ; CHECK-NEXT: [[C2:%.*]] = zext i16 [[A:%.*]] to i64
; CHECK-NEXT: ret i64 [[C2]] ; CHECK-NEXT: ret i64 [[C2]]
; ;
%c1 = zext i16 %A to i32 %c1 = zext i16 %A to i32
%c2 = sext i32 %c1 to i64 %c2 = sext i32 %c1 to i64
▲ Show 20 Lines • Show All 441 Lines • Show Last 20 Lines