-; RUN: opt %s -anders-aa -disable-output
+; RUN: opt < %s -anders-aa -disable-output
define void @x(i16 %Y) {
entry:
-; RUN: opt %s -anders-aa -gvn -S | not grep undef
+; RUN: opt < %s -anders-aa -gvn -S | not grep undef
; PR2160
declare void @f(i32*)
-; RUN: opt %s -anders-aa -gvn -S | 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
+; RUN: opt < %s -anders-aa
; PR3262
@.str15 = external global [3 x i8] ; <[3 x i8]*> [#uses=1]
-; RUN: opt %s -anders-aa -aa-eval 2>/dev/null
+; RUN: opt < %s -anders-aa -aa-eval 2>/dev/null
define void @test1() {
%X = malloc i32*
-; RUN: opt %s -anders-aa -gvn -deadargelim -S | 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
-; RUN: opt %s -anders-aa -gvn -instcombine -S \
+; RUN: opt < %s -anders-aa -gvn -instcombine -S \
; RUN: | grep {ret i1 true}
@G = internal global i32* null
-; RUN: opt %s -anders-aa -gvn -S \
+; RUN: opt < %s -anders-aa -gvn -S \
; RUN: | not grep {ret i32 undef}
;; From PR 2160
-; RUN: opt %s -anders-aa -disable-output
+; RUN: opt < %s -anders-aa -disable-output
define void @foo() { ret void }
; 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 -S | grep DONOTREMOVE
+; RUN: opt < %s -gvn -instcombine -S | grep DONOTREMOVE
define i32 @test() {
%A = alloca i32
-; RUN: opt %s -basicaa -aa-eval -disable-output 2>/dev/null
+; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null
; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2
define void @test({[2 x i32],[2 x i32]}* %A, i64 %X, i64 %Y) {
%P1 = getelementptr {[2 x i32],[2 x i32]}* %A, i64 0, i32 0, i64 %X
-; RUN: opt %s -gvn -instcombine -S | grep sub
+; RUN: opt < %s -gvn -instcombine -S | grep sub
; BasicAA was incorrectly concluding that P1 and P2 didn't conflict!
-; RUN: opt %s -basicaa -aa-eval -disable-output 2>/dev/null
+; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null
; Test for a bug in BasicAA which caused a crash when querying equality of P1&P2
define void @test([17 x i16]* %mask_bits) {
%P1 = getelementptr [17 x i16]* %mask_bits, i64 0, i64 0
-; RUN: opt %s -licm -disable-output
+; RUN: opt < %s -licm -disable-output
%struct..apr_array_header_t = type { i32*, i32, i32, i32, i8* }
%struct..apr_table_t = type { %struct..apr_array_header_t, i32, [32 x i32], [32 x i32] }
-; RUN: opt %s -basicaa -aa-eval -disable-output 2>/dev/null
+; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null
define i32 @MTConcat([3 x i32]* %a.1) {
%tmp.961 = getelementptr [3 x i32]* %a.1, i64 0, i64 4
-; RUN: opt %s -basicaa -aa-eval -disable-output 2>/dev/null
+; RUN: opt < %s -basicaa -aa-eval -disable-output 2>/dev/null
%struct..RefPoint = type { i32, { i32, i8, i8 } }
%struct..RefRect = type { %struct..RefPoint, %struct..RefPoint }
; In this test, a local alloca cannot alias an incoming argument.
-; RUN: opt %s -gvn -instcombine -S | not grep sub
+; RUN: opt < %s -gvn -instcombine -S | not grep sub
define i32 @test(i32* %P) {
%X = alloca i32
; This testcase consists of alias relations which should be completely
; resolvable by basicaa.
-; RUN: opt %s -aa-eval -print-may-aliases -disable-output \
+; RUN: opt < %s -aa-eval -print-may-aliases -disable-output \
; RUN: |& not grep May:
%T = type { i32, [10 x i8] }
; This testcase consists of alias relations which should be completely
; resolvable by basicaa, but require analysis of getelementptr constant exprs.
-; RUN: opt %s -aa-eval -print-may-aliases -disable-output \
+; RUN: opt < %s -aa-eval -print-may-aliases -disable-output \
; RUN: |& not grep May:
%T = type { i32, [10 x i8] }
-; RUN: opt %s -dse -S | 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
-; RUN: opt %s -licm
+; RUN: opt < %s -licm
%"java/lang/Object" = type { %struct.llvm_java_object_base }
%"java/lang/StringBuffer" = type { "java/lang/Object", i32, { "java/lang/Object", i32, [0 x i8] }*, i1 }
-; RUN: opt %s -dse
+; RUN: opt < %s -dse
%"java/lang/Object" = type { %struct.llvm_java_object_base }
%"java/lang/StringBuffer" = type { "java/lang/Object", i32, { "java/lang/Object", i32, [0 x i8] }*, i1 }
-; RUN: opt %s -basicaa -gvn -instcombine |\
+; RUN: opt < %s -basicaa -gvn -instcombine |\
; RUN: llvm-dis | grep {load i32\\* %A}
declare double* @useit(i32*)
-; RUN: opt %s -aa-eval -disable-output |& grep {2 no alias respon}
+; RUN: opt < %s -aa-eval -disable-output |& grep {2 no alias respon}
; TEST that A[1][0] may alias A[0][i].
define void @test(i32 %N) {
; PR1109
-; RUN: opt %s -basicaa -gvn -instcombine -S | \
+; RUN: opt < %s -basicaa -gvn -instcombine -S | \
; RUN: grep {sub i32}
-; RUN: opt %s -basicaa -gvn -instcombine -S | \
+; RUN: opt < %s -basicaa -gvn -instcombine -S | \
; RUN: not grep {ret i32 0}
; END.
; PR1600
-; RUN: opt %s -basicaa -gvn -instcombine -S | \
+; RUN: opt < %s -basicaa -gvn -instcombine -S | \
; RUN: grep {ret i32 0}
; END.
-; RUN: opt %s -basicaa -gvn -dce -S | grep tmp7
+; RUN: opt < %s -basicaa -gvn -dce -S | grep tmp7
%struct.A = type { i32 }
%struct.B = type { %struct.A }
-; RUN: opt %s -gvn -disable-output
+; RUN: opt < %s -gvn -disable-output
; PR1774
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 -gvn -disable-output
+; RUN: opt < %s -gvn -disable-output
; PR1782
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 -std-compile-opts -S | 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 -gvn -disable-output
+; RUN: opt < %s -gvn -disable-output
; PR2395
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 -aa-eval |& grep {1 no alias response}
+; RUN: opt < %s -aa-eval |& grep {1 no alias response}
declare noalias i32* @_Znwj(i32 %x) nounwind
-; RUN: opt %s -aa-eval -print-all-alias-modref-info -disable-output |& grep {MustAlias:.*%R,.*%r}
+; RUN: opt < %s -aa-eval -print-all-alias-modref-info -disable-output |& grep {MustAlias:.*%R,.*%r}
; Make sure that basicaa thinks R and r are must aliases.
define i32 @test(i8 * %P) {
-; RUN: opt %s -basicaa -gvn -S | grep load
+; RUN: opt < %s -basicaa -gvn -S | grep load
declare noalias i32* @noalias()
-; RUN: opt %s -gvn -S | 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 -S | grep load | count 1
+; RUN: opt < %s -basicaa -gvn -S | grep load | count 1
@flag0 = internal global i32 zeroinitializer
@turn = internal global i32 zeroinitializer
-; RUN: opt %s -aa-eval -print-all-alias-modref-info \
+; RUN: opt < %s -aa-eval -print-all-alias-modref-info \
; RUN: |& grep {MayAlias: double\\* \[%\]p.0.i.0, double\\* \[%\]p3\$}
; PR4267
; 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 -S | not grep REMOVE
+; RUN: opt < %s -basicaa -gvn -instcombine -dce -S | not grep REMOVE
@Global = external global { i32 }
; disambiguating some obvious cases. All loads should be removable in
; this testcase.
-; RUN: opt %s -basicaa -gvn -instcombine -dce -S \
+; RUN: opt < %s -basicaa -gvn -instcombine -dce -S \
; RUN: | not grep load
@A = global i32 7
; A store or load cannot alias a global if the accessed amount is larger then
; the global.
-; RUN: opt %s -basicaa -gvn -instcombine -S | not grep load
+; RUN: opt < %s -basicaa -gvn -instcombine -S | not grep load
@B = global i16 8 ; <i16*> [#uses=2]
; A very rudimentary test on AliasAnalysis::getModRefInfo.
-; RUN: opt %s -print-all-alias-modref-info -aa-eval -disable-output |& \
+; RUN: opt < %s -print-all-alias-modref-info -aa-eval -disable-output |& \
; RUN: not grep NoModRef
define i32 @callee() {
-; RUN: opt %s -basicaa -gvn -instcombine -S | 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 -S | 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 -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
+; 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 -S | 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 -basicaa -gvn -instcombine |\
+; RUN: opt < %s -basicaa -gvn -instcombine |\
; RUN: llvm-dis | grep {ret i32 0}
declare void @foo(i32*)
-; RUN: opt %s -print-callgraph -disable-output |& \
+; RUN: opt < %s -print-callgraph -disable-output |& \
; RUN: grep {Calls function 'callee'} | count 2
define internal void @callee(...) {
-; RUN: opt %s -print-callgraph -disable-output |& \
+; RUN: opt < %s -print-callgraph -disable-output |& \
; RUN: grep {Calls function}
@a = global void ()* @f ; <void ()**> [#uses=0]
-; RUN: opt %s -domtree -break-crit-edges -analyze \
+; RUN: opt < %s -domtree -break-crit-edges -analyze \
; RUN: -domtree | grep {3.*%brtrue }
; PR932
-; RUN: opt %s -domtree -break-crit-edges -domtree -disable-output
+; RUN: opt < %s -domtree -break-crit-edges -domtree -disable-output
; PR1110
%struct.OggVorbis_File = type { i8*, i32, i64, i64, %struct.ogg_sync_state, i32, i64*, i64*, i32*, i64*, %struct.vorbis_info*, %struct.vorbis_comment*, i64, i32, i32, i32, double, double, %struct.ogg_stream_state, %struct.vorbis_dsp_state, %struct.vorbis_block, %struct.ov_callbacks }
-; RUN: opt %s -globalsmodref-aa -gvn -S | 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 -S | 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 -S | 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 -S | \
+; 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 -S | 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 that pure functions are cse'd away
-; RUN: opt %s -globalsmodref-aa -gvn -instcombine | \
+; RUN: opt < %s -globalsmodref-aa -gvn -instcombine | \
; RUN: llvm-dis | not grep sub
define i32 @pure(i32 %X) {
-; RUN: opt %s -disable-output -analyze -lda | FileCheck %s
+; RUN: opt < %s -disable-output -analyze -lda | FileCheck %s
;; x[5] = x[6] // with x being a pointer passed as argument
-; RUN: opt %s -disable-output -analyze -lda | FileCheck %s
+; RUN: opt < %s -disable-output -analyze -lda | FileCheck %s
@x = common global [256 x i32] zeroinitializer, align 4
@y = common global [256 x i32] zeroinitializer, align 4
-; RUN: opt %s -disable-output -analyze -lda | FileCheck %s
+; RUN: opt < %s -disable-output -analyze -lda | FileCheck %s
@x = common global [256 x i32] zeroinitializer, align 4
@y = common global [256 x i32] zeroinitializer, align 4
-; RUN: opt %s -disable-output -analyze -lda | FileCheck %s
+; RUN: opt < %s -disable-output -analyze -lda | FileCheck %s
@x = common global [256 x i32] zeroinitializer, align 4
@y = common global [256 x i32] zeroinitializer, align 4
-; RUN: opt %s -disable-output -analyze -lda | FileCheck %s
+; RUN: opt < %s -disable-output -analyze -lda | FileCheck %s
@x = common global [256 x i32] zeroinitializer, align 4
; This testcase was incorrectly computing that the loopentry.7 loop was
; not a child of the loopentry.6 loop.
;
-; RUN: opt %s -analyze -loops | \
+; RUN: opt < %s -analyze -loops | \
; RUN: grep {^ Loop at depth 4 containing: %loopentry.7<header><latch><exit>}
define void @getAndMoveToFrontDecode() {
-; RUN: opt %s -pointertracking -analyze | FileCheck %s
+; RUN: opt < %s -pointertracking -analyze | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"
@.str = internal constant [5 x i8] c"1234\00" ; <[5 x i8]*> [#uses=1]
-; RUN: opt %s -analyze -postdomfrontier \
+; RUN: opt < %s -analyze -postdomfrontier \
; RUN: -disable-verify
; ModuleID = '2006-09-26-PostDominanceFrontier.bc'
target datalayout = "e-p:64:64"
-; RUN: opt %s -postdomfrontier -disable-output
+; RUN: opt < %s -postdomfrontier -disable-output
define void @SManager() {
entry:
-; RUN: opt %s -postdomfrontier -disable-output
+; RUN: opt < %s -postdomfrontier -disable-output
define void @args_out_of_range() {
entry:
-; RUN: opt %s -postdomtree -analyze | grep entry
+; RUN: opt < %s -postdomtree -analyze | grep entry
; PR932
define void @foo(i1 %x) {
; Test the edge profiling instrumentation.
-; RUN: opt %s -insert-edge-profiling -S | FileCheck %s
+; RUN: opt < %s -insert-edge-profiling -S | FileCheck %s
; ModuleID = '<stdin>'
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {Loop bb: backedge-taken count is 100}
; PR1533
-; RUN: opt %s -indvars -adce -simplifycfg -S | 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 -scalar-evolution -analyze -disable-output | grep {Loop bb: backedge-taken count is (-1 + (-1 \\* %x) + %y)}
+; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop bb: backedge-taken count is (-1 + (-1 \\* %x) + %y)}
; PR1597
define i32 @f(i32 %x, i32 %y) {
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 13}
; PR1706
-; RUN: opt %s -indvars -S | grep printd | grep 1206807378
+; RUN: opt < %s -indvars -S | grep printd | grep 1206807378
; PR1798
declare void @printd(i32)
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep -e {--> %b}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep -e {--> %b}
; PR1810
define void @fun() {
-; RUN: opt %s -scalar-evolution -analyze -disable-output | grep {Loop header: backedge-taken count is (0 smax %n)}
+; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop header: backedge-taken count is (0 smax %n)}
define void @foo(i32 %n) {
entry:
-; RUN: opt %s -scalar-evolution -analyze -disable-output | grep {Loop loop: backedge-taken count is (100 + (-100 smax %n))}
+; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop loop: backedge-taken count is (100 + (-100 smax %n))}
; PR2002
define void @foo(i8 %n) {
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep umax
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep umax
; PR2003
define i32 @foo(i32 %n) {
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 61}
; PR2364
-; RUN: opt %s -analyze -scalar-evolution 2>/dev/null
+; RUN: opt < %s -analyze -scalar-evolution 2>/dev/null
; PR2433
define i32 @main1(i32 %argc, i8** %argv) nounwind {
-; RUN: opt %s -analyze -scalar-evolution -disable-output |& not grep smax
+; RUN: opt < %s -analyze -scalar-evolution -disable-output |& not grep smax
; PR2261
@lut = common global [256 x i8] zeroinitializer, align 32 ; <[256 x i8]*> [#uses=1]
-; RUN: opt %s -analyze -scalar-evolution -disable-output |& not grep smax
+; RUN: opt < %s -analyze -scalar-evolution -disable-output |& not grep smax
; PR2070
define i32 @a(i32 %x) nounwind {
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep Unpredictable
; PR2088
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 113}
; PR2088
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | \
; RUN: grep -F "backedge-taken count is (-1 + (-1 * %j))"
; PR2607
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | \
; RUN: grep -F "backedge-taken count is (-2147483632 + ((-1 + (-1 * %x)) smax (-1 + (-1 * %y))))"
; PR2607
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep -F "Exits: 20028"
; PR2621
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep -F "Exits: -19168"
; PR2621
-; RUN: opt %s -analyze -scalar-evolution -disable-output
+; RUN: opt < %s -analyze -scalar-evolution -disable-output
; PR1827
declare void @use(i32)
-; RUN: opt %s -analyze -scalar-evolution -disable-output
+; RUN: opt < %s -analyze -scalar-evolution -disable-output
; PR2602
define i32 @a() nounwind {
-; RUN: opt %s -analyze -scalar-evolution -disable-output |& \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output |& \
; RUN: grep {Loop bb: backedge-taken count is (7 + (-1 \\* %argc))}
; XFAIL: *
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {Loop bb: Unpredictable backedge-taken count\\.}
; ScalarEvolution can't compute a trip count because it doesn't know if
-; RUN: opt %s -analyze -scalar-evolution -disable-output |& grep {/u 3}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output |& grep {/u 3}
; XFAIL: *
define i32 @f(i32 %x) nounwind readnone {
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep {backedge-taken count is 255}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep {backedge-taken count is 255}
; XFAIL: *
define i32 @foo(i32 %x, i32 %y, i32* %lam, i32* %alp) nounwind {
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep {0 smax}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep {0 smax}
; XFAIL: *
define i32 @f(i32 %c.idx.val) {
-; RUN: opt %s -analyze -scalar-evolution -disable-output |& \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output |& \
; RUN: grep {(((-1 \\* %i0) + (100005 smax %i0)) /u 5)}
; XFAIL: *
-; RUN: opt %s -analyze -scalar-evolution -disable-output |& grep {/u 5}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output |& grep {/u 5}
; XFAIL: *
define i8 @foo0(i8 %i0) nounwind {
-; RUN: opt %s -analyze -scalar-evolution -disable-output | not grep {/u -1}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | not grep {/u -1}
; PR3275
@g_16 = external global i16 ; <i16*> [#uses=3]
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep {(trunc i} | not grep ext
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep {(trunc i} | not grep ext
define i16 @test1(i8 %x) {
%A = sext i8 %x to i32
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep {count is 2}
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep {count is 2}
; PR3171
%struct.Foo = type { i32 }
-; RUN: opt %s -analyze -scalar-evolution
+; RUN: opt < %s -analyze -scalar-evolution
; PR4501
define void @test() {
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 100}
; PR1101
-; RUN: opt %s -scalar-evolution -analyze -disable-output \
+; RUN: opt < %s -scalar-evolution -analyze -disable-output \
; RUN: | grep {\\--> (zext} | count 2
define i32 @foo(i32 %x) {
-; RUN: opt %s -analyze -scalar-evolution -disable-output
+; RUN: opt < %s -analyze -scalar-evolution -disable-output
; PR4537
; ModuleID = 'b.bc'
-; RUN: opt %s -iv-users
+; RUN: opt < %s -iv-users
; PR4538
; ModuleID = 'bugpoint-reduced-simplified.bc'
-; RUN: opt %s -scalar-evolution -analyze -disable-output | grep {Loop bb3: backedge-taken count is (-1 + %n)}
+; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop bb3: backedge-taken count is (-1 + %n)}
; We don't want to use a max in the trip count expression in
; this testcase.
-; RUN: opt %s -indvars -S > %t
+; RUN: opt < %s -indvars -S > %t
; RUN: grep select %t | count 2
; RUN: grep {icmp ne i32.\* %w } %t
-; RUN: opt %s -scalar-evolution -analyze -disable-output \
+; RUN: opt < %s -scalar-evolution -analyze -disable-output \
; RUN: | grep {\\--> ((-128 \\* %a) /u -128)}
; Don't let ScalarEvolution fold this div away.
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep smax
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep smax
; PR1614
define i32 @f(i32 %x, i32 %y) {
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {\{%d,+,\[^\{\}\]\*\}<bb>}
; ScalarEvolution should be able to understand the loop and eliminate the casts.
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep { --> {.*,+,.*}<bb>} | count 8
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep { --> {.*,+,.*}<bb>} | count 8
; The addrecs in this loop are analyzable only by using nsw information.
-; RUN: opt %s -analyze -scalar-evolution -disable-output
+; RUN: opt < %s -analyze -scalar-evolution -disable-output
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"
%JavaObject = type { [0 x i32 (...)*]*, i8* }
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; PR 3909
-; RUN: opt %s -scev-aa -aa-eval -print-all-alias-modref-info \
+; RUN: opt < %s -scev-aa -aa-eval -print-all-alias-modref-info \
; RUN: |& FileCheck %s
; At the time of this writing, all of these CHECK lines are cases that
-; RUN: opt %s -analyze -scalar-evolution -disable-output > %t
+; RUN: opt < %s -analyze -scalar-evolution -disable-output > %t
; RUN: grep {sext i57 \{0,+,199\}<bb> to i64} %t | count 1
; RUN: grep {sext i59 \{0,+,199\}<bb> to i64} %t | count 1
-; RUN: opt %s -disable-output -scalar-evolution -analyze \
+; RUN: opt < %s -disable-output -scalar-evolution -analyze \
; RUN: | grep { --> \{-128,+,1\}<bb1> Exits: 127} | count 5
; Convert (sext {-128,+,1}) to {sext(-128),+,sext(1)}, since the
-; RUN: opt %s -disable-output -scalar-evolution -analyze \
+; RUN: opt < %s -disable-output -scalar-evolution -analyze \
; RUN: | grep { --> (sext i. \{.\*,+,.\*\}<bb1> to i64)} | count 5
; Don't convert (sext {...,+,...}) to {sext(...),+,sext(...)} in cases
-; RUN: opt %s -analyze -scalar-evolution -disable-output | FileCheck %s
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | FileCheck %s
; CHECK: %tmp3 = sext i8 %tmp2 to i32
; CHECK: --> (sext i8 {0,+,1}<bb1> to i32) Exits: -1
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep smax | count 2
-; RUN: opt %s -analyze -scalar-evolution -disable-output | grep \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep smax | count 2
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep \
; RUN: {%. smax %. smax %.}
; PR1614
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 10000}
; PR1101
-; RUN: opt %s -analyze -scalar-evolution -disable-output | \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output | \
; RUN: grep {backedge-taken count is 4}
; PR1101
-; RUN: opt %s -scalar-evolution -analyze -disable-output \
+; RUN: opt < %s -scalar-evolution -analyze -disable-output \
; RUN: | grep {Loop bb3\\.i: Unpredictable backedge-taken count\\.}
; ScalarEvolution can't compute a trip count because it doesn't know if
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {sext.*trunc.*Exits: 11}
; ScalarEvolution should be able to compute a loop exit value for %indvar.i8.
-; RUN: opt %s -analyze -scalar-evolution -disable-output > %t
+; RUN: opt < %s -analyze -scalar-evolution -disable-output > %t
; RUN: grep sext %t | count 2
; RUN: not grep {(sext} %t
-; RUN: opt %s -analyze -disable-output -scalar-evolution \
+; RUN: opt < %s -analyze -disable-output -scalar-evolution \
; RUN: | grep {max backedge-taken count is 1\$}
@mode_table = global [4 x i32] zeroinitializer ; <[4 x i32]*> [#uses=1]
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {Loop bb7.i: Unpredictable backedge-taken count\\.}
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 -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {Loop for\\.body: backedge-taken count is (-1 + \[%\]ecx)}
; PR4599
-; RUN: opt %s -scalar-evolution -disable-output -analyze \
+; RUN: opt < %s -scalar-evolution -disable-output -analyze \
; RUN: | grep {\\--> (zext i4 (-8 + (trunc i64 (8 \\* %x) to i4)) to i64)}
; ScalarEvolution shouldn't try to analyze %z into something like
-; RUN: opt %s -analyze -scalar-evolution -disable-output \
+; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | FileCheck %s
; PR4569
; Check by running globaldce, which will remove the constant if there are
; no references to it!
;
-; RUN: opt %s -globaldce -S | \
+; 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 -S | 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 -verify -S | 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 -S | 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 -constprop | llvm-dis
+; RUN: opt < %s -constprop | llvm-dis
; PR3465
define double @test() {
-; RUN: opt %s -anders-aa -argpromotion
+; RUN: opt < %s -anders-aa -argpromotion
declare void @llvm.gcroot(i8**, i8*)
-; RUN: opt %s -deadargelim
+; RUN: opt < %s -deadargelim
declare void @llvm.gcroot(i8**, i8*)
-; RUN: opt %s -inline -S | grep example
+; RUN: opt < %s -inline -S | grep example
%IntArray = type { i32, [0 x i32*] }
-; RUN: opt %s -inline -S | grep sample
-; RUN: opt %s -inline -S | 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 -std-compile-opts | llc > %t
+; RUN: opt < %s -std-compile-opts | llc > %t
; ModuleID = 'ld3.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-f128:64:128"
target triple = "powerpc-apple-darwin8"
-; RUN: opt %s -instcombine | \
+; RUN: opt < %s -instcombine | \
; RUN: llc -march=ppc32 -mcpu=g5 | not grep vperm
; RUN: llc < %s -march=ppc32 -mcpu=g5 > %t
; RUN: grep vsldoi %t | count 2
-; RUN: opt %s -instcombine -S | grep 302245289961712575840256
-; RUN: opt %s -instcombine -S | 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: opt %s -std-compile-opts | llc
+; RUN: opt < %s -std-compile-opts | llc
; ModuleID = 'block12.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 = "i686-apple-darwin8"
-; RUN: opt %s -std-compile-opts | llc > %t
+; RUN: opt < %s -std-compile-opts | llc > %t
; RUN: grep 2147027116 %t | count 3
; RUN: grep 2147228864 %t | count 3
; RUN: grep 2146502828 %t | count 3
-; RUN: opt %s -scalarrepl -instcombine | \
+; RUN: opt < %s -scalarrepl -instcombine | \
; RUN: llc -march=x86 -mcpu=yonah | not grep sub.*esp
; This checks that various insert/extract idiom work without going to the
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -print-dbginfo -disable-output | FileCheck %s
+; RUN: opt < %s -print-dbginfo -disable-output | FileCheck %s
; grep {%b is variable b of type x declared at x.c:7} %t1
; grep {%2 is variable b of type x declared at x.c:7} %t1
; grep {@c.1442 is variable c of type int declared at x.c:4} %t1
; PR1318
-; RUN: opt %s -load=%llvmlibsdir/LLVMHello%shlibext -hello \
+; RUN: opt < %s -load=%llvmlibsdir/LLVMHello%shlibext -hello \
; RUN: -disable-output |& grep Hello
@junk = global i32 0
; Call graph construction crash: Not handling indirect calls right
;
-; RUN: opt %s -analyze -print-callgraph >& /dev/null
+; RUN: opt < %s -analyze -print-callgraph >& /dev/null
;
%FunTy = type i32 (i32)
; Inlining used to break PHI nodes. This tests that they are correctly updated
; when a node is split around the call instruction. The verifier caught the error.
;
-; RUN: opt %s -inline
+; RUN: opt < %s -inline
;
define i64 @test(i64 %X) {
;
; Fixed by adding new arguments to ConstantFoldTerminator
;
-; RUN: opt %s -constprop
+; RUN: opt < %s -constprop
define void @build_tree(i32 %ml) {
; <label>:0
; figure out that loop "Inner" should be nested inside of leep "LoopHeader",
; and instead nests it just inside loop "Top"
;
-; RUN: opt %s -analyze -loops | \
+; RUN: opt < %s -analyze -loops | \
; RUN: grep { Loop at depth 3 containing: %Inner<header><latch><exit>}
;
define void @test() {
-;RUN: opt %s -codegenprepare -disable-output
+;RUN: opt < %s -codegenprepare -disable-output
define void @foo() {
entry:
-;RUN: opt %s -analyze -dot-cfg-only -disable-output 2>/dev/null
+;RUN: opt < %s -analyze -dot-cfg-only -disable-output 2>/dev/null
;PR 1497
define void @foo() {
-; RUN: opt %s -loop-unswitch -indvars -disable-output
+; RUN: opt < %s -loop-unswitch -indvars -disable-output
; Require SCEV before LCSSA.
define void @foo() {
entry:
; PR 2034
-; RUN: opt %s -anders-aa -instcombine -gvn -disable-output
+; RUN: opt < %s -anders-aa -instcombine -gvn -disable-output
%struct.FULL = type { i32, i32, [1000 x float*] }
define i32 @sgesl(%struct.FULL* %a, i32* %ipvt, float* %b, i32 %job) {
-; RUN: opt %s -instcombine -S | 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 -inline -internalize -disable-output
+; RUN: opt < %s -inline -internalize -disable-output
define void @foo() nounwind {
ret void
}
-; RUN: opt %s -inline -prune-eh -disable-output
+; RUN: opt < %s -inline -prune-eh -disable-output
define void @f2() {
invoke void @f6()
to label %ok1 unwind label %lpad1
-; RUN: opt %s -verify -S | 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 -S | grep BB1
+; RUN: opt < %s -adce -S | grep BB1
define i32 @test(i1 %C, i32 %A, i32 %B) {
; <label>:0
; removed even though there were uses still around. Now the uses are filled
; in with a dummy value before the PHI is deleted.
;
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
%node_t = type { double*, %node_t*, %node_t**, double**, double*, i32, i32 }
; This testcase is a distilled form of: 2002-05-28-Crash.ll
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
define float @test(i32 %i) {
%F = sitofp i32 %i to float ; <float> [#uses=1]
; return !s;
;}
;
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
define i32 @rx_bitset_empty(i32 %size, i32* %set) {
bb1:
; block in this function, it would work fine, but that would be the part we
; have to fix now, wouldn't it....
;
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
define void @foo(i8* %reg5481) {
%cast611 = bitcast i8* %reg5481 to i8** ; <i8**> [#uses=1]
; This testcase was extracted from the gzip SPEC benchmark
;
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
@bk = external global i32 ; <i32*> [#uses=2]
@hufts = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
define void @test() {
br label %BB3
; Testcase reduced from 197.parser by bugpoint
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
define void @conjunction_prune() {
; <label>:0
; entries for it's postdominator. But I think this can only happen when the
; PHI node is dead, so we just avoid patching up dead PHI nodes.
-; RUN: opt %s -adce
+; RUN: opt < %s -adce
target datalayout = "e-p:32:32"
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
@G = external global i32* ; <i32**> [#uses=1]
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
target datalayout = "e-p:32:32"
%struct..CppObjTypeDesc = type { i32, i16, i16 }
%struct..TypeToken = type { i32, i16, i16 }
-; RUN: opt %s -adce -simplifycfg -S | 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 -disable-output
+; RUN: opt < %s -adce -disable-output
define void @test() {
br i1 false, label %then, label %endif
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
define i32 @main() {
br label %loop
-; RUN: opt %s -adce -simplifycfg -S | grep call
+; RUN: opt < %s -adce -simplifycfg -S | grep call
declare void @exit(i32)
define i32 @main(i32 %argc) {
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
define void @test() {
entry:
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
declare void @strlen()
-; RUN: opt %s -adce -simplifycfg | llvm-dis
+; RUN: opt < %s -adce -simplifycfg | llvm-dis
define i32 @Test(i32 %A, i32 %B) {
BB1:
-; RUN: opt %s -adce -simplifycfg | llvm-dis
+; RUN: opt < %s -adce -simplifycfg | llvm-dis
%FILE = type { i32, i8*, i8*, i8, i8, i32, i32, i32 }
%spec_fd_t = type { i32, i32, i32, i8* }
@__iob = external global [20 x %FILE] ; <[20 x %FILE]*> [#uses=1]
-; RUN: opt %s -adce -simplifycfg | llvm-dis
+; RUN: opt < %s -adce -simplifycfg | llvm-dis
%FILE = type { i32, i8*, i8*, i8, i8, i32, i32, i32 }
%spec_fd_t = type { i32, i32, i32, i8* }
@__iob = external global [20 x %FILE] ; <[20 x %FILE]*> [#uses=1]
-; RUN: opt %s -adce -S | grep null
+; RUN: opt < %s -adce -S | grep null
declare i32 @strlen(i8*) readnone
-; RUN: opt %s -adce -disable-output
+; RUN: opt < %s -adce -disable-output
define void @test() {
unreachable
-; RUN: opt %s -argpromotion -S | 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 -S > %t
+; RUN: opt < %s -argpromotion -S > %t
; RUN: cat %t | grep {define.*@callee(.*i32\\*}
; PR2498
-; RUN: opt %s -inline -argpromotion -disable-output
+; RUN: opt < %s -inline -argpromotion -disable-output
define internal fastcc i32 @hash(i32* %ts, i32 %mod) nounwind {
entry:
-; RUN: opt %s -argpromotion -disable-output
+; RUN: opt < %s -argpromotion -disable-output
define internal fastcc i32 @term_SharingList(i32* %Term, i32* %List) nounwind {
entry:
-; RUN: opt %s -argpromotion -instcombine -S | 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 -S | grep zeroext
+; RUN: opt < %s -argpromotion -S | grep zeroext
%struct.ss = type { i32, i64 }
-; RUN: opt %s -argpromotion -mem2reg -S | 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 -S | 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 -S | 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 -simplifycfg -constmerge | llvm-dis
+; RUN: opt < %s -argpromotion -simplifycfg -constmerge | llvm-dis
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 -argpromotion -instcombine -S | 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 -S | \
+; RUN: opt < %s -argpromotion -S | \
; RUN: not grep {load i32\* null}
define internal i32 @callee(i1 %C, i32* %P) {
-; RUN: opt %s -argpromotion -S | \
+; RUN: opt < %s -argpromotion -S | \
; RUN: grep {load i32\\* %A}
define internal i32 @callee(i1 %C, i32* %P) {
-; RUN: opt %s -disable-output -loop-extract-single -loop-rotate -loop-reduce -argpromotion
+; RUN: opt < %s -disable-output -loop-extract-single -loop-rotate -loop-reduce -argpromotion
; PR 3085
%struct.Lit = type { i8 }
-; RUN: opt %s -block-placement -disable-output -print-function 2> /dev/null
+; RUN: opt < %s -block-placement -disable-output -print-function 2> /dev/null
define i32 @test() {
br i1 true, label %X, label %Y
-; RUN: opt %s -std-compile-opts -o - | llc -o - | grep bork_directive | wc -l | grep 2
+; RUN: opt < %s -std-compile-opts -o - | llc -o - | grep bork_directive | wc -l | grep 2
;; We don't want branch folding to fold asm directives.
-; RUN: opt %s -loop-extract -disable-output
+; RUN: opt < %s -loop-extract -disable-output
define void @solve() {
entry:
-; RUN: opt %s -loop-extract -disable-output
+; RUN: opt < %s -loop-extract -disable-output
; This testcase is failing the loop extractor because not all exit blocks
; are dominated by all of the live-outs.
-; RUN: opt %s -loop-extract-single -disable-output
+; RUN: opt < %s -loop-extract-single -disable-output
define void @ab() {
entry:
-; RUN: opt %s -loop-extract -disable-output
+; RUN: opt < %s -loop-extract -disable-output
define void @sendMTFValues() {
entry:
-; RUN: opt %s -loop-extract -disable-output
+; RUN: opt < %s -loop-extract -disable-output
%struct.node_t = type { double*, %struct.node_t*, %struct.node_t**, double**, double*, i32, i32 }
%struct.table_t = type { [1 x %struct.node_t**], [1 x %struct.node_t**] }
-; RUN: opt %s -loop-extract -disable-output
+; RUN: opt < %s -loop-extract -disable-output
define void @maketree() {
entry:
-; RUN: opt %s -loop-extract -disable-output
+; RUN: opt < %s -loop-extract -disable-output
declare i32 @_IO_getc()
-; RUN: opt %s -extract-blocks -disable-output
+; RUN: opt < %s -extract-blocks -disable-output
define void @test1() {
no_exit.0.i:
-; RUN: opt %s -extract-blocks -disable-output
+; RUN: opt < %s -extract-blocks -disable-output
define i32 @foo() {
br label %EB
-; RUN: opt %s -codegenprepare | llvm-dis
+; RUN: opt < %s -codegenprepare | llvm-dis
; PR3113
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 -condprop -disable-output
+; RUN: opt < %s -condprop -disable-output
; PR877
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin9.0.0d1"
-; RUN: opt %s -condprop -disable-output
+; RUN: opt < %s -condprop -disable-output
; PR979
target datalayout = "e-p:32:32"
-; RUN: opt %s -inline -tailduplicate -condprop -simplifycfg -disable-output
+; RUN: opt < %s -inline -tailduplicate -condprop -simplifycfg -disable-output
; PR1575
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 -condprop | llvm-dis
+; RUN: opt < %s -condprop | llvm-dis
; PR3405
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 -condprop -S | \
+; RUN: opt < %s -condprop -S | \
; RUN: not grep {br label}
%llvm.dbg.anchor.type = type { i32, i32 }
-; RUN: opt %s -condprop -S | \
+; RUN: opt < %s -condprop -S | \
; RUN: not grep {br label}
-; RUN: opt %s -condprop -S | not grep T2
+; RUN: opt < %s -condprop -S | not grep T2
define i32 @test(i1 %C) {
; Make sure that the constant propogator doesn't divide by zero!
;
-; RUN: opt %s -constprop
+; RUN: opt < %s -constprop
;
define i32 @test() {
; Fix #2: The unary not instruction now no longer exists. Change to xor.
-; RUN: opt %s -constprop -S | \
+; 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 -S | \
+; RUN: opt < %s -constprop -die -S | \
; RUN: not grep set
define i1 @test1() {
; Make sure that the constant propagator doesn't cause a sigfpe
;
-; RUN: opt %s -constprop
+; RUN: opt < %s -constprop
;
define i32 @test() {
-; RUN: opt %s -constprop -S | \
+; RUN: opt < %s -constprop -S | \
; RUN: not grep {ret i1 false}
@b = external global [2 x { }] ; <[2 x { }]*> [#uses=2]
-; RUN: opt %s -constprop -S | \
+; RUN: opt < %s -constprop -S | \
; RUN: grep {i32 -1}
-; RUN: opt %s -constprop -S | \
+; RUN: opt < %s -constprop -S | \
; RUN: not grep zeroinitializer
define <4 x i32> @test() {
-; RUN: opt %s -instcombine -S | \
+; 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 -S | \
+; RUN: opt < %s -constprop -S | \
; RUN: grep {ret i32 -1}
-; RUN: opt %s -constprop -S | \
+; RUN: opt < %s -constprop -S | \
; RUN: grep {ret i32 1}
define i32 @test1() {
-; RUN: opt %s -constprop -S | 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 -S | grep {ret i13 13}
+; RUN: opt < %s -constprop -S | grep {ret i13 13}
; PR1816
declare i13 @llvm.cttz.i13(i13)
-; RUN: opt %s -constprop -disable-output
+; RUN: opt < %s -constprop -disable-output
; PR2529
define <4 x i1> @test1(i32 %argc, i8** %argv) {
entry:
-; RUN: opt %s -constprop | llvm-dis
+; RUN: opt < %s -constprop | llvm-dis
; PR4848
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"
; This is a basic sanity check for constant propogation. The add instruction
; should be eliminated.
-; RUN: opt %s -constprop -die -S | not grep add
+; RUN: opt < %s -constprop -die -S | not grep add
define i32 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
; bswap should be constant folded when it is passed a constant argument
-; RUN: opt %s -constprop -S | not grep call
+; RUN: opt < %s -constprop -S | not grep call
declare i16 @llvm.bswap.i16(i16)
-; RUN: opt %s -instcombine -S | grep {ret i32 0}
+; RUN: opt < %s -instcombine -S | grep {ret i32 0}
; PR4424
declare void @ext()
-; RUN: opt %s -constprop -S | \
+; RUN: opt < %s -constprop -S | \
; RUN: grep -F {ret i32* null} | count 2
define i32* @test1() {
; Ensure constant propogation of 'not' instructions is working correctly.
-; RUN: opt %s -constprop -die -S | not grep xor
+; RUN: opt < %s -constprop -die -S | not grep xor
define i32 @test1() {
%R = xor i32 4, -1 ; <i32> [#uses=1]
-; RUN: opt %s -constmerge > /dev/null
+; RUN: opt < %s -constmerge > /dev/null
@foo.upgrd.1 = internal constant { i32 } { i32 7 } ; <{ i32 }*> [#uses=1]
@bar = internal constant { i32 } { i32 7 } ; <{ i32 }*> [#uses=1]
-; RUN: opt %s -constmerge -S | grep foo
-; RUN: opt %s -constmerge -S | 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 -disable-output
+; RUN: opt < %s -deadargelim -disable-output
define internal void @build_delaunay({ i32 }* sret %agg.result) {
ret void
-; RUN: opt %s -deadargelim -S | grep {@test(}
-; RUN: opt %s -deadargelim -S | 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 -S | 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 -S > %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 -S | 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 -S > %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
+; RUN: opt < %s -deadargelim | llvm-dis
; PR3807
define internal { i32, i32 } @foo() {
-; RUN: opt %s -deadargelim -S | 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 -S > %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 -S | not grep 47
-; RUN: opt %s -deadargelim -S | 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 -S | 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 -S > %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 -S > %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 -S | 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 -scalarrepl -instcombine | \
+; RUN: opt < %s -dse -scalarrepl -instcombine | \
; RUN: llvm-dis | not grep {ret i32 undef}
define i32 @test(double %__x) {
-; RUN: opt %s -dse -S | \
+; RUN: opt < %s -dse -S | \
; RUN: grep {store i32 1234567}
; Do not delete stores that are only partially killed.
-; RUN: opt %s -dse -S | grep store
+; RUN: opt < %s -dse -S | grep store
define double @foo(i8* %X) {
%X_addr = alloca i8* ; <i8**> [#uses=2]
-; RUN: opt %s -globalsmodref-aa -dse -disable-output
+; RUN: opt < %s -globalsmodref-aa -dse -disable-output
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin8"
%struct.ECacheType = type { i32, i32, i32 }
-; RUN: opt %s -dse -S | 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 | llvm-dis
; PR3141
%struct.ada__tags__dispatch_table = type { [1 x i32] }
%struct.f393a00_1__object = type { %struct.ada__tags__dispatch_table*, i8 }
-; RUN: opt %s -dse | llvm-dis
+; RUN: opt < %s -dse | llvm-dis
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 -dse -S | \
+; 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 -S | 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 -S | not grep store
+; RUN: opt < %s -dse -S | not grep store
%struct.x = type { i32, i32, i32, i32 }
-; RUN: opt %s -dse -S | not grep DEAD
+; RUN: opt < %s -dse -S | not grep DEAD
declare void @ext()
-; RUN: opt %s -dse | llvm-dis
+; RUN: opt < %s -dse | llvm-dis
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 -dse -S | 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 -S | 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 -S | 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 -S | grep {volatile load}
+; RUN: opt < %s -dse -S | grep {volatile load}
@g_1 = global i32 0
-; RUN: opt %s -functionattrs -S | grep readnone
+; RUN: opt < %s -functionattrs -S | grep readnone
define i32 @a() {
%tmp = call i32 @b( ) ; <i32> [#uses=1]
-; RUN: opt %s -functionattrs -S | 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 -S | grep readonly | count 2
+; RUN: opt < %s -functionattrs -S | grep readonly | count 2
define i32 @f() {
entry:
-; RUN: opt %s -functionattrs -S | not grep read
+; RUN: opt < %s -functionattrs -S | not grep read
; PR2792
@g = global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -functionattrs -S | grep readnone | count 2
+; RUN: opt < %s -functionattrs -S | grep readnone | count 2
declare i32 @g(i32*) readnone
-; RUN: opt %s -functionattrs -S | grep readnone
+; RUN: opt < %s -functionattrs -S | grep readnone
@s = external constant i8 ; <i8*> [#uses=1]
-; RUN: opt %s -functionattrs -S | not grep {nocapture *%%q}
-; RUN: opt %s -functionattrs -S | 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 -S | not grep {nocapture *%%q}
-; RUN: opt %s -functionattrs -S | 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 -S | not grep read
+; RUN: opt < %s -functionattrs -S | not grep read
; PR3754
define i8* @m(i32 %size) {
-; RUN: opt %s -gvn | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
%struct.PerlInterpreter = type { i8 }
@PL_sv_count = external global i32 ; <i32*> [#uses=2]
-; RUN: opt %s -gvn -S | 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
+; RUN: opt < %s -gvn | llvm-dis
%struct.s_segment_inf = type { float, i32, i16, i16, float, float, i32, float, float }
-; RUN: opt %s -gvn | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
%struct.TypHeader = type { i32, %struct.TypHeader**, [3 x i8], i8 }
-; RUN: opt %s -gvn | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
%struct.ggBRDF = type { i32 (...)** }
%struct.ggBox3 = type { %struct.ggPoint3, %struct.ggPoint3 }
-; RUN: opt %s -gvn -S | grep {tmp17625.* = phi i32. }
-; RUN: opt %s -gvn -S | 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
+; RUN: opt < %s -gvn | llvm-dis
@bsLive = external global i32 ; <i32*> [#uses=2]
-; RUN: opt %s -gvn -S | 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
+; RUN: opt < %s -gvn | llvm-dis
%"struct.Block::$_16" = type { i32 }
%struct.Exp = type { %struct.Exp_*, i32, i32, i32, %struct.Exp*, %struct.Exp*, %"struct.Exp::$_10", %"struct.Block::$_16", %"struct.Exp::$_12" }
-; RUN: opt %s -gvn -S | 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 -S | not grep {tmp701 =}
+; RUN: opt < %s -gvn -S | not grep {tmp701 =}
@img_width = external global i16 ; <i16*> [#uses=2]
-; RUN: opt %s -gvn -S | not grep load
+; RUN: opt < %s -gvn -S | not grep load
; PR1996
%struct.anon = type { i32, i8, i8, i8, i8 }
-; RUN: opt %s -anders-aa -gvn
+; RUN: opt < %s -anders-aa -gvn
; PR2032
define i32 @sscal(i32 %n, double %sa1, float* %sx, i32 %incx) {
-; RUN: opt %s -gvn -dse -S | 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 -S | 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 -S | 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 -S | 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 | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
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
+; RUN: opt < %s -gvn | llvm-dis
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"
@sort_value = external global [256 x i32], align 32 ; <[256 x i32]*> [#uses=2]
-; RUN: opt %s -gvn | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
; Cached results must be added to and verified against the visited sets.
; PR3217
-; RUN: opt %s -gvn | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
; PR3358
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 -gvn | llvm-dis
+; RUN: opt < %s -gvn | llvm-dis
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 -enable-load-pre -disable-output
+; RUN: opt < %s -gvn -enable-load-pre -disable-output
%struct.VEC_rtx_base = type { i32, i32, [1 x %struct.rtx_def*] }
%struct.VEC_rtx_gc = type { %struct.VEC_rtx_base }
-; RUN: opt %s -gvn -disable-output
+; RUN: opt < %s -gvn -disable-output
%llvm.dbg.compile_unit.type = type { i32, { }*, i32, i8*, i8*, i8*, i1, i1, i8*, i32 }
@llvm.dbg.compile_unit298 = external constant %llvm.dbg.compile_unit.type ; <%llvm.dbg.compile_unit.type*> [#uses=1]
-; RUN: opt %s -gvn -disable-output
+; RUN: opt < %s -gvn -disable-output
; PR3775
; ModuleID = 'bugpoint-reduced-simplified.bc'
-; RUN: opt %s -gvn -enable-load-pre -S | 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
+; RUN: opt < %s -gvn | llvm-dis
; PR4256
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-linux-gnu"
-; RUN: opt %s -gvn -S | not grep {%z2 =}
+; RUN: opt < %s -gvn -S | not grep {%z2 =}
define i32 @main() {
block1:
-; RUN: opt %s -gvn -S | not grep tmp2
+; RUN: opt < %s -gvn -S | not grep tmp2
; PR2213
define i32* @f(i8* %x) {
-; RUN: opt %s -gvn -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | not grep DEADLOAD
-; RUN: opt %s -gvn -S | 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 -S | 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 -S | 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 -S | grep load | count 2
+; RUN: opt < %s -gvn -S | grep load | count 2
define i32 @main(i32** %p) {
block1:
-; RUN: opt %s -gvn -S | 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 -S | 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 -S | grep {%DEAD = phi i32. }
+; RUN: opt < %s -gvn -S | grep {%DEAD = phi i32. }
define i32 @main(i32** %p) {
block1:
-; RUN: opt %s -gvn -S | grep {%cv = phi i32}
-; RUN: opt %s -gvn -S | 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 -S | 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
+; RUN: opt < %s -gvnpre | llvm-dis
define void @_Z4sortI3Lit16LessThan_defaultIS0_EEvPT_iT0_() {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define void @strength_test5(i32* %data) {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
@.str1 = external constant [4 x i8] ; <[4 x i8]*> [#uses=1]
@.str2 = external constant [5 x i8] ; <[5 x i8]*> [#uses=1]
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define fastcc void @compute_max_score_1() {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define void @vorbis_lsp_to_curve() {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define i32 @TreeCCStreamFlush(i8* %stream) {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define i64 @foo({ i32, i32 }** %__v) {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define i32* @_ZN6Solver9propagateEv(i32* %this) {
entry:
-; RUN: opt %s -gvnpre | llvm-dis
+; RUN: opt < %s -gvnpre | llvm-dis
define void @set_depth_values(i32 %level) {
cond_true90: ; preds = %cond_next84
-; RUN: opt %s -gvnpre -S | 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
+; RUN: opt < %s -gvnpre | llvm-dis
%"struct.ObjectArena<char>" = type { i32, i32, %"struct.ResizeArray<char*>", i8*, i8* }
%"struct.ResizeArray<char*>" = type { i32 (...)**, %"struct.ResizeArrayRaw<char*>"* }
%"struct.ResizeArrayRaw<char*>" = type { i8**, i8*, i32, i32, i32, float, i32 }
-; RUN: opt %s -gvnpre -S | not grep {%z3 =}
-; RUN: opt %s -gvnpre -S | 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 -S | grep b.gvnpre
+; RUN: opt < %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre -S | grep b.gvnpre
+; RUN: opt < %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre -S | 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 -S | grep b.gvnpre
+; RUN: opt < %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre -S | grep b.gvnpre
+; RUN: opt < %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -gvnpre -S | grep b.gvnpre
+; RUN: opt < %s -gvnpre -S | grep b.gvnpre
define i32 @extract() {
entry: ; preds = %cond_false, %entry
-; RUN: opt %s -globaldce
+; RUN: opt < %s -globaldce
;
define internal void @func() {
ret void
-; RUN: opt %s -globaldce
+; RUN: opt < %s -globaldce
;
@X = global void ()* @func ; <void ()**> [#uses=0]
; 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 -S | 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 -S | 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]
-; RUN: opt %s -globaldce
+; RUN: opt < %s -globaldce
;; Should die when function %foo is killed
@foo.upgrd.1 = internal global i32 7 ; <i32*> [#uses=3]
; distilled from 255.vortex
-; RUN: opt %s -globaldce -S | 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 -S | grep @A
+; RUN: opt < %s -globaldce -S | grep @A
@A = weak global i32 54
-; RUN: opt %s -globaldce -S | not grep @D
-; RUN: opt %s -globaldce -S | 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
+; RUN: opt < %s -globaldce
@A = alias internal void ()* @F
define internal void @F() { ret void }
-; RUN: opt %s -globaldce | llc -O0 -o /dev/null
+; RUN: opt < %s -globaldce | llc -O0 -o /dev/null
%struct..0__pthread_mutex_s = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_list_t }
%"struct.__gnu_cxx::_ConvertibleConcept<unsigned int,unsigned int>" = type { i32 }
-; RUN: opt %s -globaldce -S | not grep global
+; RUN: opt < %s -globaldce -S | not grep global
@X = external global i32
@Y = internal global i32 7
-; RUN: opt %s -globaldce -S | 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
+; RUN: opt < %s -globalopt
@V = global float 1.200000e+01 ; <float*> [#uses=1]
@G = internal global i32* null ; <i32**> [#uses=2]
-; RUN: opt %s -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
; PR579
@g_40507551 = internal global i16 31038 ; <i16*> [#uses=1]
-; RUN: opt %s -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
%RPyString = type { i32, %arraytype.Char }
%arraytype.Char = type { i32, [0 x i8] }
%arraytype.Signed = type { i32, [0 x i32] }
-; RUN: opt %s -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
; PR820
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
%struct._list = type { i32*, %struct._list* }
%struct._play = type { i32, i32*, %struct._list*, %struct._play* }
-; RUN: opt %s -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:32"
target triple = "thumb-apple-darwin8"
-; RUN: opt %s -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
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 -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
; PR1491
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 -globalopt -disable-output
+; RUN: opt < %s -globalopt -disable-output
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-f128:64:128"
target triple = "powerpc-apple-darwin8"
%struct.empty0 = type { }
-; RUN: opt %s -globalopt | llvm-dis
+; RUN: opt < %s -globalopt | llvm-dis
; PR1896
@indirect1 = internal global void (i32)* null ; <void (i32)**> [#uses=2]
-; RUN: opt %s -globalopt -S | 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 -S | 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 -S | 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 -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}
+; 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 -S > %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
+; RUN: opt < %s -globalopt | llvm-dis
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"
%struct.foo = type { i32, i32 }
-; RUN: opt %s -globalopt | llvm-dis
+; RUN: opt < %s -globalopt | llvm-dis
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"
%struct.foo = type { i32, i32 }
-; RUN: opt %s -globalopt -S | 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
+; RUN: opt < %s -globalopt
@g = external global i32
-; RUN: opt %s -globalopt -S | grep {define void @a}
+; RUN: opt < %s -globalopt -S | grep {define void @a}
define internal void @f() {
ret void
-; RUN: opt %s -globalopt -S | 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 -stats -disable-output |& grep "1 globalopt - Number of global vars shrunk to booleans"
+; RUN: opt < %s -globalopt -stats -disable-output |& grep "1 globalopt - Number of global vars shrunk to booleans"
; XFAIL: *
type { } ; type %0
-; RUN: opt %s -globalopt -S | grep internal | count 2
+; RUN: opt < %s -globalopt -S | grep internal | count 2
global i32 0
define i32* @1() {
-; RUN: opt %s -globalopt -S | 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
+; RUN: opt < %s -globalopt
%struct.s_annealing_sched = type { i32, float, float, float, float }
%struct.s_bb = type { i32, i32, i32, i32 }
-; RUN: opt %s -globalopt -S > %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 -S | not grep global
+; RUN: opt < %s -globalopt -S | not grep global
@X = internal global i32 4 ; <i32*> [#uses=1]
-; RUN: opt %s -instcombine -globalopt -S | \
+; RUN: opt < %s -instcombine -globalopt -S | \
; RUN: grep {internal fastcc float @foo}
define internal float @foo() {
-; RUN: opt %s -globalopt -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S > %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 -S | grep {@X.f0}
-; RUN: opt %s -globalopt -S | 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 -S | grep {@X.f0}
-; RUN: opt %s -globalopt -S | 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 -S | grep {tmp.f1 = phi i32. }
-; RUN: opt %s -globalopt -S | 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 -instcombine | \
+; RUN: opt < %s -globalopt -instcombine | \
; RUN: llvm-dis | grep {ret i1 true}
;; check that global opt turns integers that only hold 0 or 1 into bools.
-; RUN: opt %s -globalopt -S | 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 -S | not grep global
+; RUN: opt < %s -globalopt -S | not grep global
@G = internal global i32* null ; <i32**> [#uses=3]
-; RUN: opt %s -globalopt -S | \
+; 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 -S | \
+; 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 -S | 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 -S | \
+; 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 -S | not grep global
+; RUN: opt < %s -globalopt -S | not grep global
@G = internal global void ()* null ; <void ()**> [#uses=2]
-; RUN: opt %s -globalopt -S | 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 -S | 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 -disable-output
+; RUN: opt < %s -ipconstprop -disable-output
define internal void @foo(i32 %X) {
call void @foo( i32 %X )
ret void
-; RUN: opt %s -ipconstprop -deadargelim -S | 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 -S > %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 -instcombine | \
+; RUN: opt < %s -ipconstprop -instcombine | \
; RUN: llvm-dis | grep {ret i1 true} | count 2
define internal i32 @foo(i1 %C) {
br i1 %C, label %T, label %F
-; RUN: opt %s -ipconstprop -S > %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 -S | grep bounce | grep noalias
+; RUN: opt < %s -indmemrem -S | grep bounce | grep noalias
declare i8* @malloc(i32)
; Induction variable pass is doing bad things with pointer induction vars,
; trying to do arithmetic on them directly.
;
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
;
define void @test(i32 %A, i32 %S, i8* %S.upgrd.1) {
; <label>:0
; This is a test case for the expression analysis code, not really indvars.
; It was assuming any constant of int type was a ConstantInteger.
;
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
@X = global i32 7 ; <i32*> [#uses=1]
-; RUN: opt %s -indvars -S | 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 -S | \
+; RUN: opt < %s -indvars -S | \
; RUN: not grep {#uses=0}
define i32 @mul(i32 %x, i32 %y) {
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @test() {
entry:
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @_ZN17CoinFactorization7cleanupEv() {
entry:
br i1 false, label %loopexit.14, label %cond_continue.3
-; RUN: opt %s -indvars -S | 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 -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @test() {
br label %endif.0.i
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; ModuleID = '2004-04-05-InvokeCastCrash.ll'
%struct.__false_type = type { i8 }
%"struct.__gnu_cxx::_Hashtable_node<const llvm::Constant*>" = type { %"struct.__gnu_cxx::_Hashtable_node<const llvm::Constant*>"*, %"struct.llvm::Constant"* }
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @.outPlank_21() {
entry:
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @_ZN5ArrayISt7complexIdEEC2ERK10dim_vector() {
entry:
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
declare void @q_atomic_increment()
-; RUN: opt %s -indvars -S | \
+; RUN: opt < %s -indvars -S | \
; RUN: grep {ret i32 152}
define i32 @main() {
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @main() {
entry:
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
@fixtab = external global [29 x [29 x [2 x i32]]] ; <[29 x [29 x [2 x i32]]]*> [#uses=1]
; PR726
-; RUN: opt %s -indvars -S | \
+; RUN: opt < %s -indvars -S | \
; RUN: grep {ret i32 27}
; Make sure to compute the right exit value based on negative strides.
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
define void @get_block() {
endif.0:
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; ModuleID = '2006-09-20-LFTR-Crash.ll'
%struct.p7prior_s = type { i32, i32, [200 x float], [200 x [7 x float]], i32, [200 x float], [200 x [20 x float]], i32, [200 x float], [200 x [20 x float]] }
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin8"
%struct.vorbis_dsp_state = type { i32, %struct.vorbis_info*, float**, float**, i32, i32, i32, i32, i32, i32, i32, i32, i32, i64, i64, i64, i64, i64, i64, i8* }
; PR1015
-; RUN: opt %s -indvars -S | 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 -disable-output
+; RUN: opt < %s -indvars -disable-output
; PR1487
%struct.AVClass = type { i8*, i8* (i8*)*, %struct.AVOption* }
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; PR1814
target datalayout = "e-p:32:32-f64:32:64-i64:32:64-f80:32:32"
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; PR2434
define fastcc void @regcppop() nounwind {
-; RUN: opt %s -indvars -S | 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
+; RUN: opt < %s -indvars
; PR2857
@foo = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -indvars -S | 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 -S | grep icmp | count 2
-; RUN: opt %s -indvars -S | grep sitofp | count 1
-; RUN: opt %s -indvars -S | 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
+; RUN: opt < %s -indvars
define void @t() nounwind {
entry:
-; RUN: opt %s -indvars -S | 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 -S | 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
+; RUN: opt < %s -indvars
; rdar://6817574
define i32 @t1() nounwind ssp {
-; RUN: opt %s -indvars -S | grep icmp | grep next
+; RUN: opt < %s -indvars -S | grep icmp | grep next
; PR4086
declare void @foo()
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
; PR4258
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-linux-gnu"
-; RUN: opt %s -indvars -S > %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 -S > %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 -S > %t
+; RUN: opt < %s -indvars -S > %t
; RUN: grep sext %t | count 1
; Indvars should be able to eliminate all of the sign extensions
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
; PR4052
; PR4054
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; PR4009
; PR4038
; 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 -S | grep phi | count 1
+; RUN: opt < %s -indvars -S | grep phi | count 1
define void @foo() {
entry:
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
; PR4271
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"
; these loops all have predictable exit values we can replace the use outside
; of the loop with a closed-form computation, making the loop dead.
;
-; RUN: opt %s -indvars -loop-deletion -simplifycfg | \
+; RUN: opt < %s -indvars -loop-deletion -simplifycfg | \
; RUN: llvm-dis | not grep br
define i32 @polynomial_constant() {
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
; An invoke has a result value which is used in an "Interesting"
; expression inside the loop. IndVars should be able to rewrite
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; ModuleID = 'testcase.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"
-; RUN: opt %s -indvars -S > %t
+; RUN: opt < %s -indvars -S > %t
; RUN: grep {= sext} %t | count 4
; RUN: grep {phi i64} %t | count 2
-; RUN: opt %s -indvars -disable-output
+; RUN: opt < %s -indvars -disable-output
; Don't RAUW the loop's original comparison instruction if it has
; other uses which aren't dominated by the new comparison instruction.
-; RUN: opt %s -indvars -S | 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 -S | not grep mul
+; RUN: opt < %s -indvars -dce -S | not grep mul
@A = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -loop-index-split -instcombine -indvars -disable-output
+; RUN: opt < %s -loop-index-split -instcombine -indvars -disable-output
; PR4455
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 -indvars -S \
+; RUN: opt < %s -indvars -S \
; RUN: | grep {%b.1 = phi i32 \\\[ 2, %bb \\\], \\\[ 1, %bb2 \\\]}
; This loop has multiple exits, and the value of %b1 depends on which
-; RUN: opt %s -domfrontier -indvars -loop-deletion
+; RUN: opt < %s -domfrontier -indvars -loop-deletion
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 -indvars
+; RUN: opt < %s -indvars
; PR4436
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 -indvars -S | 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 -S > %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 -S | not grep br
+; RUN: opt < %s -indvars -loop-deletion -simplifycfg -S | not grep br
;
; Testcase distilled from 256.bzip2
-; RUN: opt %s -indvars -loop-deletion -simplifycfg | opt \
+; RUN: opt < %s -indvars -loop-deletion -simplifycfg | opt \
; RUN: -analyze -loops | not grep "^Loop Containing"
; PR1179
-; RUN: opt %s -indvars -S | grep {ret i32 600000}
+; RUN: opt < %s -indvars -S | grep {ret i32 600000}
; PR1179
define i32 @foo() {
-; RUN: opt %s -indvars -S | grep {ret i32 9900}
+; RUN: opt < %s -indvars -S | grep {ret i32 9900}
; PR1179
define i32 @test4() {
-; RUN: opt %s -indvars -S | 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 -S | 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 -S > %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
+; RUN: opt < %s -indvars
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"
@ue = external global i64
-; RUN: opt %s -indvars -S | 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 -S > %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 -S > %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 -S \
+; RUN: opt < %s -indvars -S \
; RUN: | grep {\[%\]p.2.ip.1 = getelementptr \\\[3 x \\\[3 x double\\\]\\\]\\* \[%\]p, i64 2, i64 \[%\]tmp, i64 1}
; Indvars shouldn't expand this to
-; RUN: opt %s -indvars -S > %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 -S > %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 -S > %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 -scalar-evolution -analyze -disable-output \
+; RUN: opt < %s -scalar-evolution -analyze -disable-output \
; RUN: | grep {\\--> (zext i4 {-7,+,-8}<loop> to i32)}
define fastcc void @foo() nounwind {
-; RUN: opt %s -indvars -S > %t
+; RUN: opt < %s -indvars -S > %t
; RUN: not grep sext %t
; RUN: grep phi %t | count 1
-; RUN: opt %s -indvars
+; RUN: opt < %s -indvars
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:64"
target triple = "armv6-apple-darwin10"
-; RUN: opt %s -indvars -S | 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 -S | FileCheck %s --check-prefix=CHECK
+; RUN: opt < %s -indvars -S | FileCheck %s --check-prefix=CHECK
declare i1 @b()
-; RUN: opt %s -indvars -S | 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 -S | 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 -S | 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 -S | \
+; 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 -indvars
+; RUN: opt < %s -indvars
; PR4315
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"
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
declare i32 @External()
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
define i32 @main() {
entry:
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
define i32 @main() {
entry:
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
define i32 @main() {
entry:
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
define i32 @reload() {
reloadentry:
; node in the exception destination, and the inlined function contains an
; unwind instruction.
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
define linkonce void @foo() {
unwind
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
; Inlining the first call caused the inliner function to delete the second
; call. Then the inliner tries to inline the second call, which no longer
-; RUN: opt %s -inline -prune-eh -disable-output
+; RUN: opt < %s -inline -prune-eh -disable-output
define linkonce void @caller() {
call void @callee( )
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
define i32 @test() {
unwind
-; RUN: opt %s -inline -prune-eh -disable-output
+; RUN: opt < %s -inline -prune-eh -disable-output
%"struct.std::__codecvt_abstract_base<char,char,__mbstate_t>" = type { %"struct.std::locale::facet" }
%"struct.std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >" = type { i32 (...)**, i32*, i32*, i32*, i32*, i32*, i32*, %"struct.std::locale" }
-; RUN: opt %s -inline -prune-eh -disable-output
+; RUN: opt < %s -inline -prune-eh -disable-output
; PR827
@_ZTV8CRjii = internal global [1 x i32 (...)*] [ i32 (...)* @_ZN8CRjii12NlFeeEPN5Jr7sE ] ; <[1 x i32 (...)*]*> [#uses=0]
-; RUN: opt %s -inline -prune-eh -disable-output
+; RUN: opt < %s -inline -prune-eh -disable-output
; PR993
target datalayout = "e-p:32:32"
target triple = "i386-unknown-openbsd3.9"
-; RUN: opt %s -inline -prune-eh -disable-output
+; RUN: opt < %s -inline -prune-eh -disable-output
; PR992
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -inline -S | 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 -S | 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 -S | grep call
+; RUN: opt < %s -inline -S | grep call
; 'bar' can be overridden at link-time, don't inline it.
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
%struct.Benchmark = type { i32 (...)** }
%struct.Complex = type { double, double }
%struct.ComplexBenchmark = type { %struct.Benchmark }
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
%struct.Demand = type { double, double }
%struct.branch = type { %struct.Demand, double, double, double, double, %struct.branch*, [12 x %struct.leaf*] }
%struct.leaf = type { %struct.Demand, double, double }
-; RUN: opt %s -inline -disable-output
+; RUN: opt < %s -inline -disable-output
%struct.Demand = type { double, double }
%struct.branch = type { %struct.Demand, double, double, double, double, %struct.branch*, [12 x %struct.leaf*] }
%struct.leaf = type { %struct.Demand, double, double }
-; RUN: opt %s -inline-threshold=0 -inline -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -argpromotion -disable-output
+; RUN: opt < %s -inline -argpromotion -disable-output
; 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 -inline -disable-output
+; RUN: opt < %s -inline -disable-output
; PR4123
%struct.S0 = type <{ i32 }>
%struct.S1 = type <{ i8, i8, i8, i8, %struct.S0 }>
-; RUN: opt %s -inline | llvm-dis
+; RUN: opt < %s -inline | llvm-dis
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 -S | 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 -S | 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 -disable-output -print-function 2> /dev/null
+; RUN: opt < %s -inline -disable-output -print-function 2> /dev/null
define i32 @func(i32 %i) {
ret i32 %i
-; RUN: opt %s -inline -S | 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 -S | 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 -loop-rotate | llvm-dis
+; RUN: opt < %s -inline -loop-rotate | llvm-dis
; PR3601
declare void @solve()
-; RUN: opt %s -inline -S | 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 -S | not grep br
+; RUN: opt < %s -inline -S | not grep br
define i32 @func(i32 %i) {
ret i32 %i
-; RUN: opt %s -inline -argpromotion -instcombine -disable-output
+; RUN: opt < %s -inline -argpromotion -instcombine -disable-output
; This test was failing because the inliner would inline @list_DeleteElement
; into @list_DeleteDuplicates and then into @inf_GetBackwardPartnerLits,
; Functions with dynamic allocas can only be inlined into functions that
; already have dynamic allocas.
-; RUN: opt %s -inline -S | \
+; RUN: opt < %s -inline -S | \
; RUN: grep llvm.stacksave
-; RUN: opt %s -inline -S | not grep callee
+; RUN: opt < %s -inline -S | not grep callee
declare void @ext(i32*)
-; RUN: opt %s -inline -constprop -S > %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
+; RUN: opt < %s -inline | llvm-dis
; PR4834
define i32 @main() {
-; RUN: opt %s -inline -S | 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) {
; 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 -S | \
+; RUN: opt < %s -inline -S | \
; RUN: not grep {alloca.*uses=0}
-; RUN: opt %s -inline -S | \
+; 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 -S | not grep callee
-; RUN: opt %s -inline -S | 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 -S | \
+; RUN: opt < %s -inline -S | \
; RUN: not grep @reallysmall
define internal i32 @reallysmall(i32 %A) {
-; RUN: opt %s -inline -S | \
+; RUN: opt < %s -inline -S | \
; RUN: not grep {callee\[12\](}
-; RUN: opt %s -inline -S | 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 -S | \
+; 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 -S | \
+; 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 -S | not grep unwind$
+; RUN: opt < %s -inline -S | not grep unwind$
declare void @might_throw()
; This testcase causes instcombine to hang.
;
-; RUN: opt %s -instcombine
+; RUN: opt < %s -instcombine
define void @test(i32 %X) {
%reg117 = add i32 %X, 0 ; <i32> [#uses=0]
; 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 -S | 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 -S | 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 -S | 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 -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
@X = global i32 5 ; <i32*> [#uses=1]
; because it things that the constant value is a not expression... and
; constantly inverts the branch back and forth.
;
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i8 @test19(i1 %c) {
br i1 true, label %True, label %False
; should pass through the optimizer without failure.
;
; Extra code:
-; RUN: opt %s -instcombine
+; RUN: opt < %s -instcombine
; END.
target datalayout = "e-p:32:32"
; This testcase can be simplified by "realizing" that alloca can never return
; null.
-; RUN: opt %s -instcombine -simplifycfg | \
+; RUN: opt < %s -instcombine -simplifycfg | \
; RUN: llvm-dis | not grep br
declare i32 @bitmap_clear(...)
-; RUN: opt %s -instcombine -S | grep load
+; RUN: opt < %s -instcombine -S | grep load
define void @test(i32* %P) {
; Dead but not deletable!
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
declare i32* @bar()
; The cast in this testcase is not eliminable on a 32-bit target!
-; RUN: opt %s -instcombine -S | grep inttoptr
+; RUN: opt < %s -instcombine -S | grep inttoptr
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine -S | grep call | notcast
+; RUN: opt < %s -instcombine -S | grep call | notcast
declare void @free(i8*)
; invoke instruction, we really cannot perform this transformation at all at
; least without splitting the critical edge.
;
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
declare i8* @test()
-; RUN: opt %s -instcombine -S | 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!
; This testcase caused the combiner to go into an infinite loop, moving the
; cast back and forth, changing the seteq to operate on int vs uint and back.
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i1 @test(i32 %A, i32 %B) {
%C = sub i32 0, %A ; <i32> [#uses=1]
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i32 @test() {
ret i32 0
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
%Ty = type opaque
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
@p = weak global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -instcombine
+; RUN: opt < %s -instcombine
; This testcase should not send the instcombiner into an infinite loop!
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {ret i1 false}
define i1 @test(i1 %V) {
-; RUN: opt %s -instcombine -mem2reg -S | \
+; 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 -mem2reg -simplifycfg | \
+; RUN: opt < %s -instcombine -mem2reg -simplifycfg | \
; RUN: llvm-dis | grep -v store | not grep {i32 1}
; Test to make sure that instcombine does not accidentally propagate the load
-; RUN: opt %s -instcombine -S | 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
+; RUN: opt < %s -instcombine
define i32 @test(i32 %X) {
%Y = srem i32 %X, undef ; <i32> [#uses=1]
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {ret i1 false}
define i1 @test(i64 %tmp.169) {
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i32 @test(i1 %C, i32 %tmp.15) {
%tmp.16 = select i1 %C, i32 8, i32 1 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i32 @_Z13func_31585107li(i32 %l_39521025, i32 %l_59244666) {
%shortcirc_val = select i1 false, i32 1, i32 0 ; <i32> [#uses=1]
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR577
define i1 @test() {
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR585
define i1 @test() {
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {ret i1 true}
; PR586
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; This example caused instcombine to spin into an infinite loop.
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep undef
define i32 @test(i8 %A) {
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i32 @test() {
%tmp203 = icmp eq i32 1, 2 ; <i1> [#uses=1]
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define float @test(<4 x float> %V) {
%V2 = insertelement <4 x float> %V, float 1.000000e+00, i32 3 ; <<4 x float>> [#uses=1]
-; RUN: opt %s -instcombine -S | grep shl
-; RUN: opt %s -instcombine -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
; END.
define void @test() {
-; RUN: opt %s -instcombine -S | grep and
+; RUN: opt < %s -instcombine -S | grep and
; PR913
define i32 @test(i32* %tmp1) {
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep mul | count 2
define <4 x float> @test(<4 x float> %V) {
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep memmove.i32
; Instcombine was trying to turn this into a memmove.i32
-; RUN: opt %s -instcombine -S | 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 -S | grep and.*32
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | grep and.*32
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep or.*153
; PR1014
-; RUN: opt %s -instcombine -S | grep sub
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {%bothcond =}
define i1 @Doit_bb(i32 %i.0) {
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {icmp sgt}
; END.
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine -S | grep select
+; RUN: opt < %s -instcombine -S | grep select
; END.
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep icmp | count 1
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {icmp ugt} | count 1
; END.
; For PR1065. This causes an assertion in instcombine if a select with two cmp
; operands is encountered.
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; END.
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine -S | grep {icmp ugt}
+; RUN: opt < %s -instcombine -S | grep {icmp ugt}
; PR1107
; PR1940
-; RUN: opt %s -instcombine -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
define <4 x i32> @test(<4 x i32> %A) {
%B = xor <4 x i32> %A, < i32 -1, i32 -1, i32 -1, i32 -1 >
-; RUN: opt %s -instcombine -S | 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 -S | grep {%A = alloca}
-; RUN: opt %s -instcombine -mem2reg -S | \
+; 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 -S | 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 -S | grep ret
+; RUN: opt < %s -instcombine -S | grep ret
; PR1217
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine -S | grep {icmp sle}
+; RUN: opt < %s -instcombine -S | grep {icmp sle}
; PR1244
define i1 @test(i32 %c.3.i, i32 %d.292.2.i) {
; PR1271
-; RUN: opt %s -instcombine -S | \
+; 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 -S | 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 -S | \
+; 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 -S | 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 -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR1304
define i64 @bork(<1 x i64> %vec) {
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR1384
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 -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define i1 @test(i32 %tmp9) {
%tmp20 = icmp ugt i32 %tmp9, 255 ; <i1> [#uses=1]
%tmp11.not = icmp sgt i32 %tmp9, 255 ; <i1> [#uses=1]
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
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 = "powerpc-apple-darwin8.8.0"
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | grep {ret i1 true}
+; RUN: opt < %s -instcombine -S | grep {ret i1 true}
; rdar://5278853
define i1 @test(i32 %tmp468) {
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR1594
define i64 @test(i16 %tmp510, i16 %tmp512) {
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | grep icmp
+; RUN: opt < %s -instcombine -S | grep icmp
; PR1678
@A = alias weak void ()* @B ; <void ()*> [#uses=1]
-; RUN: opt %s -instcombine -S | not grep call
-; RUN: opt %s -std-compile-opts -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
%struct.Ray = type { %struct.Vec, %struct.Vec }
%struct.Scene = type { i32 (...)** }
-; RUN: opt %s -instcombine -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
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-f128:64:128"
target triple = "powerpc-apple-darwin8"
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR1780
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 -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR1817
define i1 @test1(i32 %X) {
-; RUN: opt %s -instcombine -S | 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 -S | not grep {ret i1 0}
+; RUN: opt < %s -instcombine -S | not grep {ret i1 0}
; PR1850
define i1 @test() {
-; RUN: opt %s -instcombine -S | 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 -S | grep nounwind
+; RUN: opt < %s -instcombine -S | grep nounwind
define void @bar() {
entry:
-; RUN: opt %s -instcombine -S | grep {add} | count 1
+; RUN: opt < %s -instcombine -S | grep {add} | count 1
define i32 @foo(i32 %a) {
entry:
-; RUN: opt %s -mem2reg -instcombine -S | 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 -S | not grep bitcast
+; RUN: opt < %s -instcombine 2> /dev/null -S | not grep bitcast
define void @a() {
ret void
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
define <2 x i32> @f() {
ret <2 x i32> undef
-; RUN: opt %s -instcombine -S | not grep bitcast
+; RUN: opt < %s -instcombine -S | not grep bitcast
define void @f(i16 %y) {
ret void
-; RUN: opt %s -instcombine -S | grep and
+; RUN: opt < %s -instcombine -S | grep and
; PR1907
define i1 @test(i32 %c84.17) {
-; RUN: opt %s -instcombine -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
%struct.FRAME.nest = type { i32, i32 (i32*)* }
%struct.__builtin_trampoline = type { [10 x i8] }
-; RUN: opt %s -instcombine -S | 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 -S | notcast
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | not grep {a.off}
+; RUN: opt < %s -instcombine -S | not grep {a.off}
; PR1949
define i1 @test1(i32 %a) {
-; RUN: opt %s -instcombine -S | grep rem
+; RUN: opt < %s -instcombine -S | grep rem
; PR1933
define i32 @fold(i32 %a) {
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | not grep mul
+; RUN: opt < %s -instcombine -S | not grep mul
define i26 @test(i26 %a) nounwind {
entry:
-; RUN: opt %s -instcombine | llvm-dis
+; RUN: opt < %s -instcombine | llvm-dis
; rdar://5771353
define float @test(float %x, x86_fp80 %y) nounwind readonly {
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR2303
%"struct.std::ctype<char>" = type { %"struct.std::locale::facet", i32*, i8, i32*, i32*, i16*, i8, [256 x i8], [256 x i8], i8 }
%"struct.std::locale::facet" = type { i32 (...)**, i32 }
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR2339
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-s0:0:64-f80:32:32"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -instcombine -S | 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 -disable-output
+; RUN: opt < %s -instcombine -disable-output
define <3 x i8> @f(<3 x i8> %i) {
%A = sdiv <3 x i8> %i, %i
-; RUN: opt %s -instcombine -S | 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 -S | grep {ret i1 false}
+; RUN: opt < %s -instcombine -S | grep {ret i1 false}
; PR2359
define i1 @f(i8* %x) {
entry:
-; RUN: opt %s -instcombine -S | grep {xor}
+; RUN: opt < %s -instcombine -S | grep {xor}
; PR2389
define i1 @test(i1 %a, i1 %b) {
-; RUN: opt %s -instcombine -S > %t
+; RUN: opt < %s -instcombine -S > %t
; RUN: grep {xor} %t
; RUN: grep {and} %t
; RUN: not grep {div} %t
-; RUN: opt %s -instcombine
+; RUN: opt < %s -instcombine
define i65 @foo(i65 %x) nounwind {
entry:
-; RUN: opt %s -instcombine -S | grep {phi i32} | count 2
+; RUN: opt < %s -instcombine -S | grep {phi i32} | count 2
define void @test() nounwind {
entry:
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | grep load | count 3
+; RUN: opt < %s -instcombine -S | grep load | count 3
; PR2471
declare i32 @x(i32*)
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | 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 -S | grep -v {i32 8}
+; RUN: opt < %s -instcombine -S | grep -v {i32 8}
; PR2330
define i32 @a(i32 %a) nounwind {
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | grep {%C = xor i1 %A, true}
-; RUN: opt %s -instcombine -S | 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 -S | not grep add
-; RUN: opt %s -instcombine -S | 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 -S | not grep rem
+; RUN: opt < %s -instcombine -S | not grep rem
; PR2330
define i32 @a(i32 %b) nounwind {
-; RUN: opt %s -instcombine -S | grep {lshr.*3}
-; RUN: opt %s -instcombine -S | 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 -S | grep sub
+; RUN: opt < %s -instcombine -S | grep sub
; PR2553
define double @test(double %X) nounwind {
-; RUN: opt %s -instcombine -S | 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 -S | 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
+; RUN: opt < %s -instcombine
define void @entry(i32 %m_task_id, i32 %start_x, i32 %end_x, i32 %start_y, i32 %end_y) {
br label %1
-; RUN: opt %s -instcombine -S | grep {or i1}
+; RUN: opt < %s -instcombine -S | grep {or i1}
; PR2844
define i32 @test(i32 %p_74) {
-; RUN: opt %s -instcombine -S | grep {ret i1 false}
+; RUN: opt < %s -instcombine -S | grep {ret i1 false}
; PR2697
define i1 @x(i32 %x) nounwind {
-; RUN: opt %s -instcombine
+; RUN: opt < %s -instcombine
; PR2940
define i32 @tstid() {
-; RUN: opt %s -instcombine -S | grep {ret i1 true}
+; RUN: opt < %s -instcombine -S | grep {ret i1 true}
; PR2993
define i1 @foo(i32 %x) {
-; RUN: opt %s -instcombine -S > %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 -S > %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 -S | 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 -S | 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 -S | 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 -S | 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
+; RUN: opt < %s -instcombine | llvm-dis
; PR3235
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 -instcombine -S > %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 -S | 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 -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
+; 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 -S | grep 0x3FB99999A0000000 | count 2
-; RUN: opt %s -simplifycfg -instcombine -S | 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
+; RUN: opt < %s -instcombine
; PR3381
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 -instcombine | llvm-dis
+; RUN: opt < %s -instcombine | llvm-dis
; PR3452
define i128 @test(i64 %A, i64 %B, i1 %C, i128 %Z, i128 %Y, i64* %P, i64* %Q) {
entry:
-; RUN: opt %s -instcombine -S | 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
+; RUN: opt < %s -instcombine
; PR3468
define x86_fp80 @cast() {
-; RUN: opt %s -instcombine -scalarrepl -S | 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 -S | 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
+; RUN: opt < %s -instcombine | llvm-dis
; PR3667
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
+; RUN: opt < %s -instcombine | llvm-dis
; PR3826
define void @0(<4 x i16>*, <4 x i16>*) {
-; RUN: opt %s -instcombine -S | grep {ashr i32 %val, 31}
+; RUN: opt < %s -instcombine -S | grep {ashr i32 %val, 31}
; PR3851
define i32 @foo2(i32 %val) nounwind {
; PR3874
-; RUN: opt %s -instcombine | llvm-dis
+; RUN: opt < %s -instcombine | llvm-dis
define i1 @test(i32 %x) {
%A = lshr i32 3968, %x
%B = and i32 %A, 1
-; RUN: opt %s -instcombine -S | 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 -S | not grep cmp
+; RUN: opt < %s -instcombine -S | not grep cmp
; rdar://6903175
define i1 @f0(i32 *%a) nounwind {
-; RUN: opt %s -instcombine -S | grep {store i32 0,}
+; RUN: opt < %s -instcombine -S | grep {store i32 0,}
; PR4366
define void @a() {
-; RUN: opt %s -instcombine -S | 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 | llvm-dis
; PR4495
define i32 @test(i64 %test) {
-; RUN: opt %s -instcombine -S | \
+; 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 -S | 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 -S | 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 -S | grep {add i32}
-; RUN: opt %s -instcombine -S | 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 -S | grep {add i32}
+; RUN: opt < %s -instcombine -S | grep {add i32}
define double @x(i32 %a, i32 %b) nounwind {
%m = lshr i32 %a, 24
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | grep {GLOBAL.*align 16}
-; RUN: opt %s -instcombine -S | 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
;
; Which corresponds to test1.
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {or }
define i32 @test1(i32 %X, i32 %Y) {
-; RUN: opt %s -instcombine -S | grep {and i32 %a, 1} | count 4
-; RUN: opt %s -instcombine -S | 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 {
;
; This tests arbitrary precision integers.
-; RUN: opt %s -instcombine -S | not grep {or }
+; RUN: opt < %s -instcombine -S | not grep {or }
; END.
define i17 @test1(i17 %X, i17 %Y) {
; This test makes sure that and instructions are properly eliminated.
; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0.
-; RUN: opt %s -instcombine -S | 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 -S | not grep {and }
+; RUN: opt < %s -instcombine -S | not grep {and }
; END.
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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
; Test that elimination of logical operators works with
; arbitrary precision integers.
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {(and\|xor\|add\|shl\|shr)}
; END.
; This test makes sure that the xor instructions are properly eliminated
; when arbitrary precision integers are used.
-; RUN: opt %s -instcombine -S | not grep xor
+; RUN: opt < %s -instcombine -S | not grep xor
define i33 @test1(i33 %A) {
%B = xor i33 %A, -1
-; RUN: opt %s -instcombine -S | grep shl
+; RUN: opt < %s -instcombine -S | grep shl
; END.
define i1 @test0(i39 %X, i39 %A) {
; This test makes sure that xor instructions are properly eliminated.
; This test is for Integer BitWidth <= 64 && BitWidth % 8 != 0.
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | notcast {} {%c1.*}
+; RUN: opt < %s -instcombine -S | notcast {} {%c1.*}
define i1024 @test_sext_zext(i77 %A) {
%c1 = zext i77 %A to i533
; This file contains various testcases that require tracking whether bits are
; set or cleared by various instructions.
-; RUN: opt %s -instcombine -instcombine -S |\
+; RUN: opt < %s -instcombine -instcombine -S |\
; RUN: not grep %ELIM
; Reduce down to a single XOR
-; RUN: opt %s -instcombine -S | 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 -S | 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
; Tests to make sure bit counts of constants are folded
-; RUN: opt %s -instcombine -S | grep {ret i32 19}
-; RUN: opt %s -instcombine -S | \
+; 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 -S |\
+; 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 -S | grep ret | count 6
-; RUN: opt %s -instcombine -S | 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {call.*llvm.bswap} | count 6
define i32 @test1(i32 %i) {
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep call | not grep bitcast
target datalayout = "e-p:32:32"
-; RUN: opt %s -instcombine | llvm-dis
+; RUN: opt < %s -instcombine | llvm-dis
@X = global i8 0 ; <i8*> [#uses=3]
@Y = global i8 12 ; <i8*> [#uses=2]
; Ignore stderr, we expect warnings there
-; RUN: opt %s -instcombine 2> /dev/null -S | \
+; RUN: opt < %s -instcombine 2> /dev/null -S | \
; RUN: grep call | notcast
; END.
-; RUN: opt %s -instcombine | llvm-dis
+; RUN: opt < %s -instcombine | llvm-dis
; This used to crash trying to do a double-to-pointer conversion
define i32 @bar() {
-; RUN: opt %s -instcombine -S | \
+; 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep bitcast
define i1 @test1(i32 %val) {
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep i8
define i32 @test1(i32 %X) {
-; RUN: opt %s -instcombine -globaldce -S | \
+; 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 -S | \
+; 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 -mem2reg -S | \
+; RUN: opt < %s -instcombine -mem2reg -S | \
; RUN: not grep load
define i32 @test1(i32* %P) {
-; RUN: opt %s -instcombine -S | 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 -S | grep %c | notcast
+; RUN: opt < %s -instcombine -S | grep %c | notcast
@inbuf = external global [32832 x i8] ; <[32832 x i8]*> [#uses=1]
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | FileCheck %s
+; RUN: opt < %s -instcombine -S | FileCheck %s
target datalayout = "p:32:32"
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | grep {ret i32 %A}
-; RUN: opt %s -die -S | 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 -S | not grep sdiv
+; RUN: opt < %s -instcombine -S | not grep sdiv
; PR2740
define i1 @func_75(i32 %i2) nounwind {
-; RUN: opt %s -instcombine -S | 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 -S | FileCheck %s
+; RUN: opt < %s -instcombine -S | FileCheck %s
; CHECK: define i32 @foo
; CHECK: sdiv i32 %x, 8
-; RUN: opt %s -instcombine -S | 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 -S | not grep zeroinitializer
+; RUN: opt < %s -instcombine -S | not grep zeroinitializer
define void @foo(i64 %A, i64 %B) {
bb8:
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {call float bitcast} | count 1
%struct.NSObject = type { %struct.objc_class* }
%struct.NSArray = type { %struct.NSObject }
-; RUN: opt %s -instcombine -S | FileCheck %s
+; RUN: opt < %s -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64"
%intstruct = type { i32 }
-; RUN: opt %s -instcombine -S | 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 -S | grep {align 1}
+; RUN: opt < %s -instcombine -S | grep {align 1}
; END.
%struct.p = type <{ i8, i32 }>
-; RUN: opt %s -instcombine -S | 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
; test that malloc's with a constant argument are promoted to array allocations
-; RUN: opt %s -instcombine -S | grep getelementptr
+; RUN: opt < %s -instcombine -S | grep getelementptr
define i32* @test() {
%X = malloc i32, i32 4
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | \
+; 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 -S | 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 -S | grep ashr
+; RUN: opt < %s -instcombine -S | grep ashr
define i32 @foo(i32 %x, i32 %y) {
%a = and i32 %x, 7
-; RUN: opt %s -instcombine -S | 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 -S | \
+; 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 -S | 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 -S | 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 -S | not grep call
+; RUN: opt < %s -instcombine -S | not grep call
; rdar://6880732
declare double @t1(i32) readonly
-; RUN: opt %s -instcombine -S | FileCheck %s
+; RUN: opt < %s -instcombine -S | FileCheck %s
; CHECK: define i32 @foo
; %y = sub i32 0, %x
-; RUN: opt %s -instcombine -S | 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
; This test makes sure that these instructions are properly eliminated.
;
-; RUN: opt %s -instcombine -S | \
+; 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 -S | 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 -S | not grep {phi i32}
+; RUN: opt < %s -instcombine -S | not grep {phi i32}
; PR1777
declare i1 @rrr()
-; RUN: opt %s -instcombine -S | 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 -S | grep shufflevector
+; RUN: opt < %s -instcombine -S | grep shufflevector
; PR2645
; instcombine shouldn't delete the shufflevector.
-; RUN: opt %s -instcombine
+; RUN: opt < %s -instcombine
; PR2996
define void @func_53(i16 signext %p_56) nounwind {
-; RUN: opt %s -instcombine -S | 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 -S > %t
+; RUN: opt < %s -instcombine -S > %t
define i1 @test1(i32 *%x) nounwind {
entry:
-; RUN: opt %s -instcombine -inline -S | not grep '-715827882'
+; RUN: opt < %s -instcombine -inline -S | not grep '-715827882'
; PR3142
define i32 @a(i32 %X) nounwind readnone {
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; PR3144
define fastcc i32 @func(i32 %length) nounwind {
-; RUN: opt %s -instcombine -S | 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.
;
-; RUN: opt %s -instcombine -S | 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep -v {icmp eq} | grep -v {icmp ne} | not grep icmp
; END.
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {lshr i32} | count 2
-; RUN: opt %s -instcombine -S | not grep ashr
+; RUN: opt < %s -instcombine -S | not grep ashr
define i32 @test1(i32 %X, i8 %A) {
-; RUN: opt %s -instcombine -S | grep lshr.*63
+; RUN: opt < %s -instcombine -S | grep lshr.*63
define i32 @t1(i64 %d18) {
entry:
-; RUN: opt %s -instcombine -stats -disable-output |& \
+; RUN: opt < %s -instcombine -stats -disable-output |& \
; RUN: grep {Number of insts combined} | grep 5
define i8 @t1(i8 zeroext %x, i8 zeroext %y) zeroext nounwind {
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S > %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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {(and\|xor\|add\|shl\|shr)}
; END.
-; RUN: opt %s -instcombine -disable-output
+; RUN: opt < %s -instcombine -disable-output
; SimplifyDemandedBits should cope with pointer types.
-; RUN: opt %s -instcombine -S | grep {ret i1 false}
+; RUN: opt < %s -instcombine -S | grep {ret i1 false}
; PR2276
define i1 @f(i32 %x) {
-; RUN: opt %s -instcombine -S | 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
+; RUN: opt < %s -instcombine
; PR2670
@g_127 = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {ret i32 %.toremerge} | count 2
;; Simple sinking tests
-; RUN: opt %s -instcombine -S > %t
+; RUN: opt < %s -instcombine -S > %t
; RUN: not grep zext %t
; RUN: not grep sext %t
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | 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 -S | not grep extractelement
+; RUN: opt < %s -instcombine -S | not grep extractelement
define void @get_image() nounwind {
entry:
-; RUN: opt %s -instcombine -S | 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {fadd float}
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {fmul float}
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {insertelement.*0.00}
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {call.*llvm.x86.sse.mul}
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep {call.*llvm.x86.sse.sub}
; END.
-; RUN: opt %s -instcombine -S | 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep shufflevec | count 1
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep insertelement
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: not grep extractelement
; END.
-; RUN: opt %s -instcombine -S | 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 -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {add float}
%V = type <4 x float>
-; RUN: opt %s -instcombine -S | not grep vector_shuffle
+; RUN: opt < %s -instcombine -S | not grep vector_shuffle
; END.
%T = type <4 x float>
-; RUN: opt %s -instcombine -S | 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 -S | 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 -S | 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 -S | grep {volatile store}
-; RUN: opt %s -instcombine -S | 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 -S | not grep {= or}
+; RUN: opt < %s -instcombine -S | not grep {= or}
; PR3266
; XFAIL: *
-; RUN: opt %s -instcombine -S | 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 -S | \
+; 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 -S | not grep {xor }
+; RUN: opt < %s -instcombine -S | not grep {xor }
; PR1253
define i1 @test0(i32 %A) {
-; RUN: opt %s -instcombine -S | grep 0.0 | count 1
+; RUN: opt < %s -instcombine -S | grep 0.0 | count 1
declare double @abs(double)
-; RUN: opt %s -instcombine -S | \
+; RUN: opt < %s -instcombine -S | \
; RUN: grep {and i32 %Y, 8}
define i32 @test1(i8 %X) {
-; RUN: opt %s -instcombine -S | grep {zext } | count 1
+; RUN: opt < %s -instcombine -S | grep {zext } | count 1
; PR1570
define i32 @test2(float %X, float %Y) {
; Tests to make sure elimination of casts is working correctly
-; RUN: opt %s -instcombine -S | \
+; 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 -S | 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 -S | 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 -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
+; 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 -S | 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 -S | grep internal | count 3
+; RUN: opt < %s -internalize -S | grep internal | count 3
@A = global i32 0
@B = alias i32* @A
-; RUN: opt %s -jump-threading -disable-output
+; RUN: opt < %s -jump-threading -disable-output
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"
@Link = global [1 x i32] [ i32 -1 ] ; <[1 x i32]*> [#uses=2]
-; RUN: opt %s -jump-threading -disable-output
+; RUN: opt < %s -jump-threading -disable-output
; PR2285
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 -jump-threading | llvm-dis
+; RUN: opt < %s -jump-threading | llvm-dis
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 -jump-threading | llvm-dis
+; RUN: opt < %s -jump-threading | llvm-dis
; PR3298
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 -jump-threading | llvm-dis
+; RUN: opt < %s -jump-threading | llvm-dis
; PR3353
define i32 @test(i8 %X) {
-; RUN: opt %s -jump-threading -mem2reg -instcombine -simplifycfg -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S > %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 -S | 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 -S | not grep {br }
-; RUN: opt %s -jump-threading -S | 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 -S | \
+; RUN: opt < %s -lcssa -S | \
; RUN: grep {%%SJE.0.0.lcssa = phi .struct.SetJmpMapEntry}
-; RUN: opt %s -lcssa -S | \
+; 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 -S | \
+; RUN: opt < %s -lcssa -S | \
; RUN: grep {%X.1.lcssa}
-; RUN: opt %s -lcssa -S | \
+; RUN: opt < %s -lcssa -S | \
; RUN: not grep {%X.1.lcssa1}
declare i1 @c1()
-; RUN: opt %s -lcssa
+; RUN: opt < %s -lcssa
%struct.SetJmpMapEntry = type { i8*, i32, %struct.SetJmpMapEntry* }
-; RUN: opt %s -lcssa -disable-output -verify-dom-info
+; RUN: opt < %s -lcssa -disable-output -verify-dom-info
; PR977
; END.
declare i32 @opost_block()
-; RUN: opt %s -lcssa -disable-output
+; RUN: opt < %s -lcssa -disable-output
; PR977
; END.
-; RUN: opt %s -loop-rotate -licm -loop-unswitch -disable-output
+; RUN: opt < %s -loop-rotate -licm -loop-unswitch -disable-output
define i32 @main(i32 %argc, i8** %argv) {
entry:
br label %bb7
-; RUN: opt %s -loop-rotate -licm -loop-unswitch -disable-output
+; RUN: opt < %s -loop-rotate -licm -loop-unswitch -disable-output
define i32 @main(i32 %argc, i8** %argv) {
entry:
-; RUN: opt %s -loop-rotate -licm -loop-unswitch -disable-output
+; RUN: opt < %s -loop-rotate -licm -loop-unswitch -disable-output
define i32 @main(i32 %argc, i8** %argv) {
entry:
br label %bb7
-; RUN: opt %s -lcssa -S | \
+; RUN: opt < %s -lcssa -S | \
; RUN: grep {X3.lcssa = phi i32}
-; RUN: opt %s -lcssa -S | \
+; RUN: opt < %s -lcssa -S | \
; RUN: grep {X4 = add i32 3, %X3.lcssa}
define void @lcssa(i1 %S2) {
-; RUN: opt %s -lcssa
+; RUN: opt < %s -lcssa
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 -basicaa -licm -disable-output
+; RUN: opt < %s -basicaa -licm -disable-output
;%MoveArray = external global [64 x ulong]
; Exit blocks need to be updated for all nested loops...
-; RUN: opt %s -loopsimplify
+; RUN: opt < %s -loopsimplify
define i32 @yyparse() {
bb0:
; This testcase fails because preheader insertion is not updating exit node
; information for loops.
-; RUN: opt %s -licm
+; RUN: opt < %s -licm
define i32 @main(i32 %argc, i8** %argv) {
bb0:
; happens because preheader insertion doesn't insert a preheader for this
; case... bad.
-; RUN: opt %s -licm -loop-deletion -simplifycfg -S | \
+; RUN: opt < %s -licm -loop-deletion -simplifycfg -S | \
; RUN: not grep {br }
define i32 @main(i32 %argc) {
; LICM is adding stores before phi nodes. bad.
-; RUN: opt %s -licm
+; RUN: opt < %s -licm
define i1 @test(i1 %c) {
; <label>:0
; Test that hoisting is disabled for pointers of different types...
;
-; RUN: opt %s -licm
+; RUN: opt < %s -licm
define void @test(i32* %P) {
br label %Loop
; loaded from. Basically if the load gets hoisted, the subtract gets turned
; into a constant zero.
;
-; RUN: opt %s -licm -gvn -instcombine -S | grep load
+; RUN: opt < %s -licm -gvn -instcombine -S | grep load
@X = global i32 7 ; <i32*> [#uses=2]
-; RUN: opt %s -licm | lli
+; RUN: opt < %s -licm | lli
define i32 @main() {
entry:
-; RUN: opt %s -globalsmodref-aa -licm -disable-output
+; RUN: opt < %s -globalsmodref-aa -licm -disable-output
@PL_regcomp_parse = internal global i8* null ; <i8**> [#uses=2]
-; RUN: opt %s -licm -disable-output
+; RUN: opt < %s -licm -disable-output
%struct.roadlet = type { i8*, %struct.vehicle*, [8 x %struct.roadlet*], [8 x %struct.roadlet* (%struct.roadlet*, %struct.vehicle*, i32)*] }
%struct.vehicle = type { %struct.roadlet*, i8*, i32, i32, %union.._631., i32 }
%union.._631. = type { i32 }
-; RUN: opt %s -licm -disable-output
+; RUN: opt < %s -licm -disable-output
define void @test({ i32 }* %P) {
br label %Loop
-; RUN: opt %s -licm -disable-output
+; RUN: opt < %s -licm -disable-output
; PR908
; END.
-; RUN: opt %s -licm -S | 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"
-; RUN: opt %s -licm -loop-unswitch -disable-output
+; RUN: opt < %s -licm -loop-unswitch -disable-output
%struct.III_scalefac_t = type { [22 x i32], [13 x [3 x i32]] }
%struct.gr_info = type { i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], [3 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32*, [4 x i32] }
; 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 -S | 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 -S | 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 -S | grep promoted
+; RUN: opt < %s -licm -S | grep promoted
; Promote value if at least one use is safe
-; RUN: opt %s -licm -disable-output
+; RUN: opt < %s -licm -disable-output
; PR2346
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 -licm -enable-licm-constant-variables -S | 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 -loop-index-split -instcombine -disable-output
+; RUN: opt < %s -licm -loop-index-split -instcombine -disable-output
%struct.FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i32, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i32, i32, [40 x i8] }
%struct._IO_marker = type { %struct._IO_marker*, %struct.FILE*, i32 }
-; RUN: opt %s -loop-rotate -licm -loop-unswitch -disable-output
+; RUN: opt < %s -loop-rotate -licm -loop-unswitch -disable-output
define i32 @stringSearch_Clib(i32 %count) {
entry:
-; RUN: opt %s -licm | llvm-dis
+; RUN: opt < %s -licm | llvm-dis
define void @testfunc(i32 %i) {
; <label>:0
-; RUN: opt %s -licm -S | FileCheck %s
+; RUN: opt < %s -licm -S | FileCheck %s
@X = global i32 0 ; <i32*> [#uses=1]
; Test that LICM works when there is not a loop-preheader
-; RUN: opt %s -licm | llvm-dis
+; RUN: opt < %s -licm | llvm-dis
define void @testfunc(i32 %i.s, i1 %ifcond) {
br i1 %ifcond, label %Then, label %Else
-; RUN: opt %s -licm -S | 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 -S | FileCheck %s
+; RUN: opt < %s -basicaa -licm -S | FileCheck %s
declare i32 @strlen(i8*) readonly
-; RUN: opt %s -loop-deletion -S | grep switch
+; RUN: opt < %s -loop-deletion -S | grep switch
; PR 1564
define fastcc void @out() {
-; RUN: opt %s -inline -tailduplicate -instcombine -jump-threading -licm -loop-unswitch -instcombine -indvars -loop-deletion -gvn -simplifycfg -verify -disable-output
+; RUN: opt < %s -inline -tailduplicate -instcombine -jump-threading -licm -loop-unswitch -instcombine -indvars -loop-deletion -gvn -simplifycfg -verify -disable-output
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"
; PR1692
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
%struct.CLAUSE_HELP = type { i32, i32, i32, i32, i32*, i32, %struct.LIST_NODE*, %struct.LIST_NODE*, i32, i32, %struct.LITERAL_HELP**, i32, i32, i32, i32 }
%struct.LIST_NODE = type { %struct.LIST_NODE*, i8* }
%struct.LITERAL_HELP = type { i32, i32, i32, %struct.CLAUSE_HELP*, %struct.term* }
; Update loop iteraton space to eliminate condition inside loop.
-; RUN: opt %s -loop-index-split -S | 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 -S | 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 -disable-output -stats |& \
+; RUN: opt < %s -loop-index-split -disable-output -stats |& \
; RUN: not grep "loop-index-split"
; Induction variable decrement is not yet handled.
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; PR 1995
define void @add_blkdev_randomness(i32 %major) nounwind {
-; RUN: opt %s -disable-output -loop-index-split
+; RUN: opt < %s -disable-output -loop-index-split
; PR 2011
%struct.CLAUSE_HELP = type { i32, i32, i32, i32, i32*, i32, %struct.LIST_NODE*, %struct.LIST_NODE*, i32, i32, %struct.LITERAL_HELP**, i32, i32, i32, i32 }
%struct.LIST_NODE = type { %struct.LIST_NODE*, i8* }
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; PR 2011
%struct.CLAUSE_HELP = type { i32, i32, i32, i32, i32*, i32, %struct.LIST_NODE*, %struct.LIST_NODE*, i32, i32, %struct.LITERAL_HELP**, i32, i32, i32, i32 }
%struct.LIST_NODE = type { %struct.LIST_NODE*, i8* }
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; PR 2011
%struct.CLAUSE_HELP = type { i32, i32, i32, i32, i32*, i32, %struct.LIST_NODE*, %struct.LIST_NODE*, i32, i32, %struct.LITERAL_HELP**, i32, i32, i32, i32 }
%struct.LIST_NODE = type { %struct.LIST_NODE*, i8* }
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; PR 2030
%struct.FULL = type { i32, i32, [1000 x float*] }
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; Handle Exit block phis that do not have any use inside the loop.
%struct.ATOM = type { double, double, double, double, double, double, i32, double, double, double, double, i8*, i8, [9 x i8], double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, [200 x i8*], [32 x i8*], [32 x i8], i32 }
-; RUN: opt %s -loop-index-split -stats -disable-output | not grep "loop-index-split"
+; RUN: opt < %s -loop-index-split -stats -disable-output | not grep "loop-index-split"
;PR2294
@g_2 = external global i16 ; <i16*> [#uses=4]
@g_5 = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -loop-rotate -loop-unswitch -loop-index-split -instcombine -disable-output
+; RUN: opt < %s -loop-rotate -loop-unswitch -loop-index-split -instcombine -disable-output
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.__CFData = type opaque
-; RUN: opt %s -loop-index-split -stats -disable-output | not grep "1 loop-index-split"
+; RUN: opt < %s -loop-index-split -stats -disable-output | not grep "1 loop-index-split"
; PR 2487
@g_6 = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -loop-index-split -stats -disable-output | not grep "loop-index-split"
+; RUN: opt < %s -loop-index-split -stats -disable-output | not grep "loop-index-split"
; PR 2791
@g_40 = common global i32 0 ; <i32*> [#uses=1]
@g_192 = common global i32 0 ; <i32*> [#uses=2]
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; PR 2805
@g_330 = common global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
%struct.RExC_state_t = type { i32, i8*, %struct.regexp*, i8*, i8*, i8*, i32, %struct.regnode*, %struct.regnode*, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
%struct.SV = type { i8*, i32, i32 }
%struct.reg_data = type { i32, i8*, [1 x i8*] }
-; RUN: opt %s -loop-index-split -stats -disable-output |& grep "1 loop-index-split"
+; RUN: opt < %s -loop-index-split -stats -disable-output |& grep "1 loop-index-split"
; PR 2869
@w = external global [2 x [2 x i32]] ; <[2 x [2 x i32]]*> [#uses=5]
-; RUN: opt %s -loop-index-split -stats | not grep "loop-index-split"
+; RUN: opt < %s -loop-index-split -stats | not grep "loop-index-split"
; PR3029
@g_138 = common global i32 0 ; <i32*> [#uses=3]
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
%struct.CGPoint = type { double, double }
%struct.IBCFMutableDictionary = type { %struct.NSMutableArray, %struct.__CFDictionary*, %struct.NSSortDescriptor*, %struct.NSSortDescriptor* }
%struct.IBInspectorMode = type opaque
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
%struct._edit_script = type { %struct._edit_script*, i32, i8 }
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
; PR1828.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 = "i686-pc-linux-gnu"
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
%struct._edit_script = type { %struct._edit_script*, i32, i8 }
-; RUN: opt %s -loop-index-split -disable-output
+; RUN: opt < %s -loop-index-split -disable-output
@k = external global i32 ; <i32*> [#uses=2]
; Loop is elimianted
-; RUN: opt %s -loop-index-split -disable-output -stats |& \
+; RUN: opt < %s -loop-index-split -disable-output -stats |& \
; RUN: grep "loop-index-split" | count 1
%struct.anon = type { i32 }
@S1 = external global i32 ; <i32*> [#uses=1]
; Loop is elimianted. Save last value assignment.
-; RUN: opt %s -loop-index-split -disable-output -stats |& \
+; RUN: opt < %s -loop-index-split -disable-output -stats |& \
; RUN: grep "loop-index-split" | count 1
%struct.anon = type { i32 }
; Loop is elimianted. Save last value assignments, including induction variable.
-; RUN: opt %s -loop-index-split -disable-output -stats | not grep "loop-index-split"
+; RUN: opt < %s -loop-index-split -disable-output -stats | not grep "loop-index-split"
declare i32 @foo(i32)
declare i32 @bar(i32, i32)
-; RUN: opt %s -loop-index-split -S | not grep "icmp ne"
+; RUN: opt < %s -loop-index-split -S | not grep "icmp ne"
define i32 @main() {
entry:
; Split loop. Save last value.
-; RUN: opt %s -loop-index-split -disable-output -stats |& \
+; RUN: opt < %s -loop-index-split -disable-output -stats |& \
; RUN: grep "loop-index-split" | count 1
@k = external global i32 ; <i32*> [#uses=2]
; Split loop. Save last value. Split value is off by one in this example.
-; RUN: opt %s -loop-index-split -disable-output -stats |& \
+; RUN: opt < %s -loop-index-split -disable-output -stats |& \
; RUN: grep "loop-index-split" | count 1
%llvm.dbg.anchor.type = type { i32, i32 }
; Split loop. Save last value. Split value is off by one in this example.
-; RUN: opt %s -loop-index-split -disable-output -stats |& \
+; RUN: opt < %s -loop-index-split -disable-output -stats |& \
; RUN: grep "loop-index-split" | count 1
@k = external global i32 ; <i32*> [#uses=2]
; 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 -S | grep select
+; RUN: opt < %s -loop-index-split -S | grep select
@k = external global i32 ; <i32*> [#uses=2]
-; RUN: opt %s -inline -reassociate -loop-rotate -loop-index-split -indvars -simplifycfg -verify
+; RUN: opt < %s -inline -reassociate -loop-rotate -loop-index-split -indvars -simplifycfg -verify
; PR4471
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 -loop-rotate | llvm-dis
+; RUN: opt < %s -loop-rotate | llvm-dis
; PR3408
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 -loop-rotate -disable-output
+; RUN: opt < %s -loop-rotate -disable-output
%struct.relation = type { [4 x i16], i32, [4 x i16], i32, i32 }
-; RUN: opt %s -loop-rotate -disable-output
+; RUN: opt < %s -loop-rotate -disable-output
define void @findAllPairs() {
entry:
-; RUN: opt %s -loop-rotate -disable-output
+; RUN: opt < %s -loop-rotate -disable-output
define void @_ZN9Classfile4readEv() {
entry:
-; RUN: opt %s -loop-rotate -disable-output
+; RUN: opt < %s -loop-rotate -disable-output
define void @InterpretSEIMessage(i8* %msg) {
entry:
-; RUN: opt %s -loop-rotate -disable-output
+; RUN: opt < %s -loop-rotate -disable-output
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"
%struct.NSArray = type { %struct.NSObject }
-; RUN: opt %s -loop-rotate -S | 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"
-; RUN: opt %s -loop-rotate -disable-output
+; RUN: opt < %s -loop-rotate -disable-output
; ModuleID = 'PhiSelfRefernce-1.bc'
define void @snrm2(i32 %incx) {
-; RUN: opt %s -loop-deletion -loop-rotate -disable-output
+; RUN: opt < %s -loop-deletion -loop-rotate -disable-output
; PR 2639
%struct.HexxagonMove = type { i8, i8, i32 }
; This testcase exposed a problem with the loop identification pass (LoopInfo).
; Basically, it was incorrectly calculating the loop nesting information.
;
-; RUN: opt %s -loopsimplify
+; RUN: opt < %s -loopsimplify
define i32 @yylex() {
br label %loopentry.0
; inserted for the "fail" loop, but the exit block of a loop is not updated
; to be the preheader instead of the exit loop itself.
-; RUN: opt %s -loopsimplify
+; RUN: opt < %s -loopsimplify
define i32 @re_match_2() {
br label %loopentry.1
loopentry.1: ; preds = %endif.82, %0
-; RUN: opt %s -tailduplicate -instcombine -simplifycfg -licm -disable-output
+; RUN: opt < %s -tailduplicate -instcombine -simplifycfg -licm -disable-output
target datalayout = "e-p:32:32"
@yy_base = external global [787 x i16] ; <[787 x i16]*> [#uses=1]
@yy_state_ptr = external global i32* ; <i32**> [#uses=3]
;
; This is distilled from a monsterous crafty example.
-; RUN: opt %s -licm -disable-output
+; RUN: opt < %s -licm -disable-output
@G = weak global i32 0 ; <i32*> [#uses=7]
-; RUN: opt %s -loopsimplify -verify -licm -disable-output
+; RUN: opt < %s -loopsimplify -verify -licm -disable-output
define void @.subst_48() {
entry:
-; RUN: opt %s -loopsimplify -licm -disable-output
+; RUN: opt < %s -loopsimplify -licm -disable-output
define void @main() {
entry:
br i1 false, label %Out, label %loop
-; RUN: opt %s -loopsimplify -licm -disable-output
+; RUN: opt < %s -loopsimplify -licm -disable-output
; This is PR306
-; RUN: opt %s -loopsimplify -disable-output
+; RUN: opt < %s -loopsimplify -disable-output
define void @test() {
loopentry.0:
-; RUN: opt %s -scalarrepl -loopsimplify -licm -disable-output -verify-dom-info
+; RUN: opt < %s -scalarrepl -loopsimplify -licm -disable-output -verify-dom-info
define void @inflate() {
entry:
-; RUN: opt %s -loopsimplify -disable-output
+; RUN: opt < %s -loopsimplify -disable-output
; PR1752
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-s0:0:64-f80:32:32"
target triple = "i686-pc-mingw32"
-; RUN: opt %s -loopsimplify
+; RUN: opt < %s -loopsimplify
; This function should get a preheader inserted before BB3, that is jumped
; to by BB1 & BB2
-; RUN: opt %s -loopsimplify
+; RUN: opt < %s -loopsimplify
define void @foo(i1 %C) {
br i1 %C, label %T, label %F
-; RUN: opt %s -loopsimplify -loop-rotate -instcombine -indvars -S > %t
+; RUN: opt < %s -loopsimplify -loop-rotate -instcombine -indvars -S > %t
; RUN: not grep sext %t
; RUN: grep {phi i64} %t | count 1
; for all loops. This allows the -indvars pass to recognize the %IV
; induction variable in this testcase.
-; RUN: opt %s -indvars -S | grep indvar
+; RUN: opt < %s -indvars -S | grep indvar
define i32 @test(i1 %C) {
; <label>:0
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
define void @try_swap() {
entry:
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
define i32 @image_to_texture(i32 %indvar454) {
loopentry.1.outer:
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
define void @main() {
entry:
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
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-reduce -S | 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 -S | 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 -S | 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 -S | 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 -S | grep phi | count 1
-; RUN: opt %s -loop-reduce -S | 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 -S \
+; RUN: opt < %s -loop-reduce -S \
; RUN: | grep {getelementptr.*%lsr.iv.*%lsr.iv.*<i32\\*>}
; The multiply in bb2 must not be reduced to an add, as the sext causes the
; %1 argument to become negative after a while.
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
; Test to make sure that loop-reduce never crashes on IV's
; with different types but identical strides.
-; RUN: opt %s -loop-reduce -S | \
+; 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 -S | grep phi | count 2
+; RUN: opt < %s -loop-reduce -S | grep phi | count 2
declare i1 @pred()
; Don't reduce the byte access to P[i], at least not on targets that
; support an efficient 'mem[r1+r2]' addressing mode.
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
declare i1 @pred(i32)
-; RUN: opt %s -loop-reduce -S \
+; RUN: opt < %s -loop-reduce -S \
; RUN: | grep {icmp eq i2 %lsr.iv.next, %xmp4344}
; Don't reverse the iteration if the rhs of the compare is defined
; Check that the index of 'P[outer]' is pulled out of the loop.
-; RUN: opt %s -loop-reduce -S | \
+; 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 -S | \
+; RUN: opt < %s -loop-reduce -S | \
; RUN: not grep {getelementptr.*%outer.*%INDVAR}
declare i1 @pred()
-; RUN: opt %s -loop-reduce -S | 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 -S | not grep INDVAR
+; RUN: opt < %s -loop-reduce -S | not grep INDVAR
declare i1 @pred()
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
; LSR should not crash on this.
define fastcc void @loadloop() {
-; RUN: opt %s -loop-reduce -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
; PR 2537
define void @a() {
-; RUN: opt %s -loop-reduce -S | 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 -disable-output
-; RUN: opt %s -analyze -scalar-evolution -disable-output
+; RUN: opt < %s -loop-reduce -disable-output
+; RUN: opt < %s -analyze -scalar-evolution -disable-output
; PR 3086
%struct.Cls = type { i32, i8, [2 x %struct.Cls*], [2 x %struct.Lit*] }
-; RUN: opt %s -loop-reduce | llvm-dis
+; RUN: opt < %s -loop-reduce | llvm-dis
; PR3399
@g_53 = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -loop-reduce | llvm-dis
+; RUN: opt < %s -loop-reduce | llvm-dis
; PR3571
target triple = "i386-mingw32"
-; RUN: opt %s -analyze -iv-users -disable-output | grep {Stride i64 {3,+,2}<loop>:}
+; RUN: opt < %s -analyze -iv-users -disable-output | grep {Stride i64 {3,+,2}<loop>:}
; The value of %r is dependent on a polynomial iteration expression.
-; RUN: opt %s -loop-reduce -S | 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 -S | not grep INDVAR
+; RUN: opt < %s -loop-reduce -S | not grep INDVAR
declare i1 @pred()
-; RUN: opt %s -loop-reduce -S | 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 -S | 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -loop-reduce -S | \
; RUN: not grep {mul.*%i, 3}
; Indvar should not start at zero:
-; RUN: opt %s -loop-reduce -S | \
+; 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 -S | not grep mul
+; RUN: opt < %s -loop-reduce -S | not grep mul
declare i1 @pred(i32)
-; RUN: opt %s -loop-unroll -disable-output
+; RUN: opt < %s -loop-unroll -disable-output
define i32 @main() {
entry:
-; RUN: opt %s -loop-unroll -loopsimplify -disable-output
+; RUN: opt < %s -loop-unroll -loopsimplify -disable-output
define void @print_board() {
entry:
-; RUN: opt %s -loop-unroll -S | grep bb72.2
+; RUN: opt < %s -loop-unroll -S | grep bb72.2
define void @vorbis_encode_noisebias_setup() {
entry:
; PR 1334
-; RUN: opt %s -loop-unroll -disable-output
+; RUN: opt < %s -loop-unroll -disable-output
define void @sal__math_float_manipulator_7__math__joint_array_dcv_ops__Omultiply__3([6 x float]* %agg.result) {
entry:
-; RUN: opt %s -loop-unroll -S | 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 -S | grep bb72.2
+; RUN: opt < %s -loop-unroll -unroll-count=3 -S | grep bb72.2
define void @foo(i32 %trips) {
entry:
-; RUN: opt %s -disable-output -loop-unroll
+; RUN: opt < %s -disable-output -loop-unroll
; PR1770
; PR1947
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
; END.
target datalayout = "E-p:32:32"
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
define void @sort_Eq(i32* %S2) {
entry:
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
%struct.BLEND_MAP = type { i16, i16, i16, i32, %struct.BLEND_MAP_ENTRY* }
%struct.BLEND_MAP_ENTRY = type { float, i8, { [5 x float], [4 x i8] } }
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
define void @init_caller_save() {
entry:
; PR1333
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
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 -loop-unswitch -instcombine -disable-output
+; RUN: opt < %s -loop-unswitch -instcombine -disable-output
@str3 = external constant [3 x i8] ; <[3 x i8]*> [#uses=1]
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
define i32 @main(i32 %argc, i8** %argv) {
entry:
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
; PR1559
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -licm -loop-unswitch -disable-output
+; RUN: opt < %s -licm -loop-unswitch -disable-output
; PR 1589
%struct.QBasicAtomic = type { i32 }
-; RUN: opt %s -loop-unswitch -instcombine -disable-output
+; RUN: opt < %s -loop-unswitch -instcombine -disable-output
%struct.ClassDef = type { %struct.QByteArray, %struct.QByteArray, %"struct.QList<ArgumentDef>", %"struct.QList<ArgumentDef>", i8, i8, %"struct.QList<ArgumentDef>", %"struct.QList<ArgumentDef>", %"struct.QList<ArgumentDef>", %"struct.QList<ArgumentDef>", %"struct.QList<ArgumentDef>", %"struct.QList<ArgumentDef>", %"struct.QMap<QByteArray,QByteArray>", %"struct.QList<ArgumentDef>", %"struct.QMap<QByteArray,QByteArray>", i32, i32 }
%struct.FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i32, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i32, i32, [40 x i8] }
%struct.Generator = type { %struct.FILE*, %struct.ClassDef*, %"struct.QList<ArgumentDef>", %struct.QByteArray, %"struct.QList<ArgumentDef>" }
-; RUN: opt %s -licm -loop-unroll -disable-output
+; RUN: opt < %s -licm -loop-unroll -disable-output
@resonant = external global i32 ; <i32*> [#uses=2]
-; RUN: opt %s -loop-unswitch -instcombine -gvn -disable-output
+; RUN: opt < %s -loop-unswitch -instcombine -gvn -disable-output
; PR2372
target triple = "i386-pc-linux-gnu"
-; RUN: opt %s -licm -loop-unswitch -disable-output
+; RUN: opt < %s -licm -loop-unswitch -disable-output
@g_56 = external global i16 ; <i16*> [#uses=2]
define i32 @func_67(i32 %p_68, i8 signext %p_69, i8 signext %p_71) nounwind {
-; RUN: opt %s -loop-unswitch -stats -disable-output |& grep "1 loop-unswitch - Number of branches unswitched" | count 1
+; RUN: opt < %s -loop-unswitch -stats -disable-output |& grep "1 loop-unswitch - Number of branches unswitched" | count 1
; PR 3170
define i32 @a(i32 %x, i32 %y) nounwind {
entry:
-; RUN: opt %s -loop-unswitch -disable-output
+; RUN: opt < %s -loop-unswitch -disable-output
define i32 @test(i32* %A, i1 %C) {
entry:
; This testcase was reduced from Shootout-C++/reversefile.cpp by bugpoint
-; RUN: opt %s -lowerinvoke -disable-output
+; RUN: opt < %s -lowerinvoke -disable-output
declare void @baz()
-; RUN: opt %s -lowerinvoke -enable-correct-eh-support -disable-output
+; RUN: opt < %s -lowerinvoke -enable-correct-eh-support -disable-output
define void @_ZNKSt11__use_cacheISt16__numpunct_cacheIcEEclERKSt6locale() {
entry:
-; RUN: opt %s -lowerinvoke -enable-correct-eh-support -disable-output
+; RUN: opt < %s -lowerinvoke -enable-correct-eh-support -disable-output
declare void @ll_listnext__listiterPtr()
-; RUN: opt %s -lowerinvoke -enable-correct-eh-support -disable-output
+; RUN: opt < %s -lowerinvoke -enable-correct-eh-support -disable-output
declare fastcc i32 @ll_listnext__listiterPtr()
-; RUN: opt %s -lowerinvoke -enable-correct-eh-support -disable-output
+; RUN: opt < %s -lowerinvoke -enable-correct-eh-support -disable-output
; PR2029
define i32 @main(i32 %argc, i8** %argv) {
bb470:
-; RUN: opt %s -lowerinvoke -disable-output -enable-correct-eh-support
+; RUN: opt < %s -lowerinvoke -disable-output -enable-correct-eh-support
define i32 @foo() {
-; RUN: opt %s -lowersetjmp -disable-output
+; RUN: opt < %s -lowersetjmp -disable-output
%struct.jmpenv = type { i32, i8 }
-; RUN: opt %s -lowersetjmp -S | 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: opt %s -lowerswitch
+; RUN: opt < %s -lowerswitch
define void @child(i32 %ct.1) {
entry:
-; RUN: opt %s -lowerswitch
+; RUN: opt < %s -lowerswitch
define void @test() {
switch i32 0, label %Next [
-; RUN: opt %s -lowerswitch -disable-output
+; RUN: opt < %s -lowerswitch -disable-output
define void @solve() {
entry:
; Uninitialized values are not handled correctly.
;
-; RUN: opt %s -mem2reg -disable-output
+; RUN: opt < %s -mem2reg -disable-output
;
define i32 @test() {
; This input caused the mem2reg pass to die because it was trying to promote
; the %r alloca, even though it is invalid to do so in this case!
;
-; RUN: opt %s -mem2reg
+; RUN: opt < %s -mem2reg
define void @test() {
%r = alloca i32 ; <i32*> [#uses=2]
-; RUN: opt %s -mem2reg
+; RUN: opt < %s -mem2reg
define void @_Z3barv() {
%result = alloca i32 ; <i32*> [#uses=1]
; This testcases makes sure that mem2reg can handle unreachable blocks.
-; RUN: opt %s -mem2reg
+; RUN: opt < %s -mem2reg
define i32 @test() {
%X = alloca i32 ; <i32*> [#uses=2]
; Mem2reg used to only add one incoming value to a PHI node, even if it had
; multiple incoming edges from a block.
;
-; RUN: opt %s -mem2reg -disable-output
+; RUN: opt < %s -mem2reg -disable-output
define i32 @test(i1 %c1, i1 %c2) {
%X = alloca i32 ; <i32*> [#uses=2]
; Promoting some values allows promotion of other values.
-; RUN: opt %s -mem2reg -S | 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 -S | 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 -S | grep store
+; RUN: opt < %s -mem2reg -instcombine -S | grep store
; PR590
-; RUN: opt %s -mem2reg -disable-output
+; RUN: opt < %s -mem2reg -disable-output
; PR670
define void @printk(i32, ...) {
-; RUN: opt %s -std-compile-opts -S | 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 -S | 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 -S | 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 -S | 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 -S | not grep {call.*memcpy.}
+; RUN: opt < %s -memcpyopt -S | not grep {call.*memcpy.}
%a = type { i32 }
%b = type { float }
-; RUN: opt %s -memcpyopt -S | 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 -disable-output
+; RUN: opt < %s -memcpyopt -disable-output
; PR4882
target datalayout = "e-p:32:32:32-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"
-; RUN: opt %s -memcpyopt -S | not grep store
-; RUN: opt %s -memcpyopt -S | 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 -S | not grep store
-; RUN: opt %s -memcpyopt -S | 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 -S | 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 -S | 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 -S | 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 -S > %t
+; RUN: opt < %s -mergefunc -S > %t
; RUN: grep {define weak} %t | count 2
; RUN: grep {call} %t | count 2
-; RUN: opt %s -mergefunc -stats -disable-output |& not grep {functions merged}
+; RUN: opt < %s -mergefunc -stats -disable-output |& not grep {functions merged}
define i32 @foo1(i32 %x) {
entry:
-; RUN: opt %s -mergefunc -stats -disable-output |& grep {functions merged}
+; RUN: opt < %s -mergefunc -stats -disable-output |& grep {functions merged}
define i32 @foo1(i32 %x) {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define fastcc void @_ov_splice(i32 %n1, i32 %n2, i32 %ch2) {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define void @safe_strcpy(i32 %size1) {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define void @gs_image_next() {
entry:
-; RUN: opt %s -predsimplify -S | 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: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define void @readMotionInfoFromNAL() {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define i32 @test_wp_B_slice(i32 %select_method) {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define void @diff(i32 %N) {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
%struct.cube_struct = type { i32, i32, i32, i32*, i32*, i32*, i32*, i32*, i32*, i32*, i32**, i32**, i32*, i32*, i32, i32, i32*, i32, i32 }
@cube = external global %struct.cube_struct ; <%struct.cube_struct*> [#uses=2]
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
; END.
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
define void @ercMarkCurrMBConcealed(i32 %comp) {
entry:
-; RUN: opt %s -predsimplify -S | 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 -S | 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: opt %s -predsimplify -verify
+; RUN: opt < %s -predsimplify -verify
define void @dgefa() {
entry:
-; RUN: opt %s -predsimplify -verify
+; RUN: opt < %s -predsimplify -verify
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
deplibs = [ "c", "crtend" ]
-; RUN: opt %s -predsimplify -simplifycfg -S | grep pass
+; RUN: opt < %s -predsimplify -simplifycfg -S | grep pass
define void @regtest(i32 %x) {
entry:
-; RUN: opt %s -predsimplify -disable-output
+; RUN: opt < %s -predsimplify -disable-output
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
-; RUN: opt %s -prune-eh -S | grep invoke
+; RUN: opt < %s -prune-eh -S | grep invoke
declare void @External()
-; RUN: opt %s -prune-eh -disable-output
+; RUN: opt < %s -prune-eh -disable-output
define internal void @callee() {
ret void
-; RUN: opt %s -prune-eh -S | not grep nounwind
+; RUN: opt < %s -prune-eh -S | not grep nounwind
define weak void @f() {
entry:
-; RUN: opt %s -prune-eh -inline -print-callgraph \
+; RUN: opt < %s -prune-eh -inline -print-callgraph \
; RUN: -disable-output |& \
; RUN: grep {Calls.*ce3806g__fxio__put__put_int64__4.1339} | count 2
%struct.FRAME.ce3806g = type { %struct.string___XUB, %struct.string___XUB, %struct.string___XUB, %struct.string___XUB }
-; RUN: opt %s -prune-eh -S | not grep invoke
+; RUN: opt < %s -prune-eh -S | not grep invoke
define internal i32 @foo() {
invoke i32 @foo( )
-; RUN: opt %s -prune-eh -S | not grep {ret i32}
+; RUN: opt < %s -prune-eh -S | not grep {ret i32}
declare void @noreturn() noreturn;
-; RUN: opt %s -prune-eh -S | not grep invoke
+; RUN: opt < %s -prune-eh -S | not grep invoke
declare void @nounwind() nounwind
-; RUN: opt %s -raiseallocs -disable-output
+; RUN: opt < %s -raiseallocs -disable-output
define void @main() {
%tmp.13 = call i32 (...)* @free( i32 32 ) ; <i32> [#uses=1]
; This situation can occur due to the funcresolve pass.
;
-; RUN: opt %s -raiseallocs -S | not grep call
+; RUN: opt < %s -raiseallocs -S | not grep call
declare void @free(i8*)
-; RUN: opt %s -reassociate -instcombine -constprop -dce -S | 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]
; With sub reassociation, constant folding can eliminate all of the constants.
;
-; RUN: opt %s -reassociate -constprop -instcombine -dce -S | 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 -S | 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]
; The reassociate pass is not preserving dominance properties correctly
;
-; RUN: opt %s -reassociate
+; RUN: opt < %s -reassociate
define i32 @compute_dist(i32 %i, i32 %j) {
%reg119 = sub i32 %j, %i ; <i32> [#uses=1]
-; RUN: opt %s -reassociate -disable-output
+; RUN: opt < %s -reassociate -disable-output
define i32 @test(i32 %A.1, i32 %B.1, i32 %C.1, i32 %D.1) {
%tmp.16 = and i32 %A.1, %B.1 ; <i32> [#uses=1]
-; RUN: opt %s -reassociate -disable-output
+; RUN: opt < %s -reassociate -disable-output
define void @test(i32 %a, i32 %b, i32 %c, i32 %d) {
%tmp.2 = xor i32 %a, %b ; <i32> [#uses=1]
-; RUN: opt %s -reassociate -instcombine -S |\
+; RUN: opt < %s -reassociate -instcombine -S |\
; RUN: grep {ret i32 0}
define i32 @f(i32 %a0, i32 %a1, i32 %a2, i32 %a3, i32 %a4) {
-; RUN: opt %s -reassociate -disable-output
+; RUN: opt < %s -reassociate -disable-output
define void @foo() {
%tmp162 = fsub <4 x float> zeroinitializer, zeroinitializer ; <<4 x float>> [#uses=1]
; With reassociation, constant folding can eliminate the 12 and -12 constants.
;
-; RUN: opt %s -reassociate -constprop -instcombine -die -S | 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 -S | 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 -S | 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 -S | 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]
; 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 -S | 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]
-; RUN: opt %s -reassociate -instcombine -S |\
+; 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 -S | 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 -S | 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]
; With shl->mul reassociation, we can see that this is (shl A, 9) * A
;
-; RUN: opt %s -reassociate -instcombine -S |\
+; 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 -S | 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 -S | 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 -S | not grep loop
+; RUN: opt < %s -sccp -S | not grep loop
define i32* @test() {
bb1:
-; RUN: opt %s -sccp -S | 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 -S | 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 -S | \
+; RUN: opt < %s -sccp -simplifycfg -S | \
; RUN: grep ret
define void @old_main() {
-; RUN: opt %s -sccp -S | 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 -S | \
+; 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 -S | grep phi
+; RUN: opt < %s -sccp -S | grep phi
declare void @foo()
-; RUN: opt %s -sccp -disable-output
+; RUN: opt < %s -sccp -disable-output
declare i32 @foo()
-; RUN: opt %s -sccp -S | 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 -disable-output
+; RUN: opt < %s -sccp -disable-output
; END.
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin8.7.0"
; Test VectorType handling by SCCP.
; SCCP ignores VectorTypes until PR 1034 is fixed
;
-; RUN: opt %s -sccp
+; RUN: opt < %s -sccp
; END.
target datalayout = "E-p:32:32"
-; RUN: opt %s -sccp -S | \
+; RUN: opt < %s -sccp -S | \
; RUN: grep {ret i1 false}
define i1 @foo() {
-; RUN: opt %s -sccp -S | grep undef | count 1
+; RUN: opt < %s -sccp -S | grep undef | count 1
; PR1938
define i32 @main() {
-; RUN: opt %s -sccp -S | 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 -S | grep {ret i32 42}
-; RUN: opt %s -ipsccp -S | 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 -disable-output
+; RUN: opt < %s -sccp -disable-output
; PR4277
define i32 @main() nounwind {
-; RUN: opt %s -sccp -S | 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 -S | 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 -S | not grep phi
-; RUN: opt %s -sccp -S | 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 -S | not grep mul
-; RUN: opt %s -sccp -S | 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
-; RUN: opt %s -sccp -S | not grep %X
+; RUN: opt < %s -sccp -S | not grep %X
@G = global [1000000 x i10000] zeroinitializer
-; RUN: opt %s -ipsccp -S | 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 -S | grep -v {ret i101 0} | \
+; RUN: opt < %s -ipsccp -S | grep -v {ret i101 0} | \
; RUN: grep -v {ret i101 undef} | not grep ret
; This test makes sure that these instructions are properly constant propagated.
-; RUN: opt %s -ipsccp -S | not grep load
-; RUN: opt %s -ipsccp -S | not grep add
-; RUN: opt %s -ipsccp -S | 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 is a basic sanity check for constant propogation. The add instruction
; should be eliminated.
-; RUN: opt %s -sccp -S | 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 -ipsccp -S | \
+; 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 -S | \
+; 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 -S | not grep global
+; RUN: opt < %s -ipsccp -S | not grep global
@G = internal global i32 undef ; <i32*> [#uses=5]
-; RUN: opt %s -sccp -S | 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.
; This is the test case taken from appel's book that illustrates a hard case
; that SCCP gets right. BB3 should be completely eliminated.
;
-; RUN: opt %s -sccp -constprop -dce -simplifycfg | \
+; RUN: opt < %s -sccp -constprop -dce -simplifycfg | \
; RUN: llvm-dis | not grep BB3
define i32 @testfunction(i32 %i0, i32 %j0) {
-; RUN: opt %s -sretpromotion -disable-output
+; RUN: opt < %s -sretpromotion -disable-output
%struct.ObjPoint = type { double, double, double, double, double, double }
define void @RotatePoint(%struct.ObjPoint* sret %agg.result, %struct.ObjPoint* byval %a, double %rx, double %ry, double %rz) nounwind {
; 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 -S | 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 -S | grep sret
+; RUN: opt < %s -sretpromotion -S | grep sret
%struct.S = type <{ i32, i32 }>
-; RUN: opt %s -sretpromotion -S > %t
+; RUN: opt < %s -sretpromotion -S > %t
; RUN: cat %t | grep sret | count 1
; This function is promotable
-; RUN: opt %s -ssi-everything -disable-output
+; RUN: opt < %s -ssi-everything -disable-output
; PR4511
%"struct.std::_Vector_base<std::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >" = type { %"struct.std::_Vector_base<std::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >::_Vector_impl" }
-; RUN: opt %s -ssi-everything -disable-output
+; RUN: opt < %s -ssi-everything -disable-output
declare fastcc i32 @ras_Empty(i8** nocapture) nounwind readonly
-; RUN: opt %s -ssi-everything -disable-output
+; RUN: opt < %s -ssi-everything -disable-output
define void @test(i32 %x) {
entry:
-; RUN: opt %s -ssi-everything -disable-output
+; RUN: opt < %s -ssi-everything -disable-output
define void @foo() {
entry:
-; RUN: opt %s -ssi-everything -S | FileCheck %s
+; RUN: opt < %s -ssi-everything -S | FileCheck %s
declare void @use(i32)
declare i32 @create()
-; RUN: opt %s -scalarrepl -instcombine -S | not grep alloca
+; RUN: opt < %s -scalarrepl -instcombine -S | not grep alloca
; Test that an array is not incorrectly deconstructed.
-; RUN: opt %s -scalarrepl
+; RUN: opt < %s -scalarrepl
define void @main() {
%E = alloca { { i32, float, double, i64 }, { i32, float, double, i64 } } ; <{ { i32, float, double, i64 }, { i32, float, double, i64 } }*> [#uses=1]
-; RUN: opt %s -scalarrepl
+; RUN: opt < %s -scalarrepl
define i32 @test() {
%X = alloca { [4 x i32] } ; <{ [4 x i32] }*> [#uses=1]
; Scalar replacement was incorrectly promoting this alloca!!
;
-; RUN: opt %s -scalarrepl -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: sed {s/;.*//g} | grep {\\\[}
define i8* @test() {
-; RUN: opt %s -scalarrepl -S | 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 -disable-output
+; RUN: opt < %s -scalarrepl -disable-output
target datalayout = "E-p:32:32"
%struct.rtx_def = type { [2 x i8], i32, [1 x %union.rtunion_def] }
-; RUN: opt %s -scalarrepl -disable-output
+; RUN: opt < %s -scalarrepl -disable-output
target datalayout = "E-p:32:32"
-; RUN: opt %s -scalarrepl -disable-output
+; RUN: opt < %s -scalarrepl -disable-output
define void @output_toc() {
entry:
-; RUN: opt %s -scalarrepl -disable-output
+; RUN: opt < %s -scalarrepl -disable-output
; END.
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin8.7.2"
-; RUN: opt %s -scalarrepl -S | 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 -disable-output
+; RUN: opt < %s -scalarrepl -disable-output
; PR1045
target datalayout = "e-p:32:32"
-; RUN: opt %s -scalarrepl -disable-output
+; RUN: opt < %s -scalarrepl -disable-output
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:64"
target triple = "arm-apple-darwin8"
-; RUN: opt %s -scalarrepl -S | 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 -S | 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 -S | not grep shr
+; RUN: opt < %s -scalarrepl -S | not grep shr
%struct.S = type { i16 }
-; RUN: opt %s -scalarrepl -instcombine -S | 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 -S | 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 -S | 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 -S | 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 -S | 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 -S > %t
+; RUN: opt < %s -scalarrepl -S > %t
; RUN: cat %t | not grep alloca
%struct.two = type <{ < 2 x i8 >, i16 }>
-; RUN: opt %s -scalarrepl | llvm-dis
+; RUN: opt < %s -scalarrepl | llvm-dis
; PR3304
%struct.c37304a__vrec = type { i8, %struct.c37304a__vrec___disc___XVN }
-; RUN: opt %s -scalarrepl -instcombine -S | 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 -S | 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 -S | 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 -disable-output -stats |& grep "Number of aggregates converted to scalar"
+; RUN: opt < %s -scalarrepl -disable-output -stats |& grep "Number of aggregates converted to scalar"
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"
type { } ; type %0
-; RUN: opt %s -scalarrepl -S | 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 | llvm-dis
; rdar://6808691
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-darwin9.0"
-; RUN: opt %s -scalarrepl | llvm-dis
+; RUN: opt < %s -scalarrepl | llvm-dis
; PR4146
%wrapper = type { i1 }
-; RUN: opt %s -scalarrepl
+; RUN: opt < %s -scalarrepl
; PR4286
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"
-; RUN: opt %s -scalarrepl -disable-opt
+; RUN: opt < %s -scalarrepl -disable-opt
%struct.Item = type { [4 x i16], %struct.rule* }
%struct.rule = type { [4 x i16], i32, i32, i32, %struct.nonterminal*, %struct.pattern*, i8 }
-; RUN: opt %s -scalarrepl -S | \
+; 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 -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: not grep alloca
define i32 @testfunc(i32 %i, i8 %j) {
-; RUN: opt %s -scalarrepl -mem2reg -S | 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 -S | not grep alloca
+; RUN: opt < %s -scalarrepl -instcombine -S | not grep alloca
; PR3466
define i32 @test() {
-; RUN: opt %s -scalarrepl -mem2reg -S | 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 -S | not grep alloca
+; RUN: opt < %s -scalarrepl -S | not grep alloca
; rdar://6532315
%t = type { { i32, i16, i8, i8 } }
-; RUN: opt %s -scalarrepl -S | not grep alloca
+; RUN: opt < %s -scalarrepl -S | not grep alloca
; PR3290
;; Store of integer to whole alloca struct.
-; RUN: opt %s -scalarrepl -S | 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 -S > %t
+; RUN: opt < %s -scalarrepl -S > %t
; RUN: cat %t | not grep alloca
%struct.foo = type { i32, i32 }
-; RUN: opt %s -scalarrepl -S | 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 -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: not grep {call void @llvm.memcpy.i32}
-; RUN: opt %s -scalarrepl -S | grep getelementptr
+; RUN: opt < %s -scalarrepl -S | grep getelementptr
; END.
target datalayout = "E-p:32:32"
; PR1226
-; 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}
+; 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 -S | not grep alloca
-; RUN: opt %s -scalarrepl -S | not grep {7 x double}
-; RUN: opt %s -scalarrepl -instcombine -S | 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 -S | 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 -S | 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 | llvm-dis
; Make sure that SROA "scalar conversion" can handle first class aggregates.
define i64 @test({i32, i32} %A) {
-; RUN: opt %s -scalarrepl | llvm-dis
+; RUN: opt < %s -scalarrepl | llvm-dis
define i32 @test(i32 %X) {
%Arr = alloca [2 x i32] ; <[2 x i32]*> [#uses=3]
-; RUN: opt %s -scalarrepl -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: not grep alloca
-; RUN: opt %s -scalarrepl -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: grep {bitcast.*float.*i32}
define i32 @test(float %X) {
-; RUN: opt %s -scalarrepl -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: not grep alloca
-; RUN: opt %s -scalarrepl -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: grep bitcast
define <4 x i32> @test(<4 x float> %X) {
; PR892
-; RUN: opt %s -scalarrepl -S | \
+; RUN: opt < %s -scalarrepl -S | \
; RUN: not grep alloca
-; RUN: opt %s -scalarrepl -S | 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 -S > %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 -S | not grep alloca
-; RUN: opt %s -scalarrepl -S | 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 -S | grep {volatile load}
-; RUN: opt %s -scalarrepl -S | 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 -S | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: grep {br label}
;
;
; Which is not valid SSA
;
-; RUN: opt %s -simplifycfg | llvm-dis
+; RUN: opt < %s -simplifycfg | llvm-dis
define void @test() {
; <label>:0
-; RUN: opt %s -simplifycfg
+; RUN: opt < %s -simplifycfg
define i32 @test(i32 %A, i32 %B, i1 %cond) {
J:
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
define void @test(i32* %ldo, i1 %c, i1 %d) {
bb9:
; Do not remove the invoke!
;
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
define i32 @test() {
%A = invoke i32 @test( )
; Do not remove the invoke!
;
-; RUN: opt %s -simplifycfg -S | 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: not grep {br i1 %c2}
declare void @noop()
-; RUN: opt %s -simplifycfg -S | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: not grep switch
-; RUN: opt %s -simplifycfg -S | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: not grep switch
; Test normal folding
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
define void @symhash_add() {
entry:
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; PR584
@g_38098584 = external global i32 ; <i32*> [#uses=1]
@g_60187400 = external global i32 ; <i32*> [#uses=1]
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; END.
define void @main() {
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; END.
%arraytype.1.Char = type { i32, [0 x i8] }
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
define i1 @foo() {
%X = invoke i1 @foo( )
; Make sure this doesn't turn into an infinite loop
-; RUN: opt %s -simplifycfg -constprop -simplifycfg |\
+; RUN: opt < %s -simplifycfg -constprop -simplifycfg |\
; RUN: llvm-dis | grep bb86
; END.
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
define void @polnel_() {
entry:
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; END.
define void @main(i32 %c) {
-; RUN: opt %s -gvn -simplifycfg \
+; RUN: opt < %s -gvn -simplifycfg \
; RUN: -disable-output
; PR867
; END.
; PR957
-; RUN: opt %s -simplifycfg -S | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: not grep select
@G = extern_weak global i32
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; END.
%struct..4._102 = type { %struct.QVectorData* }
%struct..5._125 = type { %struct.QMapData* }
-; RUN: opt %s -simplifycfg | llvm-dis
+; RUN: opt < %s -simplifycfg | llvm-dis
; END.
; ModuleID = '2006-12-08-Ptr-ICmp-Branch.ll'
-; RUN: opt %s -simplifycfg -S | not grep invoke
+; RUN: opt < %s -simplifycfg -S | not grep invoke
declare i32 @func(i8*) nounwind
-;RUN: opt %s -simplifycfg -disable-output
+;RUN: opt < %s -simplifycfg -disable-output
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"
define i32 @bork() nounwind {
; The phi should not be eliminated in this case, because the fp op could trap.
-; RUN: opt %s -simplifycfg -S | 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 -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; rdar://5882392
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"
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; PR2256
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-mingw32"
-; RUN: opt %s -simplifycfg -S > %t
+; RUN: opt < %s -simplifycfg -S > %t
; RUN: not grep {^BB.tomerge} %t
; RUN grep {^BB.nomerge} %t | count 2
-; RUN: opt %s -simplifycfg -S | 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 -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; PR 2777
@g_103 = common global i32 0 ; <i32*> [#uses=1]
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; PR 2800
define void @foo() {
-; RUN: opt %s -simplifycfg
+; RUN: opt < %s -simplifycfg
; PR2855
define i32 @_Z1fPii(i32* %b, i32 %f) nounwind {
-; RUN: opt %s -simplifycfg | llvm-dis
+; RUN: opt < %s -simplifycfg | llvm-dis
define i32 @test() {
entry:
br label %T
-; RUN: opt %s -simplifycfg -S | 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
+; RUN: opt < %s -simplifycfg | llvm-dis
; PR3016
; Dead use caused invariant violation.
-; RUN: opt %s -simplifycfg -S | 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 -S | 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 -S | 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 -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
; END.
%struct..4._102 = type { %struct.QVectorData* }
%struct..5._125 = type { %struct.QMapData* }
-; RUN: opt %s -simplifycfg -S | \
+; RUN: opt < %s -simplifycfg -S | \
; RUN: not grep {br label}
define void @test(i1 %C) {
-; RUN: opt %s -simplifycfg -S | \
+; 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 -S | not grep N:
+; RUN: opt < %s -simplifycfg -S | not grep N:
;
define i32 @test(i1 %a) {
; If this test is successful, the function should be reduced to 'call; ret'
-; RUN: opt %s -simplifycfg -S | \
+; 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 -S | 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 -S | 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 -S > %t.xform
+; RUN: opt < %s -simplifycfg -S > %t.xform
; RUN: not grep phi %t.xform
; RUN: grep ret %t.xform
-; RUN: opt %s -simplifycfg -S | \
+; 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
; 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 -S | \
+; 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 -S | 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
-; RUN: opt %s -simplifycfg -S | 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 -instcombine \
+; RUN: opt < %s -simplifycfg -instcombine \
; RUN: -simplifycfg -S | not grep call
declare void @bar()
-; RUN: opt %s -simplifycfg -S | not grep call
+; RUN: opt < %s -simplifycfg -S | not grep call
declare void @bar()
-; RUN: opt %s -simplifycfg -S | 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 -S | \
+; RUN: opt < %s -simplifycfg -adce -S | \
; RUN: not grep {call void @f1}
; END.
-; RUN: opt %s -simplifycfg -S | 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 -S | not grep bb17
+; RUN: opt < %s -simplifycfg -S | not grep bb17
; PR1786
define i32 @main() {
-; RUN: opt %s -simplifycfg -S | grep unreachable
+; RUN: opt < %s -simplifycfg -S | grep unreachable
; PR1796
declare void @Finisher(i32) noreturn
-; RUN: opt %s -simplifycfg -disable-output
+; RUN: opt < %s -simplifycfg -disable-output
define void @NewExtractNames() {
entry:
-; RUN: opt %s -simplifycfg -S | \
+; 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 -S | grep {volatile load}
+; RUN: opt < %s -simplifycfg -S | grep {volatile load}
; PR2967
target datalayout =
-; RUN: opt %s -simplify-libcalls -disable-output
+; RUN: opt < %s -simplify-libcalls -disable-output
@G = constant [3 x i8] c"%s\00" ; <[3 x i8]*> [#uses=1]
; PR1307
-; RUN: opt %s -simplify-libcalls -instcombine -S > %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 -S | 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 -S > %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 -inline -simplify-libcalls -functionattrs | \
+; RUN: opt < %s -inline -simplify-libcalls -functionattrs | \
; RUN: llvm-dis | grep nocapture | count 2
; Check that nocapture attributes are added when run after an SCC pass.
; PR3520
-; RUN: opt %s -simplify-libcalls -S > %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 -S | grep {ret i32 -65}
+; RUN: opt < %s -simplify-libcalls -instcombine -S | grep {ret i32 -65}
; PR4284
define i32 @test() nounwind {
-; RUN: opt %s -simplify-libcalls -disable-output
+; RUN: opt < %s -simplify-libcalls -disable-output
; PR4641
%struct.__sFILE = 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, i8*, i32, [3 x i8], [1 x i8], %struct.__sbuf, i32, i64, %struct.pthread_mutex*, %struct.pthread*, i32, i32, %union.anon }
-; RUN: opt %s -simplify-libcalls -disable-output
+; RUN: opt < %s -simplify-libcalls -disable-output
; PR4645
define i32 @main() {
; Test that the ToAsciiOptimizer works correctly
-; RUN: opt %s -simplify-libcalls -S | \
+; 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -simplify-libcalls -S | \
; RUN: not grep call
declare i32 @isdigit(i32)
-; RUN: opt %s -constprop -instcombine -S | 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 -S | grep putchar
-; RUN: opt %s -simplify-libcalls -S | \
+; 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 -S | \
+; 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -simplify-libcalls -S | \
; RUN: not grep {call.*strcat}
-; RUN: opt %s -simplify-libcalls -S | \
+; 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 -S | \
+; 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 -S | \
+; 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 -S | \
+; 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -simplify-libcalls -S | \
; RUN: not grep {call.*strncat}
-; RUN: opt %s -simplify-libcalls -S | \
+; 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 -S | \
+; 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 -S | \
+; 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 -S | \
+; RUN: opt < %s -simplify-libcalls -S | \
; RUN: not grep {call.*toascii}
declare i32 @toascii(i32)
-; RUN: opt %s -simplify-libcalls -S | 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 -S | 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 -S > %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
; Test that the memcmpOptimizer works correctly
-; RUN: opt %s -simplify-libcalls -S | 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 -S | 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 -S | 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 -S | 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 -S | not grep {call .pow}
+; RUN: opt < %s -simplify-libcalls -S | not grep {call .pow}
declare double @pow(double, double)
-; RUN: opt %s -simplify-libcalls -S | FileCheck %s
+; RUN: opt < %s -simplify-libcalls -S | FileCheck %s
; PR4738
; SimplifyLibcalls shouldn't assume anything about weak symbols.
-; RUN: opt %s -tailcallelim -S | 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 -S | not grep call
+; RUN: opt < %s -tailcallelim -S | not grep call
define i32 @mul(i32 %x, i32 %y) {
entry:
-; RUN: opt %s -tailcallelim -S | \
+; RUN: opt < %s -tailcallelim -S | \
; RUN: grep {call i32 @foo}
declare void @bar(i32*)
-; RUN: opt %s -tailcallelim -S | 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 -S | not grep call
+; RUN: opt < %s -tailcallelim -S | not grep call
define i32 @Test(i32 %X) {
entry:
; 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 -S | not grep call
+; RUN: opt < %s -tailcallelim -S | not grep call
define i32 @aaa(i32 %c) {
entry:
-; RUN: opt %s -tailcallelim -S | \
+; RUN: opt < %s -tailcallelim -S | \
; RUN: grep {tail call void @foo}
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define void @motion_result7() {
entry:
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define i32 @sum() {
entry:
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define i32 @sell_haggle() {
entry:
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define i32 @foo() {
entry:
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define void @interpret() {
entry:
-; RUN: opt %s -tailduplicate | llc
+; RUN: opt < %s -tailduplicate | llc
; PR2323
define i32 @func_27(i32 %p_28) nounwind {
-; RUN: opt %s -tailduplicate -taildup-threshold=3 -stats -disable-output | not grep tailduplicate
+; RUN: opt < %s -tailduplicate -taildup-threshold=3 -stats -disable-output | not grep tailduplicate
; XFAIL: *
define i32 @foo(i32 %l) nounwind {
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
; PR4662
define void @a() {
-; RUN: opt %s -tailduplicate -taildup-threshold=2 -S | 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:
; This test checks to make sure phi nodes are updated properly
;
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define i32 @test(i1 %c, i32 %X, i32 %Y) {
br label %L
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
declare void @__main()
-; RUN: opt %s -tailduplicate -disable-output
+; RUN: opt < %s -tailduplicate -disable-output
define void @ab() {
entry:
-; RUN: opt %s -tailduplicate | \
+; RUN: opt < %s -tailduplicate | \
; RUN: llc -march=x86 -o %t
; RUN: grep {\\\<je\\\>} %t
; RUN: not grep jmp %t
projects / oota-llvm.git / commitdiff