; not a child of the loopentry.6 loop.
;
; RUN: opt < %s -analyze -loops | \
-; RUN: grep {^ Loop at depth 4 containing: %loopentry.7<header><latch><exiting>}
+; RUN: grep "^ Loop at depth 4 containing: %loopentry.7<header><latch><exiting>"
define void @getAndMoveToFrontDecode() {
br label %endif.2
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: -scalar-evolution-max-iterations=0 | grep {Loop %bb: backedge-taken count is 100}
+; RUN: -scalar-evolution-max-iterations=0 | grep "Loop %bb: backedge-taken count is 100"
; PR1533
@array = weak global [101 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=1]
-; RUN: opt < %s -scalar-evolution -analyze | grep {Loop %bb: backedge-taken count is (-1 + (-1 \\* %x) + %y)}
+; RUN: opt < %s -scalar-evolution -analyze | 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 \
-; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 13}
+; RUN: -scalar-evolution-max-iterations=0 | grep "backedge-taken count is 13"
; PR1706
define i32 @f() {
-; RUN: opt < %s -scalar-evolution -analyze | grep {Loop %header: backedge-taken count is (0 smax %n)}
+; RUN: opt < %s -scalar-evolution -analyze | grep "Loop %header: backedge-taken count is (0 smax %n)"
define void @foo(i32 %n) {
entry:
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 61}
+; RUN: -scalar-evolution-max-iterations=0 | grep "backedge-taken count is 61"
; PR2364
define i32 @func_6() nounwind {
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 113}
+; RUN: -scalar-evolution-max-iterations=0 | grep "backedge-taken count is 113"
; PR2088
define void @fun() {
; RUN: opt < %s -analyze -scalar-evolution |& \
-; RUN: grep {Loop %bb: backedge-taken count is (7 + (-1 \\* %argc))}
+; RUN: grep "Loop %bb: backedge-taken count is (7 + (-1 \* %argc))"
define i32 @main(i32 %argc, i8** %argv) nounwind {
entry:
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: | grep {Loop %bb: Unpredictable backedge-taken count\\.}
+; RUN: | grep "Loop %bb: Unpredictable backedge-taken count\."
; ScalarEvolution can't compute a trip count because it doesn't know if
; dividing by the stride will have a remainder. This could theoretically
-; RUN: opt < %s -analyze -scalar-evolution | grep {backedge-taken count is 255}
+; RUN: opt < %s -analyze -scalar-evolution | grep "backedge-taken count is 255"
define i32 @foo(i32 %x, i32 %y, i32* %lam, i32* %alp) nounwind {
bb1.thread:
-; RUN: opt < %s -analyze -scalar-evolution | grep {(trunc i} | not grep ext
+; RUN: opt < %s -analyze -scalar-evolution | grep "(trunc i" | not grep ext
define i16 @test1(i8 %x) {
%A = sext i8 %x to i32
-; RUN: opt < %s -analyze -scalar-evolution | grep {count is 2}
+; RUN: opt < %s -analyze -scalar-evolution | grep "count is 2"
; PR3171
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; RUN: opt < %s -scalar-evolution -analyze \
-; RUN: | grep {\\--> (zext} | count 2
+; RUN: | grep "\--> (zext" | count 2
define i32 @foo(i32 %x) {
%n = and i32 %x, 255
-; RUN: opt < %s -scalar-evolution -analyze | grep {Loop %bb3: backedge-taken count is (-1 + %n)}
+; RUN: opt < %s -scalar-evolution -analyze | 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 -scalar-evolution -analyze \
-; RUN: | grep {\\--> ((-128 \\* %a) /u -128)}
+; RUN: | grep "\--> ((-128 \* %a) /u -128)"
; Don't let ScalarEvolution fold this div away.
; RUN: opt < %s -analyze -scalar-evolution > %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: grep "sext i57 {0,+,199}<%bb> to i64" %t | count 1
+; RUN: grep "sext i59 {0,+,199}<%bb> to i64" %t | 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.6"
; RUN: opt < %s -scalar-evolution -analyze \
-; RUN: | grep { --> (sext i. \{.\*,+,.\*\}<%bb1> to i64)} | count 5
+; RUN: | grep " --> (sext i. {.*,+,.*}<%bb1> to i64)" | count 5
; Don't convert (sext {...,+,...}) to {sext(...),+,sext(...)} in cases
; where the trip count is not within range.
; RUN: opt < %s -analyze -scalar-evolution | grep smax | count 2
; RUN: opt < %s -analyze -scalar-evolution | grep \
-; RUN: {%. smax %. smax %.}
+; RUN: "%. smax %. smax %."
; PR1614
define i32 @x(i32 %a, i32 %b, i32 %c) {
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: -scalar-evolution-max-iterations=0 | grep {backedge-taken count is 10000}
+; RUN: -scalar-evolution-max-iterations=0 | grep "backedge-taken count is 10000"
; PR1101
@A = weak global [1000 x i32] zeroinitializer, align 32
; RUN: opt < %s -analyze -scalar-evolution | \
-; RUN: grep {backedge-taken count is 4}
+; RUN: grep "backedge-taken count is 4"
; PR1101
@A = weak global [1000 x i32] zeroinitializer, align 32
; RUN: opt < %s -scalar-evolution -analyze \
-; RUN: | grep {Loop %bb3\\.i: Unpredictable backedge-taken count\\.}
+; RUN: | grep "Loop %bb3\.i: Unpredictable backedge-taken count\."
; ScalarEvolution can't compute a trip count because it doesn't know if
; dividing by the stride will have a remainder. This could theoretically
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: | grep {sext.*trunc.*Exits: 11}
+; 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 > %t
; RUN: grep sext %t | count 2
-; RUN: not grep {(sext} %t
+; RUN: not grep "(sext" %t
; ScalarEvolution should be able to compute a maximum trip count
; value sufficient to fold away both sext casts.
; RUN: opt < %s -analyze -scalar-evolution \
-; RUN: | grep {max backedge-taken count is 1\$}
+; 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 \
-; RUN: | grep {Loop %bb7.i: Unpredictable backedge-taken count\\.}
+; 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 \
-; RUN: | grep {Loop %for\\.body: backedge-taken count is (-1 + \[%\]ecx)}
+; RUN: | grep "Loop %for\.body: backedge-taken count is (-1 + [%]ecx)"
; PR4599
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 -scalar-evolution -analyze \
-; RUN: | grep {\\--> (zext i4 (-8 + (trunc i64 (8 \\* %x) to i4)) to i64)}
+; RUN: | grep "\--> (zext i4 (-8 + (trunc i64 (8 \* %x) to i4)) to i64)"
; ScalarEvolution shouldn't try to analyze %z into something like
; --> (zext i4 (-1 + (-1 * (trunc i64 (8 * %x) to i4))) to i64)
-; RUN: llvm-as < %s | llvm-dis | not grep { bitcast (}
+; RUN: llvm-as < %s | llvm-dis | not grep " bitcast ("
@.Base64_1 = external constant [4 x i8] ; <[4 x i8]*> [#uses=1]
-; RUN: not llvm-as < %s |& grep {multiple definition}
+; RUN: not llvm-as < %s |& grep "multiple definition"
define void @test() {
%tmp.1 = add i32 0, 1
-; RUN: not llvm-as %s |& grep {found end of file when expecting more instructions}
+; RUN: not llvm-as %s |& grep "found end of file when expecting more instructions"
define void @foo() {
; Test for PR463. This program is erroneous, but should not crash llvm-as.
-; RUN: not llvm-as %s -o /dev/null |& grep {use of undefined type named 'struct.none'}
+; RUN: not llvm-as %s -o /dev/null |& grep "use of undefined type named 'struct.none'"
@.FOO = internal global %struct.none zeroinitializer
; The assembler should catch an undefined argument type .
-; RUN: not llvm-as %s -o /dev/null |& grep {use of undefined type named 'typedef.bc_struct'}
+; RUN: not llvm-as %s -o /dev/null |& grep "use of undefined type named 'typedef.bc_struct'"
; %typedef.bc_struct = type opaque
; PR1117
-; RUN: not llvm-as %s -o /dev/null |& grep {invalid cast opcode for cast from}
+; RUN: not llvm-as %s -o /dev/null |& grep "invalid cast opcode for cast from"
define i8* @nada(i64 %X) {
%result = trunc i64 %X to i8*
; PR1117
-; RUN: not llvm-as %s -o /dev/null |& grep {invalid cast opcode for cast from}
+; RUN: not llvm-as %s -o /dev/null |& grep "invalid cast opcode for cast from"
@X = constant i8* trunc (i64 0 to i8*)
; Test whether negative values > 64 bits retain their negativeness.
-; RUN: llvm-as < %s | llvm-dis | grep {add i65.*, -1}
+; RUN: llvm-as < %s | llvm-dis | grep "add i65.*, -1"
define i65 @testConsts(i65 %N) {
%a = add i65 %N, -1
-; RUN: llvm-as < %s | llvm-dis | grep {align 1024}
+; RUN: llvm-as < %s | llvm-dis | grep "align 1024"
define i32 @test(i32* %arg) {
entry:
-; RUN: llvm-as < %s | llvm-dis | grep {align 1024}
+; RUN: llvm-as < %s | llvm-dis | grep "align 1024"
define void @test(i32* %arg) {
entry:
-; RUN: llvm-as < %s | llvm-dis | grep {icmp.*test_weak.*null}
+; RUN: llvm-as < %s | llvm-dis | grep "icmp.*test_weak.*null"
; PR1358
@G = global i1 icmp ne (i32 (...)* @test_weak, i32 (...)* null)
-; RUN: llvm-as < %s | llvm-dis | grep {@f.*gc.*shadowstack}
-; RUN: llvm-as < %s | llvm-dis | grep {@g.*gc.*java}
+; RUN: llvm-as < %s | llvm-dis | grep "@f.*gc.*shadowstack"
+; RUN: llvm-as < %s | llvm-dis | grep "@g.*gc.*java"
define void @f() gc "shadowstack" {
entry:
-; RUN: llvm-as < %s | llvm-dis | grep {addrspace(33)} | count 7
-; RUN: llvm-as < %s | llvm-dis | grep {addrspace(42)} | count 2
-; RUN: llvm-as < %s | llvm-dis | grep {addrspace(66)} | count 2
-; RUN: llvm-as < %s | llvm-dis | grep {addrspace(11)} | count 6
-; RUN: llvm-as < %s | llvm-dis | grep {addrspace(22)} | count 5
+; RUN: llvm-as < %s | llvm-dis | grep "addrspace(33)" | count 7
+; RUN: llvm-as < %s | llvm-dis | grep "addrspace(42)" | count 2
+; RUN: llvm-as < %s | llvm-dis | grep "addrspace(66)" | count 2
+; RUN: llvm-as < %s | llvm-dis | grep "addrspace(11)" | count 6
+; RUN: llvm-as < %s | llvm-dis | grep "addrspace(22)" | count 5
%struct.mystruct = type { i32, i32 addrspace(33)*, i32, i32 addrspace(33)* }
@input = weak addrspace(42) global %struct.mystruct zeroinitializer ; <%struct.mystruct addrspace(42)*> [#uses=1]
-; RUN: not llvm-as %s |& grep {integer constant must have integer type}
+; RUN: not llvm-as %s |& grep "integer constant must have integer type"
; PR2060
define i8* @foo() {
; This test checks to make sure that constant exprs fold in some simple
; situations
-; RUN: llvm-as < %s | llvm-dis | not grep {(}
+; RUN: llvm-as < %s | llvm-dis | not grep "("
@A = global i64 0
-; RUN: llc < %s -march=arm | grep {swi 107}
+; RUN: llc < %s -march=arm | grep "swi 107"
define i32 @_swilseek(i32) nounwind {
entry:
; RUN: llc < %s -mtriple=arm-linux-gnueabi -o %t
-; RUN: grep { = } %t | count 5
+; RUN: grep " = " %t | count 5
; RUN: grep globl %t | count 4
; RUN: grep weak %t | count 1
-; RUN: llc < %s -march=arm | grep {bl.\*__ltdf} | count 1
+; RUN: llc < %s -march=arm | grep "bl.*__ltdf" | 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-darwin8"
-; RUN: llc < %s -march=arm | grep lsl | grep -F {lsl #2\]}
+; RUN: llc < %s -march=arm | grep lsl | grep -F "lsl #2]"
; Should use scaled addressing mode.
define void @sintzero(i32* %a) nounwind {
; RUN: llc < %s -march=arm | \
-; RUN: grep {str.*\\!} | count 2
+; RUN: grep "str.*\!" | count 2
define void @test1(i32* %X, i32* %A, i32** %dest) {
%B = load i32* %A ; <i32> [#uses=1]
; RUN: llc < %s -march=arm -mtriple=arm-linux-gnueabi | \
-; RUN: grep {__aeabi_read_tp}
+; RUN: grep "__aeabi_read_tp"
define i8* @test() {
entry:
; RUN: llc < %s -march=arm -mtriple=arm-linux-gnueabi | \
-; RUN: grep {i(tpoff)}
+; RUN: grep "i(tpoff)"
; RUN: llc < %s -march=arm -mtriple=arm-linux-gnueabi | \
-; RUN: grep {__aeabi_read_tp}
+; RUN: grep "__aeabi_read_tp"
; RUN: llc < %s -march=arm -mtriple=arm-linux-gnueabi \
-; RUN: -relocation-model=pic | grep {__tls_get_addr}
+; RUN: -relocation-model=pic | grep "__tls_get_addr"
@i = thread_local global i32 15 ; <i32*> [#uses=2]
; RUN: llc < %s -march=arm -mtriple=arm-linux-gnueabi | \
-; RUN: grep {tbss}
+; RUN: grep "tbss"
%struct.anon = type { i32, i32 }
@teste = internal thread_local global %struct.anon zeroinitializer ; <%struct.anon*> [#uses=1]
; RUN: llc < %s -march=cellspu > %t1.s
-; RUN: grep {shlh } %t1.s | count 10
-; RUN: grep {shlhi } %t1.s | count 3
-; RUN: grep {shl } %t1.s | count 10
-; RUN: grep {shli } %t1.s | count 3
-; RUN: grep {xshw } %t1.s | count 5
-; RUN: grep {and } %t1.s | count 15
-; RUN: grep {andi } %t1.s | count 4
-; RUN: grep {rotmi } %t1.s | count 4
-; RUN: grep {rotqmbyi } %t1.s | count 1
-; RUN: grep {rotqmbii } %t1.s | count 2
-; RUN: grep {rotqmby } %t1.s | count 1
-; RUN: grep {rotqmbi } %t1.s | count 2
-; RUN: grep {rotqbyi } %t1.s | count 1
-; RUN: grep {rotqbii } %t1.s | count 2
-; RUN: grep {rotqbybi } %t1.s | count 1
-; RUN: grep {sfi } %t1.s | count 6
+; RUN: grep "shlh " %t1.s | count 10
+; RUN: grep "shlhi " %t1.s | count 3
+; RUN: grep "shl " %t1.s | count 10
+; RUN: grep "shli " %t1.s | count 3
+; RUN: grep "xshw " %t1.s | count 5
+; RUN: grep "and " %t1.s | count 15
+; RUN: grep "andi " %t1.s | count 4
+; RUN: grep "rotmi " %t1.s | count 4
+; RUN: grep "rotqmbyi " %t1.s | count 1
+; RUN: grep "rotqmbii " %t1.s | count 2
+; RUN: grep "rotqmby " %t1.s | count 1
+; RUN: grep "rotqmbi " %t1.s | count 2
+; RUN: grep "rotqbyi " %t1.s | count 1
+; RUN: grep "rotqbii " %t1.s | count 2
+; RUN: grep "rotqbybi " %t1.s | count 1
+; RUN: grep "sfi " %t1.s | count 6
; RUN: cat %t1.s | FileCheck %s
target datalayout = "E-p:32:32:128-f64:64:128-f32:32:128-i64:32:128-i32:32:128-i16:16:128-i8:8:128-i1:8:128-a0:0:128-v128:128:128-s0:128:128"
; RUN: llc < %s -march=cellspu > %t1.s
-; RUN: grep {stqd.*0(\$3)} %t1.s | count 4
-; RUN: grep {stqd.*16(\$3)} %t1.s | count 4
+; RUN: grep 'stqd.*0($3)' %t1.s | count 4
+; RUN: grep 'stqd.*16($3)' %t1.s | count 4
; RUN: grep 16256 %t1.s | count 2
; RUN: grep 16384 %t1.s | count 1
; RUN: grep 771 %t1.s | count 4
; RUN: grep 1799 %t1.s | count 2
; RUN: grep 1543 %t1.s | count 5
; RUN: grep 1029 %t1.s | count 3
-; RUN: grep {shli.*, 4} %t1.s | count 4
+; RUN: grep 'shli.*, 4' %t1.s | count 4
; RUN: grep stqx %t1.s | count 4
; RUN: grep ilhu %t1.s | count 11
; RUN: grep iohl %t1.s | count 8
; RUN: llc < %s -march=cellspu > %t1.s
; RUN: grep shufb %t1.s | count 19
-; RUN: grep {ilhu.*1799} %t1.s | count 1
-; RUN: grep {ilhu.*771} %t1.s | count 2
-; RUN: grep {ilhu.*1543} %t1.s | count 1
-; RUN: grep {ilhu.*1029} %t1.s | count 1
-; RUN: grep {ilhu.*515} %t1.s | count 1
-; RUN: grep {ilhu.*3855} %t1.s | count 1
-; RUN: grep {ilhu.*3599} %t1.s | count 1
-; RUN: grep {ilhu.*3085} %t1.s | count 1
-; RUN: grep {iohl.*3855} %t1.s | count 1
-; RUN: grep {iohl.*3599} %t1.s | count 2
-; RUN: grep {iohl.*1543} %t1.s | count 2
-; RUN: grep {iohl.*771} %t1.s | count 2
-; RUN: grep {iohl.*515} %t1.s | count 1
-; RUN: grep {iohl.*1799} %t1.s | count 1
+; RUN: grep "ilhu.*1799" %t1.s | count 1
+; RUN: grep "ilhu.*771" %t1.s | count 2
+; RUN: grep "ilhu.*1543" %t1.s | count 1
+; RUN: grep "ilhu.*1029" %t1.s | count 1
+; RUN: grep "ilhu.*515" %t1.s | count 1
+; RUN: grep "ilhu.*3855" %t1.s | count 1
+; RUN: grep "ilhu.*3599" %t1.s | count 1
+; RUN: grep "ilhu.*3085" %t1.s | count 1
+; RUN: grep "iohl.*3855" %t1.s | count 1
+; RUN: grep "iohl.*3599" %t1.s | count 2
+; RUN: grep "iohl.*1543" %t1.s | count 2
+; RUN: grep "iohl.*771" %t1.s | count 2
+; RUN: grep "iohl.*515" %t1.s | count 1
+; RUN: grep "iohl.*1799" %t1.s | count 1
; RUN: grep lqa %t1.s | count 1
; RUN: grep cbd %t1.s | count 4
; RUN: grep chd %t1.s | count 3
; This function should have exactly one call to fixdfdi, no more!
; RUN: llc < %s -march=ppc32 -mattr=-64bit | \
-; RUN: grep {bl .*fixdfdi} | count 1
+; RUN: grep "bl .*fixdfdi" | count 1
define double @test2(double %tmp.7705) {
%mem_tmp.2.0.in = fptosi double %tmp.7705 to i64 ; <i64> [#uses=1]
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -mcpu=g5 | \
-; RUN: grep {vspltish v.*, 10}
+; RUN: grep "vspltish v.*, 10"
define void @test(<8 x i16>* %P) {
%tmp = load <8 x i16>* %P ; <<8 x i16>> [#uses=1]
-; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8.8.0 | grep {foo r3, r4}
-; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8.8.0 | grep {bari r3, 47}
+; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8.8.0 | grep "foo r3, r4"
+; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8.8.0 | grep "bari r3, 47"
; PR1351
target datalayout = "E-p:32:32:32-i1:8:8-i8:8:8-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: llc < %s -march=ppc32 | grep {rlwinm r3, r3, 23, 30, 30}
+; RUN: llc < %s -march=ppc32 | grep "rlwinm r3, r3, 23, 30, 30"
; PR1473
define zeroext i8 @foo(i16 zeroext %a) {
; RUN: llc < %s -march=ppc32 | \
-; RUN: not grep {stw r31, 20(r1)}
+; RUN: not grep "stw r31, 20(r1)"
; RUN: llc < %s -march=ppc32 | \
-; RUN: not grep {stwu r1, -.*(r1)}
+; RUN: not grep "stwu r1, -.*(r1)"
; RUN: llc < %s -march=ppc32 | \
-; RUN: not grep {addi r1, r1, }
+; RUN: not grep "addi r1, r1, "
; RUN: llc < %s -march=ppc32 | \
-; RUN: not grep {lwz r31, 20(r1)}
+; RUN: not grep "lwz r31, 20(r1)"
; RUN: llc < %s -march=ppc32 -disable-fp-elim | \
-; RUN: not grep {stw r31, 20(r1)}
+; RUN: not grep "stw r31, 20(r1)"
; RUN: llc < %s -march=ppc32 -disable-fp-elim | \
-; RUN: not grep {stwu r1, -.*(r1)}
+; RUN: not grep "stwu r1, -.*(r1)"
; RUN: llc < %s -march=ppc32 -disable-fp-elim | \
-; RUN: not grep {addi r1, r1, }
+; RUN: not grep "addi r1, r1, "
; RUN: llc < %s -march=ppc32 -disable-fp-elim | \
-; RUN: not grep {lwz r31, 20(r1)}
+; RUN: not grep "lwz r31, 20(r1)"
; RUN: llc < %s -march=ppc64 | \
-; RUN: not grep {std r31, 40(r1)}
+; RUN: not grep "std r31, 40(r1)"
; RUN: llc < %s -march=ppc64 | \
-; RUN: not grep {stdu r1, -.*(r1)}
+; RUN: not grep "stdu r1, -.*(r1)"
; RUN: llc < %s -march=ppc64 | \
-; RUN: not grep {addi r1, r1, }
+; RUN: not grep "addi r1, r1, "
; RUN: llc < %s -march=ppc64 | \
-; RUN: not grep {ld r31, 40(r1)}
+; RUN: not grep "ld r31, 40(r1)"
; RUN: llc < %s -march=ppc64 -disable-fp-elim | \
-; RUN: not grep {stw r31, 40(r1)}
+; RUN: not grep "stw r31, 40(r1)"
; RUN: llc < %s -march=ppc64 -disable-fp-elim | \
-; RUN: not grep {stdu r1, -.*(r1)}
+; RUN: not grep "stdu r1, -.*(r1)"
; RUN: llc < %s -march=ppc64 -disable-fp-elim | \
-; RUN: not grep {addi r1, r1, }
+; RUN: not grep "addi r1, r1, "
; RUN: llc < %s -march=ppc64 -disable-fp-elim | \
-; RUN: not grep {ld r31, 40(r1)}
+; RUN: not grep "ld r31, 40(r1)"
define i32* @f1() {
%tmp = alloca i32, i32 2 ; <i32*> [#uses=1]
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -o %t1
-; RUN: not grep {stw r31, -4(r1)} %t1
-; RUN: grep {stwu r1, -16448(r1)} %t1
-; RUN: grep {addi r1, r1, 16448} %t1
+; RUN: not grep "stw r31, -4(r1)" %t1
+; RUN: grep "stwu r1, -16448(r1)" %t1
+; RUN: grep "addi r1, r1, 16448" %t1
; RUN: llc < %s -march=ppc32 | \
-; RUN: not grep {lwz r31, -4(r1)}
+; RUN: not grep "lwz r31, -4(r1)"
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -disable-fp-elim \
; RUN: -o %t2
-; RUN: grep {stw r31, -4(r1)} %t2
-; RUN: grep {stwu r1, -16448(r1)} %t2
-; RUN: grep {addi r1, r1, 16448} %t2
-; RUN: grep {lwz r31, -4(r1)} %t2
+; RUN: grep "stw r31, -4(r1)" %t2
+; RUN: grep "stwu r1, -16448(r1)" %t2
+; RUN: grep "addi r1, r1, 16448" %t2
+; RUN: grep "lwz r31, -4(r1)" %t2
; RUN: llc < %s -march=ppc64 -mtriple=powerpc-apple-darwin8 -o %t3
-; RUN: not grep {std r31, -8(r1)} %t3
-; RUN: grep {stdu r1, -16496(r1)} %t3
-; RUN: grep {addi r1, r1, 16496} %t3
-; RUN: not grep {ld r31, -8(r1)} %t3
+; RUN: not grep "std r31, -8(r1)" %t3
+; RUN: grep "stdu r1, -16496(r1)" %t3
+; RUN: grep "addi r1, r1, 16496" %t3
+; RUN: not grep "ld r31, -8(r1)" %t3
; RUN: llc < %s -march=ppc64 -mtriple=powerpc-apple-darwin8 -disable-fp-elim \
; RUN: -o %t4
-; RUN: grep {std r31, -8(r1)} %t4
-; RUN: grep {stdu r1, -16512(r1)} %t4
-; RUN: grep {addi r1, r1, 16512} %t4
-; RUN: grep {ld r31, -8(r1)} %t4
+; RUN: grep "std r31, -8(r1)" %t4
+; RUN: grep "stdu r1, -16512(r1)" %t4
+; RUN: grep "addi r1, r1, 16512" %t4
+; RUN: grep "ld r31, -8(r1)" %t4
define i32* @f1() {
%tmp = alloca i32, i32 4095 ; <i32*> [#uses=1]
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin | \
-; RUN: grep {stw r4, 32751}
+; RUN: grep "stw r4, 32751"
; RUN: llc < %s -march=ppc64 -mtriple=powerpc-apple-darwin | \
-; RUN: grep {stw r4, 32751}
+; RUN: grep "stw r4, 32751"
; RUN: llc < %s -march=ppc64 -mtriple=powerpc-apple-darwin | \
-; RUN: grep {std r4, 9024}
+; RUN: grep "std r4, 9024"
define void @test() nounwind {
store i32 0, i32* inttoptr (i64 48725999 to i32*)
-; RUN: llc < %s -march=ppc32 | not grep {ori\\|lis}
+; RUN: llc < %s -march=ppc32 | not grep "ori\|lis"
; andi. r3, r3, 32769
define i32 @test(i32 %X) {
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-unknown-linux-gnu | \
-; RUN: grep {addc 4, 4, 6}
+; RUN: grep "addc 4, 4, 6"
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-unknown-linux-gnu | \
-; RUN: grep {adde 3, 3, 5}
+; RUN: grep "adde 3, 3, 5"
define i64 @foo(i64 %x, i64 %y) {
%z = add i64 %x, %y
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-unknown-linux-gnu | \
-; RUN: grep {addic 4, 4, 1}
+; RUN: grep "addic 4, 4, 1"
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-unknown-linux-gnu | \
-; RUN: grep {addze 3, 3}
+; RUN: grep "addze 3, 3"
declare i64 @foo()
; RUN: llc < %s -march=ppc32 | \
-; RUN: grep {b LBB.*} | count 4
+; RUN: grep "b LBB.*" | count 4
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin8.7.0"
; Test various forms of calls.
; RUN: llc < %s -march=ppc32 | \
-; RUN: grep {bl } | count 1
+; RUN: grep "bl " | count 1
; RUN: llc < %s -march=ppc32 | \
-; RUN: grep {bctrl} | count 1
+; RUN: grep "bctrl" | count 1
; RUN: llc < %s -march=ppc32 | \
-; RUN: grep {bla } | count 1
+; RUN: grep "bla " | count 1
declare void @foo()
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 | \
-; RUN: grep {cmpwi cr0, r3, -1}
+; RUN: grep "cmpwi cr0, r3, -1"
define i32 @test(i32 %x) nounwind {
%c = icmp eq i32 %x, -1
; RUN: llc < %s -march=ppc32 | \
; RUN: grep ori | count 3
; RUN: llc < %s -march=ppc32 | \
-; RUN: grep {li } | count 4
+; RUN: grep "li " | count 4
define i32 @f1() {
entry:
-; RUN: llc < %s | grep {foo bar":}
+; RUN: llc < %s | grep 'foo bar":'
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin8.2.0"
-; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin | grep {fabs f1, f1}
+; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin | grep "fabs f1, f1"
define double @fabs(double %f) {
entry:
; RUN: llc < %s -march=ppc32 -fp-contract=fast | \
-; RUN: egrep {fn?madd|fn?msub} | count 8
+; RUN: egrep "fn?madd|fn?msub" | count 8
define double @test_FMADD1(double %A, double %B, double %C) {
%D = fmul double %A, %B ; <double> [#uses=1]
; otherwise.
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -mattr=+fsqrt | \
-; RUN: grep {fsqrt f1, f1}
+; RUN: grep "fsqrt f1, f1"
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -mcpu=g5 | \
-; RUN: grep {fsqrt f1, f1}
+; RUN: grep "fsqrt f1, f1"
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -mattr=-fsqrt | \
-; RUN: not grep {fsqrt f1, f1}
+; RUN: not grep "fsqrt f1, f1"
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 -mcpu=g4 | \
-; RUN: not grep {fsqrt f1, f1}
+; RUN: not grep "fsqrt f1, f1"
declare double @llvm.sqrt.f64(double)
; RUN: llc < %s -march=ppc32 -stats |& \
-; RUN: grep {4 .*Number of machine instrs printed}
+; RUN: grep "4 .*Number of machine instrs printed"
;; Integer absolute value, should produce something as good as:
;; srawi r2, r3, 31
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 | \
-; RUN: grep {srwi r3, r3, 31}
+; RUN: grep "srwi r3, r3, 31"
define i32 @test1(i32 %X) {
entry:
-; RUN: llc < %s | grep {no_dead_strip.*_X}
+; RUN: llc < %s | grep "no_dead_strip.*_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"
target triple = "powerpc-apple-darwin8.8.0"
; RUN: llc < %s -march=ppc32 | grep mflr
; RUN: llc < %s -march=ppc32 | grep lwz
-; RUN: llc < %s -march=ppc64 | grep {ld r., 16(r1)}
+; RUN: llc < %s -march=ppc64 | grep "ld r., 16(r1)"
target triple = "powerpc-apple-darwin8"
; RUN: llc < %s -march=ppc32 -stats |& \
-; RUN: grep {Number of machine instrs printed} | grep 12
+; RUN: grep "Number of machine instrs printed" | grep 12
define i16 @Trans16Bit(i32 %srcA, i32 %srcB, i32 %alpha) {
%tmp1 = shl i32 %srcA, 15 ; <i32> [#uses=1]
; RUN: llc < %s -march=ppc32 -mtriple=powerpc-apple-darwin8 | \
-; RUN: grep {srwi r., r., 5}
+; RUN: grep "srwi r., r., 5"
define i32 @eq0(i32 %a) {
%tmp.1 = icmp eq i32 %a, 0 ; <i1> [#uses=1]
-; RUN: llc < %s -march=ppc32 | not grep {extsh\\|rlwinm}
+; RUN: llc < %s -march=ppc32 | not grep "extsh\|rlwinm"
declare signext i16 @foo()
-; RUN: llc -march=ppc32 < %s -o - | grep {__stack_chk_guard}
-; RUN: llc -march=ppc32 < %s -o - | grep {__stack_chk_fail}
+; RUN: llc -march=ppc32 < %s -o - | grep "__stack_chk_guard"
+; RUN: llc -march=ppc32 < %s -o - | grep "__stack_chk_fail"
@"\01LC" = internal constant [11 x i8] c"buf == %s\0A\00" ; <[11 x i8]*> [#uses=1]
-; RUN: llc < %s -march=ppc32 | grep {__trampoline_setup}
+; RUN: llc < %s -march=ppc32 | grep "__trampoline_setup"
module asm "\09.lazy_reference .objc_class_name_NSImageRep"
module asm "\09.objc_class_name_NSBitmapImageRep=0"
-; RUN: llc < %s -mtriple=thumbv6-apple-darwin10 | grep rsbs | grep {#0}
+; RUN: llc < %s -mtriple=thumbv6-apple-darwin10 | grep rsbs | grep "#0"
%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 }
%struct.__sFILEX = type opaque
; RUN: llc < %s -march=thumb -stats |& \
-; RUN: grep {4 .*Number of machine instrs printed}
+; RUN: grep "4 .*Number of machine instrs printed"
;; Integer absolute value, should produce something as good as:
;; Thumb:
; RUN: llc < %s -march=thumb -mattr=+thumb2 | \
-; RUN: grep {ldr.*\\!} | count 3
+; RUN: grep "ldr.*\!" | count 3
; RUN: llc < %s -march=thumb -mattr=+thumb2 | \
-; RUN: grep {ldrsb.*\\!} | count 1
+; RUN: grep "ldrsb.*\!" | count 1
define i32* @test1(i32* %X, i32* %dest) {
%Y = getelementptr i32* %X, i32 4 ; <i32*> [#uses=2]
; RUN: llc < %s -mtriple=thumbv7-linux-gnueabi | \
-; RUN: grep {i(tpoff)}
+; RUN: grep "i(tpoff)"
; RUN: llc < %s -mtriple=thumbv7-linux-gnueabi | \
-; RUN: grep {__aeabi_read_tp}
+; RUN: grep "__aeabi_read_tp"
; RUN: llc < %s -mtriple=thumbv7-linux-gnueabi \
-; RUN: -relocation-model=pic | grep {__tls_get_addr}
+; RUN: -relocation-model=pic | grep "__tls_get_addr"
@i = thread_local global i32 15 ; <i32*> [#uses=2]
-; RUN: llc < %s -march=x86 | grep {(%esp}
-; RUN: llc < %s -march=x86 | grep {pushl %ebp} | count 1
-; RUN: llc < %s -march=x86 | grep {popl %ebp} | count 1
+; RUN: llc < %s -march=x86 | grep "(%esp"
+; RUN: llc < %s -march=x86 | grep "pushl %ebp" | count 1
+; RUN: llc < %s -march=x86 | grep "popl %ebp" | count 1
declare i8* @llvm.returnaddress(i32)
; RUN: llc < %s -march=x86 -mtriple=i686-apple-darwin8 -relocation-model=static > %t
-; RUN: grep {movl _last} %t | count 1
-; RUN: grep {cmpl.*_last} %t | count 1
+; RUN: grep "movl _last" %t | count 1
+; RUN: grep "cmpl.*_last" %t | count 1
@block = external global i8* ; <i8**> [#uses=1]
@last = external global i32 ; <i32*> [#uses=3]
; RUN: llc < %s -march=x86 -mtriple=i386-linux-gnu -mcpu=penryn -mattr=+sse2 -stats -realign-stack=0 |&\
-; RUN: grep {asm-printer} | grep 35
+; RUN: grep "asm-printer" | grep 35
target datalayout = "e-p:32:32"
define void @foo(i32* %mc, i32* %bp, i32* %ms, i32* %xmb, i32* %mpp, i32* %tpmm, i32* %ip, i32* %tpim, i32* %dpp, i32* %tpdm, i32* %bpi, i32 %M) nounwind {
; PR850
; RUN: llc < %s -march=x86 -x86-asm-syntax=att > %t
-; RUN: grep {movl 4(%eax),%ebp} %t
-; RUN: grep {movl 0(%eax), %ebx} %t
+; RUN: grep "movl 4(%eax),%ebp" %t
+; RUN: grep "movl 0(%eax), %ebx" %t
define i32 @foo(i32 %__s.i.i, i32 %tmp5.i.i, i32 %tmp6.i.i, i32 %tmp7.i.i, i32 %tmp8.i.i) {
%tmp9.i.i = call i32 asm sideeffect "push %ebp\0Apush %ebx\0Amovl 4($2),%ebp\0Amovl 0($2), %ebx\0Amovl $1,%eax\0Aint $$0x80\0Apop %ebx\0Apop %ebp", "={ax},i,0,{cx},{dx},{si},{di}"( i32 192, i32 %__s.i.i, i32 %tmp5.i.i, i32 %tmp6.i.i, i32 %tmp7.i.i, i32 %tmp8.i.i ) ; <i32> [#uses=1]
; RUN: llc < %s -march=x86-64 > %t
; RUN: grep movb %t | count 2
-; RUN: grep {movzb\[wl\]} %t
+; RUN: grep "movzb[wl]" %t
define void @handle_vector_size_attribute() nounwind {
; RUN: llc < %s -march=x86-64 > %t
-; RUN: not grep {,%rsp)} %t
+; RUN: not grep ",%rsp)" %t
; PR1103
target datalayout = "e-p:64:64"
-; RUN: llc < %s -march=x86 | grep {mov %gs:72, %eax}
+; RUN: llc < %s -march=x86 | grep "mov %gs:72, %eax"
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin9"
; RUN: llc < %s -mcpu=yonah -march=x86 | \
-; RUN: grep {cmpltsd %xmm0, %xmm0}
+; RUN: grep "cmpltsd %xmm0, %xmm0"
target datalayout = "e-p:32:32"
target triple = "i686-apple-darwin9"
-; RUN: llc < %s -march=x86 | grep {movsbl}
+; RUN: llc < %s -march=x86 | grep "movsbl"
@X = global i32 0 ; <i32*> [#uses=1]
-; RUN: llc < %s -relocation-model=static | grep {foo str$}
+; RUN: llc < %s -relocation-model=static | grep "foo str$"
; PR1761
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"
-; RUN: llc < %s -march=x86 -mcpu=generic | grep {(%esp)} | count 2
+; RUN: llc < %s -march=x86 -mcpu=generic | grep "(%esp)" | count 2
; PR1872
%struct.c34007g__designated___XUB = type { i32, i32, i32, i32 }
-; RUN: llc < %s -march=x86 -mcpu=yonah -stats |& grep {Number of block tails merged} | grep 16
+; RUN: llc < %s -march=x86 -mcpu=yonah -stats |& grep "Number of block tails merged" | grep 16
; PR1909
@.str = internal constant [48 x i8] c"transformed bounds: (%.2f, %.2f), (%.2f, %.2f)\0A\00" ; <[48 x i8]*> [#uses=1]
-; RUN: llc < %s -mtriple=i386-apple-darwin | grep xorl | grep {%e}
+; RUN: llc < %s -mtriple=i386-apple-darwin | grep xorl | grep "%e"
; Make sure xorl operands are 32-bit registers.
%struct.tm = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8* }
-; RUN: llc -march=x86-64 < %s -o - | grep {cmpl \\$\[1\], %}
+; RUN: llc -march=x86-64 < %s -o - | grep "cmpl \$[1], %"
@.str = internal constant [4 x i8] c"%d\0A\00"
-; RUN: llc < %s -march=x86 -relocation-model=static | grep {lea.*X.*esp} | count 2
+; RUN: llc < %s -march=x86 -relocation-model=static | grep "lea.*X.*esp" | count 2
@X = external global [0 x i32]
-; RUN: llc < %s -march=x86 | grep {mov.*56}
+; RUN: llc < %s -march=x86 | grep "mov.*56"
; PR3449
define void @test(<8 x double>* %P, i64* %Q) nounwind {
-; RUN: llc < %s -march=x86-64 -mattr=+sse3,+sse41 -mcpu=penryn -stats |& grep {8 machine-licm}
+; RUN: llc < %s -march=x86-64 -mattr=+sse3,+sse41 -mcpu=penryn -stats |& grep "8 machine-licm"
; RUN: llc < %s -march=x86-64 -mattr=+sse3,+sse41 -mcpu=penryn | FileCheck %s
; rdar://6627786
; rdar://7792037
; RUN: llc < %s -march=x86-64 -mtriple=x86_64-linux-gnu -regalloc=fast -optimize-regalloc=0 -relocation-model=pic > %t2
-; RUN: grep {leaq.*TLSGD} %t2
-; RUN: grep {__tls_get_addr} %t2
+; RUN: grep "leaq.*TLSGD" %t2
+; RUN: grep "__tls_get_addr" %t2
; PR4004
@i = thread_local global i32 15
-; RUN: llc < %s | grep {movl.*%ebx, 8(%esi)}
+; RUN: llc < %s | grep "movl.*%ebx, 8(%esi)"
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16: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.0"
-; RUN: llc < %s -mtriple=x86_64-appel-darwin -disable-cgp-branch-opts -stats |& grep {machine-sink}
+; RUN: llc < %s -mtriple=x86_64-appel-darwin -disable-cgp-branch-opts -stats |& grep "machine-sink"
define fastcc void @t() nounwind ssp {
entry:
-; RUN: llc %s -o - | grep {__TEXT,__const}
+; RUN: llc %s -o - | grep "__TEXT,__const"
; PR5929
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
target triple = "i386-apple-darwin10.0"
; RUN: llc < %s -march=x86
-; RUN: llc < %s -mtriple=i386-apple-darwin10 | grep {array,16512,7}
-; RUN: llc < %s -mtriple=i386-apple-darwin9 | grep {array,16512,7}
+; RUN: llc < %s -mtriple=i386-apple-darwin10 | grep "array,16512,7"
+; RUN: llc < %s -mtriple=i386-apple-darwin9 | grep "array,16512,7"
; Darwin 9+ should get alignment on common symbols.
@array = common global [4128 x i32] zeroinitializer, align 128
; Use a subtarget that has post-RA scheduling enabled because the anti-dependency
; breaker requires liveness information to be kept.
; RUN: llc < %s -march=x86-64 -mcpu=atom -post-RA-scheduler -pre-RA-sched=list-burr -break-anti-dependencies=none > %t
-; RUN: grep {%xmm0} %t | count 14
-; RUN: not grep {%xmm1} %t
+; RUN: grep "%xmm0" %t | count 14
+; RUN: not grep "%xmm1" %t
; RUN: llc < %s -march=x86-64 -mcpu=atom -post-RA-scheduler -break-anti-dependencies=critical > %t
-; RUN: grep {%xmm0} %t | count 7
-; RUN: grep {%xmm1} %t | count 7
+; RUN: grep "%xmm0" %t | count 7
+; RUN: grep "%xmm1" %t | count 7
define void @goo(double* %r, double* %p, double* %q) nounwind {
entry:
-; RUN: llc < %s -mtriple=i386-apple-darwin -relocation-model=static | grep {call.*12345678}
-; RUN: llc < %s -mtriple=i386-apple-darwin -relocation-model=pic | not grep {call.*12345678}
-; RUN: llc < %s -mtriple=i386-pc-linux -relocation-model=dynamic-no-pic | grep {call.*12345678}
+; RUN: llc < %s -mtriple=i386-apple-darwin -relocation-model=static | grep "call.*12345678"
+; RUN: llc < %s -mtriple=i386-apple-darwin -relocation-model=pic | not grep "call.*12345678"
+; RUN: llc < %s -mtriple=i386-pc-linux -relocation-model=dynamic-no-pic | grep "call.*12345678"
; Call to immediate is not safe on x86-64 unless we *know* that the
; call will be within 32-bits pcrel from the dest immediate.
-; RUN: llc < %s -march=x86-64 | grep {call.*\\*%rax}
+; RUN: llc < %s -march=x86-64 | grep "call.*\*%rax"
; PR3666
; PR3773
-; RUN: llc < %s | grep {movl %esp, %ebp}
+; RUN: llc < %s | grep "movl %esp, %ebp"
; PR4572
; Don't coalesce with %esp if it would end up putting %esp in
; RUN: llc < %s -mcpu=generic -march=x86 | not grep lea
-; RUN: llc < %s -mcpu=generic -march=x86 | grep {movl %ebp}
+; RUN: llc < %s -mcpu=generic -march=x86 | grep "movl %ebp"
declare void @bar(<2 x i64>* %n)
; RUN: llc < %s -march=x86 -mcpu=penryn > %t
; RUN: not grep movd %t
-; RUN: grep {movss %xmm} %t | count 1
-; RUN: grep {extractps \\\$1, %xmm0, } %t | count 1
+; RUN: grep "movss %xmm" %t | count 1
+; RUN: grep "extractps \$1, %xmm0, " %t | count 1
; PR2647
external global float, align 16 ; <float*>:0 [#uses=2]
; RUN: llc < %s -mcpu=generic -march=x86 -x86-asm-syntax=intel | \
-; RUN: grep {add ESP, 8}
+; RUN: grep "add ESP, 8"
target triple = "i686-pc-linux-gnu"
-; RUN: llc < %s -fast-isel | grep {LCPI0_0(%rip)}
+; RUN: llc < %s -fast-isel | grep "LCPI0_0(%rip)"
; Make sure fast isel uses rip-relative addressing when required.
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.0"
-; RUN: llc < %s -fast-isel | grep {_kill@GOTPCREL(%rip)}
+; RUN: llc < %s -fast-isel | grep "_kill@GOTPCREL(%rip)"
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-apple-darwin10.0"
@f = global i8 (...)* @kill ; <i8 (...)**> [#uses=1]
-; RUN: llc < %s -tailcallopt=false | grep {movl\[\[:space:\]\]*8(%esp), %eax} | count 2
+; RUN: llc < %s -tailcallopt=false | grep "movl[[:space:]]*8(%esp), %eax" | count 2
; PR3122
; rdar://6400815
;; Test that this FP immediate is stored in the constant pool as a float.
; RUN: llc < %s -march=x86 -mattr=-sse2,-sse3 | \
-; RUN: grep {.long.1123418112}
+; RUN: grep ".long.1123418112"
define double @D() {
ret double 1.230000e+02
; RUN: llc < %s -march=x86 -x86-asm-syntax=intel | \
-; RUN: grep -i ST | not grep {fadd\\|fsub\\|fdiv\\|fmul}
+; RUN: grep -i ST | not grep "fadd\|fsub\|fdiv\|fmul"
; Test that the load of the memory location is folded into the operation.
; RUN: llc < %s -march=x86 >%t
-; RUN: grep {addl \\\$4,} %t | count 3
-; RUN: not grep {,%} %t
+; RUN: grep "addl \$4," %t | count 3
+; RUN: not grep ",%" %t
define void @foo(float* nocapture %A, float* nocapture %B, float* nocapture %C, i32 %N) nounwind {
entry:
-; RUN: llc < %s -march=x86 | grep {movzbl %\[abcd\]h,} | count 7
+; RUN: llc < %s -march=x86 | grep "movzbl %[abcd]h," | count 7
; Use h-register extract and zero-extend.
-; RUN: llc < %s -march=x86-64 | grep {movzbl %\[abcd\]h,} | count 7
+; RUN: llc < %s -march=x86-64 | grep "movzbl %[abcd]h," | count 7
; Use h-register extract and zero-extend.
; RUN: llc < %s -mtriple=x86_64-linux > %t
-; RUN: grep {movzbl %\[abcd\]h,} %t | count 8
-; RUN: grep {%\[abcd\]h} %t | not grep {%r\[\[:digit:\]\]*d}
+; RUN: grep "movzbl %[abcd]h," %t | count 8
+; RUN: grep "%[abcd]h" %t | not grep "%r[[:digit:]]*d"
; LLVM creates virtual registers for values live across blocks
; based on the type of the value. Make sure that the extracts
-; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep {mulpd %xmm3, %xmm1}
-; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep {mulpd %xmm2, %xmm0}
-; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep {addps %xmm3, %xmm1}
-; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep {addps %xmm2, %xmm0}
+; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep "mulpd %xmm3, %xmm1"
+; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep "mulpd %xmm2, %xmm0"
+; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep "addps %xmm3, %xmm1"
+; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=nehalem | grep "addps %xmm2, %xmm0"
define <4 x double> @foo(<4 x double> %x, <4 x double> %z) {
%y = fmul <4 x double> %x, %z
-; RUN: llc < %s -march=x86 | grep { 37}
+; RUN: llc < %s -march=x86 | grep " 37"
; rdar://7008959
define void @bork() nounwind {
; RUN: llc < %s -march=x86 > %t
-; RUN: grep {movb.7(%...)} %t
+; RUN: grep "movb.7(%...)" %t
; RUN: not grep leal %t
define i8 @test(i32 *%P) nounwind {
-; RUN: llc < %s -march=x86 | grep {shrl.*31}
+; RUN: llc < %s -march=x86 | grep "shrl.*31"
define i32 @test1(i32 %X) {
entry:
; PR7054
-; RUN: not llc %s -o - |& grep {'_foo' label emitted multiple times to assembly}
+; RUN: not llc %s -o - |& grep "'_foo' label emitted multiple times to assembly"
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
target triple = "i386-apple-darwin10.0.0"
; RUN: llc < %s -march=x86 -x86-asm-syntax=intel | \
-; RUN: grep {lea EAX, DWORD PTR \\\[... + 4\\*... - 5\\\]}
+; RUN: grep "lea EAX, DWORD PTR \[... + 4\*... - 5\]"
; RUN: llc < %s -march=x86 -x86-asm-syntax=intel | \
; RUN: not grep add
-; RUN: llc < %s -march=x86-64 | grep {xorps %xmm0, %xmm0} | count 2
+; RUN: llc < %s -march=x86-64 | grep "xorps %xmm0, %xmm0" | count 2
define float @foo(<4 x float> %a) {
%b = insertelement <4 x float> %a, float 0.0, i32 3
-; RUN: llc < %s -march=x86 -stats |& grep {Number of blocks eliminated} | grep 6
+; RUN: llc < %s -march=x86 -stats |& grep "Number of blocks eliminated" | grep 6
; PR1296
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-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: llc < %s -march=x86 -mattr=+sse2 | grep {xorps.\*sp} | count 1
+; RUN: llc < %s -march=x86 -mattr=+sse2 | grep "xorps.*sp" | count 1
; PR2656
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16: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: llc < %s -march=x86 -x86-asm-syntax=intel | \
-; RUN: grep {ro\[rl\]} | count 12
+; RUN: grep "ro[rl]" | count 12
define i32 @rotl32(i32 %A, i8 %Amt) {
%shift.upgrd.1 = zext i8 %Amt to i32 ; <i32> [#uses=1]
; RUN: llc < %s -march=x86 -x86-asm-syntax=intel | \
-; RUN: grep {shld.*CL}
+; RUN: grep "shld.*CL"
; RUN: llc < %s -march=x86 -x86-asm-syntax=intel | \
-; RUN: not grep {mov CL, BL}
+; RUN: not grep "mov CL, BL"
; PR687
; RUN: llc < %s -march=x86 -x86-asm-syntax=intel | \
-; RUN: grep {sh\[lr\]d} | count 5
+; RUN: grep "sh[lr]d" | count 5
define i64 @test1(i64 %X, i8 %C) {
%shift.upgrd.1 = zext i8 %C to i64 ; <i64> [#uses=1]
-; RUN: llc < %s -march=x86 | grep {movl 8(.esp), %eax}
-; RUN: llc < %s -march=x86 | grep {shrl .eax}
-; RUN: llc < %s -march=x86 | grep {movswl .ax, .eax}
+; RUN: llc < %s -march=x86 | grep "movl 8(.esp), %eax"
+; RUN: llc < %s -march=x86 | grep "shrl .eax"
+; RUN: llc < %s -march=x86 | grep "movswl .ax, .eax"
define i32 @test1(i64 %a) nounwind {
%tmp29 = lshr i64 %a, 24 ; <i64> [#uses=1]
; RUN: llc -mtriple=i386-pc-linux-gnu < %s -o - | grep %gs:
; RUN: llc -mtriple=x86_64-pc-linux-gnu < %s -o - | grep %fs:
; RUN: llc -code-model=kernel -mtriple=x86_64-pc-linux-gnu < %s -o - | grep %gs:
-; RUN: llc -mtriple=x86_64-apple-darwin < %s -o - | grep {__stack_chk_guard}
-; RUN: llc -mtriple=x86_64-apple-darwin < %s -o - | grep {__stack_chk_fail}
+; RUN: llc -mtriple=x86_64-apple-darwin < %s -o - | grep "__stack_chk_guard"
+; RUN: llc -mtriple=x86_64-apple-darwin < %s -o - | grep "__stack_chk_fail"
@"\01LC" = internal constant [11 x i8] c"buf == %s\0A\00" ; <[11 x i8]*> [#uses=1]
-; RUN: llc < %s -march=x86-64 | grep {leal .*), %e.\*} | count 1
+; RUN: llc < %s -march=x86-64 | grep "leal .*), %e.*" | count 1
; Don't eliminate or coalesce away the explicit zero-extension!
; This is currently using an leal because of a 3-addressification detail,
; RUN: llc < %s -march=x86 -tailcallopt | grep TAILCALL
-; RUN: llc < %s -march=x86 -tailcallopt | grep {movl\[\[:space:\]\]*4(%esp), %eax} | count 1
+; RUN: llc < %s -march=x86 -tailcallopt | grep "movl[[:space:]]*4(%esp), %eax" | count 1
%struct.s = type {i32, i32, i32, i32, i32, i32, i32, i32,
i32, i32, i32, i32, i32, i32, i32, i32,
i32, i32, i32, i32, i32, i32, i32, i32 }
; RUN: llc < %s -march=x86 -mattr=+sse2 -mcpu=penryn -stats |& \
-; RUN: grep {twoaddrinstr} | grep {Number of instructions aggressively commuted}
+; RUN: grep "twoaddrinstr" | grep "Number of instructions aggressively commuted"
; rdar://6480363
target triple = "i386-apple-darwin9.6"
-; RUN: llc < %s -march=x86 -mattr=+sse2 -stats |& grep {Number of 3-address instructions sunk}
+; RUN: llc < %s -march=x86 -mattr=+sse2 -stats |& grep "Number of 3-address instructions sunk"
define void @t2(<2 x i64>* %vDct, <2 x i64>* %vYp, i8* %skiplist, <2 x i64> %a1) nounwind {
entry:
; RUN: llc < %s -mcpu=generic -march=x86 -mattr=+sse2 -mtriple=i686-apple-darwin8 | \
-; RUN: grep {subl.*60}
+; RUN: grep "subl.*60"
; RUN: llc < %s -mcpu=generic -march=x86 -mattr=+sse2 -mtriple=i686-apple-darwin8 | \
-; RUN: grep {movaps.*32}
+; RUN: grep "movaps.*32"
define void @test() {
-; RUN: llc < %s -march=x86 -mcpu=yonah | grep {(%esp,%eax,4)} | count 4
+; RUN: llc < %s -march=x86 -mcpu=yonah | grep "(%esp,%eax,4)" | count 4
; Inserts and extracts with variable indices must be lowered
; to memory accesses.
; RUN: llc < %s -march=x86-64 | grep movd | count 1
-; RUN: llc < %s -march=x86-64 | grep {movlhps.*%xmm0, %xmm0}
+; RUN: llc < %s -march=x86-64 | grep "movlhps.*%xmm0, %xmm0"
define <2 x i64> @test3(i64 %A) nounwind {
entry:
-; RUN: llc < %s | grep {movl %edi, %eax}
+; RUN: llc < %s | grep "movl %edi, %eax"
; The input value is already sign extended, don't re-extend it.
; This testcase corresponds to:
; int test(short X) { return (int)X; }
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {callq f@PLT} %t1
+; RUN: grep "callq f@PLT" %t1
define void @g() {
entry:
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {callq g@PLT} %t1
+; RUN: grep "callq g@PLT" %t1
@g = alias weak i32 ()* @f
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {callq __fixunsxfti@PLT} %t1
+; RUN: grep "callq __fixunsxfti@PLT" %t1
define i128 @f(x86_fp80 %a) nounwind {
entry:
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {callq f} %t1
-; RUN: not grep {callq f@PLT} %t1
+; RUN: grep "callq f" %t1
+; RUN: not grep "callq f@PLT" %t1
define void @g() {
entry:
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {callq f} %t1
-; RUN: not grep {callq f@PLT} %t1
+; RUN: grep "callq f" %t1
+; RUN: not grep "callq f@PLT" %t1
define void @g() {
entry:
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {movq a@GOTPCREL(%rip),} %t1
+; RUN: grep "movq a@GOTPCREL(%rip)," %t1
@a = global i32 0
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {movl a(%rip),} %t1
+; RUN: grep "movl a(%rip)," %t1
; RUN: not grep GOTPCREL %t1
@a = hidden global i32 0
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {movl a(%rip),} %t1
+; RUN: grep "movl a(%rip)," %t1
; RUN: not grep GOTPCREL %t1
@a = internal global i32 0
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {movq f@GOTPCREL(%rip),} %t1
+; RUN: grep "movq f@GOTPCREL(%rip)," %t1
define void ()* @g() nounwind {
entry:
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {leaq f(%rip),} %t1
+; RUN: grep "leaq f(%rip)," %t1
; RUN: not grep GOTPCREL %t1
define void ()* @g() {
; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic -o %t1
-; RUN: grep {leaq f(%rip),} %t1
+; RUN: grep "leaq f(%rip)," %t1
; RUN: not grep GOTPCREL %t1
define void ()* @g() nounwind {
-; RUN: not llvm-as %s -o /dev/null |& grep {redefinition of global '@B'}
+; RUN: not llvm-as %s -o /dev/null |& grep "redefinition of global '@B'"
@B = global i32 7
@B = global i32 7
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
; RUN: not grep cast %t2.ll
-; RUN: grep {\\}>} %t2.ll
+; RUN: grep "}>" %t2.ll
; END.
%struct.anon = type <{ i8, i32, i32, i32 }>
-; RUN: llvm-as < %s | llvm-dis | not grep {ret.*(}
+; RUN: llvm-as < %s | llvm-dis | not grep "ret.*("
; All of these constant expressions should fold.
; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
; RUN: diff %t1.ll %t2.ll
; RUN: not grep cast %t2.ll
-; RUN: grep {\\}>} %t2.ll
+; RUN: grep "}>" %t2.ll
; END.
%struct.anon = type <{ i8, i35, i35, i35 }>
; This fails because the linker renames the external symbol not the internal
; one...
-; RUN: echo {define internal i32 @foo() \{ ret i32 7 \} } | llvm-as > %t.1.bc
+; RUN: echo "define internal i32 @foo() { ret i32 7 } " | llvm-as > %t.1.bc
; RUN: llvm-as %s -o %t.2.bc
-; RUN: llvm-link %t.1.bc %t.2.bc -S | grep {@foo()} | grep -v internal
+; RUN: llvm-link %t.1.bc %t.2.bc -S | grep "@foo()" | grep -v internal
define i32 @foo() { ret i32 0 }
; This fails because the linker renames the non-opaque type not the opaque
; one...
-; RUN: echo {%%Ty = type opaque @GV = external global %%Ty*} | llvm-as > %t.1.bc
+; RUN: echo "%%Ty = type opaque @GV = external global %%Ty*" | llvm-as > %t.1.bc
; RUN: llvm-as < %s > %t.2.bc
-; RUN: llvm-link %t.1.bc %t.2.bc -S | grep {%%Ty } | not grep opaque
+; RUN: llvm-link %t.1.bc %t.2.bc -S | grep "%%Ty " | not grep opaque
%Ty = type {i32}
; This fails because the linker renames the non-opaque type not the opaque
; one...
-; RUN: echo { define linkonce void @foo() \{ ret void \} } | \
+; RUN: echo " define linkonce void @foo() { ret void } " | \
; RUN: llvm-as -o %t.2.bc
; RUN: llvm-as %s -o %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S | grep foo | grep linkonce
; This one fails because the LLVM runtime is allowing two null pointers of
; the same type to be created!
-; RUN: echo {%%T = type i32} | llvm-as > %t.2.bc
+; RUN: echo "%%T = type i32" | llvm-as > %t.2.bc
; RUN: llvm-as %s -o %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc
; This one fails because the LLVM runtime is allowing two null pointers of
; the same type to be created!
-; RUN: echo {%M = type \{ %N*\} %N = type opaque} | llvm-as > %t.2.bc
+; RUN: echo "%M = type { %N*} %N = type opaque" | llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc
; the function name, we must rename the internal function to something that
; does not conflict.
-; RUN: echo { define internal i32 @foo() \{ ret i32 7 \} } | llvm-as > %t.1.bc
+; RUN: echo " define internal i32 @foo() { ret i32 7 } " | llvm-as > %t.1.bc
; RUN: llvm-as < %s > %t.2.bc
-; RUN: llvm-link %t.1.bc %t.2.bc -S | grep internal | not grep {@foo(}
+; RUN: llvm-link %t.1.bc %t.2.bc -S | grep internal | not grep "@foo("
declare i32 @foo()
-; RUN: echo {%%T = type opaque} | llvm-as > %t.2.bc
+; RUN: echo "%%T = type opaque" | llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc
-; RUN: echo {%%T = type i32} | llvm-as > %t.1.bc
+; RUN: echo "%%T = type i32" | llvm-as > %t.1.bc
; RUN: llvm-as < %s > %t.2.bc
; RUN: llvm-link %t.1.bc %t.2.bc
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: echo {%M = type \{ i32, i32* \} } | llvm-as > %t.out2.bc
+; RUN: echo "%M = type { i32, i32* } " | llvm-as > %t.out2.bc
; RUN: llvm-link %t.out1.bc %t.out2.bc
%M = type { i32, %N* }
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: echo {%%T1 = type opaque %%T2 = type opaque @S = external global \{ i32, %%T1* \} declare void @F(%%T2*)}\
+; RUN: echo "%%T1 = type opaque %%T2 = type opaque @S = external global { i32, %%T1* } declare void @F(%%T2*)"\
; RUN: | llvm-as > %t.out2.bc
; RUN: llvm-link %t.out1.bc %t.out2.bc -S | not grep opaque
; specified pointer size should not cause a warning!
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: echo {} | llvm-as > %t.out2.bc
+; RUN: echo "" | llvm-as > %t.out2.bc
; RUN: llvm-link %t.out1.bc %t.out2.bc |& not grep warning
target datalayout = "e-p:64:64"
-; RUN: echo {@G = weak global \{\{\{\{double\}\}\}\} zeroinitializer } | \
+; RUN: echo "@G = weak global {{{{double}}}} zeroinitializer " | \
; RUN: llvm-as > %t.out2.bc
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: llvm-link %t.out1.bc %t.out2.bc -S | not grep {\\}}
+; RUN: llvm-link %t.out1.bc %t.out2.bc -S | not grep "}"
; When linked, the global above should be eliminated, being merged with the
; global below.
; Test that a prototype can be marked const, and the definition is allowed
; to be nonconst.
-; RUN: echo {@X = external constant i32} | llvm-as > %t.2.bc
+; RUN: echo "@X = external constant i32" | llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
-; RUN: llvm-link %t.1.bc %t.2.bc -S | grep {global i32 7}
+; RUN: llvm-link %t.1.bc %t.2.bc -S | grep "global i32 7"
@X = global i32 7
; Test that a prototype can be marked const, and the definition is allowed
; to be nonconst.
-; RUN: echo {@X = global i32 7} | llvm-as > %t.2.bc
+; RUN: echo "@X = global i32 7" | llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
-; RUN: llvm-link %t.1.bc %t.2.bc -S | grep {global i32 7}
+; RUN: llvm-link %t.1.bc %t.2.bc -S | grep "global i32 7"
@X = external constant i32 ; <i32*> [#uses=0]
-; RUN: echo { @G = appending global \[0 x i32\] zeroinitializer } | \
+; RUN: echo " @G = appending global [0 x i32] zeroinitializer " | \
; RUN: llvm-as > %t.out2.bc
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: llvm-link %t.out1.bc %t.out2.bc -S | grep {@G =}
+; RUN: llvm-link %t.out1.bc %t.out2.bc -S | grep "@G ="
; When linked, the globals should be merged, and the result should still
; be named '@G'.
; The linker should choose the largest alignment when linking.
-; RUN: echo {@X = global i32 7, align 8} | llvm-as > %t.2.bc
+; RUN: echo "@X = global i32 7, align 8" | llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
-; RUN: llvm-link %t.1.bc %t.2.bc -S | grep {align 8}
+; RUN: llvm-link %t.1.bc %t.2.bc -S | grep "align 8"
@X = weak global i32 7, align 4
; in different modules.
; RUN: llvm-as %s -o %t.foo1.bc
; RUN: llvm-as %s -o %t.foo2.bc
-; RUN: echo {define linkonce void @foo(i32 %x) { ret void }} | llvm-as -o %t.foo3.bc
+; RUN: echo "define linkonce void @foo(i32 %x) { ret void }" | llvm-as -o %t.foo3.bc
; RUN: llvm-link %t.foo1.bc %t.foo2.bc -S
; RUN: llvm-link %t.foo1.bc %t.foo3.bc -S
define linkonce void @foo() { ret void }
; in different modules.
; RUN: llvm-as %s -o %t.foo1.bc
; RUN: echo | llvm-as -o %t.foo2.bc
-; RUN: llvm-link %t.foo2.bc %t.foo1.bc -S | grep {addrspace(2)}
-; RUN: llvm-link %t.foo1.bc %t.foo2.bc -S | grep {addrspace(2)}
+; RUN: llvm-link %t.foo2.bc %t.foo1.bc -S | grep "addrspace(2)"
+; RUN: llvm-link %t.foo1.bc %t.foo2.bc -S | grep "addrspace(2)"
; rdar://6038021
@G = addrspace(2) global i32 256
; Test that appending linkage works correctly.
-; RUN: echo {@X = appending global \[1 x i32\] \[i32 8\] } | \
+; RUN: echo "@X = appending global [1 x i32] [i32 8] " | \
; RUN: llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S | grep 7 | grep 4 | grep 8
; Test that appending linkage works correctly when arrays are the same size.
-; RUN: echo {@X = appending global \[1 x i32\] \[i32 8\] } | \
+; RUN: echo "@X = appending global [1 x i32] [i32 8] " | \
; RUN: llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S | grep 7 | grep 8
; Test that appending linkage works correctly when arrays are the same size.
-; RUN: echo {@X = constant \[1 x i32\] \[i32 8\] } | \
+; RUN: echo "@X = constant [1 x i32] [i32 8] " | \
; RUN: llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S | grep constant
; Test that appending linkage works correctly when arrays are the same size.
-; RUN: echo {@X = external global \[1 x i32\] } | \
+; RUN: echo "@X = external global [1 x i32] " | \
; RUN: llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S | grep constant
; Test that appending linkage works correctly when arrays are the same size.
-; RUN: echo {@X = external constant \[1 x i32\] } | \
+; RUN: echo "@X = external constant [1 x i32] " | \
; RUN: llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S | grep constant
; RUN: llvm-as %s -o %t1.bc
-; RUN: echo {declare void @__eprintf(i8*, i8*, i32, i8*) noreturn define void @foo() { tail call void @__eprintf( i8* undef, i8* undef, i32 4, i8* null ) noreturn nounwind unreachable }} | llvm-as -o %t2.bc
+; RUN: echo "declare void @__eprintf(i8*, i8*, i32, i8*) noreturn define void @foo() { tail call void @__eprintf( i8* undef, i8* undef, i32 4, i8* null ) noreturn nounwind unreachable }" | llvm-as -o %t2.bc
; RUN: llvm-link %t2.bc %t1.bc -S | grep __eprintf
; RUN: llvm-link %t1.bc %t2.bc -S | grep __eprintf
; in different modules.
; RUN: llvm-as %s -o %t.foo1.bc
; RUN: llvm-as %s -o %t.foo2.bc
-; RUN: echo {define void @foo(i32 %x) { ret void }} | llvm-as -o %t.foo3.bc
+; RUN: echo "define void @foo(i32 %x) { ret void }" | llvm-as -o %t.foo3.bc
; RUN: not llvm-link %t.foo1.bc %t.foo2.bc -o %t.bc |& \
-; RUN: grep {symbol multiply defined}
+; RUN: grep "symbol multiply defined"
; RUN: not llvm-link %t.foo1.bc %t.foo3.bc -o %t.bc |& \
-; RUN: grep {symbol multiply defined}
+; RUN: grep "symbol multiply defined"
define void @foo() { ret void }
; RUN: llvm-as < %s > %t.bc
; RUN: llvm-as < %p/testlink1.ll > %t2.bc
; RUN: llvm-link %t.bc %t.bc %t2.bc -o %t1.bc
-; RUN: llvm-dis < %t1.bc | grep {kallsyms_names = extern_weak}
-; RUN: llvm-dis < %t1.bc | grep {MyVar = external global i32}
-; RUN: llvm-dis < %t1.bc | grep {Inte = global i32}
+; RUN: llvm-dis < %t1.bc | grep "kallsyms_names = extern_weak"
+; RUN: llvm-dis < %t1.bc | grep "MyVar = external global i32"
+; RUN: llvm-dis < %t1.bc | grep "Inte = global i32"
@kallsyms_names = extern_weak global [0 x i8] ; <[0 x i8]*> [#uses=0]
@MyVar = extern_weak global i32 ; <i32*> [#uses=0]
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=60 Name=BFI Format=ARM_FORMAT_DPFRM(4)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=2249 Name=tBcc Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# invalid imod value (0b01)
0xc0 0x67 0x4 0xf1
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {potentially undefined instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "potentially undefined instruction encoding"
# invalid (imod, M, iflags) combination
0x93 0x00 0x02 0xf1
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1908 Name=t2DMB Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=102 Name=DSB Format=ARM_FORMAT_MISCFRM(26)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep {potentially undefined instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep "potentially undefined instruction encoding"
# CBZ / CBNZ not allowed in IT block.
-# RUN: llvm-mc --disassemble %s -triple=thumbv7-unknown-unknown |& grep {potentially undefined instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumbv7-unknown-unknown |& grep "potentially undefined instruction encoding"
0xff 0xbf 0x6b 0x80 0x00 0x75
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=0 Name=PHI Format=(42)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep {potentially undefined instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep "potentially undefined instruction encoding"
# Writeback is not allowed is Rn is in the target register list.
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {potentially undefined instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "potentially undefined instruction encoding"
# Opcode=140 Name=LDRB_POST Format=ARM_FORMAT_LDFRM(6)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1930 Name=t2LDRD_PRE Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {potentially undefined instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "potentially undefined instruction encoding"
# Opcode=165 Name=LDR_PRE Format=ARM_FORMAT_LDFRM(6)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# LDR (register) has encoding Inst{4} = 0.
0xba 0xae 0x9f 0x57
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=171 Name=MCR Format=ARM_FORMAT_BRFRM(2)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=185 Name=MOVTi16 Format=ARM_FORMAT_DPFRM(4)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=0 Name=PHI Format=(42)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=196 Name=MOVs Format=ARM_FORMAT_DPSOREGFRM(5)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=0 Name=PHI Format=(42)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=206 Name=MSRi Format=ARM_FORMAT_BRFRM(2)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=134 Name=LDMIA Format=ARM_FORMAT_LDSTMULFRM(10)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=271 Name=SBFX Format=ARM_FORMAT_DPFRM(4)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=284 Name=SMLAD Format=ARM_FORMAT_MULFRM(1)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=0 Name=PHI Format=(42)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=2313 Name=tSTMIA_UPD Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=390 Name=SXTBr_rot Format=ARM_FORMAT_EXTFRM(14)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=419 Name=UMAAL Format=ARM_FORMAT_MULFRM(1)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=871 Name=VLD3DUPd32_UPD Format=ARM_FORMAT_NLdSt(30)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=arm-apple-darwin9 |& grep "invalid instruction encoding"
# core registers out of range
0xa5 0xba 0x72 0xed
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1839 Name=VST1d8Twb_register Format=ARM_FORMAT_NLdSt(30)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1894 Name=t2Bcc Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1922 Name=t2LDRBT Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1953 Name=t2LDRSHi12 Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=1954 Name=t2LDRSHi8 Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumbv7-apple-darwin9 |& grep "invalid instruction encoding"
# SP and PC are not allowed in the register list on STM instructions in Thumb2.
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=2128 Name=t2STREXD Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=thumb-apple-darwin9 |& grep "invalid instruction encoding"
# Opcode=2137 Name=t2STR_POST Format=ARM_FORMAT_THUMBFRM(25)
# 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
-# RUN: llvm-mc --disassemble %s -triple=x86_64-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=x86_64-apple-darwin9 |& grep "invalid instruction encoding"
# This instruction would decode as movmskps if the vvvv field in the VEX prefix was all 1s.
0xc5 0xf0 0x50 0xc0
-# RUN: llvm-mc --disassemble %s -triple=x86_64-apple-darwin9 |& grep {invalid instruction encoding}
+# RUN: llvm-mc --disassemble %s -triple=x86_64-apple-darwin9 |& grep "invalid instruction encoding"
# This instruction would decode as cmpordps if the immediate byte was less than 8.
0x0f 0xc2 0xc7 0x08
; and instead nests it just inside loop "Top"
;
; RUN: opt < %s -analyze -loops | \
-; RUN: grep { Loop at depth 3 containing: %Inner<header><latch><exiting>}
+; RUN: grep " Loop at depth 3 containing: %Inner<header><latch><exiting>"
;
define void @test() {
br label %Top
-; RUN: not opt --foo |& grep {Unknown command line argument}
+; RUN: not opt --foo |& grep "Unknown command line argument"
; there is no --foo
-// RUN: llvm-tblgen %s | grep {zing = 4} | count 4
+// RUN: llvm-tblgen %s | grep "zing = 4" | count 4
// XFAIL: vg_leak
class C1<int A, string B> {
-// RUN: llvm-tblgen %s | grep {int Y = 3}
+// RUN: llvm-tblgen %s | grep "int Y = 3"
// XFAIL: vg_leak
class C {
// RUN llvm-tblgen %s | FileCheck %s
-// RUN: llvm-tblgen %s | grep {foo} | count 1
+// RUN: llvm-tblgen %s | grep "foo" | count 1
// XFAIL: vg_leak
class Base<string t> {
-// RUN: llvm-tblgen %s | grep {zing = 4} | count 2
+// RUN: llvm-tblgen %s | grep "zing = 4" | count 2
// XFAIL: vg_leak
class C1<int A, string B> {
-// RUN: llvm-tblgen %s | grep {zing = 4} | count 28
+// RUN: llvm-tblgen %s | grep "zing = 4" | count 28
// XFAIL: vg_leak
class C1<int A, string B> {
-// RUN: llvm-tblgen %s | grep {\\\[(set} | count 2
-// RUN: llvm-tblgen %s | grep {\\\[\\\]} | count 2
+// RUN: llvm-tblgen %s | grep "\[(set" | count 2
+// RUN: llvm-tblgen %s | grep "\[\]" | count 2
// XFAIL: vg_leak
class ValueType<int size, int value> {
-// RUN: llvm-tblgen %s | grep {\\\[(set VR128:\$dst, (int_x86_sse2_add_pd VR128:\$src1, VR128:\$src2))\\\]} | count 1
-// RUN: llvm-tblgen %s | grep {\\\[(set VR128:\$dst, (int_x86_sse2_add_ps VR128:\$src1, VR128:\$src2))\\\]} | count 1
+// RUN: llvm-tblgen %s | grep '\[(set VR128:$dst, (int_x86_sse2_add_pd VR128:$src1, VR128:$src2))\]' | count 1
+// RUN: llvm-tblgen %s | grep '\[(set VR128:$dst, (int_x86_sse2_add_ps VR128:$src1, VR128:$src2))\]' | count 1
// XFAIL: vg_leak
class ValueType<int size, int value> {
-// RUN: llvm-tblgen %s | grep {add_ps} | count 3
+// RUN: llvm-tblgen %s | grep "add_ps" | count 3
// XFAIL: vg_leak
class ValueType<int size, int value> {
-// RUN: llvm-tblgen %s | grep {Jr} | count 2
-// RUN: llvm-tblgen %s | grep {Sr} | count 2
-// RUN: llvm-tblgen %s | grep {"NAME"} | count 1
+// RUN: llvm-tblgen %s | grep 'Jr' | count 2
+// RUN: llvm-tblgen %s | grep 'Sr' | count 2
+// RUN: llvm-tblgen %s | grep '"NAME"' | count 1
// XFAIL: vg_leak
// Variables for foreach
-// RUN: llvm-tblgen %s | grep {}
+// RUN: llvm-tblgen %s | grep ""
// XFAIL: vg_leak
class List<list<string> n> {
-// RUN: llvm-tblgen %s | grep {Smith} | count 7
-// RUN: llvm-tblgen %s | grep {Johnson} | count 2
-// RUN: llvm-tblgen %s | grep {FIRST} | count 1
-// RUN: llvm-tblgen %s | grep {LAST} | count 1
-// RUN: llvm-tblgen %s | grep {TVAR} | count 2
-// RUN: llvm-tblgen %s | grep {Bogus} | count 1
+// RUN: llvm-tblgen %s | grep "Smith" | count 7
+// RUN: llvm-tblgen %s | grep "Johnson" | count 2
+// RUN: llvm-tblgen %s | grep "FIRST" | count 1
+// RUN: llvm-tblgen %s | grep "LAST" | count 1
+// RUN: llvm-tblgen %s | grep "TVAR" | count 2
+// RUN: llvm-tblgen %s | grep "Bogus" | count 1
// XFAIL: vg_leak
class Honorific<string t> {
; RUN: opt < %s -argpromotion -S > %t
-; RUN: cat %t | grep {define.*@callee(.*i32\\*}
+; RUN: cat %t | grep "define.*@callee(.*i32\*"
; PR2498
; This test tries to convince argpromotion about promoting the load from %A + 2,
-; 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 -S | \
-; RUN: grep {load i32\\* %A}
+; RUN: grep "load i32\* %A"
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
define internal i32 @callee(i1 %C, i32* %P) {
; RUN: opt < %s -constprop -S | \
-; RUN: grep {i32 -1}
+; RUN: grep "i32 -1"
; RUN: opt < %s -constprop -S | \
; RUN: not grep zeroinitializer
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {ret i1 false}
+; RUN: grep "ret i1 false"
define i1 @test() {
%X = trunc i32 320 to i1 ; <i1> [#uses=1]
ret i1 %X
; RUN: opt < %s -constprop -S | \
-; RUN: grep {ret i32 -1}
+; RUN: grep "ret i32 -1"
; RUN: opt < %s -constprop -S | \
-; RUN: grep {ret i32 1}
+; RUN: grep "ret i32 1"
define i32 @test1() {
%A = sext i1 true to i32 ; <i32> [#uses=1]
-; RUN: llvm-as < %s | llvm-dis | grep {global i32 0}
+; RUN: llvm-as < %s | llvm-dis | grep "global i32 0"
; PR1215
@G = global i32 sdiv (i32 0, i32 -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, i1)
-; 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 -deadargelim -S | grep {@test(}
+; RUN: opt < %s -deadargelim -S | grep "@test("
; RUN: opt < %s -deadargelim -S | not grep dead
define internal i32 @test(i32 %X, i32 %dead) {
; This test shows a few canonicalizations made by deadargelim
; RUN: opt < %s -deadargelim -S > %t
; This test should remove {} and replace it with void
-; RUN: cat %t | grep {define internal void @test}
+; RUN: cat %t | grep "define internal void @test"
; This test shouls replace the {i32} return value with just i32
-; RUN: cat %t | grep {define internal i32 @test2}
+; RUN: cat %t | grep "define internal i32 @test2"
define internal {} @test() {
ret {} undef
; RUN: opt < %s -deadargelim -S > %t
-; RUN: grep {define internal zeroext i32 @test1() nounwind} %t
-; RUN: grep {define internal <{ i32, i32 }> @test2} %t
+; RUN: grep "define internal zeroext i32 @test1() nounwind" %t
+; RUN: grep "define internal <{ i32, i32 }> @test2" %t
%Ty = type <{ i32, i32 }>
-; 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 -basicaa -gvn -S | grep {tmp47 = phi i32 }
+; RUN: opt < %s -basicaa -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 -basicaa -gvn -S | grep {ret i8 \[%\]tmp3}
+; RUN: opt < %s -basicaa -gvn -S | grep "ret i8 [%]tmp3"
; PR2503
@g_3 = external global i8 ; <i8*> [#uses=2]
-; 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 -basicaa -gvn -instcombine -S | grep {ret i32 0}
+; RUN: opt < %s -basicaa -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 -basicaa -gvn -stats -disable-output |& grep {Number of loads deleted}
+; RUN: opt < %s -basicaa -gvn -stats -disable-output |& grep "Number of loads deleted"
; rdar://7363102
; GVN should be able to eliminate load %tmp22.i, because it is redundant with
-; 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 -basicaa -gvn -S | grep {DEAD = phi i32 }
+; RUN: opt < %s -basicaa -gvn -S | grep "DEAD = phi i32 "
; GVN should eliminate the fully redundant %9 GEP which
; allows DEAD to be removed. This is PR3198.
-; RUN: opt < %s -basicaa -gvn -S | grep {DEAD = phi i32 }
+; RUN: opt < %s -basicaa -gvn -S | grep "DEAD = phi i32 "
define i32 @main(i32* %p) {
block1:
-; 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 {load volatile}
+; RUN: opt < %s -globalopt -S | grep "load volatile"
@t0.1441 = internal global double 0x3FD5555555555555, align 8 ; <double*> [#uses=1]
define double @foo() nounwind {
; 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 unnamed_addr global .*align 16}
-; RUN: opt < %s -globalopt -S | grep {@G.1 = internal unnamed_addr global .*align 8}
-; RUN: opt < %s -globalopt -S | grep {@G.2 = internal unnamed_addr global .*align 16}
+; RUN: opt < %s -globalopt -S | grep "@G.0 = internal unnamed_addr global .*align 16"
+; RUN: opt < %s -globalopt -S | grep "@G.1 = internal unnamed_addr global .*align 8"
+; RUN: opt < %s -globalopt -S | grep "@G.2 = internal unnamed_addr 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"
-; 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 -S | grep {@X = internal unnamed_addr global i32}
+; RUN: opt < %s -globalopt -S | grep "@X = internal unnamed_addr 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 -instcombine -globalopt -S | \
-; RUN: grep {internal fastcc float @foo}
+; RUN: grep "internal fastcc float @foo"
define internal float @foo() {
ret float 0.000000e+00
; RUN: opt < %s -globalopt -S > %t
-; RUN: grep {@Y = internal unnamed_addr global \\\[3 x \[%\]struct.X\\\] zeroinitializer} %t
+; RUN: grep "@Y = internal unnamed_addr global \[3 x [%]struct.X\] zeroinitializer" %t
; RUN: grep load %t | count 6
-; RUN: grep {add i32 \[%\]a, \[%\]b} %t | count 3
+; RUN: grep "add i32 [%]a, [%]b" %t | count 3
; globalopt should not sra the global, because it can't see the index.
-; 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:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
%struct.foo = type { i32, i32 }
; RUN: opt < %s -globalopt -instcombine | \
-; RUN: llvm-dis | grep {ret i1 true}
+; 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 | \
-; RUN: grep {G1 = internal unnamed_addr constant}
+; RUN: grep "G1 = internal unnamed_addr constant"
@G1 = internal global [58 x i8] c"asdlfkajsdlfkajsd;lfkajds;lfkjasd;flkajsd;lkfja;sdlkfjasd\00" ; <[58 x i8]*> [#uses=1]
; RUN: opt < %s -globalopt -S | \
-; RUN: grep {call void @Actual}
+; RUN: grep "call void @Actual"
; Check that a comparison does not prevent an indirect call from being made
; direct. The global will still remain, but indirect call elim is still good.
-; 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 -S > %t
-; RUN: cat %t | grep {store i32 %Z, i32\\* %Q}
-; RUN: cat %t | grep {add i32 1, 3}
+; RUN: cat %t | grep "store i32 %Z, i32\* %Q"
+; RUN: cat %t | grep "add i32 1, 3"
;; This function returns its second argument on all return statements
define internal i32* @incdec(i1 %C, i32* %V) {
; RUN: opt < %s -ipconstprop -instcombine | \
-; RUN: llvm-dis | grep {ret i1 true} | count 2
+; 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
;; Check that the 21 constants got propagated properly
-; RUN: cat %t | grep {%M = add i32 21, 21}
+; RUN: cat %t | grep "%M = add i32 21, 21"
;; Check that the second return values didn't get propagated
-; RUN: cat %t | grep {%N = add i32 %B, %D}
+; RUN: cat %t | grep "%N = add i32 %B, %D"
%0 = type { i32, i32 }
; RUN: opt < %s -indvars -S | \
-; RUN: grep {ret i32 152}
+; RUN: grep "ret i32 152"
define i32 @main() {
entry:
; PR726
; RUN: opt < %s -indvars -S | \
-; RUN: grep {ret i32 27}
+; RUN: grep "ret i32 27"
; Make sure to compute the right exit value based on negative strides.
-; RUN: opt < %s -S -indvars | grep {= icmp} | count 3
+; RUN: opt < %s -S -indvars | grep "= icmp" | count 3
; PR4914.ll
; Indvars should be able to do range analysis and eliminate icmps.
-; 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 -scalar-evolution -analyze \
-; RUN: | grep {\\--> (zext i4 {-7,+,-8}<%loop> to i32)}
+; RUN: | grep "\--> (zext i4 {-7,+,-8}<%loop> to i32)"
define fastcc void @foo() nounwind {
entry:
-; 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) {
-; RUN: opt %s -S -inline -functionattrs -stats |& grep {Number of call sites deleted, not inlined}
-; RUN: opt %s -S -inline -stats |& grep {Number of functions inlined}
+; RUN: opt %s -S -inline -functionattrs -stats |& grep "Number of call sites deleted, not inlined"
+; RUN: opt %s -S -inline -stats |& grep "Number of functions inlined"
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
target triple = "i386-apple-darwin9.8"
; RUN: opt < %s -inline -constprop -S > %t
; RUN: not grep test_function %t
-; RUN: grep {ret i32 5} %t
+; RUN: grep "ret i32 5" %t
; test_function should not be emitted to the .s file.
; RUN: opt < %s -inline -S | \
-; RUN: not grep {callee\[12\](}
+; RUN: not grep "callee[12]("
; RUN: opt < %s -inline -S | not grep mul
define internal i32 @callee1(i32 %A, i32 %B) {
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {ret i1 false}
+; RUN: grep "ret i1 false"
define i1 @test(i1 %V) {
%Y = icmp ult i1 %V, false ; <i1> [#uses=1]
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {ret i1 true}
+; RUN: grep "ret i1 true"
; PR586
@g_07918478 = external global i32 ; <i32*> [#uses=1]
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {icmp sgt}
+; RUN: grep "icmp sgt"
; END.
target datalayout = "e-p:32:32"
target triple = "i686-pc-linux-gnu"
; RUN: opt < %s -instcombine -S | \
; RUN: grep icmp | count 1
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {icmp ugt} | count 1
+; RUN: grep "icmp ugt" | count 1
; 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 -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 | grep "%A = alloca"
; RUN: opt < %s -instcombine -mem2reg -S | \
-; RUN: not grep {%B = alloca}
+; RUN: not grep "%B = alloca"
; END.
; Ensure that instcombine doesn't sink the loads in entry/cond_true into
-; 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) {
; For PR1248
-; RUN: opt < %s -instcombine -S | grep {ugt i32 .*, 11}
+; RUN: opt < %s -instcombine -S | grep "ugt i32 .*, 11"
define i1 @test(i32 %tmp6) {
%tmp7 = sdiv i32 %tmp6, 12 ; <i32> [#uses=1]
icmp ne i32 %tmp7, -6 ; <i1>:1 [#uses=1]
; PR1271
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {icmp eq i32 .tmp.*, 2146435072}
+; RUN: grep "icmp eq i32 .tmp.*, 2146435072"
%struct..0anon = type { i32, i32 }
%struct..1anon = type { double }
; PR1271
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {ashr exact i32 %.mp137, 2}
+; RUN: grep "ashr exact i32 %.mp137, 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"
target triple = "i686-pc-linux-gnu"
-; 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 -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 -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 -S | grep {add} | count 1
+; RUN: opt < %s -instcombine -S | grep "add" | count 1
define i32 @foo(i32 %a) {
entry:
-; 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 | grep {16} | count 1
+; RUN: opt < %s -instcombine -S | grep "16" | count 1
define i8* @bork(i8** %qux) {
%tmp275 = load i8** %qux, align 1
-; RUN: opt < %s -instcombine -S | grep {store volatile}
+; RUN: opt < %s -instcombine -S | grep "store volatile"
define void @test() {
%votf = alloca <4 x float> ; <<4 x float>*> [#uses=1]
-; RUN: opt < %s -instcombine -S | grep {load volatile} | count 2
+; RUN: opt < %s -instcombine -S | grep "load volatile" | 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 {load volatile} | count 2
+; RUN: opt < %s -instcombine -S | grep "load volatile" | 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 -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 -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: grep {xor} %t
-; RUN: grep {and} %t
-; RUN: not grep {div} %t
+; RUN: grep "xor" %t
+; RUN: grep "and" %t
+; RUN: not grep "div" %t
define i1 @foo1(i1 %a, i1 %b) {
%A = sub i1 %a, %b
-; 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 {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 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 {load volatile} | count 2
+; RUN: opt < %s -instcombine -S | grep "load volatile" | 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 | 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 | 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 {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 -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 | 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 -S > %t
-; RUN: grep {, align 4} %t | count 3
-; RUN: grep {, align 8} %t | count 3
+; RUN: grep ", align 4" %t | count 3
+; RUN: grep ", align 8" %t | count 3
; rdar://6480438
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16: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 | 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 12
-; 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 "0\.0" | count 3
+; RUN: opt < %s -simplifycfg -instcombine -S | grep "3\.5" | count 1
;
; ModuleID = 'apf.c'
-; 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 -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 -S | grep {ashr i32 %val, 31}
+; RUN: opt < %s -instcombine -S | grep "ashr i32 %val, 31"
; PR3851
define i32 @foo2(i32 %val) nounwind {
-; RUN: opt < %s -instcombine -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 | grep {store i32 0,}
+; RUN: opt < %s -instcombine -S | grep "store i32 0,"
; PR4366
define void @a() {
; 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 {icmp sle i32 %A, %B}
+; RUN: opt < %s -instcombine -S | grep "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 nsw i32}
+; RUN: opt < %s -instcombine -S | grep "add nsw 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 nsw i32}
+; RUN: opt < %s -instcombine -S | grep "add nsw i32"
define double @x(i32 %a, i32 %b) nounwind {
%m = lshr i32 %a, 24
-; 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
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; A multi-dimensional array in a nested loop doing vector stores that
-; RUN: opt < %s -instcombine -S | grep {and i32 %x, %y} | count 4
-; RUN: opt < %s -instcombine -S | not grep {or}
+; RUN: opt < %s -instcombine -S | grep "and i32 %x, %y" | count 4
+; RUN: opt < %s -instcombine -S | not grep "or"
define i32 @func1(i32 %x, i32 %y) nounwind {
entry:
-; 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 {
; RUN: opt < %s -instcombine -S | \
-; RUN: egrep {shl|lshr|ashr} | count 3
+; RUN: egrep "shl|lshr|ashr" | count 3
define i41 @test0(i41 %A, i41 %B, i41 %C) {
%X = shl i41 %A, %C
; Tests to make sure bit counts of constants are folded
-; RUN: opt < %s -instcombine -S | grep {ret i32 19}
+; RUN: opt < %s -instcombine -S | grep "ret i32 19"
; RUN: opt < %s -instcombine -S | \
; RUN: grep -v declare | not grep llvm.ct
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {call.*llvm.bswap} | count 6
+; RUN: grep "call.*llvm.bswap" | count 6
define i32 @test1(i32 %i) {
%tmp1 = lshr i32 %i, 24 ; <i32> [#uses=1]
-; 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 -instcombine -S | grep "ret i32 %A"
; RUN: opt < %s -die -S | not grep call.*llvm
define i32 @test(i32 %A) {
-; 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 | \
-; RUN: grep {call float bitcast} | count 1
+; RUN: grep "call float bitcast" | count 1
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
%struct.NSObject = type { %struct.objc_class* }
%struct.NSArray = type { %struct.NSObject }
-; 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
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
@x = external global <2 x i64>, align 16
-; 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"
-; RUN: opt < %s -instcombine -S | grep {fadd double .sx, .sy}
+; RUN: opt < %s -instcombine -S | grep "fadd 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: grep {ret i1 false}
+; RUN: grep "ret i1 false"
; test1 - Eliminating the casts in this testcase (by narrowing the AND
; operation) allows instcombine to realize the function always returns false.
-; 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
-; RUN: opt < %s -instcombine -S | grep {xor i32 %a, %b} | count 4
-; RUN: opt < %s -instcombine -S | not grep {and}
+; RUN: opt < %s -instcombine -S | grep "xor i32 %a, %b" | count 4
+; RUN: opt < %s -instcombine -S | not grep "and"
define i32 @func1(i32 %a, i32 %b) nounwind readnone {
entry:
; RUN: opt < %s -S -instcombine > %t
-; RUN: grep {= getelementptr} %t | count 20
-; RUN: grep {= phi} %t | count 13
+; RUN: grep "= getelementptr" %t | count 20
+; RUN: grep "= phi" %t | count 13
; Don't push the geps through these phis, because they would require
; two phis each, which burdens the loop with high register pressure.
-; 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 {ret i32 1}
+; RUN: opt < %s -instcombine -S | grep "ret i32 1"
declare void @test2()
-; RUN: opt < %s -instcombine -S | grep {ret <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0x7FF0000000000000, float 0x7FF0000000000000>}
+; RUN: opt < %s -instcombine -S | grep "ret <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0x7FF0000000000000, float 0x7FF0000000000000>"
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16: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: not grep zext %t
; RUN: not grep slt %t
-; RUN: grep {icmp ult} %t
+; RUN: grep "icmp ult" %t
; Instcombine should convert the zext+slt into a simple ult.
-; 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 {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 | 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 | 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 {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 | grep {fadd float}
+; RUN: opt < %s -instcombine -S | grep "fadd float"
define float @test(<4 x float> %A, <4 x float> %B, float %f) {
-; 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 {store volatile}
-; RUN: opt < %s -instcombine -S | grep {load volatile}
+; RUN: opt < %s -instcombine -S | grep "store volatile"
+; RUN: opt < %s -instcombine -S | grep "load volatile"
@x = weak global i32 0 ; <i32*> [#uses=2]
; RUN: opt < %s -instcombine -S | \
-; RUN: grep {and i32 %Y, 8}
+; RUN: grep "and i32 %Y, 8"
define i32 @test1(i8 %X) {
%Y = zext i8 %X to i32 ; <i32> [#uses=1]
-; 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) {
-; RUN: opt < %s -jump-threading -S | grep {ret i32 0}
+; RUN: opt < %s -jump-threading -S | grep "ret i32 0"
; PR3138
define i32 @jt() {
; RUN: opt < %s -jump-threading -loop-rotate -instcombine -indvars -loop-unroll -simplifycfg -S -verify-dom-info -verify-loop-info > %t
-; RUN: grep {store volatile} %t | count 3
-; RUN: not grep {br label} %t
+; RUN: grep "store volatile" %t | count 3
+; RUN: not grep "br label" %t
; Jump threading should not prevent this loop from being unrolled.
; RUN: opt < %s -loop-simplify -lcssa -S | \
-; RUN: grep {%%SJE.0.0.lcssa = phi .struct.SetJmpMapEntry}
+; RUN: grep "%%SJE.0.0.lcssa = phi .struct.SetJmpMapEntry"
%struct.SetJmpMapEntry = type { i8*, i32, %struct.SetJmpMapEntry* }
; RUN: opt < %s -lcssa -S | \
-; RUN: grep {%X.1.lcssa}
+; RUN: grep "%X.1.lcssa"
; RUN: opt < %s -lcssa -S | \
-; RUN: not grep {%X.1.lcssa1}
+; RUN: not grep "%X.1.lcssa1"
declare i1 @c1()
; RUN: opt < %s -lcssa -S | \
-; RUN: grep {X3.lcssa = phi i32}
+; RUN: grep "X3.lcssa = phi i32"
; RUN: opt < %s -lcssa -S | \
-; RUN: grep {X4 = add i32 3, %X3.lcssa}
+; RUN: grep "X4 = add i32 3, %X3.lcssa"
define void @lcssa(i1 %S2) {
entry:
-; RUN: opt < %s -lcssa -S -verify-loop-info | grep {\[%\]tmp33 = load i1\\*\\* \[%\]tmp}
+; RUN: opt < %s -lcssa -S -verify-loop-info | grep "[%]tmp33 = load i1\*\* [%]tmp"
; PR6546
; LCSSA doesn't need to transform uses in blocks not reachable
-; RUN: opt < %s -licm -S | grep {store volatile}
+; RUN: opt < %s -licm -S | grep "store volatile"
; 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 -loop-simplify -lcssa -verify-loop-info -verify-dom-info -S \
-; RUN: | grep -F {indirectbr i8* %x, \[label %L0, label %L1\]} \
+; RUN: | grep -F "indirectbr i8* %x, [label %L0, label %L1]" \
; RUN: | count 6
; LoopSimplify should not try to transform loops when indirectbr is involved.
; RUN: opt < %s -loop-simplify -loop-rotate -instcombine -indvars -S -verify-loop-info -verify-dom-info > %t
; RUN: not grep sext %t
-; RUN: grep {phi i64} %t | count 1
+; RUN: grep "phi i64" %t | count 1
; Loopsimplify should be able to merge the two loop exits
; into one, so that loop rotate can rotate the loop, so
-; RUN: opt -S < %s -indvars | opt -analyze -iv-users | grep {%cmp = icmp slt i32} | grep {= \{%\\.ph,+,1\}<%for.cond>}
+; RUN: opt -S < %s -indvars | opt -analyze -iv-users | grep "%cmp = icmp slt i32" | grep "= {%\.ph,+,1}<%for.cond>"
; PR8079
; LoopSimplify should invalidate indvars when splitting out the
; RUN: opt < %s -loop-reduce -S \
-; RUN: | grep {icmp eq i2 %lsr.iv.next, %xmp4344}
+; RUN: | grep "icmp eq i2 %lsr.iv.next, %xmp4344"
; Don't reverse the iteration if the rhs of the compare is defined
; inside the loop.
-; RUN: opt < %s -loop-reduce -S | grep {phi\\>} | count 8
+; RUN: opt < %s -loop-reduce -S | grep "phi\>" | count 8
; 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 -analyze -iv-users | grep {\{1,+,3,+,2\}<%loop> (post-inc with loop %loop)}
+; RUN: opt < %s -analyze -iv-users | grep "{1,+,3,+,2}<%loop> (post-inc with loop %loop)"
; The value of %r is dependent on a polynomial iteration expression.
; RUN: opt < %s -loop-reduce -S | \
-; RUN: grep {add i32 %indvar630.ui, 1}
+; RUN: grep "add i32 %indvar630.ui, 1"
;
; Make sure that the use of the IV outside of the loop (the store) uses the
; post incremented value of the IV, not the preincremented value. This
-; 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 -mergefunc -stats -disable-output < %s |& grep {functions merged}
+; RUN: opt -mergefunc -stats -disable-output < %s |& grep "functions merged"
; This test is checks whether we can merge
; vector<intptr_t>::push_back(0)
; RUN: opt < %s -reassociate -instcombine -S |\
-; RUN: grep {ret i32 0}
+; RUN: grep "ret i32 0"
define i32 @f(i32 %a0, i32 %a1, i32 %a2, i32 %a3, i32 %a4) {
%tmp.2 = add i32 %a4, %a3 ; <i32> [#uses=1]
; With shl->mul reassociation, we can see that this is (shl A, 9) * A
;
; RUN: opt < %s -reassociate -instcombine -S |\
-; RUN: grep {shl .*, 9}
+; RUN: grep "shl .*, 9"
define i32 @test(i32 %A, i32 %B) {
%X = shl i32 %A, 5 ; <i32> [#uses=1]
-; 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 -S | \
-; RUN: grep {ret i1 false}
+; RUN: grep "ret i1 false"
define i1 @foo() {
%X = and i1 false, undef ; <i1> [#uses=1]
-; RUN: opt < %s -sccp -S | grep {ret i32 %Z}
+; RUN: opt < %s -sccp -S | grep "ret i32 %Z"
; rdar://5778210
declare {i32, i32} @bar(i32 %A)
-; 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 -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]
; RUN: opt < %s -sccp -S | not grep and
; RUN: opt < %s -sccp -S | not grep trunc
-; RUN: opt < %s -sccp -S | grep {ret i100 -1}
+; RUN: opt < %s -sccp -S | grep "ret i100 -1"
define i100 @test(i133 %A) {
%B = and i133 0, %A
-; RUN: opt < %s -ipsccp -S | grep -v {ret i512 undef} | \
-; RUN: grep {ret i8 2}
+; RUN: opt < %s -ipsccp -S | grep -v "ret i512 undef" | \
+; RUN: grep "ret i8 2"
define internal i512 @test(i1 %B) {
br i1 %B, label %BB1, label %BB2
-; 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.
; Scalar replacement was incorrectly promoting this alloca!!
;
; RUN: opt < %s -scalarrepl -S | \
-; RUN: sed {s/;.*//g} | grep {\\\[}
+; RUN: sed "s/;.*//g" | grep "\["
define i8* @test() {
%A = alloca [30 x i8] ; <[30 x i8]*> [#uses=1]
-; 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 -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-n8:16:32"
target triple = "i386-apple-darwin9.1.0"
-; 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"
-; 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
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:64:64-v64:64:64-v128:128:128-a0:0:64"
; PR1226
-; RUN: opt < %s -scalarrepl -S | grep {ret i32 16843009}
+; 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 -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 "7 x double"
+; RUN: opt < %s -scalarrepl -instcombine -S | grep "ret double %B"
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:64:64-v64:64:64-v128:128:128-a0:0:64"
define double @test(double %A, double %B) {
; RUN: opt < %s -scalarrepl -S | \
; RUN: not grep alloca
; RUN: opt < %s -scalarrepl -S | \
-; RUN: grep {bitcast.*float.*i32}
+; RUN: grep "bitcast.*float.*i32"
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:64:64-v64:64:64-v128:128:128-a0:0:64"
define i32 @test(float %X) {
; PR892
; 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-n8:16:32"
target triple = "i686-apple-darwin8.7.2"
; RUN: opt < %s -scalarrepl -S > %t
-; RUN: grep {ret <16 x float> %A} %t
-; RUN: grep {ret <16 x float> zeroinitializer} %t
+; RUN: grep "ret <16 x float> %A" %t
+; RUN: grep "ret <16 x float> zeroinitializer" %t
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:64:64-v64:64:64-v128:128:128-a0:0:64"
define <16 x float> @foo(<16 x float> %A) nounwind {
-; RUN: opt < %s -scalarrepl -S | grep {load volatile}
-; RUN: opt < %s -scalarrepl -S | grep {store volatile}
+; RUN: opt < %s -scalarrepl -S | grep "load volatile"
+; RUN: opt < %s -scalarrepl -S | grep "store volatile"
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: grep {br label}
+; RUN: grep "br label"
;
declare void @foo()
; 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 -S > %t
-; RUN: not grep {^BB.tomerge} %t
-; RUN: grep {^BB.nomerge} %t | count 2
+; RUN: not grep "^BB.tomerge" %t
+; RUN: grep "^BB.nomerge" %t | count 2
; ModuleID = '<stdin>'
declare i1 @foo()
-; 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 -instcombine -simplifycfg -S | grep { = phi } | count 1
+; RUN: opt < %s -instcombine -simplifycfg -S | grep " = phi " | count 1
; instcombine should sort the PHI operands so that simplifycfg can see the
; duplicate and remove it.
; PR1307
; 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: grep "@str,.*i64 3" %t
+; RUN: grep "@str1,.*i64 7" %t
+; RUN: grep "ret i8.*null" %t
; END.
@str = internal constant [5 x i8] c"foog\00"
-; 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 {
; Test that the StrCatOptimizer works correctly
; PR3661
; RUN: opt < %s -simplify-libcalls -S | \
-; RUN: not grep {call.*strcat}
+; RUN: not grep "call.*strcat"
; RUN: opt < %s -simplify-libcalls -S | \
-; RUN: grep {puts.*%arg1}
+; RUN: grep "puts.*%arg1"
; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer.
; Test that the StrNCatOptimizer works correctly
; RUN: opt < %s -simplify-libcalls -S | \
-; RUN: not grep {call.*strncat}
+; RUN: not grep "call.*strncat"
; RUN: opt < %s -simplify-libcalls -S | \
-; RUN: grep {puts.*%arg1}
+; RUN: grep "puts.*%arg1"
; This transformation requires the pointer size, as it assumes that size_t is
; the size of a pointer.
-; 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 | 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"
; This function contains two tail calls, which should be eliminated
-; RUN: opt < %s -tailcallelim -stats -disable-output |& grep {2 tailcallelim}
+; RUN: opt < %s -tailcallelim -stats -disable-output |& grep "2 tailcallelim"
define i32 @Ack(i32 %M.1, i32 %N.1) {
entry:
; RUN: opt < %s -tailcallelim -S | \
-; RUN: grep {call i32 @foo}
+; RUN: grep "call i32 @foo"
declare void @bar(i32*)
; Duplicate the return into if.end to enable TCE.
-; RUN: opt %s -tailcallelim -stats -disable-output |& grep {Number of return duplicated}
+; RUN: opt %s -tailcallelim -stats -disable-output |& grep "Number of return duplicated"
define i32 @fib(i32 %n) nounwind ssp {
entry:
; RUN: opt < %s -tailcallelim -S | \
-; RUN: grep {tail call void @foo}
+; RUN: grep "tail call void @foo"
declare void @foo()
-; RUN: not llvm-as < %s |& grep {value doesn't match function result type 'i32'}
+; RUN: not llvm-as < %s |& grep "value doesn't match function result type 'i32'"
; Verify the the operand type of the ret instructions in a function match the
; delcared return type of the function they live in.
-; RUN: not llvm-as < %s |& grep {invalid getelementptr indices}
+; RUN: not llvm-as < %s |& grep "invalid getelementptr indices"
; This testcase is invalid because we are indexing into a pointer that is
; contained WITHIN a structure.
-; RUN: not llvm-as < %s |& grep {llvm intrinsics cannot be defined}
+; RUN: not llvm-as < %s |& grep "llvm intrinsics cannot be defined"
; PR1047
define void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1) {
-; RUN: not llvm-as %s -o /dev/null |& grep {Cannot allocate unsized type}
+; RUN: not llvm-as %s -o /dev/null |& grep "Cannot allocate unsized type"
; PR2113
define void @test() {
-; RUN: not llvm-as %s -o /dev/null |& grep {alignment argument of memory intrinsics must be a constant int}
+; RUN: not llvm-as %s -o /dev/null |& grep "alignment argument of memory intrinsics must be a constant int"
; PR2318
define void @x(i8* %a, i8* %src, i64 %len, i32 %align) nounwind {
-; RUN: not llvm-as < %s |& grep {value doesn't match function result type 'void'}
+; RUN: not llvm-as < %s |& grep "value doesn't match function result type 'void'"
define void @foo() {
ret i32 0
; RUN: not llvm-as < %s 2> %t
-; RUN: grep {Broken module} %t
+; RUN: grep "Broken module" %t
; PR7316
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32"
-; RUN: not llvm-as < %s |& grep {multiple entries for the same basic block}
+; RUN: not llvm-as < %s |& grep "multiple entries for the same basic block"
-; RUN: not llvm-as < %s |& grep {PHI nodes not grouped at top}
+; RUN: not llvm-as < %s |& grep "PHI nodes not grouped at top"
-; RUN: not llvm-as %s -o /dev/null |& grep {Only PHI nodes may reference their own value}
+; RUN: not llvm-as %s -o /dev/null |& grep "Only PHI nodes may reference their own value"
; Test that self referential instructions are not allowed
-; RUN: not llvm-as %s -o /dev/null |& grep {Aliasing chain should end with function or global variable}
+; RUN: not llvm-as %s -o /dev/null |& grep "Aliasing chain should end with function or global variable"
; Test that alising chain does not create a cycle
config.name = 'LLVM'
# testFormat: The test format to use to interpret tests.
-config.test_format = lit.formats.TclTest()
+execute_external = (sys.platform in ['win32']
+ or lit.getBashPath() not in [None, ""])
+config.test_format = lit.formats.ShTest(execute_external)
# To ignore test output on stderr so it doesn't trigger failures uncomment this:
#config.test_format = lit.formats.TclTest(ignoreStdErr=True)
projects / oota-llvm.git / commitdiff