-; RUN: llvm-as < %s | opt -constmerge | llvm-dis | grep -C2 foo | grep bar
+; RUN: llvm-as < %s | opt -constmerge | llvm-dis | %prcontext foo 2 | grep bar
%foo = constant int 6
%bar = constant int 6
-; RUN: llvm-as < %s | opt -indvars | llvm-dis | grep -C1 Loop: | grep %indvar
+; RUN: llvm-as < %s | opt -indvars | llvm-dis | %prcontext Loop: 1 | grep %indvar
; The indvar simplification code should ensure that the first PHI in the block
; is the canonical one!
; This test ensures that alloca instructions in the entry block for an inlined
; function are moved to the top of the function they are inlined into.
;
-; RUN: llvm-as < %s | opt -inline | llvm-dis | grep -C1 alloca | grep Entry:
+; RUN: llvm-as < %s | opt -inline | llvm-dis | %prcontext alloca 1 | grep Entry:
int %func(int %i) {
%X = alloca int
; This testcase tests for a problem where LICM hoists
; potentially trapping instructions when they are not guaranteed to execute.
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C2 "IfUnEqual" | grep div
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext "IfUnEqual" 2 | grep div
%X = global int 0
declare void %foo()
; This testcase tests to make sure a trapping instruction is hoisted when
; it is guaranteed to execute.
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C2 "test" | grep div
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext "test" 2 | grep div
%X = global int 0
declare void %foo(int)
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 volatile | grep Loop
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext volatile 1 | grep Loop
%X = global int 7
-; RUN: llvm-as < %s | opt -basicaa -licm | llvm-dis | grep -C1 sin | grep Out:
+; RUN: llvm-as < %s | opt -basicaa -licm | llvm-dis | %prcontext sin 1 | grep Out:
declare double %sin(double)
declare void %foo()
-; RUN: llvm-as < %s | opt -basicaa -licm | llvm-dis | grep -C1 strlen | grep Out:
+; RUN: llvm-as < %s | opt -basicaa -licm | llvm-dis | %prcontext strlen 1 | grep Out:
declare int %strlen(sbyte*)
declare void %foo()
; This testcase checks to make sure the sinker does not cause problems with
; critical edges.
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 add | grep Exit
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext add 1 | grep Exit
implementation ; Functions:
; the instruction to the exit blocks instead of executing it on every
; iteration of the loop.
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 mul | grep Out:
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext mul 1 | grep Out:
int %test(int %N) {
Entry:
; result of the load is only used outside of the loop, sink the load instead of
; hoisting it!
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 load | grep Out:
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext load 1 | grep Out:
%X = global int 5
; instructions from the loop. Instead they got hoisted, which is better than
; leaving them in the loop, but increases register pressure pointlessly.
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 getelementptr | grep Out:
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext getelementptr 1 | grep Out:
%Ty = type { int, int }
%X = external global %Ty
; This testcase ensures that we can sink instructions from loops with
; multiple exits.
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 mul | grep 'Out[12]:'
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext mul 1 | grep 'Out[12]:'
int %test(int %N, bool %C) {
Entry:
; some exits out of the loop, and that we can do so without breaking dominator
; info.
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 add | grep exit2:
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext add 1 | grep exit2:
implementation ; Functions:
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 add | grep preheader.loopexit:
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext add 1 | grep preheader.loopexit:
implementation
; Potentially trapping instructions may be sunk as long as they are guaranteed
; to be executed.
;
-; RUN: llvm-as < %s | opt -licm | llvm-dis | grep -C1 div | grep Out:
+; RUN: llvm-as < %s | opt -licm | llvm-dis | %prcontext div 1 | grep Out:
int %test(int %N) {
Entry: