This is an archive of the discontinued LLVM Phabricator instance.

Differential D119082

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

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

Details

Reviewers
aeubanks
Summary

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

Diff Detail

Unit TestsFailed

TimeTest
60,050 msx64 debian > MLIR.Examples/standalone::test.toy
60,030 msx64 debian > ThreadSanitizer-x86_64.ThreadSanitizer-x86_64::restore_stack.cpp
60,030 msx64 debian > libFuzzer.libFuzzer::large.test

Event Timeline

bjope requested review of this revision.Feb 6 2022, 7:26 AM
bjope created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 6 2022, 7:26 AM
Harbormaster completed remote builds in B147824: Diff 406253.Feb 6 2022, 8:00 AM
aeubanks added a comment.Feb 6 2022, 1:23 PM

I don't see a reason to split the instcombine test changes into 4 changes, I'd say just submit the full change and without need for a review

bjope abandoned this revision.Feb 7 2022, 5:28 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
6 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
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
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
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
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
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 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
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
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 406253

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

; NOTE: 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 i32 @abs(i32) declare i32 @abs(i32)
declare i64 @labs(i64) declare i64 @labs(i64)
declare i64 @llabs(i64) declare i64 @llabs(i64)
; Test that the abs library call simplifier works correctly. ; Test that the abs library call simplifier works correctly.
▲ Show 20 Lines • Show All 674 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/abs-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i8 @llvm.abs.i8(i8, i1) declare i8 @llvm.abs.i8(i8, i1)
declare i32 @llvm.abs.i32(i32, i1) declare i32 @llvm.abs.i32(i32, i1)
declare <4 x i32> @llvm.abs.v4i32(<4 x i32>, i1) declare <4 x i32> @llvm.abs.v4i32(<4 x i32>, i1)
declare <3 x i82> @llvm.abs.v3i82(<3 x i82>, i1) declare <3 x i82> @llvm.abs.v3i82(<3 x i82>, i1)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
; abs preserves trailing zeros so the second and is unneeded ; abs preserves trailing zeros so the second and is unneeded
▲ Show 20 Lines • Show All 416 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/abs_abs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @abs_abs_x01(i32 %x) { define i32 @abs_abs_x01(i32 %x) {
; CHECK-LABEL: @abs_abs_x01( ; CHECK-LABEL: @abs_abs_x01(
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true) ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true)
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[TMP1]]
; ;
%cmp = icmp sgt i32 %x, -1 %cmp = icmp sgt i32 %x, -1
%sub = sub nsw i32 0, %x %sub = sub nsw i32 0, %x
▲ Show 20 Lines • Show All 1,212 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/add-shl-sdiv-to-srem.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i8 @add-shl-sdiv-scalar0(i8 %x) { define i8 @add-shl-sdiv-scalar0(i8 %x) {
; CHECK-LABEL: @add-shl-sdiv-scalar0( ; CHECK-LABEL: @add-shl-sdiv-scalar0(
; CHECK-NEXT: [[RZ:%.*]] = srem i8 [[X:%.*]], 4 ; CHECK-NEXT: [[RZ:%.*]] = srem i8 [[X:%.*]], 4
; CHECK-NEXT: ret i8 [[RZ]] ; CHECK-NEXT: ret i8 [[RZ]]
; ;
%sd = sdiv i8 %x, -4 %sd = sdiv i8 %x, -4
%sl = shl i8 %sd, 2 %sl = shl i8 %sd, 2
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/add-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 double @x(i32 %a, i32 %b) { define double @x(i32 %a, i32 %b) {
; CHECK-LABEL: @x( ; CHECK-LABEL: @x(
; CHECK-NEXT: [[M:%.*]] = lshr i32 [[A:%.*]], 24 ; CHECK-NEXT: [[M:%.*]] = lshr i32 [[A:%.*]], 24
; CHECK-NEXT: [[N:%.*]] = and i32 [[M]], [[B:%.*]] ; CHECK-NEXT: [[N:%.*]] = and i32 [[M]], [[B:%.*]]
; CHECK-NEXT: [[ADDCONV:%.*]] = add nuw nsw i32 [[N]], 1 ; CHECK-NEXT: [[ADDCONV:%.*]] = add nuw nsw i32 [[N]], 1
; CHECK-NEXT: [[P:%.*]] = sitofp i32 [[ADDCONV]] to double ; CHECK-NEXT: [[P:%.*]] = sitofp i32 [[ADDCONV]] to double
; CHECK-NEXT: ret double [[P]] ; CHECK-NEXT: ret double [[P]]
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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
define i32 @select_0_or_1_from_bool(i1 %x) { define i32 @select_0_or_1_from_bool(i1 %x) {
; CHECK-LABEL: @select_0_or_1_from_bool( ; CHECK-LABEL: @select_0_or_1_from_bool(
; CHECK-NEXT: [[NOT_X:%.*]] = xor i1 [[X:%.*]], true ; CHECK-NEXT: [[NOT_X:%.*]] = xor i1 [[X:%.*]], true
; CHECK-NEXT: [[ADD:%.*]] = zext i1 [[NOT_X]] to i32 ; CHECK-NEXT: [[ADD:%.*]] = zext i1 [[NOT_X]] to i32
; CHECK-NEXT: ret i32 [[ADD]] ; CHECK-NEXT: ret i32 [[ADD]]
; ;
%ext = sext i1 %x to i32 %ext = sext i1 %x to i32
▲ Show 20 Lines • Show All 1,384 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/add2.ll

; NOTE: 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(i64 %A, i32 %B) { define i64 @test1(i64 %A, i32 %B) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP6:%.*]] = and i64 [[A:%.*]], 123 ; CHECK-NEXT: [[TMP6:%.*]] = and i64 [[A:%.*]], 123
; CHECK-NEXT: ret i64 [[TMP6]] ; CHECK-NEXT: ret i64 [[TMP6]]
; ;
%tmp12 = zext i32 %B to i64 %tmp12 = zext i32 %B to i64
%tmp3 = shl i64 %tmp12, 32 %tmp3 = shl i64 %tmp12, 32
▲ Show 20 Lines • Show All 464 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/add3.ll

; RUN: opt < %s -instcombine -S | grep inttoptr | count 2 ; RUN: opt < %s -passes=instcombine -S | grep inttoptr | count 2
;; Target triple for gep raising case below. ;; Target triple for gep raising case below.
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 = "i686-apple-darwin8" target triple = "i686-apple-darwin8"
; PR1795 ; PR1795
define void @test2(i32 %.val24) { define void @test2(i32 %.val24) {
EntryBlock: EntryBlock:
Show All 12 Lines

llvm/test/Transforms/InstCombine/add4.ll

; NOTE: 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 @match_unsigned(i64 %x) { define i64 @match_unsigned(i64 %x) {
; CHECK-LABEL: @match_unsigned( ; CHECK-LABEL: @match_unsigned(
; CHECK-NEXT: [[UREM:%.*]] = urem i64 [[X:%.*]], 19136 ; CHECK-NEXT: [[UREM:%.*]] = urem i64 [[X:%.*]], 19136
; CHECK-NEXT: ret i64 [[UREM]] ; CHECK-NEXT: ret i64 [[UREM]]
; ;
%t = urem i64 %x, 299 %t = urem i64 %x, 299
%t1 = udiv i64 %x, 299 %t1 = udiv i64 %x, 299
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/addnegneg.ll

; RUN: opt < %s -instcombine -S | grep " sub " | count 1 ; RUN: opt < %s -passes=instcombine -S | grep " sub " | count 1
; PR2047 ; PR2047
define i32 @l(i32 %a, i32 %b, i32 %c, i32 %d) { define i32 @l(i32 %a, i32 %b, i32 %c, i32 %d) {
entry: entry:
%b.neg = sub i32 0, %b ; <i32> [#uses=1] %b.neg = sub i32 0, %b ; <i32> [#uses=1]
%c.neg = sub i32 0, %c ; <i32> [#uses=1] %c.neg = sub i32 0, %c ; <i32> [#uses=1]
%sub4 = add i32 %c.neg, %b.neg ; <i32> [#uses=1] %sub4 = add i32 %c.neg, %b.neg ; <i32> [#uses=1]
%sub6 = add i32 %sub4, %d ; <i32> [#uses=1] %sub6 = add i32 %sub4, %d ; <i32> [#uses=1]
ret i32 %sub6 ret i32 %sub6
} }

llvm/test/Transforms/InstCombine/addrspacecast.ll

; 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-p:64:64:64-p1:32:32:32-p2:16:16:16-n8:16:32:64" target datalayout = "e-p:64:64:64-p1:32:32:32-p2:16:16:16-n8:16:32:64"
declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) nounwind
declare void @llvm.memcpy.p0i8.p1i8.i32(i8*, i8 addrspace(1)*, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p1i8.i32(i8*, i8 addrspace(1)*, i32, i1) nounwind
declare void @llvm.memcpy.p0i8.p2i8.i32(i8*, i8 addrspace(2)*, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p2i8.i32(i8*, i8 addrspace(2)*, i32, i1) nounwind
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/addsub-constant-folding.ll

; NOTE: 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 %arg) declare void @use(i32 %arg)
declare void @vec_use(<4 x i32> %arg) declare void @vec_use(<4 x i32> %arg)
; (x+c1)+c2 ; (x+c1)+c2
define i32 @add_const_add_const(i32 %arg) { define i32 @add_const_add_const(i32 %arg) {
; CHECK-LABEL: @add_const_add_const( ; CHECK-LABEL: @add_const_add_const(
▲ Show 20 Lines • Show All 579 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/adjust-for-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
; Instcombine should recognize that this code can be adjusted to fit the canonical max/min pattern. ; Instcombine should recognize that this code can be adjusted to fit the canonical max/min pattern.
; No change ; No change
define i32 @smax1(i32 %n) { define i32 @smax1(i32 %n) {
; CHECK-LABEL: @smax1( ; CHECK-LABEL: @smax1(
; CHECK-NEXT: [[T:%.*]] = icmp sgt i32 [[N:%.*]], 0 ; CHECK-NEXT: [[T:%.*]] = icmp sgt i32 [[N:%.*]], 0
▲ Show 20 Lines • Show All 476 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/aggregate-reconstruction.ll

; NOTE: 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()
declare void @bar() declare void @bar()
declare void @baz() declare void @baz()
declare void @usei32(i32) declare void @usei32(i32)
declare void @usei32i32agg({ i32, i32 }) declare void @usei32i32agg({ i32, i32 })
▲ Show 20 Lines • Show All 293 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/alias-recursion.ll

; 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-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
%class.A = type { i32 (...)** } %class.A = type { i32 (...)** }
@0 = constant [1 x i8*] zeroinitializer @0 = constant [1 x i8*] zeroinitializer
Show All 15 Lines

llvm/test/Transforms/InstCombine/align-2d-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-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; A multi-dimensional array in a nested loop doing vector stores that ; A multi-dimensional array in a nested loop doing vector stores that
; aren't yet aligned. Instcombine can understand the addressing in the ; aren't yet aligned. Instcombine can understand the addressing in the
; Nice case to prove 16 byte alignment. In the Awkward case, the inner ; Nice case to prove 16 byte alignment. In the Awkward case, the inner
; array dimension is not even, so the stores to it won't always be ; array dimension is not even, so the stores to it won't always be
; aligned. Instcombine should prove alignment in exactly one of the two ; aligned. Instcombine should prove alignment in exactly one of the two
; stores. ; stores.
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/align-addr.ll

; NOTE: 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:32:32:32-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-p1:32:32:32-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; Instcombine should be able to prove vector alignment in the ; Instcombine should be able to prove vector alignment in the
; presence of a few mild address computation tricks. ; presence of a few mild address computation tricks.
define void @test0(i8* %b, i64 %n, i64 %u, i64 %y) nounwind { define void @test0(i8* %b, i64 %n, i64 %u, i64 %y) nounwind {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/align-attr.ll

; NOTE: 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"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @foo1(i32* align 32 %a) #0 { define i32 @foo1(i32* align 32 %a) #0 {
; CHECK-LABEL: @foo1( ; CHECK-LABEL: @foo1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A:%.*]], align 32 ; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A:%.*]], align 32
Show All 24 Lines

llvm/test/Transforms/InstCombine/align-external.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Don't assume that external global variables or those with weak linkage have ; Don't assume that external global variables or those with weak linkage have
; their preferred alignment. They may only have the ABI minimum alignment. ; their preferred alignment. They may only have the ABI minimum alignment.
target datalayout = "i32:8:32" target datalayout = "i32:8:32"
@A = external global i32 @A = external global i32
@B = weak_odr global i32 0 @B = weak_odr global i32 0
Show All 32 Lines

llvm/test/Transforms/InstCombine/all-bits-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
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
@d = global i32 15, align 4 @d = global i32 15, align 4
@b = global i32* @d, align 8 @b = global i32* @d, align 8
@a = common global i32 0, align 4 @a = common global i32 0, align 4
; Check that both InstCombine and InstSimplify can use computeKnownBits to ; Check that both InstCombine and InstSimplify can use computeKnownBits to
Show All 36 Lines

llvm/test/Transforms/InstCombine/alloc-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 @test() local_unnamed_addr #0 { define dso_local void @test() local_unnamed_addr #0 {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%1 = tail call noalias align 16 dereferenceable_or_null(4) i8* @malloc(i64 4) #4 %1 = tail call noalias align 16 dereferenceable_or_null(4) i8* @malloc(i64 4) #4
%2 = tail call align 16 dereferenceable_or_null(6) i8* @realloc(i8* %1, i64 6) #4 %2 = tail call align 16 dereferenceable_or_null(6) i8* @realloc(i8* %1, i64 6) #4
tail call void @free(i8* %2) #4 tail call void @free(i8* %2) #4
Show All 14 Lines

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

; NOTE: 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
; OSS-Fuzz: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=5223 ; OSS-Fuzz: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=5223
define void @test_bigalloc() { define void @test_bigalloc() {
; CHECK-LABEL: @test_bigalloc( ; CHECK-LABEL: @test_bigalloc(
; CHECK-NEXT: [[TMP1:%.*]] = alloca [18446744069414584320 x i8], align 1 ; CHECK-NEXT: [[TMP1:%.*]] = alloca [18446744069414584320 x i8], align 1
; CHECK-NEXT: [[DOTSUB:%.*]] = getelementptr inbounds [18446744069414584320 x i8], [18446744069414584320 x i8]* [[TMP1]], i64 0, i64 0 ; CHECK-NEXT: [[DOTSUB:%.*]] = getelementptr inbounds [18446744069414584320 x i8], [18446744069414584320 x i8]* [[TMP1]], i64 0, i64 0
; CHECK-NEXT: store i8* [[DOTSUB]], i8** undef, align 8 ; CHECK-NEXT: store i8* [[DOTSUB]], i8** undef, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%1 = alloca i8, i864 -4294967296 %1 = alloca i8, i864 -4294967296
%2 = getelementptr i8, i8* %1, i1 undef %2 = getelementptr i8, i8* %1, i1 undef
store i8* %2, i8** undef store i8* %2, i8** undef
ret void ret void
} }

llvm/test/Transforms/InstCombine/alloca-in-non-alloca-as.ll

; NOTE: 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
; Gracefully handle the alloca that is not in the alloca AS (=5) ; Gracefully handle the alloca that is not in the alloca AS (=5)
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7"
target triple = "amdgcn-amd-amdhsa" target triple = "amdgcn-amd-amdhsa"
declare void @use(i8*, i32**) declare void @use(i8*, i32**)
Show All 34 Lines

llvm/test/Transforms/InstCombine/alloca.ll

; NOTE: 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-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" | FileCheck %s -check-prefixes=ALL,CHECK ; RUN: opt < %s -passes=instcombine -S -data-layout="E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" | FileCheck %s -check-prefixes=ALL,CHECK
; RUN: opt < %s -instcombine -S -data-layout="E-p:32:32:32-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" | FileCheck %s -check-prefixes=ALL,P32 ; RUN: opt < %s -passes=instcombine -S -data-layout="E-p:32:32:32-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" | FileCheck %s -check-prefixes=ALL,P32
; RUN: opt < %s -instcombine -S | FileCheck %s -check-prefixes=ALL,NODL ; RUN: opt < %s -passes=instcombine -S | FileCheck %s -check-prefixes=ALL,NODL
declare void @use(...) declare void @use(...)
@int = global i32 zeroinitializer @int = global i32 zeroinitializer
; Zero byte allocas should be merged if they can't be deleted. ; Zero byte allocas should be merged if they can't be deleted.
define void @test() { define void @test() {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/allocsize-32.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; The idea is that we want to have sane semantics (e.g. not assertion failures) ; The idea is that we want to have sane semantics (e.g. not assertion failures)
; when given an allocsize function that takes a 64-bit argument in the face of ; when given an allocsize function that takes a 64-bit argument in the face of
; 32-bit pointers. ; 32-bit pointers.
target datalayout="e-p:32:32:32" target datalayout="e-p:32:32:32"
declare i8* @my_malloc(i8*, i64) allocsize(1) declare i8* @my_malloc(i8*, i64) allocsize(1)
Show All 20 Lines

llvm/test/Transforms/InstCombine/allocsize.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; Test that instcombine folds allocsize function calls properly. ; Test that instcombine folds allocsize function calls properly.
; Dummy arguments are inserted to verify that allocsize is picking the right ; Dummy arguments are inserted to verify that allocsize is picking the right
; args, and to prove that arbitrary unfoldable values don't interfere with ; args, and to prove that arbitrary unfoldable values don't interfere with
; allocsize if they're not used by allocsize. ; allocsize if they're not used by allocsize.
declare i8* @my_malloc(i8*, i32) allocsize(1) declare i8* @my_malloc(i8*, i32) allocsize(1)
declare i8* @my_calloc(i8*, i8*, i32, i32) allocsize(2, 3) declare i8* @my_calloc(i8*, i8*, i32, i32) allocsize(2, 3)
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and-compare.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -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"
; Should be optimized to one and. ; Should be optimized to one and.
define i1 @test1(i32 %a, i32 %b) { define i1 @test1(i32 %a, i32 %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[A:%.*]], [[B:%.*]]
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and-fcmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i1 @PR1738(double %x, double %y) { define i1 @PR1738(double %x, double %y) {
; CHECK-LABEL: @PR1738( ; CHECK-LABEL: @PR1738(
; CHECK-NEXT: [[TMP1:%.*]] = fcmp ord double [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = fcmp ord double [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[TMP1]] ; CHECK-NEXT: ret i1 [[TMP1]]
; ;
%cmp1 = fcmp ord double %x, 0.0 %cmp1 = fcmp ord double %x, 0.0
%cmp2 = fcmp ord double %y, 0.0 %cmp2 = fcmp ord double %y, 0.0
▲ Show 20 Lines • Show All 3,112 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and-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 -data-layout="n8:16:32" -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -data-layout="n8:16:32" -S | FileCheck %s
; RUN: opt < %s -instcombine -data-layout="n16" -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -data-layout="n16" -S | FileCheck %s
; PR35792 - https://bugs.llvm.org/show_bug.cgi?id=35792 ; PR35792 - https://bugs.llvm.org/show_bug.cgi?id=35792
define i16 @zext_add(i8 %x) { define i16 @zext_add(i8 %x) {
; CHECK-LABEL: @zext_add( ; CHECK-LABEL: @zext_add(
; CHECK-NEXT: [[TMP1:%.*]] = add i8 [[X:%.*]], 44 ; CHECK-NEXT: [[TMP1:%.*]] = add i8 [[X:%.*]], 44
; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X]] ; CHECK-NEXT: [[TMP2:%.*]] = and i8 [[TMP1]], [[X]]
; CHECK-NEXT: [[R:%.*]] = zext i8 [[TMP2]] to i16 ; CHECK-NEXT: [[R:%.*]] = zext i8 [[TMP2]] to i16
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and-or-and.ll

; If we have an 'and' of the result of an 'or', and one of the 'or' operands ; If we have an 'and' of the result of an 'or', and one of the 'or' operands
; cannot have contributed any of the resultant bits, delete the or. This ; cannot have contributed any of the resultant bits, delete the or. This
; occurs for very common C/C++ code like this: ; occurs for very common C/C++ code like this:
; ;
; struct foo { int A : 16; int B : 16; }; ; struct foo { int A : 16; int B : 16; };
; void test(struct foo *F, int X, int Y) { ; void test(struct foo *F, int X, int Y) {
; F->A = X; F->B = Y; ; F->A = X; F->B = Y;
; } ; }
; ;
; Which corresponds to test1. ; Which corresponds to test1.
; RUN: opt < %s -instcombine -S | \ ; RUN: opt < %s -passes=instcombine -S | \
; RUN: not grep "or " ; RUN: not grep "or "
define i32 @test1(i32 %X, i32 %Y) { define i32 @test1(i32 %X, i32 %Y) {
%A = and i32 %X, 7 ; <i32> [#uses=1] %A = and i32 %X, 7 ; <i32> [#uses=1]
%B = and i32 %Y, 8 ; <i32> [#uses=1] %B = and i32 %Y, 8 ; <i32> [#uses=1]
%C = or i32 %A, %B ; <i32> [#uses=1] %C = or i32 %A, %B ; <i32> [#uses=1]
;; This cannot include any bits from %Y! ;; This cannot include any bits from %Y!
%D = and i32 %C, 7 ; <i32> [#uses=1] %D = and i32 %C, 7 ; <i32> [#uses=1]
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

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

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

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

llvm/test/Transforms/InstCombine/and-or-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
declare void @use(i1) declare void @use(i1)
define i1 @PR1817_1(i32 %X) { define i1 @PR1817_1(i32 %X) {
; CHECK-LABEL: @PR1817_1( ; CHECK-LABEL: @PR1817_1(
; CHECK-NEXT: [[B:%.*]] = icmp ult i32 [[X:%.*]], 10 ; CHECK-NEXT: [[B:%.*]] = icmp ult i32 [[X:%.*]], 10
; CHECK-NEXT: ret i1 [[B]] ; CHECK-NEXT: ret i1 [[B]]
; ;
▲ Show 20 Lines • Show All 1,172 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and-or-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
; PR1510 ; PR1510
; (a | b) & ~(a & b) --> a ^ b ; (a | b) & ~(a & b) --> a ^ b
define i32 @and_to_xor1(i32 %a, i32 %b) { define i32 @and_to_xor1(i32 %a, i32 %b) {
; CHECK-LABEL: @and_to_xor1( ; CHECK-LABEL: @and_to_xor1(
; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[AND2:%.*]] = xor i32 [[A:%.*]], [[B:%.*]]
▲ Show 20 Lines • Show All 632 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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(i8) declare void @use(i8)
declare void @use_vec(<2 x i8>) declare void @use_vec(<2 x i8>)
; ((b | a) & C1) | (b & C2) -> (a & C1) | b iff C1 == ~C2 ; ((b | a) & C1) | (b & C2) -> (a & C1) | b iff C1 == ~C2
define i32 @or_and_not_constant_commute0(i32 %a, i32 %b) { define i32 @or_and_not_constant_commute0(i32 %a, i32 %b) {
; CHECK-LABEL: @or_and_not_constant_commute0( ; CHECK-LABEL: @or_and_not_constant_commute0(
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and-xor-merge.ll

; NOTE: 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&z) ^ (y&z) -> (x^y)&z ; (x&z) ^ (y&z) -> (x^y)&z
define i32 @test1(i32 %x, i32 %y, i32 %z) { define i32 @test1(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[T61:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[T61:%.*]] = xor i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[T7:%.*]] = and i32 [[T61]], [[Z:%.*]] ; CHECK-NEXT: [[T7:%.*]] = and i32 [[T61]], [[Z:%.*]]
; CHECK-NEXT: ret i32 [[T7]] ; CHECK-NEXT: ret i32 [[T7]]
; ;
Show All 32 Lines

llvm/test/Transforms/InstCombine/and-xor-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(i32) declare void @use(i32)
; a & (a ^ b) --> a & ~b ; a & (a ^ b) --> a & ~b
define i32 @and_xor_common_op(i32 %pa, i32 %pb) { define i32 @and_xor_common_op(i32 %pa, i32 %pb) {
; CHECK-LABEL: @and_xor_common_op( ; CHECK-LABEL: @and_xor_common_op(
; CHECK-NEXT: [[A:%.*]] = udiv i32 42, [[PA:%.*]] ; CHECK-NEXT: [[A:%.*]] = udiv i32 42, [[PA:%.*]]
▲ Show 20 Lines • Show All 3,775 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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
declare void @use8(i8) declare void @use8(i8)
declare void @use32(i32) declare void @use32(i32)
; There should be no 'and' instructions left in any test. ; There should be no 'and' instructions left in any test.
define i32 @test1(i32 %A) { define i32 @test1(i32 %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 516 Lines • ▼ Show 20 Lines
; CHECK-LABEL: @test34( ; CHECK-LABEL: @test34(
; CHECK-NEXT: ret i32 [[B:%.*]] ; CHECK-NEXT: ret i32 [[B:%.*]]
; ;
%t2 = or i32 %B, %A %t2 = or i32 %B, %A
%t4 = and i32 %t2, %B %t4 = and i32 %t2, %B
ret i32 %t4 ret i32 %t4
} }
; FIXME: This test should only need -instsimplify (ValueTracking / computeKnownBits), not -instcombine. ; FIXME: This test should only need -instsimplify (ValueTracking / computeKnownBits), not -passes=instcombine.
define <2 x i32> @PR24942(<2 x i32> %x) { define <2 x i32> @PR24942(<2 x i32> %x) {
; CHECK-LABEL: @PR24942( ; CHECK-LABEL: @PR24942(
; CHECK-NEXT: ret <2 x i32> zeroinitializer ; CHECK-NEXT: ret <2 x i32> zeroinitializer
; ;
%lshr = lshr <2 x i32> %x, <i32 31, i32 31> %lshr = lshr <2 x i32> %x, <i32 31, i32 31>
%and = and <2 x i32> %lshr, <i32 2, i32 2> %and = and <2 x i32> %lshr, <i32 2, i32 2>
ret <2 x i32> %and ret <2 x i32> %and
▲ Show 20 Lines • Show All 1,009 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/and2.ll

; NOTE: 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 @test2(i1 %X, i1 %Y) { define i1 @test2(i1 %X, i1 %Y) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[A:%.*]] = and i1 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[A:%.*]] = and i1 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[A]] ; CHECK-NEXT: ret i1 [[A]]
; ;
%a = and i1 %X, %Y %a = and i1 %X, %Y
%b = and i1 %a, %X %b = and i1 %a, %X
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/annotation-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s
; This tests that llvm.annotation does not prevent load combining. ; This tests that llvm.annotation does not prevent load combining.
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-grtev4-linux-gnu" target triple = "x86_64-grtev4-linux-gnu"
declare i32 @llvm.annotation.i32(i32, i8*, i8*, i32) #1 declare i32 @llvm.annotation.i32(i32, i8*, i8*, i32) #1
Show All 17 Lines

llvm/test/Transforms/InstCombine/annotations.ll

; RUN: opt < %s -instcombine -S | FileCheck --match-full-lines %s ; RUN: opt < %s -passes=instcombine -S | FileCheck --match-full-lines %s
; Test cases to make sure !annotation metadata is preserved, if possible. ; Test cases to make sure !annotation metadata is preserved, if possible.
; Currently we fail to preserve !annotation metadata in many cases. ; Currently we fail to preserve !annotation metadata in many cases.
; Make sure !annotation metadata is added to new instructions, if the source ; Make sure !annotation metadata is added to new instructions, if the source
; instruction has !annotation metadata. ; instruction has !annotation metadata.
define i1 @fold_to_new_instruction(i8* %a, i8* %b) { define i1 @fold_to_new_instruction(i8* %a, i8* %b) {
; CHECK-LABEL: define {{.+}} @fold_to_new_instruction({{.+}} ; CHECK-LABEL: define {{.+}} @fold_to_new_instruction({{.+}}
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-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
; Tests for Integer BitWidth <= 64 && BitWidth % 8 != 0. ; Tests for Integer BitWidth <= 64 && BitWidth % 8 != 0.
;; Flip sign bit then add INT_MIN -> nop. ;; Flip sign bit then add INT_MIN -> nop.
define i1 @test1(i1 %x) { define i1 @test1(i1 %x) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 %x ; CHECK-NEXT: ret i1 %x
; ;
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-and-compare.ll

; RUN: opt < %s -instcombine -S | grep and | count 2 ; RUN: opt < %s -passes=instcombine -S | grep and | count 2
; Should be optimized to one and. ; Should be optimized to one and.
define i1 @test1(i33 %a, i33 %b) { define i1 @test1(i33 %a, i33 %b) {
%tmp1 = and i33 %a, 65280 %tmp1 = and i33 %a, 65280
%tmp3 = and i33 %b, 65280 %tmp3 = and i33 %b, 65280
%tmp = icmp ne i33 %tmp1, %tmp3 %tmp = icmp ne i33 %tmp1, %tmp3
ret i1 %tmp ret i1 %tmp
} }
define i1 @test2(i999 %a, i999 %b) { define i1 @test2(i999 %a, i999 %b) {
%tmp1 = and i999 %a, 65280 %tmp1 = and i999 %a, 65280
%tmp3 = and i999 %b, 65280 %tmp3 = and i999 %b, 65280
%tmp = icmp ne i999 %tmp1, %tmp3 %tmp = icmp ne i999 %tmp1, %tmp3
ret i1 %tmp ret i1 %tmp
} }

llvm/test/Transforms/InstCombine/apint-and-or-and.ll

; If we have an 'and' of the result of an 'or', and one of the 'or' operands ; If we have an 'and' of the result of an 'or', and one of the 'or' operands
; cannot have contributed any of the resultant bits, delete the or. This ; cannot have contributed any of the resultant bits, delete the or. This
; occurs for very common C/C++ code like this: ; occurs for very common C/C++ code like this:
; ;
; struct foo { int A : 16; int B : 16; }; ; struct foo { int A : 16; int B : 16; };
; void test(struct foo *F, int X, int Y) { ; void test(struct foo *F, int X, int Y) {
; F->A = X; F->B = Y; ; F->A = X; F->B = Y;
; } ; }
; ;
; Which corresponds to test1. ; Which corresponds to test1.
; ;
; This tests arbitrary precision integers. ; This tests arbitrary precision integers.
; RUN: opt < %s -instcombine -S | not grep "or " ; RUN: opt < %s -passes=instcombine -S | not grep "or "
; END. ; END.
define i17 @test1(i17 %X, i17 %Y) { define i17 @test1(i17 %X, i17 %Y) {
%A = and i17 %X, 7 %A = and i17 %X, 7
%B = and i17 %Y, 8 %B = and i17 %Y, 8
%C = or i17 %A, %B %C = or i17 %A, %B
%D = and i17 %C, 7 ;; This cannot include any bits from %Y! %D = and i17 %C, 7 ;; This cannot include any bits from %Y!
ret i17 %D ret i17 %D
Show All 28 Lines

llvm/test/Transforms/InstCombine/apint-and-xor-merge.ll

; NOTE: Assertions have been autogenerated by update_test_checks.py ; NOTE: Assertions have been autogenerated by update_test_checks.py
; This test case checks that the merge of and/xor can work on arbitrary ; This test case checks that the merge of and/xor can work on arbitrary
; precision integers. ; precision integers.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; (x &z ) ^ (y & z) -> (x ^ y) & z ; (x &z ) ^ (y & z) -> (x ^ y) & z
define i57 @test1(i57 %x, i57 %y, i57 %z) { define i57 @test1(i57 %x, i57 %y, i57 %z) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP61:%.*]] = xor i57 %x, %y ; CHECK-NEXT: [[TMP61:%.*]] = xor i57 %x, %y
; CHECK-NEXT: [[TMP7:%.*]] = and i57 [[TMP61]], %z ; CHECK-NEXT: [[TMP7:%.*]] = and i57 [[TMP61]], %z
; CHECK-NEXT: ret i57 [[TMP7]] ; CHECK-NEXT: ret i57 [[TMP7]]
; ;
Show All 18 Lines

llvm/test/Transforms/InstCombine/apint-and.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; FIXME: Some of these tests belong in InstSimplify. ; FIXME: Some of these tests belong in InstSimplify.
; Integer BitWidth <= 64 && BitWidth % 8 != 0. ; Integer BitWidth <= 64 && BitWidth % 8 != 0.
define i39 @test0(i39 %A) { define i39 @test0(i39 %A) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: ret i39 0 ; CHECK-NEXT: ret i39 0
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-call-cast-target.ll

; NOTE: 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" target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu" target triple = "i686-pc-linux-gnu"
declare i32 @main2() declare i32 @main2()
declare i7* @ctime2(i999*) declare i7* @ctime2(i999*)
define i7* @ctime(i999*) { define i7* @ctime(i999*) {
Show All 22 Lines

llvm/test/Transforms/InstCombine/apint-cast-and-cast.ll

; RUN: opt < %s -instcombine -S | not grep bitcast ; RUN: opt < %s -passes=instcombine -S | not grep bitcast
define i19 @test1(i43 %val) { define i19 @test1(i43 %val) {
%t1 = bitcast i43 %val to i43 %t1 = bitcast i43 %val to i43
%t2 = and i43 %t1, 1 %t2 = and i43 %t1, 1
%t3 = trunc i43 %t2 to i19 %t3 = trunc i43 %t2 to i19
ret i19 %t3 ret i19 %t3
} }
define i73 @test2(i677 %val) { define i73 @test2(i677 %val) {
%t1 = bitcast i677 %val to i677 %t1 = bitcast i677 %val to i677
%t2 = and i677 %t1, 1 %t2 = and i677 %t1, 1
%t3 = trunc i677 %t2 to i73 %t3 = trunc i677 %t2 to i73
ret i73 %t3 ret i73 %t3
} }

llvm/test/Transforms/InstCombine/apint-cast-cast-to-and.ll

; RUN: opt < %s -instcombine -S | not grep i41 ; RUN: opt < %s -passes=instcombine -S | not grep i41
define i61 @test1(i61 %X) { define i61 @test1(i61 %X) {
%Y = trunc i61 %X to i41 ;; Turn i61o an AND %Y = trunc i61 %X to i41 ;; Turn i61o an AND
%Z = zext i41 %Y to i61 %Z = zext i41 %Y to i61
ret i61 %Z ret i61 %Z
} }

llvm/test/Transforms/InstCombine/apint-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 | 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"
; Tests to make sure elimination of casts is working correctly ; Tests to make sure elimination of casts is working correctly
define i17 @test1(i17 %a) { define i17 @test1(i17 %a) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[C:%.*]] = lshr i17 [[A:%.*]], 8 ; CHECK-NEXT: [[C:%.*]] = lshr i17 [[A:%.*]], 8
Show All 26 Lines

llvm/test/Transforms/InstCombine/apint-div1.ll

; This test makes sure that div instructions are properly eliminated. ; This test makes sure that div instructions are properly eliminated.
; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0. ; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0.
; ;
; RUN: opt < %s -instcombine -S | not grep div ; RUN: opt < %s -passes=instcombine -S | not grep div
define i33 @test1(i33 %X) { define i33 @test1(i33 %X) {
%Y = udiv i33 %X, 4096 %Y = udiv i33 %X, 4096
ret i33 %Y ret i33 %Y
} }
define i49 @test2(i49 %X) { define i49 @test2(i49 %X) {
Show All 10 Lines

llvm/test/Transforms/InstCombine/apint-div2.ll

; This test makes sure that div instructions are properly eliminated. ; This test makes sure that div instructions are properly eliminated.
; This test is for Integer BitWidth >= 64 && BitWidth <= 1024. ; This test is for Integer BitWidth >= 64 && BitWidth <= 1024.
; ;
; RUN: opt < %s -instcombine -S | not grep div ; RUN: opt < %s -passes=instcombine -S | not grep div
define i333 @test1(i333 %X) { define i333 @test1(i333 %X) {
%Y = udiv i333 %X, 70368744177664 %Y = udiv i333 %X, 70368744177664
ret i333 %Y ret i333 %Y
} }
define i499 @test2(i499 %X) { define i499 @test2(i499 %X) {
Show All 10 Lines

llvm/test/Transforms/InstCombine/apint-mul1.ll

; NOTE: 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 makes sure that mul instructions are properly eliminated. ; This test makes sure that mul instructions are properly eliminated.
; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0. ; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0.
define i17 @test1(i17 %X) { define i17 @test1(i17 %X) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[Y:%.*]] = shl i17 [[X:%.*]], 10 ; CHECK-NEXT: [[Y:%.*]] = shl i17 [[X:%.*]], 10
; CHECK-NEXT: ret i17 [[Y]] ; CHECK-NEXT: ret i17 [[Y]]
Show All 22 Lines

llvm/test/Transforms/InstCombine/apint-mul2.ll

; NOTE: 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 makes sure that mul instructions are properly eliminated. ; This test makes sure that mul instructions are properly eliminated.
; This test is for Integer BitWidth >= 64 && BitWidth % 2 >= 1024. ; This test is for Integer BitWidth >= 64 && BitWidth % 2 >= 1024.
define i177 @test1(i177 %X) { define i177 @test1(i177 %X) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[Y:%.*]] = shl i177 [[X:%.*]], 155 ; CHECK-NEXT: [[Y:%.*]] = shl i177 [[X:%.*]], 155
; CHECK-NEXT: ret i177 [[Y]] ; CHECK-NEXT: ret i177 [[Y]]
Show All 25 Lines

llvm/test/Transforms/InstCombine/apint-not.ll

; This test makes sure that the xor instructions are properly eliminated ; This test makes sure that the xor instructions are properly eliminated
; when arbitrary precision integers are used. ; when arbitrary precision integers are used.
; RUN: opt < %s -instcombine -S | not grep xor ; RUN: opt < %s -passes=instcombine -S | not grep xor
define i33 @test1(i33 %A) { define i33 @test1(i33 %A) {
%B = xor i33 %A, -1 %B = xor i33 %A, -1
%C = xor i33 %B, -1 %C = xor i33 %B, -1
ret i33 %C ret i33 %C
} }
define i1 @test2(i52 %A, i52 %B) { define i1 @test2(i52 %A, i52 %B) {
%cond = icmp ule i52 %A, %B ; Can change into uge %cond = icmp ule i52 %A, %B ; Can change into uge
%Ret = xor i1 %cond, true %Ret = xor i1 %cond, true
ret i1 %Ret ret i1 %Ret
} }

llvm/test/Transforms/InstCombine/apint-or.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; These tests are for Integer BitWidth <= 64 && BitWidth % 2 != 0. ; These tests are for Integer BitWidth <= 64 && BitWidth % 2 != 0.
define i23 @test1(i23 %A) { define i23 @test1(i23 %A) {
;; A | ~A == -1 ;; A | ~A == -1
%NotA = xor i23 -1, %A %NotA = xor i23 -1, %A
%B = or i23 %A, %NotA %B = or i23 %A, %NotA
ret i23 %B ret i23 %B
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-rem1.ll

; This test makes sure that these instructions are properly eliminated. ; This test makes sure that these instructions are properly eliminated.
; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0. ; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0.
; ;
; RUN: opt < %s -instcombine -S | not grep rem ; RUN: opt < %s -passes=instcombine -S | not grep rem
define i33 @test1(i33 %A) { define i33 @test1(i33 %A) {
%B = urem i33 %A, 4096 %B = urem i33 %A, 4096
ret i33 %B ret i33 %B
} }
define i49 @test2(i49 %A) { define i49 @test2(i49 %A) {
Show All 10 Lines

llvm/test/Transforms/InstCombine/apint-rem2.ll

; This test makes sure that these instructions are properly eliminated. ; This test makes sure that these instructions are properly eliminated.
; This test is for Integer BitWidth >= 64 && BitWidth <= 1024. ; This test is for Integer BitWidth >= 64 && BitWidth <= 1024.
; ;
; RUN: opt < %s -instcombine -S | not grep rem ; RUN: opt < %s -passes=instcombine -S | not grep rem
define i333 @test1(i333 %A) { define i333 @test1(i333 %A) {
%B = urem i333 %A, 70368744177664 %B = urem i333 %A, 70368744177664
ret i333 %B ret i333 %B
} }
define i499 @test2(i499 %A) { define i499 @test2(i499 %A) {
Show All 10 Lines

llvm/test/Transforms/InstCombine/apint-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
; No selects should remain. ; No selects should remain.
define i41 @zext(i1 %C) { define i41 @zext(i1 %C) {
; CHECK-LABEL: @zext( ; CHECK-LABEL: @zext(
; CHECK-NEXT: [[V:%.*]] = zext i1 %C to i41 ; CHECK-NEXT: [[V:%.*]] = zext i1 %C to i41
; CHECK-NEXT: ret i41 [[V]] ; CHECK-NEXT: ret i41 [[V]]
; ;
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-shift-simplify.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i41 @test0(i41 %A, i41 %B, i41 %C) { define i41 @test0(i41 %A, i41 %B, i41 %C) {
%X = shl i41 %A, %C %X = shl i41 %A, %C
%Y = shl i41 %B, %C %Y = shl i41 %B, %C
%Z = and i41 %X, %Y %Z = and i41 %X, %Y
ret i41 %Z ret i41 %Z
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: and i41 %A, %B ; CHECK-NEXT: and i41 %A, %B
Show All 25 Lines

llvm/test/Transforms/InstCombine/apint-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 i55 @test6(i55 %A) { define i55 @test6(i55 %A) {
; CHECK-LABEL: @test6( ; CHECK-LABEL: @test6(
; CHECK-NEXT: [[C:%.*]] = mul i55 [[A:%.*]], 6 ; CHECK-NEXT: [[C:%.*]] = mul i55 [[A:%.*]], 6
; CHECK-NEXT: ret i55 [[C]] ; CHECK-NEXT: ret i55 [[C]]
; ;
%B = shl i55 %A, 1 %B = shl i55 %A, 1
%C = mul i55 %B, 3 %C = mul i55 %B, 3
▲ Show 20 Lines • Show All 562 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-shl-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 i1 @test0(i39 %X, i39 %A) { define i1 @test0(i39 %X, i39 %A) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NEXT: [[TMP1:%.*]] = shl i39 1, [[A:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = shl i39 1, [[A:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = and i39 [[TMP1]], [[X:%.*]] ; CHECK-NEXT: [[TMP2:%.*]] = and i39 [[TMP1]], [[X:%.*]]
; CHECK-NEXT: [[D:%.*]] = icmp ne i39 [[TMP2]], 0 ; CHECK-NEXT: [[D:%.*]] = icmp ne i39 [[TMP2]], 0
; CHECK-NEXT: ret i1 [[D]] ; CHECK-NEXT: ret i1 [[D]]
; ;
Show All 28 Lines

llvm/test/Transforms/InstCombine/apint-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
define i23 @test1(i23 %A) { define i23 @test1(i23 %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i23 0 ; CHECK-NEXT: ret i23 0
; ;
%B = sub i23 %A, %A %B = sub i23 %A, %A
ret i23 %B ret i23 %B
} }
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/apint-xor1.ll

; This test makes sure that xor instructions are properly eliminated. ; This test makes sure that xor instructions are properly eliminated.
; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0. ; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0.
; RUN: opt < %s -instcombine -S | not grep "xor " ; RUN: opt < %s -passes=instcombine -S | not grep "xor "
define i47 @test1(i47 %A, i47 %B) { define i47 @test1(i47 %A, i47 %B) {
;; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0 ;; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
%A1 = and i47 %A, 70368744177664 %A1 = and i47 %A, 70368744177664
%B1 = and i47 %B, 70368744177661 %B1 = and i47 %B, 70368744177661
%C1 = xor i47 %A1, %B1 %C1 = xor i47 %A1, %B1
ret i47 %C1 ret i47 %C1
Show All 38 Lines

llvm/test/Transforms/InstCombine/apint-xor2.ll

; This test makes sure that xor instructions are properly eliminated. ; This test makes sure that xor instructions are properly eliminated.
; This test is for Integer BitWidth > 64 && BitWidth <= 1024. ; This test is for Integer BitWidth > 64 && BitWidth <= 1024.
; RUN: opt < %s -instcombine -S | not grep "xor " ; RUN: opt < %s -passes=instcombine -S | not grep "xor "
; END. ; END.
define i447 @test1(i447 %A, i447 %B) { define i447 @test1(i447 %A, i447 %B) {
;; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0 ;; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
%A1 = and i447 %A, 70368744177664 %A1 = and i447 %A, 70368744177664
%B1 = and i447 %B, 70368744177663 %B1 = and i447 %B, 70368744177663
%C1 = xor i447 %A1, %B1 %C1 = xor i447 %A1, %B1
Show All 39 Lines

llvm/test/Transforms/InstCombine/ashr-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
define i32 @ashr_lshr_exact_ashr_only(i32 %x, i32 %y) { define i32 @ashr_lshr_exact_ashr_only(i32 %x, i32 %y) {
; CHECK-LABEL: @ashr_lshr_exact_ashr_only( ; CHECK-LABEL: @ashr_lshr_exact_ashr_only(
; CHECK-NEXT: [[CMP1:%.*]] = ashr i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP1:%.*]] = ashr i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret i32 [[CMP1]] ; CHECK-NEXT: ret i32 [[CMP1]]
; ;
%cmp = icmp sgt i32 %x, -1 %cmp = icmp sgt i32 %x, -1
%l = lshr i32 %x, %y %l = lshr i32 %x, %y
▲ Show 20 Lines • Show All 574 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/ashr-or-mul-abs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ((ashr X, 31) | 1 ) * X --> abs(X) ; ((ashr X, 31) | 1 ) * X --> abs(X)
; X * ((ashr X, 31) | 1 ) --> abs(X) ; X * ((ashr X, 31) | 1 ) --> abs(X)
define i32 @ashr_or_mul_to_abs(i32 %X) { define i32 @ashr_or_mul_to_abs(i32 %X) {
; CHECK-LABEL: @ashr_or_mul_to_abs( ; CHECK-LABEL: @ashr_or_mul_to_abs(
; CHECK-NEXT: [[I2:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true) ; CHECK-NEXT: [[I2:%.*]] = call i32 @llvm.abs.i32(i32 [[X:%.*]], i1 true)
; CHECK-NEXT: ret i32 [[I2]] ; CHECK-NEXT: ret i32 [[I2]]
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/assoc-cast-assoc.ll

; NOTE: 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 i5 @XorZextXor(i3 %a) { define i5 @XorZextXor(i3 %a) {
; CHECK-LABEL: @XorZextXor( ; CHECK-LABEL: @XorZextXor(
; CHECK-NEXT: [[CAST:%.*]] = zext i3 %a to i5 ; CHECK-NEXT: [[CAST:%.*]] = zext i3 %a to i5
; CHECK-NEXT: [[OP2:%.*]] = xor i5 [[CAST]], 15 ; CHECK-NEXT: [[OP2:%.*]] = xor i5 [[CAST]], 15
; CHECK-NEXT: ret i5 [[OP2]] ; CHECK-NEXT: ret i5 [[OP2]]
; ;
%op1 = xor i3 %a, 3 %op1 = xor i3 %a, 3
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/assume-icmp-null-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
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i8* @example(i8* dereferenceable(24) %x) { define i8* @example(i8* dereferenceable(24) %x) {
; CHECK-LABEL: @example( ; CHECK-LABEL: @example(
; CHECK-NEXT: [[X2:%.*]] = bitcast i8* [[X:%.*]] to {}** ; CHECK-NEXT: [[X2:%.*]] = bitcast i8* [[X:%.*]] to {}**
; CHECK-NEXT: [[Y:%.*]] = load {}*, {}** [[X2]], align 8 ; CHECK-NEXT: [[Y:%.*]] = load {}*, {}** [[X2]], align 8
; CHECK-NEXT: [[Y_IS_NULL:%.*]] = icmp ne {}* [[Y]], null ; CHECK-NEXT: [[Y_IS_NULL:%.*]] = icmp ne {}* [[Y]], null
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/assume2.ll

; NOTE: 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"
declare void @llvm.assume(i1) #1 declare void @llvm.assume(i1) #1
define i32 @test1(i32 %a) #0 { define i32 @test1(i32 %a) #0 {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], 15 ; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], 15
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/assume_inevitable.ll

; NOTE: 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 assume is propagated backwards through all ; Check that assume is propagated backwards through all
; operations that are `isGuaranteedToTransferExecutionToSuccessor` ; operations that are `isGuaranteedToTransferExecutionToSuccessor`
; (it should reach the load and mark it as `align 32`). ; (it should reach the load and mark it as `align 32`).
define i32 @assume_inevitable(i32* %a, i32* %b, i8* %c) { define i32 @assume_inevitable(i32* %a, i32* %b, i8* %c) {
; CHECK-LABEL: @assume_inevitable( ; CHECK-LABEL: @assume_inevitable(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[M:%.*]] = alloca i64, align 8 ; CHECK-NEXT: [[M:%.*]] = alloca i64, align 8
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/atomic.ll

; NOTE: 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 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-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; Check transforms involving atomic operations ; Check transforms involving atomic operations
define i32 @test1(i32* %p) { define i32 @test1(i32* %p) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 414 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/atomicrmw.ll

; RUN: opt -instcombine -S -o - %s | FileCheck %s ; RUN: opt -passes=instcombine -S -o - %s | FileCheck %s
; Check that we can replace `atomicrmw <op> LHS, 0` with `load atomic LHS`. ; Check that we can replace `atomicrmw <op> LHS, 0` with `load atomic LHS`.
; This is possible when: ; This is possible when:
; - <op> LHS, 0 == LHS ; - <op> LHS, 0 == LHS
; - the ordering of atomicrmw is compatible with a load (i.e., no release semantic) ; - the ordering of atomicrmw is compatible with a load (i.e., no release semantic)
; CHECK-LABEL: atomic_add_zero ; CHECK-LABEL: atomic_add_zero
; CHECK-NEXT: %res = load atomic i32, i32* %addr monotonic, align 4 ; CHECK-NEXT: %res = load atomic i32, i32* %addr monotonic, align 4
; CHECK-NEXT: ret i32 %res ; CHECK-NEXT: ret i32 %res
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/badmalloc.ll

; 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"
target triple = "x86_64-apple-darwin10.0" target triple = "x86_64-apple-darwin10.0"
declare noalias i8* @malloc(i64) nounwind declare noalias i8* @malloc(i64) nounwind
declare void @free(i8*) declare void @free(i8*)
; PR5130 ; PR5130
Show All 32 Lines

llvm/test/Transforms/InstCombine/bcmp-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 bcmp library call simplifier works correctly. ; Test that the bcmp library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -mtriple=x86_64-unknown-linux-gnu -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -mtriple=x86_64-unknown-linux-gnu -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:64" 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:64"
@foo = constant [4 x i8] c"foo\00" @foo = constant [4 x i8] c"foo\00"
@hel = constant [4 x i8] c"hel\00" @hel = constant [4 x i8] c"hel\00"
@hello_u = constant [8 x i8] c"hello_u\00" @hello_u = constant [8 x i8] c"hello_u\00"
declare i32 @bcmp(i8*, i8*, i32) declare i32 @bcmp(i8*, i8*, i32)
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bcopy.ll

; NOTE: 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 @bcopy(i8* nocapture readonly, i8* nocapture, i32) declare void @bcopy(i8* nocapture readonly, i8* nocapture, i32)
define void @bcopy_memmove(i8* nocapture readonly %a, i8* nocapture %b) { define void @bcopy_memmove(i8* nocapture readonly %a, i8* nocapture %b) {
; CHECK-LABEL: @bcopy_memmove( ; CHECK-LABEL: @bcopy_memmove(
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[A:%.*]] to i64* ; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[A:%.*]] to i64*
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[B:%.*]] to i64* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[B:%.*]] to i64*
; CHECK-NEXT: [[TMP3:%.*]] = load i64, i64* [[TMP1]], align 1 ; CHECK-NEXT: [[TMP3:%.*]] = load i64, i64* [[TMP1]], align 1
Show All 15 Lines

llvm/test/Transforms/InstCombine/binop-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 | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(i32) declare void @use(i32)
define i32 @testAdd(i32 %X, i32 %Y) { define i32 @testAdd(i32 %X, i32 %Y) {
; CHECK-LABEL: @testAdd( ; CHECK-LABEL: @testAdd(
; CHECK-NEXT: [[T:%.*]] = add i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[T:%.*]] = add i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: ret i32 [[T]] ; CHECK-NEXT: ret i32 [[T]]
; ;
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/binop-phi-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 @use(i32) declare void @use(i32)
declare void @sideeffect() declare void @sideeffect()
; negative test (but we could allow this?) - don't hoist to conditional predecessor block ; negative test (but we could allow this?) - don't hoist to conditional predecessor block
define i32 @add_const_incoming0_speculative(i1 %b, i32 %x, i32 %y) { define i32 @add_const_incoming0_speculative(i1 %b, i32 %x, i32 %y) {
; CHECK-LABEL: @add_const_incoming0_speculative( ; CHECK-LABEL: @add_const_incoming0_speculative(
▲ Show 20 Lines • Show All 770 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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
declare void @use(i32) declare void @use(i32)
define i32 @test1(i1 %c, i32 %x, i32 %y) { define i32 @test1(i1 %c, i32 %x, i32 %y) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[X:%.*]] ; CHECK-NEXT: [[SUB:%.*]] = sub i32 0, [[X:%.*]]
; CHECK-NEXT: [[COND:%.*]] = select i1 [[C:%.*]], i32 [[SUB]], i32 [[Y:%.*]] ; CHECK-NEXT: [[COND:%.*]] = select i1 [[C:%.*]], i32 [[SUB]], i32 [[Y:%.*]]
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bit-checks.ll

; NOTE: 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 @main1(i32 %argc) { define i32 @main1(i32 %argc) {
; CHECK-LABEL: @main1( ; CHECK-LABEL: @main1(
; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[ARGC:%.*]], 3 ; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[ARGC:%.*]], 3
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 3 ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 3
; CHECK-NEXT: [[RETVAL_0:%.*]] = select i1 [[TMP2]], i32 2, i32 1 ; CHECK-NEXT: [[RETVAL_0:%.*]] = select i1 [[TMP2]], i32 2, i32 1
; CHECK-NEXT: ret i32 [[RETVAL_0]] ; CHECK-NEXT: ret i32 [[RETVAL_0]]
; ;
▲ Show 20 Lines • Show All 1,306 Lines • Show Last 20 Lines

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

; NOTE: 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-f128:128:128-v128:128:128-n32: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-f128:128:128-v128:128:128-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
; These tests are extracted from bitcast.ll. ; These tests are extracted from bitcast.ll.
; Verify that they also work correctly on big-endian targets. ; Verify that they also work correctly on big-endian targets.
define float @test2(<2 x float> %A, <2 x i32> %B) { define float @test2(<2 x float> %A, <2 x i32> %B) {
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

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

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; Check all scalar / vector combinations for a pair of bitcasts. ; Check all scalar / vector combinations for a pair of bitcasts.
define ppc_fp128 @bitcast_bitcast_s_s_s(i128 %a) { define ppc_fp128 @bitcast_bitcast_s_s_s(i128 %a) {
%bc1 = bitcast i128 %a to fp128 %bc1 = bitcast i128 %a to fp128
%bc2 = bitcast fp128 %bc1 to ppc_fp128 %bc2 = bitcast fp128 %bc1 to ppc_fp128
ret ppc_fp128 %bc2 ret ppc_fp128 %bc2
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

; RUN: opt -S -instcombine -o - %s | FileCheck %s ; RUN: opt -S -passes=instcombine -o - %s | FileCheck %s
target datalayout = "e-p:32:32:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v64:64:64-v128:128:128-a0:0:64" target datalayout = "e-p:32:32:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v64:64:64-v128:128:128-a0:0:64"
define internal <2 x i32> @func_v2i32(<2 x i32> %v) noinline nounwind { define internal <2 x i32> @func_v2i32(<2 x i32> %v) noinline nounwind {
entry: entry:
ret <2 x i32> %v ret <2 x i32> %v
} }
define internal <2 x float> @func_v2f32(<2 x float> %v) noinline nounwind { define internal <2 x float> @func_v2f32(<2 x float> %v) noinline nounwind {
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitcast-inselt-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 -data-layout="E-n64" | FileCheck %s --check-prefixes=ALL,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E-n64" | FileCheck %s --check-prefixes=ALL,BE
; RUN: opt < %s -instcombine -S -data-layout="e-n64" | FileCheck %s --check-prefixes=ALL,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e-n64" | FileCheck %s --check-prefixes=ALL,LE
declare void @use(<2 x i8>) declare void @use(<2 x i8>)
; i16 is a common type, so we can convert independently of the data layout. ; i16 is a common type, so we can convert independently of the data layout.
; Endian determines if a shift is needed (and so the transform is avoided). ; Endian determines if a shift is needed (and so the transform is avoided).
define i16 @insert0_v2i8(i16 %x, i8 %y) { define i16 @insert0_v2i8(i16 %x, i8 %y) {
; BE-LABEL: @insert0_v2i8( ; BE-LABEL: @insert0_v2i8(
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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
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"
; Bitcasts between vectors and scalars are valid. ; Bitcasts between vectors and scalars are valid.
; PR4487 ; PR4487
define i32 @test1(i64 %a) { define i32 @test1(i64 %a) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 563 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitcast-phi-uselistorder.ll

; NOTE: 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
@Q = internal unnamed_addr global double 1.000000e+00, align 8 @Q = internal unnamed_addr global double 1.000000e+00, align 8
define double @test(i1 %c, i64* %p) { define double @test(i1 %c, i64* %p) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C:%.*]], label [[IF:%.*]], label [[END:%.*]] ; CHECK-NEXT: br i1 [[C:%.*]], label [[IF:%.*]], label [[END:%.*]]
; CHECK: if: ; CHECK: if:
Show All 23 Lines

llvm/test/Transforms/InstCombine/bitcast-sext-vector.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; CHECK: sext ; CHECK: sext
; Don't fold zero/sign extensions with a bitcast between a vector and scalar. ; Don't fold zero/sign extensions with a bitcast between a vector and scalar.
define i32 @t(<4 x i8> %src1, <4 x i8> %src2) nounwind readonly { define i32 @t(<4 x i8> %src1, <4 x i8> %src2) nounwind readonly {
entry: entry:
%cmp = icmp eq <4 x i8> %src1, %src2; <<4 x i1>> [#uses=1] %cmp = icmp eq <4 x i8> %src1, %src2; <<4 x i1>> [#uses=1]
%sext = sext <4 x i1> %cmp to <4 x i8> %sext = sext <4 x i1> %cmp to <4 x i8>
%val = bitcast <4 x i8> %sext to i32 %val = bitcast <4 x i8> %sext to i32
ret i32 %val ret i32 %val
} }

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

; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
; Instcombine should preserve metadata and alignment while ; Instcombine should preserve metadata and alignment while
; folding a bitcast into a store. ; folding a bitcast into a 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" 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"
%struct.A = type { i32 (...)** } %struct.A = type { i32 (...)** }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitcast-vec-canon-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 double @a(<1 x i64> %y) { define double @a(<1 x i64> %y) {
; CHECK-LABEL: @a( ; CHECK-LABEL: @a(
; CHECK-NEXT: [[BC:%.*]] = bitcast <1 x i64> [[Y:%.*]] to <1 x double> ; CHECK-NEXT: [[BC:%.*]] = bitcast <1 x i64> [[Y:%.*]] to <1 x double>
; CHECK-NEXT: [[C:%.*]] = extractelement <1 x double> [[BC]], i64 0 ; CHECK-NEXT: [[C:%.*]] = extractelement <1 x double> [[BC]], i64 0
; CHECK-NEXT: ret double [[C]] ; CHECK-NEXT: ret double [[C]]
; ;
%c = bitcast <1 x i64> %y to double %c = bitcast <1 x i64> %y to double
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitcast-vec-canon.ll

; NOTE: 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 double @a(<1 x i64> %y) { define double @a(<1 x i64> %y) {
; CHECK-LABEL: @a( ; CHECK-LABEL: @a(
; CHECK-NEXT: [[BC:%.*]] = bitcast <1 x i64> [[Y:%.*]] to <1 x double> ; CHECK-NEXT: [[BC:%.*]] = bitcast <1 x i64> [[Y:%.*]] to <1 x double>
; CHECK-NEXT: [[C:%.*]] = extractelement <1 x double> [[BC]], i64 0 ; CHECK-NEXT: [[C:%.*]] = extractelement <1 x double> [[BC]], i64 0
; CHECK-NEXT: ret double [[C]] ; CHECK-NEXT: ret double [[C]]
; ;
%c = bitcast <1 x i64> %y to double %c = bitcast <1 x i64> %y to double
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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
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"
; Bitcasts between vectors and scalars are valid. ; Bitcasts between vectors and scalars are valid.
; PR4487 ; PR4487
define i32 @test1(i64 %a) { define i32 @test1(i64 %a) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 583 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitreverse-known-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 -S -instcombine | FileCheck %s ; RUN: opt < %s -S -passes=instcombine | FileCheck %s
declare i8 @llvm.bitreverse.i8(i8) declare i8 @llvm.bitreverse.i8(i8)
declare i32 @llvm.bitreverse.i32(i32) declare i32 @llvm.bitreverse.i32(i32)
define i1 @test1(i32 %arg) { define i1 @test1(i32 %arg) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bitreverse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -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"
;pairwise reverse ;pairwise reverse
;template <typename T> ;template <typename T>
;T reverse(T v) { ;T reverse(T v) {
; T s = sizeof(v) * 8; ; T s = sizeof(v) * 8;
; T mask = ~(T)0; ; T mask = ~(T)0;
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/broadcast-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 float> @good1(float %arg) { define <4 x float> @good1(float %arg) {
; CHECK-LABEL: @good1( ; CHECK-LABEL: @good1(
; CHECK-NEXT: [[T:%.*]] = insertelement <4 x float> poison, float [[ARG:%.*]], i64 0 ; CHECK-NEXT: [[T:%.*]] = insertelement <4 x float> poison, float [[ARG:%.*]], i64 0
; CHECK-NEXT: [[T6:%.*]] = shufflevector <4 x float> [[T]], <4 x float> poison, <4 x i32> zeroinitializer ; CHECK-NEXT: [[T6:%.*]] = shufflevector <4 x float> [[T]], <4 x float> poison, <4 x i32> zeroinitializer
; CHECK-NEXT: ret <4 x float> [[T6]] ; CHECK-NEXT: ret <4 x float> [[T6]]
; ;
%t = insertelement <4 x float> poison, float %arg, i32 0 %t = insertelement <4 x float> poison, float %arg, i32 0
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/broadcast.ll

; 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 float> @good1(float %arg) { define <4 x float> @good1(float %arg) {
; CHECK-LABEL: @good1( ; CHECK-LABEL: @good1(
; CHECK-NEXT: [[T:%.*]] = insertelement <4 x float> undef, float [[ARG:%.*]], i64 0 ; CHECK-NEXT: [[T:%.*]] = insertelement <4 x float> undef, float [[ARG:%.*]], i64 0
; CHECK-NEXT: [[T6:%.*]] = shufflevector <4 x float> [[T]], <4 x float> poison, <4 x i32> zeroinitializer ; CHECK-NEXT: [[T6:%.*]] = shufflevector <4 x float> [[T]], <4 x float> poison, <4 x i32> zeroinitializer
; CHECK-NEXT: ret <4 x float> [[T6]] ; CHECK-NEXT: ret <4 x float> [[T6]]
; ;
%t = insertelement <4 x float> undef, float %arg, i32 0 %t = insertelement <4 x float> undef, float %arg, i32 0
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; rdar://5992453 ; rdar://5992453
; A & 255 ; A & 255
define i32 @test4(i32 %a) nounwind { define i32 @test4(i32 %a) nounwind {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: [[T2:%.*]] = and i32 [[A:%.*]], 255 ; CHECK-NEXT: [[T2:%.*]] = and i32 [[A:%.*]], 255
; CHECK-NEXT: ret i32 [[T2]] ; CHECK-NEXT: ret i32 [[T2]]
; ;
▲ Show 20 Lines • Show All 621 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bswap-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: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"
; A copy of bswap.ll, with undef at insertelement/shufflevector replaced with ; A copy of bswap.ll, with undef at insertelement/shufflevector replaced with
; poison ; poison
define i32 @shuf_4bytes(<4 x i8> %x) { define i32 @shuf_4bytes(<4 x i8> %x) {
; CHECK-LABEL: @shuf_4bytes( ; CHECK-LABEL: @shuf_4bytes(
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/bswap-known-bits.ll

; RUN: opt < %s -S -instcombine | FileCheck %s ; RUN: opt < %s -S -passes=instcombine | FileCheck %s
; Note: This is testing functionality in computeKnownBits. I'd have rather ; Note: This is testing functionality in computeKnownBits. I'd have rather
; used instsimplify, but the bit test folding is apparently only in instcombine. ; used instsimplify, but the bit test folding is apparently only in instcombine.
declare i16 @llvm.bswap.i16(i16) declare i16 @llvm.bswap.i16(i16)
declare i32 @llvm.bswap.i32(i32) declare i32 @llvm.bswap.i32(i32)
define i1 @test1(i16 %arg) { define i1 @test1(i16 %arg) {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
Show All 38 Lines

llvm/test/Transforms/InstCombine/bswap.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -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"
define i32 @test1(i32 %i) { define i32 @test1(i32 %i) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[T12:%.*]] = call i32 @llvm.bswap.i32(i32 [[I:%.*]]) ; CHECK-NEXT: [[T12:%.*]] = call i32 @llvm.bswap.i32(i32 [[I:%.*]])
; CHECK-NEXT: ret i32 [[T12]] ; CHECK-NEXT: ret i32 [[T12]]
; ;
▲ Show 20 Lines • Show All 922 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/builtin-dynamic-object-size.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %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"
target triple = "x86_64-apple-macosx10.14.0" target triple = "x86_64-apple-macosx10.14.0"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define i64 @weird_identity_but_ok(i64 %sz) { define i64 @weird_identity_but_ok(i64 %sz) {
entry: entry:
%call = tail call i8* @malloc(i64 %sz) %call = tail call i8* @malloc(i64 %sz)
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/builtin-object-size-custom-dl.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | 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"
; check that memory builtins can be handled. ; check that memory builtins can be handled.
define i64 @objsize1_custom_idx(i64 %sz) { define i64 @objsize1_custom_idx(i64 %sz) {
entry: entry:
%ptr = call i8* @malloc(i64 %sz) %ptr = call i8* @malloc(i64 %sz)
%ptr2 = getelementptr inbounds i8, i8* %ptr, i32 2 %ptr2 = getelementptr inbounds i8, i8* %ptr, i32 2
%calc_size = call i64 @llvm.objectsize.i64.p0i8(i8* %ptr2, i1 false, i1 true, i1 true) %calc_size = call i64 @llvm.objectsize.i64.p0i8(i8* %ptr2, i1 false, i1 true, i1 true)
Show All 23 Lines

llvm/test/Transforms/InstCombine/builtin-object-size-offset.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; #include <stdlib.h> ; #include <stdlib.h>
; #include <stdio.h> ; #include <stdio.h>
; ;
; int foo1(int N) { ; int foo1(int N) {
; char Big[20]; ; char Big[20];
; char Small[10]; ; char Small[10];
; char *Ptr = N ? Big + 10 : Small; ; char *Ptr = N ? Big + 10 : Small;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/builtin-object-size-ptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; int foo() { ; int foo() {
; struct V { char buf1[10]; ; struct V { char buf1[10];
; int b; ; int b;
; char buf2[10]; ; char buf2[10];
; } var; ; } var;
; ;
; char *p = &var.buf1[1]; ; char *p = &var.buf1[1];
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/byval.ll

; RUN: opt -S -instcombine %s | FileCheck %s ; RUN: opt -S -passes=instcombine %s | FileCheck %s
declare void @add_byval_callee(double*) declare void @add_byval_callee(double*)
; CHECK-LABEL: define void @add_byval ; CHECK-LABEL: define void @add_byval
; CHECK: [[ARG:%.*]] = bitcast i64* %in to double* ; CHECK: [[ARG:%.*]] = bitcast i64* %in to double*
; CHECK: call void @add_byval_callee(double* byval(double) [[ARG]]) ; CHECK: call void @add_byval_callee(double* byval(double) [[ARG]])
define void @add_byval(i64* %in) { define void @add_byval(i64* %in) {
%tmp = bitcast void (double*)* @add_byval_callee to void (i64*)* %tmp = bitcast void (double*)* @add_byval_callee to void (i64*)*
Show All 15 Lines

llvm/test/Transforms/InstCombine/cabs-array.ll

; NOTE: 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 double @std_cabs([2 x double] %z) { define double @std_cabs([2 x double] %z) {
; CHECK-LABEL: @std_cabs( ; CHECK-LABEL: @std_cabs(
; CHECK-NEXT: [[CALL:%.*]] = tail call double @cabs([2 x double] [[Z:%.*]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call double @cabs([2 x double] [[Z:%.*]])
; CHECK-NEXT: ret double [[CALL]] ; CHECK-NEXT: ret double [[CALL]]
; ;
%call = tail call double @cabs([2 x double] %z) %call = tail call double @cabs([2 x double] %z)
ret double %call ret double %call
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cabs-discrete.ll

; NOTE: 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 double @std_cabs(double %real, double %imag) { define double @std_cabs(double %real, double %imag) {
; CHECK-LABEL: @std_cabs( ; CHECK-LABEL: @std_cabs(
; CHECK-NEXT: [[CALL:%.*]] = tail call double @cabs(double [[REAL:%.*]], double [[IMAG:%.*]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call double @cabs(double [[REAL:%.*]], double [[IMAG:%.*]])
; CHECK-NEXT: ret double [[CALL]] ; CHECK-NEXT: ret double [[CALL]]
; ;
%call = tail call double @cabs(double %real, double %imag) %call = tail call double @cabs(double %real, double %imag)
ret double %call ret double %call
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/call-callconv-mismatch.ll

; NOTE: 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
; Verify that a cdecl-compatible calling convention does not trigger emitting ; Verify that a cdecl-compatible calling convention does not trigger emitting
; unreachable idom `store i1 true, i1* undef`. ; unreachable idom `store i1 true, i1* undef`.
define arm_aapcs_vfpcc i8 @bar(i8* %0) { define arm_aapcs_vfpcc i8 @bar(i8* %0) {
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
; CHECK-NEXT: [[TMP2:%.*]] = load i8, i8* [[TMP0:%.*]], align 1 ; CHECK-NEXT: [[TMP2:%.*]] = load i8, i8* [[TMP0:%.*]], align 1
; CHECK-NEXT: ret i8 [[TMP2]] ; CHECK-NEXT: ret i8 [[TMP2]]
; ;
Show All 12 Lines

llvm/test/Transforms/InstCombine/call-callconv.ll

; NOTE: 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
; Verify that the non-default calling conv doesn't prevent the libcall simplification ; Verify that the non-default calling conv doesn't prevent the libcall simplification
; Layout specifies type of pointer which determines "size_t" ; Layout specifies type of pointer which determines "size_t"
; which is used to identify libcalls such as "size_t strlen(char*)". ; which is used to identify libcalls such as "size_t strlen(char*)".
target datalayout = "p:32:32" target datalayout = "p:32:32"
@.str = private unnamed_addr constant [4 x i8] c"abc\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"abc\00", align 1
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/call-cast-attrs.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define signext i32 @b(i32* inreg %x) { define signext i32 @b(i32* inreg %x) {
ret i32 0 ret i32 0
} }
define void @c(...) { define void @c(...) {
ret void ret void
} }
Show All 20 Lines

llvm/test/Transforms/InstCombine/call-cast-target-inalloca.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:32:32" target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu" target triple = "i686-pc-linux-gnu"
declare void @takes_i32(i32) declare void @takes_i32(i32)
declare void @takes_i32_inalloca(i32* inalloca(i32)) declare void @takes_i32_inalloca(i32* inalloca(i32))
define void @f() { define void @f() {
Show All 13 Lines

llvm/test/Transforms/InstCombine/call-cast-target-preallocated.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:32:32" target datalayout = "e-p:32:32"
target triple = "i686-pc-win32" target triple = "i686-pc-win32"
declare token @llvm.call.preallocated.setup(i32) declare token @llvm.call.preallocated.setup(i32)
declare i8* @llvm.call.preallocated.arg(token, i32) declare i8* @llvm.call.preallocated.arg(token, i32)
Show All 19 Lines

llvm/test/Transforms/InstCombine/call-cast-target.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:32:32" target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu" target triple = "i686-pc-linux-gnu"
define i32 @main() { define i32 @main() {
; CHECK-LABEL: @main ; CHECK-LABEL: @main
; CHECK: %[[call:.*]] = call i8* @ctime(i32* null) ; CHECK: %[[call:.*]] = call i8* @ctime(i32* null)
; CHECK: %[[cast:.*]] = ptrtoint i8* %[[call]] to i32 ; CHECK: %[[cast:.*]] = ptrtoint i8* %[[call]] to i32
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/call-intrinsics.ll

; RUN: opt < %s -instcombine | llvm-dis ; RUN: opt < %s -passes=instcombine | llvm-dis
@X = global i8 0 ; <i8*> [#uses=3] @X = global i8 0 ; <i8*> [#uses=3]
@Y = global i8 12 ; <i8*> [#uses=2] @Y = global i8 12 ; <i8*> [#uses=2]
declare void @llvm.memmove.p0i8.p0i8.i32(i8*, i8*, i32, i1) declare void @llvm.memmove.p0i8.p0i8.i32(i8*, i8*, i32, i1)
declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
Show All 10 Lines

llvm/test/Transforms/InstCombine/call-returned.ll

; NOTE: 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 i32 @passthru_i32(i32 returned) declare i32 @passthru_i32(i32 returned)
declare i8* @passthru_p8(i8* returned) declare i8* @passthru_p8(i8* returned)
declare i8* @passthru_p8_from_p32(i32* returned) declare i8* @passthru_p8_from_p32(i32* returned)
declare <8 x i8> @passthru_8i8v_from_2i32v(<2 x i32> returned) declare <8 x i8> @passthru_8i8v_from_2i32v(<2 x i32> returned)
define i32 @returned_const_int_arg() { define i32 @returned_const_int_arg() {
; CHECK-LABEL: @returned_const_int_arg( ; CHECK-LABEL: @returned_const_int_arg(
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/call.ll

; Ignore stderr, we expect warnings there ; Ignore stderr, we expect warnings there
; RUN: opt < %s -instcombine 2> /dev/null -S | FileCheck %s ; RUN: opt < %s -passes=instcombine 2> /dev/null -S | FileCheck %s
target datalayout = "E-p:64:64:64-p1:16:16:16-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-p1:16:16:16-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; Simple case, argument translatable without changing the value ; Simple case, argument translatable without changing the value
declare void @test1a(i8*) declare void @test1a(i8*)
define void @test1(i32* %A) { define void @test1(i32* %A) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/call2.ll

; RUN: opt < %s -instcombine | llvm-dis ; RUN: opt < %s -passes=instcombine | llvm-dis
; This used to crash trying to do a double-to-pointer conversion ; This used to crash trying to do a double-to-pointer conversion
define i32 @bar() { define i32 @bar() {
entry: entry:
%retval = alloca i32, align 4 ; <i32*> [#uses=1] %retval = alloca i32, align 4 ; <i32*> [#uses=1]
%tmp = call i32 (...) bitcast (i32 (i8*)* @f to i32 (...)*)( double 3.000000e+00 ) ; <i32> [#uses=0] %tmp = call i32 (...) bitcast (i32 (i8*)* @f to i32 (...)*)( double 3.000000e+00 ) ; <i32> [#uses=0]
br label %return br label %return
Show All 16 Lines

llvm/test/Transforms/InstCombine/call_nonnull_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 < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; InstCombine should mark null-checked argument as nonnull at callsite ; InstCombine should mark null-checked argument as nonnull at callsite
declare void @dummy(i32*, i32) declare void @dummy(i32*, i32)
define void @test(i32* %a, i32 %b) { define void @test(i32* %a, i32 %b) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND1:%.*]] = icmp eq i32* [[A:%.*]], null ; CHECK-NEXT: [[COND1:%.*]] = icmp eq i32* [[A:%.*]], null
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/calloc-mismatch.ll

; NOTE: 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 argument types should match if it is the standard library calloc. ; The argument types should match if it is the standard library calloc.
; Don't crash analyzing an imposter. ; Don't crash analyzing an imposter.
declare i8* @calloc(i64, i32) declare i8* @calloc(i64, i32)
define void @PR50846() { define void @PR50846() {
; CHECK-LABEL: @PR50846( ; CHECK-LABEL: @PR50846(
; CHECK-NEXT: [[CALL:%.*]] = call i8* @calloc(i64 1, i32 1) ; CHECK-NEXT: [[CALL:%.*]] = call i8* @calloc(i64 1, i32 1)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%call = call i8* @calloc(i64 1, i32 1) %call = call i8* @calloc(i64 1, i32 1)
ret void ret void
} }

llvm/test/Transforms/InstCombine/callsite_nonnull_args_through_casts.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
declare void @foo(i8*) declare void @foo(i8*)
declare void @bar(i8 addrspace(1)*) declare void @bar(i8 addrspace(1)*)
define void @nonnullAfterBitCast() { define void @nonnullAfterBitCast() {
entry: entry:
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-ashr-shl-to-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
; https://bugs.llvm.org/show_bug.cgi?id=37603 ; https://bugs.llvm.org/show_bug.cgi?id=37603
; https://reviews.llvm.org/D46760#1123713 ; https://reviews.llvm.org/D46760#1123713
; Pattern: ; Pattern:
; x >> y << y ; x >> y << y
; Should be transformed into: ; Should be transformed into:
; x & (-1 << y) ; x & (-1 << y)
▲ Show 20 Lines • Show All 605 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-clamp-like-pattern-between-negative-and-positive-thresholds.ll

; NOTE: 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 a pattern like: ; Given a pattern like:
; %old_cmp1 = icmp slt i32 %x, C2 ; %old_cmp1 = icmp slt i32 %x, C2
; %old_replacement = select i1 %old_cmp1, i32 %target_low, i32 %target_high ; %old_replacement = select i1 %old_cmp1, i32 %target_low, i32 %target_high
; %old_x_offseted = add i32 %x, C1 ; %old_x_offseted = add i32 %x, C1
; %old_cmp0 = icmp ult i32 %old_x_offseted, C0 ; %old_cmp0 = icmp ult i32 %old_x_offseted, C0
; %r = select i1 %old_cmp0, i32 %x, i32 %old_replacement ; %r = select i1 %old_cmp0, i32 %x, i32 %old_replacement
; it can be rewriten as more canonical pattern: ; it can be rewriten as more canonical pattern:
▲ Show 20 Lines • Show All 469 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-clamp-like-pattern-between-zero-and-positive-threshold.ll

; NOTE: 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 a pattern like: ; Given a pattern like:
; %old_cmp1 = icmp slt i32 %x, C2 ; %old_cmp1 = icmp slt i32 %x, C2
; %old_replacement = select i1 %old_cmp1, i32 %target_low, i32 %target_high ; %old_replacement = select i1 %old_cmp1, i32 %target_low, i32 %target_high
; %old_x_offseted = add i32 %x, C1 ; %old_x_offseted = add i32 %x, C1
; %old_cmp0 = icmp ult i32 %old_x_offseted, C0 ; %old_cmp0 = icmp ult i32 %old_x_offseted, C0
; %r = select i1 %old_cmp0, i32 %x, i32 %old_replacement ; %r = select i1 %old_cmp0, i32 %x, i32 %old_replacement
; it can be rewriten as more canonical pattern: ; it can be rewriten as more canonical pattern:
▲ Show 20 Lines • Show All 389 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-clamp-with-select-of-constant-threshold-pattern.ll

; NOTE: 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 patterns are all just traditional clamp pattern. ; These patterns are all just traditional clamp pattern.
; But they are not canonical, the and/or/xor is more canonically represented ; But they are not canonical, the and/or/xor is more canonically represented
; as an add+icmp. ; as an add+icmp.
define i32 @t0_select_cond_and_v0(i32 %X) { define i32 @t0_select_cond_and_v0(i32 %X) {
; CHECK-LABEL: @t0_select_cond_and_v0( ; CHECK-LABEL: @t0_select_cond_and_v0(
; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i32 [[X:%.*]], -32768 ; CHECK-NEXT: [[TMP1:%.*]] = icmp sgt i32 [[X:%.*]], -32768
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-eq-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & C == x ; x & C == x
; Should be transformed into: ; Should be transformed into:
; x u<= C ; x u<= C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-ne-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & C != x ; x & C != x
; Should be transformed into: ; Should be transformed into:
; x u> C ; x u> C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-sge-to-icmp-sle.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & C s>= x ; x & C s>= x
; Should be transformed into: ; Should be transformed into:
; x s<= C ; x s<= C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-sgt-to-icmp-sgt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x s> x & C ; x s> x & C
; Should be transformed into: ; Should be transformed into:
; x s> C ; x s> C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-sle-to-icmp-sle.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x s<= x & C ; x s<= x & C
; Should be transformed into: ; Should be transformed into:
; x s<= C ; x s<= C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-slt-to-icmp-sgt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & C s< x ; x & C s< x
; Should be transformed into: ; Should be transformed into:
; x s> C ; x s> C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-uge-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & C u>= x ; x & C u>= x
; Should be transformed into: ; Should be transformed into:
; x u<= C ; x u<= C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-ugt-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x u> x & C ; x u> x & C
; Should be transformed into: ; Should be transformed into:
; x u> C ; x u> C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-ule-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x u<= x & C ; x u<= x & C
; Should be transformed into: ; Should be transformed into:
; x u<= C ; x u<= C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-constant-low-bit-mask-and-icmp-ult-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & C u< x ; x & C u< x
; Should be transformed into: ; Should be transformed into:
; x u> C ; x u> C
; Iff: isPowerOf2(C + 1) ; Iff: isPowerOf2(C + 1)
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-lack-of-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
; https://bugs.llvm.org/show_bug.cgi?id=38149 ; https://bugs.llvm.org/show_bug.cgi?id=38149
; Pattern: ; Pattern:
; ((%x << MaskedBits) a>> MaskedBits) == %x ; ((%x << MaskedBits) a>> MaskedBits) == %x
; Should be transformed into: ; Should be transformed into:
; (add %x, (1 << (KeptBits-1))) u< (1 << KeptBits) ; (add %x, (1 << (KeptBits-1))) u< (1 << KeptBits)
; Where KeptBits = bitwidth(%x) - MaskedBits ; Where KeptBits = bitwidth(%x) - MaskedBits
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-and-icmp-eq-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & (-1 >> y) == x ; x & (-1 >> y) == x
; Should be transformed into: ; Should be transformed into:
; x u<= (-1 >> y) ; x u<= (-1 >> y)
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-and-icmp-ne-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & (-1 >> y) != x ; x & (-1 >> y) != x
; Should be transformed into: ; Should be transformed into:
; x u> (-1 >> y) ; x u> (-1 >> y)
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v2-and-icmp-eq-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & ~(-1 << y) == x ; x & ~(-1 << y) == x
; Should be transformed into: ; Should be transformed into:
; x u<= ~(-1 << y) ; x u<= ~(-1 << y)
; That is then later transformed into: ; That is then later transformed into:
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v2-and-icmp-ne-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & ~(-1 << y) != x ; x & ~(-1 << y) != x
; Should be transformed into: ; Should be transformed into:
; x u> ~(-1 << y) ; x u> ~(-1 << y)
; That is then later transformed into: ; That is then later transformed into:
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v3-and-icmp-eq-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & ((1 << y) + (-1)) == x ; x & ((1 << y) + (-1)) == x
; Should be transformed into: ; Should be transformed into:
; x u<= ((1 << y) + (-1)) ; x u<= ((1 << y) + (-1))
; That is then later transformed into: ; That is then later transformed into:
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v3-and-icmp-ne-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & ((1 << y) + (-1)) != x ; x & ((1 << y) + (-1)) != x
; Should be transformed into: ; Should be transformed into:
; x u> ((1 << y) + (-1)) ; x u> ((1 << y) + (-1))
; That is then later transformed into: ; That is then later transformed into:
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v4-and-icmp-eq-to-icmp-ule.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & ((-1 << y) >> y) == x ; x & ((-1 << y) >> y) == x
; Should be transformed into: ; Should be transformed into:
; x u<= ((-1 << y) >> y) ; x u<= ((-1 << y) >> y)
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-low-bit-mask-v4-and-icmp-ne-to-icmp-ugt.ll

; NOTE: 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=38123 ; https://bugs.llvm.org/show_bug.cgi?id=38123
; Pattern: ; Pattern:
; x & ((-1 << y) >> y) != x ; x & ((-1 << y) >> y) != x
; Should be transformed into: ; Should be transformed into:
; x u> ((-1 << y) >> y) ; x u> ((-1 << y) >> y)
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-lshr-shl-to-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
; https://bugs.llvm.org/show_bug.cgi?id=37603 ; https://bugs.llvm.org/show_bug.cgi?id=37603
; https://reviews.llvm.org/D46760#1123713 ; https://reviews.llvm.org/D46760#1123713
; Pattern: ; Pattern:
; x >> y << y ; x >> y << y
; Should be transformed into: ; Should be transformed into:
; x & (-1 << y) ; x & (-1 << y)
▲ Show 20 Lines • Show All 605 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-selects-icmp-condition-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
declare void @use8(i8) declare void @use8(i8)
declare void @use1(i1) declare void @use1(i1)
; Basic case - all good. ; Basic case - all good.
define i8 @p0(i8 %x, i8 %v0, i8 %v1) { define i8 @p0(i8 %x, i8 %v0, i8 %v1) {
; CHECK-LABEL: @p0( ; CHECK-LABEL: @p0(
; CHECK-NEXT: [[T0:%.*]] = and i8 [[X:%.*]], 1 ; CHECK-NEXT: [[T0:%.*]] = and i8 [[X:%.*]], 1
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-shl-lshr-to-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
; https://bugs.llvm.org/show_bug.cgi?id=37603 ; https://bugs.llvm.org/show_bug.cgi?id=37603
; Pattern: ; Pattern:
; x << y >> y ; x << y >> y
; Should be transformed into: ; Should be transformed into:
; x & (-1 >> y) ; x & (-1 >> y)
▲ Show 20 Lines • Show All 388 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-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
; https://bugs.llvm.org/show_bug.cgi?id=38149 ; https://bugs.llvm.org/show_bug.cgi?id=38149
; Pattern: ; Pattern:
; ((%x << MaskedBits) a>> MaskedBits) != %x ; ((%x << MaskedBits) a>> MaskedBits) != %x
; Should be transformed into: ; Should be transformed into:
; (add %x, (1 << (KeptBits-1))) u>= (1 << KeptBits) ; (add %x, (1 << (KeptBits-1))) u>= (1 << KeptBits)
; Where KeptBits = bitwidth(%x) - MaskedBits ; Where KeptBits = bitwidth(%x) - MaskedBits
▲ Show 20 Lines • Show All 224 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-vector-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
; llvm.experimental.vector.extract canonicalizes to shufflevector in the fixed case. In the ; llvm.experimental.vector.extract canonicalizes to shufflevector in the fixed case. In the
; scalable case, we lower to the EXTRACT_SUBVECTOR ISD node. ; scalable case, we lower to the EXTRACT_SUBVECTOR ISD node.
declare <10 x i32> @llvm.experimental.vector.extract.v10i32.v8i32(<8 x i32> %vec, i64 %idx) declare <10 x i32> @llvm.experimental.vector.extract.v10i32.v8i32(<8 x i32> %vec, i64 %idx)
declare <2 x i32> @llvm.experimental.vector.extract.v2i32.v4i32(<8 x i32> %vec, i64 %idx) declare <2 x i32> @llvm.experimental.vector.extract.v2i32.v4i32(<8 x i32> %vec, i64 %idx)
declare <3 x i32> @llvm.experimental.vector.extract.v3i32.v8i32(<8 x i32> %vec, i64 %idx) declare <3 x i32> @llvm.experimental.vector.extract.v3i32.v8i32(<8 x i32> %vec, i64 %idx)
declare <4 x i32> @llvm.experimental.vector.extract.v4i32.nxv4i32(<vscale x 4 x i32> %vec, i64 %idx) declare <4 x i32> @llvm.experimental.vector.extract.v4i32.nxv4i32(<vscale x 4 x i32> %vec, i64 %idx)
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize-vector-insert.ll

; NOTE: 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
; llvm.experimental.vector.insert canonicalizes to shufflevector in the fixed case. In the ; llvm.experimental.vector.insert canonicalizes to shufflevector in the fixed case. In the
; scalable case, we lower to the INSERT_SUBVECTOR ISD node. ; scalable case, we lower to the INSERT_SUBVECTOR ISD node.
declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v2i32(<8 x i32> %vec, <2 x i32> %subvec, i64 %idx) declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v2i32(<8 x i32> %vec, <2 x i32> %subvec, i64 %idx)
declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v3i32(<8 x i32> %vec, <3 x i32> %subvec, i64 %idx) declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v3i32(<8 x i32> %vec, <3 x i32> %subvec, i64 %idx)
declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v4i32(<8 x i32> %vec, <4 x i32> %subvec, i64 %idx) declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v4i32(<8 x i32> %vec, <4 x i32> %subvec, i64 %idx)
declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v8i32(<8 x i32> %vec, <8 x i32> %subvec, i64 %idx) declare <8 x i32> @llvm.experimental.vector.insert.v8i32.v8i32(<8 x i32> %vec, <8 x i32> %subvec, i64 %idx)
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/canonicalize_branch.ll

; NOTE: 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 an already canonical branch to make sure we don't flip those. ; Test an already canonical branch to make sure we don't flip those.
define i32 @eq(i32 %X, i32 %Y) { define i32 @eq(i32 %X, i32 %Y) {
; CHECK-LABEL: @eq( ; CHECK-LABEL: @eq(
; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]], !prof !0 ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]], !prof !0
; CHECK: T: ; CHECK: T:
; CHECK-NEXT: ret i32 12 ; CHECK-NEXT: ret i32 12
▲ Show 20 Lines • Show All 490 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-call-combine-prof.ll

; RUN: opt -S -instcombine < %s | FileCheck -enable-var-scope %s ; RUN: opt -S -passes=instcombine < %s | FileCheck -enable-var-scope %s
; Check that instcombine preserves !prof metadata when removing function ; Check that instcombine preserves !prof metadata when removing function
; prototype casts. ; prototype casts.
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
declare void @__cxa_call_unexpected(i8*) declare void @__cxa_call_unexpected(i8*)
declare void @foo(i16* %a) declare void @foo(i16* %a)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-callee-deopt-bundles.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare void @foo(i32) declare void @foo(i32)
define void @g() { define void @g() {
; CHECK-LABEL: @g( ; CHECK-LABEL: @g(
entry: entry:
; CHECK: call void @foo(i32 0) [ "deopt"() ] ; CHECK: call void @foo(i32 0) [ "deopt"() ]
call void bitcast (void (i32)* @foo to void ()*) () [ "deopt"() ] call void bitcast (void (i32)* @foo to void ()*) () [ "deopt"() ]
ret void ret void
} }

llvm/test/Transforms/InstCombine/cast-int-fcmp-eq-0.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define i1 @i32_cast_cmp_oeq_int_0_uitofp(i32 %i) { define i1 @i32_cast_cmp_oeq_int_0_uitofp(i32 %i) {
; CHECK-LABEL: @i32_cast_cmp_oeq_int_0_uitofp( ; CHECK-LABEL: @i32_cast_cmp_oeq_int_0_uitofp(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%f = uitofp i32 %i to float %f = uitofp i32 %i to float
%cmp = fcmp oeq float %f, 0.0 %cmp = fcmp oeq float %f, 0.0
▲ Show 20 Lines • Show All 501 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-int-icmp-eq-0.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; This is https://bugs.llvm.org/show_bug.cgi?id=36682 ; This is https://bugs.llvm.org/show_bug.cgi?id=36682
; In *all* of these, sitofp and bitcast should be instcombine'd out. ; In *all* of these, sitofp and bitcast should be instcombine'd out.
; "sle 0" is canonicalized to "slt 1", so we don't test "sle 0" case. ; "sle 0" is canonicalized to "slt 1", so we don't test "sle 0" case.
; "sge 0" is canonicalized to "sgt -1", so we don't test "sge 0" case. ; "sge 0" is canonicalized to "sgt -1", so we don't test "sge 0" case.
; "sge 1" is canonicalized to "sgt 0", so we don't test "sge 1" case. ; "sge 1" is canonicalized to "sgt 0", so we don't test "sge 1" case.
; "sle -1" is canonicalized to "slt 0", so we don't test "sle -1" case. ; "sle -1" is canonicalized to "slt 0", so we don't test "sle -1" case.
▲ Show 20 Lines • Show All 699 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-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 i64 @zext(i32 %x, i32 %y, i32 %z) { define i64 @zext(i32 %x, i32 %y, i32 %z) {
; CHECK-LABEL: @zext( ; CHECK-LABEL: @zext(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], i32 0, i32 [[Z:%.*]] ; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], i32 0, i32 [[Z:%.*]]
; CHECK-NEXT: [[R:%.*]] = zext i32 [[SEL]] to i64 ; CHECK-NEXT: [[R:%.*]] = zext i32 [[SEL]] to i64
; CHECK-NEXT: ret i64 [[R]] ; CHECK-NEXT: ret i64 [[R]]
; ;
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-set-preserve-signed-dbg-val.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; CHECK-LABEL: define {{.*}} @test5 ; CHECK-LABEL: define {{.*}} @test5
define i16 @test5(i16 %A) !dbg !34 { define i16 @test5(i16 %A) !dbg !34 {
; CHECK: [[and:%.*]] = and i16 %A, 15 ; CHECK: [[and:%.*]] = and i16 %A, 15
%B = sext i16 %A to i32, !dbg !40 %B = sext i16 %A to i32, !dbg !40
call void @llvm.dbg.value(metadata i32 %B, metadata !36, metadata !DIExpression()), !dbg !40 call void @llvm.dbg.value(metadata i32 %B, metadata !36, metadata !DIExpression()), !dbg !40
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-set.ll

; NOTE: 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"
define i1 @test1(i32 %X) { define i1 @test1(i32 %X) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[C:%.*]] = icmp ne i32 %X, 12 ; CHECK-NEXT: [[C:%.*]] = icmp ne i32 %X, 12
; CHECK-NEXT: ret i1 [[C]] ; CHECK-NEXT: ret i1 [[C]]
; ;
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast-unsigned-icmp-eqcmp-0.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; This is related to https://bugs.llvm.org/show_bug.cgi?id=36682 ; This is related to https://bugs.llvm.org/show_bug.cgi?id=36682
; In *all* of these, uitofp and bitcast should be instcombine'd out. ; In *all* of these, uitofp and bitcast should be instcombine'd out.
define i1 @i32_cast_cmp_eq_int_0_uitofp_float(i32 %i) { define i1 @i32_cast_cmp_eq_int_0_uitofp_float(i32 %i) {
; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_float( ; CHECK-LABEL: @i32_cast_cmp_eq_int_0_uitofp_float(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], 0
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Tests to make sure elimination of casts is working correctly ; Tests to make sure elimination of casts is working correctly
; RUN: opt < %s -instcombine -S -data-layout="E-p:64:64:64-p1:32:32:32-p2:64:64:64-p3:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128-n8:16:32:64" | FileCheck %s --check-prefixes=ALL,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E-p:64:64:64-p1:32:32:32-p2:64:64:64-p3:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128-n8:16:32:64" | FileCheck %s --check-prefixes=ALL,BE
; RUN: opt < %s -instcombine -S -data-layout="e-p:64:64:64-p1:32:32:32-p2:64:64:64-p3:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128-n8:16:32:64" | FileCheck %s --check-prefixes=ALL,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e-p:64:64:64-p1:32:32:32-p2:64:64:64-p3:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128-n8:16:32:64" | FileCheck %s --check-prefixes=ALL,LE
declare void @use_i32(i32) declare void @use_i32(i32)
declare void @use_v2i32(<2 x i32>) declare void @use_v2i32(<2 x i32>)
@inbuf = external global [32832 x i8] @inbuf = external global [32832 x i8]
define i32 @test1(i32 %A) { define i32 @test1(i32 %A) {
; ALL-LABEL: @test1( ; ALL-LABEL: @test1(
▲ Show 20 Lines • Show All 2,166 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cast_ptr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Tests to make sure elimination of casts is working correctly ; Tests to make sure elimination of casts is working correctly
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "p:32:32-p1:32:32-p2:16:16" target datalayout = "p:32:32-p1:32:32-p2:16:16"
@global = global i8 0 @global = global i8 0
; This shouldn't convert to getelementptr because the relationship ; This shouldn't convert to getelementptr because the relationship
; between the arithmetic and the layout of allocated memory is ; between the arithmetic and the layout of allocated memory is
; entirely unknown. ; entirely unknown.
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

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

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.quux = type { i32 } %struct.quux = type { i32 }
%struct.blam = type <{ %struct.quux }> %struct.blam = type <{ %struct.quux }>
declare void @foo() declare void @foo()
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/ceil.ll

; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare float @llvm.ceil.f32(float) #0 declare float @llvm.ceil.f32(float) #0
declare double @llvm.ceil.f64(double) #0 declare double @llvm.ceil.f64(double) #0
declare <4 x float> @llvm.ceil.v4f32(<4 x float>) #0 declare <4 x float> @llvm.ceil.v4f32(<4 x float>) #0
; CHECK-LABEL: @constant_fold_ceil_f32_01 ; CHECK-LABEL: @constant_fold_ceil_f32_01
; CHECK-NEXT: ret float 1.000000e+00 ; CHECK-NEXT: ret float 1.000000e+00
define float @constant_fold_ceil_f32_01() #0 { define float @constant_fold_ceil_f32_01() #0 {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/clamp-to-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
; (X < C1) ? C1 : MIN(X, C2) ; (X < C1) ? C1 : MIN(X, C2)
define float @clamp_float_fast_ordered_strict_maxmin(float %x) { define float @clamp_float_fast_ordered_strict_maxmin(float %x) {
; CHECK-LABEL: @clamp_float_fast_ordered_strict_maxmin( ; CHECK-LABEL: @clamp_float_fast_ordered_strict_maxmin(
; CHECK-NEXT: [[CMP2:%.*]] = fcmp fast olt float [[X:%.*]], 2.550000e+02 ; CHECK-NEXT: [[CMP2:%.*]] = fcmp fast olt float [[X:%.*]], 2.550000e+02
; CHECK-NEXT: [[MIN:%.*]] = select i1 [[CMP2]], float [[X]], float 2.550000e+02 ; CHECK-NEXT: [[MIN:%.*]] = select i1 [[CMP2]], float [[X]], float 2.550000e+02
; CHECK-NEXT: [[TMP1:%.*]] = call fast float @llvm.maxnum.f32(float [[MIN]], float 1.000000e+00) ; CHECK-NEXT: [[TMP1:%.*]] = call fast float @llvm.maxnum.f32(float [[MIN]], float 1.000000e+00)
; CHECK-NEXT: ret float [[TMP1]] ; CHECK-NEXT: ret float [[TMP1]]
▲ Show 20 Lines • Show All 564 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cmp-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i16 @llvm.bswap.i16(i16) declare i16 @llvm.bswap.i16(i16)
declare i32 @llvm.bswap.i32(i32) declare i32 @llvm.bswap.i32(i32)
declare <2 x i64> @llvm.bswap.v2i64(<2 x i64>) declare <2 x i64> @llvm.bswap.v2i64(<2 x i64>)
declare i33 @llvm.cttz.i33(i33, i1) declare i33 @llvm.cttz.i33(i33, i1)
declare i32 @llvm.ctlz.i32(i32, i1) declare i32 @llvm.ctlz.i32(i32, i1)
declare i8 @llvm.ctpop.i8(i8) declare i8 @llvm.ctpop.i8(i8)
declare i11 @llvm.ctpop.i11(i11) declare i11 @llvm.ctpop.i11(i11)
▲ Show 20 Lines • Show All 505 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cmp-x-vs-neg-x.ll

; NOTE: 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 @gen8() declare i8 @gen8()
declare void @use8(i8) declare void @use8(i8)
define i1 @t0(i8 %x) { define i1 @t0(i8 %x) {
; CHECK-LABEL: @t0( ; CHECK-LABEL: @t0(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], 0
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/commutative-intrinsics.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define i35 @smax(i35 %x) { define i35 @smax(i35 %x) {
; CHECK-LABEL: @smax( ; CHECK-LABEL: @smax(
; CHECK-NEXT: [[R:%.*]] = call i35 @llvm.smax.i35(i35 [[X:%.*]], i35 42) ; CHECK-NEXT: [[R:%.*]] = call i35 @llvm.smax.i35(i35 [[X:%.*]], i35 42)
; CHECK-NEXT: ret i35 [[R]] ; CHECK-NEXT: ret i35 [[R]]
; ;
%r = call i35 @llvm.smax.i35(i35 42, i35 %x) %r = call i35 @llvm.smax.i35(i35 42, i35 %x)
ret i35 %r ret i35 %r
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/compare-3way.ll

; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare void @use(i32) declare void @use(i32)
; These 18 exercise all combinations of signed comparison ; These 18 exercise all combinations of signed comparison
; for each of the three values produced by your typical ; for each of the three values produced by your typical
; 3way compare function (-1, 0, 1) ; 3way compare function (-1, 0, 1)
define void @test_low_sgt(i64 %a, i64 %b) { define void @test_low_sgt(i64 %a, i64 %b) {
▲ Show 20 Lines • Show All 386 Lines • Show Last 20 Lines

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

; RUN: opt -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
target datalayout = "p:32:32" target datalayout = "p:32:32"
define i1 @alloca_argument_compare(i64* %arg) { define i1 @alloca_argument_compare(i64* %arg) {
%alloc = alloca i64 %alloc = alloca i64
%cmp = icmp eq i64* %arg, %alloc %cmp = icmp eq i64* %arg, %alloc
ret i1 %cmp ret i1 %cmp
; CHECK-LABEL: alloca_argument_compare ; CHECK-LABEL: alloca_argument_compare
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/compare-signs.ll

; 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
; PR5438 ; PR5438
define i32 @test1(i32 %a, i32 %b) nounwind readnone { define i32 @test1(i32 %a, i32 %b) nounwind readnone {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]] ; CHECK-NEXT: [[TMP1:%.*]] = xor i32 [[B:%.*]], [[A:%.*]]
; CHECK-NEXT: [[TMP2:%.*]] = xor i32 [[TMP1]], -1 ; CHECK-NEXT: [[TMP2:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[DOTLOBIT_NOT:%.*]] = lshr i32 [[TMP2]], 31 ; CHECK-NEXT: [[DOTLOBIT_NOT:%.*]] = lshr i32 [[TMP2]], 31
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/compare-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i1 @test1(i32 %n, i32 %d) { define i1 @test1(i32 %n, i32 %d) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i32 %d, %n ; CHECK-NEXT: [[CMP1:%.*]] = icmp ugt i32 %d, %n
; CHECK-NEXT: ret i1 [[CMP1]] ; CHECK-NEXT: ret i1 [[CMP1]]
; ;
%div = udiv i32 %n, %d %div = udiv i32 %n, %d
%cmp1 = icmp eq i32 %div, 0 %cmp1 = icmp eq i32 %div, 0
▲ Show 20 Lines • Show All 308 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/compare-unescaped.ll

; 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
@gp = global i32* null, align 8 @gp = global i32* null, align 8
declare i8* @malloc(i64) #1 declare i8* @malloc(i64) #1
define i1 @compare_global_trivialeq() { define i1 @compare_global_trivialeq() {
; CHECK-LABEL: @compare_global_trivialeq( ; CHECK-LABEL: @compare_global_trivialeq(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/conditional-variable-length-signext-after-high-bit-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
; If we extract (via lshr) some high bits, and then perform their sign-extension ; If we extract (via lshr) some high bits, and then perform their sign-extension
; conditionally depending on whether the extracted value is negative or not ; conditionally depending on whether the extracted value is negative or not
; (i.e. interpreting the highest extracted bit, which was the original signbit ; (i.e. interpreting the highest extracted bit, which was the original signbit
; of the value from which we extracted as a signbit), then we should just ; of the value from which we extracted as a signbit), then we should just
; perform extraction via `ashr`. ; perform extraction via `ashr`.
; Base patterns. ; Base patterns.
▲ Show 20 Lines • Show All 1,129 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/consecutive-fences.ll

; RUN: opt -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
; Make sure we collapse the fences in this case ; Make sure we collapse the fences in this case
; CHECK-LABEL: define void @tinkywinky ; CHECK-LABEL: define void @tinkywinky
; CHECK-NEXT: fence seq_cst ; CHECK-NEXT: fence seq_cst
; CHECK-NEXT: fence syncscope("singlethread") acquire ; CHECK-NEXT: fence syncscope("singlethread") acquire
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK-NEXT: } ; CHECK-NEXT: }
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/constant-expr-datalayout.ll

; RUN: opt -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | 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"
%test1.struct = type { i32, i32 } %test1.struct = type { i32, i32 }
@test1.aligned_glbl = global %test1.struct zeroinitializer, align 4 @test1.aligned_glbl = global %test1.struct zeroinitializer, align 4
define void @test1(i64 *%ptr) { define void @test1(i64 *%ptr) {
store i64 and (i64 ptrtoint (i32* getelementptr (%test1.struct, %test1.struct* @test1.aligned_glbl, i32 0, i32 1) to i64), i64 3), i64* %ptr store i64 and (i64 ptrtoint (i32* getelementptr (%test1.struct, %test1.struct* @test1.aligned_glbl, i32 0, i32 1) to i64), i64 3), i64* %ptr
; CHECK: store i64 0, i64* %ptr ; CHECK: store i64 0, i64* %ptr
ret void ret void
} }

llvm/test/Transforms/InstCombine/constant-fold-address-space-pointer.ll

; NOTE: 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
target datalayout = "e-p:32:32:32-p1:64:64:64-p2:8:8:8-p3:16:16:16-p4:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32" target datalayout = "e-p:32:32:32-p1:64:64:64-p2:8:8:8-p3:16:16:16-p4:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32"
@g = addrspace(3) global i32 89 @g = addrspace(3) global i32 89
@const_zero_i8_as1 = addrspace(1) constant i8 0 @const_zero_i8_as1 = addrspace(1) constant i8 0
@const_zero_i32_as1 = addrspace(1) constant i32 0 @const_zero_i32_as1 = addrspace(1) constant i32 0
@const_zero_i8_as2 = addrspace(2) constant i8 0 @const_zero_i8_as2 = addrspace(2) constant i8 0
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/constant-fold-alias.ll

; RUN: opt -S < %s -instcombine | FileCheck %s ; RUN: opt -S < %s -passes=instcombine | FileCheck %s
target datalayout = "e-p1:16:16-p2:32:32-p3:64:64" target datalayout = "e-p1:16:16-p2:32:32-p3:64:64"
@G1 = global i32 42, align 1 @G1 = global i32 42, align 1
@G2 = global i32 42 @G2 = global i32 42
@G3 = global [4 x i8] zeroinitializer, align 1 @G3 = global [4 x i8] zeroinitializer, align 1
@A1 = alias i32, bitcast (i8* getelementptr inbounds ([4 x i8], [4 x i8]* @G3, i32 0, i32 2) to i32*) @A1 = alias i32, bitcast (i8* getelementptr inbounds ([4 x i8], [4 x i8]* @G3, i32 0, i32 2) to i32*)
Show All 31 Lines

llvm/test/Transforms/InstCombine/constant-fold-compare.ll

; 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:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
define i32 @a() nounwind readnone { define i32 @a() nounwind readnone {
entry: entry:
ret i32 zext (i1 icmp eq (i32 0, i32 ptrtoint (i32 ()* @a to i32)) to i32) ret i32 zext (i1 icmp eq (i32 0, i32 ptrtoint (i32 ()* @a to i32)) to i32)
} }
; CHECK: ret i32 0 ; CHECK: ret i32 0

llvm/test/Transforms/InstCombine/constant-fold-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:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64" target datalayout = "E-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64"
; Constant folding should fix notionally out-of-bounds indices ; Constant folding should fix notionally out-of-bounds indices
; and add inbounds keywords. ; and add inbounds keywords.
%struct.X = type { [3 x i32], [3 x i32] } %struct.X = type { [3 x i32], [3 x i32] }
@Y = internal global [3 x %struct.X] zeroinitializer @Y = internal global [3 x %struct.X] zeroinitializer
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/constant-fold-iteration.ll

; RUN: opt < %s -instcombine -S -debug 2>&1 | FileCheck %s ; RUN: opt < %s -passes=instcombine -S -debug 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
define i32 @a() nounwind readnone { define i32 @a() nounwind readnone {
entry: entry:
ret i32 zext (i1 icmp eq (i32 0, i32 ptrtoint (i32 ()* @a to i32)) to i32) ret i32 zext (i1 icmp eq (i32 0, i32 ptrtoint (i32 ()* @a to i32)) to i32)
} }
; CHECK: INSTCOMBINE ITERATION #1 ; CHECK: INSTCOMBINE ITERATION #1
; CHECK-NOT: INSTCOMBINE ITERATION #2 ; CHECK-NOT: INSTCOMBINE ITERATION #2

llvm/test/Transforms/InstCombine/constant-fold-libfunc.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare double @acos(double) willreturn declare double @acos(double) willreturn
; Check that functions without any function attributes are simplified. ; Check that functions without any function attributes are simplified.
define double @test_simplify_acos() { define double @test_simplify_acos() {
; CHECK-LABEL: @test_simplify_acos ; CHECK-LABEL: @test_simplify_acos
%pi = call double @acos(double -1.000000e+00) %pi = call double @acos(double -1.000000e+00)
Show All 22 Lines

llvm/test/Transforms/InstCombine/constant-fold-math.ll

; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare float @llvm.fma.f32(float, float, float) #0 declare float @llvm.fma.f32(float, float, float) #0
declare float @llvm.fmuladd.f32(float, float, float) #0 declare float @llvm.fmuladd.f32(float, float, float) #0
declare <4 x float> @llvm.fma.v4f32(<4 x float>, <4 x float>, <4 x float>) #0 declare <4 x float> @llvm.fma.v4f32(<4 x float>, <4 x float>, <4 x float>) #0
declare double @llvm.fma.f64(double, double, double) #0 declare double @llvm.fma.f64(double, double, double) #0
declare double @llvm.fmuladd.f64(double, double, double) #0 declare double @llvm.fmuladd.f64(double, double, double) #0
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/constant-fold-shifts.ll

; NOTE: 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 = external constant i32 @A = external constant i32
; OSS-Fuzz #14169 ; OSS-Fuzz #14169
; https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=14169 ; https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=14169
define void @ossfuzz_14169_test1(i32* %a0) { define void @ossfuzz_14169_test1(i32* %a0) {
; CHECK-LABEL: @ossfuzz_14169_test1( ; CHECK-LABEL: @ossfuzz_14169_test1(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
Show All 26 Lines

llvm/test/Transforms/InstCombine/convergent.ll

; RUN: opt -instcombine -S < %s | FileCheck -enable-var-scope %s ; RUN: opt -passes=instcombine -S < %s | FileCheck -enable-var-scope %s
declare i32 @k() convergent declare i32 @k() convergent
declare i32 @f() declare i32 @f()
declare i64 @llvm.read_register.i64(metadata) nounwind declare i64 @llvm.read_register.i64(metadata) nounwind
define i32 @extern() { define i32 @extern() {
; Convergent attr shouldn't be removed here; k is convergent. ; Convergent attr shouldn't be removed here; k is convergent.
Show All 35 Lines

llvm/test/Transforms/InstCombine/copysign.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare float @llvm.fabs.f32(float) declare float @llvm.fabs.f32(float)
declare float @llvm.copysign.f32(float, float) declare float @llvm.copysign.f32(float, float)
declare float @llvm.maxnum.f32(float, float) declare float @llvm.maxnum.f32(float, float)
declare <3 x double> @llvm.copysign.v3f64(<3 x double>, <3 x double>) declare <3 x double> @llvm.copysign.v3f64(<3 x double>, <3 x double>)
define float @positive_sign_arg(float %x) { define float @positive_sign_arg(float %x) {
; CHECK-LABEL: @positive_sign_arg( ; CHECK-LABEL: @positive_sign_arg(
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

; NOTE: 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 --check-prefixes=ANY,NO-FLOAT-SHRINK ; RUN: opt < %s -passes=instcombine -S | FileCheck %s --check-prefixes=ANY,NO-FLOAT-SHRINK
; RUN: opt < %s -instcombine -enable-double-float-shrink -S | FileCheck %s --check-prefixes=ANY,DO-FLOAT-SHRINK ; RUN: opt < %s -passes=instcombine -enable-double-float-shrink -S | FileCheck %s --check-prefixes=ANY,DO-FLOAT-SHRINK
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 double @cos(double) declare double @cos(double)
declare double @llvm.cos.f64(double) declare double @llvm.cos.f64(double)
declare float @cosf(float) declare float @cosf(float)
declare float @llvm.cos.f32(float) declare float @llvm.cos.f32(float)
▲ Show 20 Lines • Show All 379 Lines • Show Last 20 Lines

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

; 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"
declare float @cos(double) declare float @cos(double)
declare signext i8 @sqrt(...) declare signext i8 @sqrt(...)
; Check that functions with the wrong prototype aren't simplified. ; Check that functions with the wrong prototype aren't simplified.
Show All 25 Lines

llvm/test/Transforms/InstCombine/cos-sin-intrinsic.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare double @llvm.cos.f64(double %Val) declare double @llvm.cos.f64(double %Val)
declare float @llvm.cos.f32(float %Val) declare float @llvm.cos.f32(float %Val)
declare <2 x float> @llvm.cos.v2f32(<2 x float> %Val) declare <2 x float> @llvm.cos.v2f32(<2 x float> %Val)
declare float @llvm.fabs.f32(float %Val) declare float @llvm.fabs.f32(float %Val)
declare <2 x float> @llvm.fabs.v2f32(<2 x float> %Val) declare <2 x float> @llvm.fabs.v2f32(<2 x float> %Val)
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/crash.ll

; RUN: opt < %s -instcombine -S ; RUN: opt < %s -passes=instcombine -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"
target triple = "i386-apple-darwin10.0" target triple = "i386-apple-darwin10.0"
define i32 @test0(i8 %tmp2) ssp { define i32 @test0(i8 %tmp2) ssp {
entry: entry:
%tmp3 = zext i8 %tmp2 to i32 %tmp3 = zext i8 %tmp2 to i32
%tmp8 = lshr i32 %tmp3, 6 %tmp8 = lshr i32 %tmp3, 6
%tmp9 = lshr i32 %tmp3, 7 %tmp9 = lshr i32 %tmp3, 7
▲ Show 20 Lines • Show All 389 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/ctlz-cttz-bitreverse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i32 @ctlz_true_bitreverse(i32 %x) { define i32 @ctlz_true_bitreverse(i32 %x) {
; CHECK-LABEL: @ctlz_true_bitreverse( ; CHECK-LABEL: @ctlz_true_bitreverse(
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 true), !range !0 ; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 true), !range !0
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[TMP1]]
; ;
%a = tail call i32 @llvm.bitreverse.i32(i32 %x) %a = tail call i32 @llvm.bitreverse.i32(i32 %x)
%b = tail call i32 @llvm.ctlz.i32(i32 %a, i1 true) %b = tail call i32 @llvm.ctlz.i32(i32 %a, i1 true)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/ctpop-bswap-bitreverse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i32 @ctpop_bitreverse(i32 %x) { define i32 @ctpop_bitreverse(i32 %x) {
; CHECK-LABEL: @ctpop_bitreverse( ; CHECK-LABEL: @ctpop_bitreverse(
; CHECK-NEXT: [[B:%.*]] = tail call i32 @llvm.ctpop.i32(i32 [[X:%.*]]), !range !0 ; CHECK-NEXT: [[B:%.*]] = tail call i32 @llvm.ctpop.i32(i32 [[X:%.*]]), !range !0
; CHECK-NEXT: ret i32 [[B]] ; CHECK-NEXT: ret i32 [[B]]
; ;
%a = tail call i32 @llvm.bitreverse.i32(i32 %x) %a = tail call i32 @llvm.bitreverse.i32(i32 %x)
%b = tail call i32 @llvm.ctpop.i32(i32 %a) %b = tail call i32 @llvm.ctpop.i32(i32 %a)
Show All 39 Lines

llvm/test/Transforms/InstCombine/ctpop-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 < %s -S -instcombine | FileCheck %s ; RUN: opt < %s -S -passes=instcombine | FileCheck %s
declare i32 @llvm.ctpop.i32(i32) declare i32 @llvm.ctpop.i32(i32)
declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32>) declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32>)
; PR43513 ; PR43513
; __builtin_popcount(i | -i) -> 32 - __builtin_cttz(i, false) ; __builtin_popcount(i | -i) -> 32 - __builtin_cttz(i, false)
define i32 @ctpop1(i32 %0) { define i32 @ctpop1(i32 %0) {
; CHECK-LABEL: @ctpop1( ; CHECK-LABEL: @ctpop1(
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/ctpop.ll

; NOTE: 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
declare i32 @llvm.ctpop.i32(i32) declare i32 @llvm.ctpop.i32(i32)
declare i64 @llvm.ctpop.i64(i64) declare i64 @llvm.ctpop.i64(i64)
declare i8 @llvm.ctpop.i8(i8) declare i8 @llvm.ctpop.i8(i8)
declare i7 @llvm.ctpop.i7(i7) declare i7 @llvm.ctpop.i7(i7)
declare i1 @llvm.ctpop.i1(i1) declare i1 @llvm.ctpop.i1(i1)
declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32>) declare <2 x i32> @llvm.ctpop.v2i32(<2 x i32>)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
▲ Show 20 Lines • Show All 472 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cttz-abs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
define i32 @cttz_abs(i32 %x) { define i32 @cttz_abs(i32 %x) {
; CHECK-LABEL: @cttz_abs( ; CHECK-LABEL: @cttz_abs(
; CHECK-NEXT: [[R:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 true), [[RNG0:!range !.*]] ; CHECK-NEXT: [[R:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 true), [[RNG0:!range !.*]]
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
%c = icmp slt i32 %x, 0 %c = icmp slt i32 %x, 0
%s = sub i32 0, %x %s = sub i32 0, %x
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/cttz-negative.ll

; 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 @cttz_neg_value(i32 %x) { define i32 @cttz_neg_value(i32 %x) {
; CHECK-LABEL: @cttz_neg_value( ; CHECK-LABEL: @cttz_neg_value(
; CHECK-NEXT: [[B:%.*]] = call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[B:%.*]] = call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: ret i32 [[B]] ; CHECK-NEXT: ret i32 [[B]]
; ;
%a = sub i32 0, %x %a = sub i32 0, %x
%b = tail call i32 @llvm.cttz.i32(i32 %a) %b = tail call i32 @llvm.cttz.i32(i32 %a)
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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 < %s -S -instcombine | FileCheck %s ; RUN: opt < %s -S -passes=instcombine | FileCheck %s
declare i32 @llvm.cttz.i32(i32, i1) declare i32 @llvm.cttz.i32(i32, i1)
declare <2 x i64> @llvm.cttz.v2i64(<2 x i64>, i1) declare <2 x i64> @llvm.cttz.v2i64(<2 x i64>, i1)
declare void @use(i32) declare void @use(i32)
define i32 @cttz_zext_zero_undef(i16 %x) { define i32 @cttz_zext_zero_undef(i16 %x) {
; CHECK-LABEL: @cttz_zext_zero_undef( ; CHECK-LABEL: @cttz_zext_zero_undef(
; CHECK-NEXT: [[TMP1:%.*]] = call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 true), !range [[RNG0:![0-9]+]] ; CHECK-NEXT: [[TMP1:%.*]] = call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 true), !range [[RNG0:![0-9]+]]
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/dce-iterate.ll

; RUN: opt < %s -instcombine -S | grep "ret double .sy" ; RUN: opt < %s -passes=instcombine -S | grep "ret double .sy"
define internal double @ScaleObjectAdd(double %sx, double %sy, double %sz) nounwind { define internal double @ScaleObjectAdd(double %sx, double %sy, double %sz) nounwind {
entry: entry:
%sx34 = bitcast double %sx to i64 ; <i64> [#uses=1] %sx34 = bitcast double %sx to i64 ; <i64> [#uses=1]
%sx3435 = zext i64 %sx34 to i960 ; <i960> [#uses=1] %sx3435 = zext i64 %sx34 to i960 ; <i960> [#uses=1]
%sy22 = bitcast double %sy to i64 ; <i64> [#uses=1] %sy22 = bitcast double %sy to i64 ; <i64> [#uses=1]
%sy2223 = zext i64 %sy22 to i960 ; <i960> [#uses=1] %sy2223 = zext i64 %sy22 to i960 ; <i960> [#uses=1]
%sy222324 = shl i960 %sy2223, 320 ; <i960> [#uses=1] %sy222324 = shl i960 %sy2223, 320 ; <i960> [#uses=1]
Show All 15 Lines

llvm/test/Transforms/InstCombine/deadcode.ll

; RUN: opt < %s -instcombine -S | grep "ret i32 %A" ; RUN: opt < %s -passes=instcombine -S | grep "ret i32 %A"
; RUN: opt < %s -dce -S | not grep call.*llvm ; RUN: opt < %s -dce -S | not grep call.*llvm
define i32 @test(i32 %A) { define i32 @test(i32 %A) {
%X = or i1 false, false %X = or i1 false, false
br i1 %X, label %T, label %C br i1 %X, label %T, label %C
T: ; preds = %0 T: ; preds = %0
%B = add i32 %A, 1 %B = add i32 %A, 1
Show All 24 Lines

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

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
@.str = private constant [3 x i8] c"%c\00" @.str = private constant [3 x i8] c"%c\00"
define void @foo() nounwind ssp !dbg !0 { define void @foo() nounwind ssp !dbg !0 {
;CHECK: call i32 @putchar{{.+}} !dbg ;CHECK: call i32 @putchar{{.+}} !dbg
%1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i32 97), !dbg !5 %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i32 97), !dbg !5
ret void, !dbg !7 ret void, !dbg !7
Show All 17 Lines

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

; RUN: opt -instcombine %s -S -o - | FileCheck %s ; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s
; Verify that the eliminated instructions (bitcast, gep, load) are salvaged into ; Verify that the eliminated instructions (bitcast, gep, load) are salvaged into
; a DIExpression. ; a DIExpression.
; ;
; Originally created from the following C source and then heavily isolated/reduced. ; Originally created from the following C source and then heavily isolated/reduced.
; ;
; struct entry { ; struct entry {
; struct entry *next; ; struct entry *next;
; }; ; };
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

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

; RUN: opt -instcombine -S %s -o - | FileCheck %s ; RUN: opt -passes=instcombine -S %s -o - | FileCheck %s
; In this example, the cast from i8* to i32* becomes trivially dead. We should ; In this example, the cast from i8* to i32* becomes trivially dead. We should
; salvage its debug info. ; salvage its debug info.
; C source: ; C source:
; void use_as_void(void *); ; void use_as_void(void *);
; void f(void *p) { ; void f(void *p) {
; int *q = (int *)p; ; int *q = (int *)p;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/debuginfo-scalable-typesize.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; This test is defending against a TypeSize message raised in the method ; This test is defending against a TypeSize message raised in the method
; `valueCoversEntireFragment` in Local.cpp because of an implicit cast from ; `valueCoversEntireFragment` in Local.cpp because of an implicit cast from
; `TypeSize` to `uint64_t`. This particular TypeSize message only occurred when ; `TypeSize` to `uint64_t`. This particular TypeSize message only occurred when
; debug info was available. ; debug info was available.
; CHECK-LABEL: @debug_local_scalable( ; CHECK-LABEL: @debug_local_scalable(
define <vscale x 2 x double> @debug_local_scalable(<vscale x 2 x double> %tostore) { define <vscale x 2 x double> @debug_local_scalable(<vscale x 2 x double> %tostore) {
Show All 28 Lines

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

; RUN: opt %s -instcombine -S | FileCheck %s ; RUN: opt %s -passes=instcombine -S | FileCheck %s
; Test sinking of dbg.values when instcombine sinks associated instructions. ; Test sinking of dbg.values when instcombine sinks associated instructions.
declare void @llvm.dbg.value(metadata, metadata, metadata) declare void @llvm.dbg.value(metadata, metadata, metadata)
; This GEP is sunk, but can be folded into a DIExpression. Check that it ; This GEP is sunk, but can be folded into a DIExpression. Check that it
; gets folded. The dbg.value should be duplicated in the block its sunk ; gets folded. The dbg.value should be duplicated in the block its sunk
; into, to maximise liveness. ; into, to maximise liveness.
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/demand_shrink_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 -instcombine -o - -S %s | FileCheck %s ; RUN: opt -passes=instcombine -o - -S %s | FileCheck %s
; The constant at %v35 should be shrunk, but this must lead to the nsw flag of ; The constant at %v35 should be shrunk, but this must lead to the nsw flag of
; %v43 getting removed. ; %v43 getting removed.
define i32 @foo(i32 %arg) { define i32 @foo(i32 %arg) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[V33:%.*]] = and i32 [[ARG:%.*]], 223 ; CHECK-NEXT: [[V33:%.*]] = and i32 [[ARG:%.*]], 223
; CHECK-NEXT: [[V34:%.*]] = xor i32 [[V33]], 29 ; CHECK-NEXT: [[V34:%.*]] = xor i32 [[V33]], 29
Show All 23 Lines

llvm/test/Transforms/InstCombine/demorgan-sink-not-into-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
; https://bugs.llvm.org/show_bug.cgi?id=38446 ; https://bugs.llvm.org/show_bug.cgi?id=38446
; Pattern: ; Pattern:
; ~(x ^ y) ; ~(x ^ y)
; Should be transformed into: ; Should be transformed into:
; (~x) ^ y ; (~x) ^ y
; or into ; or into
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/demorgan.ll

; NOTE: 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 & B) ; (~A | ~B) == ~(A & B)
define i43 @demorgan_or_apint1(i43 %A, i43 %B) { define i43 @demorgan_or_apint1(i43 %A, i43 %B) {
; CHECK-LABEL: @demorgan_or_apint1( ; CHECK-LABEL: @demorgan_or_apint1(
; CHECK-NEXT: [[C_DEMORGAN:%.*]] = and i43 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[C_DEMORGAN:%.*]] = and i43 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[C:%.*]] = xor i43 [[C_DEMORGAN]], -1 ; CHECK-NEXT: [[C:%.*]] = xor i43 [[C_DEMORGAN]], -1
; CHECK-NEXT: ret i43 [[C]] ; CHECK-NEXT: ret i43 [[C]]
▲ Show 20 Lines • Show All 521 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

; 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
; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -instcombine -S | FileCheck %s --check-prefixes=CHECK,GNU ; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -passes=instcombine -S | FileCheck %s --check-prefixes=CHECK,GNU
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
declare noalias i8* @calloc(i64, i64) declare noalias i8* @calloc(i64, i64)
declare noalias i8* @realloc(i8* nocapture, i64) declare noalias i8* @realloc(i8* nocapture, i64)
declare noalias nonnull i8* @_Znam(i64) ; throwing version of 'new' declare noalias nonnull i8* @_Znam(i64) ; throwing version of 'new'
declare noalias nonnull i8* @_Znwm(i64) ; throwing version of 'new' declare noalias nonnull i8* @_Znwm(i64) ; throwing version of 'new'
declare noalias i8* @strdup(i8*) declare noalias i8* @strdup(i8*)
▲ Show 20 Lines • Show All 345 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/disable-builtin.ll

; Test that -disable-builtin works correctly. ; Test that -disable-builtin works correctly.
; ;
; RUN: opt < %s -instcombine -disable-builtin strcat -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -disable-builtin strcat -S | FileCheck %s
; ;
; RUN: not opt < %s -instcombine -disable-builtin foobar -S 2>&1 | FileCheck --check-prefix=FOOBAR %s ; RUN: not opt < %s -passes=instcombine -disable-builtin foobar -S 2>&1 | FileCheck --check-prefix=FOOBAR %s
; FOOBAR: cannot disable nonexistent builtin function foobar ; FOOBAR: cannot disable nonexistent builtin function foobar
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"
@empty = constant [1 x i8] c"\00", align 1 @empty = constant [1 x i8] c"\00", align 1
declare i8* @strcat(i8*, i8*) declare i8* @strcat(i8*, i8*)
define i8* @test_strcat(i8* %x) { define i8* @test_strcat(i8* %x) {
; CHECK-LABEL: @test_strcat( ; CHECK-LABEL: @test_strcat(
%empty = getelementptr [1 x i8], [1 x i8]* @empty, i32 0, i32 0 %empty = getelementptr [1 x i8], [1 x i8]* @empty, i32 0, i32 0
%ret = call i8* @strcat(i8* %x, i8* %empty) %ret = call i8* @strcat(i8* %x, i8* %empty)
ret i8* %ret ret i8* %ret
; CHECK: call i8* @strcat ; CHECK: call i8* @strcat
} }

llvm/test/Transforms/InstCombine/distribute.ll

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

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

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

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

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

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

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

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

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

llvm/test/Transforms/InstCombine/div-shift-crash.ll

; RUN: opt -instcombine < %s ; RUN: opt -passes=instcombine < %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-f128:128:128-v128:128:128-n32: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-f128:128:128-v128:128:128-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
%struct.S0.0.1.2.3.4.13.22.31.44.48.53.54.55.56.58.59.60.66.68.70.74.77.106.107.108.109.110.113.117.118.128.129 = type <{ i64 }> %struct.S0.0.1.2.3.4.13.22.31.44.48.53.54.55.56.58.59.60.66.68.70.74.77.106.107.108.109.110.113.117.118.128.129 = type <{ i64 }>
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @main() #0 { define void @main() #0 {
entry: entry:
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/div-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 i32 @t1(i16 zeroext %x, i32 %y) { define i32 @t1(i16 zeroext %x, i32 %y) {
; CHECK-LABEL: @t1( ; CHECK-LABEL: @t1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CONV:%.*]] = zext i16 [[X:%.*]] to i32 ; CHECK-NEXT: [[CONV:%.*]] = zext i16 [[X:%.*]] to i32
; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[Y:%.*]], 1 ; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[Y:%.*]], 1
; CHECK-NEXT: [[D:%.*]] = lshr i32 [[CONV]], [[TMP0]] ; CHECK-NEXT: [[D:%.*]] = lshr i32 [[CONV]], [[TMP0]]
; CHECK-NEXT: ret i32 [[D]] ; CHECK-NEXT: ret i32 [[D]]
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/div.ll

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

llvm/test/Transforms/InstCombine/dont-distribute-phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; ;
; This test ensures that InstCombine does not distribute And over Xor ; This test ensures that InstCombine does not distribute And over Xor
; using simplifications involving undef. ; using simplifications involving undef.
define zeroext i1 @foo(i32 %arg) { define zeroext i1 @foo(i32 %arg) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[ARG:%.*]], 37 ; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[ARG:%.*]], 37
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/double-float-shrink-1.ll

; RUN: opt < %s -instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,ISC99 ; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,LINUX,ISC99
; RUN: opt < %s -instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,ISC99 ; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-win32 | FileCheck %s --check-prefixes=CHECK,ISC99
; RUN: opt < %s -instcombine -S -mtriple x86_64-pc-windows-msvc16 | FileCheck %s --check-prefixes=CHECK,MS64,ISC89 ; RUN: opt < %s -passes=instcombine -S -mtriple x86_64-pc-windows-msvc16 | FileCheck %s --check-prefixes=CHECK,MS64,ISC89
; RUN: opt < %s -instcombine -S -mtriple i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,ISC99 ; RUN: opt < %s -passes=instcombine -S -mtriple i386-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,ISC99
; RUN: opt < %s -instcombine -S -mtriple i686-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MS32,ISC89 ; RUN: opt < %s -passes=instcombine -S -mtriple i686-pc-windows-msvc17 | FileCheck %s --check-prefixes=CHECK,MS32,ISC89
; Check for and against shrinkage when using the ; Check for and against shrinkage when using the
; unsafe-fp-math function attribute on a math lib ; unsafe-fp-math function attribute on a math lib
; function. This optimization may be overridden by ; function. This optimization may be overridden by
; the -enable-double-float-shrink option. ; the -enable-double-float-shrink option.
; PR17850: http://llvm.org/bugs/show_bug.cgi?id=17850 ; PR17850: http://llvm.org/bugs/show_bug.cgi?id=17850
define float @acos_test1(float %f) { define float @acos_test1(float %f) {
▲ Show 20 Lines • Show All 564 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/element-atomic-memintrins.ll

; 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
;; ---- memset ----- ;; ---- memset -----
; Ensure 0-length memset is removed ; Ensure 0-length memset is removed
define void @test_memset_zero_length(i8* %dest) { define void @test_memset_zero_length(i8* %dest) {
; CHECK-LABEL: @test_memset_zero_length( ; CHECK-LABEL: @test_memset_zero_length(
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/enforce-known-alignment.ll

; RUN: opt -instcombine -S %s | FileCheck %s ; RUN: opt -passes=instcombine -S %s | FileCheck %s
target datalayout = "e-p:32:32:32-p1:16:16:16-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-p1:16:16:16-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.6" target triple = "i386-apple-darwin9.6"
define void @foo(i32) { define void @foo(i32) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: alloca ; CHECK: alloca
; CHECK: align 16 ; CHECK: align 16
Show All 29 Lines

llvm/test/Transforms/InstCombine/eq-of-parts.ll

; NOTE: 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
; Combine equality comparisons of adjacent extracted integers parts into ; Combine equality comparisons of adjacent extracted integers parts into
; a comparison of a larger part. Start with some examples... ; a comparison of a larger part. Start with some examples...
declare void @use.i32(i32) declare void @use.i32(i32)
declare void @use.i8(i8) declare void @use.i8(i8)
declare void @use.i1(i1) declare void @use.i1(i1)
▲ Show 20 Lines • Show All 1,325 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/erase-dbg-values-at-dead-alloc-site.ll

; RUN: opt -S -instcombine %s | FileCheck %s -check-prefix=RUN-ONCE ; RUN: opt -S -passes=instcombine %s | FileCheck %s -check-prefix=RUN-ONCE
; This example was reduced from a test case in which InstCombine ran at least ; This example was reduced from a test case in which InstCombine ran at least
; twice: ; twice:
; - The first InstCombine run converted dbg.declares to dbg.values using the ; - The first InstCombine run converted dbg.declares to dbg.values using the
; LowerDbgDeclare utility. This produced a dbg.value(i32* %2, DW_OP_deref) ; LowerDbgDeclare utility. This produced a dbg.value(i32* %2, DW_OP_deref)
; (this happens when the contents of an alloca are passed by-value), and a ; (this happens when the contents of an alloca are passed by-value), and a
; dbg.value(i32 %0) (due to the store of %0 into the alloca). ; dbg.value(i32 %0) (due to the store of %0 into the alloca).
; - The second InstCombine run deleted the alloca (%2). ; - The second InstCombine run deleted the alloca (%2).
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/err-rep-cold.ll

; Test the static branch probability heuristics for error-reporting functions. ; Test the static branch probability heuristics for error-reporting functions.
; RUN: opt < %s -instcombine -S | FileCheck -enable-var-scope %s ; RUN: opt < %s -passes=instcombine -S | FileCheck -enable-var-scope %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"
%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 }
@stdout = external global %struct._IO_FILE* @stdout = external global %struct._IO_FILE*
@stderr = external global %struct._IO_FILE* @stderr = external global %struct._IO_FILE*
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/exact.ll

; NOTE: 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 @sdiv1(i32 %x) { define i32 @sdiv1(i32 %x) {
; CHECK-LABEL: @sdiv1( ; CHECK-LABEL: @sdiv1(
; CHECK-NEXT: [[Y:%.*]] = sdiv i32 [[X:%.*]], 8 ; CHECK-NEXT: [[Y:%.*]] = sdiv i32 [[X:%.*]], 8
; CHECK-NEXT: ret i32 [[Y]] ; CHECK-NEXT: ret i32 [[Y]]
; ;
%y = sdiv i32 %x, 8 %y = sdiv i32 %x, 8
ret i32 %y ret i32 %y
▲ Show 20 Lines • Show All 326 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/exp2-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 exp2 library call simplifier works correctly. ; Test that the exp2 library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S -mtriple=unknown | FileCheck %s -check-prefixes=LDEXP32 ; RUN: opt < %s -passes=instcombine -S -mtriple=unknown | FileCheck %s -check-prefixes=LDEXP32
; RUN: opt < %s -instcombine -S -mtriple=msp430 | FileCheck %s -check-prefixes=LDEXP16 ; RUN: opt < %s -passes=instcombine -S -mtriple=msp430 | FileCheck %s -check-prefixes=LDEXP16
; RUN: opt < %s -instcombine -S -mtriple=i386-pc-win32 | FileCheck %s -check-prefixes=NOLDEXPF ; RUN: opt < %s -passes=instcombine -S -mtriple=i386-pc-win32 | FileCheck %s -check-prefixes=NOLDEXPF
; RUN: opt < %s -instcombine -S -mtriple=amdgcn-unknown-unknown | FileCheck %s -check-prefixes=NOLDEXP ; RUN: opt < %s -passes=instcombine -S -mtriple=amdgcn-unknown-unknown | FileCheck %s -check-prefixes=NOLDEXP
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 double @exp2(double) declare double @exp2(double)
declare float @exp2f(float) declare float @exp2f(float)
; Check exp2(sitofp(x)) -> ldexp(1.0, sext(x)). ; Check exp2(sitofp(x)) -> ldexp(1.0, sext(x)).
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

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

; Test that the exp2 library call simplifier works correctly. ; Test that the exp2 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 float @exp2(double) declare float @exp2(double)
; Check that exp2 functions with the wrong prototype aren't simplified. ; Check that exp2 functions with the wrong prototype aren't simplified.
define float @test_no_simplify1(i32 %x) { define float @test_no_simplify1(i32 %x) {
; CHECK-LABEL: @test_no_simplify1( ; CHECK-LABEL: @test_no_simplify1(
%conv = sitofp i32 %x to double %conv = sitofp i32 %x to double
%ret = call float @exp2(double %conv) %ret = call float @exp2(double %conv)
; CHECK: call float @exp2(double %conv) ; CHECK: call float @exp2(double %conv)
ret float %ret ret float %ret
} }

llvm/test/Transforms/InstCombine/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 @extractelement_out_of_range(<2 x i32> %x) { define i32 @extractelement_out_of_range(<2 x i32> %x) {
; ANY-LABEL: @extractelement_out_of_range( ; ANY-LABEL: @extractelement_out_of_range(
; ANY-NEXT: ret i32 poison ; ANY-NEXT: ret i32 poison
; ;
%E1 = extractelement <2 x i32> %x, i8 16 %E1 = extractelement <2 x i32> %x, i8 16
ret i32 %E1 ret i32 %E1
} }
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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-n64" | FileCheck %s --check-prefixes=ANY,LE ; RUN: opt < %s -passes=instcombine -S -data-layout="e-n64" | FileCheck %s --check-prefixes=ANY,LE
; RUN: opt < %s -instcombine -S -data-layout="E-n64" | FileCheck %s --check-prefixes=ANY,BE ; RUN: opt < %s -passes=instcombine -S -data-layout="E-n64" | FileCheck %s --check-prefixes=ANY,BE
define i32 @extractelement_out_of_range(<2 x i32> %x) { define i32 @extractelement_out_of_range(<2 x i32> %x) {
; ANY-LABEL: @extractelement_out_of_range( ; ANY-LABEL: @extractelement_out_of_range(
; ANY-NEXT: ret i32 poison ; ANY-NEXT: ret i32 poison
; ;
%E1 = extractelement <2 x i32> %x, i8 16 %E1 = extractelement <2 x i32> %x, i8 16
ret i32 %E1 ret i32 %E1
} }
▲ Show 20 Lines • Show All 444 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/extractinsert-tbaa.ll

; RUN: opt -S -instcombine %s -o - | FileCheck %s ; RUN: opt -S -passes=instcombine %s -o - | FileCheck %s
%Complex = type { double, double } %Complex = type { double, double }
; Check that instcombine preserves TBAA when narrowing loads ; Check that instcombine preserves TBAA when narrowing loads
define double @teststructextract(%Complex *%val) { define double @teststructextract(%Complex *%val) {
; CHECK: load double, {{.*}}, !tbaa ; CHECK: load double, {{.*}}, !tbaa
; CHECK-NOT: load %Complex ; CHECK-NOT: load %Complex
%loaded = load %Complex, %Complex *%val, !tbaa !1 %loaded = load %Complex, %Complex *%val, !tbaa !1
Show All 36 Lines

llvm/test/Transforms/InstCombine/extractvalue.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @bar({i32, i32} %a) declare void @bar({i32, i32} %a)
declare i32 @baz(i32 %a) declare i32 @baz(i32 %a)
; CHECK-LABEL: define i32 @foo( ; CHECK-LABEL: define i32 @foo(
; CHECK-NOT: extractvalue ; CHECK-NOT: extractvalue
define i32 @foo(i32 %a, i32 %b) { define i32 @foo(i32 %a, i32 %b) {
; Instcombine should fold various combinations of insertvalue and extractvalue ; Instcombine should fold various combinations of insertvalue and extractvalue
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fabs-copysign.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
declare double @llvm.fabs.f64(double) declare double @llvm.fabs.f64(double)
declare float @llvm.fabs.f32(float) declare float @llvm.fabs.f32(float)
declare <4 x double> @llvm.fabs.v4f64(<4 x double>) declare <4 x double> @llvm.fabs.v4f64(<4 x double>)
declare void @use(double) declare void @use(double)
declare double @llvm.copysign.f64(double, double) declare double @llvm.copysign.f64(double, double)
declare float @llvm.copysign.f32(float, float) declare float @llvm.copysign.f32(float, float)
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fabs-libcall.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -mtriple=i686-apple-macosx -instcombine %s | FileCheck %s ; RUN: opt -S -mtriple=i686-apple-macosx -passes=instcombine %s | FileCheck %s
declare x86_fp80 @fabsl(x86_fp80) declare x86_fp80 @fabsl(x86_fp80)
define x86_fp80 @replace_fabs_call_f80(x86_fp80 %x) { define x86_fp80 @replace_fabs_call_f80(x86_fp80 %x) {
; CHECK-LABEL: @replace_fabs_call_f80( ; CHECK-LABEL: @replace_fabs_call_f80(
; CHECK-NEXT: [[FABSL:%.*]] = tail call x86_fp80 @llvm.fabs.f80(x86_fp80 [[X:%.*]]) ; CHECK-NEXT: [[FABSL:%.*]] = tail call x86_fp80 @llvm.fabs.f80(x86_fp80 [[X:%.*]])
; CHECK-NEXT: ret x86_fp80 [[FABSL]] ; CHECK-NEXT: ret x86_fp80 [[FABSL]]
; ;
Show All 13 Lines

llvm/test/Transforms/InstCombine/fabs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -instcombine -S | FileCheck %s ; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -passes=instcombine -S | FileCheck %s
; Make sure libcalls are replaced with intrinsic calls. ; Make sure libcalls are replaced with intrinsic calls.
declare float @llvm.fabs.f32(float) declare float @llvm.fabs.f32(float)
declare <2 x float> @llvm.fabs.v2f32(<2 x float>) declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
declare double @llvm.fabs.f64(double) declare double @llvm.fabs.f64(double)
declare fp128 @llvm.fabs.f128(fp128) declare fp128 @llvm.fabs.f128(fp128)
▲ Show 20 Lines • Show All 967 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fadd-fsub-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
; ========================================================================= ; =========================================================================
; ;
; Test FP factorization with patterns: ; Test FP factorization with patterns:
; X * Z + Y * Z --> (X + Y) * Z (including all 4 commuted variants) ; X * Z + Y * Z --> (X + Y) * Z (including all 4 commuted variants)
; X * Z - Y * Z --> (X - Y) * Z (including all 4 commuted variants) ; X * Z - Y * Z --> (X - Y) * Z (including all 4 commuted variants)
; X / Z + Y / Z --> (X + Y) / Z ; X / Z + Y / Z --> (X + Y) / Z
; X / Z - Y / Z --> (X - Y) / Z ; X / Z - Y / Z --> (X - Y) / Z
▲ Show 20 Lines • Show All 625 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fadd.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(float) declare void @use(float)
declare void @use_vec(<2 x float>) declare void @use_vec(<2 x float>)
declare float @llvm.vector.reduce.fadd.v4f32(float, <4 x float>) declare float @llvm.vector.reduce.fadd.v4f32(float, <4 x float>)
; -x + y => y - x ; -x + y => y - x
define float @fneg_op0(float %x, float %y) { define float @fneg_op0(float %x, float %y) {
▲ Show 20 Lines • Show All 519 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; testing-case "float fold(float a) { return 1.2f * a * 2.3f; }" ; testing-case "float fold(float a) { return 1.2f * a * 2.3f; }"
; 1.2f and 2.3f is supposed to be fold. ; 1.2f and 2.3f is supposed to be fold.
define float @fold(float %a) { define float @fold(float %a) {
; CHECK-LABEL: @fold( ; CHECK-LABEL: @fold(
; CHECK-NEXT: [[MUL1:%.*]] = fmul fast float [[A:%.*]], 0x4006147AE0000000 ; CHECK-NEXT: [[MUL1:%.*]] = fmul fast float [[A:%.*]], 0x4006147AE0000000
; CHECK-NEXT: ret float [[MUL1]] ; CHECK-NEXT: ret float [[MUL1]]
; ;
▲ Show 20 Lines • Show All 928 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/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
declare void @use(i1) declare void @use(i1)
; X == 42.0 ? X : 42.0 --> 42.0 ; X == 42.0 ? X : 42.0 --> 42.0
define double @oeq(double %x) { define double @oeq(double %x) {
; CHECK-LABEL: @oeq( ; CHECK-LABEL: @oeq(
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[X:%.*]], 4.200000e+01 ; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[X:%.*]], 4.200000e+01
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fcmp-special.ll

; NOTE: 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 @oeq_self(double %arg) { define i1 @oeq_self(double %arg) {
; CHECK-LABEL: @oeq_self( ; CHECK-LABEL: @oeq_self(
; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[ARG:%.*]], 0.000000e+00 ; CHECK-NEXT: [[TMP:%.*]] = fcmp ord double [[ARG:%.*]], 0.000000e+00
; CHECK-NEXT: ret i1 [[TMP]] ; CHECK-NEXT: ret i1 [[TMP]]
; ;
%tmp = fcmp oeq double %arg, %arg %tmp = fcmp oeq double %arg, %arg
ret i1 %tmp ret i1 %tmp
▲ Show 20 Lines • Show All 234 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fcmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare half @llvm.fabs.f16(half) declare half @llvm.fabs.f16(half)
declare double @llvm.fabs.f64(double) declare double @llvm.fabs.f64(double)
declare <2 x float> @llvm.fabs.v2f32(<2 x float>) declare <2 x float> @llvm.fabs.v2f32(<2 x float>)
declare double @llvm.copysign.f64(double, double) declare double @llvm.copysign.f64(double, double)
declare <2 x double> @llvm.copysign.v2f64(<2 x double>, <2 x double>) declare <2 x double> @llvm.copysign.v2f64(<2 x double>, <2 x double>)
define i1 @fpext_fpext(float %x, float %y) { define i1 @fpext_fpext(float %x, float %y) {
▲ Show 20 Lines • Show All 663 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fdiv-cos-sin.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define double @fdiv_cos_sin(double %a) { define double @fdiv_cos_sin(double %a) {
; CHECK-LABEL: @fdiv_cos_sin( ; CHECK-LABEL: @fdiv_cos_sin(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.cos.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.cos.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.sin.f64(double [[A]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.sin.f64(double [[A]])
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[TMP1]], [[TMP2]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[TMP1]], [[TMP2]]
; CHECK-NEXT: ret double [[DIV]] ; CHECK-NEXT: ret double [[DIV]]
; ;
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fdiv-sin-cos.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
define double @fdiv_sin_cos(double %a) { define double @fdiv_sin_cos(double %a) {
; CHECK-LABEL: @fdiv_sin_cos( ; CHECK-LABEL: @fdiv_sin_cos(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.sin.f64(double [[A:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.sin.f64(double [[A:%.*]])
; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.cos.f64(double [[A]]) ; CHECK-NEXT: [[TMP2:%.*]] = call double @llvm.cos.f64(double [[A]])
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[TMP1]], [[TMP2]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[TMP1]], [[TMP2]]
; CHECK-NEXT: ret double [[DIV]] ; CHECK-NEXT: ret double [[DIV]]
; ;
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fdiv.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare float @llvm.fabs.f32(float) nounwind readnone declare float @llvm.fabs.f32(float) nounwind readnone
declare float @llvm.pow.f32(float, float) nounwind readnone declare float @llvm.pow.f32(float, float) nounwind readnone
declare <2 x half> @llvm.pow.v2f16(<2 x half>, <2 x half>) nounwind readnone declare <2 x half> @llvm.pow.v2f16(<2 x half>, <2 x half>) nounwind readnone
declare float @llvm.exp.f32(float) nounwind readnone declare float @llvm.exp.f32(float) nounwind readnone
declare <2 x half> @llvm.exp.v2f16(<2 x half>) nounwind readnone declare <2 x half> @llvm.exp.v2f16(<2 x half>) nounwind readnone
declare float @llvm.exp2.f32(float) nounwind readnone declare float @llvm.exp2.f32(float) nounwind readnone
declare <2 x half> @llvm.exp2.v2f16(<2 x half>) nounwind readnone declare <2 x half> @llvm.exp2.v2f16(<2 x half>) nounwind readnone
▲ Show 20 Lines • Show All 929 Lines • Show Last 20 Lines

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

; Test that the ffs* library call simplifier works correctly. ; Test that the ffs* library call simplifier works correctly.
; ;
; RUN: opt < %s -instcombine -S | FileCheck %s --check-prefix=ALL --check-prefix=GENERIC ; RUN: opt < %s -passes=instcombine -S | FileCheck %s --check-prefix=ALL --check-prefix=GENERIC
; RUN: opt < %s -instcombine -mtriple i386-pc-linux -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET ; RUN: opt < %s -passes=instcombine -mtriple i386-pc-linux -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET
; RUN: opt < %s -instcombine -mtriple=arm64-apple-ios9.0 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET ; RUN: opt < %s -passes=instcombine -mtriple=arm64-apple-ios9.0 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET
; RUN: opt < %s -instcombine -mtriple=arm64-apple-tvos9.0 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET ; RUN: opt < %s -passes=instcombine -mtriple=arm64-apple-tvos9.0 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET
; RUN: opt < %s -instcombine -mtriple=thumbv7k-apple-watchos2.0 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET ; RUN: opt < %s -passes=instcombine -mtriple=thumbv7k-apple-watchos2.0 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET
; RUN: opt < %s -instcombine -mtriple=x86_64-apple-macosx10.11 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET ; RUN: opt < %s -passes=instcombine -mtriple=x86_64-apple-macosx10.11 -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET
; RUN: opt < %s -instcombine -mtriple=x86_64-freebsd-gnu -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET ; RUN: opt < %s -passes=instcombine -mtriple=x86_64-freebsd-gnu -S | FileCheck %s --check-prefix=ALL --check-prefix=TARGET
declare i32 @ffs(i32) declare i32 @ffs(i32)
declare i32 @ffsl(i32) declare i32 @ffsl(i32)
declare i32 @ffsll(i64) declare i32 @ffsll(i64)
; Check ffs(0) -> 0. ; Check ffs(0) -> 0.
define i32 @test_simplify1() { define i32 @test_simplify1() {
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/float-shrink-compare.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -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-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define i1 @test1(float %x, float %y) { define i1 @test1(float %x, float %y) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[CEIL:%.*]] = call float @llvm.ceil.f32(float %x) ; CHECK-NEXT: [[CEIL:%.*]] = call float @llvm.ceil.f32(float %x)
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[CEIL]], %y ; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[CEIL]], %y
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
▲ Show 20 Lines • Show All 518 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fls.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target triple = "x86_64-unknown-freebsd11.0" target triple = "x86_64-unknown-freebsd11.0"
define i32 @myfls() { define i32 @myfls() {
; CHECK-LABEL: @myfls( ; CHECK-LABEL: @myfls(
; CHECK-NEXT: ret i32 6 ; CHECK-NEXT: ret i32 6
; ;
%call = call i32 @fls(i32 42) %call = call i32 @fls(i32 42)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fma.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S -instcombine < %s | FileCheck %s ; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare float @llvm.fma.f32(float, float, float) #1 declare float @llvm.fma.f32(float, float, float) #1
declare <2 x float> @llvm.fma.v2f32(<2 x float>, <2 x float>, <2 x float>) #1 declare <2 x float> @llvm.fma.v2f32(<2 x float>, <2 x float>, <2 x float>) #1
declare <8 x half> @llvm.fma.v8f16(<8 x half>, <8 x half>, <8 x half>) #1 declare <8 x half> @llvm.fma.v8f16(<8 x half>, <8 x half>, <8 x half>) #1
declare float @llvm.fmuladd.f32(float, float, float) #1 declare float @llvm.fmuladd.f32(float, float, float) #1
declare float @llvm.fabs.f32(float) #1 declare float @llvm.fabs.f32(float) #1
@external = external global i32 @external = external global i32
▲ Show 20 Lines • Show All 792 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fmul-exp.ll

; NOTE: 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 double @llvm.exp.f64(double) nounwind readnone speculatable declare double @llvm.exp.f64(double) nounwind readnone speculatable
declare void @use(double) declare void @use(double)
; exp(a) * exp(b) no reassoc flags ; exp(a) * exp(b) no reassoc flags
define double @exp_a_exp_b(double %a, double %b) { define double @exp_a_exp_b(double %a, double %b) {
; CHECK-LABEL: @exp_a_exp_b( ; CHECK-LABEL: @exp_a_exp_b(
; CHECK-NEXT: [[T:%.*]] = call double @llvm.exp.f64(double [[A:%.*]]) ; CHECK-NEXT: [[T:%.*]] = call double @llvm.exp.f64(double [[A:%.*]])
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fmul-exp2.ll

; NOTE: 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 double @llvm.exp2.f64(double) nounwind readnone speculatable declare double @llvm.exp2.f64(double) nounwind readnone speculatable
declare void @use(double) declare void @use(double)
; exp2(a) * exp2(b) no reassoc flags ; exp2(a) * exp2(b) no reassoc flags
define double @exp2_a_exp2_b(double %a, double %b) { define double @exp2_a_exp2_b(double %a, double %b) {
; CHECK-LABEL: @exp2_a_exp2_b( ; CHECK-LABEL: @exp2_a_exp2_b(
; CHECK-NEXT: [[T:%.*]] = call double @llvm.exp2.f64(double [[A:%.*]]) ; CHECK-NEXT: [[T:%.*]] = call double @llvm.exp2.f64(double [[A:%.*]])
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fmul-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
; A copy of fmul.ll, with undef at insertelement/shufflevector replaced with ; A copy of fmul.ll, with undef at insertelement/shufflevector replaced with
; poison ; poison
; Don't crash when attempting to cast a constant FMul to an instruction. ; Don't crash when attempting to cast a constant FMul to an instruction.
define void @test8(i32* %inout) { define void @test8(i32* %inout) {
; CHECK-LABEL: @test8( ; CHECK-LABEL: @test8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fmul-pow.ll

; NOTE: 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 double @llvm.pow.f64(double, double) declare double @llvm.pow.f64(double, double)
declare void @use(double) declare void @use(double)
define double @pow_ab_a(double %a, double %b) { define double @pow_ab_a(double %a, double %b) {
; CHECK-LABEL: @pow_ab_a( ; CHECK-LABEL: @pow_ab_a(
; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.pow.f64(double [[A:%.*]], double [[B:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call double @llvm.pow.f64(double [[A:%.*]], double [[B:%.*]])
; CHECK-NEXT: [[MUL:%.*]] = fmul double [[TMP1]], [[A]] ; CHECK-NEXT: [[MUL:%.*]] = fmul double [[TMP1]], [[A]]
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fmul-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
declare double @llvm.sqrt.f64(double) nounwind readnone speculatable declare double @llvm.sqrt.f64(double) nounwind readnone speculatable
declare <2 x float> @llvm.sqrt.v2f32(<2 x float>) declare <2 x float> @llvm.sqrt.v2f32(<2 x float>)
declare void @use(double) declare void @use(double)
; sqrt(a) * sqrt(b) no math flags ; sqrt(a) * sqrt(b) no math flags
define double @sqrt_a_sqrt_b(double %a, double %b) { define double @sqrt_a_sqrt_b(double %a, double %b) {
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fmul.ll

; NOTE: 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
; (-0.0 - X) * C => X * -C ; (-0.0 - X) * C => X * -C
define float @neg_constant(float %x) { define float @neg_constant(float %x) {
; CHECK-LABEL: @neg_constant( ; CHECK-LABEL: @neg_constant(
; CHECK-NEXT: [[MUL:%.*]] = fmul ninf float [[X:%.*]], -2.000000e+01 ; CHECK-NEXT: [[MUL:%.*]] = fmul ninf float [[X:%.*]], -2.000000e+01
; CHECK-NEXT: ret float [[MUL]] ; CHECK-NEXT: ret float [[MUL]]
; ;
%sub = fsub float -0.0, %x %sub = fsub float -0.0, %x
▲ Show 20 Lines • Show All 1,190 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fneg-fabs.ll

; NOTE: 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 < +/-0.0) ? X : -X --> -fabs(X) ; (X < +/-0.0) ? X : -X --> -fabs(X)
; (X <= +/-0.0) ? X : -X --> -fabs(X) ; (X <= +/-0.0) ? X : -X --> -fabs(X)
; One negative test with no fmf ; One negative test with no fmf
define double @select_noFMF_nfabs_lt(double %x) { define double @select_noFMF_nfabs_lt(double %x) {
; CHECK-LABEL: @select_noFMF_nfabs_lt( ; CHECK-LABEL: @select_noFMF_nfabs_lt(
; CHECK-NEXT: [[CMP:%.*]] = fcmp olt double [[X:%.*]], 0.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp olt double [[X:%.*]], 0.000000e+00
; CHECK-NEXT: [[NEGX:%.*]] = fneg double [[X]] ; CHECK-NEXT: [[NEGX:%.*]] = fneg double [[X]]
▲ Show 20 Lines • Show All 228 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fneg.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare void @use(float) declare void @use(float)
define float @fneg_fneg(float %a) { define float @fneg_fneg(float %a) {
; ;
; CHECK-LABEL: @fneg_fneg( ; CHECK-LABEL: @fneg_fneg(
; CHECK-NEXT: ret float [[A:%.*]] ; CHECK-NEXT: ret float [[A:%.*]]
; ;
▲ Show 20 Lines • Show All 709 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fold-bin-operand.ll

; NOTE: 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-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
define i1 @f(i1 %x) { define i1 @f(i1 %x) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%b = and i1 %x, icmp eq (i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 2 to i8*)) %b = and i1 %x, icmp eq (i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 2 to i8*))
ret i1 %b ret i1 %b
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; This shouldn't fold, because sin(inf) is invalid. ; This shouldn't fold, because sin(inf) is invalid.
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: %t = call double @sin(double 0x7FF0000000000000) ; CHECK: %t = call double @sin(double 0x7FF0000000000000)
define double @foo() { define double @foo() {
%t = call double @sin(double 0x7FF0000000000000) %t = call double @sin(double 0x7FF0000000000000)
ret double %t ret double %t
} }
Show All 10 Lines

llvm/test/Transforms/InstCombine/fold-fops-into-selects.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define float @test1(i1 %A) { define float @test1(i1 %A) {
EntryBlock: EntryBlock:
%cf = select i1 %A, float 1.000000e+00, float 0.000000e+00 %cf = select i1 %A, float 1.000000e+00, float 0.000000e+00
%op = fsub float 1.000000e+00, %cf %op = fsub float 1.000000e+00, %cf
ret float %op ret float %op
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: select i1 %A, float 0.000000e+00, float 1.000000e+00 ; CHECK: select i1 %A, float 0.000000e+00, float 1.000000e+00
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fold-inc-of-add-of-not-x-and-y-to-sub-x-from-y.ll

; 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
; Given: ; Given:
; add (add (xor %x, -1), %y), 1 ; add (add (xor %x, -1), %y), 1
; Transform it to: ; Transform it to:
; sub %y, %x ; sub %y, %x
;------------------------------------------------------------------------------; ;------------------------------------------------------------------------------;
; Scalar tests ; Scalar tests
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fold-phi-load-metadata.ll

; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
@g1 = common global i32* null, align 8 @g1 = common global i32* null, align 8
%struct.S1 = type { i32, float } %struct.S1 = type { i32, float }
%struct.S2 = type { float, i32 } %struct.S2 = type { float, i32 }
; Check that instcombine preserves metadata when it merges two loads. ; Check that instcombine preserves metadata when it merges two loads.
; ;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; CHECK: no_crash ; CHECK: no_crash
define float @no_crash(float %a) nounwind { define float @no_crash(float %a) nounwind {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
%sum.057 = phi float [ 0.000000e+00, %entry ], [ %add5, %bb0 ] %sum.057 = phi float [ 0.000000e+00, %entry ], [ %add5, %bb0 ]
Show All 30 Lines

llvm/test/Transforms/InstCombine/fold-sqrt-sqrtf.ll

; RUN: opt -instcombine -S -disable-simplify-libcalls < %s | FileCheck %s ; RUN: opt -passes=instcombine -S -disable-simplify-libcalls < %s | FileCheck %s
; rdar://10466410 ; rdar://10466410
; Instcombine tries to fold (fptrunc (sqrt (fpext x))) -> (sqrtf x), but this ; Instcombine tries to fold (fptrunc (sqrt (fpext x))) -> (sqrtf x), but this
; shouldn't fold when sqrtf isn't available. ; shouldn't fold when sqrtf isn't available.
define float @foo(float %f) uwtable ssp { define float @foo(float %f) uwtable ssp {
entry: entry:
; CHECK: %conv = fpext float %f to double ; CHECK: %conv = fpext float %f to double
; CHECK: %call = tail call double @sqrt(double %conv) ; CHECK: %call = tail call double @sqrt(double %conv)
; CHECK: %conv1 = fptrunc double %call to float ; CHECK: %conv1 = fptrunc double %call to float
%conv = fpext float %f to double %conv = fpext float %f to double
%call = tail call double @sqrt(double %conv) %call = tail call double @sqrt(double %conv)
%conv1 = fptrunc double %call to float %conv1 = fptrunc double %call to float
ret float %conv1 ret float %conv1
} }
declare double @sqrt(double) declare double @sqrt(double)

llvm/test/Transforms/InstCombine/fold-sub-of-not-to-inc-of-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 -instcombine -S < %s | FileCheck %s ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
; Given: ; Given:
; sub %y, (xor %x, -1) ; sub %y, (xor %x, -1)
; Transform it to: ; Transform it to:
; add (add %x, 1), %y ; add (add %x, 1), %y
; We prefer this form because that is what -reassociate would produce. ; We prefer this form because that is what -reassociate would produce.
;------------------------------------------------------------------------------; ;------------------------------------------------------------------------------;
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fold-vector-select.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; CHECK-NOT: select ; CHECK-NOT: select
define void @foo(<4 x i32> *%A, <4 x i32> *%B, <4 x i32> *%C, <4 x i32> *%D, define void @foo(<4 x i32> *%A, <4 x i32> *%B, <4 x i32> *%C, <4 x i32> *%D,
<4 x i32> *%E, <4 x i32> *%F, <4 x i32> *%G, <4 x i32> *%H, <4 x i32> *%E, <4 x i32> *%F, <4 x i32> *%G, <4 x i32> *%H,
<4 x i32> *%I, <4 x i32> *%J, <4 x i32> *%K, <4 x i32> *%L, <4 x i32> *%I, <4 x i32> *%J, <4 x i32> *%K, <4 x i32> *%L,
<4 x i32> *%M, <4 x i32> *%N, <4 x i32> *%O, <4 x i32> *%P, <4 x i32> *%M, <4 x i32> *%N, <4 x i32> *%O, <4 x i32> *%P,
<4 x i32> *%Q, <4 x i32> *%R, <4 x i32> *%S, <4 x i32> *%T, <4 x i32> *%Q, <4 x i32> *%R, <4 x i32> *%S, <4 x i32> *%T,
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fold-vector-zero-inseltpoison.ll

; RUN: opt < %s -instcombine -S | not grep zeroinitializer ; RUN: opt < %s -passes=instcombine -S | not grep zeroinitializer
define void @foo(i64 %A, i64 %B) { define void @foo(i64 %A, i64 %B) {
bb8: bb8:
br label %bb30 br label %bb30
bb30: bb30:
%s0 = phi i64 [ 0, %bb8 ], [ %r21, %bb30 ] %s0 = phi i64 [ 0, %bb8 ], [ %r21, %bb30 ]
%l0 = phi i64 [ -2222, %bb8 ], [ %r23, %bb30 ] %l0 = phi i64 [ -2222, %bb8 ], [ %r23, %bb30 ]
Show All 26 Lines

llvm/test/Transforms/InstCombine/fold-vector-zero.ll

; RUN: opt < %s -instcombine -S | not grep zeroinitializer ; RUN: opt < %s -passes=instcombine -S | not grep zeroinitializer
define void @foo(i64 %A, i64 %B) { define void @foo(i64 %A, i64 %B) {
bb8: bb8:
br label %bb30 br label %bb30
bb30: bb30:
%s0 = phi i64 [ 0, %bb8 ], [ %r21, %bb30 ] %s0 = phi i64 [ 0, %bb8 ], [ %r21, %bb30 ]
%l0 = phi i64 [ -2222, %bb8 ], [ %r23, %bb30 ] %l0 = phi i64 [ -2222, %bb8 ], [ %r23, %bb30 ]
Show All 26 Lines

llvm/test/Transforms/InstCombine/fortify-folding.ll

; NOTE: 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"
@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"
%struct.__va_list_tag = type { i32, i32, i8*, i8* } %struct.__va_list_tag = type { i32, i32, i8*, i8* }
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fp-ret-bitcast.ll

; RUN: opt < %s -instcombine -S | \ ; RUN: opt < %s -passes=instcombine -S | \
; RUN: grep "call float bitcast" | count 1 ; RUN: grep "call float bitcast" | count 1
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
%struct.NSObject = type { %struct.objc_class* } %struct.NSObject = type { %struct.objc_class* }
%struct.NSArray = type { %struct.NSObject } %struct.NSArray = type { %struct.NSObject }
%struct.objc_class = type opaque %struct.objc_class = type opaque
%struct.objc_selector = type opaque %struct.objc_selector = type opaque
@"\01L_OBJC_METH_VAR_NAME_112" = internal global [15 x i8] c"whiteComponent\00", section "__TEXT,__cstring,cstring_literals" @"\01L_OBJC_METH_VAR_NAME_112" = internal global [15 x i8] c"whiteComponent\00", section "__TEXT,__cstring,cstring_literals"
Show All 19 Lines

llvm/test/Transforms/InstCombine/fpcast.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Test some floating point casting cases ; Test some floating point casting cases
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i8 @test1() { define i8 @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: ret i8 -1 ; CHECK-NEXT: ret i8 -1
; ;
%x = fptoui float 2.550000e+02 to i8 %x = fptoui float 2.550000e+02 to i8
ret i8 %x ret i8 %x
} }
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fpextend.ll

; NOTE: 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 @test(float %x) nounwind { define float @test(float %x) nounwind {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: [[T34:%.*]] = fadd float [[X:%.*]], 0.000000e+00 ; CHECK-NEXT: [[T34:%.*]] = fadd float [[X:%.*]], 0.000000e+00
; CHECK-NEXT: ret float [[T34]] ; CHECK-NEXT: ret float [[T34]]
; ;
%t1 = fpext float %x to double %t1 = fpext float %x to double
%t3 = fadd double %t1, 0.000000e+00 %t3 = fadd double %t1, 0.000000e+00
▲ Show 20 Lines • Show All 421 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fpextend_x86.ll

; RUN: opt < %s -instcombine -mtriple=x86_64-apple-macosx -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -mtriple=x86_64-apple-macosx -S | FileCheck %s
target triple = "x86_64-apple-macosx" target triple = "x86_64-apple-macosx"
define double @test1(double %a, double %b) nounwind { define double @test1(double %a, double %b) nounwind {
%wa = fpext double %a to x86_fp80 %wa = fpext double %a to x86_fp80
%wb = fpext double %b to x86_fp80 %wb = fpext double %b to x86_fp80
%wr = fadd x86_fp80 %wa, %wb %wr = fadd x86_fp80 %wa, %wb
%r = fptrunc x86_fp80 %wr to double %r = fptrunc x86_fp80 %wr to double
ret double %r ret double %r
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; Test that the fprintf library call simplifier works correctly. ; Test that the fprintf 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-prefix=CHECK-IPRINTF ; RUN: opt < %s -mtriple xcore-xmos-elf -passes=instcombine -S | FileCheck %s -check-prefix=CHECK-IPRINTF
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"
%FILE = type { } %FILE = type { }
@hello_world = constant [13 x i8] c"hello world\0A\00" @hello_world = constant [13 x i8] c"hello world\0A\00"
@percent_c = constant [3 x i8] c"%c\00" @percent_c = constant [3 x i8] c"%c\00"
@percent_d = constant [3 x i8] c"%d\00" @percent_d = constant [3 x i8] c"%d\00"
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fptrunc.ll

; NOTE: 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 @fadd_fpext_op0(float %x, double %y) { define float @fadd_fpext_op0(float %x, double %y) {
; CHECK-LABEL: @fadd_fpext_op0( ; CHECK-LABEL: @fadd_fpext_op0(
; CHECK-NEXT: [[EXT:%.*]] = fpext float [[X:%.*]] to double ; CHECK-NEXT: [[EXT:%.*]] = fpext float [[X:%.*]] to double
; CHECK-NEXT: [[BO:%.*]] = fadd reassoc double [[EXT]], [[Y:%.*]] ; CHECK-NEXT: [[BO:%.*]] = fadd reassoc double [[EXT]], [[Y:%.*]]
; CHECK-NEXT: [[R:%.*]] = fptrunc double [[BO]] to float ; CHECK-NEXT: [[R:%.*]] = fptrunc double [[BO]] to float
; CHECK-NEXT: ret float [[R]] ; CHECK-NEXT: ret float [[R]]
; ;
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

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

; Test that the fputs library call simplifier works correctly. ; Test that the fputs 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"
%FILE = type { } %FILE = type { }
@empty = constant [1 x i8] zeroinitializer @empty = constant [1 x i8] zeroinitializer
@A = constant [2 x i8] c"A\00" @A = constant [2 x i8] c"A\00"
@hello = constant [7 x i8] c"hello\0A\00" @hello = constant [7 x i8] c"hello\0A\00"
Show All 32 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
define i32 @const(i1 %cond) { define i32 @const(i1 %cond) {
; CHECK-LABEL: @const( ; CHECK-LABEL: @const(
; CHECK-NEXT: br i1 [[COND:%.*]], label [[A:%.*]], label [[B:%.*]] ; CHECK-NEXT: br i1 [[COND:%.*]], label [[A:%.*]], label [[B:%.*]]
; CHECK: A: ; CHECK: A:
; CHECK-NEXT: br label [[C:%.*]] ; CHECK-NEXT: br label [[C:%.*]]
; CHECK: B: ; CHECK: B:
; CHECK-NEXT: br label [[C]] ; CHECK-NEXT: br label [[C]]
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/freeze.ll

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

llvm/test/Transforms/InstCombine/fsh.ll

; NOTE: 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 i32 @llvm.fshl.i32(i32, i32, i32) declare i32 @llvm.fshl.i32(i32, i32, i32)
declare i33 @llvm.fshr.i33(i33, i33, i33) declare i33 @llvm.fshr.i33(i33, i33, i33)
declare <2 x i32> @llvm.fshr.v2i32(<2 x i32>, <2 x i32>, <2 x i32>) declare <2 x i32> @llvm.fshr.v2i32(<2 x i32>, <2 x i32>, <2 x i32>)
declare <2 x i31> @llvm.fshl.v2i31(<2 x i31>, <2 x i31>, <2 x i31>) declare <2 x i31> @llvm.fshl.v2i31(<2 x i31>, <2 x i31>, <2 x i31>)
; If the shift mask doesn't include any demanded bits, the funnel shift can be eliminated. ; If the shift mask doesn't include any demanded bits, the funnel shift can be eliminated.
▲ Show 20 Lines • Show All 727 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/fsub.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
; PR4374 ; PR4374
define float @test1(float %x, float %y) { define float @test1(float %x, float %y) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[T1:%.*]] = fsub float [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[T1:%.*]] = fsub float [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: [[T2:%.*]] = fneg float [[T1]] ; CHECK-NEXT: [[T2:%.*]] = fneg float [[T1]]
; CHECK-NEXT: ret float [[T2]] ; CHECK-NEXT: ret float [[T2]]
▲ Show 20 Lines • Show All 966 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/funnel.ll

; NOTE: 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 or(shl,lshr) by constant to funnel shift intrinsics. ; Canonicalize or(shl,lshr) 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 fshl instruction, the expansion will ; If a target does not have a fshl 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 407 Lines • Show Last 20 Lines

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

; Test that the fwrite library call simplifier works correctly. ; Test that the fwrite 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"
%FILE = type { } %FILE = type { }
@str = constant [1 x i8] zeroinitializer @str = constant [1 x i8] zeroinitializer
@empty = constant [0 x i8] zeroinitializer @empty = constant [0 x i8] zeroinitializer
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines