Use the new prcontext script.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15427 91177308-0d34-0410-b5e6-96231b3b80d8

test/Transforms/ConstantMerge/2003-10-28-MergeExternalConstants.ll

@@ -1,4 +1,4 @@
-; 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

test/Transforms/IndVarsSimplify/2003-09-23-NotAtTop.ll

@@ -1,4 +1,4 @@
-; 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!

test/Transforms/Inline/alloca_test.ll

@@ -1,7 +1,7 @@
 ; 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 

test/Transforms/LICM/2003-08-04-TrappingInstHoist.ll

@@ -1,7 +1,7 @@
 ; 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()

test/Transforms/LICM/2003-08-04-TrappingInstOkHoist.ll

@@ -1,7 +1,7 @@
 ; 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)

test/Transforms/LICM/2003-12-13-VolatilePromote.ll

@@ -1,4 +1,4 @@
-; 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
 

test/Transforms/LICM/call_sink_const_function.ll

@@ -1,4 +1,4 @@
-; 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()
 

test/Transforms/LICM/call_sink_pure_function.ll

@@ -1,4 +1,4 @@
-; 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()
 

test/Transforms/LICM/sink_critical_edge.ll

@@ -1,7 +1,7 @@
 ; 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:
 

test/Transforms/LICM/sink_inst.ll

@@ -2,7 +2,7 @@
 ; 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:

test/Transforms/LICM/sink_load.ll

@@ -2,7 +2,7 @@
 ; 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
 

test/Transforms/LICM/sink_multiple.ll

@@ -3,7 +3,7 @@
 ; 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

test/Transforms/LICM/sink_multiple_exits.ll

@@ -1,7 +1,7 @@
 ; 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:

test/Transforms/LICM/sink_only_some_exits.ll

@@ -2,7 +2,7 @@
 ; 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:
 

test/Transforms/LICM/sink_phi_node_use.ll

@@ -1,4 +1,4 @@
-; 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
 

test/Transforms/LICM/sink_trapping_inst.ll

@@ -1,7 +1,7 @@
 ; 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: