-; RUN: opt %s -anders-aa -gvn | llvm-dis | not grep undef
+; RUN: opt %s -anders-aa -gvn -S | not grep undef
; PR2160
declare void @f(i32*)
-; RUN: opt %s -anders-aa -gvn | llvm-dis | not grep undef
+; RUN: opt %s -anders-aa -gvn -S | not grep undef
; PR2169
declare void @llvm.memcpy.i32(i8*, i8*, i32, i32) nounwind
-; RUN: opt %s -anders-aa -gvn -deadargelim | llvm-dis | grep store | not grep null
+; RUN: opt %s -anders-aa -gvn -deadargelim -S | grep store | not grep null
; Because the 'internal' function is passed to an external function, we don't
; know what the incoming values will alias. As such, we cannot do the
; is performed. It is not legal to delete the second load instruction because
; the value computed by the first load instruction is changed by the store.
-; RUN: opt %s -gvn -instcombine | llvm-dis | grep DONOTREMOVE
+; RUN: opt %s -gvn -instcombine -S | grep DONOTREMOVE
define i32 @test() {
%A = alloca i32
-; RUN: opt %s -gvn -instcombine | llvm-dis | grep sub
+; RUN: opt %s -gvn -instcombine -S | grep sub
; BasicAA was incorrectly concluding that P1 and P2 didn't conflict!
; In this test, a local alloca cannot alias an incoming argument.
-; RUN: opt %s -gvn -instcombine | llvm-dis | not grep sub
+; RUN: opt %s -gvn -instcombine -S | not grep sub
define i32 @test(i32* %P) {
%X = alloca i32
-; RUN: opt %s -dse | llvm-dis | grep {store i32 0}
+; RUN: opt %s -dse -S | grep {store i32 0}
define void @test({i32,i32 }* %P) {
%Q = getelementptr {i32,i32}* %P, i32 1
; PR1109
-; RUN: opt %s -basicaa -gvn -instcombine | llvm-dis | \
+; RUN: opt %s -basicaa -gvn -instcombine -S | \
; RUN: grep {sub i32}
-; RUN: opt %s -basicaa -gvn -instcombine | llvm-dis | \
+; RUN: opt %s -basicaa -gvn -instcombine -S | \
; RUN: not grep {ret i32 0}
; END.
; PR1600
-; RUN: opt %s -basicaa -gvn -instcombine | llvm-dis | \
+; RUN: opt %s -basicaa -gvn -instcombine -S | \
; RUN: grep {ret i32 0}
; END.
-; RUN: opt %s -basicaa -gvn -dce | llvm-dis | grep tmp7
+; RUN: opt %s -basicaa -gvn -dce -S | grep tmp7
%struct.A = type { i32 }
%struct.B = type { %struct.A }
-; RUN: opt %s -std-compile-opts | llvm-dis | grep store
+; RUN: opt %s -std-compile-opts -S | grep store
; ModuleID = 'small2.c'
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -basicaa -gvn | llvm-dis | grep load
+; RUN: opt %s -basicaa -gvn -S | grep load
declare noalias i32* @noalias()
-; RUN: opt %s -gvn | llvm-dis | grep {ret i32 1}
+; RUN: opt %s -gvn -S | grep {ret i32 1}
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"
%struct.x = type { i32, i32, i32, i32 }
-; RUN: opt %s -basicaa -gvn | llvm-dis | grep load | count 1
+; RUN: opt %s -basicaa -gvn -S | grep load | count 1
@flag0 = internal global i32 zeroinitializer
@turn = internal global i32 zeroinitializer
; This testcase tests for various features the basicaa test should be able to
; determine, as noted in the comments.
-; RUN: opt %s -basicaa -gvn -instcombine -dce | llvm-dis | not grep REMOVE
+; RUN: opt %s -basicaa -gvn -instcombine -dce -S | not grep REMOVE
@Global = external global { i32 }
; A store or load cannot alias a global if the accessed amount is larger then
; the global.
-; RUN: opt %s -basicaa -gvn -instcombine | llvm-dis | not grep load
+; RUN: opt %s -basicaa -gvn -instcombine -S | not grep load
@B = global i16 8 ; <i16*> [#uses=2]
-; RUN: opt %s -basicaa -gvn -instcombine | llvm-dis | grep {ret i1 true}
+; RUN: opt %s -basicaa -gvn -instcombine -S | grep {ret i1 true}
; PR2436
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -basicaa -gvn -instcombine | llvm-dis | grep {ret i32 0}
+; RUN: opt %s -basicaa -gvn -instcombine -S | grep {ret i32 0}
declare i32* @test(i32* nocapture)
-; RUN: opt %s -basicaa -gvn | llvm-dis | grep TestConst | count 2
-; RUN: opt %s -basicaa -gvn | llvm-dis | grep TestPure | count 3
-; RUN: opt %s -basicaa -gvn | llvm-dis | grep TestNone | count 4
+; RUN: opt %s -basicaa -gvn -S | grep TestConst | count 2
+; RUN: opt %s -basicaa -gvn -S | grep TestPure | count 3
+; RUN: opt %s -basicaa -gvn -S | grep TestNone | count 4
@g = global i32 0 ; <i32*> [#uses=1]
define i32 @test() {
; disambiguating some obvious cases. If LICM is able to disambiguate the
; two pointers, then the load should be hoisted, and the store sunk.
-; RUN: opt %s -basicaa -licm | llvm-dis | FileCheck %s
+; RUN: opt %s -basicaa -licm -S | FileCheck %s
@A = global i32 7 ; <i32*> [#uses=3]
@B = global i32 8 ; <i32*> [#uses=2]
-; RUN: opt %s -globalsmodref-aa -gvn | llvm-dis | grep call | count 2
+; RUN: opt %s -globalsmodref-aa -gvn -S | grep call | count 2
@g = internal global i32 0 ; <i32*> [#uses=2]
-; RUN: opt %s -globalsmodref-aa -gvn | llvm-dis | not grep load
+; RUN: opt %s -globalsmodref-aa -gvn -S | not grep load
@X = internal global i32 4 ; <i32*> [#uses=1]
define i32 @test(i32* %P) {
-; RUN: opt %s -globalsmodref-aa -gvn | llvm-dis | not grep load
+; RUN: opt %s -globalsmodref-aa -gvn -S | not grep load
; This test requires the use of previous analyses to determine that
; doesnotmodX does not modify X (because 'sin' doesn't).
-; RUN: opt %s -globalsmodref-aa -gvn -instcombine | llvm-dis | \
+; RUN: opt %s -globalsmodref-aa -gvn -instcombine -S | \
; RUN: grep {ret i32 0}
@G = internal global i32* null ; <i32**> [#uses=3]
-; RUN: opt %s -globalsmodref-aa -gvn | llvm-dis | not grep load
+; RUN: opt %s -globalsmodref-aa -gvn -S | not grep load
@X = internal global i32 4 ; <i32*> [#uses=2]
define i32 @test(i32* %P) {
; Test the edge profiling instrumentation.
-; RUN: opt %s -insert-edge-profiling | llvm-dis | FileCheck %s
+; RUN: opt %s -insert-edge-profiling -S | FileCheck %s
; ModuleID = '<stdin>'
-; RUN: opt %s -indvars -adce -simplifycfg | llvm-dis | grep "icmp s"
+; RUN: opt %s -indvars -adce -simplifycfg -S | grep "icmp s"
; PR1598
define i32 @f(i32 %a, i32 %b, i32 %x, i32 %y) {
-; RUN: opt %s -indvars | llvm-dis | grep printd | grep 1206807378
+; RUN: opt %s -indvars -S | grep printd | grep 1206807378
; PR1798
declare void @printd(i32)
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep select %t | count 2
; RUN: grep {icmp ne i32.\* %w } %t
; of the bug that was causing the Olden Health benchmark to output incorrect
; results!
;
-; RUN: opt %s -constprop | llvm-dis > %t.1
+; RUN: opt -constprop -S > %t.1 < %s
; RUN: llvm-as < %s | llvm-dis | llvm-as | opt -constprop | \
; RUN: llvm-dis > %t.2
; RUN: diff %t.1 %t.2
; Check by running globaldce, which will remove the constant if there are
; no references to it!
;
-; RUN: opt %s -globaldce | llvm-dis | \
+; RUN: opt %s -globaldce -S | \
; RUN: not grep constant
;
; Testcase that seems to break the bytecode reader. This comes from the
; "crafty" spec benchmark.
;
-; RUN: opt %s -instcombine | llvm-dis | llvm-as
+; RUN: opt %s -instcombine -S | llvm-as
%CHESS_POSITION = type { i32, i32 }
@pawn_probes = external global i32 ; <i32*> [#uses=0]
-; RUN: opt %s -instcombine -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -instcombine -simplifycfg -S | not grep br
@.str_1 = internal constant [6 x i8] c"_Bool\00" ; <[6 x i8]*> [#uses=2]
-; RUN: opt %s -verify | llvm-dis | llvm-as -disable-output
+; RUN: opt %s -verify -S | llvm-as -disable-output
define {i32, i8} @foo(i32 %p) {
ret i32 1, i8 2
-; RUN: opt %s -strip | llvm-dis | llvm-as | llvm-dis
+; RUN: opt %s -strip -S | llvm-as | llvm-dis
; Stripping the name from A should not break references to it.
%A = type opaque
-; RUN: opt %s -inline | llvm-dis | grep example
+; RUN: opt %s -inline -S | grep example
%IntArray = type { i32, [0 x i32*] }
-; RUN: opt %s -inline | llvm-dis | grep sample
-; RUN: opt %s -inline | llvm-dis | grep example
+; RUN: opt %s -inline -S | grep sample
+; RUN: opt %s -inline -S | grep example
%IntArray = type { i32, [0 x i32*] }
-; RUN: opt %s -instcombine | llvm-dis | grep 302245289961712575840256
-; RUN: opt %s -instcombine | llvm-dis | grep K40018000000000000000
+; RUN: opt %s -instcombine -S | grep 302245289961712575840256
+; RUN: opt %s -instcombine -S | grep K40018000000000000000
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-darwin9"
-;RUN: llvm-as <%s | opt -licm | llvm-dis | grep {load } | count 4
+;RUN: llvm-as <%s | opt -licm -S | grep {load } | count 4
; ModuleID = '2009-02-27-licm.bc'
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"
target triple = "i386-pc-linux-gnu"
-; RUN: opt %s -instcombine | llvm-dis | grep store | count 5
+; RUN: opt %s -instcombine -S | grep store | count 5
; ModuleID = '<stdin>'
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.6"
-; RUN: opt %s -instcombine | llvm-dis | not grep alloca
+; RUN: opt %s -instcombine -S | not grep alloca
; ModuleID = '<stdin>'
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.6"
-; RUN: opt %s -instcombine | llvm-dis | not grep alloca
+; RUN: opt %s -instcombine -S | not grep alloca
; ModuleID = '<stdin>'
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.6"
-;RUN: llvm-as <%s | opt -gvn | llvm-dis | grep {load } | count 1
+;RUN: llvm-as <%s | opt -gvn -S | grep {load } | count 1
; ModuleID = 'db2-before.bc'
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"
target triple = "i386-pc-linux-gnu"
-; RUN: opt %s -std-compile-opts | llvm-dis > %t
+; RUN: opt %s -std-compile-opts -S > %t
; RUN: grep undef %t | count 1
; RUN: grep 5 %t | count 1
; RUN: grep 7 %t | count 1
-; RUN: opt %s -instcombine | llvm-dis | grep true
+; RUN: opt %s -instcombine -S | grep true
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt %s -verify | llvm-dis | grep noimplicitfloat
+; RUN: opt %s -verify -S | grep noimplicitfloat
define void @f() noimplicitfloat {
}
; It is illegal to remove BB1 because it will mess up the PHI node!
;
-; RUN: opt %s -adce | llvm-dis | grep BB1
+; RUN: opt %s -adce -S | grep BB1
define i32 @test(i1 %C, i32 %A, i32 %B) {
; <label>:0
-; RUN: opt %s -adce -simplifycfg | llvm-dis | not grep then:
+; RUN: opt %s -adce -simplifycfg -S | not grep then:
define void @dead_test8(i32* %data.1, i32 %idx.1) {
entry:
-; RUN: opt %s -adce -simplifycfg | llvm-dis | grep call
+; RUN: opt %s -adce -simplifycfg -S | grep call
declare void @exit(i32)
define i32 @main(i32 %argc) {
-; RUN: opt %s -adce | llvm-dis | not grep call
+; RUN: opt -adce -S < %s | not grep call
declare i32 @strlen(i8*) readonly nounwind
-; RUN: opt %s -adce | llvm-dis | grep null
+; RUN: opt %s -adce -S | grep null
declare i32 @strlen(i8*) readnone
-; RUN: opt %s -argpromotion | llvm-dis | grep nounwind | count 2
+; RUN: opt %s -argpromotion -S | grep nounwind | count 2
define internal i32 @deref(i32* %x) nounwind {
entry:
-; RUN: opt %s -argpromotion | llvm-dis > %t
+; RUN: opt %s -argpromotion -S > %t
; RUN: cat %t | grep {define.*@callee(.*i32\\*}
; PR2498
-; RUN: opt %s -argpromotion -instcombine | llvm-dis | not grep load
+; RUN: opt %s -argpromotion -instcombine -S | not grep load
%QuadTy = type { i32, i32, i32, i32 }
@G = constant %QuadTy {
-; RUN: opt %s -argpromotion | llvm-dis | grep zeroext
+; RUN: opt %s -argpromotion -S | grep zeroext
%struct.ss = type { i32, i64 }
-; RUN: opt %s -argpromotion -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -argpromotion -mem2reg -S | not grep alloca
define internal i32 @test(i32* %X, i32* %Y) {
%A = load i32* %X ; <i32> [#uses=1]
%B = load i32* %Y ; <i32> [#uses=1]
-; RUN: opt %s -argpromotion | llvm-dis | grep -F {i32* byval} | count 2
+; RUN: opt %s -argpromotion -S | grep -F {i32* byval} | count 2
; Argpromote + scalarrepl should change this to passing the two integers by value.
%struct.ss = type { i32, i64 }
-; RUN: opt %s -argpromotion -scalarrepl | llvm-dis | not grep load
+; RUN: opt %s -argpromotion -scalarrepl -S | not grep load
; Argpromote + scalarrepl should change this to passing the two integers by value.
%struct.ss = type { i32, i64 }
-; RUN: opt %s -argpromotion -instcombine | llvm-dis | not grep load
+; RUN: opt %s -argpromotion -instcombine -S | not grep load
@G1 = constant i32 0 ; <i32*> [#uses=1]
@G2 = constant i32* @G1 ; <i32**> [#uses=1]
-; RUN: opt %s -argpromotion | llvm-dis | \
+; RUN: opt %s -argpromotion -S | \
; RUN: not grep {load i32\* null}
define internal i32 @callee(i1 %C, i32* %P) {
-; RUN: opt %s -argpromotion | llvm-dis | \
+; RUN: opt %s -argpromotion -S | \
; RUN: grep {load i32\\* %A}
define internal i32 @callee(i1 %C, i32* %P) {
-; RUN: opt %s -condprop | llvm-dis | \
+; RUN: opt %s -condprop -S | \
; RUN: not grep {br label}
%llvm.dbg.anchor.type = type { i32, i32 }
-; RUN: opt %s -condprop | llvm-dis | \
+; RUN: opt %s -condprop -S | \
; RUN: not grep {br label}
-; RUN: opt %s -condprop | llvm-dis | not grep T2
+; RUN: opt %s -condprop -S | not grep T2
define i32 @test(i1 %C) {
-; RUN: opt %s -condprop | llvm-dis | not grep phi
+; RUN: opt < %s -condprop -S | not grep phi
define i32 @test(i32 %C, i1 %Val) {
switch i32 %C, label %T1 [
-; RUN: opt %s -condprop | llvm-dis | not grep phi
+; RUN: opt < %s -condprop -S | not grep phi
declare i1 @foo()
-; RUN: opt %s -condprop | llvm-dis | not grep phi
+; RUN: opt < %s -condprop -S | not grep phi
define i32 @foo(i1, i32, i32) {
prologue:
; Fix #2: The unary not instruction now no longer exists. Change to xor.
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: not grep {i32 0}
define i32 @test1() {
; SetCC on boolean values was not implemented!
-; RUN: opt %s -constprop -die | llvm-dis | \
+; RUN: opt %s -constprop -die -S | \
; RUN: not grep set
define i1 @test1() {
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: not grep {ret i1 false}
@b = external global [2 x { }] ; <[2 x { }]*> [#uses=2]
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: grep {i32 -1}
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: not grep zeroinitializer
define <4 x i32> @test() {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {ret i1 false}
define i1 @test() {
%X = trunc i32 320 to i1 ; <i1> [#uses=1]
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: grep {ret i32 -1}
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: grep {ret i32 1}
define i32 @test1() {
-; RUN: opt %s -constprop | llvm-dis | grep 1065353216
+; RUN: opt %s -constprop -S | grep 1065353216
define i32 @test() {
%A = bitcast float 1.000000e+00 to i32 ; <i32> [#uses=1]
-; RUN: opt %s -constprop | llvm-dis | grep {ret i13 13}
+; RUN: opt %s -constprop -S | grep {ret i13 13}
; PR1816
declare i13 @llvm.cttz.i13(i13)
; This is a basic sanity check for constant propogation. The add instruction
; should be eliminated.
-; RUN: opt %s -constprop -die | llvm-dis | not grep add
+; RUN: opt %s -constprop -die -S | not grep add
define i32 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
-; RUN: opt %s -instcombine | llvm-dis | not grep bitcast
+; RUN: opt < %s -instcombine -S | not grep bitcast
; PR2165
define <1 x i64> @test() {
; bswap should be constant folded when it is passed a constant argument
-; RUN: opt %s -constprop | llvm-dis | not grep call
+; RUN: opt %s -constprop -S | not grep call
declare i16 @llvm.bswap.i16(i16)
-; RUN: opt %s -constprop | llvm-dis | not grep call
+; RUN: opt < %s -constprop -S | not grep call
declare double @cos(double)
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 0}
+; RUN: opt %s -instcombine -S | grep {ret i32 0}
; PR4424
declare void @ext()
-; RUN: opt %s -constprop | llvm-dis | \
+; RUN: opt %s -constprop -S | \
; RUN: grep -F {ret i32* null} | count 2
define i32* @test1() {
; Ensure constant propogation of logical instructions is working correctly.
-; RUN: opt %s -constprop -die | llvm-dis | \
+; RUN: opt < %s -constprop -die -S | \
; RUN: not egrep {and|or|xor}
define i32 @test1() {
; Ensure constant propogation of 'not' instructions is working correctly.
-; RUN: opt %s -constprop -die | llvm-dis | not grep xor
+; RUN: opt %s -constprop -die -S | not grep xor
define i32 @test1() {
%R = xor i32 4, -1 ; <i32> [#uses=1]
; This is a basic sanity check for constant propogation. The add instruction
; should be eliminated.
-; RUN: opt %s -constprop -die | llvm-dis | not grep phi
+; RUN: opt < %s -constprop -die -S | not grep phi
define i32 @test(i1 %B) {
BB0:
; Ensure constant propagation of remainder instructions is working correctly.
-; RUN: opt %s -constprop -die | llvm-dis | not grep rem
+; RUN: opt < %s -constprop -die -S | not grep rem
define i32 @test1() {
%R = srem i32 4, 3 ; <i32> [#uses=1]
-; RUN: opt %s -constmerge | llvm-dis | grep foo
-; RUN: opt %s -constmerge | llvm-dis | grep bar
+; RUN: opt %s -constmerge -S | grep foo
+; RUN: opt %s -constmerge -S | grep bar
; Don't merge constants in different sections.
-; RUN: opt %s -deadargelim | llvm-dis | grep {@test(}
-; RUN: opt %s -deadargelim | llvm-dis | not grep dead
+; RUN: opt %s -deadargelim -S | grep {@test(}
+; RUN: opt %s -deadargelim -S | not grep dead
define internal i32 @test(i32 %X, i32 %dead) {
ret i32 %X
-; RUN: opt %s -deadargelim | llvm-dis | not grep {ret i32 0}
+; RUN: opt %s -deadargelim -S | not grep {ret i32 0}
; PR1735
define internal i32 @test(i32 %A, ...) {
-; RUN: opt %s -deadargelim | llvm-dis > %t
+; RUN: opt %s -deadargelim -S > %t
; RUN: cat %t | grep nounwind | count 2
; RUN: cat %t | grep signext | count 2
; RUN: cat %t | not grep inreg
-; RUN: opt %s -deadargelim | llvm-dis | grep byval
+; RUN: opt %s -deadargelim -S | grep byval
%struct.point = type { double, double }
@pts = global [4 x %struct.point] [ %struct.point { double 1.000000e+00, double 2.000000e+00 }, %struct.point { double 3.000000e+00, double 4.000000e+00 }, %struct.point { double 5.000000e+00, double 6.000000e+00 }, %struct.point { double 7.000000e+00, double 8.000000e+00 } ], align 32 ; <[4 x %struct.point]*> [#uses=1]
-; RUN: opt %s -deadargelim -die | llvm-dis > %t
+; RUN: opt %s -deadargelim -die -S > %t
; RUN: cat %t | grep 123
; This test tries to catch wrongful removal of return values for a specific case
-; RUN: opt %s -deadargelim | llvm-dis | not grep DEADARG
+; RUN: opt %s -deadargelim -S | not grep DEADARG
; test - an obviously dead argument
define internal i32 @test(i32 %v, i32 %DEADARG1, i32* %p) {
; This test shows a few canonicalizations made by deadargelim
-; RUN: opt %s -deadargelim | llvm-dis > %t
+; RUN: opt %s -deadargelim -S > %t
; This test should remove {} and replace it with void
; RUN: cat %t | grep {define internal void @test}
; This test shouls replace the {i32} return value with just i32
-; RUN: opt %s -deadargelim | llvm-dis | not grep 47
-; RUN: opt %s -deadargelim | llvm-dis | not grep 1.0
+; RUN: opt %s -deadargelim -S | not grep 47
+; RUN: opt %s -deadargelim -S | not grep 1.0
define i32 @bar(i32 %A) {
%tmp4 = tail call i32 (i32, ...)* @foo( i32 %A, i32 %A, i32 %A, i32 %A, i64 47, double 1.000000e+00 ) ; <i32> [#uses=1]
-; RUN: opt %s -deadargelim | llvm-dis | not grep DEAD
+; RUN: opt %s -deadargelim -S | not grep DEAD
; Dead arg only used by dead retval
define internal i32 @test(i32 %DEADARG) {
-; RUN: opt %s -deadargelim -die | llvm-dis > %t
+; RUN: opt %s -deadargelim -die -S > %t
; RUN: cat %t | not grep DEAD
; RUN: cat %t | grep LIVE | count 4
-; RUN: opt %s -deadargelim | llvm-dis > %t
+; RUN: opt %s -deadargelim -S > %t
; RUN: grep {define internal zeroext i32 @test1() nounwind} %t
; RUN: grep {define internal %Ty @test2} %t
; are unused. All unused values are typed i16, so we can easily check. We also
; run instcombine to fold insert/extractvalue chains and we run dce to clean up
; any remaining dead stuff.
-; RUN: opt %s -deadargelim -instcombine -dce | llvm-dis | not grep i16
+; RUN: opt %s -deadargelim -instcombine -dce -S | not grep i16
define internal {i16, i32} @test(i16 %DEADARG) {
%A = insertvalue {i16,i32} undef, i16 1, 0
-; RUN: opt %s -dse | llvm-dis | \
+; RUN: opt %s -dse -S | \
; RUN: grep {store i32 1234567}
; Do not delete stores that are only partially killed.
-; RUN: opt %s -dse | llvm-dis | grep store
+; RUN: opt %s -dse -S | grep store
define double @foo(i8* %X) {
%X_addr = alloca i8* ; <i8**> [#uses=2]
-; RUN: opt %s -dse | llvm-dis | not grep tmp5
+; RUN: opt %s -dse -S | not grep tmp5
; PR2599
define void @foo({ i32, i32 }* %x) nounwind {
-; RUN: opt %s -dse | llvm-dis | \
+; RUN: opt %s -dse -S | \
; RUN: not grep {store i8}
; Ensure that the dead store is deleted in this case. It is wholely
; overwritten by the second store.
-; RUN: opt %s -dse | llvm-dis | not grep DEAD
+; RUN: opt %s -dse -S | not grep DEAD
define void @test(i32* %Q) {
%P = alloca i32 ; <i32*> [#uses=1]
-; RUN: opt %s -dse | llvm-dis | not grep store
+; RUN: opt %s -dse -S | not grep store
%struct.x = type { i32, i32, i32, i32 }
-; RUN: opt %s -dse | llvm-dis | not grep DEAD
+; RUN: opt %s -dse -S | not grep DEAD
declare void @ext()
-; RUN: opt %s -dse | llvm-dis | not grep DEAD
+; RUN: opt %s -dse -S | not grep DEAD
define void @test(i32* %Q, i32* %P) {
%DEAD = load i32* %Q ; <i32> [#uses=1]
-; RUN: opt %s -dse | llvm-dis | not grep alloca
+; RUN: opt %s -dse -S | not grep alloca
; ModuleID = 'placeholder.adb'
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"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -dse | llvm-dis | not grep DEAD
+; RUN: opt %s -dse -S | not grep DEAD
define void @test(i32* %Q, i32* %P) {
%DEAD = load i32* %Q ; <i32> [#uses=1]
-; RUN: opt %s -dse | llvm-dis | grep {volatile load}
+; RUN: opt %s -dse -S | grep {volatile load}
@g_1 = global i32 0
-; RUN: opt %s -functionattrs | llvm-dis | grep readnone
+; RUN: opt %s -functionattrs -S | grep readnone
define i32 @a() {
%tmp = call i32 @b( ) ; <i32> [#uses=1]
-; RUN: opt %s -functionattrs | llvm-dis | grep readnone | count 4
+; RUN: opt %s -functionattrs -S | grep readnone | count 4
@x = global i32 0
declare i32 @e() readnone
-; RUN: opt %s -functionattrs | llvm-dis | grep readonly | count 2
+; RUN: opt %s -functionattrs -S | grep readonly | count 2
define i32 @f() {
entry:
-; RUN: opt %s -functionattrs | llvm-dis | not grep read
+; RUN: opt %s -functionattrs -S | not grep read
; PR2792
@g = global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -functionattrs | llvm-dis | grep readnone | count 2
+; RUN: opt %s -functionattrs -S | grep readnone | count 2
declare i32 @g(i32*) readnone
-; RUN: opt %s -functionattrs | llvm-dis | grep readnone
+; RUN: opt %s -functionattrs -S | grep readnone
@s = external constant i8 ; <i8*> [#uses=1]
-; RUN: opt %s -functionattrs | llvm-dis | not grep {nocapture *%%q}
-; RUN: opt %s -functionattrs | llvm-dis | grep {nocapture *%%p} | count 6
+; RUN: opt %s -functionattrs -S | not grep {nocapture *%%q}
+; RUN: opt %s -functionattrs -S | grep {nocapture *%%p} | count 6
@g = global i32* null ; <i32**> [#uses=1]
define i32* @c1(i32* %q) {
-; RUN: opt %s -functionattrs | llvm-dis | not grep {nocapture *%%q}
-; RUN: opt %s -functionattrs | llvm-dis | grep {nocapture *%%p}
+; RUN: opt %s -functionattrs -S | not grep {nocapture *%%q}
+; RUN: opt %s -functionattrs -S | grep {nocapture *%%p}
define i32* @a(i32** %p) {
%tmp = load i32** %p
-; RUN: opt %s -functionattrs | llvm-dis | not grep read
+; RUN: opt %s -functionattrs -S | not grep read
; PR3754
define i8* @m(i32 %size) {
-; RUN: opt %s -gvn | llvm-dis | not grep {tmp10 =}
+; RUN: opt %s -gvn -S | not grep {tmp10 =}
%struct.INT2 = type { i32, i32 }
@blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2]
-; RUN: opt %s -gvn | llvm-dis | grep {tmp17625.* = phi i32. }
-; RUN: opt %s -gvn | llvm-dis | grep {tmp17631.* = phi i32. }
+; RUN: opt %s -gvn -S | grep {tmp17625.* = phi i32. }
+; RUN: opt %s -gvn -S | grep {tmp17631.* = phi i32. }
@last = external global [65 x i32*] ; <[65 x i32*]*> [#uses=1]
-; RUN: opt %s -gvn | llvm-dis | grep {tmp298316 = phi i32 }
+; RUN: opt %s -gvn -S | grep {tmp298316 = phi i32 }
%struct..0anon = type { i32 }
%struct.FILE = type { i8*, i32, i32, i16, i16, %struct.__sbuf, i32, i8*, i32 (i8*)*, i32 (i8*, i8*, i32)*, i64 (i8*, i64, i32)*, i32 (i8*, i8*, i32)*, %struct.__sbuf, %struct.__sFILEX*, i32, [3 x i8], [1 x i8], %struct.__sbuf, i32, i64 }
-; RUN: opt %s -gvn | llvm-dis | grep {tmp47 = phi i32 }
+; RUN: opt %s -gvn -S | grep {tmp47 = phi i32 }
%struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* }
@debug = external constant i32 ; <i32*> [#uses=0]
-; RUN: opt %s -gvn | llvm-dis | not grep {tmp701 =}
+; RUN: opt %s -gvn -S | not grep {tmp701 =}
@img_width = external global i16 ; <i16*> [#uses=2]
-; RUN: opt %s -gvn | llvm-dis | not grep load
+; RUN: opt %s -gvn -S | not grep load
; PR1996
%struct.anon = type { i32, i8, i8, i8, i8 }
-; RUN: opt %s -gvn -dse | llvm-dis | grep {call.*memcpy} | count 1
+; RUN: opt %s -gvn -dse -S | grep {call.*memcpy} | count 1
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-darwin8"
-; RUN: opt %s -gvn -dse | llvm-dis | grep {call.*memcpy.*cell} | count 2
+; RUN: opt %s -gvn -dse -S | grep {call.*memcpy.*cell} | count 2
; PR2099
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"
-; RUN: opt %s -gvn | llvm-dis | grep {ret i8 \[%\]tmp3}
+; RUN: opt %s -gvn -S | grep {ret i8 \[%\]tmp3}
; PR2503
@g_3 = external global i8 ; <i8*> [#uses=2]
-; RUN: opt %s -gvn | llvm-dis | grep getelementptr | count 1
+; RUN: opt %s -gvn -S | grep getelementptr | count 1
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.5"
-; RUN: opt %s -gvn -enable-load-pre | llvm-dis | not grep pre1
+; RUN: opt %s -gvn -enable-load-pre -S | not grep pre1
; GVN load pre was hoisting the loads at %13 and %16 up to bb4.outer.
; This is invalid as it bypasses the check for %m.0.ph==null in bb4.
; ModuleID = 'mbuf.c'
-; RUN: opt %s -gvn | llvm-dis | not grep {%z2 =}
+; RUN: opt %s -gvn -S | not grep {%z2 =}
define i32 @main() {
block1:
-; RUN: opt %s -gvn | llvm-dis | not grep tmp2
+; RUN: opt %s -gvn -S | not grep tmp2
; PR2213
define i32* @f(i8* %x) {
-; RUN: opt %s -gvn | llvm-dis | grep strlen | count 2
+; RUN: opt %s -gvn -S | grep strlen | count 2
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9"
-; RUN: opt %s -basicaa -gvn | llvm-dis | grep {call.*strlen} | count 1
+; RUN: opt %s -basicaa -gvn -S | grep {call.*strlen} | count 1
; Should delete the second call to strlen even though the intervening strchr call exists.
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"
-; RUN: opt %s -gvn | llvm-dis | grep {br i1 false}
+; RUN: opt %s -gvn -S | grep {br i1 false}
@a = external global i32 ; <i32*> [#uses=7]
-; RUN: opt %s -gvn -instcombine | llvm-dis | grep {ret i32 0}
+; RUN: opt %s -gvn -instcombine -S | grep {ret i32 0}
; PR4189
@G = external constant [4 x i32]
-; RUN: opt %s -gvn -enable-pre | llvm-dis | grep {b.pre}
+; RUN: opt %s -gvn -enable-pre -S | grep {b.pre}
define i32 @main(i32 %p) {
block1:
-; RUN: opt %s -gvn -enable-load-pre | llvm-dis | grep {%PRE = phi}
+; RUN: opt %s -gvn -enable-load-pre -S | grep {%PRE = phi}
define i32 @test(i32* %p, i1 %C) {
block1:
-; RUN: opt %s -gvn | llvm-dis | not grep DEADLOAD
-; RUN: opt %s -gvn | llvm-dis | not grep DEADGEP
+; RUN: opt %s -gvn -S | not grep DEADLOAD
+; RUN: opt %s -gvn -S | not grep DEADGEP
define i32 @main(i32** %p) {
block1:
-; RUN: opt %s -gvn -enable-pre | llvm-dis | grep {.pre}
+; RUN: opt %s -gvn -enable-pre -S | grep {.pre}
@H = common global i32 0 ; <i32*> [#uses=2]
@G = common global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -gvn -enable-load-pre | llvm-dis | not grep {tmp3 = load}
+; RUN: opt %s -gvn -enable-load-pre -S | not grep {tmp3 = load}
@p = external global i32
define i32 @f(i32 %n) nounwind {
-; RUN: opt %s -gvn | llvm-dis | grep load | count 2
+; RUN: opt %s -gvn -S | grep load | count 2
define i32 @main(i32** %p) {
block1:
-; RUN: opt %s -gvn | llvm-dis | grep {DEAD = phi i32 }
+; RUN: opt %s -gvn -S | grep {DEAD = phi i32 }
; XFAIL: *
; FIXME: GVN should eliminate the fully redundant %9 GEP which
-; RUN: opt %s -gvn | llvm-dis | grep load
+; RUN: opt %s -gvn -S | grep load
; FIXME: This should be promotable, but memdep/gvn don't track values
; path/edge sensitively enough.
-; RUN: opt %s -gvn | llvm-dis | grep {%DEAD = phi i32. }
+; RUN: opt %s -gvn -S | grep {%DEAD = phi i32. }
define i32 @main(i32** %p) {
block1:
-; RUN: opt %s -gvn | llvm-dis | grep {%cv = phi i32}
-; RUN: opt %s -gvn | llvm-dis | grep {%bv = phi i32}
+; RUN: opt %s -gvn -S | grep {%cv = phi i32}
+; RUN: opt %s -gvn -S | grep {%bv = phi i32}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7"
-; RUN: opt %s -gvn | llvm-dis | grep {DEAD = phi i32 }
+; RUN: opt %s -gvn -S | grep {DEAD = phi i32 }
define i32 @main(i32* %p) {
block1:
-; RUN: opt %s -gvnpre | llvm-dis | grep tmp114115.gvnpre
+; RUN: opt %s -gvnpre -S | grep tmp114115.gvnpre
%struct.AV = type { %struct.XPVAV*, i32, i32 }
%struct.CLONE_PARAMS = type { %struct.AV*, i32, %struct.PerlInterpreter* }
-; RUN: opt %s -gvnpre | llvm-dis | not grep {%z3 =}
-; RUN: opt %s -gvnpre | llvm-dis | not grep {%z9 =}
+; RUN: opt %s -gvnpre -S | not grep {%z3 =}
+; RUN: opt %s -gvnpre -S | not grep {%z9 =}
define i32 @main() {
block1:
-; RUN: opt %s -gvnpre | llvm-dis | grep b.gvnpre
+; RUN: opt %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre | llvm-dis | grep b.gvnpre
+; RUN: opt %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre | llvm-dis | grep b.gvnpre
+; RUN: opt %s -gvnpre -S | grep b.gvnpre
define i32 @extract({ i32 }* %P) {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre | llvm-dis | grep b.gvnpre
+; RUN: opt %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre | llvm-dis | grep b.gvnpre
+; RUN: opt %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre | llvm-dis | grep b.gvnpre
+; RUN: opt %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
; Make sure that functions are removed successfully if they are referred to by
; a global that is dead. Make sure any globals they refer to die as well.
-; RUN: opt %s -globaldce | llvm-dis | not grep foo
+; RUN: opt %s -globaldce -S | not grep foo
;; Unused, kills %foo
@b = internal global i32 ()* @foo ; <i32 ()**> [#uses=0]
; This testcase tests that a worklist is being used, and that globals can be
; removed if they are the subject of a constexpr and ConstantPointerRef
-; RUN: opt %s -globaldce | llvm-dis | not grep global
+; RUN: opt %s -globaldce -S | not grep global
@t0 = internal global [4 x i8] c"foo\00" ; <[4 x i8]*> [#uses=1]
@t1 = internal global [4 x i8] c"bar\00" ; <[4 x i8]*> [#uses=1]
; distilled from 255.vortex
-; RUN: opt %s -globaldce | llvm-dis | not grep testfunc
+; RUN: opt %s -globaldce -S | not grep testfunc
declare i1 ()* @getfunc()
; Weak variables should be preserved by global DCE!
-; RUN: opt %s -globaldce | llvm-dis | grep @A
+; RUN: opt %s -globaldce -S | grep @A
@A = weak global i32 54
-; RUN: opt %s -globaldce | llvm-dis | not grep @D
-; RUN: opt %s -globaldce | llvm-dis | grep @L | count 3
+; RUN: opt %s -globaldce -S | not grep @D
+; RUN: opt %s -globaldce -S | grep @L | count 3
@A = global i32 0
@D = alias internal i32* @A
-; RUN: opt %s -globaldce | llvm-dis | not grep global
+; RUN: opt %s -globaldce -S | not grep global
@X = external global i32
@Y = internal global i32 7
-; RUN: opt %s -globaldce | llvm-dis | not grep test_
+; RUN: opt %s -globaldce -S | not grep test_
; test_function should not be emitted to the .s file.
define available_externally i32 @test_function() {
-; RUN: opt %s -globalopt | llvm-dis | grep {16 x .31 x double.. zeroinitializer}
+; RUN: opt %s -globalopt -S | grep {16 x .31 x double.. zeroinitializer}
; The 'X' indices could be larger than 31. Do not SROA the outer indices of this array.
@mm = internal global [16 x [31 x double]] zeroinitializer, align 32
-; RUN: opt %s -globalopt | llvm-dis | grep {volatile load}
+; RUN: opt %s -globalopt -S | grep {volatile load}
@t0.1441 = internal global double 0x3FD5555555555555, align 8 ; <double*> [#uses=1]
define double @foo() nounwind {
-; RUN: opt %s -globalopt | llvm-dis | grep { nest } | count 1
+; RUN: opt %s -globalopt -S | grep { nest } | count 1
%struct.FRAME.nest = type { i32, i32 (i32)* }
%struct.__builtin_trampoline = type { [10 x i8] }
@.str = internal constant [7 x i8] c"%d %d\0A\00" ; <[7 x i8]*> [#uses=1]
; alignments. Elements 0 and 2 must be 16-byte aligned, and element
; 1 must be at least 8 byte aligned (but could be more).
-; RUN: opt %s -globalopt | llvm-dis | grep {@G.0 = internal global .*align 16}
-; RUN: opt %s -globalopt | llvm-dis | grep {@G.1 = internal global .*align 8}
-; RUN: opt %s -globalopt | llvm-dis | grep {@G.2 = internal global .*align 16}
+; RUN: opt %s -globalopt -S | grep {@G.0 = internal global .*align 16}
+; RUN: opt %s -globalopt -S | grep {@G.1 = internal global .*align 8}
+; RUN: opt %s -globalopt -S | grep {@G.2 = internal global .*align 16}
; rdar://5891920
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:32:32-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
; values. This used to crash, because globalopt forgot to put the new var in the
; same address space as the old one.
-; RUN: opt %s -globalopt | llvm-dis > %t
+; RUN: opt %s -globalopt -S > %t
; Check that the new global values still have their address space
; RUN: cat %t | grep global.*addrspace
-; RUN: opt %s -globalopt | llvm-dis | grep {phi.*@head}
+; RUN: opt %s -globalopt -S | grep {phi.*@head}
; PR3321
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt %s -globalopt | llvm-dis | grep {define void @a}
+; RUN: opt %s -globalopt -S | grep {define void @a}
define internal void @f() {
ret void
-; RUN: opt %s -globalopt | llvm-dis | not grep global_variable42
+; RUN: opt %s -globalopt -S | not grep global_variable42
; XFAIL: *
%llvm.dbg.anchor.type = type { i32, i32 }
-; RUN: opt %s -globalopt | llvm-dis | grep internal | count 2
+; RUN: opt %s -globalopt -S | grep internal | count 2
global i32 0
define i32* @1() {
-; RUN: opt %s -globalopt | llvm-dis | grep {@X = internal global i32}
+; RUN: opt %s -globalopt -S | grep {@X = internal global i32}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7"
@X = internal global i32* null ; <i32**> [#uses=2]
-; RUN: opt %s -globalopt | llvm-dis > %t
+; RUN: opt %s -globalopt -S > %t
; RUN: cat %t | grep foo1 | count 1
; RUN: cat %t | grep foo2 | count 4
; RUN: cat %t | grep bar1 | count 1
-; RUN: opt %s -globalopt | llvm-dis | not grep global
+; RUN: opt %s -globalopt -S | not grep global
@X = internal global i32 4 ; <i32*> [#uses=1]
-; RUN: opt %s -instcombine -globalopt | llvm-dis | \
+; RUN: opt %s -instcombine -globalopt -S | \
; RUN: grep {internal fastcc float @foo}
define internal float @foo() {
-; RUN: opt %s -globalopt | llvm-dis | not grep CTOR
+; RUN: opt %s -globalopt -S | not grep CTOR
@llvm.global_ctors = appending global [10 x { i32, void ()* }] [ { i32, void ()* } { i32 65535, void ()* @CTOR1 }, { i32, void ()* } { i32 65535, void ()* @CTOR1 }, { i32, void ()* } { i32 65535, void ()* @CTOR2 }, { i32, void ()* } { i32 65535, void ()* @CTOR3 }, { i32, void ()* } { i32 65535, void ()* @CTOR4 }, { i32, void ()* } { i32 65535, void ()* @CTOR5 }, { i32, void ()* } { i32 65535, void ()* @CTOR6 }, { i32, void ()* } { i32 65535, void ()* @CTOR7 }, { i32, void ()* } { i32 65535, void ()* @CTOR8 }, { i32, void ()* } { i32 2147483647, void ()* null } ] ; <[10 x { i32, void ()* }]*> [#uses=0]
@G = global i32 0 ; <i32*> [#uses=1]
@G2 = global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -globalopt | llvm-dis | FileCheck %s
+; RUN: opt %s -globalopt -S | FileCheck %s
; Don't get fooled by the inbounds keyword; it doesn't change
; the computed address.
-; RUN: opt %s -globalopt | llvm-dis | not grep CTOR
+; RUN: opt %s -globalopt -S | not grep CTOR
@llvm.global_ctors = appending global [10 x { i32, void ()* }] [ { i32, void ()* } { i32 65535, void ()* @CTOR1 }, { i32, void ()* } { i32 65535, void ()* @CTOR1 }, { i32, void ()* } { i32 65535, void ()* @CTOR2 }, { i32, void ()* } { i32 65535, void ()* @CTOR3 }, { i32, void ()* } { i32 65535, void ()* @CTOR4 }, { i32, void ()* } { i32 65535, void ()* @CTOR5 }, { i32, void ()* } { i32 65535, void ()* @CTOR6 }, { i32, void ()* } { i32 65535, void ()* @CTOR7 }, { i32, void ()* } { i32 65535, void ()* @CTOR8 }, { i32, void ()* } { i32 2147483647, void ()* null } ] ; <[10 x { i32, void ()* }]*> [#uses=0]
@G = global i32 0 ; <i32*> [#uses=1]
@G2 = global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -globalopt | llvm-dis | not grep internal
+; RUN: opt %s -globalopt -S | not grep internal
; This is a harder case to delete as the GEP has a variable index.
-; RUN: opt %s -globalopt | llvm-dis | not grep internal
+; RUN: opt %s -globalopt -S | not grep internal
@G = internal global i32 123 ; <i32*> [#uses=1]
; In this case, the global can only be broken up by one level.
-; RUN: opt %s -globalopt | llvm-dis | not grep 12345
+; RUN: opt %s -globalopt -S | not grep 12345
@G = internal global { i32, [4 x float] } zeroinitializer ; <{ i32, [4 x float] }*> [#uses=3]
-; RUN: opt %s -globalopt | llvm-dis > %t
+; RUN: opt %s -globalopt -S > %t
; RUN: grep {@Y = internal global \\\[3 x \[%\]struct.X\\\] zeroinitializer} %t
; RUN: grep load %t | count 6
; RUN: grep {add i32 \[%\]a, \[%\]b} %t | count 3
-; RUN: opt %s -globalopt | llvm-dis | not grep global
+; RUN: opt < %s -globalopt -S | not grep global
@G = internal global { i32, float, { double } } {
i32 1,
-; RUN: opt %s -globalopt | llvm-dis | grep {@X.f0}
-; RUN: opt %s -globalopt | llvm-dis | grep {@X.f1}
+; RUN: opt %s -globalopt -S | grep {@X.f0}
+; RUN: opt %s -globalopt -S | grep {@X.f1}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7"
-; RUN: opt %s -globalopt | llvm-dis | grep {@X.f0}
-; RUN: opt %s -globalopt | llvm-dis | grep {@X.f1}
+; RUN: opt %s -globalopt -S | grep {@X.f0}
+; RUN: opt %s -globalopt -S | grep {@X.f1}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7"
-; RUN: opt %s -globalopt | llvm-dis | grep {tmp.f1 = phi i32. }
-; RUN: opt %s -globalopt | llvm-dis | grep {tmp.f0 = phi i32. }
+; RUN: opt %s -globalopt -S | grep {tmp.f1 = phi i32. }
+; RUN: opt %s -globalopt -S | grep {tmp.f0 = phi i32. }
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7"
-; RUN: opt %s -globalopt | llvm-dis | not grep %G
+; RUN: opt %s -globalopt -S | not grep %G
@G = internal global i32 0 ; <i32*> [#uses=1]
@H = internal global { i32* } { i32* @G } ; <{ i32* }*> [#uses=1]
-; RUN: opt %s -globalopt | llvm-dis | not grep G
+; RUN: opt < %s -globalopt -S | not grep G
@G = internal global i32 17 ; <i32*> [#uses=3]
-; RUN: opt %s -globalopt | llvm-dis | not grep global
+; RUN: opt %s -globalopt -S | not grep global
@G = internal global i32* null ; <i32**> [#uses=3]
-; RUN: opt %s -globalopt | llvm-dis | not grep malloc
+; RUN: opt < %s -globalopt -S | not grep malloc
@G = internal global i32* null ; <i32**> [#uses=3]
-; RUN: opt %s -globalopt | llvm-dis | not grep malloc
+; RUN: opt < %s -globalopt -S | not grep malloc
@G = internal global i32* null ; <i32**> [#uses=4]
-; RUN: opt %s -globalopt | llvm-dis | \
+; RUN: opt %s -globalopt -S | \
; RUN: grep {G1 = internal constant}
@G1 = internal global [58 x i8] c"asdlfkajsdlfkajsd;lfkajds;lfkjasd;flkajsd;lkfja;sdlkfjasd\00" ; <[58 x i8]*> [#uses=1]
; both globals are write only, delete them.
-; RUN: opt %s -globalopt | llvm-dis | \
+; RUN: opt %s -globalopt -S | \
; RUN: not grep internal
@G0 = internal global [58 x i8] c"asdlfkajsdlfkajsd;lfkajds;lfkjasd;flkajsd;lkfja;sdlkfjasd\00" ; <[58 x i8]*> [#uses=1]
; Test that PHI nodes and select instructions do not necessarily make stuff
; non-constant.
-; RUN: opt %s -globalopt | llvm-dis | not grep global
+; RUN: opt %s -globalopt -S | not grep global
@X = internal global i32 4 ; <i32*> [#uses=2]
@Y = internal global i32 5 ; <i32*> [#uses=2]
-; RUN: opt %s -globalopt | llvm-dis | \
+; RUN: opt %s -globalopt -S | \
; RUN: grep {call void @Actual}
; Check that a comparison does not prevent an indirect call from being made
-; RUN: opt %s -globalopt | llvm-dis | not grep global
+; RUN: opt %s -globalopt -S | not grep global
@G = internal global void ()* null ; <void ()**> [#uses=2]
-; RUN: opt %s -globalopt | llvm-dis | not grep G
+; RUN: opt < %s -globalopt -S | not grep G
@G = internal global i32 17 ; <i32*> [#uses=3]
-; RUN: opt %s -globalopt | llvm-dis | not grep store
+; RUN: opt %s -globalopt -S | not grep store
@llvm.global_ctors = appending global [1 x { i32, void ()* }] [ { i32, void ()* } { i32 65535, void ()* @_GLOBAL__I__Z3foov } ] ; <[1 x { i32, void ()* }]*> [#uses=0]
@X.0 = internal global i32 undef ; <i32*> [#uses=2]
-; RUN: opt %s -ipconstprop | llvm-dis | grep {ret i32 %r}
+; RUN: opt %s -ipconstprop -S | grep {ret i32 %r}
; Should not propagate the result of a weak function.
; PR2411
-; RUN: opt %s -ipconstprop -deadargelim | llvm-dis | not grep %X
+; RUN: opt %s -ipconstprop -deadargelim -S | not grep %X
define internal i32 @foo(i32 %X) {
%Y = call i32 @foo( i32 %X ) ; <i32> [#uses=1]
%Z = add i32 %Y, 1 ; <i32> [#uses=1]
-; RUN: opt %s -ipconstprop | llvm-dis > %t
+; RUN: opt %s -ipconstprop -S > %t
; RUN: cat %t | grep {store i32 %Z, i32\\* %Q}
; RUN: cat %t | grep {add i32 1, 3}
-; RUN: opt %s -ipconstprop | llvm-dis > %t
+; RUN: opt %s -ipconstprop -S > %t
;; Check that the 21 constants got propagated properly
; RUN: cat %t | grep {%M = add i32 21, 21}
;; Check that the second return values didn't get propagated
-; RUN: opt %s -indmemrem | llvm-dis | grep bounce | grep noalias
+; RUN: opt %s -indmemrem -S | grep bounce | grep noalias
declare i8* @malloc(i32)
-; RUN: opt %s -indvars | llvm-dis | grep indvar
+; RUN: opt %s -indvars -S | grep indvar
define i32 @test() {
; <label>:0
; The induction variable canonicalization pass shouldn't leave dead
; instructions laying around!
;
-; RUN: opt %s -indvars | llvm-dis | \
+; RUN: opt %s -indvars -S | \
; RUN: not grep {#uses=0}
define i32 @mul(i32 %x, i32 %y) {
-; RUN: opt %s -indvars | llvm-dis | grep indvar | not grep i32
+; RUN: opt %s -indvars -S | grep indvar | not grep i32
@G = global i64 0 ; <i64*> [#uses=1]
-; RUN: opt %s -indvars | llvm-dis | \
+; RUN: opt %s -indvars -S | \
; RUN: grep {ret i32 152}
define i32 @main() {
; PR726
-; RUN: opt %s -indvars | llvm-dis | \
+; RUN: opt %s -indvars -S | \
; RUN: grep {ret i32 27}
; Make sure to compute the right exit value based on negative strides.
; PR1015
-; RUN: opt %s -indvars | llvm-dis | not grep {ret i32 0}
+; RUN: opt %s -indvars -S | not grep {ret i32 0}
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin8"
-; RUN: opt %s -indvars | llvm-dis | grep sext | count 1
+; RUN: opt %s -indvars -S | grep sext | count 1
; ModuleID = '<stdin>'
%struct.App1Marker = type <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }>
-; RUN: opt %s -indvars | llvm-dis | grep icmp | count 4
+; RUN: opt %s -indvars -S | grep icmp | count 4
define void @bar() nounwind {
entry:
br label %bb
-; RUN: opt %s -indvars | llvm-dis | grep icmp | count 2
-; RUN: opt %s -indvars | llvm-dis | grep sitofp | count 1
-; RUN: opt %s -indvars | llvm-dis | grep uitofp | count 1
+; RUN: opt %s -indvars -S | grep icmp | count 2
+; RUN: opt %s -indvars -S | grep sitofp | count 1
+; RUN: opt %s -indvars -S | grep uitofp | count 1
define void @bar() nounwind {
entry:
-; RUN: opt %s -indvars | llvm-dis | not grep {sext}
+; RUN: opt %s -indvars -S | not grep {sext}
; ModuleID = '<stdin>'
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-darwin9.6"
-; RUN: opt %s -indvars -instcombine | llvm-dis | not grep {\[sz\]ext}
+; RUN: opt %s -indvars -instcombine -S | not grep {\[sz\]ext}
; ModuleID = '<stdin>'
;extern int *a, *b, *c, *d, *e, *f; /* 64 bit */
;extern int K[256];
-; RUN: opt %s -indvars | llvm-dis | grep icmp | grep next
+; RUN: opt %s -indvars -S | grep icmp | grep next
; PR4086
declare void @foo()
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep phi %t | count 4
; RUN: grep {= phi i32} %t | count 4
; RUN: not grep {sext i} %t
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep getelementptr %t | count 1
; RUN: grep {mul .*, 37} %t | count 1
; RUN: grep {add .*, 5203} %t | count 1
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep sext %t | count 1
; Indvars should be able to eliminate all of the sign extensions
; The i induction variable looks like a wrap-around, but it really is just
; a simple affine IV. Make sure that indvars eliminates it.
-; RUN: opt %s -indvars | llvm-dis | grep phi | count 1
+; RUN: opt %s -indvars -S | grep phi | count 1
define void @foo() {
entry:
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt < %s -indvars -S > %t
; RUN: grep add %t | count 8
; RUN: grep mul %t | count 7
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep {= sext} %t | count 4
; RUN: grep {phi i64} %t | count 2
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt < %s -indvars -S > %t
; RUN: not grep and %t
; RUN: not grep zext %t
-; RUN: opt %s -indvars | llvm-dis | grep add | count 1
+; RUN: opt %s -indvars -S | grep add | count 1
; Indvars should be able to compute the exit value of this loop
; without any additional arithmetic. The only add needed should
; LFTR should eliminate the need for the computation of i*i completely. It
; is only used to compute the exit value.
-; RUN: opt %s -indvars -dce | llvm-dis | not grep mul
+; RUN: opt %s -indvars -dce -S | not grep mul
@A = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -indvars | llvm-dis | not grep select
+; RUN: opt %s -indvars -S | not grep select
; This loop has backedge-taken-count zero. Indvars shouldn't expand any
; instructions to compute a trip count.
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep {\[%\]tmp7 = icmp eq i8 -28, -28} %t
; RUN: grep {\[%\]tmp8 = icmp eq i8 63, 63} %t
; PR4477
-; RUN: opt %s -indvars -loop-deletion -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -indvars -loop-deletion -simplifycfg -S | not grep br
;
; Testcase distilled from 256.bzip2
-; RUN: opt %s -indvars | llvm-dis | grep {ret i32 600000}
+; RUN: opt %s -indvars -S | grep {ret i32 600000}
; PR1179
define i32 @foo() {
-; RUN: opt %s -indvars | llvm-dis | grep {ret i32 9900}
+; RUN: opt %s -indvars -S | grep {ret i32 9900}
; PR1179
define i32 @test4() {
-; RUN: opt %s -indvars | llvm-dis | grep {120, %bb2.bb3_crit_edge}
+; RUN: opt %s -indvars -S | grep {120, %bb2.bb3_crit_edge}
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"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -indvars -loop-deletion | llvm-dis | grep phi | count 1
+; RUN: opt %s -indvars -loop-deletion -S | grep phi | count 1
; XFAIL: *
; Indvars can't evaluate this loop, because ScalarEvolution can't compute
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: not grep trunc %t
; RUN: grep and %t | count 1
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep {icmp ugt i8\\\*} %t | count 1
; RUN: grep {icmp sgt i8\\\*} %t | count 1
-; RUN: opt %s -indvars | llvm-dis | grep indvar
+; RUN: opt %s -indvars -S | grep indvar
@G = global i32* null ; <i32**> [#uses=1]
@Array = external global [40 x i32] ; <[40 x i32]*> [#uses=1]
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep {%exitcond = icmp eq i64 %indvar.next, %n} %t
; RUN: grep {getelementptr i8\\* %A, i64 %indvar} %t
; RUN: grep getelementptr %t | count 1
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; Exactly one getelementptr for each load+store.
; RUN: grep getelementptr %t | count 6
; Each getelementptr using %struct.Q* %s as a base and not i8*.
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: not grep ptrtoint %t
; RUN: not grep inttoptr %t
; RUN: grep getelementptr %t | count 1
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: grep sext %t | count 1
; RUN: grep phi %t | count 1
; RUN: grep {phi i64} %t
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: not grep sext %t
define i64 @test(i64* nocapture %first, i32 %count) nounwind readonly {
-; RUN: opt %s -indvars | llvm-dis > %t
+; RUN: opt %s -indvars -S > %t
; RUN: not grep sext %t
; RUN: grep phi %t | count 1
-; RUN: opt %s -indvars | llvm-dis | FileCheck %s
+; RUN: opt %s -indvars -S | FileCheck %s
; PR4775
; Indvars shouldn't sink the alloca out of the entry block, even though
-; RUN: opt %s -indvars | llvm-dis | FileCheck %s --check-prefix=CHECK
+; RUN: opt %s -indvars -S | FileCheck %s --check-prefix=CHECK
declare i1 @b()
-; RUN: opt %s -indvars | llvm-dis | grep indvar
+; RUN: opt %s -indvars -S | grep indvar
@G = global i64 0 ; <i64*> [#uses=1]
; the exit value of the loop will be for some value, allowing us to substitute
; it directly into users outside of the loop, making the loop dead.
;
-; RUN: opt %s -indvars -loop-deletion -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -indvars -loop-deletion -simplifycfg -S | not grep br
define i32 @linear_setne() {
entry:
; These tests have an infinite trip count. We obviously shouldn't remove the
; loops! :)
;
-; RUN: opt %s -indvars -adce -simplifycfg | llvm-dis | grep icmp | wc -l > %t2
+; RUN: opt %s -indvars -adce -simplifycfg -S | grep icmp | wc -l > %t2
; RUN: llvm-as < %s | llvm-dis | grep icmp | wc -l > %t1
; RUN: diff %t1 %t2
-; RUN: opt %s -indvars -instcombine | llvm-dis | \
+; RUN: opt %s -indvars -instcombine -S | \
; RUN: grep {store i32 0}
; Test that -indvars can reduce variable stride IVs. If it can reduce variable
; stride iv's, it will make %iv. and %m.0.0 isomorphic to each other without
-; RUN: opt %s -inline | llvm-dis | not grep {invoke void asm}
+; RUN: opt %s -inline -S | not grep {invoke void asm}
; PR1335
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"
-; RUN: opt %s -inline | llvm-dis | grep "define internal i32 @bar"
+; RUN: opt %s -inline -S | grep "define internal i32 @bar"
@llvm.noinline = appending global [1 x i8*] [ i8* bitcast (i32 (i32, i32)* @bar to i8*) ], section "llvm.metadata" ; <[1 x i8*]*> [#uses=0]
define internal i32 @bar(i32 %x, i32 %y) {
-; RUN: opt %s -inline | llvm-dis | grep call
+; RUN: opt %s -inline -S | grep call
; 'bar' can be overridden at link-time, don't inline it.
-; RUN: llvm-as %s -o - | opt -inline | llvm-dis | grep nounwind
-; RUN: llvm-as %s -o - | opt -inline | llvm-dis | grep unreachable
+; RUN: llvm-as %s -o - | opt -inline -S | grep nounwind
+; RUN: llvm-as %s -o - | opt -inline -S | grep unreachable
declare i1 @extern()
-; RUN: opt %s -inline-threshold=0 -inline | llvm-dis | not grep call
+; RUN: opt %s -inline-threshold=0 -inline -S | not grep call
define i32 @fn2() alwaysinline {
ret i32 1
-; RUN: opt %s -inline | llvm-dis | grep call | count 1
+; RUN: opt %s -inline -S | grep call | count 1
define i32 @fn2() noinline {
ret i32 1
-; RUN: opt %s -always-inline | llvm-dis | not grep call
+; RUN: opt %s -always-inline -S | not grep call
; Ensure that threshold doesn't disrupt always inline.
-; RUN: opt %s -inline-threshold=-2000000001 -always-inline | llvm-dis | not grep call
+; RUN: opt %s -inline-threshold=-2000000001 -always-inline -S | not grep call
define internal i32 @if0() alwaysinline {
-; RUN: opt %s -always-inline | llvm-dis | grep {@foo}
+; RUN: opt %s -always-inline -S | grep {@foo}
; Ensure that foo is not removed by always inliner
; PR 2945
-; RUN: opt %s -inline | llvm-dis | grep call
+; RUN: opt %s -inline -S | grep call
; Do not inline calls to variable-sized alloca.
@q = common global i8* null ; <i8**> [#uses=1]
-; RUN: opt %s -inline | llvm-dis | grep {call.*fib} | count 4
+; RUN: opt %s -inline -S | grep {call.*fib} | count 4
; First call to fib from fib is inlined, producing 2 instead of 1, total 3.
; Second call to fib from fib is not inlined because new body of fib exceeds
; inlining limit of 200. Plus call in main = 4 total.
-; RUN: opt %s -inline | llvm-dis | not grep callee
+; RUN: opt %s -inline -S | not grep callee
; rdar://6655932
; If callee is marked alwaysinline, inline it! Even if callee has dynamic
-; RUN: opt %s -inline | llvm-dis | FileCheck %s
+; RUN: opt %s -inline -S | FileCheck %s
; rdar://7173846
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin10.0"
-; RUN: opt %s -inline | llvm-dis | grep {llvm.memcpy}
+; RUN: opt %s -inline -S | grep {llvm.memcpy}
; Inlining a byval struct should cause an explicit copy into an alloca.
-; RUN: opt %s -inline | llvm-dis | not grep {llvm.memcpy}
+; RUN: opt %s -inline -S | not grep {llvm.memcpy}
; Inlining a byval struct should NOT cause an explicit copy
; into an alloca if the function is readonly
-; RUN: opt %s -inline | llvm-dis | grep {ret i32 1}
+; RUN: opt %s -inline -S | grep {ret i32 1}
; ModuleID = 'short.opt.bc'
define i32 @testBool(i1 %X) {
; This test ensures that inlining an "empty" function does not destroy the CFG
;
-; RUN: opt %s -inline | llvm-dis | not grep br
+; RUN: opt %s -inline -S | not grep br
define i32 @func(i32 %i) {
ret i32 %i
; Functions with dynamic allocas can only be inlined into functions that
; already have dynamic allocas.
-; RUN: opt %s -inline | llvm-dis | \
+; RUN: opt %s -inline -S | \
; RUN: grep llvm.stacksave
-; RUN: opt %s -inline | llvm-dis | not grep callee
+; RUN: opt %s -inline -S | not grep callee
declare void @ext(i32*)
-; RUN: opt %s -inline -constprop | llvm-dis > %t
+; RUN: opt %s -inline -constprop -S > %t
; RUN: not grep test_function %t
; RUN: grep {ret i32 5} %t
-; RUN: opt %s -inline | llvm-dis | not grep {tail call void @llvm.memcpy.i32}
+; RUN: opt %s -inline -S | not grep {tail call void @llvm.memcpy.i32}
; PR3550
define internal void @foo(i32* %p, i32* %q) {
-; RUN: opt %s -inline | llvm-dis | not grep tail
+; RUN: opt < %s -inline -S | not grep tail
declare void @bar(i32*)
; Test that the inliner doesn't leave around dead allocas, and that it folds
; uncond branches away after it is done specializing.
-; RUN: opt %s -inline | llvm-dis | \
+; RUN: opt %s -inline -S | \
; RUN: not grep {alloca.*uses=0}
-; RUN: opt %s -inline | llvm-dis | \
+; RUN: opt %s -inline -S | \
; RUN: not grep {br label}
@A = weak global i32 0 ; <i32*> [#uses=1]
@B = weak global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -inline | llvm-dis | not grep callee
-; RUN: opt %s -inline | llvm-dis | not grep div
+; RUN: opt %s -inline -S | not grep callee
+; RUN: opt %s -inline -S | not grep div
define internal i32 @callee(i32 %A, i32 %B) {
; This checks to ensure that the inline pass deletes functions if they get
; inlined into all of their callers.
-; RUN: opt %s -inline | llvm-dis | \
+; RUN: opt %s -inline -S | \
; RUN: not grep @reallysmall
define internal i32 @reallysmall(i32 %A) {
-; RUN: opt %s -inline | llvm-dis | \
+; RUN: opt %s -inline -S | \
; RUN: not grep {callee\[12\](}
-; RUN: opt %s -inline | llvm-dis | not grep mul
+; RUN: opt %s -inline -S | not grep mul
define internal i32 @callee1(i32 %A, i32 %B) {
%cond = icmp eq i32 %A, 123 ; <i1> [#uses=1]
; Test that we can inline a simple function, turning the calls in it into invoke
; instructions
-; RUN: opt %s -inline | llvm-dis | \
+; RUN: opt %s -inline -S | \
; RUN: not grep {call\[^e\]}
declare void @might_throw()
; Test that if an invoked function is inlined, and if that function cannot
; throw, that the dead handler is now unreachable.
-; RUN: opt %s -inline -simplifycfg | llvm-dis | \
+; RUN: opt %s -inline -simplifycfg -S | \
; RUN: not grep UnreachableExceptionHandler
declare void @might_throw()
; Test that any rethrown exceptions in an inlined function are automatically
; turned into branches to the invoke destination.
-; RUN: opt %s -inline | llvm-dis | not grep unwind$
+; RUN: opt %s -inline -S | not grep unwind$
declare void @might_throw()
; Instcombine was missing a test that caused it to make illegal transformations
; sometimes. In this case, it transforms the sub into an add:
-; RUN: opt %s -instcombine | llvm-dis | grep sub
+; RUN: opt %s -instcombine -S | grep sub
;
define i32 @test(i32 %i, i32 %j) {
%A = mul i32 %i, %j
; This testcase is incorrectly getting completely eliminated. There should be
; SOME instruction named %c here, even if it's a bitwise and.
;
-; RUN: opt %s -instcombine | llvm-dis | grep %c
+; RUN: opt %s -instcombine -S | grep %c
;
define i64 @test3(i64 %A) {
%c1 = trunc i64 %A to i8 ; <i8> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep add
+; RUN: opt %s -instcombine -S | not grep add
define i32 @test(i32 %A) {
%A.neg = sub i32 0, %A ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep 4294967295
+; RUN: opt %s -instcombine -S | grep 4294967295
define i64 @test(i64 %Val) {
%tmp.3 = trunc i64 %Val to i32 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep load
+; RUN: opt %s -instcombine -S | grep load
define void @test(i32* %P) {
; Dead but not deletable!
; The cast in this testcase is not eliminable on a 32-bit target!
-; RUN: opt %s -instcombine | llvm-dis | grep inttoptr
+; RUN: opt %s -instcombine -S | grep inttoptr
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine | llvm-dis | grep call | notcast
+; RUN: opt %s -instcombine -S | grep call | notcast
declare void @free(i8*)
-; RUN: opt %s -instcombine | llvm-dis | not grep 34
+; RUN: opt %s -instcombine -S | not grep 34
define i32 @test(i32 %X) {
; Do not fold into shr X, 34, as this uses undefined behavior!
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {ret i1 false}
define i1 @test(i1 %V) {
-; RUN: opt %s -instcombine -mem2reg | llvm-dis | \
+; RUN: opt %s -instcombine -mem2reg -S | \
; RUN: not grep {i32 1}
; When propagating the load through the select, make sure that the load is
-; RUN: opt %s -instcombine | llvm-dis | not grep -- -65536
+; RUN: opt %s -instcombine -S | not grep -- -65536
define i1 @test(i32 %tmp.124) {
%tmp.125 = shl i32 %tmp.124, 8 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep and
+; RUN: opt < %s -instcombine -S | not grep and
define i8 @test21(i8 %A) {
;; sign extend
; be eliminated. In many cases the setCC is also eliminated based on the
; constant value and the range of the casted value.
;
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine -S | \
; RUN: notcast .*int
; END.
define i1 @lt_signed_to_large_unsigned(i8 %SB) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {ret i1 false}
define i1 @test(i64 %tmp.169) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {ret i1 true}
; PR586
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep undef
define i32 @test(i8 %A) {
-; RUN: opt %s -instcombine | llvm-dis | grep shl
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt %s -instcombine -S | grep shl
+; RUN: opt %s -instcombine -S | notcast
; This cannot be turned into a sign extending cast!
-; RUN: opt %s -instcombine | llvm-dis | grep and
+; RUN: opt %s -instcombine -S | grep and
; PR913
define i32 @test(i32* %tmp1) {
; The optimizer should be able to remove cast operation here.
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine -S | \
; RUN: not grep sext.*i32
define i1 @eq_signed_to_small_unsigned(i8 %SB) {
; This test case is reduced from llvmAsmParser.cpp
; The optimizer should not remove the cast here.
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine -S | \
; RUN: grep sext.*i32
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine -S | \
; RUN: grep and
define i64 @foo(i64 %tmp, i64 %tmp2) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep mul | count 2
define <4 x float> @test(<4 x float> %V) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep memmove.i32
; Instcombine was trying to turn this into a memmove.i32
-; RUN: opt %s -instcombine | llvm-dis | grep lshr
+; RUN: opt %s -instcombine -S | grep lshr
; Verify this is not turned into -1.
define i32 @test(i8 %amt) {
-; RUN: opt %s -instcombine | llvm-dis | grep and.*32
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | grep and.*32
+; RUN: opt %s -instcombine -S | \
; RUN: not grep or.*153
; PR1014
-; RUN: opt %s -instcombine | llvm-dis | grep sub
-; RUN: opt %s -instcombine | llvm-dis | grep add
+; RUN: opt %s -instcombine -S | grep sub
+; RUN: opt %s -instcombine -S | grep add
define <4 x float> @test(<4 x float> %tmp26, <4 x float> %tmp53) {
; (X+Y)-Y != X for fp vectors.
-; RUN: opt %s -instcombine | llvm-dis | grep zext
+; RUN: opt %s -instcombine -S | grep zext
; Never merge these two conversions, even though it's possible: this is
; significantly more expensive than the two conversions on some targets
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {%bothcond =}
define i1 @Doit_bb(i32 %i.0) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {icmp sgt}
; END.
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine | llvm-dis | grep select
+; RUN: opt %s -instcombine -S | grep select
; END.
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep icmp | count 1
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {icmp ugt} | count 1
; END.
-; RUN: opt %s -instcombine | llvm-dis | grep {icmp ugt}
+; RUN: opt %s -instcombine -S | grep {icmp ugt}
; PR1107
; PR1940
-; RUN: opt %s -instcombine | llvm-dis | grep {fcmp uno.*0.0}
+; RUN: opt %s -instcombine -S | grep {fcmp uno.*0.0}
; PR1111
define i1 @test(double %X) {
%tmp = fcmp une double %X, %X
-; RUN: opt %s -instcombine | llvm-dis | grep {ugt.*, 1}
+; RUN: opt %s -instcombine -S | grep {ugt.*, 1}
define i1 @test(i32 %tmp1030) {
%tmp1037 = icmp ne i32 %tmp1030, 40 ; <i1> [#uses=1]
-; RUN: opt %s -instcombine -mem2reg | llvm-dis | grep {%A = alloca}
-; RUN: opt %s -instcombine -mem2reg | llvm-dis | \
+; RUN: opt %s -instcombine -mem2reg -S | grep {%A = alloca}
+; RUN: opt %s -instcombine -mem2reg -S | \
; RUN: not grep {%B = alloca}
; END.
-;RUN: opt %s -instcombine | llvm-dis | grep zext
+;RUN: opt %s -instcombine -S | grep zext
; Make sure the uint isn't removed. Instcombine in llvm 1.9 was dropping the
; uint cast which was causing a sign extend. This only affected code with
-; RUN: opt %s -instcombine | llvm-dis | grep ret
+; RUN: opt %s -instcombine -S | grep ret
; PR1217
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine | llvm-dis | grep {icmp sle}
+; RUN: opt %s -instcombine -S | grep {icmp sle}
; PR1244
define i1 @test(i32 %c.3.i, i32 %d.292.2.i) {
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | grep zext
+; RUN: llvm-as %s -o - | opt -instcombine -S | grep zext
; PR1261.
define i16 @test(i31 %zzz) {
; For PR1248
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | grep {ugt i32 .*, 11}
+; RUN: llvm-as %s -o - | opt -instcombine -S | grep {ugt i32 .*, 11}
define i1 @test(i32 %tmp6) {
%tmp7 = sdiv i32 %tmp6, 12 ; <i32> [#uses=1]
icmp ne i32 %tmp7, -6 ; <i1>:1 [#uses=1]
; PR1271
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {icmp eq i32 .tmp.*, 2146435072}
%struct..0anon = type { i32, i32 }
%struct..1anon = type { double }
; PR1271
-; RUN: opt %s -instcombine | llvm-dis | grep and
+; RUN: opt %s -instcombine -S | grep and
define i1 @test(i32 %tmp13) {
entry:
%tmp14 = shl i32 %tmp13, 12 ; <i32> [#uses=1]
; PR1271
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {ashr i32 %.mp137, 2}
; END.
; is not done. It should be removed when code gen supports "funny"
; bit widths.
-; RUN: opt %s -instcombine | llvm-dis | grep {add i49.*-8388608}
+; RUN: opt %s -instcombine -S | grep {add i49.*-8388608}
define i49 @test5(i49 %x) {
;; If we have ADD(XOR(AND(X, 0xFF), 0x80), 0xF..F80), it's a sext.
; a malloc messes up the element count, causing an extra 4GB to be allocated on
; 64-bit targets.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep {= add }
+; RUN: opt %s -instcombine -S | not grep {= add }
target datalayout = "e-p:64:64:64-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"
target triple = "x86_64-unknown-freebsd6.2"
-; RUN: opt %s -instcombine | llvm-dis | grep {call.*sret}
+; RUN: opt %s -instcombine -S | grep {call.*sret}
; Make sure instcombine doesn't drop the sret attribute.
define void @blah(i16* %tmp10) {
-; RUN: opt %s -instcombine | llvm-dis | grep {ashr}
+; RUN: opt %s -instcombine -S | grep {ashr}
; PR1499
define void @av_cmp_q_cond_true(i32* %retval, i32* %tmp9, i64* %tmp10) {
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 true}
+; RUN: opt %s -instcombine -S | grep {ret i1 true}
; rdar://5278853
define i1 @test(i32 %tmp468) {
-; RUN: opt %s -instcombine | llvm-dis | grep icmp
+; RUN: opt %s -instcombine -S | grep icmp
; PR1646
@__gthrw_pthread_cancel = alias weak i32 (i32)* @pthread_cancel ; <i32 (i32)*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep {call i32 @f}
+; RUN: opt %s -instcombine -S | grep {call i32 @f}
%struct.FRAME.nest = type { i32, i32 (i32)* }
%struct.__builtin_trampoline = type { [10 x i8] }
-; RUN: opt %s -instcombine | llvm-dis | grep icmp
+; RUN: opt %s -instcombine -S | grep icmp
; PR1678
@A = alias weak void ()* @B ; <void ()*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep call
-; RUN: opt %s -std-compile-opts | llvm-dis | not grep xyz
+; RUN: opt %s -instcombine -S | not grep call
+; RUN: opt %s -std-compile-opts -S | not grep xyz
@.str = internal constant [4 x i8] c"xyz\00" ; <[4 x i8]*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep {call.*stacksave}
+; RUN: opt %s -instcombine -S | grep {call.*stacksave}
; PR1745
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"
-; RUN: opt %s -instcombine | llvm-dis | grep {icmp eq i32 %In, 1}
+; RUN: opt %s -instcombine -S | grep {icmp eq i32 %In, 1}
; PR1800
define i1 @test(i32 %In) {
-; RUN: opt %s -instcombine | llvm-dis | not grep bitcast
+; RUN: opt %s -instcombine -S | not grep bitcast
; PR1716
@.str = internal constant [4 x i8] c"%d\0A\00" ; <[4 x i8]*> [#uses=1]
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"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -instcombine | llvm-dis | not grep {ret i1 0}
+; RUN: opt %s -instcombine -S | not grep {ret i1 0}
; PR1850
define i1 @test() {
-; RUN: opt %s -instcombine | llvm-dis | not grep 1431655764
+; RUN: opt %s -instcombine -S | not grep 1431655764
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"
-; RUN: opt %s -instcombine | llvm-dis | grep nounwind
+; RUN: opt %s -instcombine -S | grep nounwind
define void @bar() {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {add} | count 1
+; RUN: opt %s -instcombine -S | grep {add} | count 1
define i32 @foo(i32 %a) {
entry:
-; RUN: opt %s -mem2reg -instcombine | llvm-dis | grep "ret i32 1" | count 8
+; RUN: opt %s -mem2reg -instcombine -S | grep "ret i32 1" | count 8
define i32 @test1() {
entry:
; Ignore stderr, we expect warnings there
-; RUN: opt %s -instcombine 2> /dev/null | llvm-dis | not grep bitcast
+; RUN: opt %s -instcombine 2> /dev/null -S | not grep bitcast
define void @a() {
ret void
-; RUN: opt %s -instcombine | llvm-dis | not grep bitcast
+; RUN: opt %s -instcombine -S | not grep bitcast
define void @f(i16 %y) {
ret void
-; RUN: opt %s -instcombine | llvm-dis | grep and
+; RUN: opt %s -instcombine -S | grep and
; PR1907
define i1 @test(i32 %c84.17) {
-; RUN: opt %s -instcombine | llvm-dis | grep bitcast | count 2
+; RUN: opt %s -instcombine -S | grep bitcast | count 2
define i32 @b(i32* inreg %x) signext {
ret i32 0
-; RUN: opt %s -instcombine | llvm-dis | grep zeroext
+; RUN: opt %s -instcombine -S | grep zeroext
%struct.FRAME.nest = type { i32, i32 (...)* }
%struct.__builtin_trampoline = type { [10 x i8] }
-; RUN: opt %s -instcombine | llvm-dis | notcast
-; RUN: opt %s -instcombine | llvm-dis | not grep {icmp s}
+; RUN: opt %s -instcombine -S | notcast
+; RUN: opt %s -instcombine -S | not grep {icmp s}
; PR1940
define i1 @test1(i8 %A, i8 %B) {
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt %s -instcombine -S | notcast
define i16 @test1(i16 %a) {
%tmp = zext i16 %a to i32 ; <i32> [#uses=2]
-; RUN: opt %s -instcombine | llvm-dis | grep select
+; RUN: opt %s -instcombine -S | grep select
define double @fold(i1 %a, double %b) {
%s = select i1 %a, double 0., double 1.
-; RUN: opt %s -instcombine | llvm-dis | not grep {a.off}
+; RUN: opt %s -instcombine -S | not grep {a.off}
; PR1949
define i1 @test1(i32 %a) {
-; RUN: opt %s -instcombine | llvm-dis | grep rem
+; RUN: opt %s -instcombine -S | grep rem
; PR1933
define i32 @fold(i32 %a) {
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i.* 0} | count 2
+; RUN: opt %s -instcombine -S | grep {ret i.* 0} | count 2
; PR2048
define i32 @i(i32 %a) {
-; RUN: opt %s -instcombine | llvm-dis | grep {sdiv i8 \%a, 9}
+; RUN: opt %s -instcombine -S | grep {sdiv i8 \%a, 9}
; PR2048
define i8 @i(i8 %a) {
-; RUN: opt %s -instcombine | llvm-dis | not grep mul
+; RUN: opt %s -instcombine -S | not grep mul
define i26 @test(i26 %a) nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {16} | count 1
+; RUN: opt %s -instcombine -S | grep {16} | count 1
define i8* @bork(i8** %qux) {
%tmp275 = load i8** %qux, align 1
;; The bitcast cannot be eliminated because byval arguments need
;; the correct type, or at least a type of the correct size.
-; RUN: opt %s -instcombine | llvm-dis | grep bitcast
+; RUN: opt %s -instcombine -S | grep bitcast
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9"
%struct.NSRect = type { [4 x float] }
-; RUN: opt %s -instcombine | llvm-dis | grep {volatile store}
+; RUN: opt %s -instcombine -S | grep {volatile store}
define void @test() {
%votf = alloca <4 x float> ; <<4 x float>*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep {volatile load} | count 2
+; RUN: opt %s -instcombine -S | grep {volatile load} | count 2
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
@g_1 = internal global i32 0 ; <i32*> [#uses=3]
-; RUN: opt %s -instcombine | llvm-dis | grep {volatile load} | count 2
+; RUN: opt %s -instcombine -S | grep {volatile load} | count 2
; PR2262
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -instcombine | llvm-dis | grep {store i8} | count 3
+; RUN: opt %s -instcombine -S | grep {store i8} | count 3
; PR2297
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 false} | count 2
+; RUN: opt %s -instcombine -S | grep {ret i1 false} | count 2
; PR2329
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"
-; RUN: opt %s -instcombine | llvm-dis | not grep sub
+; RUN: opt %s -instcombine -S | not grep sub
define <3 x i8> @f(<3 x i8> %a) {
%A = sub <3 x i8> zeroinitializer, %a
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 false}
+; RUN: opt %s -instcombine -S | grep {ret i1 false}
; PR2359
define i1 @f(i8* %x) {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {xor}
+; RUN: opt %s -instcombine -S | grep {xor}
; PR2389
define i1 @test(i1 %a, i1 %b) {
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
; RUN: grep {xor} %t
; RUN: grep {and} %t
; RUN: not grep {div} %t
-; RUN: opt %s -instcombine | llvm-dis | grep {phi i32} | count 2
+; RUN: opt %s -instcombine -S | grep {phi i32} | count 2
define void @test() nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {store i32} | count 2
+; RUN: opt %s -instcombine -S | grep {store i32} | count 2
@g_139 = global i32 0 ; <i32*> [#uses=2]
-; RUN: opt %s -instcombine | llvm-dis | grep {store i8} | count 2
+; RUN: opt %s -instcombine -S | grep {store i8} | count 2
define i32 @a(i8* %s) nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep load | count 3
+; RUN: opt %s -instcombine -S | grep load | count 3
; PR2471
declare i32 @x(i32*)
-; RUN: opt %s -instcombine | llvm-dis | grep {icmp eq i32 %In, 15}
+; RUN: opt %s -instcombine -S | grep {icmp eq i32 %In, 15}
; PR2479
; (See also PR1800.)
-; RUN: opt %s -instcombine | llvm-dis | grep {call.*llvm.stackrestore}
+; RUN: opt %s -instcombine -S | grep {call.*llvm.stackrestore}
; PR2488
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"
target triple = "i386-pc-linux-gnu"
-; RUN: opt %s -instcombine | llvm-dis | grep icmp | count 1
+; RUN: opt %s -instcombine -S | grep icmp | count 1
; PR2330
define i1 @foo(i32 %a, i32 %b) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {icmp ne i32 \%a}
+; RUN: opt %s -instcombine -S | grep {icmp ne i32 \%a}
; PR2330
define i1 @foo(i32 %a) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep -v {i32 8}
+; RUN: opt %s -instcombine -S | grep -v {i32 8}
; PR2330
define i32 @a(i32 %a) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {volatile load} | count 2
+; RUN: opt %s -instcombine -S | grep {volatile load} | count 2
; PR2496
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -instcombine | llvm-dis | not grep {sub i32 0}
+; RUN: opt %s -instcombine -S | not grep {sub i32 0}
; PR2330
define i32 @foo(i32 %a) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {%C = xor i1 %A, true}
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 false}
+; RUN: opt %s -instcombine -S | grep {%C = xor i1 %A, true}
+; RUN: opt %s -instcombine -S | grep {ret i1 false}
; PR2539
define i1 @test1(i1 %A) {
-; RUN: opt %s -instcombine | llvm-dis | not grep add
-; RUN: opt %s -instcombine | llvm-dis | not grep mul
+; RUN: opt %s -instcombine -S | not grep add
+; RUN: opt %s -instcombine -S | not grep mul
; PR2330
define i1 @f(i32 %x, i32 %y) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | not grep rem
+; RUN: opt %s -instcombine -S | not grep rem
; PR2330
define i32 @a(i32 %b) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {lshr.*3}
-; RUN: opt %s -instcombine | llvm-dis | grep {call .*%cond}
+; RUN: opt %s -instcombine -S | grep {lshr.*3}
+; RUN: opt %s -instcombine -S | grep {call .*%cond}
; PR2506
; We can simplify the operand of udiv to '8', but not the operand to the
-; RUN: opt %s -instcombine | llvm-dis | grep sub
+; RUN: opt %s -instcombine -S | grep sub
; PR2553
define double @test(double %X) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | not grep {store }
+; RUN: opt %s -instcombine -S | not grep {store }
; PR2296
@G = common global double 0.000000e+00, align 16
-; RUN: opt %s -instcombine | llvm-dis | not grep or
+; RUN: opt < %s -instcombine -S | not grep or
; PR2629
define void @f(i8* %x) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | not grep xor
+; RUN: opt %s -instcombine -S | not grep xor
define i1 @test1(i8 %x, i8 %y) {
%X = xor i8 %x, 128
-; RUN: opt %s -instcombine | llvm-dis | grep {or i1}
+; RUN: opt %s -instcombine -S | grep {or i1}
; PR2844
define i32 @test(i32 %p_74) {
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 false}
+; RUN: opt %s -instcombine -S | grep {ret i1 false}
; PR2697
define i1 @x(i32 %x) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 true}
+; RUN: opt %s -instcombine -S | grep {ret i1 true}
; PR2993
define i1 @foo(i32 %x) {
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
; RUN: grep {icmp eq} %t
; RUN: grep {ret i1 false} %t | count 2
; RUN: grep {ret i1 true} %t | count 2
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
; RUN: grep urem %t | count 3
; RUN: grep srem %t | count 1
; RUN: grep sub %t | count 2
-; RUN: opt %s -instcombine | llvm-dis | not grep div
+; RUN: opt %s -instcombine -S | not grep div
define <2 x i8> @f(<2 x i8> %x) {
%A = udiv <2 x i8> %x, <i8 1, i8 1>
-; RUN: opt %s -instcombine | llvm-dis | not grep mul
+; RUN: opt %s -instcombine -S | not grep mul
define <2 x i8> @f(<2 x i8> %x) {
%A = mul <2 x i8> %x, <i8 1, i8 1>
-; RUN: opt %s -instcombine | llvm-dis | not grep div
+; RUN: opt %s -instcombine -S | not grep div
define i8 @test(i8 %x) readnone nounwind {
%A = udiv i8 %x, 250
-; RUN: opt %s -instcombine | llvm-dis | grep {i8 2, i8 2}
+; RUN: opt %s -instcombine -S | grep {i8 2, i8 2}
; PR2756
define <2 x i8> @foo(<2 x i8> %x) {
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
; RUN: grep {, align 4} %t | count 3
; RUN: grep {, align 8} %t | count 3
; rdar://6480438
-; RUN: opt %s -instcombine | llvm-dis | grep {store.*addrspace(1)}
+; RUN: opt %s -instcombine -S | grep {store.*addrspace(1)}
; PR3335
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.6"
-; RUN: opt %s -simplifycfg -instcombine | llvm-dis | grep 0x7FF8000000000000 | count 7
-; RUN: opt %s -simplifycfg -instcombine | llvm-dis | grep 0x7FF00000FFFFFFFF | count 5
-; RUN: opt %s -simplifycfg -instcombine | llvm-dis | grep {0\\.0} | count 3
-; RUN: opt %s -simplifycfg -instcombine | llvm-dis | grep {3\\.5} | count 1
+; RUN: opt %s -simplifycfg -instcombine -S | grep 0x7FF8000000000000 | count 7
+; RUN: opt %s -simplifycfg -instcombine -S | grep 0x7FF00000FFFFFFFF | count 5
+; RUN: opt %s -simplifycfg -instcombine -S | grep {0\\.0} | count 3
+; RUN: opt %s -simplifycfg -instcombine -S | grep {3\\.5} | count 1
;
; ModuleID = 'apf.c'
-; RUN: opt %s -simplifycfg -instcombine | llvm-dis | grep 0x3FB99999A0000000 | count 2
-; RUN: opt %s -simplifycfg -instcombine | llvm-dis | grep 0xBFB99999A0000000 | count 2
+; RUN: opt %s -simplifycfg -instcombine -S | grep 0x3FB99999A0000000 | count 2
+; RUN: opt %s -simplifycfg -instcombine -S | grep 0xBFB99999A0000000 | count 2
; check constant folding for 'frem'. PR 3316.
; ModuleID = 'tt.c'
-; RUN: opt %s -instcombine | llvm-dis | grep {%B = add i8 %b, %x}
+; RUN: opt %s -instcombine -S | grep {%B = add i8 %b, %x}
; PR2698
declare void @use1(i1)
-; RUN: opt %s -instcombine -scalarrepl | llvm-dis | not grep { = alloca}
+; RUN: opt %s -instcombine -scalarrepl -S | not grep { = alloca}
; rdar://6417724
; Instcombine shouldn't do anything to this function that prevents promoting the allocas inside it.
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 3679669}
+; RUN: opt %s -instcombine -S | grep {ret i32 3679669}
; PR3595
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"
-; RUN: opt %s -instcombine | llvm-dis | grep {ashr i32 %val, 31}
+; RUN: opt %s -instcombine -S | grep {ashr i32 %val, 31}
; PR3851
define i32 @foo2(i32 %val) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {mul i64}
+; RUN: opt %s -instcombine -S | grep {mul i64}
; rdar://6762288
; Instcombine should not promote the mul to i96 because it is definitely
-; RUN: opt %s -instcombine | llvm-dis | not grep cmp
+; RUN: opt %s -instcombine -S | not grep cmp
; rdar://6903175
define i1 @f0(i32 *%a) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {store i32 0,}
+; RUN: opt %s -instcombine -S | grep {store i32 0,}
; PR4366
define void @a() {
-; RUN: opt %s -instcombine | llvm-dis | grep srem
+; RUN: opt %s -instcombine -S | grep srem
; PR3439
define i32 @a(i32 %x) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep select | not grep {i32\\*}
; This testcase corresponds to PR362, which notices that this horrible code
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt %s -instcombine -S | notcast
target datalayout = "e-p:32:32"
define i32* @test(i32* %P) {
; This is the sequence of stuff that the Java front-end expands for a single
; <= comparison. Check to make sure we turn it into a <= (only)
-; RUN: opt %s -instcombine | llvm-dis | grep {%c3 = icmp sle i32 %A, %B}
+; RUN: opt %s -instcombine -S | grep {%c3 = icmp sle i32 %A, %B}
define i1 @le(i32 %A, i32 %B) {
%c1 = icmp sgt i32 %A, %B ; <i1> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep {add i32}
-; RUN: opt %s -instcombine | llvm-dis | grep sext | count 1
+; RUN: opt %s -instcombine -S | grep {add i32}
+; RUN: opt %s -instcombine -S | grep sext | count 1
; Should only have one sext and the add should be i32 instead of i64.
-; RUN: opt %s -instcombine | llvm-dis | grep {add i32}
+; RUN: opt %s -instcombine -S | grep {add i32}
define double @x(i32 %a, i32 %b) nounwind {
%m = lshr i32 %a, 24
; This test makes sure that add instructions are properly eliminated.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v OK | not grep add
define i32 @test1(i32 %A) {
-; RUN: opt %s -instcombine | llvm-dis | not grep add
+; RUN: opt < %s -instcombine -S | not grep add
define i64 @test1(i64 %A, i32 %B) {
%tmp12 = zext i32 %B to i64
-; RUN: opt %s -instcombine | llvm-dis | grep inttoptr | count 2
+; RUN: opt %s -instcombine -S | grep inttoptr | count 2
;; 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"
-; RUN: opt %s -instcombine | llvm-dis | grep { sub } | count 1
+; RUN: opt %s -instcombine -S | grep { sub } | count 1
; PR2047
define i32 @l(i32 %a, i32 %b, i32 %c, i32 %d) {
-; RUN: opt %s -instcombine | llvm-dis | grep {icmp s\[lg\]t i32 %n, 0} | count 16
+; RUN: opt %s -instcombine -S | grep {icmp s\[lg\]t i32 %n, 0} | count 16
; Instcombine should recognize that this code can be adjusted
; to fit the canonical smax/smin pattern.
-; RUN: opt %s -instcombine | llvm-dis | grep {align 16} | count 1
+; RUN: opt %s -instcombine -S | grep {align 16} | count 1
; A multi-dimensional array in a nested loop doing vector stores that
; aren't yet aligned. Instcombine can understand the addressing in the
-; RUN: opt %s -instcombine | llvm-dis | grep {align 16} | count 1
+; RUN: opt %s -instcombine -S | grep {align 16} | count 1
; Instcombine should be able to prove vector alignment in the
; presence of a few mild address computation tricks.
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
; Don't assume that external global variables have their preferred
; alignment. They may only have the ABI minimum alignment.
-; RUN: opt %s -instcombine | llvm-dis | grep {GLOBAL.*align 16}
-; RUN: opt %s -instcombine | llvm-dis | grep {tmp = load}
+; RUN: opt %s -instcombine -S | grep {GLOBAL.*align 16}
+; RUN: opt %s -instcombine -S | grep {tmp = load}
@GLOBAL = internal global [4 x i32] zeroinitializer
; Zero byte allocas should be deleted.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep alloca
; END.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep and | count 1
; Should be optimized to one and.
-; RUN: opt %s -instcombine | llvm-dis | grep fcmp | count 3
-; RUN: opt %s -instcombine | llvm-dis | grep ret | grep 0
+; RUN: opt < %s -instcombine -S | grep fcmp | count 3
+; RUN: opt < %s -instcombine -S | grep ret | grep 0
define zeroext i8 @t1(float %x, float %y) nounwind {
%a = fcmp ueq float %x, %y
-; RUN: opt %s -instcombine | llvm-dis | grep {and i32 %x, %y} | count 4
-; RUN: opt %s -instcombine | llvm-dis | not grep {or}
+; RUN: opt < %s -instcombine -S | grep {and i32 %x, %y} | count 4
+; RUN: opt < %s -instcombine -S | not grep {or}
define i32 @func1(i32 %x, i32 %y) nounwind {
entry:
;
; Which corresponds to test1.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {or }
define i32 @test1(i32 %X, i32 %Y) {
-; RUN: opt %s -instcombine | llvm-dis | grep xor | count 4
-; RUN: opt %s -instcombine | llvm-dis | not grep and
-; RUN: opt %s -instcombine | llvm-dis | not grep { or}
+; RUN: opt < %s -instcombine -S | grep xor | count 4
+; RUN: opt < %s -instcombine -S | not grep and
+; RUN: opt < %s -instcombine -S | not grep { or}
; PR1510
-; RUN: opt %s -instcombine | llvm-dis | grep {and i32 %a, 1} | count 4
-; RUN: opt %s -instcombine | llvm-dis | grep {or i32 %0, %b} | count 4
+; RUN: opt %s -instcombine -S | grep {and i32 %a, 1} | count 4
+; RUN: opt %s -instcombine -S | grep {or i32 %0, %b} | count 4
define i32 @func1(i32 %a, i32 %b) nounwind readnone {
-; RUN: opt %s -instcombine | llvm-dis | grep and | count 1
-; RUN: opt %s -instcombine | llvm-dis | grep xor | count 2
+; RUN: opt < %s -instcombine -S | grep and | count 1
+; RUN: opt < %s -instcombine -S | grep xor | count 2
; (x&z) ^ (y&z) -> (x^y)&z
define i32 @test1(i32 %x, i32 %y, i32 %z) {
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep and
+; RUN: opt < %s -instcombine -S | not grep and
define i32 @test1(i32 %A) {
; zero result
-; RUN: opt %s -instcombine | llvm-dis | not grep and
+; RUN: opt < %s -instcombine -S | not grep and
; PR1738
; This test makes sure that add instructions are properly eliminated.
; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v OK | not grep add
; This test makes sure that add instructions are properly eliminated.
; This test is for Integer BitWidth > 64 && BitWidth <= 1024.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v OK | not grep add
; END.
-; RUN: opt %s -instcombine | llvm-dis | grep and | count 2
+; RUN: opt < %s -instcombine -S | grep and | count 2
; Should be optimized to one and.
define i1 @test1(i33 %a, i33 %b) {
;
; This tests arbitrary precision integers.
-; RUN: opt %s -instcombine | llvm-dis | not grep {or }
+; RUN: opt %s -instcombine -S | not grep {or }
; END.
define i17 @test1(i17 %X, i17 %Y) {
; This test case checks that the merge of and/xor can work on arbitrary
; precision integers.
-; RUN: opt %s -instcombine | llvm-dis | grep and | count 1
-; RUN: opt %s -instcombine | llvm-dis | grep xor | count 2
+; RUN: opt < %s -instcombine -S | grep and | count 1
+; RUN: opt < %s -instcombine -S | grep xor | count 2
; (x &z ) ^ (y & z) -> (x ^ y) & z
define i57 @test1(i57 %x, i57 %y, i57 %z) {
; This test makes sure that and instructions are properly eliminated.
; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0.
-; RUN: opt %s -instcombine | llvm-dis | not grep {and }
+; RUN: opt %s -instcombine -S | not grep {and }
; END.
define i39 @test0(i39 %A) {
; This test makes sure that and instructions are properly eliminated.
; This test is for Integer BitWidth > 64 && BitWidth <= 1024.
-; RUN: opt %s -instcombine | llvm-dis | not grep {and }
+; RUN: opt %s -instcombine -S | not grep {and }
; END.
-; RUN: opt %s -instcombine | llvm-dis | grep call | not grep bitcast
+; RUN: opt %s -instcombine -S | grep call | not grep bitcast
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -instcombine | llvm-dis | not grep bitcast
+; RUN: opt %s -instcombine -S | not grep bitcast
define i19 @test1(i43 %val) {
%t1 = bitcast i43 %val to i43
-; RUN: opt %s -instcombine | llvm-dis | not grep i41
+; RUN: opt %s -instcombine -S | not grep i41
define i61 @test1(i61 %X) {
%Y = trunc i61 %X to i41 ;; Turn i61o an AND
; Tests to make sure elimination of casts is working correctly
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt < %s -instcombine -S | notcast
define i17 @test1(i17 %a) {
%tmp = zext i17 %a to i37 ; <i37> [#uses=2]
; This test makes sure that div instructions are properly eliminated.
; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep div
+; RUN: opt < %s -instcombine -S | not grep div
define i33 @test1(i33 %X) {
; This test makes sure that div instructions are properly eliminated.
; This test is for Integer BitWidth >= 64 && BitWidth <= 1024.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep div
+; RUN: opt < %s -instcombine -S | not grep div
define i333 @test1(i333 %X) {
; Test that elimination of logical operators works with
; arbitrary precision integers.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {(and\|xor\|add\|shl\|shr)}
; END.
; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep mul
+; RUN: opt < %s -instcombine -S | not grep mul
define i17 @test1(i17 %X) {
; This test is for Integer BitWidth >= 64 && BitWidth % 2 >= 1024.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep mul
+; RUN: opt < %s -instcombine -S | not grep mul
define i177 @test1(i177 %X) {
; This test makes sure that the xor instructions are properly eliminated
; when arbitrary precision integers are used.
-; RUN: opt %s -instcombine | llvm-dis | not grep xor
+; RUN: opt %s -instcombine -S | not grep xor
define i33 @test1(i33 %A) {
%B = xor i33 %A, -1
; This test is for Integer BitWidth <= 64 && BitWidth % 2 != 0.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep or
+; RUN: opt < %s -instcombine -S | not grep or
define i7 @test0(i7 %X) {
; This test makes sure that or instructions are properly eliminated.
; This test is for Integer BitWidth > 64 && BitWidth <= 1024.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep or
+; RUN: opt < %s -instcombine -S | not grep or
define i777 @test0(i777 %X) {
; This test makes sure that these instructions are properly eliminated.
; This test is for Integer BitWidth < 64 && BitWidth % 2 != 0.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep rem
+; RUN: opt < %s -instcombine -S | not grep rem
define i33 @test1(i33 %A) {
; This test makes sure that these instructions are properly eliminated.
; This test is for Integer BitWidth >= 64 && BitWidth <= 1024.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep rem
+; RUN: opt < %s -instcombine -S | not grep rem
define i333 @test1(i333 %A) {
; This test makes sure that these instructions are properly eliminated.
-; RUN: opt %s -instcombine | llvm-dis | not grep select
+; RUN: opt < %s -instcombine -S | not grep select
define i41 @test1(i1 %C) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: egrep {shl|lshr|ashr} | count 3
define i41 @test0(i41 %A, i41 %B, i41 %C) {
; This test makes sure that shit instructions are properly eliminated
; even with arbitrary precision integers.
-; RUN: opt %s -instcombine | llvm-dis | not grep sh
+; RUN: opt < %s -instcombine -S | not grep sh
; END.
define i47 @test1(i47 %A) {
-; RUN: opt %s -instcombine | llvm-dis | grep shl
+; RUN: opt %s -instcombine -S | grep shl
; END.
define i1 @test0(i39 %X, i39 %A) {
; even with arbitrary precision integers.
;
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v {sub i19 %Cok, %Bok} | grep -v {sub i25 0, %Aok} | not grep sub
; END.
; This test makes sure that xor instructions are properly eliminated.
; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0.
-; RUN: opt %s -instcombine | llvm-dis | not grep {xor }
+; RUN: opt %s -instcombine -S | not grep {xor }
define i47 @test1(i47 %A, i47 %B) {
; This test makes sure that xor instructions are properly eliminated.
; This test is for Integer BitWidth > 64 && BitWidth <= 1024.
-; RUN: opt %s -instcombine | llvm-dis | not grep {xor }
+; RUN: opt %s -instcombine -S | not grep {xor }
; END.
; Tests to make sure elimination of casts is working correctly
; This test is for Integer BitWidth <= 64 && BitWidth % 2 != 0.
-; RUN: opt %s -instcombine | llvm-dis | notcast {} {%c1.*}
+; RUN: opt %s -instcombine -S | notcast {} {%c1.*}
define i47 @test_sext_zext(i11 %A) {
%c1 = zext i11 %A to i39
; Tests to make sure elimination of casts is working correctly
; This test is for Integer BitWidth > 64 && BitWidth <= 1024.
-; RUN: opt %s -instcombine | llvm-dis | notcast {} {%c1.*}
+; RUN: opt %s -instcombine -S | notcast {} {%c1.*}
define i1024 @test_sext_zext(i77 %A) {
%c1 = zext i77 %A to i533
-; RUN: opt %s -instcombine | llvm-dis | not grep ashr
+; RUN: opt < %s -instcombine -S | not grep ashr
define i32 @foo(i32 %x) {
%o = and i32 %x, 1
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt < %s -instcombine -S | notcast
define i32 @testAdd(i32 %X, i32 %Y) {
%tmp = add i32 %X, %Y
; This file contains various testcases that require tracking whether bits are
; set or cleared by various instructions.
-; RUN: opt %s -instcombine -instcombine | llvm-dis |\
+; RUN: opt %s -instcombine -instcombine -S |\
; RUN: not grep %ELIM
; Reduce down to a single XOR
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 0}
+; RUN: opt %s -instcombine -S | grep {ret i32 0}
; PR4487
; Bitcasts between vectors and scalars are valid, despite being ill-advised.
-; RUN: opt %s -instcombine | llvm-dis | grep element | count 4
+; RUN: opt %s -instcombine -S | grep element | count 4
define double @a(<1 x i64> %y) {
%c = bitcast <1 x i64> %y to double
-; RUN: opt %s -instcombine | llvm-dis | not grep bitcast
+; RUN: opt < %s -instcombine -S | not grep bitcast
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"
; Tests to make sure bit counts of constants are folded
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 19}
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | grep {ret i32 19}
+; RUN: opt %s -instcombine -S | \
; RUN: grep -v declare | not grep llvm.ct
declare i31 @llvm.ctpop.i31(i31 %val)
-; RUN: opt %s -instcombine -simplifycfg | llvm-dis |\
+; RUN: opt %s -instcombine -simplifycfg -S |\
; RUN: not grep {call void @abort}
@b_rec.0 = external global i32 ; <i32*> [#uses=2]
-; RUN: opt %s -instcombine | llvm-dis | grep ret | count 6
-; RUN: opt %s -instcombine | llvm-dis | not grep call.*bswap
+; RUN: opt %s -instcombine -S | grep ret | count 6
+; RUN: opt %s -instcombine -S | not grep call.*bswap
define i1 @test1(i16 %tmp2) {
%tmp10 = call i16 @llvm.bswap.i16( i16 %tmp2 ) ; <i16> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {call.*llvm.bswap} | count 6
define i32 @test1(i32 %i) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep call | not grep bitcast
target datalayout = "e-p:32:32"
; Ignore stderr, we expect warnings there
-; RUN: opt %s -instcombine 2> /dev/null | llvm-dis | \
+; RUN: opt %s -instcombine 2> /dev/null -S | \
; RUN: grep call | notcast
; END.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {icmp ne\|icmp ule\|icmp uge}
define i32 @test1(i32 %X, i32 %Y) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep bitcast
define i1 @test1(i32 %val) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep i8
define i32 @test1(i32 %X) {
-; RUN: opt %s -instcombine -globaldce | llvm-dis | \
+; RUN: opt %s -instcombine -globaldce -S | \
; RUN: not grep Array
; Pulling the cast out of the load allows us to eliminate the load, and then
; test that casted mallocs get converted to malloc of the right type
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep bitcast
; The target datalayout is important for this test case. We have to tell
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt < %s -instcombine -S | notcast
define i32 @mul(i32 %x, i32 %y) {
%A = trunc i32 %x to i8
-; RUN: opt %s -instcombine -mem2reg | llvm-dis | \
+; RUN: opt %s -instcombine -mem2reg -S | \
; RUN: not grep load
define i32 @test1(i32* %P) {
; This tests for various complex cast elimination cases instcombine should
; handle.
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt < %s -instcombine -S | notcast
define i1 @test1(i32 %X) {
%A = bitcast i32 %X to i32 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep sext
+; RUN: opt %s -instcombine -S | not grep sext
; XFAIL: *
define zeroext i16 @t(i8 zeroext %on_off, i16* nocapture %puls) nounwind readonly {
; Tests to make sure elimination of casts is working correctly
-; RUN: opt %s -instcombine | llvm-dis | grep %c | notcast
+; RUN: opt %s -instcombine -S | grep %c | notcast
@inbuf = external global [32832 x i8] ; <[32832 x i8]*> [#uses=1]
; Tests to make sure elimination of casts is working correctly
-; RUN: opt %s -instcombine | llvm-dis | notcast
+; RUN: opt < %s -instcombine -S | notcast
define i16 @test1(i16 %a) {
%tmp = zext i16 %a to i32 ; <i32> [#uses=2]
-; RUN: opt %s -instcombine | llvm-dis | not grep getelementptr
+; RUN: opt %s -instcombine -S | not grep getelementptr
; PR2831
; Don't raise arbitrary inttoptr+arithmetic+ptrtoint to getelementptr.
-; RUN: opt %s -instcombine | llvm-dis | grep bitcast | count 1
+; RUN: opt %s -instcombine -S | grep bitcast | count 1
; InstCombine can not 'load (cast P)' -> cast (load P)' if the cast changes
; the address space.
; Tests to make sure elimination of casts is working correctly
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
target datalayout = "p:32:32"
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
; Constant folding should fix notionally out-of-bounds indices
; and add inbounds keywords.
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 2143034560}
+; RUN: opt %s -instcombine -S | grep {ret i32 2143034560}
; Instcombine should be able to completely fold this code.
-; RUN: opt %s -instcombine | llvm-dis | grep {ret double .sy}
+; RUN: opt %s -instcombine -S | grep {ret double .sy}
define internal double @ScaleObjectAdd(double %sx, double %sy, double %sz) nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 %A}
-; RUN: opt %s -die | llvm-dis | not grep call.*llvm.stacksave
+; RUN: opt %s -instcombine -S | grep {ret i32 %A}
+; RUN: opt %s -die -S | not grep call.*llvm.stacksave
define i32 @test(i32 %A) {
%X = or i1 false, false
-; RUN: opt %s -instcombine | llvm-dis | not grep sdiv
+; RUN: opt %s -instcombine -S | not grep sdiv
; PR2740
define i1 @func_75(i32 %i2) nounwind {
; This test makes sure that div instructions are properly eliminated.
-; RUN: opt %s -instcombine | llvm-dis | not grep div
+; RUN: opt < %s -instcombine -S | not grep div
define i32 @test1(i32 %A) {
%B = sdiv i32 %A, 1 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep alloca | grep {align 16}
+; RUN: opt %s -instcombine -S | grep alloca | grep {align 16}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.6"
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
; CHECK: define i32 @foo
; CHECK: sdiv i32 %x, 8
-; RUN: opt %s -instcombine | llvm-dis | not grep extractvalue
+; RUN: opt < %s -instcombine -S | not grep extractvalue
; Instcombine should fold various combinations of insertvalue and extractvalue
; together
-; RUN: opt %s -instcombine | llvm-dis | not grep icmp
+; RUN: opt %s -instcombine -S | not grep icmp
define i1 @f(i1 %x) {
%b = and i1 %x, icmp eq (i8* inttoptr (i32 1 to i8*), i8* inttoptr (i32 2 to i8*))
-; RUN: opt %s -instcombine | llvm-dis | not grep zeroinitializer
+; RUN: opt %s -instcombine -S | not grep zeroinitializer
define void @foo(i64 %A, i64 %B) {
bb8:
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {call float bitcast} | count 1
%struct.NSObject = type { %struct.objc_class* }
%struct.NSArray = type { %struct.NSObject }
; Test some floating point casting cases
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | notcast
-; RUN: llvm-as %s -o - | opt -instcombine | llvm-dis | \
+; RUN: llvm-as %s -o - | opt -instcombine -S | notcast
+; RUN: llvm-as %s -o - | opt -instcombine -S | \
; RUN: egrep {ret i8 \(-1\)\|\(255\)}
define i8 @test1() {
-; RUN: opt %s -instcombine | llvm-dis | not grep fpext
+; RUN: opt < %s -instcombine -S | not grep fpext
@X = external global float
@Y = external global float
-; RUN: opt %s -instcombine | llvm-dis | grep fsub | count 2
+; RUN: opt < %s -instcombine -S | grep fsub | count 2
; PR4374
define float @func(float %a, float %b) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64"
%intstruct = type { i32 }
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
;; This tests that the div is hoisted into the then block.
define i32 @foo(i1 %C, i32 %A, i32 %B) {
-; RUN: opt %s -instcombine | llvm-dis | not grep icmp
+; RUN: opt < %s -instcombine -S | not grep icmp
define i32 @test1(i32 %X) {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {align 1}
+; RUN: opt %s -instcombine -S | grep {align 1}
; END.
%struct.p = type <{ i8, i32 }>
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep load
+; RUN: opt < %s -instcombine -S | not grep load
@X = constant i32 42 ; <i32*> [#uses=2]
@X2 = constant i32 47 ; <i32*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep load
+; RUN: opt < %s -instcombine -S | not grep load
@GLOBAL = internal constant [4 x i32] zeroinitializer
-; RUN: opt %s -instcombine | llvm-dis | grep load | count 1
+; RUN: opt < %s -instcombine -S | grep load | count 1
; Instcombine should be able to do trivial CSE of loads.
-; RUN: opt %s -instcombine | llvm-dis | grep {, align 16} | count 14
+; RUN: opt %s -instcombine -S | grep {, align 16} | count 14
@x = external global <2 x i64>, align 16
@xx = external global [13 x <2 x i64>], align 16
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt < %s -instcombine -S > %t
; RUN: grep select %t | count 5
; RUN: not grep and %t
; RUN: not grep or %t
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt < %s -instcombine -S > %t
; RUN: not grep lshr %t
; RUN: grep add %t | count 1
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 0}
-; RUN: opt %s -instcombine | llvm-dis | not grep malloc
+; RUN: opt < %s -instcombine -S | grep {ret i32 0}
+; RUN: opt < %s -instcombine -S | not grep malloc
; PR1201
define i32 @main(i32 %argc, i8** %argv) {
%c_19 = alloca i8* ; <i8**> [#uses=2]
; test that malloc's with a constant argument are promoted to array allocations
-; RUN: opt %s -instcombine | llvm-dis | grep getelementptr
+; RUN: opt %s -instcombine -S | grep getelementptr
define i32* @test() {
%X = malloc i32, i32 4
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 0}
-; RUN: opt %s -instcombine | llvm-dis | not grep malloc
+; RUN: opt < %s -instcombine -S | grep {ret i32 0}
+; RUN: opt < %s -instcombine -S | not grep malloc
; PR1313
define i32 @test1(i32 %argc, i8* %argv, i8* %envp) {
-; RUN: opt %s -instcombine | llvm-dis | grep {malloc.*struct.foo} | count 2
+; RUN: opt %s -instcombine -S | grep {malloc.*struct.foo} | count 2
; PR1728
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"
-; RUN: opt %s -instcombine | llvm-dis | grep {load double}
+; RUN: opt %s -instcombine -S | grep {load double}
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"
; This test makes sure that memmove instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {call void @llvm.memmove}
@S = internal constant [33 x i8] c"panic: restorelist inconsistency\00" ; <[33 x i8]*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep {call.*llvm.memset}
+; RUN: opt %s -instcombine -S | not grep {call.*llvm.memset}
declare void @llvm.memset.i32(i8*, i8, i32, i32)
-; RUN: opt %s -instcombine | llvm-dis | grep ashr
+; RUN: opt %s -instcombine -S | grep ashr
define i32 @foo(i32 %x, i32 %y) {
%a = and i32 %x, 7
; This test makes sure that mul instructions are properly eliminated.
-; RUN: opt %s -instcombine | llvm-dis | not grep mul
+; RUN: opt < %s -instcombine -S | not grep mul
define i32 @test1(i32 %A) {
%B = mul i32 %A, 1 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep {add double .sx, .sy}
+; RUN: opt %s -instcombine -S | grep {add double .sx, .sy}
; The 'or' has multiple uses, make sure that this doesn't prevent instcombine
; from propagating the extends to the truncs.
; This file contains various testcases that check to see that instcombine
; is narrowing computations when possible.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {ret i1 false}
; test1 - Eliminating the casts in this testcase (by narrowing the AND
-; RUN: opt %s -instcombine | llvm-dis | grep "fcmp uge"
+; RUN: opt %s -instcombine -S | grep "fcmp uge"
; PR1570
define i1 @f(float %X, float %Y) {
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep xor
+; RUN: opt %s -instcombine -S | not grep xor
define i32 @test1(i32 %A) {
%B = xor i32 %A, -1 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep call
+; RUN: opt %s -instcombine -S | not grep call
; rdar://6880732
declare double @t1(i32) readonly
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
; CHECK: define i32 @foo
; %y = sub i32 0, %x
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 10}
+; RUN: opt %s -instcombine -S | grep {ret i32 10}
@g1 = available_externally constant i32 1
@g2 = linkonce_odr constant i32 2
-; RUN: opt %s -instcombine | llvm-dis | grep fcmp | count 3
-; RUN: opt %s -instcombine | llvm-dis | grep ret | grep 1
+; RUN: opt < %s -instcombine -S | grep fcmp | count 3
+; RUN: opt < %s -instcombine -S | grep ret | grep 1
define zeroext i8 @t1(float %x, float %y) nounwind {
%a = fcmp ueq float %x, %y ; <i1> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep {xor i32 %a, %b} | count 4
-; RUN: opt %s -instcombine | llvm-dis | not grep {and}
+; RUN: opt %s -instcombine -S | grep {xor i32 %a, %b} | count 4
+; RUN: opt %s -instcombine -S | not grep {and}
define i32 @func1(i32 %a, i32 %b) nounwind readnone {
entry:
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep -v xor | not grep {or }
; END.
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | grep -v xor | not grep {or }
+; RUN: opt %s -instcombine -S | grep -v xor | not grep {or }
; PR1738
define i1 @test1(double %X, double %Y) {
-; RUN: opt %s -instcombine | llvm-dis | not grep {phi i32}
+; RUN: opt %s -instcombine -S | not grep {phi i32}
; PR1777
declare i1 @rrr()
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep phi
+; RUN: opt < %s -instcombine -S | not grep phi
define i32 @test1(i32 %A, i1 %b) {
BB0:
-; RUN: opt %s -instcombine | llvm-dis | grep {insertelement <4 x float> undef}
+; RUN: opt %s -instcombine -S | grep {insertelement <4 x float> undef}
; Instcombine should be able to prove that none of the
; insertelement's first operand's elements are needed.
-; RUN: opt %s -instcombine | llvm-dis | grep shufflevector
+; RUN: opt %s -instcombine -S | grep shufflevector
; PR2645
; instcombine shouldn't delete the shufflevector.
-; RUN: opt %s -instcombine | llvm-dis | grep { i32 \[%\]sd, \[\[:alnum:\]\]* \\?1\\>} | count 4
+; RUN: opt %s -instcombine -S | grep { i32 \[%\]sd, \[\[:alnum:\]\]* \\?1\\>} | count 4
; Instcombine normally would fold the sdiv into the comparison,
; making "icmp slt i32 %h, 2", but in this case the sdiv has
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
define i1 @test1(i32 *%x) nounwind {
entry:
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep rem
+; RUN: opt < %s -instcombine -S | not grep rem
; END.
define i32 @test1(i32 %A) {
-; RUN: opt %s -instcombine -inline | llvm-dis | not grep '-715827882'
+; RUN: opt %s -instcombine -inline -S | not grep '-715827882'
; PR3142
define i32 @a(i32 %X) nounwind readnone {
-; RUN: opt %s -instcombine | llvm-dis | not grep div
+; RUN: opt < %s -instcombine -S | not grep div
define i32 @a(i16 zeroext %x, i32 %y) nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep select | count 2
+; RUN: opt < %s -instcombine -S | grep select | count 2
; Make sure instcombine don't fold select into operands. We don't want to emit
; select of two integers unless it's selecting 0 / 1.
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i32 1}
+; RUN: opt %s -instcombine -S | grep {ret i32 1}
declare void @test2()
; This test makes sure that these instructions are properly eliminated.
; PR1822
-; RUN: opt %s -instcombine | llvm-dis | not grep select
+; RUN: opt < %s -instcombine -S | not grep select
define i32 @test1(i32 %A, i32 %B) {
%C = select i1 false, i32 %A, i32 %B ; <i32> [#uses=1]
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep icmp
+; RUN: opt %s -instcombine -S | not grep icmp
; END.
@X = external global i32 ; <i32*> [#uses=2]
; This test case was reduced from MultiSource/Applications/hbd. It makes sure
; that folding doesn't happen in case a zext is applied where a sext should have
; been when a setcc is used with two casts.
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {br i1 false}
; END.
; working. Basically this boils down to converting setlt,gt,le,ge instructions
; into equivalent setne,eq instructions.
;
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep -v {icmp eq} | grep -v {icmp ne} | not grep icmp
; END.
-; RUN: opt %s -instcombine | llvm-dis | not grep sext
+; RUN: opt < %s -instcombine -S | not grep sext
declare i32 @llvm.ctpop.i32(i32)
declare i32 @llvm.ctlz.i32(i32)
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: egrep {shl|lshr|ashr} | count 3
define i32 @test0(i32 %A, i32 %B, i32 %C) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {lshr i32} | count 2
-; RUN: opt %s -instcombine | llvm-dis | not grep ashr
+; RUN: opt %s -instcombine -S | not grep ashr
define i32 @test1(i32 %X, i8 %A) {
-; RUN: opt %s -instcombine | llvm-dis | grep lshr.*63
+; RUN: opt %s -instcombine -S | grep lshr.*63
define i32 @t1(i64 %d18) {
entry:
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep sh
+; RUN: opt < %s -instcombine -S | not grep sh
; END.
define i32 @test1(i32 %A) {
-; RUN: opt %s -instcombine | llvm-dis | grep shl
+; RUN: opt %s -instcombine -S | grep shl
define i1 @test(i32 %X, i8 %A) {
%shift.upgrd.1 = zext i8 %A to i32 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | not grep {shufflevector.\*i32 8}
+; RUN: opt %s -instcombine -S | not grep {shufflevector.\*i32 8}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9"
-; RUN: opt %s -instcombine | llvm-dis | grep "2 x float"
+; RUN: opt %s -instcombine -S | grep "2 x float"
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9"
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
; RUN: not grep zext %t
; RUN: not grep slt %t
; RUN: grep {icmp ult} %t
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {(and\|xor\|add\|shl\|shr)}
; END.
-; RUN: opt -instcombine %s | llvm-dis | FileCheck %s
+; RUN: opt -instcombine %s -S | FileCheck %s
;; This tests that the instructions in the entry blocks are sunk into each
;; arm of the 'if'.
-; RUN: opt %s -instcombine | llvm-dis | not grep itofp
+; RUN: opt < %s -instcombine -S | not grep itofp
define i1 @test1(i8 %A) {
%B = sitofp i8 %A to double
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i1 false}
+; RUN: opt %s -instcombine -S | grep {ret i1 false}
; PR2276
define i1 @f(i32 %x) {
-; RUN: opt %s -instcombine | llvm-dis | grep srem
+; RUN: opt %s -instcombine -S | grep srem
define i64 @foo(i64 %x1, i64 %y2) {
%r = sdiv i64 %x1, %y2
-; RUN: opt %s -instcombine | llvm-dis | grep {align 32} | count 1
+; RUN: opt %s -instcombine -S | grep {align 32} | count 1
; It's tempting to have an instcombine in which the src pointer of a
; memcpy is aligned up to the alignment of the destination, however
-; RUN: opt %s -instcombine | llvm-dis | grep {call.*stackrestore} | count 1
+; RUN: opt %s -instcombine -S | grep {call.*stackrestore} | count 1
declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*)
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {ret i32 %.toremerge} | count 2
;; Simple sinking tests
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v {store.*,.*null} | not grep store
define void @test1(i32* %P) {
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v {sub i32 %Cok, %Bok} | grep -v {sub i32 0, %Aok} | not grep sub
define i32 @test1(i32 %A) {
-; RUN: opt %s -instcombine | llvm-dis > %t
+; RUN: opt %s -instcombine -S > %t
; RUN: not grep zext %t
; RUN: not grep sext %t
-; RUN: opt %s -instcombine | llvm-dis | grep {ret i64 0} | count 2
+; RUN: opt %s -instcombine -S | grep {ret i64 0} | count 2
define i64 @foo(i32 %x) nounwind {
%y = lshr i32 %x, 1
-; RUN: opt %s -instcombine | llvm-dis > %t1.ll
+; RUN: opt < %s -instcombine -S > %t1.ll
; RUN: grep udiv %t1.ll | count 2
; RUN: grep zext %t1.ll | count 2
; PR2274
-; RUN: opt %s -instcombine | llvm-dis | not grep zext
+; RUN: opt %s -instcombine -S | not grep zext
; PR4548
define i8 @udiv_i8(i8 %a, i8 %b) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | grep {= or i32 %x, -5 }
+; RUN: opt %s -instcombine -S | grep {= or i32 %x, -5 }
@.str = internal constant [5 x i8] c"foo\0A\00" ; <[5 x i8]*> [#uses=1]
@.str1 = internal constant [5 x i8] c"bar\0A\00" ; <[5 x i8]*> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | grep urem
+; RUN: opt %s -instcombine -S | grep urem
define i64 @rem_unsigned(i64 %x1, i64 %y2) {
%r = udiv i64 %x1, %y2
-; RUN: opt %s -instcombine | llvm-dis | not grep extractelement
+; RUN: opt %s -instcombine -S | not grep extractelement
define void @get_image() nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis | not grep load
+; RUN: opt %s -instcombine -S | not grep load
; PR4340
define void @vac(<4 x float>* nocapture %a) nounwind {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {fadd float}
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {fmul float}
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {insertelement.*0.00}
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {call.*llvm.x86.sse.mul}
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {call.*llvm.x86.sse.sub}
; END.
-; RUN: opt %s -instcombine | llvm-dis | not grep extractelement
+; RUN: opt %s -instcombine -S | not grep extractelement
define i32 @test(float %f) {
%tmp7 = insertelement <4 x float> undef, float %f, i32 0 ; <<4 x float>> [#uses=1]
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep shufflevec | count 1
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep insertelement
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep extractelement
; END.
-; RUN: opt %s -instcombine | llvm-dis | grep {ret <4 x i32> %A}
+; RUN: opt %s -instcombine -S | grep {ret <4 x i32> %A}
; PR1286
define <4 x i32> @test1(<4 x i32> %A) {
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {add float}
%V = type <4 x float>
-; RUN: opt %s -instcombine | llvm-dis | not grep vector_shuffle
+; RUN: opt %s -instcombine -S | not grep vector_shuffle
; END.
%T = type <4 x float>
-; RUN: opt %s -instcombine | llvm-dis | grep undef | count 1
+; RUN: opt %s -instcombine -S | grep undef | count 1
; END.
; Test fold of two shuffles where the first shuffle vectors inputs are a
-; RUN: opt %s -instcombine | llvm-dis | FileCheck %s
+; RUN: opt %s -instcombine -S | FileCheck %s
; This turns into a&1 != 0
define <2 x i1> @test1(<2 x i64> %a) {
-; RUN: opt %s -instcombine | llvm-dis | grep {srem <4 x i32>}
+; RUN: opt %s -instcombine -S | grep {srem <4 x i32>}
define <4 x i32> @foo(<4 x i32> %t, <4 x i32> %u)
{
-; RUN: opt %s -instcombine | llvm-dis | grep {volatile store}
-; RUN: opt %s -instcombine | llvm-dis | grep {volatile load}
+; RUN: opt %s -instcombine -S | grep {volatile store}
+; RUN: opt %s -instcombine -S | grep {volatile load}
@x = weak global i32 0 ; <i32*> [#uses=2]
-; RUN: opt %s -instcombine | llvm-dis | not grep {= or}
+; RUN: opt %s -instcombine -S | not grep {= or}
; PR3266
; XFAIL: *
-; RUN: opt %s -instcombine | llvm-dis | grep zeroinitializer
+; RUN: opt %s -instcombine -S | grep zeroinitializer
define <2 x i64> @f() {
%tmp = xor <2 x i64> undef, undef
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: not grep {xor }
; END.
@G1 = global i32 0 ; <i32*> [#uses=1]
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine | llvm-dis | not grep {xor }
+; RUN: opt %s -instcombine -S | not grep {xor }
; PR1253
define i1 @test0(i32 %A) {
-; RUN: opt %s -instcombine | llvm-dis | grep 0.0 | count 1
+; RUN: opt %s -instcombine -S | grep 0.0 | count 1
declare double @abs(double)
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: grep {and i32 %Y, 8}
define i32 @test1(i8 %X) {
-; RUN: opt %s -instcombine | llvm-dis | not grep zext
+; RUN: opt < %s -instcombine -S | not grep zext
define i32 @a(i1 %x) {
entry:
-; RUN: opt %s -instcombine | llvm-dis | grep {zext } | count 1
+; RUN: opt %s -instcombine -S | grep {zext } | count 1
; PR1570
define i32 @test2(float %X, float %Y) {
-; RUN: opt %s -instcombine | llvm-dis | grep icmp | count 1
+; RUN: opt < %s -instcombine -S | grep icmp | count 1
%struct.FooBar = type <{ i8, i8, [2 x i8], i8, i8, i8, i8, i16, i16, [4 x i8], [8 x %struct.Rock] }>
%struct.Rock = type { i16, i16 }
; Tests to make sure elimination of casts is working correctly
-; RUN: opt %s -instcombine | llvm-dis | \
+; RUN: opt %s -instcombine -S | \
; RUN: notcast {} {%c1.*}
define i64 @test_sext_zext(i16 %A) {
; No arguments means internalize all but main
-; RUN: opt %s -internalize | llvm-dis | grep internal | count 4
+; RUN: opt %s -internalize -S | grep internal | count 4
; Internalize all but foo and j
-; RUN: opt %s -internalize -internalize-public-api-list foo -internalize-public-api-list j | llvm-dis | grep internal | count 3
+; RUN: opt %s -internalize -internalize-public-api-list foo -internalize-public-api-list j -S | grep internal | count 3
; Non existent files should be treated as if they were empty (so internalize all but main)
-; RUN: opt %s -internalize -internalize-public-api-file /nonexistent/file 2> /dev/null | llvm-dis | grep internal | count 4
-; RUN: opt %s -internalize -internalize-public-api-list bar -internalize-public-api-list foo -internalize-public-api-file /nonexistent/file 2> /dev/null | llvm-dis | grep internal | count 3
+; RUN: opt %s -internalize -internalize-public-api-file /nonexistent/file 2> /dev/null -S | grep internal | count 4
+; RUN: opt %s -internalize -internalize-public-api-list bar -internalize-public-api-list foo -internalize-public-api-file /nonexistent/file 2> /dev/null -S | grep internal | count 3
; -file and -list options should be merged, the .apifile contains foo and j
-; RUN: opt %s -internalize -internalize-public-api-list bar -internalize-public-api-file %s.apifile | llvm-dis | grep internal | count 2
+; RUN: opt %s -internalize -internalize-public-api-list bar -internalize-public-api-file %s.apifile -S | grep internal | count 2
@i = weak global i32 0 ; <i32*> [#uses=0]
@j = weak global i32 0 ; <i32*> [#uses=0]
-; RUN: opt %s -internalize | llvm-dis | grep internal | count 3
+; RUN: opt %s -internalize -S | grep internal | count 3
@A = global i32 0
@B = alias i32* @A
-; RUN: llvm-as < %s | opt -jump-threading -simplifycfg | llvm-dis | grep {ret i32 0}
+; RUN: llvm-as < %s | opt -jump-threading -simplifycfg -S | grep {ret i32 0}
; PR3138
define i32 @jt() {
-; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg | llvm-dis | grep {ret i32 %v1}
+; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg -S | grep {ret i32 %v1}
; There should be no uncond branches left.
-; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg | llvm-dis | not grep {br label}
+; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg -S | not grep {br label}
declare i32 @f1()
declare i32 @f2()
-; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg | llvm-dis | grep {ret i32 %v1}
+; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg -S | grep {ret i32 %v1}
; There should be no uncond branches left.
-; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg | llvm-dis | not grep {br label}
+; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg -S | not grep {br label}
declare i32 @f1()
declare i32 @f2()
-; RUN: opt %s -jump-threading -simplifycfg -mem2reg | llvm-dis | grep {ret i32 %v1}
+; RUN: opt %s -jump-threading -simplifycfg -mem2reg -S | grep {ret i32 %v1}
; There should be no uncond branches left.
-; RUN: opt %s -jump-threading -simplifycfg -mem2reg | llvm-dis | not grep {br label}
+; RUN: opt %s -jump-threading -simplifycfg -mem2reg -S | not grep {br label}
declare i32 @f1()
declare i32 @f2()
-; RUN: opt %s -jump-threading | llvm-dis | not grep phi
+; RUN: opt %s -jump-threading -S | not grep phi
declare i8 @mcguffin()
; There should be no phi nodes left.
-; RUN: opt %s -jump-threading -simplifycfg -mem2reg | llvm-dis | not grep {phi i32}
+; RUN: opt %s -jump-threading -simplifycfg -mem2reg -S | not grep {phi i32}
declare i32 @f1()
declare i32 @f2()
-; RUN: opt %s -jump-threading -die | llvm-dis | grep icmp | count 1
+; RUN: opt %s -jump-threading -die -S | grep icmp | count 1
declare void @f1()
declare void @f2()
-; RUN: opt %s -jump-threading -loop-rotate -instcombine -indvars -loop-unroll -simplifycfg | llvm-dis > %t
+; RUN: opt %s -jump-threading -loop-rotate -instcombine -indvars -loop-unroll -simplifycfg -S > %t
; RUN: grep {volatile store} %t | count 3
; RUN: not grep {br label} %t
-; RUN: opt %s -jump-threading -mem2reg -simplifycfg | llvm-dis | grep {ret i32 1}
+; RUN: opt %s -jump-threading -mem2reg -simplifycfg -S | grep {ret i32 1}
; rdar://6402033
; Test that we can thread through the block with the partially redundant load (%2).
-; RUN: opt %s -jump-threading | llvm-dis | not grep {br }
-; RUN: opt %s -jump-threading | llvm-dis | grep {ret i32} | count 1
+; RUN: opt %s -jump-threading -S | not grep {br }
+; RUN: opt %s -jump-threading -S | grep {ret i32} | count 1
define i32 @test(i1 %cond) {
br i1 undef, label %T1, label %F1
-; RUN: opt %s -lcssa | llvm-dis | \
+; RUN: opt %s -lcssa -S | \
; RUN: grep {%%SJE.0.0.lcssa = phi .struct.SetJmpMapEntry}
-; RUN: opt %s -lcssa | llvm-dis | \
+; RUN: opt %s -lcssa -S | \
; RUN: grep {%%SJE.0.0.lcssa1 = phi .struct.SetJmpMapEntry}
%struct.SetJmpMapEntry = type { i8*, i32, %struct.SetJmpMapEntry* }
-; RUN: opt %s -lcssa | llvm-dis | \
+; RUN: opt %s -lcssa -S | \
; RUN: grep {%X.1.lcssa}
-; RUN: opt %s -lcssa | llvm-dis | \
+; RUN: opt %s -lcssa -S | \
; RUN: not grep {%X.1.lcssa1}
declare i1 @c1()
-; RUN: opt %s -lcssa | llvm-dis | \
+; RUN: opt %s -lcssa -S | \
; RUN: grep {X3.lcssa = phi i32}
-; RUN: opt %s -lcssa | llvm-dis | \
+; RUN: opt %s -lcssa -S | \
; RUN: grep {X4 = add i32 3, %X3.lcssa}
define void @lcssa(i1 %S2) {
; happens because preheader insertion doesn't insert a preheader for this
; case... bad.
-; RUN: opt %s -licm -loop-deletion -simplifycfg | llvm-dis | \
+; RUN: opt %s -licm -loop-deletion -simplifycfg -S | \
; RUN: not grep {br }
define i32 @main(i32 %argc) {
; loaded from. Basically if the load gets hoisted, the subtract gets turned
; into a constant zero.
;
-; RUN: opt %s -licm -gvn -instcombine | llvm-dis | grep load
+; RUN: opt %s -licm -gvn -instcombine -S | grep load
@X = global i32 7 ; <i32*> [#uses=2]
-; RUN: opt %s -licm | llvm-dis | grep {volatile store}
+; RUN: opt %s -licm -S | grep {volatile store}
; PR1435
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"
target triple = "i686-apple-darwin8"
; Do not promote getelementptr because it may exposes load from a null pointer
; and store from a null pointer which are covered by
; icmp eq %struct.decision* null, null condition.
-; RUN: opt %s -licm | llvm-dis | not grep promoted
+; RUN: opt %s -licm -S | not grep promoted
%struct.decision = type { i8, %struct.decision* }
define i32 @main() {
; Do not promote null value because it may be unsafe to do so.
-; RUN: opt %s -licm | llvm-dis | not grep promoted
+; RUN: opt %s -licm -S | not grep promoted
define i32 @f(i32 %foo, i32 %bar, i32 %com) {
entry:
-; RUN: opt %s -licm | llvm-dis | grep promoted
+; RUN: opt %s -licm -S | grep promoted
; Promote value if at least one use is safe
-; RUN: opt %s -licm -enable-licm-constant-variables | llvm-dis | grep -A 1 entry | grep load.*@a
+; RUN: opt %s -licm -enable-licm-constant-variables -S | grep -A 1 entry | grep load.*@a
@a = external constant float*
define void @test(i32 %count) {
-; RUN: opt %s -licm | llvm-dis | FileCheck %s
+; RUN: opt %s -licm -S | FileCheck %s
@X = global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -licm | llvm-dis | FileCheck %s
+; RUN: opt %s -licm -S | FileCheck %s
@X = global i32 7 ; <i32*> [#uses=4]
define void @test1(i32 %i) {
-; RUN: opt %s -basicaa -licm | llvm-dis | FileCheck %s
+; RUN: opt %s -basicaa -licm -S | FileCheck %s
declare i32 @strlen(i8*) readonly
-; RUN: opt %s -loop-deletion | llvm-dis | grep switch
+; RUN: opt %s -loop-deletion -S | grep switch
; PR 1564
define fastcc void @out() {
; This is the test case taken from Appel's book that illustrates a hard case
; that SCCP gets right, and when followed by ADCE, is completely eliminated
;
-; RUN: opt %s -sccp -simplifycfg -indvars -loop-deletion -dce -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -sccp -simplifycfg -indvars -loop-deletion -dce -simplifycfg -S | not grep br
define i32 @"test function"(i32 %i0, i32 %j0) {
BB1:
; Update loop iteraton space to eliminate condition inside loop.
-; RUN: opt %s -loop-index-split | llvm-dis | not grep bothcond
+; RUN: opt %s -loop-index-split -S | not grep bothcond
define void @test(float* %x, i32 %ndat, float** %y, float %xcen, i32 %xmin, i32 %xmax, float %sigmal, float %contribution) {
entry:
%tmp519 = icmp sgt i32 %xmin, %xmax ; <i1> [#uses=1]
; PR714
; Update loop iteraton space to eliminate condition inside loop.
-; RUN: opt %s -loop-index-split | llvm-dis | not grep bothcond
+; RUN: opt %s -loop-index-split -S | not grep bothcond
define void @test(float* %x, i32 %ndat, float** %y, float %xcen, i32 %xmin, i32 %xmax, float %sigmal, float %contribution) {
entry:
-; RUN: opt %s -loop-index-split | llvm-dis | not grep undef
+; RUN: opt < %s -loop-index-split -S | not grep undef
define i32 @main() {
entry:
br label %header
-; RUN: opt %s -loop-index-split | llvm-dis | not grep "icmp ne"
+; RUN: opt %s -loop-index-split -S | not grep "icmp ne"
define i32 @main() {
entry:
; Split loop. Split value is a constant and greater then exit value.
; Check whether optimizer inserts proper checkfor split value or not.
-; RUN: opt %s -loop-index-split | llvm-dis | grep select
+; RUN: opt %s -loop-index-split -S | grep select
@k = external global i32 ; <i32*> [#uses=2]
-; RUN: opt %s -loop-rotate | llvm-dis | not grep {\\\[ .tmp224}
+; RUN: opt %s -loop-rotate -S | not grep {\\\[ .tmp224}
; END.
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"
; Loop Simplify should turn phi nodes like X = phi [X, Y] into just Y, eliminating them.
-; RUN: opt %s -loopsimplify | llvm-dis | grep phi | count 6
+; RUN: opt < %s -loopsimplify -S | grep phi | count 6
@A = weak global [3000000 x i32] zeroinitializer ; <[3000000 x i32]*> [#uses=1]
@B = weak global [20000 x i32] zeroinitializer ; <[20000 x i32]*> [#uses=1]
; for all loops. This allows the -indvars pass to recognize the %IV
; induction variable in this testcase.
-; RUN: opt %s -indvars | llvm-dis | grep indvar
+; RUN: opt %s -indvars -S | grep indvar
define i32 @test(i1 %C) {
; <label>:0
-; RUN: opt %s -loop-reduce | llvm-dis | grep ugt
+; RUN: opt %s -loop-reduce -S | grep ugt
; PR2535
@.str = internal constant [4 x i8] c"%d\0A\00"
-; RUN: opt %s -loop-reduce | llvm-dis | grep add | count 2
+; RUN: opt %s -loop-reduce -S | grep add | count 2
; PR 2662
@g_3 = common global i16 0 ; <i16*> [#uses=2]
@"\01LC" = internal constant [4 x i8] c"%d\0A\00" ; <[4 x i8]*> [#uses=1]
-; RUN: opt %s -loop-reduce | llvm-dis | grep "phi double" | count 1
+; RUN: opt %s -loop-reduce -S | grep "phi double" | count 1
define void @foobar(i32 %n) nounwind {
entry:
-; RUN: opt %s -loop-reduce | llvm-dis | grep phi | count 2
+; RUN: opt %s -loop-reduce -S | grep phi | count 2
; PR 2779
@g_19 = common global i32 0 ; <i32*> [#uses=3]
@"\01LC" = internal constant [4 x i8] c"%d\0A\00" ; <[4 x i8]*> [#uses=1]
-; RUN: opt %s -loop-reduce | llvm-dis | grep phi | count 1
-; RUN: opt %s -loop-reduce | llvm-dis | grep mul | count 1
+; RUN: opt %s -loop-reduce -S | grep phi | count 1
+; RUN: opt %s -loop-reduce -S | grep mul | count 1
; ModuleID = '<stdin>'
; Make sure examining a fuller expression outside the loop doesn't cause us to create a second
; IV of stride %3.
-; RUN: opt %s -loop-reduce | llvm-dis | grep phi | count 1
+; RUN: opt < %s -loop-reduce -S | grep phi | count 1
define void @foo(i32 %n) {
entry:
-; RUN: opt %s -loop-reduce | llvm-dis | \
+; RUN: opt %s -loop-reduce -S | \
; RUN: not grep {bitcast i32 1 to i32}
; END.
; The setlt wants to use a value that is incremented one more than the dominant
; Check that this test makes INDVAR and related stuff dead.
-; RUN: opt %s -loop-reduce | llvm-dis | grep phi | count 2
+; RUN: opt %s -loop-reduce -S | grep phi | count 2
declare i1 @pred()
; Check that the index of 'P[outer]' is pulled out of the loop.
-; RUN: opt %s -loop-reduce | llvm-dis | \
+; RUN: opt %s -loop-reduce -S | \
; RUN: not grep {getelementptr.*%outer.*%INDVAR}
declare i1 @pred()
; Check that the index of 'P[outer]' is pulled out of the loop.
-; RUN: opt %s -loop-reduce | llvm-dis | \
+; RUN: opt %s -loop-reduce -S | \
; RUN: not grep {getelementptr.*%outer.*%INDVAR}
declare i1 @pred()
-; RUN: opt %s -loop-reduce | llvm-dis | not grep mul
+; RUN: opt %s -loop-reduce -S | not grep mul
; Make sure we don't get a multiply by 6 in this loop.
; Check that this test makes INDVAR and related stuff dead, because P[indvar]
; gets reduced, making INDVAR dead.
-; RUN: opt %s -loop-reduce | llvm-dis | not grep INDVAR
+; RUN: opt %s -loop-reduce -S | not grep INDVAR
declare i1 @pred()
-; RUN: opt %s -loop-reduce | llvm-dis | grep {phi\\>} | count 10
+; RUN: opt %s -loop-reduce -S | grep {phi\\>} | count 10
; PR2570
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"
-; RUN: opt %s -loop-reduce | llvm-dis | grep phi | count 1
+; RUN: opt %s -loop-reduce -S | grep phi | count 1
; This should only result in one PHI node!
; Check that this test makes INDVAR and related stuff dead.
-; RUN: opt %s -loop-reduce | llvm-dis | not grep INDVAR
+; RUN: opt %s -loop-reduce -S | not grep INDVAR
declare i1 @pred()
-; RUN: opt %s -loop-reduce | llvm-dis | grep mul | count 1
+; RUN: opt %s -loop-reduce -S | grep mul | count 1
; LSR should not make two copies of the Q*L expression in the preheader!
define i8 @test(i8* %A, i8* %B, i32 %L, i32 %Q, i32 %N.s) {
-; RUN: opt %s -loop-reduce | llvm-dis | grep phi | count 1
+; RUN: opt %s -loop-reduce -S | grep phi | count 1
; This testcase should have ONE stride 18 indvar, the other use should have a
; loop invariant value (B) added to it inside of the loop, instead of having
-; RUN: opt %s -loop-reduce | llvm-dis | \
+; RUN: opt %s -loop-reduce -S | \
; RUN: grep {add i32 %lsr.iv.next, 1}
;
; Make sure that the use of the IV outside of the loop (the store) uses the
; Base should not be i*3, it should be i*2.
-; RUN: opt %s -loop-reduce | llvm-dis | \
+; RUN: opt %s -loop-reduce -S | \
; RUN: not grep {mul.*%i, 3}
; Indvar should not start at zero:
-; RUN: opt %s -loop-reduce | llvm-dis | \
+; RUN: opt %s -loop-reduce -S | \
; RUN: not grep {phi i32 .* 0}
; END.
; Check that variable strides are reduced to adds instead of multiplies.
-; RUN: opt %s -loop-reduce | llvm-dis | not grep mul
+; RUN: opt %s -loop-reduce -S | not grep mul
declare i1 @pred(i32)
-; RUN: opt %s -loop-unroll | llvm-dis | grep bb72.2
+; RUN: opt %s -loop-unroll -S | grep bb72.2
define void @vorbis_encode_noisebias_setup() {
entry:
-; RUN: opt %s -loop-unroll | llvm-dis | not grep undef
+; RUN: opt %s -loop-unroll -S | not grep undef
; PR1385
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"
-; RUN: opt %s -loop-unroll -unroll-count=3 | llvm-dis | grep bb72.2
+; RUN: opt %s -loop-unroll -unroll-count=3 -S | grep bb72.2
define void @foo(i32 %trips) {
entry:
-; RUN: opt %s -lowersetjmp | llvm-dis | grep invoke
+; RUN: opt %s -lowersetjmp -S | grep invoke
%JmpBuf = type i32
@.str_1 = internal constant [13 x i8] c"returned %d\0A\00" ; <[13 x i8]*> [#uses=1]
-; RUN: llvm-as %s -o - | opt -lowerswitch | llvm-dis > %t
+; RUN: llvm-as %s -o - | opt -lowerswitch -S > %t
; RUN: grep slt %t | count 10
; RUN: grep ule %t | count 3
; RUN: grep eq %t | count 9
; Promoting some values allows promotion of other values.
-; RUN: opt %s -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -mem2reg -S | not grep alloca
define i32 @test2() {
%result = alloca i32 ; <i32*> [#uses=2]
; Mem2reg should not insert dead PHI nodes! The naive algorithm inserts a PHI
; node in L3, even though there is no load of %A in anything dominated by L3.
-; RUN: opt %s -mem2reg | llvm-dis | not grep phi
+; RUN: opt %s -mem2reg -S | not grep phi
define void @test(i32 %B, i1 %C) {
%A = alloca i32 ; <i32*> [#uses=4]
-; RUN: opt %s -mem2reg -instcombine | llvm-dis | grep store
+; RUN: opt %s -mem2reg -instcombine -S | grep store
; PR590
-; RUN: opt %s -std-compile-opts | llvm-dis | grep volatile | count 3
+; RUN: opt %s -std-compile-opts -S | grep volatile | count 3
; PR1520
; Don't promote volatile loads/stores. This is really needed to handle setjmp/lonjmp properly.
; Simple sanity check testcase. Both alloca's should be eliminated.
-; RUN: opt %s -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -mem2reg -S | not grep alloca
define double @testfunc(i32 %i, double %j) {
%I = alloca i32 ; <i32*> [#uses=4]
-; RUN: opt %s -mem2reg | llvm-dis | not grep phi
+; RUN: opt %s -mem2reg -S | not grep phi
define i32 @testfunc(i1 %C, i32 %i, i8 %j) {
%I = alloca i32 ; <i32*> [#uses=2]
-; RUN: opt %s -memcpyopt -dse | llvm-dis | grep {call.*initialize} | not grep memtmp
+; RUN: opt %s -memcpyopt -dse -S | grep {call.*initialize} | not grep memtmp
; PR2077
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"
-; RUN: opt %s -memcpyopt | llvm-dis | not grep {call.*memcpy.}
+; RUN: opt %s -memcpyopt -S | not grep {call.*memcpy.}
%a = type { i32 }
%b = type { float }
-; RUN: opt %s -memcpyopt | llvm-dis | grep {call.*memcpy.*agg.result}
+; RUN: opt %s -memcpyopt -S | grep {call.*memcpy.*agg.result}
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -memcpyopt | llvm-dis | not grep store
-; RUN: opt %s -memcpyopt | llvm-dis | grep {call.*llvm.memset}
+; RUN: opt %s -memcpyopt -S | not grep store
+; RUN: opt %s -memcpyopt -S | grep {call.*llvm.memset}
; All the stores in this example should be merged into a single memset.
-; RUN: opt %s -memcpyopt | llvm-dis | not grep store
-; RUN: opt %s -memcpyopt | llvm-dis | grep {call.*llvm.memset} | count 3
+; RUN: opt %s -memcpyopt -S | not grep store
+; RUN: opt %s -memcpyopt -S | grep {call.*llvm.memset} | count 3
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
-; RUN: opt %s -memcpyopt -dse | llvm-dis | grep {call.*memcpy} | count 1
+; RUN: opt %s -memcpyopt -dse -S | grep {call.*memcpy} | count 1
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-darwin9"
-; RUN: opt %s -memcpyopt | llvm-dis | FileCheck %s
+; RUN: opt %s -memcpyopt -S | FileCheck %s
; These memmoves should get optimized to memcpys.
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"
-; RUN: opt %s -memcpyopt | llvm-dis | not grep {call.*memcpy}
+; RUN: opt %s -memcpyopt -S | not grep {call.*memcpy}
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-darwin9"
-; RUN: opt %s -mergefunc | llvm-dis > %t
+; RUN: opt %s -mergefunc -S > %t
; RUN: grep {define weak} %t | count 2
; RUN: grep {call} %t | count 2
-; RUN: opt %s -predsimplify | llvm-dis | grep br | grep return.i.bb8_crit_edge | grep false
+; RUN: opt %s -predsimplify -S | grep br | grep return.i.bb8_crit_edge | grep false
@str = external global [4 x i8] ; <[4 x i8]*> [#uses=1]
declare i32 @sprintf(i8*, i8*, ...)
; RUN: llvm-as < %s | \
-; RUN: opt -predsimplify -instcombine -simplifycfg | llvm-dis > %t
+; RUN: opt -predsimplify -instcombine -simplifycfg -S > %t
; RUN: grep -v declare %t | not grep fail
; RUN: grep -v declare %t | grep pass | count 3
; RUN: llvm-as < %s | \
-; RUN: opt -predsimplify -instcombine -simplifycfg | llvm-dis | \
+; RUN: opt -predsimplify -instcombine -simplifycfg -S | \
; RUN: grep -v declare | grep pass | count 2
define i32 @test(i32 %x, i32 %y) {
-; RUN: opt %s -predsimplify | llvm-dis | grep -v %c
+; RUN: opt %s -predsimplify -S | grep -v %c
define void @foo(i8* %X, i8* %Y) {
entry:
%A = load i8* %X
-; RUN: opt %s -predsimplify | llvm-dis | grep unreachable | count 2
+; RUN: opt %s -predsimplify -S | grep unreachable | count 2
; PR1683
@.str = internal constant [13 x i8] c"c36174a.adb\00\00" ; <[13 x i8]*> [#uses=1]
; RUN: llvm-as < %s | \
-; RUN: opt -predsimplify -instcombine -simplifycfg | llvm-dis > %t
+; RUN: opt -predsimplify -instcombine -simplifycfg -S > %t
; RUN: grep -v declare %t | not grep fail
; RUN: grep -v declare %t | grep pass | count 4
-; RUN: opt %s -predsimplify -simplifycfg | llvm-dis | grep pass
+; RUN: opt %s -predsimplify -simplifycfg -S | grep pass
define void @regtest(i32 %x) {
entry:
-; RUN: opt %s -prune-eh | llvm-dis | grep invoke
+; RUN: opt %s -prune-eh -S | grep invoke
declare void @External()
-; RUN: opt %s -prune-eh | llvm-dis | not grep nounwind
+; RUN: opt %s -prune-eh -S | not grep nounwind
define weak void @f() {
entry:
-; RUN: opt %s -prune-eh | llvm-dis | not grep invoke
+; RUN: opt %s -prune-eh -S | not grep invoke
define internal i32 @foo() {
invoke i32 @foo( )
-; RUN: opt %s -prune-eh | llvm-dis | not grep {ret i32}
+; RUN: opt %s -prune-eh -S | not grep {ret i32}
declare void @noreturn() noreturn;
-; RUN: opt %s -prune-eh | llvm-dis | not grep invoke
+; RUN: opt %s -prune-eh -S | not grep invoke
declare void @nounwind() nounwind
; This situation can occur due to the funcresolve pass.
;
-; RUN: opt %s -raiseallocs | llvm-dis | not grep call
+; RUN: opt %s -raiseallocs -S | not grep call
declare void @free(i8*)
-; RUN: opt %s -reassociate -instcombine -constprop -dce | llvm-dis | not grep add
+; RUN: opt %s -reassociate -instcombine -constprop -dce -S | not grep add
define i32 @test(i32 %A) {
%X = add i32 %A, 1 ; <i32> [#uses=1]
-; RUN: opt %s -reassociate -instcombine -constprop -die | llvm-dis | not grep 5
+; RUN: opt < %s -reassociate -instcombine -constprop -die -S | not grep 5
define i32 @test(i32 %A, i32 %B) {
%W = add i32 %B, -5 ; <i32> [#uses=1]
; With sub reassociation, constant folding can eliminate all of the constants.
;
-; RUN: opt %s -reassociate -constprop -instcombine -dce | llvm-dis | not grep add
+; RUN: opt %s -reassociate -constprop -instcombine -dce -S | not grep add
define i32 @test(i32 %A, i32 %B) {
%W = add i32 5, %B ; <i32> [#uses=1]
; With sub reassociation, constant folding can eliminate the two 12 constants.
;
-; RUN: opt %s -reassociate -constprop -dce | llvm-dis | not grep 12
+; RUN: opt %s -reassociate -constprop -dce -S | not grep 12
define i32 @test(i32 %A, i32 %B, i32 %C, i32 %D) {
%M = add i32 %A, 12 ; <i32> [#uses=1]
-; RUN: opt %s -reassociate -instcombine | llvm-dis |\
+; RUN: opt %s -reassociate -instcombine -S |\
; RUN: grep {ret i32 0}
define i32 @f(i32 %a0, i32 %a1, i32 %a2, i32 %a3, i32 %a4) {
; With reassociation, constant folding can eliminate the 12 and -12 constants.
;
-; RUN: opt %s -reassociate -constprop -instcombine -die | llvm-dis | not grep add
+; RUN: opt %s -reassociate -constprop -instcombine -die -S | not grep add
define i32 @test(i32 %arg) {
%tmp1 = sub i32 -12, %arg ; <i32> [#uses=1]
; With reassociation, constant folding can eliminate the +/- 30 constants.
;
-; RUN: opt %s -reassociate -constprop -instcombine -die | llvm-dis | not grep 30
+; RUN: opt %s -reassociate -constprop -instcombine -die -S | not grep 30
define i32 @test(i32 %reg109, i32 %reg1111) {
%reg115 = add i32 %reg109, -30 ; <i32> [#uses=1]
-; RUN: opt %s -reassociate -gvn | llvm-dis | grep add | count 6
+; RUN: opt %s -reassociate -gvn -S | grep add | count 6
; Each of these functions should turn into two adds each.
@e = external global i32 ; <i32*> [#uses=3]
-; RUN: opt %s -reassociate -gvn -instcombine | llvm-dis | not grep add
+; RUN: opt %s -reassociate -gvn -instcombine -S | not grep add
@a = weak global i32 0 ; <i32*> [#uses=1]
@b = weak global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -reassociate -dce | llvm-dis | \
+; RUN: opt %s -reassociate -dce -S | \
; RUN: not grep {\\(and\\|sub\\)}
define i32 @test1(i32 %a, i32 %b) {
; In this case, we want to reassociate the specified expr so that i+j can be
; hoisted out of the inner most loop.
;
-; RUN: opt %s -reassociate | llvm-dis | grep 115 | not grep 117
+; RUN: opt %s -reassociate -S | grep 115 | not grep 117
; END.
@.LC0 = internal global [4 x i8] c"%d\0A\00" ; <[4 x i8]*> [#uses=1]
; This should be one add and two multiplies.
; RUN: llvm-as < %s | \
-; RUN: opt -reassociate -instcombine | llvm-dis > %t
+; RUN: opt -reassociate -instcombine -S > %t
; RUN: grep mul %t | count 2
; RUN: grep add %t | count 1
-; RUN: opt %s -reassociate -instcombine | llvm-dis |\
+; RUN: opt %s -reassociate -instcombine -S |\
; RUN: not grep {sub i32 0}
define i32 @test(i32 %X, i32 %Y, i32 %Z) {
-; RUN: opt %s -reassociate -instcombine | llvm-dis | grep mul | count 2
+; RUN: opt < %s -reassociate -instcombine -S | grep mul | count 2
; This should have exactly 2 multiplies when we're done.
; This should turn into one multiply and one add.
; RUN: llvm-as < %s | \
-; RUN: opt -instcombine -reassociate -instcombine | llvm-dis > %t
+; RUN: opt -instcombine -reassociate -instcombine -S > %t
; RUN: grep mul %t | count 1
; RUN: grep add %t | count 1
-; RUN: opt %s -reassociate -instcombine | llvm-dis | not grep sub
+; RUN: opt %s -reassociate -instcombine -S | not grep sub
; Test that we can turn things like X*-(Y*Z) -> X*-1*Y*Z.
; Reassociation should apply to Add, Mul, And, Or, & Xor
;
-; RUN: opt %s -reassociate -constprop -instcombine -die | llvm-dis | not grep 12
+; RUN: opt %s -reassociate -constprop -instcombine -die -S | not grep 12
define i32 @test_mul(i32 %arg) {
%tmp1 = mul i32 12, %arg ; <i32> [#uses=1]
; There should be exactly one shift and one add left.
; RUN: llvm-as < %s | \
-; RUN: opt -reassociate -instcombine | llvm-dis > %t
+; RUN: opt -reassociate -instcombine -S > %t
; RUN: grep shl %t | count 1
; RUN: grep add %t | count 1
; With shl->mul reassociation, we can see that this is (shl A, 9) * A
;
-; RUN: opt %s -reassociate -instcombine | llvm-dis |\
+; RUN: opt %s -reassociate -instcombine -S |\
; RUN: grep {shl .*, 9}
define i32 @test(i32 %A, i32 %B) {
; With sub reassociation, constant folding can eliminate the 12 and -12 constants.
;
-; RUN: opt %s -reassociate -instcombine | llvm-dis | not grep 12
+; RUN: opt %s -reassociate -instcombine -S | not grep 12
define i32 @test(i32 %A, i32 %B) {
%X = add i32 -12, %A ; <i32> [#uses=1]
; With sub reassociation, constant folding can eliminate the uses of %a.
;
-; RUN: opt %s -reassociate -instcombine | llvm-dis | grep %a | count 1
+; RUN: opt %s -reassociate -instcombine -S | grep %a | count 1
; PR2047
define i32 @test(i32 %a, i32 %b, i32 %c) nounwind {
; real benchmark (mst from Olden benchmark, MakeGraph function). When SCCP is
; fixed, this should be eliminated by a single SCCP application.
;
-; RUN: opt %s -sccp | llvm-dis | not grep loop
+; RUN: opt %s -sccp -S | not grep loop
define i32* @test() {
bb1:
-; RUN: opt %s -sccp | llvm-dis | not grep sub
+; RUN: opt %s -sccp -S | not grep sub
define void @test3(i32, i32) {
add i32 0, 0 ; <i32>:3 [#uses=0]
; This test shows a case where SCCP is incorrectly eliminating the PHI node
; because it thinks it has a constant 0 value, when it really doesn't.
-; RUN: opt %s -sccp | llvm-dis | grep phi
+; RUN: opt %s -sccp -S | grep phi
define i32 @test(i32 %A, i1 %c) {
bb1:
; this is in fact NOT the case, so the return should still be alive in the code
; after sccp and CFG simplification have been performed.
;
-; RUN: opt %s -sccp -simplifycfg | llvm-dis | \
+; RUN: opt %s -sccp -simplifycfg -S | \
; RUN: grep ret
define void @old_main() {
-; RUN: opt %s -sccp | llvm-dis | not grep %X
+; RUN: opt %s -sccp -S | not grep %X
@G = external global [40 x i32] ; <[40 x i32]*> [#uses=1]
-; RUN: opt %s -sccp -simplifycfg | llvm-dis | \
+; RUN: opt %s -sccp -simplifycfg -S | \
; RUN: not grep then:
define void @cprop_test11(i32* %data.1) {
; The PHI cannot be eliminated from this testcase, SCCP is mishandling invoke's!
-; RUN: opt %s -sccp | llvm-dis | grep phi
+; RUN: opt %s -sccp -S | grep phi
declare void @foo()
-; RUN: opt %s -sccp | llvm-dis | grep {ret i32 1}
+; RUN: opt %s -sccp -S | grep {ret i32 1}
; This function definitely returns 1, even if we don't know the direction
; of the branch.
-; RUN: opt %s -sccp | llvm-dis | \
+; RUN: opt %s -sccp -S | \
; RUN: grep {ret i1 false}
define i1 @foo() {
-; RUN: opt %s -sccp | llvm-dis | grep undef | count 1
+; RUN: opt %s -sccp -S | grep undef | count 1
; PR1938
define i32 @main() {
-; RUN: llvm-as < %s | opt -ipsccp | llvm-dis > %t
+; RUN: llvm-as < %s | opt -ipsccp -S > %t
; RUN: grep {ret i32 36} %t
; RUN: grep {%mrv = insertvalue %T undef, i32 18, 0} %t
; RUN: grep {%mrv1 = insertvalue %T %mrv, i32 17, 1} %t
-; RUN: llvm-as < %s | opt -sccp | llvm-dis | grep {ret i32 %Z}
+; RUN: llvm-as < %s | opt -sccp -S | grep {ret i32 %Z}
; rdar://5778210
declare {i32, i32} @bar(i32 %A)
-; RUN: opt %s -sccp | llvm-dis | not grep {ret i32 undef}
+; RUN: opt %s -sccp -S | not grep {ret i32 undef}
; PR2358
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"
-; RUN: opt %s -ipsccp | llvm-dis | grep {ret i32 42}
-; RUN: opt %s -ipsccp | llvm-dis | grep {ret i32 undef}
+; RUN: opt %s -ipsccp -S | grep {ret i32 42}
+; RUN: opt %s -ipsccp -S | grep {ret i32 undef}
; PR3325
define i32 @main() {
-; RUN: opt %s -sccp | llvm-dis | grep {ret i101 12}
+; RUN: opt %s -sccp -S | grep {ret i101 12}
@Y = constant [6 x i101] [ i101 12, i101 123456789000000, i101 -12,i101
-123456789000000, i101 0,i101 9123456789000000]
; This is a basic sanity check for constant propogation. The add instruction
; should be eliminated.
-; RUN: opt %s -sccp | llvm-dis | not grep add
+; RUN: opt %s -sccp -S | not grep add
define i128 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
; This is a basic sanity check for constant propogation. The add instruction
; and phi instruction should be eliminated.
-; RUN: opt %s -sccp | llvm-dis | not grep phi
-; RUN: opt %s -sccp | llvm-dis | not grep add
+; RUN: opt %s -sccp -S | not grep phi
+; RUN: opt %s -sccp -S | not grep add
define i128 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
; arithmatic operations.
-; RUN: opt %s -sccp | llvm-dis | not grep mul
-; RUN: opt %s -sccp | llvm-dis | not grep umod
+; RUN: opt %s -sccp -S | not grep mul
+; RUN: opt %s -sccp -S | not grep umod
define i128 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
; logic operations.
-; RUN: opt %s -sccp | llvm-dis | not grep and
-; RUN: opt %s -sccp | llvm-dis | not grep trunc
-; RUN: opt %s -sccp | llvm-dis | grep {ret i100 -1}
+; RUN: opt %s -sccp -S | not grep and
+; RUN: opt %s -sccp -S | not grep trunc
+; RUN: opt %s -sccp -S | grep {ret i100 -1}
define i100 @test(i133 %A) {
%B = and i133 0, %A
-; RUN: opt %s -sccp | llvm-dis | not grep %X
+; RUN: opt %s -sccp -S | not grep %X
@G = global [1000000 x i10000] zeroinitializer
-; RUN: llvm-as < %s | opt -sccp | llvm-dis | not grep xor
+; RUN: llvm-as < %s | opt -sccp -S | not grep xor
define i11129 @test1() {
%B = shl i11129 1, 11128
-; RUN: llvm-as < %s | opt -sccp | llvm-dis | not grep load
+; RUN: llvm-as < %s | opt -sccp -S | not grep load
@Y = constant [6 x i101] [ i101 12, i101 123456789000000, i101 -12,
i101 -123456789000000, i101 0,i101 9123456789000000]
-; RUN: opt %s -ipsccp | llvm-dis | grep -v {ret i512 undef} | \
+; RUN: opt %s -ipsccp -S | grep -v {ret i512 undef} | \
; RUN: grep {ret i8 2}
define internal i512 @test(i1 %B) {
-; RUN: opt %s -ipsccp | llvm-dis | grep -v {ret i101 0} | \
+; RUN: opt %s -ipsccp -S | grep -v {ret i101 0} | \
; RUN: grep -v {ret i101 undef} | not grep ret
-; RUN: llvm-as < %s | opt -ipsccp | llvm-dis | not grep global
+; RUN: llvm-as < %s | opt -ipsccp -S | not grep global
@G = internal global i66 undef
; This test makes sure that these instructions are properly constant propagated.
-; RUN: opt %s -ipsccp | llvm-dis | not grep load
-; RUN: opt %s -ipsccp | llvm-dis | not grep add
-; RUN: opt %s -ipsccp | llvm-dis | not grep phi
+; RUN: opt %s -ipsccp -S | not grep load
+; RUN: opt %s -ipsccp -S | not grep add
+; RUN: opt %s -ipsccp -S | not grep phi
@Y = constant [2 x { i212, float }] [ { i212, float } { i212 12, float 1.0 },
; This test makes sure that these instructions are properly constant propagated.
-; RUN: opt %s -ipsccp | llvm-dis | not grep load
-; RUN: opt %s -ipsccp | llvm-dis | not grep fdiv
+; RUN: opt < %s -ipsccp -S | not grep load
+; RUN: opt < %s -ipsccp -S | not grep fdiv
@X = constant i212 42
@Y = constant [2 x { i212, float }] [ { i212, float } { i212 12, float 1.0 },
-; RUN: opt %s -sccp | llvm-dis | not grep phi
+; RUN: opt < %s -sccp -S | not grep phi
define i999 @test(i999%A, i1 %c) {
bb1:
-; RUN: llvm-as < %s | opt -sccp | llvm-dis | not grep select
+; RUN: llvm-as < %s | opt -sccp -S | not grep select
@A = constant i32 10
; This is a basic sanity check for constant propogation. The add instruction
; should be eliminated.
-; RUN: opt %s -sccp | llvm-dis | not grep add
+; RUN: opt %s -sccp -S | not grep add
define i32 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
-; RUN: opt %s -sccp -loop-deletion -simplifycfg | llvm-dis | \
+; RUN: opt %s -sccp -loop-deletion -simplifycfg -S | \
; RUN: not grep br
; No matter how hard you try, sqrt(1.0) is always 1.0. This allows the
-; RUN: opt %s -ipsccp | llvm-dis | \
+; RUN: opt %s -ipsccp -S | \
; RUN: grep -v {ret i32 17} | grep -v {ret i32 undef} | not grep ret
define internal i32 @bar(i32 %A) {
-; RUN: opt %s -ipsccp | llvm-dis | \
+; RUN: opt %s -ipsccp -S | \
; RUN: grep -v {ret i32 0} | grep -v {ret i32 undef} | not grep ret
define internal i32 @bar(i32 %A) {
-; RUN: opt %s -ipsccp | llvm-dis | not grep global
+; RUN: opt %s -ipsccp -S | not grep global
@G = internal global i32 undef ; <i32*> [#uses=5]
; This test makes sure that these instructions are properly constant propagated.
;
-; RUN: opt %s -sccp | llvm-dis | not grep load
+; RUN: opt < %s -sccp -S | not grep load
@X = constant i32 42 ; <i32*> [#uses=1]
-; RUN: opt %s -sccp | llvm-dis | grep {ret i32 0}
+; RUN: opt %s -sccp -S | grep {ret i32 0}
; Test that SCCP has basic knowledge of when and/or nuke overdefined values.
-; RUN: opt %s -sccp -dce -simplifycfg | llvm-dis | \
+; RUN: opt %s -sccp -dce -simplifycfg -S | \
; RUN: not grep br
define i32 @test(i32 %param) {
-; RUN: opt %s -sccp | llvm-dis | not grep select
+; RUN: opt < %s -sccp -S | not grep select
define i32 @test1(i1 %C) {
%X = select i1 %C, i32 0, i32 0 ; <i32> [#uses=1]
; We're mainly testing for opt not to crash, but we'll check to see if the sret
; attribute is still there for good measure.
-; RUN: opt %s -sretpromotion | llvm-dis | grep sret
+; RUN: opt %s -sretpromotion -S | grep sret
%struct.S = type <{ i32, i32 }>
; We're mainly testing for opt not to crash, but we'll check to see if the sret
; attribute is still there for good measure.
-; RUN: opt %s -sretpromotion | llvm-dis | grep sret
+; RUN: opt %s -sretpromotion -S | grep sret
%struct.S = type <{ i32, i32 }>
-; RUN: opt %s -sretpromotion | llvm-dis > %t
+; RUN: opt %s -sretpromotion -S > %t
; RUN: cat %t | grep sret | count 1
; This function is promotable
-; RUN: opt %s -ssi-everything | llvm-dis | FileCheck %s
+; RUN: opt %s -ssi-everything -S | FileCheck %s
declare void @use(i32)
declare i32 @create()
-; RUN: opt %s -scalarrepl -instcombine | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -instcombine -S | not grep alloca
; Test that an array is not incorrectly deconstructed.
; Scalar replacement was incorrectly promoting this alloca!!
;
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: sed {s/;.*//g} | grep {\\\[}
define i8* @test() {
-; RUN: opt %s -scalarrepl | llvm-dis | grep {alloca %T}
+; RUN: opt %s -scalarrepl -S | grep {alloca %T}
%T = type { [80 x i8], i32, i32 }
declare i32 @.callback_1(i8*)
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep alloca
define i32 @func(<4 x float> %v0, <4 x float> %v1) nounwind {
%vsiidx = alloca [2 x <4 x i32>], align 16 ; <[2 x <4 x i32>]*> [#uses=3]
-; RUN: opt %s -scalarrepl | llvm-dis | grep {alloca.*client_t}
+; RUN: opt %s -scalarrepl -S | grep {alloca.*client_t}
; PR1446
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"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -scalarrepl | llvm-dis | grep memcpy
+; RUN: opt %s -scalarrepl -S | grep memcpy
; PR1421
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"
-; RUN: opt %s -scalarrepl | llvm-dis | not grep shr
+; RUN: opt %s -scalarrepl -S | not grep shr
%struct.S = type { i16 }
-; RUN: opt %s -scalarrepl -instcombine | llvm-dis | grep {ret i8 17}
+; RUN: opt %s -scalarrepl -instcombine -S | grep {ret i8 17}
; rdar://5707076
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.1.0"
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep alloca
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"
%struct..0anon = type { <1 x i64> }
; instruction, which was not possible before aggregrates were first class
; values. This checks of scalarrepl splits up the struct and array properly.
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep alloca
define i32 @foo() {
%target = alloca { i32, i32 } ; <{ i32, i32 }*> [#uses=1]
-; RUN: opt %s -scalarrepl | llvm-dis | grep {call.*mem}
+; RUN: opt %s -scalarrepl -S | grep {call.*mem}
; PR2369
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"
-; RUN: opt %s -scalarrepl | llvm-dis | grep {s = alloca .struct.x}
+; RUN: opt %s -scalarrepl -S | grep {s = alloca .struct.x}
; PR2423
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin8"
; this would not work when there was a vector involved in the struct, preventing
; scalarrepl from removing the alloca below.
-; RUN: opt %s -scalarrepl | llvm-dis > %t
+; RUN: opt %s -scalarrepl -S > %t
; RUN: cat %t | not grep alloca
%struct.two = type <{ < 2 x i8 >, i16 }>
-; RUN: opt %s -scalarrepl -instcombine | llvm-dis | grep {ret i32 %x}
+; RUN: opt %s -scalarrepl -instcombine -S | grep {ret i32 %x}
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"
target triple = "i386-pc-linux-gnu"
-; RUN: opt %s -scalarrepl -instcombine -inline -instcombine | llvm-dis | grep {ret i32 42}
+; RUN: opt %s -scalarrepl -instcombine -inline -instcombine -S | grep {ret i32 42}
; PR3489
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-f80:128:128"
target triple = "x86_64-apple-darwin10.0"
; The store into %p should end up with a known alignment of 1, since the memcpy
; is only known to access it with 1-byte alignment.
-; RUN: opt %s -scalarrepl | llvm-dis | grep {store i16 1, .*, align 1}
+; RUN: opt %s -scalarrepl -S | grep {store i16 1, .*, align 1}
; PR3720
%struct.st = type { i16 }
-; RUN: opt %s -scalarrepl | llvm-dis | grep store | not grep undef
+; RUN: opt %s -scalarrepl -S | grep store | not grep undef
; ModuleID = '<stdin>'
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"
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: not grep alloca
target datalayout = "E-p:32:32"
; This is a feature test. Hopefully one day this will be implemented. The
; generated code should perform the appropriate masking operations required
; depending on the endianness of the target...
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: not grep alloca
define i32 @testfunc(i32 %i, i8 %j) {
-; RUN: opt %s -scalarrepl -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -mem2reg -S | not grep alloca
define i32 @test() {
%X = alloca [4 x i32] ; <[4 x i32]*> [#uses=1]
-; RUN: opt %s -scalarrepl -instcombine | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -instcombine -S | not grep alloca
; PR3466
define i32 @test() {
-; RUN: opt %s -scalarrepl -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -mem2reg -S | not grep alloca
define i32 @test() {
%X = alloca { i32, float } ; <{ i32, float }*> [#uses=1]
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep alloca
; rdar://6532315
%t = type { { i32, i16, i8, i8 } }
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep alloca
; PR3290
;; Store of integer to whole alloca struct.
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep alloca
%llvm.dbg.anchor.type = type { i32, i32 }
%llvm.dbg.basictype.type = type { i32, { }*, i8*, { }*, i32, i64, i64, i64, i32, i32 }
%llvm.dbg.compile_unit.type = type { i32, { }*, i32, i8*, i8*, i8*, i1, i1, i8* }
; are directly loaded from or stored to (using the first class aggregates
; feature).
-; RUN: opt %s -scalarrepl | llvm-dis > %t
+; RUN: opt %s -scalarrepl -S > %t
; RUN: cat %t | not grep alloca
%struct.foo = type { i32, i32 }
-; RUN: opt %s -scalarrepl | llvm-dis | not grep {call.*memcpy}
+; RUN: opt %s -scalarrepl -S | not grep {call.*memcpy}
@C.0.1248 = internal constant [128 x float] [ float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 0.000000e+00, float -1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float -1.000000e+00, float 0.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00 ], align 32 ; <[128 x float]*> [#uses=1]
define float @grad4(i32 %hash, float %x, float %y, float %z, float %w) {
; PR1226
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: not grep {call void @llvm.memcpy.i32}
-; RUN: opt %s -scalarrepl | llvm-dis | grep getelementptr
+; RUN: opt %s -scalarrepl -S | grep getelementptr
; END.
target datalayout = "E-p:32:32"
; PR1226
-; RUN: opt %s -scalarrepl | llvm-dis | grep {ret i32 16843009}
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
-; RUN: opt %s -scalarrepl -instcombine | llvm-dis | grep {ret i16 514}
+; RUN: opt %s -scalarrepl -S | grep {ret i32 16843009}
+; RUN: opt %s -scalarrepl -S | not grep alloca
+; RUN: opt %s -scalarrepl -instcombine -S | grep {ret i16 514}
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"
target triple = "i686-apple-darwin8"
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
-; RUN: opt %s -scalarrepl | llvm-dis | not grep {7 x double}
-; RUN: opt %s -scalarrepl -instcombine | llvm-dis | grep {ret double %B}
+; RUN: opt %s -scalarrepl -S | not grep alloca
+; RUN: opt %s -scalarrepl -S | not grep {7 x double}
+; RUN: opt %s -scalarrepl -instcombine -S | grep {ret double %B}
define double @test(double %A, double %B) {
%ARR = alloca [7 x i64]
-; RUN: opt %s -simplifycfg -instcombine -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -simplifycfg -instcombine -mem2reg -S | not grep alloca
;
; This tests to see if mem2reg can promote alloca instructions whose addresses
; are used by PHI nodes that are immediately loaded. The LLVM C++ front-end
; Test promotion of loads that use the result of a select instruction. This
; should be simplified by the instcombine pass.
-; RUN: opt %s -instcombine -mem2reg | llvm-dis | not grep alloca
+; RUN: opt %s -instcombine -mem2reg -S | not grep alloca
define i32 @main() {
%mem_tmp.0 = alloca i32 ; <i32*> [#uses=3]
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: not grep alloca
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: grep {bitcast.*float.*i32}
define i32 @test(float %X) {
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: not grep alloca
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: grep bitcast
define <4 x i32> @test(<4 x float> %X) {
; PR892
-; RUN: opt %s -scalarrepl | llvm-dis | \
+; RUN: opt %s -scalarrepl -S | \
; RUN: not grep alloca
-; RUN: opt %s -scalarrepl | llvm-dis | grep {ret i8}
+; RUN: opt %s -scalarrepl -S | grep {ret i8}
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin8.7.2"
-; RUN: opt %s -scalarrepl | llvm-dis > %t
+; RUN: opt %s -scalarrepl -S > %t
; RUN: grep {ret <16 x float> %A} %t
; RUN: grep {ret <16 x float> zeroinitializer} %t
-; RUN: opt %s -scalarrepl | llvm-dis | not grep alloca
-; RUN: opt %s -scalarrepl | llvm-dis | grep {load <4 x float>}
+; RUN: opt %s -scalarrepl -S | not grep alloca
+; RUN: opt %s -scalarrepl -S | grep {load <4 x float>}
define void @test(<4 x float>* %F, float %f) {
entry:
-; RUN: opt %s -scalarrepl | llvm-dis | grep {volatile load}
-; RUN: opt %s -scalarrepl | llvm-dis | grep {volatile store}
+; RUN: opt %s -scalarrepl -S | grep {volatile load}
+; RUN: opt %s -scalarrepl -S | grep {volatile store}
define i32 @voltest(i32 %T) {
%A = alloca {i32, i32}
; Basic block #2 should not be merged into BB #3!
;
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: grep {br label}
;
; -simplifycfg is not folding blocks if there is a PHI node involved. This
; should be fixed eventually
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
define i32 @main(i32 %argc) {
; <label>:0
; Do not remove the invoke!
;
-; RUN: opt %s -simplifycfg | llvm-dis | grep invoke
+; RUN: opt %s -simplifycfg -S | grep invoke
define i32 @test() {
invoke i32 @test( )
; This test checks to make sure that 'br X, Dest, Dest' is folded into
; 'br Dest'
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep {br i1 %c2}
declare void @noop()
; due to the fact that the SimplifyCFG function does not use
; the ConstantFoldTerminator function.
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep {br i1 %c2}
declare void @noop()
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep switch
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep switch
; Test normal folding
; PR957
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep select
@G = extern_weak global i32
-; RUN: opt %s -simplifycfg | llvm-dis | not grep invoke
+; RUN: opt %s -simplifycfg -S | not grep invoke
declare i32 @func(i8*) nounwind
; The phi should not be eliminated in this case, because the fp op could trap.
-; RUN: opt %s -simplifycfg | llvm-dis | grep {= phi double}
+; RUN: opt %s -simplifycfg -S | grep {= phi double}
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"
-; RUN: opt %s -simplifycfg | llvm-dis > %t
+; RUN: opt %s -simplifycfg -S > %t
; RUN: not grep {^BB.tomerge} %t
; RUN grep {^BB.nomerge} %t | count 2
-; RUN: opt %s -simplifycfg | llvm-dis | grep {%outval = phi i32 .*mux}
+; RUN: opt %s -simplifycfg -S | grep {%outval = phi i32 .*mux}
; PR2540
; Outval should end up with a select from 0/2, not all constants.
-; RUN: opt %s -simplifycfg | llvm-dis | not grep icmp
+; RUN: opt %s -simplifycfg -S | not grep icmp
; ModuleID = '/tmp/x.bc'
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-pc-linux-gnu"
-; RUN: opt %s -simplifycfg | llvm-dis | grep {br i1 } | count 4
+; RUN: opt %s -simplifycfg -S | grep {br i1 } | count 4
; PR3354
; Do not merge bb1 into the entry block, it might trap.
-; RUN: opt %s -simplifycfg | llvm-dis | grep select
+; RUN: opt %s -simplifycfg -S | grep select
%llvm.dbg.anchor.type = type { i32, i32 }
%llvm.dbg.compile_unit.type = type { i32, { }*, i32, i8*, i8*, i8*, i1, i1, i8* }
-; RUN: opt %s -simplifycfg | llvm-dis | not grep select
+; RUN: opt %s -simplifycfg -S | not grep select
; ModuleID = '<stdin>'
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin10.0"
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep {br label}
define void @test(i1 %C) {
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep {icmp eq}
; Check that simplifycfg deletes a dead 'seteq' instruction when it
; Test merging of blocks with phi nodes.
;
-; RUN: opt %s -simplifycfg | llvm-dis | not grep N:
+; RUN: opt %s -simplifycfg -S | not grep N:
;
define i32 @test(i1 %a) {
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
define void @foo(i1 %C, i32* %P) {
br i1 %C, label %T, label %F
; If this test is successful, the function should be reduced to 'call; ret'
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not egrep {\\(invoke\\)|\\(br\\)}
declare void @bar()
; Test merging of blocks that only have PHI nodes in them
;
-; RUN: opt %s -simplifycfg | llvm-dis | not grep N:
+; RUN: opt %s -simplifycfg -S | not grep N:
;
define i32 @test(i1 %a, i1 %b) {
; where the mergedinto block doesn't have any PHI nodes, and is in fact
; dominated by the block-to-be-eliminated
;
-; RUN: opt %s -simplifycfg | llvm-dis | not grep N:
+; RUN: opt %s -simplifycfg -S | not grep N:
;
declare i1 @foo()
; nodes away allows the branches to be eliminated, performing a simple form of
; 'if conversion'.
-; RUN: opt %s -simplifycfg | llvm-dis > %t.xform
+; RUN: opt %s -simplifycfg -S > %t.xform
; RUN: not grep phi %t.xform
; RUN: grep ret %t.xform
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
define i32 @test(i1 %C, i32 %V1, i32 %V2) {
entry:
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep select
;; The PHI node in this example should not be turned into a select, as we are
-; RUN: opt %s -simplifycfg | llvm-dis | grep select
-; RUN: opt %s -simplifycfg | llvm-dis | grep br | count 2
+; RUN: opt %s -simplifycfg -S | grep select
+; RUN: opt %s -simplifycfg -S | grep br | count 2
define i32 @t2(i32 %a, i32 %b, i32 %c) nounwind {
entry:
; a PHI node and a return. Make sure the simplify cfg can straighten out this
; important case. This is basically the most trivial form of tail-duplication.
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep {br label}
define i32 @test(i1 %B, i32 %A, i32 %B.upgrd.1) {
-; RUN: opt %s -simplifycfg | llvm-dis | not grep unreachable
+; RUN: opt %s -simplifycfg -S | not grep unreachable
define void @test1(i1 %C, i1* %BP) {
br i1 %C, label %T, label %F
; Test CFG simplify removal of branch instructions...
;
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
define void @test1() {
br label %BB1
-; RUN: opt %s -simplifycfg | llvm-dis | grep {br i1} | count 1
+; RUN: opt %s -simplifycfg -S | grep {br i1} | count 1
; ModuleID = '<stdin>'
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"
-; RUN: opt %s -simplifycfg | llvm-dis | not grep call
+; RUN: opt %s -simplifycfg -S | not grep call
declare void @bar()
; This test ensures that the simplifycfg pass continues to constant fold
; terminator instructions.
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt < %s -simplifycfg -S | not grep br
define i32 @test(i32 %A, i32 %B) {
J:
-; RUN: opt %s -simplifycfg | llvm-dis | grep {br i1} | count 1
+; RUN: opt %s -simplifycfg -S | grep {br i1} | count 1
define void @test(i32* %P, i32* %Q, i1 %A, i1 %B) {
br i1 %A, label %a, label %b
-; RUN: opt %s -simplifycfg -adce | llvm-dis | \
+; RUN: opt %s -simplifycfg -adce -S | \
; RUN: not grep {call void @f1}
; END.
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt < %s -simplifycfg -S | not grep br
; END.
%llvm.dbg.anchor.type = type { i32, i32 }
-; RUN: opt %s -simplifycfg | llvm-dis | not grep "br label"
+; RUN: opt %s -simplifycfg -S | not grep "br label"
%llvm.dbg.anchor.type = type { i32, i32 }
%llvm.dbg.basictype.type = type { i32, { }*, i8*, { }*, i32, i64, i64, i64, i32, i32 }
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
%llvm.dbg.anchor.type = type { i32, i32 }
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
declare void @bar(i32)
-; RUN: opt %s -simplifycfg | llvm-dis | not grep bb17
+; RUN: opt %s -simplifycfg -S | not grep bb17
; PR1786
define i32 @main() {
-; RUN: opt %s -simplifycfg | llvm-dis | grep unreachable
+; RUN: opt %s -simplifycfg -S | grep unreachable
; PR1796
declare void @Finisher(i32) noreturn
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
define i32 @test1(i1 %C) {
entry:
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
declare void @foo1()
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
; END.
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
; END.
define i1 @_ZN4llvm11SetCondInst7classofEPKNS_11InstructionE({ i32, i32 }* %I) {
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: grep switch | count 1
; Test that a switch going to a switch on the same value can be merged. All
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: grep switch | count 1
; ModuleID = '<stdin>'
-; RUN: opt %s -simplifycfg | llvm-dis | \
+; RUN: opt %s -simplifycfg -S | \
; RUN: not grep {call void @DEAD}
; Test that we can thread a simple known condition through switch statements.
-; RUN: opt %s -simplifycfg | llvm-dis | grep {volatile load}
+; RUN: opt %s -simplifycfg -S | grep {volatile load}
; PR2967
target datalayout =
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
%llvm.dbg.anchor.type = type { i32, i32 }
%llvm.dbg.compile_unit.type = type { i32, { }*, i32, i8*, i8*, i8*, i1, i1, i8* }
-; RUN: opt %s -simplifycfg | llvm-dis | not grep br
+; RUN: opt %s -simplifycfg -S | not grep br
define i1 @qux(i8* %m, i8* %n, i8* %o, i8* %p) nounwind {
entry:
; PR1307
-; RUN: opt %s -simplify-libcalls -instcombine | llvm-dis > %t
+; RUN: opt %s -simplify-libcalls -instcombine -S > %t
; RUN: grep {@str,.*i64 3} %t
; RUN: grep {@str1,.*i64 7} %t
; RUN: grep {ret i8.*null} %t
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep i32
+; RUN: opt %s -simplify-libcalls -S | grep i32
; PR2341
@_2E_str = external constant [5 x i8] ; <[5 x i8]*> [#uses=1]
-; RUN: opt %s -simplify-libcalls | llvm-dis > %t
+; RUN: opt %s -simplify-libcalls -S > %t
; RUN: grep noalias %t | count 2
; RUN: grep nocapture %t | count 3
; RUN: grep nounwind %t | count 3
-; RUN: opt %s -simplify-libcalls | llvm-dis > %t
+; RUN: opt %s -simplify-libcalls -S > %t
; RUN: grep nocapture %t | count 2
; RUN: grep null %t | grep nocapture | count 1
; RUN: grep null %t | grep call | grep readonly | count 1
-; RUN: opt %s -simplify-libcalls -instcombine | llvm-dis | grep {ret i32 -65}
+; RUN: opt %s -simplify-libcalls -instcombine -S | grep {ret i32 -65}
; PR4284
define i32 @test() nounwind {
; Test that the ToAsciiOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*@ffs}
@non_const = external global i32 ; <i32*> [#uses=1]
; Test that the FPrintFOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*fprintf}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the IsDigitOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep call
declare i32 @isdigit(i32)
-; RUN: opt %s -constprop -instcombine | llvm-dis | not grep {call.*llvm.memcpy.i32}
+; RUN: opt %s -constprop -instcombine -S | not grep {call.*llvm.memcpy.i32}
@h = constant [2 x i8] c"h\00" ; <[2 x i8]*> [#uses=1]
@hel = constant [4 x i8] c"hel\00" ; <[4 x i8]*> [#uses=1]
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep putchar
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | grep putchar
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*printf}
@str = internal constant [13 x i8] c"hello world\0A\00" ; <[13 x i8]*> [#uses=1]
; Test that the PutsCatOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*fputs}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the SPrintFOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*sprintf}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the StrCatOptimizer works correctly
; PR3661
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strcat}
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: grep {puts.*%arg1}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the StrChrOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*@strchr}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the StrCmpOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strcmp}
@hello = constant [6 x i8] c"hello\00" ; <[6 x i8]*> [#uses=1]
; Test that the StrCpyOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strcpy}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the StrCatOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strlen}
target datalayout = "e-p:32:32"
; Test that the StrNCatOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strncat}
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: grep {puts.*%arg1}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the StrNCmpOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strncmp}
@hello = constant [6 x i8] c"hello\00" ; <[6 x i8]*> [#uses=1]
; Test that the StrNCpyOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*strncpy}
; This transformation requires the pointer size, as it assumes that size_t is
; Test that the ToAsciiOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | \
+; RUN: opt %s -simplify-libcalls -S | \
; RUN: not grep {call.*toascii}
declare i32 @toascii(i32)
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep {select i1 %ispos}
+; RUN: opt %s -simplify-libcalls -S | grep {select i1 %ispos}
; PR2337
define i32 @test(i32 %x) {
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep {call.*ldexp} | count 4
+; RUN: opt %s -simplify-libcalls -S | grep {call.*ldexp} | count 4
; rdar://5852514
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"
-; RUN: opt %s -simplify-libcalls | llvm-dis > %t
+; RUN: opt %s -simplify-libcalls -S > %t
; RUN: not grep {call.*floor(} %t
; RUN: grep {call.*floorf(} %t
; RUN: not grep {call.*ceil(} %t
-; RUN: opt -simplify-libcalls-halfpowr %s | llvm-dis | FileCheck %s
+; RUN: opt -simplify-libcalls-halfpowr %s -S | FileCheck %s
define float @__half_powrf4(float %f, float %g) nounwind readnone {
entry:
; Test that the memcmpOptimizer works correctly
-; RUN: opt %s -simplify-libcalls | llvm-dis | not grep {call.*memcmp}
+; RUN: opt %s -simplify-libcalls -S | not grep {call.*memcmp}
@h = constant [2 x i8] c"h\00" ; <[2 x i8]*> [#uses=0]
@hel = constant [4 x i8] c"hel\00" ; <[4 x i8]*> [#uses=0]
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep {llvm.memmove}
+; RUN: opt %s -simplify-libcalls -S | grep {llvm.memmove}
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"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep {llvm.memset}
+; RUN: opt %s -simplify-libcalls -S | grep {llvm.memset}
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-pc-linux-gnu"
-; RUN: opt %s -simplify-libcalls | llvm-dis | grep {llvm.memset}
+; RUN: opt %s -simplify-libcalls -S | grep {llvm.memset}
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"
target triple = "i686-pc-linux-gnu"
; Testcase for calls to the standard C "pow" function
;
-; RUN: opt %s -simplify-libcalls | llvm-dis | not grep {call .pow}
+; RUN: opt %s -simplify-libcalls -S | not grep {call .pow}
declare double @pow(double, double)
-; RUN: opt %s -simplify-libcalls | llvm-dis | FileCheck %s
+; RUN: opt %s -simplify-libcalls -S | FileCheck %s
; PR4738
; SimplifyLibcalls shouldn't assume anything about weak symbols.
-; RUN: opt %s -strip | llvm-dis | grep foo | count 2
-; RUN: opt %s -strip | llvm-dis | grep bar | count 2
+; RUN: opt %s -strip -S | grep foo | count 2
+; RUN: opt %s -strip -S | grep bar | count 2
@llvm.used = appending global [2 x i8*] [ i8* bitcast (i32* @foo to i8*), i8* bitcast (i32 ()* @bar to i8*) ], section "llvm.metadata" ; <[2 x i8*]*> [#uses=0]
@foo = internal constant i32 41 ; <i32*> [#uses=1]
-; RUN: opt %s -tailcallelim | llvm-dis | not grep call
+; RUN: opt %s -tailcallelim -S | not grep call
define i32 @factorial(i32 %x) {
entry:
; go out to the anonymous users of the demo script for "suggesting"
; optimizations that should be done. :)
-; RUN: opt %s -tailcallelim | llvm-dis | not grep call
+; RUN: opt %s -tailcallelim -S | not grep call
define i32 @mul(i32 %x, i32 %y) {
entry:
-; RUN: opt %s -tailcallelim | llvm-dis | \
+; RUN: opt %s -tailcallelim -S | \
; RUN: grep {call i32 @foo}
declare void @bar(i32*)
-; RUN: llvm-as <%s | opt -tailcallelim | llvm-dis | grep call | count 3
+; RUN: llvm-as <%s | opt -tailcallelim -S | grep call | count 3
; PR4323
; Several cases where tail call elimination should not move the load above the
-; RUN: opt %s -tailcallelim | llvm-dis | grep call
+; RUN: opt %s -tailcallelim -S | grep call
; Don't turn this into an infinite loop, this is probably the implementation
; of fabs and we expect the codegen to lower fabs.
; This function contains intervening instructions which should be moved out of the way
-; RUN: opt %s -tailcallelim | llvm-dis | not grep call
+; RUN: opt %s -tailcallelim -S | not grep call
define i32 @Test(i32 %X) {
entry:
-; RUN: opt -tailcallelim %s | llvm-dis | FileCheck %s
+; RUN: opt -tailcallelim %s -S | FileCheck %s
; PR615
declare void @bar(i32*)
-; RUN: llvm-as <%s | opt -tailcallelim | llvm-dis | not grep call
+; RUN: llvm-as <%s | opt -tailcallelim -S | not grep call
; PR4323
; Several cases where tail call elimination should move the load above the call,
; Though this case seems to be fairly unlikely to occur in the wild, someone
; plunked it into the demo script, so maybe they care about it.
;
-; RUN: opt %s -tailcallelim | llvm-dis | not grep call
+; RUN: opt %s -tailcallelim -S | not grep call
define i32 @aaa(i32 %c) {
entry:
-; RUN: opt %s -tailcallelim | llvm-dis | \
+; RUN: opt %s -tailcallelim -S | \
; RUN: grep {tail call void @foo}
-; RUN: opt %s -tailduplicate -taildup-threshold=2 | llvm-dis | grep add | not grep uses=1
+; RUN: opt %s -tailduplicate -taildup-threshold=2 -S | grep add | not grep uses=1
define i32 @test1(i1 %C, i32 %A, i32* %P) {
entry:
projects / oota-llvm.git / commitdiff