Upgrade tests to not use llvm-upgrade.

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

26 files changed, 564 insertions, 605 deletions

diff --git a/test/Transforms/InstCombine/div.ll b/test/Transforms/InstCombine/div.ll
index 97f331cb28..b21d39b7a5 100644
--- a/test/Transforms/InstCombine/div.ll
+++ b/test/Transforms/InstCombine/div.ll
@@ -1,69 +1,74 @@
 ; This test makes sure that div instructions are properly eliminated.
 ;
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep div
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep div
 ; END.
 
-implementation
-
-int %test1(int %A) {
-	%B = div int %A, 1
-	ret int %B
+define i32 @test1(i32 %A) {
+        %B = sdiv i32 %A, 1             ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-uint %test2(uint %A) {
-	%B = div uint %A, 8   ; => Shift
-	ret uint %B
+define i32 @test2(i32 %A) {
+        ; => Shift
+        %B = udiv i32 %A, 8             ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test3(int %A) {
-	%B = div int 0, %A    ; => 0, don't need to keep traps
-	ret int %B
+define i32 @test3(i32 %A) {
+        ; => 0, don't need to keep traps
+        %B = sdiv i32 0, %A             ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test4(int %A) {
-	%B = div int %A, -1    ; 0-A
-	ret int %B
+define i32 @test4(i32 %A) {
+        ; 0-A
+        %B = sdiv i32 %A, -1            ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-uint %test5(uint %A) {
-	%B = div uint %A, 4294967280
-	%C = div uint %B, 4294967292
-	ret uint %C
+define i32 @test5(i32 %A) {
+        %B = udiv i32 %A, -16           ; <i32> [#uses=1]
+        %C = udiv i32 %B, -4            ; <i32> [#uses=1]
+        ret i32 %C
 }
 
-bool %test6(uint %A) {
-	%B = div uint %A, 123
-	%C = seteq uint %B, 0   ; A < 123
-	ret bool %C
-} 
+define i1 @test6(i32 %A) {
+        %B = udiv i32 %A, 123           ; <i32> [#uses=1]
+        ; A < 123
+        %C = icmp eq i32 %B, 0          ; <i1> [#uses=1]
+        ret i1 %C
+}
 
-bool %test7(uint %A) {
-	%B = div uint %A, 10
-	%C = seteq uint %B, 2    ; A >= 20 && A < 30
-	ret bool %C
+define i1 @test7(i32 %A) {
+        %B = udiv i32 %A, 10            ; <i32> [#uses=1]
+        ; A >= 20 && A < 30
+        %C = icmp eq i32 %B, 2          ; <i1> [#uses=1]
+        ret i1 %C
 }
 
-bool %test8(ubyte %A) {
-	%B = div ubyte %A, 123
-	%C = seteq ubyte %B, 2   ; A >= 246
-	ret bool %C
-} 
+define i1 @test8(i8 %A) {
+        %B = udiv i8 %A, 123            ; <i8> [#uses=1]
+        ; A >= 246
+        %C = icmp eq i8 %B, 2           ; <i1> [#uses=1]
+        ret i1 %C
+}
 
-bool %test9(ubyte %A) {
-	%B = div ubyte %A, 123
-	%C = setne ubyte %B, 2   ; A < 246
-	ret bool %C
-} 
+define i1 @test9(i8 %A) {
+        %B = udiv i8 %A, 123            ; <i8> [#uses=1]
+        ; A < 246
+        %C = icmp ne i8 %B, 2           ; <i1> [#uses=1]
+        ret i1 %C
+}
 
-uint %test10(uint %X, bool %C) {
-        %V = select bool %C, uint 64, uint 8
-        %R = udiv uint %X, %V
-        ret uint %R
+define i32 @test10(i32 %X, i1 %C) {
+        %V = select i1 %C, i32 64, i32 8                ; <i32> [#uses=1]
+        %R = udiv i32 %X, %V            ; <i32> [#uses=1]
+        ret i32 %R
 }
 
-int %test11(int %X, bool %C) {
-        %A = select bool %C, int 1024, int 32
-        %B = udiv int %X, %A
-        ret int %B
+define i32 @test11(i32 %X, i1 %C) {
+        %A = select i1 %C, i32 1024, i32 32             ; <i32> [#uses=1]
+        %B = udiv i32 %X, %A            ; <i32> [#uses=1]
+        ret i32 %B
 }
diff --git a/test/Transforms/InstCombine/memmove.ll b/test/Transforms/InstCombine/memmove.ll
index 52ed592b18..66ed174ad5 100644
--- a/test/Transforms/InstCombine/memmove.ll
+++ b/test/Transforms/InstCombine/memmove.ll
@@ -1,23 +1,19 @@
 ; This test makes sure that memmove instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | \
 ; RUN:    not grep {call void @llvm.memmove}
 
-%S = internal constant [33 x sbyte] c"panic: restorelist inconsistency\00"
+@S = internal constant [33 x i8] c"panic: restorelist inconsistency\00"		; <[33 x i8]*> [#uses=1]
 
-implementation
+declare void @llvm.memmove.i32(i8*, i8*, i32, i32)
 
-declare void %llvm.memmove.i32(sbyte*, sbyte*, uint, uint)
-
-void %test1(sbyte* %A, sbyte* %B, uint %N) {
- 	;; 0 bytes -> noop.
-	call void %llvm.memmove.i32(sbyte* %A, sbyte* %B, uint 0, uint 1)
+define void @test1(i8* %A, i8* %B, i32 %N) {
+	call void @llvm.memmove.i32( i8* %A, i8* %B, i32 0, i32 1 )
 	ret void
 }
 
-void %test2(sbyte *%A, uint %N) {
- 	;; dest can't alias source since we can't write to source!
-	call void %llvm.memmove.i32(sbyte* %A, sbyte* getelementptr ([33 x sbyte]* %S, int 0, int 0), 
-                                uint %N, uint 1)
+define void @test2(i8* %A, i32 %N) {
+        ;; dest can't alias source since we can't write to source!
+	call void @llvm.memmove.i32( i8* %A, i8* getelementptr ([33 x i8]* @S, i32 0, i32 0), i32 %N, i32 1 )
 	ret void
 }
diff --git a/test/Transforms/InstCombine/mul.ll b/test/Transforms/InstCombine/mul.ll
index 1d5c286281..8e9ab8d421 100644
--- a/test/Transforms/InstCombine/mul.ll
+++ b/test/Transforms/InstCombine/mul.ll
@@ -1,74 +1,80 @@
 ; This test makes sure that mul instructions are properly eliminated.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep mul
+; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep mul
 ; END.
 
-implementation
-
-int %test1(int %A) {
-	%B = mul int %A, 1
-	ret int %B
+define i32 @test1(i32 %A) {
+        %B = mul i32 %A, 1              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test2(int %A) {
-	%B = mul int %A, 2   ; Should convert to an add instruction
-	ret int %B
+define i32 @test2(i32 %A) {
+        ; Should convert to an add instruction
+        %B = mul i32 %A, 2              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-int %test3(int %A) {
-	%B = mul int %A, 0   ; This should disappear entirely
-	ret int %B
+define i32 @test3(i32 %A) {
+        ; This should disappear entirely
+        %B = mul i32 %A, 0              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-double %test4(double %A) {
-	%B = mul double 1.0, %A   ; This is safe for FP
-	ret double %B
+define double @test4(double %A) {
+        ; This is safe for FP
+        %B = mul double 1.000000e+00, %A                ; <double> [#uses=1]
+        ret double %B
 }
 
-int %test5(int %A) {
-	%B = mul int %A, 8
-	ret int %B
+define i32 @test5(i32 %A) {
+        %B = mul i32 %A, 8              ; <i32> [#uses=1]
+        ret i32 %B
 }
 
-ubyte %test6(ubyte %A) {
-	%B = mul ubyte %A, 8
-	%C = mul ubyte %B, 8
-	ret ubyte %C
+define i8 @test6(i8 %A) {
+        %B = mul i8 %A, 8               ; <i8> [#uses=1]
+        %C = mul i8 %B, 8               ; <i8> [#uses=1]
+        ret i8 %C
 }
 
-int %test7(int %i) {
-        %tmp = mul int %i, -1   ; %tmp = sub 0, %i
-        ret int %tmp
+define i32 @test7(i32 %i) {
+        %tmp = mul i32 %i, -1           ; <i32> [#uses=1]
+        ret i32 %tmp
 }
 
-ulong %test8(ulong %i) {
-	%j = mul ulong %i, 18446744073709551615 ; tmp = sub 0, %i
-	ret ulong %j
+define i64 @test8(i64 %i) {
+       ; tmp = sub 0, %i
+        %j = mul i64 %i, -1             ; <i64> [#uses=1]
+        ret i64 %j
 }
 
-uint %test9(uint %i) {
-	%j = mul uint %i, 4294967295    ; %j = sub 0, %i
-	ret uint %j
+define i32 @test9(i32 %i) {
+        ; %j = sub 0, %i
+        %j = mul i32 %i, -1             ; <i32> [#uses=1]
+        ret i32 %j
 }
 
-uint %test10(int %a, uint %b) {
-	%c = setlt int %a, 0
-	%d = cast bool %c to uint
-	%e = mul uint %d, %b           ; e = b & (a >> 31)
-	ret uint %e
+define i32 @test10(i32 %a, i32 %b) {
+        %c = icmp slt i32 %a, 0         ; <i1> [#uses=1]
+        %d = zext i1 %c to i32          ; <i32> [#uses=1]
+       ; e = b & (a >> 31)
+        %e = mul i32 %d, %b             ; <i32> [#uses=1]
+        ret i32 %e
 }
 
-uint %test11(int %a, uint %b) {
-	%c = setle int %a, -1
-	%d = cast bool %c to uint
-	%e = mul uint %d, %b           ; e = b & (a >> 31)
-	ret uint %e
+define i32 @test11(i32 %a, i32 %b) {
+        %c = icmp sle i32 %a, -1                ; <i1> [#uses=1]
+        %d = zext i1 %c to i32          ; <i32> [#uses=1]
+        ; e = b & (a >> 31)
+        %e = mul i32 %d, %b             ; <i32> [#uses=1]
+        ret i32 %e
 }
 
-uint %test12(ubyte %a, uint %b) {
-	%c = setgt ubyte %a, 127
-	%d = cast bool %c to uint
-	%e = mul uint %d, %b           ; e = b & (a >> 31)
-	ret uint %e
+define i32 @test12(i8 %a, i32 %b) {
+        %c = icmp ugt i8 %a, 127                ; <i1> [#uses=1]
+        %d = zext i1 %c to i32          ; <i32> [#uses=1]
+        ; e = b & (a >> 31)
+        %e = mul i32 %d, %b             ; <i32> [#uses=1]
+        ret i32 %e
 }
 
diff --git a/test/Transforms/SimplifyCFG/BrUnwind.ll b/test/Transforms/SimplifyCFG/BrUnwind.ll
index 73bd9756c1..1acdecd578 100644
--- a/test/Transforms/SimplifyCFG/BrUnwind.ll
+++ b/test/Transforms/SimplifyCFG/BrUnwind.ll
@@ -1,14 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN: not grep {br label}
 
-void %test(bool %C) {
-	br bool %C, label %A, label %B
-A:
-	call void %test(bool %C)
-	br label %X
-B:
-	call void %test(bool %C)
-	br label %X
-X:
-	unwind
+define void @test(i1 %C) {
+        br i1 %C, label %A, label %B
+A:              ; preds = %0
+        call void @test( i1 %C )
+        br label %X
+B:              ; preds = %0
+        call void @test( i1 %C )
+        br label %X
+X:              ; preds = %B, %A
+        unwind
 }
+
diff --git a/test/Transforms/SimplifyCFG/DeadSetCC.ll b/test/Transforms/SimplifyCFG/DeadSetCC.ll
index ea215e39e9..a4c8366e00 100644
--- a/test/Transforms/SimplifyCFG/DeadSetCC.ll
+++ b/test/Transforms/SimplifyCFG/DeadSetCC.ll
@@ -1,27 +1,28 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not grep {icmp eq}
 
 ; Check that simplifycfg deletes a dead 'seteq' instruction when it
 ; folds a conditional branch into a switch instruction.
 
-declare void %foo()
-declare void %bar()
+declare void @foo()
 
-void %testcfg(uint %V) {
-	%C = seteq uint %V, 18
-	%D = seteq uint %V, 180
-	%E = or bool %C, %D
-	br bool %E, label %L1, label %Sw
-Sw:
-       switch uint %V, label %L1 [
-              uint 15, label %L2
-              uint 16, label %L2
+declare void @bar()
+
+define void @testcfg(i32 %V) {
+        %C = icmp eq i32 %V, 18         ; <i1> [#uses=1]
+        %D = icmp eq i32 %V, 180                ; <i1> [#uses=1]
+        %E = or i1 %C, %D               ; <i1> [#uses=1]
+        br i1 %E, label %L1, label %Sw
+Sw:             ; preds = %0
+        switch i32 %V, label %L1 [
+                 i32 15, label %L2
+                 i32 16, label %L2
         ]
-L1:
-	call void %foo()
-	ret void
-L2:
-	call void %bar()
-	ret void
+L1:             ; preds = %Sw, %0
+        call void @foo( )
+        ret void
+L2:             ; preds = %Sw, %Sw
+        call void @bar( )
+        ret void
 }
 
diff --git a/test/Transforms/SimplifyCFG/EqualPHIEdgeBlockMerge.ll b/test/Transforms/SimplifyCFG/EqualPHIEdgeBlockMerge.ll
index 3c1f14185c..55db7880f1 100644
--- a/test/Transforms/SimplifyCFG/EqualPHIEdgeBlockMerge.ll
+++ b/test/Transforms/SimplifyCFG/EqualPHIEdgeBlockMerge.ll
@@ -1,18 +1,18 @@
 ; Test merging of blocks with phi nodes.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | not grep N:
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | not grep N:
 ;
 
-int %test(bool %a) {
+define i32 @test(i1 %a) {
 Q:
-	br bool %a, label %N, label %M
-N:
-	br label %M
-M:
-	; It's ok to merge N and M because the incoming values for W are the 
+        br i1 %a, label %N, label %M
+N:              ; preds = %Q
+        br label %M
+M:              ; preds = %N, %Q
+        ; It's ok to merge N and M because the incoming values for W are the
         ; same for both cases...
-	%W = phi int [2, %N], [2, %Q]
-	%R = add int %W, 1
-	ret int %R
+        %W = phi i32 [ 2, %N ], [ 2, %Q ]               ; <i32> [#uses=1]
+        %R = add i32 %W, 1              ; <i32> [#uses=1]
+        ret i32 %R
 }
 
diff --git a/test/Transforms/SimplifyCFG/HoistCode.ll b/test/Transforms/SimplifyCFG/HoistCode.ll
index b817477161..d8894a6faa 100644
--- a/test/Transforms/SimplifyCFG/HoistCode.ll
+++ b/test/Transforms/SimplifyCFG/HoistCode.ll
@@ -1,11 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | not grep br
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | not grep br
 
-void %foo(bool %C, int* %P) {
-	br bool %C, label %T, label %F
-T:
-	store int 7, int* %P
-	ret void
-F:
-	store int 7, int* %P
-	ret void
+define void @foo(i1 %C, i32* %P) {
+        br i1 %C, label %T, label %F
+T:              ; preds = %0
+        store i32 7, i32* %P
+        ret void
+F:              ; preds = %0
+        store i32 7, i32* %P
+        ret void
 }
diff --git a/test/Transforms/SimplifyCFG/InvokeEliminate.ll b/test/Transforms/SimplifyCFG/InvokeEliminate.ll
index 89d76a8492..4f52f6b72e 100644
--- a/test/Transforms/SimplifyCFG/InvokeEliminate.ll
+++ b/test/Transforms/SimplifyCFG/InvokeEliminate.ll
@@ -3,16 +3,16 @@
 
 ; If this test is successful, the function should be reduced to 'call; ret'
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not egrep {\\(invoke\\)|\\(br\\)}
 
-declare void %bar()
+declare void @bar()
 
-int %test() {
-	invoke void %bar() to label %Ok except label %Rethrow
-Ok:
-	ret int 0
-Rethrow:
-	unwind
+define i32 @test() {
+        invoke void @bar( )
+                        to label %Ok unwind label %Rethrow
+Ok:             ; preds = %0
+        ret i32 0
+Rethrow:                ; preds = %0
+        unwind
 }
-
diff --git a/test/Transforms/SimplifyCFG/PhiBlockMerge.ll b/test/Transforms/SimplifyCFG/PhiBlockMerge.ll
index 7b24426959..f3844f7328 100644
--- a/test/Transforms/SimplifyCFG/PhiBlockMerge.ll
+++ b/test/Transforms/SimplifyCFG/PhiBlockMerge.ll
@@ -1,23 +1,22 @@
 ; Test merging of blocks that only have PHI nodes in them
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | not grep N:
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | not grep N:
 ;
 
-int %test(bool %a, bool %b) {
-        br bool %a, label %M, label %O
-
-O:
-	br bool %b, label %N, label %Q
-Q:
-	br label %N
-N:
-	%Wp = phi int [0, %O], [1, %Q]
-	; This block should be foldable into M
-	br label %M
-
-M:
-	%W = phi int [%Wp, %N], [2, %0]
-	%R = add int %W, 1
-	ret int %R
+define i32 @test(i1 %a, i1 %b) {
+; <label>:0
+        br i1 %a, label %M, label %O
+O:              ; preds = %0
+        br i1 %b, label %N, label %Q
+Q:              ; preds = %O
+        br label %N
+N:              ; preds = %Q, %O
+        ; This block should be foldable into M
+        %Wp = phi i32 [ 0, %O ], [ 1, %Q ]              ; <i32> [#uses=1]
+        br label %M
+M:              ; preds = %N, %0
+        %W = phi i32 [ %Wp, %N ], [ 2, %0 ]             ; <i32> [#uses=1]
+        %R = add i32 %W, 1              ; <i32> [#uses=1]
+        ret i32 %R
 }
 
diff --git a/test/Transforms/SimplifyCFG/PhiEliminate.ll b/test/Transforms/SimplifyCFG/PhiEliminate.ll
index ef2433c11b..94697c96b7 100644
--- a/test/Transforms/SimplifyCFG/PhiEliminate.ll
+++ b/test/Transforms/SimplifyCFG/PhiEliminate.ll
@@ -3,36 +3,39 @@
 ; nodes away allows the branches to be eliminated, performing a simple form of
 ; 'if conversion'.
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis > %t.xform
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis > %t.xform
 ; RUN:   not grep phi %t.xform 
 ; RUN:   grep ret %t.xform
 
-declare void %use(bool)
-declare void %use(int)
+declare void @use(i1)
 
+declare void @use.upgrd.1(i32)
 
-void %test2(bool %c, bool %d, int %V, int %V2) {
-	br bool %d, label %X, label %F
-X:
-	br bool %c, label %T, label %F
-T:
-	br label %F
-F:
-	%B1 = phi bool [true, %0], [false, %T], [false, %X]
-	%I7 = phi int  [%V, %0], [%V2, %T], [%V2, %X]
-	call void %use(bool %B1)
-	call void %use(int  %I7)
-	ret void
+define void @test2(i1 %c, i1 %d, i32 %V, i32 %V2) {
+; <label>:0
+        br i1 %d, label %X, label %F
+X:              ; preds = %0
+        br i1 %c, label %T, label %F
+T:              ; preds = %X
+        br label %F
+F:              ; preds = %T, %X, %0
+        %B1 = phi i1 [ true, %0 ], [ false, %T ], [ false, %X ]         ; <i1> [#uses=1]
+        %I7 = phi i32 [ %V, %0 ], [ %V2, %T ], [ %V2, %X ]              ; <i32> [#uses=1]
+        call void @use( i1 %B1 )
+        call void @use.upgrd.1( i32 %I7 )
+        ret void
 }
 
-void %test(bool %c, int %V, int %V2) {
-	br bool %c, label %T, label %F
-T:
-	br label %F
-F:
-	%B1 = phi bool [true, %0], [false, %T]
-	%I6 = phi int  [%V, %0], [0, %T]
-	call void %use(bool %B1)
-	call void %use(int  %I6)
-	ret void
+define void @test(i1 %c, i32 %V, i32 %V2) {
+; <label>:0
+        br i1 %c, label %T, label %F
+T:              ; preds = %0
+        br label %F
+F:              ; preds = %T, %0
+        %B1 = phi i1 [ true, %0 ], [ false, %T ]                ; <i1> [#uses=1]
+        %I6 = phi i32 [ %V, %0 ], [ 0, %T ]             ; <i32> [#uses=1]
+        call void @use( i1 %B1 )
+        call void @use.upgrd.1( i32 %I6 )
+        ret void
 }
+
diff --git a/test/Transforms/SimplifyCFG/PhiEliminate2.ll b/test/Transforms/SimplifyCFG/PhiEliminate2.ll
index fb00a1342b..ec1b91a0d1 100644
--- a/test/Transforms/SimplifyCFG/PhiEliminate2.ll
+++ b/test/Transforms/SimplifyCFG/PhiEliminate2.ll
@@ -1,15 +1,14 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | not grep br
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | not grep br
 
-int %test(bool %C, int %V1, int %V2) {
+define i32 @test(i1 %C, i32 %V1, i32 %V2) {
 entry:
-        br bool %C, label %then, label %Cont
-
-then:
-        %V3 = or int %V2, %V1
+        br i1 %C, label %then, label %Cont
+then:           ; preds = %entry
+        %V3 = or i32 %V2, %V1           ; <i32> [#uses=1]
         br label %Cont
-Cont:
-	%V4 = phi int [%V1, %entry], [%V3, %then]
-	call int %test(bool false, int 0, int 0)           ;; don't fold into preds
-        ret int %V1
+Cont:           ; preds = %then, %entry
+        %V4 = phi i32 [ %V1, %entry ], [ %V3, %then ]           ; <i32> [#uses=0]
+        call i32 @test( i1 false, i32 0, i32 0 )                ; <i32>:0 [#uses=0]
+        ret i32 %V1
 }
 
diff --git a/test/Transforms/SimplifyCFG/PhiNoEliminate.ll b/test/Transforms/SimplifyCFG/PhiNoEliminate.ll
index 4535541383..dfe122abbf 100644
--- a/test/Transforms/SimplifyCFG/PhiNoEliminate.ll
+++ b/test/Transforms/SimplifyCFG/PhiNoEliminate.ll
@@ -1,30 +1,27 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not grep select
 
 ;; The PHI node in this example should not be turned into a select, as we are
 ;; not able to ifcvt the entire block.  As such, converting to a select just 
 ;; introduces inefficiency without saving copies.
 
-int %bar(bool %C) {
+define i32 @bar(i1 %C) {
 entry:
-        br bool %C, label %then, label %endif
-
-then:
-        %tmp.3 = call int %qux()
+        br i1 %C, label %then, label %endif
+then:           ; preds = %entry
+        %tmp.3 = call i32 @qux( )               ; <i32> [#uses=0]
         br label %endif
-
-endif:
-	%R = phi int [123, %entry], [12312, %then]
-	;; stuff to disable tail duplication
-        call int %qux()
-        call int %qux()
-        call int %qux()
-        call int %qux()
-        call int %qux()
-        call int %qux()
-        call int %qux()
-        ret int %R
+endif:          ; preds = %then, %entry
+        %R = phi i32 [ 123, %entry ], [ 12312, %then ]          ; <i32> [#uses=1]
+        ;; stuff to disable tail duplication
+        call i32 @qux( )                ; <i32>:0 [#uses=0]
+        call i32 @qux( )                ; <i32>:1 [#uses=0]
+        call i32 @qux( )                ; <i32>:2 [#uses=0]
+        call i32 @qux( )                ; <i32>:3 [#uses=0]
+        call i32 @qux( )                ; <i32>:4 [#uses=0]
+        call i32 @qux( )                ; <i32>:5 [#uses=0]
+        call i32 @qux( )                ; <i32>:6 [#uses=0]
+        ret i32 %R
 }
 
-declare int %qux()
-
+declare i32 @qux()
diff --git a/test/Transforms/SimplifyCFG/UncondBranchToReturn.ll b/test/Transforms/SimplifyCFG/UncondBranchToReturn.ll
index 6ab16218f3..e6c05f3bee 100644
--- a/test/Transforms/SimplifyCFG/UncondBranchToReturn.ll
+++ b/test/Transforms/SimplifyCFG/UncondBranchToReturn.ll
@@ -2,32 +2,32 @@
 ; a PHI node and a return.  Make sure the simplify cfg can straighten out this
 ; important case.  This is basically the most trivial form of tail-duplication.
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:    not grep {br label}
 
-int %test(bool %B, int %A, int %B) {
-	br bool %B, label %T, label %F
-T:
-	br label %ret
-F:
-	br label %ret
-ret:
-	%X = phi int [%A, %F], [%B, %T]
-	ret int %X
+define i32 @test(i1 %B, i32 %A, i32 %B.upgrd.1) {
+        br i1 %B, label %T, label %F
+T:              ; preds = %0
+        br label %ret
+F:              ; preds = %0
+        br label %ret
+ret:            ; preds = %F, %T
+        %X = phi i32 [ %A, %F ], [ %B.upgrd.1, %T ]             ; <i32> [#uses=1]
+        ret i32 %X
 }
 
+
 ; Make sure it's willing to move unconditional branches to return instructions
 ; as well, even if the return block is shared and the source blocks are
 ; non-empty.
-int %test2(bool %B, int %A, int %B) {
-	br bool %B, label %T, label %F
-T:
-	call int %test(bool true, int 5, int 8)
-	br label %ret
-F:
-	call int %test(bool true, int 5, int 8)
-	br label %ret
-ret:
-	ret int %A
+define i32 @test2(i1 %B, i32 %A, i32 %B.upgrd.2) {
+        br i1 %B, label %T, label %F
+T:              ; preds = %0
+        call i32 @test( i1 true, i32 5, i32 8 )         ; <i32>:1 [#uses=0]
+        br label %ret
+F:              ; preds = %0
+        call i32 @test( i1 true, i32 5, i32 8 )         ; <i32>:2 [#uses=0]
+        br label %ret
+ret:            ; preds = %F, %T
+        ret i32 %A
 }
-
diff --git a/test/Transforms/SimplifyCFG/UnreachableEliminate.ll b/test/Transforms/SimplifyCFG/UnreachableEliminate.ll
index 22cd3d4685..3c44919373 100644
--- a/test/Transforms/SimplifyCFG/UnreachableEliminate.ll
+++ b/test/Transforms/SimplifyCFG/UnreachableEliminate.ll
@@ -1,29 +1,33 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | not grep unreachable
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | not grep unreachable
 
-void %test1(bool %C, bool* %BP) {
-	br bool %C, label %T, label %F
-T:
-	store bool %C, bool* %BP  ;; dead
-	unreachable
-F:
-	ret void
+define void @test1(i1 %C, i1* %BP) {
+        br i1 %C, label %T, label %F
+T:              ; preds = %0
+        store i1 %C, i1* %BP
+        unreachable
+F:              ; preds = %0
+        ret void
 }
 
-void %test2() {
-	invoke void %test2() to label %N unwind label %U
-U:
-	unreachable
-N:
-	ret void
+define void @test2() {
+        invoke void @test2( )
+                        to label %N unwind label %U
+U:              ; preds = %0
+        unreachable
+N:              ; preds = %0
+        ret void
 }
 
-int %test3(int %v) {
-	switch int %v, label %default [ int 1, label %U
-                                        int 2, label %T]
-default:
-	ret int 1
-U:
-	unreachable
-T:
-	ret int 2
+define i32 @test3(i32 %v) {
+        switch i32 %v, label %default [
+                 i32 1, label %U
+                 i32 2, label %T
+        ]
+default:                ; preds = %0
+        ret i32 1
+U:              ; preds = %0
+        unreachable
+T:              ; preds = %0
+        ret i32 2
 }
+
diff --git a/test/Transforms/SimplifyCFG/basictest.ll b/test/Transforms/SimplifyCFG/basictest.ll
index 18fa8978ca..1fd629a4fd 100644
--- a/test/Transforms/SimplifyCFG/basictest.ll
+++ b/test/Transforms/SimplifyCFG/basictest.ll
@@ -1,24 +1,25 @@
 ; Test CFG simplify removal of branch instructions...
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | not grep br
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | not grep br
 
-
-void "test1"() {
-	br label %BB1
-BB1:
-	ret void
+define void @test1() {
+        br label %BB1
+BB1:            ; preds = %0
+        ret void
 }
 
-void "test2"() {
-	ret void
-BB1:
-	ret void
+define void @test2() {
+        ret void
+BB1:            ; No predecessors!
+        ret void
 }
 
-void "test3"(bool %T) {
-	br bool %T, label %BB1, label %BB1
-BB1:
-	ret void
+define void @test3(i1 %T) {
+        br i1 %T, label %BB1, label %BB1
+BB1:            ; preds = %0, %0
+        ret void
 }
 
 
+
+
diff --git a/test/Transforms/SimplifyCFG/branch-cond-merge.ll b/test/Transforms/SimplifyCFG/branch-cond-merge.ll
index 2a93057959..ae46503658 100644
--- a/test/Transforms/SimplifyCFG/branch-cond-merge.ll
+++ b/test/Transforms/SimplifyCFG/branch-cond-merge.ll
@@ -1,22 +1,19 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -instcombine \
+; RUN: llvm-as < %s | opt -simplifycfg -instcombine \
 ; RUN:   -simplifycfg | llvm-dis | not grep call
 
-declare void %bar()
+declare void @bar()
 
-void %test(int %X, int %Y) {