diff --git a/test/DebugInfo/funccall.ll b/test/DebugInfo/funccall.ll
index cb5dab6..47fe4c2 100644
--- a/test/DebugInfo/funccall.ll
+++ b/test/DebugInfo/funccall.ll
@@ -1,166 +1,147 @@
-;; RUN: llvm-upgrade < %s | llvm-as | llc
+;; RUN: llvm-as < %s | llc
+	%llvm.dbg.anchor.type = type { i32, i32 }
+	%llvm.dbg.basictype.type = type { i32, {  }*, i8*, {  }*, i32, i64, i64, i64, i32, i32 }
+	%llvm.dbg.compile_unit.type = type { i32, {  }*, i32, i8*, i8*, i8* }
+	%llvm.dbg.global_variable.type = type { i32, {  }*, {  }*, i8*, i8*, i8*, {  }*, i32, {  }*, i1, i1, {  }* }
+	%llvm.dbg.subprogram.type = type { i32, {  }*, {  }*, i8*, i8*, i8*, {  }*, i32, {  }*, i1, i1 }
+	%llvm.dbg.variable.type = type { i32, {  }*, i8*, {  }*, i32, {  }* }
+@llvm.dbg.subprograms = linkonce constant %llvm.dbg.anchor.type { i32 393216, i32 46 }, section "llvm.metadata"		; <%llvm.dbg.anchor.type*> [#uses=1]
+@llvm.dbg.compile_units = linkonce constant %llvm.dbg.anchor.type { i32 393216, i32 17 }, section "llvm.metadata"		; <%llvm.dbg.anchor.type*> [#uses=1]
+@llvm.dbg.global_variables = linkonce constant %llvm.dbg.anchor.type { i32 393216, i32 52 }, section "llvm.metadata"		; <%llvm.dbg.anchor.type*> [#uses=1]
+@llvm.dbg.subprogram = internal constant %llvm.dbg.subprogram.type {
+    i32 393262, 
+    {  }* bitcast (%llvm.dbg.anchor.type* @llvm.dbg.subprograms to {  }*), 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i8* getelementptr ([4 x i8]* @str, i32 0, i32 0), 
+    i8* getelementptr ([4 x i8]* @str, i32 0, i32 0), 
+    i8* null, 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i32 4, 
+    {  }* null, 
+    i1 false, 
+    i1 true }, section "llvm.metadata"		; <%llvm.dbg.subprogram.type*> [#uses=1]
+@str = internal constant [4 x i8] c"foo\00", section "llvm.metadata"		; <[4 x i8]*> [#uses=1]
+@llvm.dbg.compile_unit = internal constant %llvm.dbg.compile_unit.type {
+    i32 393233, 
+    {  }* bitcast (%llvm.dbg.anchor.type* @llvm.dbg.compile_units to {  }*), 
+    i32 1, 
+    i8* getelementptr ([11 x i8]* @str1, i32 0, i32 0), 
+    i8* getelementptr ([50 x i8]* @str2, i32 0, i32 0), 
+    i8* getelementptr ([45 x i8]* @str3, i32 0, i32 0) }, section "llvm.metadata"		; <%llvm.dbg.compile_unit.type*> [#uses=1]
+@str1 = internal constant [11 x i8] c"funccall.c\00", section "llvm.metadata"		; <[11 x i8]*> [#uses=1]
+@str2 = internal constant [50 x i8] c"/Volumes/Big2/llvm/llvm/test/Regression/Debugger/\00", section "llvm.metadata"		; <[50 x i8]*> [#uses=1]
+@str3 = internal constant [45 x i8] c"4.0.1 LLVM (Apple Computer, Inc. build 5421)\00", section "llvm.metadata"		; <[45 x i8]*> [#uses=1]
+@llvm.dbg.variable = internal constant %llvm.dbg.variable.type {
+    i32 393472, 
+    {  }* bitcast (%llvm.dbg.subprogram.type* @llvm.dbg.subprogram to {  }*), 
+    i8* getelementptr ([2 x i8]* @str4, i32 0, i32 0), 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i32 5, 
+    {  }* bitcast (%llvm.dbg.basictype.type* @llvm.dbg.basictype to {  }*) }, section "llvm.metadata"		; <%llvm.dbg.variable.type*> [#uses=1]
+@str4 = internal constant [2 x i8] c"t\00", section "llvm.metadata"		; <[2 x i8]*> [#uses=1]
+@llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
+    i32 393252, 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i8* getelementptr ([4 x i8]* @str15, i32 0, i32 0), 
+    {  }* null, 
+    i32 0, 
+    i64 32, 
+    i64 32, 
+    i64 0, 
+    i32 0, 
+    i32 5 }, section "llvm.metadata"		; <%llvm.dbg.basictype.type*> [#uses=1]
+@str15 = internal constant [4 x i8] c"int\00", section "llvm.metadata"		; <[4 x i8]*> [#uses=1]
+@llvm.dbg.subprogram2 = internal constant %llvm.dbg.subprogram.type {
+    i32 393262, 
+    {  }* bitcast (%llvm.dbg.anchor.type* @llvm.dbg.subprograms to {  }*), 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i8* getelementptr ([5 x i8]* @str6, i32 0, i32 0), 
+    i8* getelementptr ([5 x i8]* @str6, i32 0, i32 0), 
+    i8* null, 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i32 8, 
+    {  }* bitcast (%llvm.dbg.basictype.type* @llvm.dbg.basictype to {  }*), 
+    i1 false, 
+    i1 true }, section "llvm.metadata"		; <%llvm.dbg.subprogram.type*> [#uses=1]
+@str6 = internal constant [5 x i8] c"main\00", section "llvm.metadata"		; <[5 x i8]*> [#uses=1]
+@llvm.dbg.variable3 = internal constant %llvm.dbg.variable.type {
+    i32 393474, 
+    {  }* bitcast (%llvm.dbg.subprogram.type* @llvm.dbg.subprogram2 to {  }*), 
+    i8* getelementptr ([7 x i8]* @str7, i32 0, i32 0), 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i32 8, 
+    {  }* bitcast (%llvm.dbg.basictype.type* @llvm.dbg.basictype to {  }*) }, section "llvm.metadata"		; <%llvm.dbg.variable.type*> [#uses=1]
+@str7 = internal constant [7 x i8] c"retval\00", section "llvm.metadata"		; <[7 x i8]*> [#uses=1]
+@llvm.dbg.global_variable = internal constant %llvm.dbg.global_variable.type {
+    i32 393268, 
+    {  }* bitcast (%llvm.dbg.anchor.type* @llvm.dbg.global_variables to {  }*), 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i8* getelementptr ([2 x i8]* @str4, i32 0, i32 0), 
+    i8* getelementptr ([2 x i8]* @str4, i32 0, i32 0), 
+    i8* null, 
+    {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*), 
+    i32 2, 
+    {  }* bitcast (%llvm.dbg.basictype.type* @llvm.dbg.basictype to {  }*), 
+    i1 true, 
+    i1 true, 
+    {  }* bitcast (i32* @q to {  }*) }, section "llvm.metadata"		; <%llvm.dbg.global_variable.type*> [#uses=0]
+@str4.upgrd.1 = internal constant [2 x i8] c"q\00", section "llvm.metadata"		; <[2 x i8]*> [#uses=0]
+@q = internal global i32 0		; <i32*> [#uses=7]
 
-;; Debugger type declarations
-%llvm.dbg.anchor.type = type { uint, uint }
-%llvm.dbg.basictype.type = type { uint, {  }*, sbyte*, {  }*, uint, ulong, ulong, ulong, uint, uint }
-%llvm.dbg.compile_unit.type = type { uint, {  }*, uint, sbyte*, sbyte*, sbyte* }
-%llvm.dbg.global_variable.type = type { uint, {  }*, {  }*, sbyte*, sbyte*, sbyte*, {  }*, uint, {  }*, bool, bool, {  }* }
-%llvm.dbg.subprogram.type = type { uint, {  }*, {  }*, sbyte*, sbyte*, sbyte*, {  }*, uint, {  }*, bool, bool }
-%llvm.dbg.variable.type = type { uint, {  }*, sbyte*, {  }*, uint, {  }* }
+declare void @llvm.dbg.func.start({  }*)
 
-;; Debugger intrinsic declarations...
-declare void %llvm.dbg.func.start({  }*)
-declare void %llvm.dbg.stoppoint(uint, uint, {  }*)
-declare void %llvm.dbg.declare({  }*, {  }*)
-declare void %llvm.dbg.region.start({  }*)
-declare void %llvm.dbg.region.end({  }*)
+declare void @llvm.dbg.stoppoint(i32, i32, {  }*)
 
-;; Debugger anchors
-%llvm.dbg.subprograms = linkonce constant %llvm.dbg.anchor.type {
-  uint 393216,                                                                   ;; DW_TAG_anchor | version(6)
-  uint 46 }, section "llvm.metadata"                                             ;; DW_TAG_subprogram
-%llvm.dbg.compile_units = linkonce constant %llvm.dbg.anchor.type {
-  uint 393216,                                                                   ;; DW_TAG_anchor | version(6)
-  uint 17 }, section "llvm.metadata"                                             ;; DW_TAG_compile_unit
-%llvm.dbg.global_variables = linkonce constant %llvm.dbg.anchor.type {
-  uint 393216,                                                                   ;; DW_TAG_anchor | version(6)
-  uint 52 }, section "llvm.metadata"                                             ;; DW_TAG_variable
+declare void @llvm.dbg.declare({  }*, {  }*)
 
-;; Debug info
-%llvm.dbg.subprogram = internal constant %llvm.dbg.subprogram.type {
-    uint 393262,                                                                 ;; DW_TAG_subprogram | version(6)
-    {  }* bitcast (%llvm.dbg.anchor.type* %llvm.dbg.subprograms to {  }*),       ;; Anchor
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Context
-    sbyte* getelementptr ([4 x sbyte]* %str, int 0, int 0),                      ;; Name
-    sbyte* getelementptr ([4 x sbyte]* %str, int 0, int 0),                      ;; Fully quanlified name
-    sbyte* null,                                                                 ;; Linkage name
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Compile unit
-    uint 4,                                                                      ;; Line number
-    {  }* null,                                                                  ;; Type descriptor
-    bool false,                                                                  ;; Static?
-    bool true }, section "llvm.metadata"                                         ;; External?
-%str = internal constant [4 x sbyte] c"foo\00", section "llvm.metadata"
-    
-%llvm.dbg.compile_unit = internal constant %llvm.dbg.compile_unit.type {
-    uint 393233,                                                                 ;; DW_TAG_compile_unit | version(6)
-    {  }* bitcast (%llvm.dbg.anchor.type* %llvm.dbg.compile_units to {  }*),     ;; Anchor
-    uint 1,                                                                      ;; Language
-    sbyte* getelementptr ([11 x sbyte]* %str, int 0, int 0),                     ;; Source file
-    sbyte* getelementptr ([50 x sbyte]* %str, int 0, int 0),                     ;; Source file directory
-    sbyte* getelementptr ([45 x sbyte]* %str, int 0, int 0) }, section "llvm.metadata" ;; Produceer
-%str = internal constant [11 x sbyte] c"funccall.c\00", section "llvm.metadata"
-%str = internal constant [50 x sbyte] c"/Volumes/Big2/llvm/llvm/test/Regression/Debugger/\00", section "llvm.metadata"
-%str = internal constant [45 x sbyte] c"4.0.1 LLVM (Apple Computer, Inc. build 5421)\00", section "llvm.metadata"
+declare void @llvm.dbg.region.start({  }*)
 
-%llvm.dbg.variable = internal constant %llvm.dbg.variable.type {
-    uint 393472,                                                                 ;; DW_TAG_auto_variable | version(6)
-    {  }* bitcast (%llvm.dbg.subprogram.type* %llvm.dbg.subprogram to {  }*),    ;; Context
-    sbyte* getelementptr ([2 x sbyte]* %str, int 0, int 0),                      ;; Name
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Compile unit
-    uint 5,                                                                      ;; Line number
-    {  }* bitcast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to {  }*) }, section "llvm.metadata" ;; Type
-%str = internal constant [2 x sbyte] c"t\00", section "llvm.metadata"
+declare void @llvm.dbg.region.end({  }*)
 
-%llvm.dbg.basictype = internal constant %llvm.dbg.basictype.type {
-    uint 393252,                                                                 ;; DW_TAG_base_type | version(6)
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Context
-    sbyte* getelementptr ([4 x sbyte]* %str1, int 0, int 0),                     ;; Name
-    {  }* null,                                                                  ;; Compile Unit
-    uint 0,                                                                      ;; Line number
-    ulong 32,                                                                    ;; Size in bits
-    ulong 32,                                                                    ;; Align in bits
-    ulong 0,                                                                     ;; Offset in bits
-    uint 0,                                                                      ;; Flags
-    uint 5 }, section "llvm.metadata"                                            ;; Basic type encoding
-%str1 = internal constant [4 x sbyte] c"int\00", section "llvm.metadata"
-
-%llvm.dbg.subprogram2 = internal constant %llvm.dbg.subprogram.type {
-    uint 393262,                                                                 ;; DW_TAG_subprogram | version(6)
-    {  }* bitcast (%llvm.dbg.anchor.type* %llvm.dbg.subprograms to {  }*),       ;; Anchor
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Context
-    sbyte* getelementptr ([5 x sbyte]* %str, int 0, int 0),                      ;; Name
-    sbyte* getelementptr ([5 x sbyte]* %str, int 0, int 0),                      ;; Fully quanlified name
-    sbyte* null,                                                                 ;; Linkage name
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Compile unit
-    uint 8,                                                                      ;; Line number
-    {  }* bitcast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to {  }*),      ;; Type descriptor
-    bool false,                                                                  ;; Static?
-    bool true }, section "llvm.metadata"                                         ;; External?
-%str = internal constant [5 x sbyte] c"main\00", section "llvm.metadata"
-
-%llvm.dbg.variable3 = internal constant %llvm.dbg.variable.type {
-    uint 393474,                                                                 ;; DW_TAG_return_variable | version(6)
-    {  }* bitcast (%llvm.dbg.subprogram.type* %llvm.dbg.subprogram2 to {  }*),   ;; Context
-    sbyte* getelementptr ([7 x sbyte]* %str, int 0, int 0),                      ;; Name
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Compile unit
-    uint 8,                                                                      ;; Line number
-    {  }* bitcast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to {  }*) }, section "llvm.metadata" ;; Type 
-%str = internal constant [7 x sbyte] c"retval\00", section "llvm.metadata"
-
-%llvm.dbg.global_variable = internal constant %llvm.dbg.global_variable.type {
-    uint 393268,                                                                 ;; DW_TAG_variable | version(6)
-    {  }* bitcast (%llvm.dbg.anchor.type* %llvm.dbg.global_variables to {  }*),  ;; Anchor
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Context
-    sbyte* getelementptr ([2 x sbyte]* %str4, int 0, int 0),                     ;; Name
-    sbyte* getelementptr ([2 x sbyte]* %str4, int 0, int 0),                     ;; Fully qualified name
-    sbyte* null,                                                                 ;; Linkage name
-    {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*),;; Compile unit
-    uint 2,                                                                      ;; Line number
-    {  }* bitcast (%llvm.dbg.basictype.type* %llvm.dbg.basictype to {  }*),      ;; Type
-    bool true,                                                                   ;; Static?
-    bool true,                                                                   ;; External?
-    {  }* bitcast (int* %q to {  }*) }, section "llvm.metadata"                  ;; Variable
-%str4 = internal constant [2 x sbyte] c"q\00", section "llvm.metadata"
-
-;; Global
-%q = internal global int 0
-
-implementation
-
-void %foo() {
+define void @foo() {
 entry:
-	%t = alloca int, align 4
-	"alloca point" = bitcast int 0 to int
-	call void %llvm.dbg.func.start( {  }* bitcast (%llvm.dbg.subprogram.type* %llvm.dbg.subprogram to {  }*) )
-	call void %llvm.dbg.stoppoint( uint 4, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	%t = bitcast int* %t to {  }*
-	call void %llvm.dbg.declare( {  }* %t, {  }* bitcast (%llvm.dbg.variable.type* %llvm.dbg.variable to {  }*) )
-	call void %llvm.dbg.stoppoint( uint 5, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	%tmp = load int* %q
-	store int %tmp, int* %t
-	call void %llvm.dbg.stoppoint( uint 6, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	%tmp1 = load int* %t
-	%tmp2 = add int %tmp1, 1
-	store int %tmp2, int* %q
-	call void %llvm.dbg.stoppoint( uint 7, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	call void %llvm.dbg.region.end( {  }* bitcast (%llvm.dbg.subprogram.type* %llvm.dbg.subprogram to {  }*) )
+	%t = alloca i32, align 4		; <i32*> [#uses=3]
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	call void @llvm.dbg.func.start( {  }* bitcast (%llvm.dbg.subprogram.type* @llvm.dbg.subprogram to {  }*) )
+	call void @llvm.dbg.stoppoint( i32 4, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	%t.upgrd.2 = bitcast i32* %t to {  }*		; <{  }*> [#uses=1]
+	call void @llvm.dbg.declare( {  }* %t.upgrd.2, {  }* bitcast (%llvm.dbg.variable.type* @llvm.dbg.variable to {  }*) )
+	call void @llvm.dbg.stoppoint( i32 5, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	%tmp = load i32* @q		; <i32> [#uses=1]
+	store i32 %tmp, i32* %t
+	call void @llvm.dbg.stoppoint( i32 6, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	%tmp1 = load i32* %t		; <i32> [#uses=1]
+	%tmp2 = add i32 %tmp1, 1		; <i32> [#uses=1]
+	store i32 %tmp2, i32* @q
+	call void @llvm.dbg.stoppoint( i32 7, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	call void @llvm.dbg.region.end( {  }* bitcast (%llvm.dbg.subprogram.type* @llvm.dbg.subprogram to {  }*) )
 	ret void
 }
 
-int %main() {
+define i32 @main() {
 entry:
-	%retval = alloca int, align 4
-	%tmp = alloca int, align 4
-	"alloca point" = bitcast int 0 to int
-	call void %llvm.dbg.func.start( {  }* bitcast (%llvm.dbg.subprogram.type* %llvm.dbg.subprogram2 to {  }*) )
-	call void %llvm.dbg.stoppoint( uint 8, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	%retval = bitcast int* %retval to {  }*
-	call void %llvm.dbg.declare( {  }* %retval, {  }* bitcast (%llvm.dbg.variable.type* %llvm.dbg.variable3 to {  }*) )
-	call void %llvm.dbg.stoppoint( uint 9, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	store int 0, int* %q
-	call void %llvm.dbg.stoppoint( uint 10, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	call void (...)* bitcast (void ()* %foo to void (...)*)( )
-	call void %llvm.dbg.stoppoint( uint 11, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	%tmp = load int* %q
-	%tmp1 = sub int %tmp, 1
-	store int %tmp1, int* %q
-	call void %llvm.dbg.stoppoint( uint 13, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	%tmp2 = load int* %q
-	store int %tmp2, int* %tmp
-	%tmp3 = load int* %tmp
-	store int %tmp3, int* %retval
-	%retval = load int* %retval
-	call void %llvm.dbg.stoppoint( uint 14, uint 0, {  }* bitcast (%llvm.dbg.compile_unit.type* %llvm.dbg.compile_unit to {  }*) )
-	call void %llvm.dbg.region.end( {  }* bitcast (%llvm.dbg.subprogram.type* %llvm.dbg.subprogram2 to {  }*) )
-	ret int %retval
+	%retval = alloca i32, align 4		; <i32*> [#uses=3]
+	%tmp = alloca i32, align 4		; <i32*> [#uses=2]
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	call void @llvm.dbg.func.start( {  }* bitcast (%llvm.dbg.subprogram.type* @llvm.dbg.subprogram2 to {  }*) )
+	call void @llvm.dbg.stoppoint( i32 8, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	%retval.upgrd.3 = bitcast i32* %retval to {  }*		; <{  }*> [#uses=1]
+	call void @llvm.dbg.declare( {  }* %retval.upgrd.3, {  }* bitcast (%llvm.dbg.variable.type* @llvm.dbg.variable3 to {  }*) )
+	call void @llvm.dbg.stoppoint( i32 9, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	store i32 0, i32* @q
+	call void @llvm.dbg.stoppoint( i32 10, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	call void (...)* bitcast (void ()* @foo to void (...)*)( )
+	call void @llvm.dbg.stoppoint( i32 11, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	%tmp.upgrd.4 = load i32* @q		; <i32> [#uses=1]
+	%tmp1 = sub i32 %tmp.upgrd.4, 1		; <i32> [#uses=1]
+	store i32 %tmp1, i32* @q
+	call void @llvm.dbg.stoppoint( i32 13, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	%tmp2 = load i32* @q		; <i32> [#uses=1]
+	store i32 %tmp2, i32* %tmp
+	%tmp3 = load i32* %tmp		; <i32> [#uses=1]
+	store i32 %tmp3, i32* %retval
+	%retval.upgrd.5 = load i32* %retval		; <i32> [#uses=1]
+	call void @llvm.dbg.stoppoint( i32 14, i32 0, {  }* bitcast (%llvm.dbg.compile_unit.type* @llvm.dbg.compile_unit to {  }*) )
+	call void @llvm.dbg.region.end( {  }* bitcast (%llvm.dbg.subprogram.type* @llvm.dbg.subprogram2 to {  }*) )
+	ret i32 %retval.upgrd.5
 }
diff --git a/test/ExecutionEngine/2002-12-16-ArgTest.ll b/test/ExecutionEngine/2002-12-16-ArgTest.ll
index 4ef1439..6a8d100 100644
--- a/test/ExecutionEngine/2002-12-16-ArgTest.ll
+++ b/test/ExecutionEngine/2002-12-16-ArgTest.ll
@@ -1,47 +1,38 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-%.LC0 = internal global [10 x sbyte] c"argc: %d\0A\00"
+@.LC0 = internal global [10 x i8] c"argc: %d\0A\00"		; <[10 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i32 @puts(i8*)
 
-declare int %puts(sbyte*)
-
-void %getoptions(int* %argc) {
-bb0:		; No predecessors!
+define void @getoptions(i32* %argc) {
+bb0:
 	ret void
 }
 
-declare int %printf(sbyte*, ...)
+declare i32 @printf(i8*, ...)
 
-int %main(int %argc, sbyte** %argv) {
-bb0:		; No predecessors!
-	call int (sbyte*, ...)* %printf( sbyte* getelementptr ([10 x sbyte]* %.LC0, long 0, long 0), int %argc)
-	%cast224 = cast sbyte** %argv to sbyte*		; <sbyte*> [#uses=1]
-	%local = alloca sbyte*		; <sbyte**> [#uses=3]
-	store sbyte* %cast224, sbyte** %local
-	%cond226 = setle int %argc, 0		; <bool> [#uses=1]
-	br bool %cond226, label %bb3, label %bb2
-
+define i32 @main(i32 %argc, i8** %argv) {
+bb0:
+	call i32 (i8*, ...)* @printf( i8* getelementptr ([10 x i8]* @.LC0, i64 0, i64 0), i32 %argc )		; <i32>:0 [#uses=0]
+	%cast224 = bitcast i8** %argv to i8*		; <i8*> [#uses=1]
+	%local = alloca i8*		; <i8**> [#uses=3]
+	store i8* %cast224, i8** %local
+	%cond226 = icmp sle i32 %argc, 0		; <i1> [#uses=1]
+	br i1 %cond226, label %bb3, label %bb2
 bb2:		; preds = %bb2, %bb0
-	%cann-indvar = phi int [ 0, %bb0 ], [ %add1-indvar, %bb2 ]		; <int> [#uses=2]
-	%add1-indvar = add int %cann-indvar, 1		; <int> [#uses=2]
-	%cann-indvar-idxcast = cast int %cann-indvar to long		; <long> [#uses=1]
-	;%reg115 = load sbyte** %local		; <sbyte*> [#uses=1]
-	;%cann-indvar-idxcast-scale = mul long %cann-indvar-idxcast, 8		; <long> [#uses=1]
-	;%reg232 = getelementptr sbyte* %reg115, long %cann-indvar-idxcast-scale		; <sbyte*> [#uses=1]
-	;%cast235 = cast sbyte* %reg232 to sbyte**		; <sbyte**> [#uses=1]
-	%CT = cast sbyte**  %local to sbyte***
-	%reg115 = load sbyte*** %CT
-	%cast235 = getelementptr sbyte** %reg115, long %cann-indvar-idxcast
-
-	%reg117 = load sbyte** %cast235		; <sbyte*> [#uses=1]
-	%reg236 = call int %puts( sbyte* %reg117 )		; <int> [#uses=0]
-	%cond239 = setlt int %add1-indvar, %argc		; <bool> [#uses=1]
-	br bool %cond239, label %bb2, label %bb3
-
+	%cann-indvar = phi i32 [ 0, %bb0 ], [ %add1-indvar, %bb2 ]		; <i32> [#uses=2]
+	%add1-indvar = add i32 %cann-indvar, 1		; <i32> [#uses=2]
+	%cann-indvar-idxcast = sext i32 %cann-indvar to i64		; <i64> [#uses=1]
+	%CT = bitcast i8** %local to i8***		; <i8***> [#uses=1]
+	%reg115 = load i8*** %CT		; <i8**> [#uses=1]
+	%cast235 = getelementptr i8** %reg115, i64 %cann-indvar-idxcast		; <i8**> [#uses=1]
+	%reg117 = load i8** %cast235		; <i8*> [#uses=1]
+	%reg236 = call i32 @puts( i8* %reg117 )		; <i32> [#uses=0]
+	%cond239 = icmp slt i32 %add1-indvar, %argc		; <i1> [#uses=1]
+	br i1 %cond239, label %bb2, label %bb3
 bb3:		; preds = %bb2, %bb0
-	%cast243 = cast sbyte** %local to int*		; <int*> [#uses=1]
-	call void %getoptions( int* %cast243 )
-	ret int 0
+	%cast243 = bitcast i8** %local to i32*		; <i32*> [#uses=1]
+	call void @getoptions( i32* %cast243 )
+	ret i32 0
 }
diff --git a/test/ExecutionEngine/2003-01-04-ArgumentBug.ll b/test/ExecutionEngine/2003-01-04-ArgumentBug.ll
index 218154f..6a8f07b 100644
--- a/test/ExecutionEngine/2003-01-04-ArgumentBug.ll
+++ b/test/ExecutionEngine/2003-01-04-ArgumentBug.ll
@@ -1,16 +1,14 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-implementation   ; Functions:
-
-int %foo(int %X, int %Y, double %A) {
-	%cond212 = setne double %A, 1.000000e+00		; <bool> [#uses=1]
-	%cast110 = cast bool %cond212 to int		; <int> [#uses=1]
-	ret int %cast110
+define i32 @foo(i32 %X, i32 %Y, double %A) {
+	%cond212 = fcmp une double %A, 1.000000e+00		; <i1> [#uses=1]
+	%cast110 = zext i1 %cond212 to i32		; <i32> [#uses=1]
+	ret i32 %cast110
 }
 
-int %main() {
-	%reg212 = call int %foo( int 0, int 1, double 1.000000e+00 )		; <int> [#uses=1]
-	ret int %reg212
+define i32 @main() {
+	%reg212 = call i32 @foo( i32 0, i32 1, double 1.000000e+00 )		; <i32> [#uses=1]
+	ret i32 %reg212
 }
+
diff --git a/test/ExecutionEngine/2003-01-04-LoopTest.ll b/test/ExecutionEngine/2003-01-04-LoopTest.ll
index f70928a..fce0b00 100644
--- a/test/ExecutionEngine/2003-01-04-LoopTest.ll
+++ b/test/ExecutionEngine/2003-01-04-LoopTest.ll
@@ -1,25 +1,21 @@
-; RUN: llvm-upgrade < %s | llvm-as -o %t.bc -f
+; RUN: llvm-as < %s -o %t.bc -f
 ; RUN: lli %t.bc > /dev/null
 
-implementation
-
-int %main() {
-	call int %mylog(int 4)
-	ret int 0
+define i32 @main() {
+	call i32 @mylog( i32 4 )		; <i32>:1 [#uses=0]
+	ret i32 0
 }
 
-internal int %mylog(int %num) {
-bb0:            ; No predecessors!
+define internal i32 @mylog(i32 %num) {
+bb0:
 	br label %bb2
-
-bb2:
-        %reg112 = phi int [ 10, %bb2 ], [ 1, %bb0 ]
-        %cann-indvar = phi int [ %cann-indvar, %bb2 ], [0, %bb0]
-        %reg114 = add int %reg112, 1
-        %cond222 = setlt int %reg114, %num
-        br bool %cond222, label %bb2, label %bb3
-
-bb3:            ; preds = %bb2, %bb0
-	ret int %reg114
+bb2:		; preds = %bb2, %bb0
+	%reg112 = phi i32 [ 10, %bb2 ], [ 1, %bb0 ]		; <i32> [#uses=1]
+	%cann-indvar = phi i32 [ %cann-indvar, %bb2 ], [ 0, %bb0 ]		; <i32> [#uses=1]
+	%reg114 = add i32 %reg112, 1		; <i32> [#uses=2]
+	%cond222 = icmp slt i32 %reg114, %num		; <i1> [#uses=1]
+	br i1 %cond222, label %bb2, label %bb3
+bb3:		; preds = %bb2
+	ret i32 %reg114
 }
 
diff --git a/test/ExecutionEngine/2003-01-04-PhiTest.ll b/test/ExecutionEngine/2003-01-04-PhiTest.ll
index 45af830..cadb19e 100644
--- a/test/ExecutionEngine/2003-01-04-PhiTest.ll
+++ b/test/ExecutionEngine/2003-01-04-PhiTest.ll
@@ -1,11 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-int %main() {
+define i32 @main() {
+; <label>:0
 	br label %Loop
-Loop:
-	%X = phi int [0, %0], [1, %Loop]
-	br bool true, label %Out, label %Loop
-Out:
-	ret int %X
+Loop:		; preds = %Loop, %0
+	%X = phi i32 [ 0, %0 ], [ 1, %Loop ]		; <i32> [#uses=1]
+	br i1 true, label %Out, label %Loop
+Out:		; preds = %Loop
+	ret i32 %X
 }
+
diff --git a/test/ExecutionEngine/2003-01-09-SARTest.ll b/test/ExecutionEngine/2003-01-09-SARTest.ll
index 73f2900..eeb4326 100644
--- a/test/ExecutionEngine/2003-01-09-SARTest.ll
+++ b/test/ExecutionEngine/2003-01-09-SARTest.ll
@@ -1,11 +1,12 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; We were accidentally inverting the signedness of right shifts.  Whoops.
 
-int %main() {
-  %X = shr int -1, ubyte 16
-  %Y = shr int %X, ubyte 16
-  %Z = add int %Y, 1
-  ret int %Z
+define i32 @main() {
+	%X = ashr i32 -1, 16		; <i32> [#uses=1]
+	%Y = ashr i32 %X, 16		; <i32> [#uses=1]
+	%Z = add i32 %Y, 1		; <i32> [#uses=1]
+	ret i32 %Z
 }
+
diff --git a/test/ExecutionEngine/2003-01-10-FUCOM.ll b/test/ExecutionEngine/2003-01-10-FUCOM.ll
index 4209df9..c45674c 100644
--- a/test/ExecutionEngine/2003-01-10-FUCOM.ll
+++ b/test/ExecutionEngine/2003-01-10-FUCOM.ll
@@ -1,11 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-int %main() {
-	%X = add double 0.0, 1.0
-	%Y = sub double 0.0, 1.0
-	%Z = seteq double %X, %Y
-	add double %Y, 0.0
-	ret int 0
+define i32 @main() {
+	%X = add double 0.000000e+00, 1.000000e+00		; <double> [#uses=1]
+	%Y = sub double 0.000000e+00, 1.000000e+00		; <double> [#uses=2]
+	%Z = fcmp oeq double %X, %Y		; <i1> [#uses=0]
+	add double %Y, 0.000000e+00		; <double>:1 [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/2003-01-15-AlignmentTest.ll b/test/ExecutionEngine/2003-01-15-AlignmentTest.ll
index e9ffd90..02872f6 100644
--- a/test/ExecutionEngine/2003-01-15-AlignmentTest.ll
+++ b/test/ExecutionEngine/2003-01-15-AlignmentTest.ll
@@ -1,19 +1,18 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-int %bar(sbyte* %X) {
-	%P = alloca double   ; pointer should be 4 byte aligned!
-	%R = cast double* %P to int
-	%A = and int %R, 3
-	ret int %A
+define i32 @bar(i8* %X) {
+        ; pointer should be 4 byte aligned!
+	%P = alloca double		; <double*> [#uses=1]
+	%R = ptrtoint double* %P to i32		; <i32> [#uses=1]
+	%A = and i32 %R, 3		; <i32> [#uses=1]
+	ret i32 %A
 }
 
-int %main() {
-	%SP = alloca sbyte
-	%X = add uint 0, 0
-	alloca sbyte, uint %X
-
-	call int %bar(sbyte* %SP)
-	ret int %0
+define i32 @main() {
+	%SP = alloca i8		; <i8*> [#uses=1]
+	%X = add i32 0, 0		; <i32> [#uses=1]
+	alloca i8, i32 %X		; <i8*>:1 [#uses=0]
+	call i32 @bar( i8* %SP )		; <i32>:2 [#uses=1]
+	ret i32 %2
 }
diff --git a/test/ExecutionEngine/2003-05-06-LivenessClobber.llx b/test/ExecutionEngine/2003-05-06-LivenessClobber.llx
index ea3f14b..57fe95b 100644
--- a/test/ExecutionEngine/2003-05-06-LivenessClobber.llx
+++ b/test/ExecutionEngine/2003-05-06-LivenessClobber.llx
@@ -1,20 +1,19 @@
 ; This testcase shoudl return with an exit code of 1.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | not lli
+; RUN: llvm-as < %s | not lli
 
-%test = global long 0
-implementation
+@test = global i64 0		; <i64*> [#uses=1]
 
-
-internal long %test() {
-        %tmp.0 = load long* %test               ; <long> [#uses=1]
-        %tmp.1 = add long %tmp.0, 1             ; <long> [#uses=1]
-        ret long %tmp.1
+define internal i64 @test.upgrd.1() {
+	%tmp.0 = load i64* @test		; <i64> [#uses=1]
+	%tmp.1 = add i64 %tmp.0, 1		; <i64> [#uses=1]
+	ret i64 %tmp.1
 }
 
-int %main() {
-	%L = call long %test()
-	%I = cast long %L to int
-	ret int %I
+define i32 @main() {
+	%L = call i64 @test.upgrd.1( )		; <i64> [#uses=1]
+	%I = trunc i64 %L to i32		; <i32> [#uses=1]
+	ret i32 %I
 }
 
+
diff --git a/test/ExecutionEngine/2003-05-07-ArgumentTest.llx b/test/ExecutionEngine/2003-05-07-ArgumentTest.llx
index e5dd04e..fa15d71 100644
--- a/test/ExecutionEngine/2003-05-07-ArgumentTest.llx
+++ b/test/ExecutionEngine/2003-05-07-ArgumentTest.llx
@@ -1,13 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | lli - test
+; RUN: llvm-as < %s | lli - test
 
-implementation  
+declare i32 @puts(i8*)
 
-declare int %puts(sbyte*)
-
-int %main(int %argc.1, sbyte** %argv.1) {
-	%tmp.5 = getelementptr sbyte** %argv.1, long 1		; <sbyte**> [#uses=1]
-	%tmp.6 = load sbyte** %tmp.5		; <sbyte*> [#uses=1]
-	%tmp.0 = call int %puts( sbyte* %tmp.6 )		; <int> [#uses=0]
-	ret int 0
+define i32 @main(i32 %argc.1, i8** %argv.1) {
+	%tmp.5 = getelementptr i8** %argv.1, i64 1		; <i8**> [#uses=1]
+	%tmp.6 = load i8** %tmp.5		; <i8*> [#uses=1]
+	%tmp.0 = call i32 @puts( i8* %tmp.6 )		; <i32> [#uses=0]
+	ret i32 0
 }
 
diff --git a/test/ExecutionEngine/2003-05-11-PHIRegAllocBug.ll b/test/ExecutionEngine/2003-05-11-PHIRegAllocBug.ll
index 1d9ba77..850654f 100644
--- a/test/ExecutionEngine/2003-05-11-PHIRegAllocBug.ll
+++ b/test/ExecutionEngine/2003-05-11-PHIRegAllocBug.ll
@@ -1,18 +1,16 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-target endian = little
-target pointersize = 32
+target datalayout = "e-p:32:32"
 
-implementation
-
-int %main() {
+define i32 @main() {
 entry:
 	br label %endif
-then:
+then:		; No predecessors!
 	br label %endif
-endif:
-	%x = phi uint [ 4, %entry ], [ 27, %then ]
-	%result = phi int [ 32, %then ], [ 0, %entry ]
-	ret int 0
+endif:		; preds = %then, %entry
+	%x = phi i32 [ 4, %entry ], [ 27, %then ]		; <i32> [#uses=0]
+	%result = phi i32 [ 32, %then ], [ 0, %entry ]		; <i32> [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/2003-06-04-bzip2-bug.ll b/test/ExecutionEngine/2003-06-04-bzip2-bug.ll
index cd237c3..ff758cf 100644
--- a/test/ExecutionEngine/2003-06-04-bzip2-bug.ll
+++ b/test/ExecutionEngine/2003-06-04-bzip2-bug.ll
@@ -1,22 +1,20 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; Testcase distilled from 256.bzip2.
 
-target endian = little
-target pointersize = 32
+target datalayout = "e-p:32:32"
 
-int %main() {
+define i32 @main() {
 entry:
 	br label %loopentry.0
-
-loopentry.0:
-	%h.0 = phi int [ %tmp.2, %loopentry.0 ], [ -1, %entry ]
-	%tmp.2 = add int %h.0, 1
-	%tmp.4 = setne int %tmp.2, 0
-	br bool %tmp.4, label %loopentry.0, label %loopentry.1
-
-loopentry.1:
-	%h.1 = phi int [ %tmp.2, %loopentry.0 ]
-	ret int %h.1
+loopentry.0:		; preds = %loopentry.0, %entry
+	%h.0 = phi i32 [ %tmp.2, %loopentry.0 ], [ -1, %entry ]		; <i32> [#uses=1]
+	%tmp.2 = add i32 %h.0, 1		; <i32> [#uses=3]
+	%tmp.4 = icmp ne i32 %tmp.2, 0		; <i1> [#uses=1]
+	br i1 %tmp.4, label %loopentry.0, label %loopentry.1
+loopentry.1:		; preds = %loopentry.0
+	%h.1 = phi i32 [ %tmp.2, %loopentry.0 ]		; <i32> [#uses=1]
+	ret i32 %h.1
 }
+
diff --git a/test/ExecutionEngine/2003-06-05-PHIBug.ll b/test/ExecutionEngine/2003-06-05-PHIBug.ll
index 8c1aaba..3a55f72 100644
--- a/test/ExecutionEngine/2003-06-05-PHIBug.ll
+++ b/test/ExecutionEngine/2003-06-05-PHIBug.ll
@@ -1,19 +1,18 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; Testcase distilled from 256.bzip2.
 
-target endian = little
-target pointersize = 32
+target datalayout = "e-p:32:32"
 
-int %main() {
+define i32 @main() {
 entry:
-	%X = add int 1, -1
+	%X = add i32 1, -1		; <i32> [#uses=3]
 	br label %Next
-
-Next:
-	%A = phi int [ %X, %entry ]
-	%B = phi int [ %X, %entry ]
-	%C = phi int [ %X, %entry ]
-	ret int %C
+Next:		; preds = %entry
+	%A = phi i32 [ %X, %entry ]		; <i32> [#uses=0]
+	%B = phi i32 [ %X, %entry ]		; <i32> [#uses=0]
+	%C = phi i32 [ %X, %entry ]		; <i32> [#uses=1]
+	ret i32 %C
 }
+
diff --git a/test/ExecutionEngine/2003-08-15-AllocaAssertion.ll b/test/ExecutionEngine/2003-08-15-AllocaAssertion.ll
index adc8220..ce5e1ed 100644
--- a/test/ExecutionEngine/2003-08-15-AllocaAssertion.ll
+++ b/test/ExecutionEngine/2003-08-15-AllocaAssertion.ll
@@ -1,12 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; This testcase failed to work because two variable sized allocas confused the
 ; local register allocator.
 
-int %main(uint %X) {
-  %A = alloca uint, uint %X
-
-  %B = alloca float, uint %X
-  ret int 0
+define i32 @main(i32 %X) {
+	%A = alloca i32, i32 %X		; <i32*> [#uses=0]
+	%B = alloca float, i32 %X		; <float*> [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/2003-08-21-EnvironmentTest.ll b/test/ExecutionEngine/2003-08-21-EnvironmentTest.ll
index 21e87ca..ec36a85 100644
--- a/test/ExecutionEngine/2003-08-21-EnvironmentTest.ll
+++ b/test/ExecutionEngine/2003-08-21-EnvironmentTest.ll
@@ -1,4 +1,4 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ;
@@ -9,15 +9,14 @@
 ;	environment to the main() function.
 ;
 
-implementation
 
-declare uint %strlen(sbyte*)
+declare i32 @strlen(i8*)
 
-int %main(int %argc.1, sbyte** %argv.1, sbyte** %envp.1) {
-	%tmp.2 = load sbyte** %envp.1
-	%tmp.3 = call uint %strlen( sbyte* %tmp.2 )
-	%T = seteq uint %tmp.3, 0
-	%R = cast bool %T to int	
-	ret int %R
+define i32 @main(i32 %argc.1, i8** %argv.1, i8** %envp.1) {
+	%tmp.2 = load i8** %envp.1		; <i8*> [#uses=1]
+	%tmp.3 = call i32 @strlen( i8* %tmp.2 )		; <i32> [#uses=1]
+	%T = icmp eq i32 %tmp.3, 0		; <i1> [#uses=1]
+	%R = zext i1 %T to i32		; <i32> [#uses=1]
+	ret i32 %R
 }
 
diff --git a/test/ExecutionEngine/2003-08-23-RegisterAllocatePhysReg.ll b/test/ExecutionEngine/2003-08-23-RegisterAllocatePhysReg.ll
index 4d1d045..42e8dc3 100644
--- a/test/ExecutionEngine/2003-08-23-RegisterAllocatePhysReg.ll
+++ b/test/ExecutionEngine/2003-08-23-RegisterAllocatePhysReg.ll
@@ -1,33 +1,35 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; This testcase exposes a bug in the local register allocator where it runs out
 ; of registers (due to too many overlapping live ranges), but then attempts to
 ; use the ESP register (which is not allocatable) to hold a value.
 
-int %main(uint %A) {
-	%Ap2 = alloca uint, uint %A   ; ESP gets used again...
-	%B = add uint %A, 1 	      ; Produce lots of overlapping live ranges
-	%C = add uint %A, 2
-	%D = add uint %A, 3
-	%E = add uint %A, 4
-	%F = add uint %A, 5
-	%G = add uint %A, 6
-	%H = add uint %A, 7
-	%I = add uint %A, 8
-	%J = add uint %A, 9
-	%K = add uint %A, 10
-
-	store uint %A, uint *%Ap2      ; Uses of all of the values
-	store uint %B, uint *%Ap2
-	store uint %C, uint *%Ap2
-	store uint %D, uint *%Ap2
-	store uint %E, uint *%Ap2
-	store uint %F, uint *%Ap2
-	store uint %G, uint *%Ap2
-	store uint %H, uint *%Ap2
-	store uint %I, uint *%Ap2
-	store uint %J, uint *%Ap2
-	store uint %K, uint *%Ap2
-	ret int 0
+define i32 @main(i32 %A) {
+        ; ESP gets used again...
+	%Ap2 = alloca i32, i32 %A		; <i32*> [#uses=11]
+	; Produce lots of overlapping live ranges
+        %B = add i32 %A, 1		; <i32> [#uses=1]
+	%C = add i32 %A, 2		; <i32> [#uses=1]
+	%D = add i32 %A, 3		; <i32> [#uses=1]
+	%E = add i32 %A, 4		; <i32> [#uses=1]
+	%F = add i32 %A, 5		; <i32> [#uses=1]
+	%G = add i32 %A, 6		; <i32> [#uses=1]
+	%H = add i32 %A, 7		; <i32> [#uses=1]
+	%I = add i32 %A, 8		; <i32> [#uses=1]
+	%J = add i32 %A, 9		; <i32> [#uses=1]
+	%K = add i32 %A, 10		; <i32> [#uses=1]
+        ; Uses of all of the values
+	store i32 %A, i32* %Ap2
+	store i32 %B, i32* %Ap2
+	store i32 %C, i32* %Ap2
+	store i32 %D, i32* %Ap2
+	store i32 %E, i32* %Ap2
+	store i32 %F, i32* %Ap2
+	store i32 %G, i32* %Ap2
+	store i32 %H, i32* %Ap2
+	store i32 %I, i32* %Ap2
+	store i32 %J, i32* %Ap2
+	store i32 %K, i32* %Ap2
+	ret i32 0
 }
diff --git a/test/ExecutionEngine/2003-10-18-PHINode-ConstantExpr-CondCode-Failure.ll b/test/ExecutionEngine/2003-10-18-PHINode-ConstantExpr-CondCode-Failure.ll
index b2700e1..32d99d5 100644
--- a/test/ExecutionEngine/2003-10-18-PHINode-ConstantExpr-CondCode-Failure.ll
+++ b/test/ExecutionEngine/2003-10-18-PHINode-ConstantExpr-CondCode-Failure.ll
@@ -1,30 +1,24 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-%A = global int 0
+@A = global i32 0		; <i32*> [#uses=1]
 
-int %main() {
-	%Ret = call int %test(bool true, int 0)	
-	ret int %Ret
+define i32 @main() {
+	%Ret = call i32 @test( i1 true, i32 0 )		; <i32> [#uses=1]
+	ret i32 %Ret
 }
 
-int %test(bool %c, int %A) {
-	br bool %c, label %Taken1, label %NotTaken
-
-Cont:
-	%V = phi int [0, %NotTaken], 
-	              [ sub (int cast (int* %A to int), int 1234), %Taken1]
-	ret int 0
-
-NotTaken:
-	br label %Cont	
-
-Taken1:
-	%B = seteq int %A, 0
-	; Code got inserted here, breaking the condition code.
-	br bool %B, label %Cont, label %ExitError
-
-ExitError:
-	ret int 12
-
+define i32 @test(i1 %c, i32 %A) {
+	br i1 %c, label %Taken1, label %NotTaken
+Cont:		; preds = %Taken1, %NotTaken
+	%V = phi i32 [ 0, %NotTaken ], [ sub (i32 ptrtoint (i32* @A to i32), i32 1234), %Taken1 ]		; <i32> [#uses=0]
+	ret i32 0
+NotTaken:		; preds = %0
+	br label %Cont
+Taken1:		; preds = %0
+	%B = icmp eq i32 %A, 0		; <i1> [#uses=1]
+	br i1 %B, label %Cont, label %ExitError
+ExitError:		; preds = %Taken1
+	ret i32 12
 }
+
diff --git a/test/ExecutionEngine/2005-12-02-TailCallBug.ll b/test/ExecutionEngine/2005-12-02-TailCallBug.ll
index 447f49e..59a40ae 100644
--- a/test/ExecutionEngine/2005-12-02-TailCallBug.ll
+++ b/test/ExecutionEngine/2005-12-02-TailCallBug.ll
@@ -1,21 +1,21 @@
 ; PR672
-; RUN: llvm-upgrade < %s | llvm-as | lli
+; RUN: llvm-as < %s | lli
 
-int %main(){ 
- %f   = cast int (int, int*, int)* %check_tail to int*
- %res = tail call fastcc int %check_tail( int 10, int* %f,int 10)
- ret int %res
+define i32 @main() {
+	%f = bitcast i32 (i32, i32*, i32)* @check_tail to i32*		; <i32*> [#uses=1]
+	%res = tail call fastcc i32 @check_tail( i32 10, i32* %f, i32 10 )		; <i32> [#uses=1]
+	ret i32 %res
 }
-fastcc int %check_tail(int %x, int* %f, int %g) {
-	%tmp1 = setgt int %x, 0
-	br bool %tmp1, label %if-then, label %if-else
 
-if-then:
-	%fun_ptr = cast int* %f to int(int, int*, int)*	
-	%arg1    = add int %x, -1		
-	%res = tail call fastcc int %fun_ptr( int %arg1, int * %f, int %g)
-	ret int %res
-
-if-else:
-        ret int %x
+define fastcc i32 @check_tail(i32 %x, i32* %f, i32 %g) {
+	%tmp1 = icmp sgt i32 %x, 0		; <i1> [#uses=1]
+	br i1 %tmp1, label %if-then, label %if-else
+if-then:		; preds = %0
+	%fun_ptr = bitcast i32* %f to i32 (i32, i32*, i32)*		; <i32 (i32, i32*, i32)*> [#uses=1]
+	%arg1 = add i32 %x, -1		; <i32> [#uses=1]
+	%res = tail call fastcc i32 %fun_ptr( i32 %arg1, i32* %f, i32 %g )		; <i32> [#uses=1]
+	ret i32 %res
+if-else:		; preds = %0
+	ret i32 %x
 }
+
diff --git a/test/ExecutionEngine/hello.ll b/test/ExecutionEngine/hello.ll
index ea2f9a4..a0c5e1a 100644
--- a/test/ExecutionEngine/hello.ll
+++ b/test/ExecutionEngine/hello.ll
@@ -1,14 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-%.LC0 = internal global [12 x sbyte] c"Hello World\00"
+@.LC0 = internal global [12 x i8] c"Hello World\00"		; <[12 x i8]*> [#uses=1]
 
-implementation
+declare i32 @puts(i8*)
 
-declare int %puts(sbyte*)
-
-int %main() {
-        %reg210 = call int %puts( sbyte* getelementptr ([12 x sbyte]* %.LC0, long 0, long 0) )
-        ret int 0
+define i32 @main() {
+	%reg210 = call i32 @puts( i8* getelementptr ([12 x i8]* @.LC0, i64 0, i64 0) )		; <i32> [#uses=0]
+	ret i32 0
 }
 
diff --git a/test/ExecutionEngine/hello2.ll b/test/ExecutionEngine/hello2.ll
index b186c52..772dc04 100644
--- a/test/ExecutionEngine/hello2.ll
+++ b/test/ExecutionEngine/hello2.ll
@@ -1,22 +1,18 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
+@X = global i32 7		; <i32*> [#uses=0]
+@msg = internal global [13 x i8] c"Hello World\0A\00"		; <[13 x i8]*> [#uses=1]
 
-%X = global int 7
-%msg = internal global [13 x sbyte] c"Hello World\0A\00"
+declare void @printf([13 x i8]*, ...)
 
-
-implementation
-
-declare void %printf([13 x sbyte]*,...)
-
-void %bar() {
-  call void([13 x sbyte]*,...)* %printf([13 x sbyte]* %msg)
-  ret void 
+define void @bar() {
+	call void ([13 x i8]*, ...)* @printf( [13 x i8]* @msg )
+	ret void
 }
 
-int %main() {
-        call void %bar()
-        ret int 0
+define i32 @main() {
+	call void @bar( )
+	ret i32 0
 }
 
diff --git a/test/ExecutionEngine/simplesttest.ll b/test/ExecutionEngine/simplesttest.ll
index 1f578d2..82e8a2d 100644
--- a/test/ExecutionEngine/simplesttest.ll
+++ b/test/ExecutionEngine/simplesttest.ll
@@ -1,10 +1,7 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-implementation
-
-int %main() {
-        ret int 0
+define i32 @main() {
+	ret i32 0
 }
 
diff --git a/test/ExecutionEngine/simpletest.ll b/test/ExecutionEngine/simpletest.ll
index 68b7044..cca3499 100644
--- a/test/ExecutionEngine/simpletest.ll
+++ b/test/ExecutionEngine/simpletest.ll
@@ -1,12 +1,12 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-implementation
+define i32 @bar() {
+	ret i32 0
+}
 
-int %bar() { ret int 0 }
-
-int %main() {
-        %r = call int %bar()
-        ret int %r
+define i32 @main() {
+	%r = call i32 @bar( )		; <i32> [#uses=1]
+	ret i32 %r
 }
 
diff --git a/test/ExecutionEngine/test-arith.ll b/test/ExecutionEngine/test-arith.ll
index 49d85af..d99e30f 100644
--- a/test/ExecutionEngine/test-arith.ll
+++ b/test/ExecutionEngine/test-arith.ll
@@ -1,38 +1,35 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-int %main() {
-	%A = add sbyte 0, 12
-	%B = sub sbyte %A, 1
-	%C = mul sbyte %B, %B
-	%D = div sbyte %C, %C
-	%E = rem sbyte %D, %D
-	%F = div ubyte 5, 6
-	%G = rem ubyte 6, 5
-
-	%A = add short 0, 12
-	%B = sub short %A, 1
-	%C = mul short %B, %B
-	%D = div short %C, %C
-	%E = rem short %D, %D
-	%F = div ushort 5, 6
-	%G = rem uint 6, 5
-
-	%A = add int 0, 12
-	%B = sub int %A, 1
-	%C = mul int %B, %B
-	%D = div int %C, %C
-	%E = rem int %D, %D
-	%F = div uint 5, 6
-	%G1 = rem uint 6, 5
-
-	%A = add long 0, 12
-	%B = sub long %A, 1
-	%C = mul long %B, %B
-	%D = div long %C, %C
-	%E = rem long %D, %D
-	%F = div ulong 5, 6
-	%G = rem ulong 6, 5
-
-	ret int 0
+define i32 @main() {
+	%A = add i8 0, 12		; <i8> [#uses=1]
+	%B = sub i8 %A, 1		; <i8> [#uses=2]
+	%C = mul i8 %B, %B		; <i8> [#uses=2]
+	%D = sdiv i8 %C, %C		; <i8> [#uses=2]
+	%E = srem i8 %D, %D		; <i8> [#uses=0]
+	%F = udiv i8 5, 6		; <i8> [#uses=0]
+	%G = urem i8 6, 5		; <i8> [#uses=0]
+	%A.upgrd.1 = add i16 0, 12		; <i16> [#uses=1]
+	%B.upgrd.2 = sub i16 %A.upgrd.1, 1		; <i16> [#uses=2]
+	%C.upgrd.3 = mul i16 %B.upgrd.2, %B.upgrd.2		; <i16> [#uses=2]
+	%D.upgrd.4 = sdiv i16 %C.upgrd.3, %C.upgrd.3		; <i16> [#uses=2]
+	%E.upgrd.5 = srem i16 %D.upgrd.4, %D.upgrd.4		; <i16> [#uses=0]
+	%F.upgrd.6 = udiv i16 5, 6		; <i16> [#uses=0]
+	%G.upgrd.7 = urem i32 6, 5		; <i32> [#uses=0]
+	%A.upgrd.8 = add i32 0, 12		; <i32> [#uses=1]
+	%B.upgrd.9 = sub i32 %A.upgrd.8, 1		; <i32> [#uses=2]
+	%C.upgrd.10 = mul i32 %B.upgrd.9, %B.upgrd.9		; <i32> [#uses=2]
+	%D.upgrd.11 = sdiv i32 %C.upgrd.10, %C.upgrd.10		; <i32> [#uses=2]
+	%E.upgrd.12 = srem i32 %D.upgrd.11, %D.upgrd.11		; <i32> [#uses=0]
+	%F.upgrd.13 = udiv i32 5, 6		; <i32> [#uses=0]
+	%G1 = urem i32 6, 5		; <i32> [#uses=0]
+	%A.upgrd.14 = add i64 0, 12		; <i64> [#uses=1]
+	%B.upgrd.15 = sub i64 %A.upgrd.14, 1		; <i64> [#uses=2]
+	%C.upgrd.16 = mul i64 %B.upgrd.15, %B.upgrd.15		; <i64> [#uses=2]
+	%D.upgrd.17 = sdiv i64 %C.upgrd.16, %C.upgrd.16		; <i64> [#uses=2]
+	%E.upgrd.18 = srem i64 %D.upgrd.17, %D.upgrd.17		; <i64> [#uses=0]
+	%F.upgrd.19 = udiv i64 5, 6		; <i64> [#uses=0]
+	%G.upgrd.20 = urem i64 6, 5		; <i64> [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/test-branch.ll b/test/ExecutionEngine/test-branch.ll
index 649319b..55b7ef1 100644
--- a/test/ExecutionEngine/test-branch.ll
+++ b/test/ExecutionEngine/test-branch.ll
@@ -1,12 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; test unconditional branch
-int %main() {
+define i32 @main() {
 	br label %Test
-Test:
-	%X = seteq int 0, 4
-	br bool %X, label %Test, label %Label
-Label:
-	ret int 0
+Test:		; preds = %Test, %0
+	%X = icmp eq i32 0, 4		; <i1> [#uses=1]
+	br i1 %X, label %Test, label %Label
+Label:		; preds = %Test
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/test-call.ll b/test/ExecutionEngine/test-call.ll
index 23e4f14..645396f 100644
--- a/test/ExecutionEngine/test-call.ll
+++ b/test/ExecutionEngine/test-call.ll
@@ -1,22 +1,22 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
+declare void @exit(i32)
 
-declare void %exit(int)
-
-int %test(sbyte %C, short %S) {
-  %X = cast short %S to ubyte
-  %Y = cast ubyte %X to int
-  ret int %Y
+define i32 @test(i8 %C, i16 %S) {
+	%X = trunc i16 %S to i8		; <i8> [#uses=1]
+	%Y = zext i8 %X to i32		; <i32> [#uses=1]
+	ret i32 %Y
 }
 
-void %FP(void(int) * %F) {
-	%X = call int %test(sbyte 123, short 1024)
-	call void %F(int %X)
+define void @FP(void (i32)* %F) {
+	%X = call i32 @test( i8 123, i16 1024 )		; <i32> [#uses=1]
+	call void %F( i32 %X )
 	ret void
 }
 
-int %main() {
-	call void %FP(void(int)* %exit)
-	ret int 1
+define i32 @main() {
+	call void @FP( void (i32)* @exit )
+	ret i32 1
 }
+
diff --git a/test/ExecutionEngine/test-cast.ll b/test/ExecutionEngine/test-cast.ll
index 97e7157..bc48716 100644
--- a/test/ExecutionEngine/test-cast.ll
+++ b/test/ExecutionEngine/test-cast.ll
@@ -1,136 +1,110 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-int %foo() {
-  ret int 0
+define i32 @foo() {
+	ret i32 0
 }
 
-int %main() {
-  ; cast bool to ...
-  cast bool true to bool
-  cast bool true to ubyte
-  cast bool true to sbyte
-  cast bool true to short
-  cast bool true to ushort
-  cast bool true to int
-  cast bool true to uint
-  cast bool true to long
-  cast bool true to ulong
-  cast bool true to float
-  cast bool true to double
-
-  ; cast sbyte to ...
-  cast sbyte 0 to bool
-  cast sbyte 1 to bool
-  cast sbyte 0 to sbyte
-  cast sbyte -1 to ubyte
-  cast sbyte 4 to short
-  cast sbyte 4 to ushort
-  cast sbyte 4 to long
-  cast sbyte 4 to ulong
-  cast sbyte 4 to float
-  cast sbyte 4 to double
-
-  ; cast ubyte to ...
-  cast ubyte 0 to bool
-  cast ubyte 1 to bool
-  cast ubyte 0 to sbyte
-  cast ubyte 1 to ubyte
-  cast ubyte 4 to short
-  cast ubyte 4 to ushort
-  cast ubyte 4 to long
-  cast ubyte 4 to ulong
-  cast ubyte 0 to float
-  cast ubyte 0 to double
-
-  ; cast short to ...
-  cast short 1 to bool
-  cast short -1 to sbyte
-  cast short 255 to ubyte
-  cast short 0 to short
-  cast short 0 to ushort
-  cast short 0 to long
-  cast short 0 to ulong
-  cast short 0 to float
-  cast short 0 to double
-
-  ; cast ushort to ...
-  cast ushort 1 to bool
-  cast ushort 1 to sbyte
-  cast ushort 255 to ubyte
-  cast ushort 0 to short
-  cast ushort 0 to ushort
-  cast ushort 0 to long
-  cast ushort 0 to ulong
-  cast ushort 0 to float
-  cast ushort 0 to double
-
-  ; cast int to ...
-  cast int 6 to bool
-  cast int -6 to sbyte
-  cast int 6 to ubyte
-  cast int 6 to short
-  cast int 0 to int
-  cast int 0 to long
-  cast int 0 to ulong
-  cast int 0 to float
-  cast int 0 to double
-
-  ; cast uint to ...
-  cast uint 6 to bool
-  cast uint 7 to sbyte
-  cast uint 8 to ubyte
-  cast uint 9 to short
-  cast uint 10 to int
-  cast uint 0 to long
-  cast uint 0 to ulong
-  cast uint 0 to float
-  cast uint 0 to double
-
-  ; cast long to ...
-  cast long 0 to bool
-  cast long 0 to sbyte
-  cast long 0 to ubyte
-  cast long 0 to short
-  cast long 0 to ushort
-  cast long 0 to int
-  cast long 0 to uint
-  cast long 0 to long
-  cast long 0 to ulong
-  cast long 0 to float
-  cast long 0 to double
-
-  ; cast ulong to ...
-  cast ulong 1 to bool
-  cast ulong 1 to sbyte
-  cast ulong 1 to ubyte
-  cast ulong 1 to short
-  cast ulong 1 to ushort
-  cast ulong 1 to int
-  cast ulong 1 to uint
-  cast ulong 1 to long
-  cast ulong 1 to ulong
-  cast ulong 1 to float
-  cast ulong 0 to double
-  
-  ; cast float to ...
-  ;cast float 0.0 to bool
-  cast float 0.0 to float
-  cast float 0.0 to double
-
-  ; cast double to ...
-  ;cast double 0.0 to bool
-  cast double 0.0 to sbyte
-  cast double 0.0 to ubyte
-  cast double 0.0 to short
-  cast double 0.0 to ushort
-  cast double 0.0 to int
-  cast double 0.0 to uint
-  cast double 0.0 to long
-  ;cast double 0.0 to ulong
-  cast double 0.0 to float
-  cast double 0.0 to double
-
-  ret int 0
+define i32 @main() {
+	icmp ne i1 true, false		; <i1>:1 [#uses=0]
+	zext i1 true to i8		; <i8>:2 [#uses=0]
+	zext i1 true to i8		; <i8>:3 [#uses=0]
+	zext i1 true to i16		; <i16>:4 [#uses=0]
+	zext i1 true to i16		; <i16>:5 [#uses=0]
+	zext i1 true to i32		; <i32>:6 [#uses=0]
+	zext i1 true to i32		; <i32>:7 [#uses=0]
+	zext i1 true to i64		; <i64>:8 [#uses=0]
+	zext i1 true to i64		; <i64>:9 [#uses=0]
+	uitofp i1 true to float		; <float>:10 [#uses=0]
+	uitofp i1 true to double		; <double>:11 [#uses=0]
+	icmp ne i8 0, 0		; <i1>:12 [#uses=0]
+	icmp ne i8 1, 0		; <i1>:13 [#uses=0]
+	bitcast i8 0 to i8		; <i8>:14 [#uses=0]
+	bitcast i8 -1 to i8		; <i8>:15 [#uses=0]
+	sext i8 4 to i16		; <i16>:16 [#uses=0]
+	sext i8 4 to i16		; <i16>:17 [#uses=0]
+	sext i8 4 to i64		; <i64>:18 [#uses=0]
+	sext i8 4 to i64		; <i64>:19 [#uses=0]
+	sitofp i8 4 to float		; <float>:20 [#uses=0]
+	sitofp i8 4 to double		; <double>:21 [#uses=0]
+	icmp ne i8 0, 0		; <i1>:22 [#uses=0]
+	icmp ne i8 1, 0		; <i1>:23 [#uses=0]
+	bitcast i8 0 to i8		; <i8>:24 [#uses=0]
+	bitcast i8 1 to i8		; <i8>:25 [#uses=0]
+	zext i8 4 to i16		; <i16>:26 [#uses=0]
+	zext i8 4 to i16		; <i16>:27 [#uses=0]
+	zext i8 4 to i64		; <i64>:28 [#uses=0]
+	zext i8 4 to i64		; <i64>:29 [#uses=0]
+	uitofp i8 0 to float		; <float>:30 [#uses=0]
+	uitofp i8 0 to double		; <double>:31 [#uses=0]
+	icmp ne i16 1, 0		; <i1>:32 [#uses=0]
+	trunc i16 -1 to i8		; <i8>:33 [#uses=0]
+	trunc i16 255 to i8		; <i8>:34 [#uses=0]
+	bitcast i16 0 to i16		; <i16>:35 [#uses=0]
+	bitcast i16 0 to i16		; <i16>:36 [#uses=0]
+	sext i16 0 to i64		; <i64>:37 [#uses=0]
+	sext i16 0 to i64		; <i64>:38 [#uses=0]
+	sitofp i16 0 to float		; <float>:39 [#uses=0]
+	sitofp i16 0 to double		; <double>:40 [#uses=0]
+	icmp ne i16 1, 0		; <i1>:41 [#uses=0]
+	trunc i16 1 to i8		; <i8>:42 [#uses=0]
+	trunc i16 255 to i8		; <i8>:43 [#uses=0]
+	bitcast i16 0 to i16		; <i16>:44 [#uses=0]
+	bitcast i16 0 to i16		; <i16>:45 [#uses=0]
+	zext i16 0 to i64		; <i64>:46 [#uses=0]
+	zext i16 0 to i64		; <i64>:47 [#uses=0]
+	uitofp i16 0 to float		; <float>:48 [#uses=0]
+	uitofp i16 0 to double		; <double>:49 [#uses=0]
+	icmp ne i32 6, 0		; <i1>:50 [#uses=0]
+	trunc i32 -6 to i8		; <i8>:51 [#uses=0]
+	trunc i32 6 to i8		; <i8>:52 [#uses=0]
+	trunc i32 6 to i16		; <i16>:53 [#uses=0]
+	bitcast i32 0 to i32		; <i32>:54 [#uses=0]
+	sext i32 0 to i64		; <i64>:55 [#uses=0]
+	sext i32 0 to i64		; <i64>:56 [#uses=0]
+	sitofp i32 0 to float		; <float>:57 [#uses=0]
+	sitofp i32 0 to double		; <double>:58 [#uses=0]
+	icmp ne i32 6, 0		; <i1>:59 [#uses=0]
+	trunc i32 7 to i8		; <i8>:60 [#uses=0]
+	trunc i32 8 to i8		; <i8>:61 [#uses=0]
+	trunc i32 9 to i16		; <i16>:62 [#uses=0]
+	bitcast i32 10 to i32		; <i32>:63 [#uses=0]
+	zext i32 0 to i64		; <i64>:64 [#uses=0]
+	zext i32 0 to i64		; <i64>:65 [#uses=0]
+	uitofp i32 0 to float		; <float>:66 [#uses=0]
+	uitofp i32 0 to double		; <double>:67 [#uses=0]
+	icmp ne i64 0, 0		; <i1>:68 [#uses=0]
+	trunc i64 0 to i8		; <i8>:69 [#uses=0]
+	trunc i64 0 to i8		; <i8>:70 [#uses=0]
+	trunc i64 0 to i16		; <i16>:71 [#uses=0]
+	trunc i64 0 to i16		; <i16>:72 [#uses=0]
+	trunc i64 0 to i32		; <i32>:73 [#uses=0]
+	trunc i64 0 to i32		; <i32>:74 [#uses=0]
+	bitcast i64 0 to i64		; <i64>:75 [#uses=0]
+	bitcast i64 0 to i64		; <i64>:76 [#uses=0]
+	sitofp i64 0 to float		; <float>:77 [#uses=0]
+	sitofp i64 0 to double		; <double>:78 [#uses=0]
+	icmp ne i64 1, 0		; <i1>:79 [#uses=0]
+	trunc i64 1 to i8		; <i8>:80 [#uses=0]
+	trunc i64 1 to i8		; <i8>:81 [#uses=0]
+	trunc i64 1 to i16		; <i16>:82 [#uses=0]
+	trunc i64 1 to i16		; <i16>:83 [#uses=0]
+	trunc i64 1 to i32		; <i32>:84 [#uses=0]
+	trunc i64 1 to i32		; <i32>:85 [#uses=0]
+	bitcast i64 1 to i64		; <i64>:86 [#uses=0]
+	bitcast i64 1 to i64		; <i64>:87 [#uses=0]
+	uitofp i64 1 to float		; <float>:88 [#uses=0]
+	uitofp i64 0 to double		; <double>:89 [#uses=0]
+	bitcast float 0.000000e+00 to float		; <float>:90 [#uses=0]
+	fpext float 0.000000e+00 to double		; <double>:91 [#uses=0]
+	fptosi double 0.000000e+00 to i8		; <i8>:92 [#uses=0]
+	fptoui double 0.000000e+00 to i8		; <i8>:93 [#uses=0]
+	fptosi double 0.000000e+00 to i16		; <i16>:94 [#uses=0]
+	fptoui double 0.000000e+00 to i16		; <i16>:95 [#uses=0]
+	fptosi double 0.000000e+00 to i32		; <i32>:96 [#uses=0]
+	fptoui double 0.000000e+00 to i32		; <i32>:97 [#uses=0]
+	fptosi double 0.000000e+00 to i64		; <i64>:98 [#uses=0]
+	fptrunc double 0.000000e+00 to float		; <float>:99 [#uses=0]
+	bitcast double 0.000000e+00 to double		; <double>:100 [#uses=0]
+	ret i32 0
 }
diff --git a/test/ExecutionEngine/test-constantexpr.ll b/test/ExecutionEngine/test-constantexpr.ll
index 1ee7e14..2bf1949 100644
--- a/test/ExecutionEngine/test-constantexpr.ll
+++ b/test/ExecutionEngine/test-constantexpr.ll
@@ -1,14 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; This tests to make sure that we can evaluate weird constant expressions
-%A = global int 5
-%B = global int 6
 
-implementation
+@A = global i32 5		; <i32*> [#uses=1]
+@B = global i32 6		; <i32*> [#uses=1]
 
-int %main() {
-	%A = or bool false, setlt (int* %A, int* %B)  ; Which is lower in memory?
-	ret int 0
+define i32 @main() {
+	%A = or i1 false, icmp slt (i32* @A, i32* @B)		; <i1> [#uses=0]
+	ret i32 0
 }
 
diff --git a/test/ExecutionEngine/test-fp.ll b/test/ExecutionEngine/test-fp.ll
index 1ee29b5..aa136dd 100644
--- a/test/ExecutionEngine/test-fp.ll
+++ b/test/ExecutionEngine/test-fp.ll
@@ -1,24 +1,24 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-double %test(double* %DP, double %Arg) {
-	%D = load double* %DP
-	%V = add double %D, 1.0
-	%W = sub double %V, %V
-	%X = mul double %W, %W
-	%Y = div double %X, %X
-	%Z = rem double %Y, %Y
-	%Z1 = div double %Z, %W
-	%Q = add double %Z, %Arg
-	%R = cast double %Q to double
+define double @test(double* %DP, double %Arg) {
+	%D = load double* %DP		; <double> [#uses=1]
+	%V = add double %D, 1.000000e+00		; <double> [#uses=2]
+	%W = sub double %V, %V		; <double> [#uses=3]
+	%X = mul double %W, %W		; <double> [#uses=2]
+	%Y = fdiv double %X, %X		; <double> [#uses=2]
+	%Z = frem double %Y, %Y		; <double> [#uses=3]
+	%Z1 = fdiv double %Z, %W		; <double> [#uses=0]
+	%Q = add double %Z, %Arg		; <double> [#uses=1]
+	%R = bitcast double %Q to double		; <double> [#uses=1]
 	store double %R, double* %DP
 	ret double %Z
 }
 
-int %main() { 
-  %X = alloca double
-  store double 0.0, double* %X
-  call double %test(double* %X, double 2.0)
-  ret int 0 
+define i32 @main() {
+	%X = alloca double		; <double*> [#uses=2]
+	store double 0.000000e+00, double* %X
+	call double @test( double* %X, double 2.000000e+00 )		; <double>:1 [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/test-loadstore.ll b/test/ExecutionEngine/test-loadstore.ll
index 8a4b793..ca2ecbf 100644
--- a/test/ExecutionEngine/test-loadstore.ll
+++ b/test/ExecutionEngine/test-loadstore.ll
@@ -1,37 +1,32 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-void %test(sbyte* %P, short* %P, int* %P, long* %P) {
-	%V = load sbyte* %P
-	store sbyte %V, sbyte* %P
-
-	%V = load short* %P
-	store short %V, short* %P
-
-	%V = load int* %P
-	store int %V, int* %P
-
-	%V = load long* %P
-	store long %V, long* %P
-
+define void @test(i8* %P, i16* %P.upgrd.1, i32* %P.upgrd.2, i64* %P.upgrd.3) {
+	%V = load i8* %P		; <i8> [#uses=1]
+	store i8 %V, i8* %P
+	%V.upgrd.4 = load i16* %P.upgrd.1		; <i16> [#uses=1]
+	store i16 %V.upgrd.4, i16* %P.upgrd.1
+	%V.upgrd.5 = load i32* %P.upgrd.2		; <i32> [#uses=1]
+	store i32 %V.upgrd.5, i32* %P.upgrd.2
+	%V.upgrd.6 = load i64* %P.upgrd.3		; <i64> [#uses=1]
+	store i64 %V.upgrd.6, i64* %P.upgrd.3
 	ret void
 }
 
-uint %varalloca(uint %Size) {
-	%X = alloca uint, uint %Size        ;; Variable sized alloca
-	store uint %Size, uint* %X
-	%Y = load uint* %X
-	ret uint %Y
+define i32 @varalloca(i32 %Size) {
+        ;; Variable sized alloca
+	%X = alloca i32, i32 %Size		; <i32*> [#uses=2]
+	store i32 %Size, i32* %X
+	%Y = load i32* %X		; <i32> [#uses=1]
+	ret i32 %Y
 }
 
-int %main() {
-	%A = alloca sbyte
-	%B = alloca short
-	%C = alloca int
-	%D = alloca long
-	call void %test(sbyte* %A, short* %B, int* %C, long* %D)
-	call uint %varalloca(uint 7)
-
-	ret int 0
+define i32 @main() {
+	%A = alloca i8		; <i8*> [#uses=1]
+	%B = alloca i16		; <i16*> [#uses=1]
+	%C = alloca i32		; <i32*> [#uses=1]
+	%D = alloca i64		; <i64*> [#uses=1]
+	call void @test( i8* %A, i16* %B, i32* %C, i64* %D )
+	call i32 @varalloca( i32 7 )		; <i32>:1 [#uses=0]
+	ret i32 0
 }
diff --git a/test/ExecutionEngine/test-logical.ll b/test/ExecutionEngine/test-logical.ll
index 86af2e2..800de1f 100644
--- a/test/ExecutionEngine/test-logical.ll
+++ b/test/ExecutionEngine/test-logical.ll
@@ -1,23 +1,19 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-int %main() {
-	%A = and sbyte 4, 8
-	%B = or sbyte %A, 7
-	%C = xor sbyte %B, %A
-
-	%A = and short 4, 8
-	%B = or short %A, 7
-	%C = xor short %B, %A
-
-	%A = and int 4, 8
-	%B = or int %A, 7
-	%C = xor int %B, %A
-
-	%A = and long 4, 8
-	%B = or long %A, 7
-	%C = xor long %B, %A
-
-	ret int 0
+define i32 @main() {
+	%A = and i8 4, 8		; <i8> [#uses=2]
+	%B = or i8 %A, 7		; <i8> [#uses=1]
+	%C = xor i8 %B, %A		; <i8> [#uses=0]
+	%A.upgrd.1 = and i16 4, 8		; <i16> [#uses=2]
+	%B.upgrd.2 = or i16 %A.upgrd.1, 7		; <i16> [#uses=1]
+	%C.upgrd.3 = xor i16 %B.upgrd.2, %A.upgrd.1		; <i16> [#uses=0]
+	%A.upgrd.4 = and i32 4, 8		; <i32> [#uses=2]
+	%B.upgrd.5 = or i32 %A.upgrd.4, 7		; <i32> [#uses=1]
+	%C.upgrd.6 = xor i32 %B.upgrd.5, %A.upgrd.4		; <i32> [#uses=0]
+	%A.upgrd.7 = and i64 4, 8		; <i64> [#uses=2]
+	%B.upgrd.8 = or i64 %A.upgrd.7, 7		; <i64> [#uses=1]
+	%C.upgrd.9 = xor i64 %B.upgrd.8, %A.upgrd.7		; <i64> [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/test-loop.ll b/test/ExecutionEngine/test-loop.ll
index 79ffbd2..d428adc 100644
--- a/test/ExecutionEngine/test-loop.ll
+++ b/test/ExecutionEngine/test-loop.ll
@@ -1,13 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-int %main() {
+define i32 @main() {
+; <label>:0
 	br label %Loop
-Loop:
-	%I = phi int [0, %0], [%i2, %Loop]
-	%i2 = add int %I, 1
-	%C = seteq int %i2, 10
-	br bool %C, label %Out, label %Loop
-Out:
-	ret int 0
+Loop:		; preds = %Loop, %0
+	%I = phi i32 [ 0, %0 ], [ %i2, %Loop ]		; <i32> [#uses=1]
+	%i2 = add i32 %I, 1		; <i32> [#uses=2]
+	%C = icmp eq i32 %i2, 10		; <i1> [#uses=1]
+	br i1 %C, label %Out, label %Loop
+Out:		; preds = %Loop
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/test-malloc.ll b/test/ExecutionEngine/test-malloc.ll
index 7a7f245..843a389 100644
--- a/test/ExecutionEngine/test-malloc.ll
+++ b/test/ExecutionEngine/test-malloc.ll
@@ -1,14 +1,14 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-int %main() {
-   %X = malloc int                ; constant size
-   %Y = malloc int, uint 100      ; constant size
-   %u = add uint 1, 2
-   %Z = malloc int, uint %u       ; variable size
-   free int* %X
-   free int* %Y
-   free int* %Z
-   ret int 0
+define i32 @main() {
+	%X = malloc i32		; <i32*> [#uses=1]
+	%Y = malloc i32, i32 100		; <i32*> [#uses=1]
+	%u = add i32 1, 2		; <i32> [#uses=1]
+	%Z = malloc i32, i32 %u		; <i32*> [#uses=1]
+	free i32* %X
+	free i32* %Y
+	free i32* %Z
+	ret i32 0
 }
+
diff --git a/test/ExecutionEngine/test-phi.ll b/test/ExecutionEngine/test-phi.ll
index e50cbad..9ca1eb4 100644
--- a/test/ExecutionEngine/test-phi.ll
+++ b/test/ExecutionEngine/test-phi.ll
@@ -1,32 +1,35 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; test phi node
+@Y = global i32 6		; <i32*> [#uses=1]
 
-%Y = global int 6
-
-void %blah(int *%X) {
+define void @blah(i32* %X) {
+; <label>:0
 	br label %T
-T:
-	phi int* [%X, %0], [%Y, %Dead]
+T:		; preds = %Dead, %0
+	phi i32* [ %X, %0 ], [ @Y, %Dead ]		; <i32*>:1 [#uses=0]
 	ret void
-Dead:
+Dead:		; No predecessors!
 	br label %T
 }
 
-int %test(bool %C) {
-	br bool %C, label %T, label %T
-T:
-	%X = phi int [123, %0], [123, %0]
-	ret int %X
+define i32 @test(i1 %C) {
+; <label>:0
+	br i1 %C, label %T, label %T
+T:		; preds = %0, %0
+	%X = phi i32 [ 123, %0 ], [ 123, %0 ]		; <i32> [#uses=1]
+	ret i32 %X
 }
 
-int %main() {
+define i32 @main() {
+; <label>:0
 	br label %Test
-Test:
-	%X = phi int [0, %0], [%Y, %Dead]
-	ret int %X
-Dead:
-	%Y = shr int 12, ubyte 4
+Test:		; preds = %Dead, %0
+	%X = phi i32 [ 0, %0 ], [ %Y, %Dead ]		; <i32> [#uses=1]
+	ret i32 %X
+Dead:		; No predecessors!
+	%Y = ashr i32 12, 4		; <i32> [#uses=1]
 	br label %Test
 }
+
diff --git a/test/ExecutionEngine/test-ret.ll b/test/ExecutionEngine/test-ret.ll
index e206912..2d79945 100644
--- a/test/ExecutionEngine/test-ret.ll
+++ b/test/ExecutionEngine/test-ret.ll
@@ -1,16 +1,47 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 ; test return instructions
+define void @test1() {
+	ret void
+}
 
-void %test1() { ret void }
-sbyte %test2() { ret sbyte 1 }
-ubyte %test3() { ret ubyte 1 }
-short %test4() { ret short -1 }
-ushort %test5() { ret ushort 65535 }
-int  %main() { ret int 0 }
-uint %test6() { ret uint 4 }
-long %test7() { ret long 0 }
-ulong %test8() { ret ulong 0 }
-float %test9() { ret float 1.0 }
-double %test10() { ret double 2.0 }
+define i8 @test2() {
+	ret i8 1
+}
+
+define i8 @test3() {
+	ret i8 1
+}
+
+define i16 @test4() {
+	ret i16 -1
+}
+
+define i16 @test5() {
+	ret i16 -1
+}
+
+define i32 @main() {
+	ret i32 0
+}
+
+define i32 @test6() {
+	ret i32 4
+}
+
+define i64 @test7() {
+	ret i64 0
+}
+
+define i64 @test8() {
+	ret i64 0
+}
+
+define float @test9() {
+	ret float 1.000000e+00
+}
+
+define double @test10() {
+	ret double 2.000000e+00
+}
diff --git a/test/ExecutionEngine/test-setcond-fp.ll b/test/ExecutionEngine/test-setcond-fp.ll
index 3f54d6f..2f53e90 100644
--- a/test/ExecutionEngine/test-setcond-fp.ll
+++ b/test/ExecutionEngine/test-setcond-fp.ll
@@ -1,23 +1,25 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
 
-int %main() {
-	%double1 = add double 0.0, 0.0
-	%double2 = add double 0.0, 0.0
-	%float1 = add float 0.0, 0.0
-	%float2 = add float 0.0, 0.0
-	%test49 = seteq float %float1, %float2
-	%test50 = setge float %float1, %float2
-	%test51 = setgt float %float1, %float2
-	%test52 = setle float %float1, %float2
-	%test53 = setlt float %float1, %float2
-	%test54 = setne float %float1, %float2
-	%test55 = seteq double %double1, %double2
-	%test56 = setge double %double1, %double2
-	%test57 = setgt double %double1, %double2
-	%test58 = setle double %double1, %double2
-	%test59 = setlt double %double1, %double2
-	%test60 = setne double %double1, %double2
-	ret int 0
+define i32 @main() {
+	%double1 = add double 0.000000e+00, 0.000000e+00		; <double> [#uses=6]
+	%double2 = add double 0.000000e+00, 0.000000e+00		; <double> [#uses=6]
+	%float1 = add float 0.000000e+00, 0.000000e+00		; <float> [#uses=6]
+	%float2 = add float 0.000000e+00, 0.000000e+00		; <float> [#uses=6]
+	%test49 = fcmp oeq float %float1, %float2		; <i1> [#uses=0]
+	%test50 = fcmp oge float %float1, %float2		; <i1> [#uses=0]
+	%test51 = fcmp ogt float %float1, %float2		; <i1> [#uses=0]
+	%test52 = fcmp ole float %float1, %float2		; <i1> [#uses=0]
+	%test53 = fcmp olt float %float1, %float2		; <i1> [#uses=0]
+	%test54 = fcmp une float %float1, %float2		; <i1> [#uses=0]
+	%test55 = fcmp oeq double %double1, %double2		; <i1> [#uses=0]
+	%test56 = fcmp oge double %double1, %double2		; <i1> [#uses=0]
+	%test57 = fcmp ogt double %double1, %double2		; <i1> [#uses=0]
+	%test58 = fcmp ole double %double1, %double2		; <i1> [#uses=0]
+	%test59 = fcmp olt double %double1, %double2		; <i1> [#uses=0]
+	%test60 = fcmp une double %double1, %double2		; <i1> [#uses=0]
+	ret i32 0
 }
+
+
diff --git a/test/ExecutionEngine/test-setcond-int.ll b/test/ExecutionEngine/test-setcond-int.ll
index db5b48b..5ec4ec9 100644
--- a/test/ExecutionEngine/test-setcond-int.ll
+++ b/test/ExecutionEngine/test-setcond-int.ll
@@ -1,71 +1,70 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-
-int %main() {
-	%int1 = add int 0, 0
-	%int2 = add int 0, 0
-	%long1 = add long 0, 0
-	%long2 = add long 0, 0
-	%sbyte1 = add sbyte 0, 0
-	%sbyte2 = add sbyte 0, 0
-	%short1 = add short 0, 0
-	%short2 = add short 0, 0
-	%ubyte1 = add ubyte 0, 0
-	%ubyte2 = add ubyte 0, 0
-	%uint1 = add uint 0, 0
-	%uint2 = add uint 0, 0
-	%ulong1 = add ulong 0, 0
-	%ulong2 = add ulong 0, 0
-	%ushort1 = add ushort 0, 0
-	%ushort2 = add ushort 0, 0
-	%test1 = seteq ubyte %ubyte1, %ubyte2
-	%test2 = setge ubyte %ubyte1, %ubyte2
-	%test3 = setgt ubyte %ubyte1, %ubyte2
-	%test4 = setle ubyte %ubyte1, %ubyte2
-	%test5 = setlt ubyte %ubyte1, %ubyte2
-	%test6 = setne ubyte %ubyte1, %ubyte2
-	%test7 = seteq ushort %ushort1, %ushort2
-	%test8 = setge ushort %ushort1, %ushort2
-	%test9 = setgt ushort %ushort1, %ushort2
-	%test10 = setle ushort %ushort1, %ushort2
-	%test11 = setlt ushort %ushort1, %ushort2
-	%test12 = setne ushort %ushort1, %ushort2
-	%test13 = seteq uint %uint1, %uint2
-	%test14 = setge uint %uint1, %uint2
-	%test15 = setgt uint %uint1, %uint2
-	%test16 = setle uint %uint1, %uint2
-	%test17 = setlt uint %uint1, %uint2
-	%test18 = setne uint %uint1, %uint2
-	%test19 = seteq ulong %ulong1, %ulong2
-	%test20 = setge ulong %ulong1, %ulong2
-	%test21 = setgt ulong %ulong1, %ulong2
-	%test22 = setle ulong %ulong1, %ulong2
-	%test23 = setlt ulong %ulong1, %ulong2
-	%test24 = setne ulong %ulong1, %ulong2
-	%test25 = seteq sbyte %sbyte1, %sbyte2
-	%test26 = setge sbyte %sbyte1, %sbyte2
-	%test27 = setgt sbyte %sbyte1, %sbyte2
-	%test28 = setle sbyte %sbyte1, %sbyte2
-	%test29 = setlt sbyte %sbyte1, %sbyte2
-	%test30 = setne sbyte %sbyte1, %sbyte2
-	%test31 = seteq short %short1, %short2
-	%test32 = setge short %short1, %short2
-	%test33 = setgt short %short1, %short2
-	%test34 = setle short %short1, %short2
-	%test35 = setlt short %short1, %short2
-	%test36 = setne short %short1, %short2
-	%test37 = seteq int %int1, %int2
-	%test38 = setge int %int1, %int2
-	%test39 = setgt int %int1, %int2
-	%test40 = setle int %int1, %int2
-	%test41 = setlt int %int1, %int2
-	%test42 = setne int %int1, %int2
-	%test43 = seteq long %long1, %long2
-	%test44 = setge long %long1, %long2
-	%test45 = setgt long %long1, %long2
-	%test46 = setle long %long1, %long2
-	%test47 = setlt long %long1, %long2
-	%test48 = setne long %long1, %long2
-	ret int 0
+define i32 @main() {
+	%int1 = add i32 0, 0		; <i32> [#uses=6]
+	%int2 = add i32 0, 0		; <i32> [#uses=6]
+	%long1 = add i64 0, 0		; <i64> [#uses=6]
+	%long2 = add i64 0, 0		; <i64> [#uses=6]
+	%sbyte1 = add i8 0, 0		; <i8> [#uses=6]
+	%sbyte2 = add i8 0, 0		; <i8> [#uses=6]
+	%short1 = add i16 0, 0		; <i16> [#uses=6]
+	%short2 = add i16 0, 0		; <i16> [#uses=6]
+	%ubyte1 = add i8 0, 0		; <i8> [#uses=6]
+	%ubyte2 = add i8 0, 0		; <i8> [#uses=6]
+	%uint1 = add i32 0, 0		; <i32> [#uses=6]
+	%uint2 = add i32 0, 0		; <i32> [#uses=6]
+	%ulong1 = add i64 0, 0		; <i64> [#uses=6]
+	%ulong2 = add i64 0, 0		; <i64> [#uses=6]
+	%ushort1 = add i16 0, 0		; <i16> [#uses=6]
+	%ushort2 = add i16 0, 0		; <i16> [#uses=6]
+	%test1 = icmp eq i8 %ubyte1, %ubyte2		; <i1> [#uses=0]
+	%test2 = icmp uge i8 %ubyte1, %ubyte2		; <i1> [#uses=0]
+	%test3 = icmp ugt i8 %ubyte1, %ubyte2		; <i1> [#uses=0]
+	%test4 = icmp ule i8 %ubyte1, %ubyte2		; <i1> [#uses=0]
+	%test5 = icmp ult i8 %ubyte1, %ubyte2		; <i1> [#uses=0]
+	%test6 = icmp ne i8 %ubyte1, %ubyte2		; <i1> [#uses=0]
+	%test7 = icmp eq i16 %ushort1, %ushort2		; <i1> [#uses=0]
+	%test8 = icmp uge i16 %ushort1, %ushort2		; <i1> [#uses=0]
+	%test9 = icmp ugt i16 %ushort1, %ushort2		; <i1> [#uses=0]
+	%test10 = icmp ule i16 %ushort1, %ushort2		; <i1> [#uses=0]
+	%test11 = icmp ult i16 %ushort1, %ushort2		; <i1> [#uses=0]
+	%test12 = icmp ne i16 %ushort1, %ushort2		; <i1> [#uses=0]
+	%test13 = icmp eq i32 %uint1, %uint2		; <i1> [#uses=0]
+	%test14 = icmp uge i32 %uint1, %uint2		; <i1> [#uses=0]
+	%test15 = icmp ugt i32 %uint1, %uint2		; <i1> [#uses=0]
+	%test16 = icmp ule i32 %uint1, %uint2		; <i1> [#uses=0]
+	%test17 = icmp ult i32 %uint1, %uint2		; <i1> [#uses=0]
+	%test18 = icmp ne i32 %uint1, %uint2		; <i1> [#uses=0]
+	%test19 = icmp eq i64 %ulong1, %ulong2		; <i1> [#uses=0]
+	%test20 = icmp uge i64 %ulong1, %ulong2		; <i1> [#uses=0]
+	%test21 = icmp ugt i64 %ulong1, %ulong2		; <i1> [#uses=0]
+	%test22 = icmp ule i64 %ulong1, %ulong2		; <i1> [#uses=0]
+	%test23 = icmp ult i64 %ulong1, %ulong2		; <i1> [#uses=0]
+	%test24 = icmp ne i64 %ulong1, %ulong2		; <i1> [#uses=0]
+	%test25 = icmp eq i8 %sbyte1, %sbyte2		; <i1> [#uses=0]
+	%test26 = icmp sge i8 %sbyte1, %sbyte2		; <i1> [#uses=0]
+	%test27 = icmp sgt i8 %sbyte1, %sbyte2		; <i1> [#uses=0]
+	%test28 = icmp sle i8 %sbyte1, %sbyte2		; <i1> [#uses=0]
+	%test29 = icmp slt i8 %sbyte1, %sbyte2		; <i1> [#uses=0]
+	%test30 = icmp ne i8 %sbyte1, %sbyte2		; <i1> [#uses=0]
+	%test31 = icmp eq i16 %short1, %short2		; <i1> [#uses=0]
+	%test32 = icmp sge i16 %short1, %short2		; <i1> [#uses=0]
+	%test33 = icmp sgt i16 %short1, %short2		; <i1> [#uses=0]
+	%test34 = icmp sle i16 %short1, %short2		; <i1> [#uses=0]
+	%test35 = icmp slt i16 %short1, %short2		; <i1> [#uses=0]
+	%test36 = icmp ne i16 %short1, %short2		; <i1> [#uses=0]
+	%test37 = icmp eq i32 %int1, %int2		; <i1> [#uses=0]
+	%test38 = icmp sge i32 %int1, %int2		; <i1> [#uses=0]
+	%test39 = icmp sgt i32 %int1, %int2		; <i1> [#uses=0]
+	%test40 = icmp sle i32 %int1, %int2		; <i1> [#uses=0]
+	%test41 = icmp slt i32 %int1, %int2		; <i1> [#uses=0]
+	%test42 = icmp ne i32 %int1, %int2		; <i1> [#uses=0]
+	%test43 = icmp eq i64 %long1, %long2		; <i1> [#uses=0]
+	%test44 = icmp sge i64 %long1, %long2		; <i1> [#uses=0]
+	%test45 = icmp sgt i64 %long1, %long2		; <i1> [#uses=0]
+	%test46 = icmp sle i64 %long1, %long2		; <i1> [#uses=0]
+	%test47 = icmp slt i64 %long1, %long2		; <i1> [#uses=0]
+	%test48 = icmp ne i64 %long1, %long2		; <i1> [#uses=0]
+	ret i32 0
 }
diff --git a/test/ExecutionEngine/test-shift.ll b/test/ExecutionEngine/test-shift.ll
index 2549f34..ebb85d3 100644
--- a/test/ExecutionEngine/test-shift.ll
+++ b/test/ExecutionEngine/test-shift.ll
@@ -1,40 +1,33 @@
-; RUN: llvm-upgrade %s | llvm-as -f -o %t.bc
+; RUN: llvm-as < %s -f -o %t.bc
 ; RUN: lli %t.bc > /dev/null
 
-; test shifts
-int %main() {
-    %shamt = add ubyte 0, 1
-
-    ; Left shifts...
-    %t1.s = shl int 1, ubyte %shamt
-    %t2.s = shl int 1, ubyte 4
-
-    %t1 = shl uint 1, ubyte %shamt
-    %t2 = shl uint 1, ubyte 5
-
-    ;%t1 = shl long 1, ubyte %shamt
-    %t2.s = shl long 1, ubyte 4
-
-    ;%t1 = shl ulong 1, ubyte %shamt
-    %t2 = shl ulong 1, ubyte 5
-
-    ; Right shifts...
-    %tr1.s = shr int 1, ubyte %shamt
-    %tr2.s = shr int 1, ubyte 4
-
-    %tr1 = shr uint 1, ubyte %shamt
-    %tr2 = shr uint 1, ubyte 5
-
-    ;%tr1 = shr long 1, ubyte %shamt
-    %tr1.l = shr long 1, ubyte 4
-    %tr2.l = shr long 1, ubyte %shamt
-    %tr3.l = shl long 1, ubyte 4
-    %tr4.l = shl long 1, ubyte %shamt
-
-    ;%t1 = shr ulong 1, ubyte %shamt
-    %tr1.u = shr ulong 1, ubyte 5
-    %tr2.u = shr ulong 1, ubyte %shamt
-    %tr3.u = shl ulong 1, ubyte 5
-    %tr4.u = shl ulong 1, ubyte %shamt
-    ret int 0
+define i32 @main() {
+	%shamt = add i8 0, 1		; <i8> [#uses=8]
+	%shift.upgrd.1 = zext i8 %shamt to i32		; <i32> [#uses=1]
+	%t1.s = shl i32 1, %shift.upgrd.1		; <i32> [#uses=0]
+	%t2.s = shl i32 1, 4		; <i32> [#uses=0]
+	%shift.upgrd.2 = zext i8 %shamt to i32		; <i32> [#uses=1]
+	%t1 = shl i32 1, %shift.upgrd.2		; <i32> [#uses=0]
+	%t2 = shl i32 1, 5		; <i32> [#uses=0]
+	%t2.s.upgrd.3 = shl i64 1, 4		; <i64> [#uses=0]
+	%t2.upgrd.4 = shl i64 1, 5		; <i64> [#uses=0]
+	%shift.upgrd.5 = zext i8 %shamt to i32		; <i32> [#uses=1]
+	%tr1.s = ashr i32 1, %shift.upgrd.5		; <i32> [#uses=0]
+	%tr2.s = ashr i32 1, 4		; <i32> [#uses=0]
+	%shift.upgrd.6 = zext i8 %shamt to i32		; <i32> [#uses=1]
+	%tr1 = lshr i32 1, %shift.upgrd.6		; <i32> [#uses=0]
+	%tr2 = lshr i32 1, 5		; <i32> [#uses=0]
+	%tr1.l = ashr i64 1, 4		; <i64> [#uses=0]
+	%shift.upgrd.7 = zext i8 %shamt to i64		; <i64> [#uses=1]
+	%tr2.l = ashr i64 1, %shift.upgrd.7		; <i64> [#uses=0]
+	%tr3.l = shl i64 1, 4		; <i64> [#uses=0]
+	%shift.upgrd.8 = zext i8 %shamt to i64		; <i64> [#uses=1]
+	%tr4.l = shl i64 1, %shift.upgrd.8		; <i64> [#uses=0]
+	%tr1.u = lshr i64 1, 5		; <i64> [#uses=0]
+	%shift.upgrd.9 = zext i8 %shamt to i64		; <i64> [#uses=1]
+	%tr2.u = lshr i64 1, %shift.upgrd.9		; <i64> [#uses=0]
+	%tr3.u = shl i64 1, 5		; <i64> [#uses=0]
+	%shift.upgrd.10 = zext i8 %shamt to i64		; <i64> [#uses=1]
+	%tr4.u = shl i64 1, %shift.upgrd.10		; <i64> [#uses=0]
+	ret i32 0
 }
diff --git a/test/Linker/2003-11-18-TypeResolution.ll b/test/Linker/2003-11-18-TypeResolution.ll
index ff22e31..d3152ed 100644
--- a/test/Linker/2003-11-18-TypeResolution.ll
+++ b/test/Linker/2003-11-18-TypeResolution.ll
@@ -4,19 +4,16 @@
 ; little symbol table.  This is causing llvm-link to die, at no fault of its
 ; own.
 
-; RUN: llvm-upgrade %s | llvm-as > %t.out2.bc
+; RUN: llvm-as < %s > %t.out2.bc
 ; RUN: echo "%T1 = type opaque  @GVar = external global %T1*" | llvm-as > %t.out1.bc
 ; RUN: llvm-link %t.out1.bc %t.out2.bc
 
-	%T1 = type opaque
-	%T2 = type int
+%T1 = type opaque
+%T2 = type i32
+@GVar = global i32* null		; <i32**> [#uses=0]
 
-%GVar = global %T2 * null
-
-implementation
-
-void %foo(%T2 * %X) {
-	%X = cast %T2* %X to %T1 *
+define void @foo(i32* %X) {
+	%X.upgrd.1 = bitcast i32* %X to %T1*		; <%T1*> [#uses=0]
 	ret void
 }
 
diff --git a/test/Linker/2004-02-17-WeakStrongLinkage.ll b/test/Linker/2004-02-17-WeakStrongLinkage.ll
index 4c6e8f8..0e970dd 100644
--- a/test/Linker/2004-02-17-WeakStrongLinkage.ll
+++ b/test/Linker/2004-02-17-WeakStrongLinkage.ll
@@ -1,7 +1,7 @@
-; RUN: llvm-upgrade < %s | llvm-as > %t.out2.bc
-; RUN: echo "%me = global int* null" | llvm-upgrade | llvm-as > %t.out1.bc
+; RUN: llvm-as < %s > %t.out2.bc
+; RUN: echo "@me = global i32* null" | llvm-as > %t.out1.bc
 ; RUN: llvm-link %t.out1.bc %t.out2.bc -o /dev/null -f
 
-%me = weak global int * null
+@me = weak global i32* null		; <i32**> [#uses=0]
 
 
diff --git a/test/Linker/2004-05-07-TypeResolution1.ll b/test/Linker/2004-05-07-TypeResolution1.ll
index 1c90079..970a6d2 100644
--- a/test/Linker/2004-05-07-TypeResolution1.ll
+++ b/test/Linker/2004-05-07-TypeResolution1.ll
@@ -1,45 +1,35 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t1.bc
-; RUN: llvm-upgrade < %p/2004-05-07-TypeResolution2.ll | \
-; RUN:    llvm-as -o %t2.bc -f
+; RUN: llvm-as < %s -f -o %t1.bc
+; RUN: llvm-as < %p/2004-05-07-TypeResolution2.ll -o %t2.bc -f
 ; RUN: llvm-link -f -o %t3.bc %t1.bc %t2.bc
 
-target endian = little
-target pointersize = 32
-
-  %myint = type opaque
+target datalayout = "e-p:32:32"
+	%myint = type opaque
+	%struct1 = type { i32, void (%struct2*)*, %myint*, i32 (i32*)* }
 	%struct2 = type { %struct1 }
+@driver1 = global %struct1 zeroinitializer		; <%struct1*> [#uses=1]
+@m1 = external global [1 x i8]*		; <[1 x i8]**> [#uses=0]
+@str1 = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=0]
+@str2 = constant [2 x i8] zeroinitializer		; <[2 x i8]*> [#uses=0]
+@str3 = constant [3 x i8] zeroinitializer		; <[3 x i8]*> [#uses=0]
+@str4 = constant [4 x i8] zeroinitializer		; <[4 x i8]*> [#uses=0]
+@str5 = constant [5 x i8] zeroinitializer		; <[5 x i8]*> [#uses=0]
+@str6 = constant [6 x i8] zeroinitializer		; <[6 x i8]*> [#uses=0]
+@str7 = constant [7 x i8] zeroinitializer		; <[7 x i8]*> [#uses=0]
+@str8 = constant [8 x i8] zeroinitializer		; <[8 x i8]*> [#uses=0]
+@str9 = constant [9 x i8] zeroinitializer		; <[9 x i8]*> [#uses=0]
+@stra = constant [10 x i8] zeroinitializer		; <[10 x i8]*> [#uses=0]
+@strb = constant [11 x i8] zeroinitializer		; <[11 x i8]*> [#uses=0]
+@strc = constant [12 x i8] zeroinitializer		; <[12 x i8]*> [#uses=0]
+@strd = constant [13 x i8] zeroinitializer		; <[13 x i8]*> [#uses=0]
+@stre = constant [14 x i8] zeroinitializer		; <[14 x i8]*> [#uses=0]
+@strf = constant [15 x i8] zeroinitializer		; <[15 x i8]*> [#uses=0]
+@strg = constant [16 x i8] zeroinitializer		; <[16 x i8]*> [#uses=0]
+@strh = constant [17 x i8] zeroinitializer		; <[17 x i8]*> [#uses=0]
 
-	%struct1 = type { int, void (%struct2*)*,  %myint *, int (uint *)* }
+declare void @func(%struct2*)
 
-
-%driver1 = global %struct1 zeroinitializer		; <%struct1*> [#uses=1]
-
-%m1 = external global [1 x sbyte] * 	; <%struct.task_struct**> [#uses=0]
-;%m1 = external global uint  	; <%struct.task_struct**> [#uses=0]
-%str1 = constant [1 x ubyte] zeroinitializer
-%str2 = constant [2 x ubyte] zeroinitializer
-%str3 = constant [3 x ubyte] zeroinitializer
-%str4 = constant [4 x ubyte] zeroinitializer
-%str5 = constant [5 x ubyte] zeroinitializer
-%str6 = constant [6 x ubyte] zeroinitializer
-%str7 = constant [7 x ubyte] zeroinitializer
-%str8 = constant [8 x ubyte] zeroinitializer
-%str9 = constant [9 x ubyte] zeroinitializer
-%stra = constant [10 x ubyte] zeroinitializer
-%strb = constant [11 x ubyte] zeroinitializer
-%strc = constant [12 x ubyte] zeroinitializer
-%strd = constant [13 x ubyte] zeroinitializer
-%stre = constant [14 x ubyte] zeroinitializer
-%strf = constant [15 x ubyte] zeroinitializer
-%strg = constant [16 x ubyte] zeroinitializer
-%strh = constant [17 x ubyte] zeroinitializer
-
-implementation   ; Functions:
-
-declare void %func(%struct2*)
-
-void %tty_init() {
+define void @tty_init() {
 entry:
-	volatile store void (%struct2*)* %func, void (%struct2 *)** getelementptr (%struct1*  %driver1, uint 0, uint 1)
+	volatile store void (%struct2*)* @func, void (%struct2*)** getelementptr (%struct1* @driver1, i64 0, i32 1)
 	ret void
 }
diff --git a/test/Linker/2004-05-07-TypeResolution2.ll b/test/Linker/2004-05-07-TypeResolution2.ll
index 05be611..74fe39f 100644
--- a/test/Linker/2004-05-07-TypeResolution2.ll
+++ b/test/Linker/2004-05-07-TypeResolution2.ll
@@ -1,25 +1,15 @@
 ; This file is used by testlink1.ll, so it doesn't actually do anything itself
 ;
 ; RUN: echo
-
-target endian = little
-target pointersize = 32
-
-  %myint = type ushort
+target datalayout = "e-p:32:32"
+	%myint = type i16
+	%struct1 = type { i32, void (%struct2*)*, i16*, i32 (i32*)* }
 	%struct2 = type { %struct1 }
-	%struct1 = type { int, void (%struct2*)*, %myint *, int (uint *)* }
 
-implementation   ; Functions:
-
-internal void %f1 (%struct1* %tty) {
+define internal void @f1(%struct1* %tty) {
 loopentry.preheader:
-
-  ; <void (%struct2*, ubyte)**> [#uses=1]
-  ; <void (%struct2*, ubyte)*> [#uses=0]
-
-	%tmp.2.i.i = getelementptr %struct1* %tty, uint 0, uint 1
-	%tmp.3.i.i = volatile load void (%struct2*)** %tmp.2.i.i
-
+	%tmp.2.i.i = getelementptr %struct1* %tty, i64 0, i32 1		; <void (%struct2*)**> [#uses=1]
+	%tmp.3.i.i = volatile load void (%struct2*)** %tmp.2.i.i		; <void (%struct2*)*> [#uses=0]
 	ret void
 }
 
diff --git a/test/Linker/2005-02-12-ConstantGlobals.ll b/test/Linker/2005-02-12-ConstantGlobals.ll
index fbc0bc1..4077372 100644
--- a/test/Linker/2005-02-12-ConstantGlobals.ll
+++ b/test/Linker/2005-02-12-ConstantGlobals.ll
@@ -2,7 +2,7 @@
 ; to be nonconst.
 
 ; RUN: echo {@X = global i32 7} | llvm-as > %t.2.bc
-; RUN: llvm-upgrade < %s | llvm-as > %t.1.bc
+; RUN: llvm-as < %s > %t.1.bc
 ; RUN: llvm-link %t.1.bc %t.2.bc | llvm-dis | grep {global i32 7}
 
-@X = external constant i32
+@X = external constant i32		; <i32*> [#uses=0]
diff --git a/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll b/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll
index 3e57bec..2637da1 100644
--- a/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll
+++ b/test/Linker/2005-12-06-AppendingZeroLengthArrays.ll
@@ -1,9 +1,10 @@
 ; RUN: echo { @G = appending global \[0 x i32\] zeroinitializer } | \
 ; RUN:   llvm-as > %t.out2.bc
-; RUN: llvm-upgrade < %s | llvm-as > %t.out1.bc
+; RUN: llvm-as < %s > %t.out1.bc
 ; RUN: llvm-link %t.out1.bc %t.out2.bc | llvm-dis | grep {@G =}
 
 ; When linked, the globals should be merged, and the result should still 
 ; be named '@G'.
 
-%G = appending global [1 x int] zeroinitializer
+@G = appending global [1 x i32] zeroinitializer		; <[1 x i32]*> [#uses=0]
+
diff --git a/test/Linker/2006-01-19-ConstantPacked.ll b/test/Linker/2006-01-19-ConstantPacked.ll
index 7b405f3..1cb4749 100644
--- a/test/Linker/2006-01-19-ConstantPacked.ll
+++ b/test/Linker/2006-01-19-ConstantPacked.ll
@@ -1,15 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as -f -o %t1.bc
+; RUN: llvm-as < %s -f -o %t1.bc
 ; RUN: llvm-link -f -o %t2.bc %t1.bc
 
-target endian = big
-target pointersize = 32
+target datalayout = "E-p:32:32"
 target triple = "powerpc-apple-darwin7.7.0"
 deplibs = [ "c", "crtend" ]
-%source = global <4 x int> < int 0, int 1, int 2, int 3 >
+@source = global <4 x i32> < i32 0, i32 1, i32 2, i32 3 >		; <<4 x i32>*> [#uses=0]
 
-implementation   ; Functions:
-
-int %main() {
+define i32 @main() {
 entry:
-        ret int 0
+	ret i32 0
 }
+
diff --git a/test/Linker/AppendingLinkage.ll b/test/Linker/AppendingLinkage.ll
index d59a374..da08ca0 100644
--- a/test/Linker/AppendingLinkage.ll
+++ b/test/Linker/AppendingLinkage.ll
@@ -1,15 +1,15 @@
 ; Test that appending linkage works correctly.
 
-; RUN: echo {%X = appending global \[1 x int\] \[int 8\] } | \
-; RUN:   llvm-upgrade | llvm-as > %t.2.bc
-; RUN: llvm-upgrade < %s | llvm-as > %t.1.bc
+; 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 | llvm-dis | grep 7 | grep 4 | grep 8
 
-%X = appending global [2 x int] [int 7, int 4]
+@X = appending global [2 x i32] [ i32 7, i32 4 ]		; <[2 x i32]*> [#uses=2]
+@Y = global i32* getelementptr ([2 x i32]* @X, i64 0, i64 0)		; <i32**> [#uses=0]
 
-%Y = global int* getelementptr ([2 x int]* %X, long 0, long 0)
-
-void %foo(long %V) {
-  %Y = getelementptr [2 x int]* %X, long 0, long %V
-  ret void
+define void @foo(i64 %V) {
+	%Y = getelementptr [2 x i32]* @X, i64 0, i64 %V		; <i32*> [#uses=0]
+	ret void
 }
+
diff --git a/test/Linker/AppendingLinkage2.ll b/test/Linker/AppendingLinkage2.ll
index fc992e0..fddc494 100644
--- a/test/Linker/AppendingLinkage2.ll
+++ b/test/Linker/AppendingLinkage2.ll
@@ -1,8 +1,8 @@
 ; Test that appending linkage works correctly when arrays are the same size.
 
-; RUN: echo {%X = appending global \[1 x int\] \[int 8\] } | \
-; RUN:   llvm-upgrade | llvm-as > %t.2.bc
-; RUN: llvm-upgrade < %s | llvm-as > %t.1.bc
+; 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 | llvm-dis | grep 7 | grep 8
 
-%X = appending global [1 x int] [int 7]
+@X = appending global [1 x i32] [ i32 7 ]		; <[1 x i32]*> [#uses=0]
diff --git a/test/Linker/ConstantGlobals1.ll b/test/Linker/ConstantGlobals1.ll
index a5a9ce9..5d42f4b 100644
--- a/test/Linker/ConstantGlobals1.ll
+++ b/test/Linker/ConstantGlobals1.ll
@@ -1,8 +1,9 @@
 ; Test that appending linkage works correctly when arrays are the same size.
 
-; RUN: echo {%X = constant \[1 x int\] \[int 8\] } | \
-; RUN:   llvm-upgrade | llvm-as > %t.2.bc
-; RUN: llvm-upgrade < %s | llvm-as > %t.1.bc
+; 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 | llvm-dis | grep constant
 
-%X = uninitialized global [1 x int]
+@X = external global [1 x i32]		; <[1 x i32]*> [#uses=0]
+
diff --git a/test/Linker/ConstantGlobals2.ll b/test/Linker/ConstantGlobals2.ll
index 612603d..9cd6bdb 100644
--- a/test/Linker/ConstantGlobals2.ll
+++ b/test/Linker/ConstantGlobals2.ll
@@ -1,8 +1,9 @@
 ; Test that appending linkage works correctly when arrays are the same size.
 
-; RUN: echo {%X = external global \[1 x int\] } | \
-; RUN:   llvm-upgrade | llvm-as > %t.2.bc
-; RUN: llvm-upgrade %s -o - | llvm-as > %t.1.bc
+; 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 | llvm-dis | grep constant
 
-%X = constant [1 x int] [ int 12 ]
+@X = constant [1 x i32] [ i32 12 ]		; <[1 x i32]*> [#uses=0]
+
diff --git a/test/Linker/ConstantGlobals3.ll b/test/Linker/ConstantGlobals3.ll
index 4435f2d..f9aa07d 100644
--- a/test/Linker/ConstantGlobals3.ll
+++ b/test/Linker/ConstantGlobals3.ll
@@ -1,8 +1,8 @@
 ; Test that appending linkage works correctly when arrays are the same size.
 
-; RUN: echo {%X = external constant \[1 x int\] } | \
-; RUN:   llvm-upgrade | llvm-as > %t.2.bc
-; RUN: llvm-upgrade %s | llvm-as > %t.1.bc
+; 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 | llvm-dis | grep constant
 
-%X = uninitialized global [1 x int] 
+@X = external global [1 x i32]		; <[1 x i32]*> [#uses=0]
diff --git a/test/Linker/LinkOnce.ll b/test/Linker/LinkOnce.ll
index b1a0216..5befd77 100644
--- a/test/Linker/LinkOnce.ll
+++ b/test/Linker/LinkOnce.ll
@@ -1,8 +1,8 @@
 ; This fails because the linker renames the non-opaque type not the opaque 
 ; one...
 
-; RUN: echo "%X = linkonce global int 8" | llvm-upgrade | llvm-as > %t.2.bc
-; RUN: llvm-upgrade < %s | llvm-as > %t.1.bc
+; RUN: echo "@X = linkonce global i32 8" | llvm-as > %t.2.bc
+; RUN: llvm-as < %s > %t.1.bc
 ; RUN: llvm-link %t.1.bc %t.2.bc | llvm-dis
 
-%X = linkonce global int 7
+@X = linkonce global i32 7		; <i32*> [#uses=0]
diff --git a/test/Linker/testlink1.ll b/test/Linker/testlink1.ll
index df89d84..4a94025 100644
--- a/test/Linker/testlink1.ll
+++ b/test/Linker/testlink1.ll
@@ -1,48 +1,42 @@
-; RUN: llvm-upgrade < %s | llvm-as > %t.bc
-; RUN: llvm-upgrade < %p/testlink2.ll | llvm-as > %t2.bc
+; RUN: llvm-as < %s > %t.bc
+; RUN: llvm-as < %p/testlink2.ll > %t2.bc
 ; RUN: llvm-link %t.bc %t2.bc
 
-%MyVar     = external global int
-%MyIntList = global { \2 *, int } { { \2, int }* null, int 17 }
-             external global int      ; int*:0
+@MyVar = external global i32		; <i32*> [#uses=3]
+@MyIntList = global { \2*, i32 } { { \2*, i32 }* null, i32 17 }		; <{ \2*, i32 }*> [#uses=1]
+external global i32		; <i32*>:0 [#uses=0]
+@Inte = global i32 1		; <i32*> [#uses=0]
+@AConst = linkonce constant i32 123		; <i32*> [#uses=0]
+@Intern1 = internal constant i32 42		; <i32*> [#uses=0]
+@Intern2 = internal constant i32 792		; <i32*> [#uses=0]
+@MyVarPtr = linkonce global { i32* } { i32* @MyVar }		; <{ i32* }*> [#uses=0]
 
-%Inte = global int 1
+declare i32 @foo(i32)
 
-%AConst    = linkonce constant int 123
+declare void @print(i32)
 
-%Intern1   = internal constant int 42
-%Intern2   = internal constant int 792
-
-; Initialized to point to external %MyVar
-%MyVarPtr  = linkonce global { int * }  { int * %MyVar }
-
-declare int "foo"(int %blah)      ;; Declared in testlink2.ll
-
-declare void "print"(int %Value)
-
-implementation
-
-void "main"()
-begin
-	%v1 = load int* %MyVar
-	call void %print(int %v1)    ;; Should start out 4
-
-	%idx = getelementptr { \2 *, int }* %MyIntList, long 0, uint 1
-	%v2 = load int* %idx
-	call void %print(int %v2)    ;; Should start out 17
-
-	call int %foo(int 5)         ;; Modify global variablesx
-
-	%v3 = load int* %MyVar
-	call void %print(int %v3)    ;; Should now be 5
-
-	%v4 = load int* %idx
-	call void %print(int %v4)    ;; Should start out 12
-
+define void @main() {
+	%v1 = load i32* @MyVar		; <i32> [#uses=1]
+	call void @print( i32 %v1 )
+	%idx = getelementptr { \2*, i32 }* @MyIntList, i64 0, i32 1		; <i32*> [#uses=2]
+	%v2 = load i32* %idx		; <i32> [#uses=1]
+	call void @print( i32 %v2 )
+	call i32 @foo( i32 5 )		; <i32>:1 [#uses=0]
+	%v3 = load i32* @MyVar		; <i32> [#uses=1]
+	call void @print( i32 %v3 )
+	%v4 = load i32* %idx		; <i32> [#uses=1]
+	call void @print( i32 %v4 )
 	ret void
-end
+}
 
-internal void "testintern"() begin ret void end
-internal void "Testintern"() begin ret void end
-         void "testIntern"() begin ret void end
+define internal void @testintern() {
+	ret void
+}
 
+define internal void @Testintern() {
+	ret void
+}
+
+define void @testIntern() {
+	ret void
+}
diff --git a/test/Linker/testlink2.ll b/test/Linker/testlink2.ll
index 0f4468d..d243e3c 100644
--- a/test/Linker/testlink2.ll
+++ b/test/Linker/testlink2.ll
@@ -2,35 +2,40 @@
 ;
 ; RUN: true
 
-%MyVar     = global int 4
-%MyIntList = external global { \2 *, int }
+@MyVar = global i32 4		; <i32*> [#uses=2]
+@MyIntList = external global { \2*, i32 }		; <{ \2*, i32 }*> [#uses=2]
+@AConst = constant i32 123		; <i32*> [#uses=0]
 
-%AConst    = constant int 123
+;; Intern in both testlink[12].ll
+@Intern1 = internal constant i32 52		; <i32*> [#uses=0]
 
-%Intern1   = internal constant int 52 ;; Intern in both testlink[12].ll
-%Intern2   = constant int 12345       ;; Intern in one but not in other
+;; Intern in one but not in other
+@Intern2 = constant i32 12345		; <i32*> [#uses=0]
 
-%MyIntListPtr = constant { {\2,int}* } { {\2,int}* %MyIntList }
-%MyVarPtr  = linkonce global { int * }  { int * %MyVar }
+@MyIntListPtr = constant { { \2*, i32 }* } { { \2*, i32 }* @MyIntList }		; <{ { \2*, i32 }* }*> [#uses=0]
+@MyVarPtr = linkonce global { i32* } { i32* @MyVar }		; <{ i32* }*> [#uses=0]
+constant i32 412		; <i32*>:0 [#uses=1]
 
-constant int 412
+define i32 @foo(i32 %blah) {
+	store i32 %blah, i32* @MyVar
+	%idx = getelementptr { \2*, i32 }* @MyIntList, i64 0, i32 1		; <i32*> [#uses=1]
+	store i32 12, i32* %idx
+	%ack = load i32* @0		; <i32> [#uses=1]
+	%fzo = add i32 %ack, %blah		; <i32> [#uses=1]
+	ret i32 %fzo
+}
 
-implementation
+declare void @unimp(float, double)
 
-int "foo"(int %blah)
-begin
-	store int %blah, int *%MyVar
-	%idx = getelementptr { \2 *, int } * %MyIntList, long 0, uint 1
-	store int 12, int* %idx
+define internal void @testintern() {
+	ret void
+}
 
-	%ack = load int * %0   ;; Load from the unnamed constant
-	%fzo = add int %ack, %blah
-	ret int %fzo
-end
+define void @Testintern() {
+	ret void
+}
 
-declare void "unimp"(float, double)
-
-internal void "testintern"() begin ret void end
-         void "Testintern"() begin ret void end
-internal void "testIntern"() begin ret void end
+define internal void @testIntern() {
+	ret void
+}
 
diff --git a/test/Linker/weakextern.ll b/test/Linker/weakextern.ll
index 60ca596..edb23bc 100644
--- a/test/Linker/weakextern.ll
+++ b/test/Linker/weakextern.ll
@@ -1,12 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as > %t.bc
-; RUN: llvm-upgrade < %p/testlink1.ll | llvm-as > %t2.bc
+; 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 -f
 ; 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 ubyte]
-%MyVar     = extern_weak global int
-%Inte = extern_weak global int
+@kallsyms_names = extern_weak global [0 x i8]		; <[0 x i8]*> [#uses=0]
+@MyVar = extern_weak global i32		; <i32*> [#uses=0]
+@Inte = extern_weak global i32		; <i32*> [#uses=0]
 
-implementation
diff --git a/test/Transforms/SimplifyCFG/2002-05-05-EmptyBlockMerge.ll b/test/Transforms/SimplifyCFG/2002-05-05-EmptyBlockMerge.ll
index 7f0a57c..5682ff4 100644
--- a/test/Transforms/SimplifyCFG/2002-05-05-EmptyBlockMerge.ll
+++ b/test/Transforms/SimplifyCFG/2002-05-05-EmptyBlockMerge.ll
@@ -1,24 +1,22 @@
 ; Basic block #2 should not be merged into BB #3!
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   grep {br label}
 ;
-declare void %foo()
-implementation
 
-void "cprop_test12"(int* %data) {
+declare void @foo()
+
+define void @cprop_test12(i32* %data) {
 bb0:
-        %reg108 = load int* %data
-        %cond218 = setne int %reg108, 5
-        br bool %cond218, label %bb3, label %bb2
-
-bb2:
-	call void %foo()
-        br label %bb3
-
-bb3:
-        %reg117 = phi int [ 110, %bb2 ], [ %reg108, %bb0 ]
-        store int %reg117, int* %data
-        ret void
+	%reg108 = load i32* %data		; <i32> [#uses=2]
+	%cond218 = icmp ne i32 %reg108, 5		; <i1> [#uses=1]
+	br i1 %cond218, label %bb3, label %bb2
+bb2:		; preds = %bb0
+	call void @foo( )
+	br label %bb3
+bb3:		; preds = %bb2, %bb0
+	%reg117 = phi i32 [ 110, %bb2 ], [ %reg108, %bb0 ]		; <i32> [#uses=1]
+	store i32 %reg117, i32* %data
+	ret void
 }
 
diff --git a/test/Transforms/SimplifyCFG/2002-05-21-PHIElimination.ll b/test/Transforms/SimplifyCFG/2002-05-21-PHIElimination.ll
index 1ef6593..c955d66 100644
--- a/test/Transforms/SimplifyCFG/2002-05-21-PHIElimination.ll
+++ b/test/Transforms/SimplifyCFG/2002-05-21-PHIElimination.ll
@@ -4,16 +4,16 @@
 ;
 ; Which is not valid SSA
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis
 
-void "test"() {
-	br bool true, label %end, label %Loop
-
-Loop:
-	%V = phi int [0, %0], [%V1, %Loop]
-	%V1 = add int %V, 1
-
+define void @test() {
+; <label>:0
+	br i1 true, label %end, label %Loop
+Loop:		; preds = %Loop, %0
+	%V = phi i32 [ 0, %0 ], [ %V1, %Loop ]		; <i32> [#uses=1]
+	%V1 = add i32 %V, 1		; <i32> [#uses=1]
 	br label %Loop
-end:
+end:		; preds = %0
 	ret void
 }
+
diff --git a/test/Transforms/SimplifyCFG/2002-06-24-PHINode.ll b/test/Transforms/SimplifyCFG/2002-06-24-PHINode.ll
index a669a3f..87b4286 100644
--- a/test/Transforms/SimplifyCFG/2002-06-24-PHINode.ll
+++ b/test/Transforms/SimplifyCFG/2002-06-24-PHINode.ll
@@ -1,14 +1,14 @@
 ; -simplifycfg is not folding blocks if there is a PHI node involved.  This 
 ; should be fixed eventually
 
-; 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 %main(int %argc) {
-        br label %InlinedFunctionReturnNode
-
-InlinedFunctionReturnNode:                                      ;[#uses=1]
-        %X = phi int [ 7, %0 ]          ; <int> [#uses=1]
-        %Y = add int %X, %argc          ; <int> [#uses=1]
-        ret int %Y
+define i32 @main(i32 %argc) {
+; <label>:0
+	br label %InlinedFunctionReturnNode
+InlinedFunctionReturnNode:		; preds = %0
+	%X = phi i32 [ 7, %0 ]		; <i32> [#uses=1]
+	%Y = add i32 %X, %argc		; <i32> [#uses=1]
+	ret i32 %Y
 }
 
diff --git a/test/Transforms/SimplifyCFG/2002-09-24-PHIAssertion.ll b/test/Transforms/SimplifyCFG/2002-09-24-PHIAssertion.ll
index f1674b7..75beb34 100644
--- a/test/Transforms/SimplifyCFG/2002-09-24-PHIAssertion.ll
+++ b/test/Transforms/SimplifyCFG/2002-09-24-PHIAssertion.ll
@@ -1,12 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg
+; RUN: llvm-as < %s | opt -simplifycfg
 
-int %test(int %A, int %B, bool %cond) {
+define i32 @test(i32 %A, i32 %B, i1 %cond) {
 J:
-	%C = add int %A, 12
-	br bool %cond, label %L, label %L
-L:
-	%Q = phi int [%C, %J], [%C, %J]  ; PHI node is obviously redundant
-	%D = add int %C, %B
-	%E = add int %Q, %D
-	ret int %E
+	%C = add i32 %A, 12		; <i32> [#uses=3]
+	br i1 %cond, label %L, label %L
+L:		; preds = %J, %J
+	%Q = phi i32 [ %C, %J ], [ %C, %J ]		; <i32> [#uses=1]
+	%D = add i32 %C, %B		; <i32> [#uses=1]
+	%E = add i32 %Q, %D		; <i32> [#uses=1]
+	ret i32 %E
 }
+
diff --git a/test/Transforms/SimplifyCFG/2003-03-07-DominateProblem.ll b/test/Transforms/SimplifyCFG/2003-03-07-DominateProblem.ll
index 312e514..c45a5c9 100644
--- a/test/Transforms/SimplifyCFG/2003-03-07-DominateProblem.ll
+++ b/test/Transforms/SimplifyCFG/2003-03-07-DominateProblem.ll
@@ -1,22 +1,17 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 
-implementation   ; Functions:
-
-void %test(int* %ldo, bool %c, bool %d) {
+define void @test(i32* %ldo, i1 %c, i1 %d) {
 bb9:
-	br bool %c, label %bb11, label %bb10
-
+	br i1 %c, label %bb11, label %bb10
 bb10:		; preds = %bb9
 	br label %bb11
-
 bb11:		; preds = %bb10, %bb9
-	%reg330 = phi int* [ null, %bb10 ], [ %ldo, %bb9 ]
+	%reg330 = phi i32* [ null, %bb10 ], [ %ldo, %bb9 ]		; <i32*> [#uses=1]
 	br label %bb20
-
-bb20:		; preds = %bb23, %bb25, %bb27, %bb11
-	store int* %reg330, int** null
-	br bool %d, label %bb20, label %done
-
-done:
+bb20:		; preds = %bb20, %bb11
+	store i32* %reg330, i32** null
+	br i1 %d, label %bb20, label %done
+done:		; preds = %bb20
 	ret void
 }
+
diff --git a/test/Transforms/SimplifyCFG/2003-08-05-InvokeCrash.ll b/test/Transforms/SimplifyCFG/2003-08-05-InvokeCrash.ll
index 811fe50..74e7428 100644
--- a/test/Transforms/SimplifyCFG/2003-08-05-InvokeCrash.ll
+++ b/test/Transforms/SimplifyCFG/2003-08-05-InvokeCrash.ll
@@ -1,11 +1,13 @@
 ; Do not remove the invoke!
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 
-int %test() {
-	%A = invoke int %test() to label %Ret except label %Ret2
-Ret:
-	ret int %A
-Ret2:
-	ret int undef
+define i32 @test() {
+	%A = invoke i32 @test( )
+			to label %Ret unwind label %Ret2		; <i32> [#uses=1]
+Ret:		; preds = %0
+	ret i32 %A
+Ret2:		; preds = %0
+	ret i32 undef
 }
+
diff --git a/test/Transforms/SimplifyCFG/2003-08-05-MishandleInvoke.ll b/test/Transforms/SimplifyCFG/2003-08-05-MishandleInvoke.ll
index ff549ad..9f56e07 100644
--- a/test/Transforms/SimplifyCFG/2003-08-05-MishandleInvoke.ll
+++ b/test/Transforms/SimplifyCFG/2003-08-05-MishandleInvoke.ll
@@ -1,10 +1,12 @@
 ; Do not remove the invoke!
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | grep invoke
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | grep invoke
 
-int %test() {
-	invoke int %test() to label %Ret except label %Ret
-Ret:
-	%A = add int 0, 1
-	ret int %A
+define i32 @test() {
+	invoke i32 @test( )
+			to label %Ret unwind label %Ret		; <i32>:1 [#uses=0]
+Ret:		; preds = %0, %0
+	%A = add i32 0, 1		; <i32> [#uses=1]
+	ret i32 %A
 }
+
diff --git a/test/Transforms/SimplifyCFG/2003-08-17-BranchFold.ll b/test/Transforms/SimplifyCFG/2003-08-17-BranchFold.ll
index fcefac1..d1de65c 100644
--- a/test/Transforms/SimplifyCFG/2003-08-17-BranchFold.ll
+++ b/test/Transforms/SimplifyCFG/2003-08-17-BranchFold.ll
@@ -1,21 +1,22 @@
 ; This test checks to make sure that 'br X, Dest, Dest' is folded into 
 ; 'br Dest'
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not grep {br bool %c2}
 
-declare void %noop()
+declare void @noop()
 
-int %test(bool %c1, bool %c2) {
-	call void %noop()
-	br bool %c1, label %A, label %Y
-A:
-	call void %noop()
- 	br bool %c2, label %X, label %X   ; Can be converted to unconditional br
-X:
-	call void %noop()
-	ret int 0
-Y:
-	call void %noop()
+define i32 @test(i1 %c1, i1 %c2) {
+	call void @noop( )
+	br i1 %c1, label %A, label %Y
+A:		; preds = %0
+	call void @noop( )
+	br i1 %c2, label %X, label %X
+X:		; preds = %Y, %A, %A
+	call void @noop( )
+	ret i32 0
+Y:		; preds = %0
+	call void @noop( )
 	br label %X
 }
+
diff --git a/test/Transforms/SimplifyCFG/2003-08-17-BranchFoldOrdering.ll b/test/Transforms/SimplifyCFG/2003-08-17-BranchFoldOrdering.ll
index 08ff290..7564cfa 100644
--- a/test/Transforms/SimplifyCFG/2003-08-17-BranchFoldOrdering.ll
+++ b/test/Transforms/SimplifyCFG/2003-08-17-BranchFoldOrdering.ll
@@ -3,23 +3,24 @@
 ; due to the fact that the SimplifyCFG function does not use 
 ; the ConstantFoldTerminator function.
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not grep {br bool %c2}
 
-declare void %noop()
+declare void @noop()
 
-int %test(bool %c1, bool %c2) {
-	call void %noop()
-	br bool %c1, label %A, label %Y
-A:
-	call void %noop()
- 	br bool %c2, label %Z, label %X   ; Can be converted to unconditional br
-Z:
+define i32 @test(i1 %c1, i1 %c2) {
+	call void @noop( )
+	br i1 %c1, label %A, label %Y
+A:		; preds = %0
+	call void @noop( )
+	br i1 %c2, label %Z, label %X
+Z:		; preds = %A
 	br label %X
-X:
-	call void %noop()
-	ret int 0
-Y:
-	call void %noop()
+X:		; preds = %Y, %Z, %A
+	call void @noop( )
+	ret i32 0
+Y:		; preds = %0
+	call void @noop( )
 	br label %X
 }
+
diff --git a/test/Transforms/SimplifyCFG/2003-08-17-FoldSwitch.ll b/test/Transforms/SimplifyCFG/2003-08-17-FoldSwitch.ll
index ac9ba18..cd22e1e 100644
--- a/test/Transforms/SimplifyCFG/2003-08-17-FoldSwitch.ll
+++ b/test/Transforms/SimplifyCFG/2003-08-17-FoldSwitch.ll
@@ -1,61 +1,80 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not grep switch
 
-int %test1() {   ; Test normal folding
-	switch uint 5, label %Default [
-		uint 0, label %Foo
-		uint 1, label %Bar
-		uint 2, label %Baz
-		uint 5, label %TheDest
-	]
-Default:ret int -1
-Foo:	ret int -2
-Bar:	ret int -3
-Baz: 	ret int -4
-TheDest:ret int 1234
+; Test normal folding
+define i32 @test1() {
+        switch i32 5, label %Default [
+                 i32 0, label %Foo
+                 i32 1, label %Bar
+                 i32 2, label %Baz
+                 i32 5, label %TheDest
+        ]
+Default:                ; preds = %0
+        ret i32 -1
+Foo:            ; preds = %0
+        ret i32 -2
+Bar:            ; preds = %0
+        ret i32 -3
+Baz:            ; preds = %0
+        ret i32 -4
+TheDest:                ; preds = %0
+        ret i32 1234
 }
 
-int %test2() {   ; Test folding to default dest
-	switch uint 3, label %Default [
-		uint 0, label %Foo
-		uint 1, label %Bar
-		uint 2, label %Baz
-		uint 5, label %TheDest
-	]
-Default:ret int 1234
-Foo:	ret int -2
-Bar:	ret int -5
-Baz: 	ret int -6
-TheDest:ret int -8
+; Test folding to default dest
+define i32 @test2() {
+        switch i32 3, label %Default [
+                 i32 0, label %Foo
+                 i32 1, label %Bar
+                 i32 2, label %Baz
+                 i32 5, label %TheDest
+        ]
+Default:                ; preds = %0
+        ret i32 1234
+Foo:            ; preds = %0
+        ret i32 -2
+Bar:            ; preds = %0
+        ret i32 -5
+Baz:            ; preds = %0
+        ret i32 -6
+TheDest:                ; preds = %0
+        ret i32 -8
 }
 
-int %test3(bool %C) {   ; Test folding all to same dest
-	br bool %C, label %Start, label %TheDest
-Start:
-	switch uint 3, label %TheDest [
-		uint 0, label %TheDest
-		uint 1, label %TheDest
-		uint 2, label %TheDest
-		uint 5, label %TheDest
-	]
-TheDest: ret int 1234
+; Test folding all to same dest
+define i32 @test3(i1 %C) {
+        br i1 %C, label %Start, label %TheDest
+Start:          ; preds = %0
+        switch i32 3, label %TheDest [
+                 i32 0, label %TheDest
+                 i32 1, label %TheDest
+                 i32 2, label %TheDest
+                 i32 5, label %TheDest
+        ]
+TheDest:                ; preds = %Start, %Start, %Start, %Start, %Start, %0
+        ret i32 1234
 }
 
-int %test4(uint %C) {   ; Test folding switch -> branch
-	switch uint %C, label %L1 [
-		uint 0, label %L2
-	]
-L1:	ret int 0
-L2:	ret int 1
+; Test folding switch -> branch
+define i32 @test4(i32 %C) {
+        switch i32 %C, label %L1 [
+                 i32 0, label %L2
+        ]
+L1:             ; preds = %0
+        ret i32 0
+L2:             ; preds = %0
+        ret i32 1
 }
 
-int %test5(uint %C) {
-	switch uint %C, label %L1 [   ; Can fold into a cond branch!
-		uint 0, label %L2
-		uint 123, label %L1
-	]
-L1:	ret int 0
-L2:	ret int 1
+; Can fold into a cond branch!
+define i32 @test5(i32 %C) {
+        switch i32 %C, label %L1 [
+                 i32 0, label %L2
+                 i32 123, label %L1
+        ]
+L1:             ; preds = %0, %0
+        ret i32 0
+L2:             ; preds = %0
+        ret i32 1
 }
 
-
diff --git a/test/Transforms/SimplifyCFG/2004-12-10-SimplifyCFGCrash.ll b/test/Transforms/SimplifyCFG/2004-12-10-SimplifyCFGCrash.ll
index 44c89d6..de0d262 100644
--- a/test/Transforms/SimplifyCFG/2004-12-10-SimplifyCFGCrash.ll
+++ b/test/Transforms/SimplifyCFG/2004-12-10-SimplifyCFGCrash.ll
@@ -1,59 +1,40 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 
-implementation   ; Functions:
-
-void %symhash_add() {
+define void @symhash_add() {
 entry:
-	br bool undef, label %then.0, label %UnifiedReturnBlock
-
+	br i1 undef, label %then.0, label %UnifiedReturnBlock
 then.0:		; preds = %entry
-	br bool undef, label %loopentry.2, label %loopentry.1.preheader
-
+	br i1 undef, label %loopentry.2, label %loopentry.1.preheader
 loopentry.1.preheader:		; preds = %then.0
 	br label %loopentry.1.outer
-
-loopentry.1.outer:		; preds = %loopentry.1.preheader, %loopexit.1
+loopentry.1.outer:		; preds = %loopexit.1, %loopentry.1.preheader
 	br label %loopentry.1
-
-loopentry.1:		; preds = %loopentry.1.outer, %then.1, %then.3, %then.4, %endif.1
-	br bool undef, label %loopexit.1, label %no_exit.1
-
+loopentry.1:		; preds = %endif.1, %then.4, %then.3, %then.1, %loopentry.1.outer
+	br i1 undef, label %loopexit.1, label %no_exit.1
 no_exit.1:		; preds = %loopentry.1
-	br bool undef, label %then.1, label %else.0
-
+	br i1 undef, label %then.1, label %else.0
 then.1:		; preds = %no_exit.1
 	br label %loopentry.1
-
 else.0:		; preds = %no_exit.1
-	br bool undef, label %then.2, label %else.1
-
+	br i1 undef, label %then.2, label %else.1
 then.2:		; preds = %else.0
-	br bool undef, label %then.3, label %endif.1
-
+	br i1 undef, label %then.3, label %endif.1
 then.3:		; preds = %then.2
 	br label %loopentry.1
-
 else.1:		; preds = %else.0
-	br bool undef, label %endif.1, label %then.4
-
+	br i1 undef, label %endif.1, label %then.4
 then.4:		; preds = %else.1
 	br label %loopentry.1
-
-endif.1:		; preds = %then.2, %else.1
+endif.1:		; preds = %else.1, %then.2
 	br label %loopentry.1
-
 loopexit.1:		; preds = %loopentry.1
-	br bool undef, label %loopentry.1.outer, label %loopentry.2
-
-loopentry.2:		; preds = %then.0, %loopexit.1, %no_exit.2
-	br bool undef, label %loopexit.2, label %no_exit.2
-
+	br i1 undef, label %loopentry.1.outer, label %loopentry.2
+loopentry.2:		; preds = %no_exit.2, %loopexit.1, %then.0
+	br i1 undef, label %loopexit.2, label %no_exit.2
 no_exit.2:		; preds = %loopentry.2
 	br label %loopentry.2
-
 loopexit.2:		; preds = %loopentry.2
 	ret void
-
 UnifiedReturnBlock:		; preds = %entry
 	ret void
 }
diff --git a/test/Transforms/SimplifyCFG/2005-06-16-PHICrash.ll b/test/Transforms/SimplifyCFG/2005-06-16-PHICrash.ll
index 6c53029..7fea292 100644
--- a/test/Transforms/SimplifyCFG/2005-06-16-PHICrash.ll
+++ b/test/Transforms/SimplifyCFG/2005-06-16-PHICrash.ll
@@ -1,125 +1,95 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 ; PR584
+@g_38098584 = external global i32		; <i32*> [#uses=1]
+@g_60187400 = external global i32		; <i32*> [#uses=1]
+@g_59182229 = external global i32		; <i32*> [#uses=2]
 
-%g_38098584 = external global uint		; <uint*> [#uses=1]
-%g_60187400 = external global uint		; <uint*> [#uses=1]
-%g_59182229 = external global uint		; <uint*> [#uses=2]
-
-implementation   ; Functions:
-
-int %_Z13func_26556482h(ubyte %l_88173906) {
+define i32 @_Z13func_26556482h(i8 %l_88173906) {
 entry:
-	%tmp.1 = cast ubyte %l_88173906 to sbyte		; <sbyte> [#uses=2]
-	%tmp.3 = seteq ubyte %l_88173906, 0		; <bool> [#uses=1]
-	br bool %tmp.3, label %else.0, label %then.0
-
+	%tmp.1 = bitcast i8 %l_88173906 to i8		; <i8> [#uses=2]
+	%tmp.3 = icmp eq i8 %l_88173906, 0		; <i1> [#uses=1]
+	br i1 %tmp.3, label %else.0, label %then.0
 then.0:		; preds = %entry
-	%tmp.5 = seteq ubyte %l_88173906, 0		; <bool> [#uses=1]
-	br bool %tmp.5, label %else.1, label %then.1
-
+	%tmp.5 = icmp eq i8 %l_88173906, 0		; <i1> [#uses=1]
+	br i1 %tmp.5, label %else.1, label %then.1
 then.1:		; preds = %then.0
 	br label %return
-
 else.1:		; preds = %then.0
 	br label %loopentry.0
-
 loopentry.0:		; preds = %no_exit.0, %else.1
-	%i.0.1 = phi int [ 0, %else.1 ], [ %inc.0, %no_exit.0 ]		; <int> [#uses=2]
-	%tmp.9 = setgt int %i.0.1, 99		; <bool> [#uses=1]
-	br bool %tmp.9, label %endif.0, label %no_exit.0
-
+	%i.0.1 = phi i32 [ 0, %else.1 ], [ %inc.0, %no_exit.0 ]		; <i32> [#uses=2]
+	%tmp.9 = icmp sgt i32 %i.0.1, 99		; <i1> [#uses=1]
+	br i1 %tmp.9, label %endif.0, label %no_exit.0
 no_exit.0:		; preds = %loopentry.0
-	%inc.0 = add int %i.0.1, 1		; <int> [#uses=1]
+	%inc.0 = add i32 %i.0.1, 1		; <i32> [#uses=1]
 	br label %loopentry.0
-
 else.0:		; preds = %entry
-	%tmp.12 = cast sbyte %tmp.1 to int		; <int> [#uses=1]
+	%tmp.12 = sext i8 %tmp.1 to i32		; <i32> [#uses=1]
 	br label %return
-
 endif.0:		; preds = %loopentry.0
-	%tmp.14 = cast sbyte %tmp.1 to int		; <int> [#uses=1]
-	%tmp.16 = cast ubyte %l_88173906 to int		; <int> [#uses=1]
-	%tmp.17 = setgt int %tmp.14, %tmp.16		; <bool> [#uses=1]
-	%tmp.19 = load uint* %g_59182229		; <uint> [#uses=2]
-	br bool %tmp.17, label %cond_true, label %cond_false
-
+	%tmp.14 = sext i8 %tmp.1 to i32		; <i32> [#uses=1]
+	%tmp.16 = zext i8 %l_88173906 to i32		; <i32> [#uses=1]
+	%tmp.17 = icmp sgt i32 %tmp.14, %tmp.16		; <i1> [#uses=1]
+	%tmp.19 = load i32* @g_59182229		; <i32> [#uses=2]
+	br i1 %tmp.17, label %cond_true, label %cond_false
 cond_true:		; preds = %endif.0
-	%tmp.20 = setne uint %tmp.19, 1		; <bool> [#uses=1]
+	%tmp.20 = icmp ne i32 %tmp.19, 1		; <i1> [#uses=1]
 	br label %cond_continue
-
 cond_false:		; preds = %endif.0
-	%tmp.22 = setne uint %tmp.19, 0		; <bool> [#uses=1]
+	%tmp.22 = icmp ne i32 %tmp.19, 0		; <i1> [#uses=1]
 	br label %cond_continue
-
 cond_continue:		; preds = %cond_false, %cond_true
-	%mem_tmp.0 = phi bool [ %tmp.20, %cond_true ], [ %tmp.22, %cond_false ]		; <bool> [#uses=1]
-	br bool %mem_tmp.0, label %then.2, label %else.2
-
+	%mem_tmp.0 = phi i1 [ %tmp.20, %cond_true ], [ %tmp.22, %cond_false ]		; <i1> [#uses=1]
+	br i1 %mem_tmp.0, label %then.2, label %else.2
 then.2:		; preds = %cond_continue
-	%tmp.25 = cast ubyte %l_88173906 to int		; <int> [#uses=1]
+	%tmp.25 = zext i8 %l_88173906 to i32		; <i32> [#uses=1]
 	br label %return
-
 else.2:		; preds = %cond_continue
 	br label %loopentry.1
-
 loopentry.1:		; preds = %endif.3, %else.2
-	%i.1.1 = phi int [ 0, %else.2 ], [ %inc.3, %endif.3 ]		; <int> [#uses=2]
-	%i.3.2 = phi int [ undef, %else.2 ], [ %i.3.0, %endif.3 ]		; <int> [#uses=2]
-	%l_88173906_addr.1 = phi ubyte [ %l_88173906, %else.2 ], [ %l_88173906_addr.0, %endif.3 ]		; <ubyte> [#uses=3]
-	%tmp.29 = setgt int %i.1.1, 99		; <bool> [#uses=1]
-	br bool %tmp.29, label %endif.2, label %no_exit.1
-
+	%i.1.1 = phi i32 [ 0, %else.2 ], [ %inc.3, %endif.3 ]		; <i32> [#uses=2]
+	%i.3.2 = phi i32 [ undef, %else.2 ], [ %i.3.0, %endif.3 ]		; <i32> [#uses=2]
+	%l_88173906_addr.1 = phi i8 [ %l_88173906, %else.2 ], [ %l_88173906_addr.0, %endif.3 ]		; <i8> [#uses=3]
+	%tmp.29 = icmp sgt i32 %i.1.1, 99		; <i1> [#uses=1]
+	br i1 %tmp.29, label %endif.2, label %no_exit.1
 no_exit.1:		; preds = %loopentry.1
-	%tmp.30 = load uint* %g_38098584		; <uint> [#uses=1]
-	%tmp.31 = seteq uint %tmp.30, 0		; <bool> [#uses=1]
-	br bool %tmp.31, label %else.3, label %then.3
-
+	%tmp.30 = load i32* @g_38098584		; <i32> [#uses=1]
+	%tmp.31 = icmp eq i32 %tmp.30, 0		; <i1> [#uses=1]
+	br i1 %tmp.31, label %else.3, label %then.3
 then.3:		; preds = %no_exit.1
 	br label %endif.3
-
 else.3:		; preds = %no_exit.1
-	br bool false, label %else.4, label %then.4
-
+	br i1 false, label %else.4, label %then.4
 then.4:		; preds = %else.3
 	br label %endif.3
-
 else.4:		; preds = %else.3
-	br bool false, label %else.5, label %then.5
-
+	br i1 false, label %else.5, label %then.5
 then.5:		; preds = %else.4
-	store uint 3290648471, uint* %g_59182229
+	store i32 -1004318825, i32* @g_59182229
 	br label %return
-
 else.5:		; preds = %else.4
 	br label %loopentry.3
-
 loopentry.3:		; preds = %then.7, %else.5
-	%i.3.3 = phi int [ 0, %else.5 ], [ %inc.2, %then.7 ]		; <int> [#uses=3]
-	%tmp.55 = setgt int %i.3.3, 99		; <bool> [#uses=1]
-	br bool %tmp.55, label %endif.3, label %no_exit.3
-
+	%i.3.3 = phi i32 [ 0, %else.5 ], [ %inc.2, %then.7 ]		; <i32> [#uses=3]
+	%tmp.55 = icmp sgt i32 %i.3.3, 99		; <i1> [#uses=1]
+	br i1 %tmp.55, label %endif.3, label %no_exit.3
 no_exit.3:		; preds = %loopentry.3
-	%tmp.57 = seteq ubyte %l_88173906_addr.1, 0		; <bool> [#uses=1]
-	br bool %tmp.57, label %else.7, label %then.7
-
+	%tmp.57 = icmp eq i8 %l_88173906_addr.1, 0		; <i1> [#uses=1]
+	br i1 %tmp.57, label %else.7, label %then.7
 then.7:		; preds = %no_exit.3
-	store uint 16239, uint* %g_60187400
-	%inc.2 = add int %i.3.3, 1		; <int> [#uses=1]
+	store i32 16239, i32* @g_60187400
+	%inc.2 = add i32 %i.3.3, 1		; <i32> [#uses=1]
 	br label %loopentry.3
-
 else.7:		; preds = %no_exit.3
 	br label %return
-
 endif.3:		; preds = %loopentry.3, %then.4, %then.3
-	%i.3.0 = phi int [ %i.3.2, %then.3 ], [ %i.3.2, %then.4 ], [ %i.3.3, %loopentry.3 ]		; <int> [#uses=1]
-	%l_88173906_addr.0 = phi ubyte [ 100, %then.3 ], [ %l_88173906_addr.1, %then.4 ], [ %l_88173906_addr.1, %loopentry.3 ]		; <ubyte> [#uses=1]
-	%inc.3 = add int %i.1.1, 1		; <int> [#uses=1]
+	%i.3.0 = phi i32 [ %i.3.2, %then.3 ], [ %i.3.2, %then.4 ], [ %i.3.3, %loopentry.3 ]		; <i32> [#uses=1]
+	%l_88173906_addr.0 = phi i8 [ 100, %then.3 ], [ %l_88173906_addr.1, %then.4 ], [ %l_88173906_addr.1, %loopentry.3 ]		; <i8> [#uses=1]
+	%inc.3 = add i32 %i.1.1, 1		; <i32> [#uses=1]
 	br label %loopentry.1
-
 endif.2:		; preds = %loopentry.1
 	br label %return
-
 return:		; preds = %endif.2, %else.7, %then.5, %then.2, %else.0, %then.1
-	%result.0 = phi int [ 1624650671, %then.1 ], [ %tmp.25, %then.2 ], [ 3379, %then.5 ], [ 52410, %else.7 ], [ -1526438411, %endif.2 ], [ %tmp.12, %else.0 ]		; <int> [#uses=1]
-	ret int %result.0
+	%result.0 = phi i32 [ 1624650671, %then.1 ], [ %tmp.25, %then.2 ], [ 3379, %then.5 ], [ 52410, %else.7 ], [ -1526438411, %endif.2 ], [ %tmp.12, %else.0 ]		; <i32> [#uses=1]
+	ret i32 %result.0
 }
diff --git a/test/Transforms/SimplifyCFG/2005-08-01-PHIUpdateFail.ll b/test/Transforms/SimplifyCFG/2005-08-01-PHIUpdateFail.ll
index 9271ac2..8314321 100644
--- a/test/Transforms/SimplifyCFG/2005-08-01-PHIUpdateFail.ll
+++ b/test/Transforms/SimplifyCFG/2005-08-01-PHIUpdateFail.ll
@@ -1,96 +1,71 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
+; END.
 
-void %main() {
+define void @main() {
 entry:
-	%tmp.14.i19 = seteq int 0, 2		; <bool> [#uses=1]
-	br bool %tmp.14.i19, label %endif.1.i20, label %read_min.exit
-
+	%tmp.14.i19 = icmp eq i32 0, 2		; <i1> [#uses=1]
+	br i1 %tmp.14.i19, label %endif.1.i20, label %read_min.exit
 endif.1.i20:		; preds = %entry
-	%tmp.9.i.i = seteq sbyte* null, null		; <bool> [#uses=1]
-	br bool %tmp.9.i.i, label %then.i12.i, label %then.i.i
-
+	%tmp.9.i.i = icmp eq i8* null, null		; <i1> [#uses=1]
+	br i1 %tmp.9.i.i, label %then.i12.i, label %then.i.i
 then.i.i:		; preds = %endif.1.i20
 	ret void
-
 then.i12.i:		; preds = %endif.1.i20
-	%tmp.9.i4.i = seteq sbyte* null, null		; <bool> [#uses=1]
-	br bool %tmp.9.i4.i, label %endif.2.i33, label %then.i5.i
-
+	%tmp.9.i4.i = icmp eq i8* null, null		; <i1> [#uses=1]
+	br i1 %tmp.9.i4.i, label %endif.2.i33, label %then.i5.i
 then.i5.i:		; preds = %then.i12.i
 	ret void
-
 endif.2.i33:		; preds = %then.i12.i
-	br bool false, label %loopexit.0.i40, label %no_exit.0.i35
-
+	br i1 false, label %loopexit.0.i40, label %no_exit.0.i35
 no_exit.0.i35:		; preds = %no_exit.0.i35, %endif.2.i33
-	%tmp.130.i = setlt int 0, 0		; <bool> [#uses=1]
-	br bool %tmp.130.i, label %loopexit.0.i40.loopexit, label %no_exit.0.i35
-
+	%tmp.130.i = icmp slt i32 0, 0		; <i1> [#uses=1]
+	br i1 %tmp.130.i, label %loopexit.0.i40.loopexit, label %no_exit.0.i35
 loopexit.0.i40.loopexit:		; preds = %no_exit.0.i35
 	br label %loopexit.0.i40
-
 loopexit.0.i40:		; preds = %loopexit.0.i40.loopexit, %endif.2.i33
-	%tmp.341.i = seteq int 0, 0		; <bool> [#uses=1]
-	br bool %tmp.341.i, label %loopentry.1.i, label %read_min.exit
-
+	%tmp.341.i = icmp eq i32 0, 0		; <i1> [#uses=1]
+	br i1 %tmp.341.i, label %loopentry.1.i, label %read_min.exit
 loopentry.1.i:		; preds = %loopexit.0.i40
-	%tmp.347.i = setgt int 0, 0		; <bool> [#uses=1]
-	br bool %tmp.347.i, label %no_exit.1.i41, label %loopexit.2.i44
-
+	%tmp.347.i = icmp sgt i32 0, 0		; <i1> [#uses=1]
+	br i1 %tmp.347.i, label %no_exit.1.i41, label %loopexit.2.i44
 no_exit.1.i41:		; preds = %endif.5.i, %loopentry.1.i
-	%indvar.i42 = phi uint [ %indvar.next.i, %endif.5.i ], [ 0, %loopentry.1.i ]		; <uint> [#uses=1]
-	%tmp.355.i = seteq int 0, 3		; <bool> [#uses=1]
-	br bool %tmp.355.i, label %endif.5.i, label %read_min.exit
-
+	%indvar.i42 = phi i32 [ %indvar.next.i, %endif.5.i ], [ 0, %loopentry.1.i ]		; <i32> [#uses=1]
+	%tmp.355.i = icmp eq i32 0, 3		; <i1> [#uses=1]
+	br i1 %tmp.355.i, label %endif.5.i, label %read_min.exit
 endif.5.i:		; preds = %no_exit.1.i41
-	%tmp.34773.i = setgt int 0, 0		; <bool> [#uses=1]
-	%indvar.next.i = add uint %indvar.i42, 1		; <uint> [#uses=1]
-	br bool %tmp.34773.i, label %no_exit.1.i41, label %loopexit.1.i.loopexit
-
+	%tmp.34773.i = icmp sgt i32 0, 0		; <i1> [#uses=1]
+	%indvar.next.i = add i32 %indvar.i42, 1		; <i32> [#uses=1]
+	br i1 %tmp.34773.i, label %no_exit.1.i41, label %loopexit.1.i.loopexit
 loopexit.1.i.loopexit:		; preds = %endif.5.i
 	ret void
-
 loopexit.2.i44:		; preds = %loopentry.1.i
 	ret void
-
 read_min.exit:		; preds = %no_exit.1.i41, %loopexit.0.i40, %entry
-	%tmp.23 = seteq int 0, 0		; <bool> [#uses=1]
-	br bool %tmp.23, label %endif.1, label %then.1
-
+	%tmp.23 = icmp eq i32 0, 0		; <i1> [#uses=1]
+	br i1 %tmp.23, label %endif.1, label %then.1
 then.1:		; preds = %read_min.exit
-	br bool false, label %endif.0.i, label %then.0.i
-
+	br i1 false, label %endif.0.i, label %then.0.i
 then.0.i:		; preds = %then.1
-	br bool false, label %endif.1.i, label %then.1.i
-
+	br i1 false, label %endif.1.i, label %then.1.i
 endif.0.i:		; preds = %then.1
-	br bool false, label %endif.1.i, label %then.1.i
-
+	br i1 false, label %endif.1.i, label %then.1.i
 then.1.i:		; preds = %endif.0.i, %then.0.i
-	br bool false, label %getfree.exit, label %then.2.i
-
+	br i1 false, label %getfree.exit, label %then.2.i
 endif.1.i:		; preds = %endif.0.i, %then.0.i
-	br bool false, label %getfree.exit, label %then.2.i
-
+	br i1 false, label %getfree.exit, label %then.2.i
 then.2.i:		; preds = %endif.1.i, %then.1.i
 	ret void
-
 getfree.exit:		; preds = %endif.1.i, %then.1.i
 	ret void
-
 endif.1:		; preds = %read_min.exit
-	%tmp.27.i = getelementptr int* null, int 0
-	br bool false, label %loopexit.0.i15, label %no_exit.0.i14
-
+	%tmp.27.i = getelementptr i32* null, i32 0		; <i32*> [#uses=0]
+	br i1 false, label %loopexit.0.i15, label %no_exit.0.i14
 no_exit.0.i14:		; preds = %endif.1
 	ret void
-
 loopexit.0.i15:		; preds = %endif.1
-	br bool false, label %primal_start_artificial.exit, label %no_exit.1.i16
-
+	br i1 false, label %primal_start_artificial.exit, label %no_exit.1.i16
 no_exit.1.i16:		; preds = %no_exit.1.i16, %loopexit.0.i15
-	br bool false, label %primal_start_artificial.exit, label %no_exit.1.i16
-
+	br i1 false, label %primal_start_artificial.exit, label %no_exit.1.i16
 primal_start_artificial.exit:		; preds = %no_exit.1.i16, %loopexit.0.i15
 	ret void
 }
diff --git a/test/Transforms/SimplifyCFG/2005-08-03-PHIFactorCrash.ll b/test/Transforms/SimplifyCFG/2005-08-03-PHIFactorCrash.ll
index 4ac692e..51490a0 100644
--- a/test/Transforms/SimplifyCFG/2005-08-03-PHIFactorCrash.ll
+++ b/test/Transforms/SimplifyCFG/2005-08-03-PHIFactorCrash.ll
@@ -1,94 +1,74 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 ; END.
 
-	%arraytype.1.Char = type { int, [0 x sbyte] }
-	%arraytype.4.Signed = type { int, [0 x int] }
+	%arraytype.1.Char = type { i32, [0 x i8] }
+	%arraytype.4.Signed = type { i32, [0 x i32] }
 	%functiontype.23 = type %structtype.Task* (%structtype.Task*, %structtype.Packet*, %structtype.FailedRun*)
 	%functiontype.27 = type %structtype.object* ()
-	%functiontype.28 = type bool (%structtype.object*, %structtype.object_vtable*)
-	%functiontype.39 = type int (%structtype.listiter*)
-	%opaquetype.RuntimeTypeInfo = type sbyte* (sbyte*)
+	%functiontype.28 = type i1 (%structtype.object*, %structtype.object_vtable*)
+	%functiontype.39 = type i32 (%structtype.listiter*)
+	%opaquetype.RuntimeTypeInfo = type i8* (i8*)
 	%structtype.AssertionError_vtable = type { %structtype.FailedRun_vtable }
 	%structtype.DeviceTask = type { %structtype.Task }
 	%structtype.FailedRun = type { %structtype.object }
 	%structtype.FailedRun_vtable = type { %structtype.object_vtable }
-	%structtype.Packet = type { %structtype.object, %structtype.list.1*, int, int, int, %structtype.Packet* }
-	%structtype.Task = type { %structtype.TaskState, %structtype.FailedRun*, int, %structtype.Packet*, %structtype.Task*, int }
-	%structtype.TaskState = type { %structtype.object, bool, bool, bool }
+	%structtype.Packet = type { %structtype.object, %structtype.list.1*, i32, i32, i32, %structtype.Packet* }
+	%structtype.Task = type { %structtype.TaskState, %structtype.FailedRun*, i32, %structtype.Packet*, %structtype.Task*, i32 }
+	%structtype.TaskState = type { %structtype.object, i1, i1, i1 }
 	%structtype.list.1 = type { %arraytype.4.Signed* }
-	%structtype.listiter = type { %structtype.list.1*, int }
+	%structtype.listiter = type { %structtype.list.1*, i32 }
 	%structtype.object = type { %structtype.object_vtable* }
 	%structtype.object_vtable = type { %structtype.object_vtable*, %opaquetype.RuntimeTypeInfo*, %arraytype.1.Char*, %functiontype.27* }
-%structinstance.59 = external global %structtype.AssertionError_vtable		; <%structtype.AssertionError_vtable*> [#uses=0]
+@structinstance.59 = external global %structtype.AssertionError_vtable		; <%structtype.AssertionError_vtable*> [#uses=0]
 
-implementation   ; Functions:
+declare fastcc i1 @ll_isinstance__objectPtr_object_vtablePtr()
 
-declare fastcc bool %ll_isinstance__objectPtr_object_vtablePtr()
+declare fastcc void @ll_listnext__listiterPtr()
 
-declare fastcc void %ll_listnext__listiterPtr()
-
-fastcc void %WorkTask.fn() {
+define fastcc void @WorkTask.fn() {
 block0:
 	br label %block1
-
 block1:		; preds = %block0
-	%v2542 = call fastcc bool %ll_isinstance__objectPtr_object_vtablePtr( )		; <bool> [#uses=1]
-	br bool %v2542, label %block4, label %block2
-
+	%v2542 = call fastcc i1 @ll_isinstance__objectPtr_object_vtablePtr( )		; <i1> [#uses=1]
+	br i1 %v2542, label %block4, label %block2
 block2:		; preds = %block1
 	br label %block3
-
 block3:		; preds = %block2
 	unwind
-
 block4:		; preds = %block1
 	br label %block5
-
 block5:		; preds = %block4
-	%v2565 = seteq %structtype.Packet* null, null		; <bool> [#uses=1]
-	br bool %v2565, label %block15, label %block6
-
+	%v2565 = icmp eq %structtype.Packet* null, null		; <i1> [#uses=1]
+	br i1 %v2565, label %block15, label %block6
 block6:		; preds = %block5
 	%self_2575 = phi %structtype.DeviceTask* [ null, %block5 ]		; <%structtype.DeviceTask*> [#uses=1]
-	br bool false, label %block14, label %block7
-
+	br i1 false, label %block14, label %block7
 block7:		; preds = %block14, %block6
 	%self_2635 = phi %structtype.DeviceTask* [ %self_2575, %block6 ], [ null, %block14 ]		; <%structtype.DeviceTask*> [#uses=1]
-	%tmp.124 = getelementptr %structtype.Packet* null, int 0, uint 2		; <int*> [#uses=0]
+	%tmp.124 = getelementptr %structtype.Packet* null, i32 0, i32 2		; <i32*> [#uses=0]
 	br label %block8
-
 block8:		; preds = %block10, %block7
 	%self_2672 = phi %structtype.DeviceTask* [ %self_2635, %block7 ], [ null, %block10 ]		; <%structtype.DeviceTask*> [#uses=0]
-	invoke fastcc void %ll_listnext__listiterPtr( )
+	invoke fastcc void @ll_listnext__listiterPtr( )
 			to label %block9 unwind label %block8_exception_handling
-
 block8_exception_handling:		; preds = %block8
-	br bool false, label %block8_exception_found_branchto_block12, label %block8_not_exception_structinstance.10
-
+	br i1 false, label %block8_exception_found_branchto_block12, label %block8_not_exception_structinstance.10
 block8_not_exception_structinstance.10:		; preds = %block8_exception_handling
 	unwind
-
 block8_exception_found_branchto_block12:		; preds = %block8_exception_handling
 	br label %block12
-
 block9:		; preds = %block8
-	br bool false, label %block11, label %block10
-
+	br i1 false, label %block11, label %block10
 block10:		; preds = %block11, %block9
 	br label %block8
-
 block11:		; preds = %block9
 	br label %block10
-
 block12:		; preds = %block8_exception_found_branchto_block12
 	br label %block13
-
 block13:		; preds = %block15, %block12
 	ret void
-
 block14:		; preds = %block6
 	br label %block7
-
 block15:		; preds = %block5
 	%v2586 = phi %structtype.DeviceTask* [ null, %block5 ]		; <%structtype.DeviceTask*> [#uses=0]
 	br label %block13
diff --git a/test/Transforms/SimplifyCFG/2005-10-02-InvokeSimplify.ll b/test/Transforms/SimplifyCFG/2005-10-02-InvokeSimplify.ll
index c3b4194..a0fe781 100644
--- a/test/Transforms/SimplifyCFG/2005-10-02-InvokeSimplify.ll
+++ b/test/Transforms/SimplifyCFG/2005-10-02-InvokeSimplify.ll
@@ -1,13 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 
-bool %foo() {
-	%X = invoke bool %foo() to label %N unwind label %F
-F:
-	ret bool false
-N:
-	br bool %X, label %A, label %B
-A:
-	ret bool true
-B:
-	ret bool true
+define i1 @foo() {
+	%X = invoke i1 @foo( )
+			to label %N unwind label %F		; <i1> [#uses=1]
+F:		; preds = %0
+	ret i1 false
+N:		; preds = %0
+	br i1 %X, label %A, label %B
+A:		; preds = %N
+	ret i1 true
+B:		; preds = %N
+	ret i1 true
 }
+
diff --git a/test/Transforms/SimplifyCFG/2005-12-03-IncorrectPHIFold.ll b/test/Transforms/SimplifyCFG/2005-12-03-IncorrectPHIFold.ll
index ca69970..27413fc 100644
--- a/test/Transforms/SimplifyCFG/2005-12-03-IncorrectPHIFold.ll
+++ b/test/Transforms/SimplifyCFG/2005-12-03-IncorrectPHIFold.ll
@@ -1,140 +1,124 @@
 ; Make sure this doesn't turn into an infinite loop
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -constprop -simplifycfg |\
+; RUN: llvm-as < %s | opt -simplifycfg -constprop -simplifycfg |\
 ; RUN:   llvm-dis | grep bb86
 ; END.
+	
+%struct.anon = type { i32, i32, i32, i32, [1024 x i8] }
+@_zero_ = external global %struct.anon*		; <%struct.anon**> [#uses=2]
+@_one_ = external global %struct.anon*		; <%struct.anon**> [#uses=4]
+@str = internal constant [4 x i8] c"%d\0A\00"		; <[4 x i8]*> [#uses=0]
 
-	%struct.anon = type { uint, int, int, int, [1024 x sbyte] }
-%_zero_ = external global %struct.anon*		; <%struct.anon**> [#uses=2]
-%_one_ = external global %struct.anon*		; <%struct.anon**> [#uses=4]
-%str = internal constant [4 x sbyte] c"%d\0A\00"		; <[4 x sbyte]*> [#uses=1]
+declare i32 @bc_compare(%struct.anon*, %struct.anon*)
 
-implementation   ; Functions:
+declare void @free_num(%struct.anon**)
 
+declare %struct.anon* @copy_num(%struct.anon*)
 
-declare int %bc_compare(%struct.anon*, %struct.anon*)
+declare void @init_num(%struct.anon**)
 
-declare void %free_num(%struct.anon**)
+declare %struct.anon* @new_num(i32, i32)
 
-declare %struct.anon* %copy_num(%struct.anon*)
+declare void @int2num(%struct.anon**, i32)
 
-declare void %init_num(%struct.anon**)
+declare void @bc_multiply(%struct.anon*, %struct.anon*, %struct.anon**, i32)
 
-declare %struct.anon* %new_num(int, int)
+declare void @bc_raise(%struct.anon*, %struct.anon*, %struct.anon**, i32)
 
-declare void %int2num(%struct.anon**, int)
+declare i32 @bc_divide(%struct.anon*, %struct.anon*, %struct.anon**, i32)
 
-declare void %bc_multiply(%struct.anon*, %struct.anon*, %struct.anon**, int)
+declare void @bc_add(%struct.anon*, %struct.anon*, %struct.anon**)
 
-declare void %bc_raise(%struct.anon*, %struct.anon*, %struct.anon**, int)
+declare i32 @_do_compare(%struct.anon*, %struct.anon*, i32, i32)
 
-declare int %bc_divide(%struct.anon*, %struct.anon*, %struct.anon**, int)
+declare i32 @printf(i8*, ...)
 
-declare void %bc_add(%struct.anon*, %struct.anon*, %struct.anon**)
-
-declare int %_do_compare(%struct.anon*, %struct.anon*, int, int)
-
-declare int %printf(sbyte*, ...)
-
-int %bc_sqrt(%struct.anon** %num, int %scale) {
+define i32 @bc_sqrt(%struct.anon** %num, i32 %scale) {
 entry:
-	%guess = alloca %struct.anon*		; <%struct.anon**> [#uses=15]
-	%guess1 = alloca %struct.anon*		; <%struct.anon**> [#uses=12]
-	%point5 = alloca %struct.anon*		; <%struct.anon**> [#uses=4]
+	%guess = alloca %struct.anon*		; <%struct.anon**> [#uses=7]
+	%guess1 = alloca %struct.anon*		; <%struct.anon**> [#uses=7]
+	%point5 = alloca %struct.anon*		; <%struct.anon**> [#uses=3]
 	%tmp = load %struct.anon** %num		; <%struct.anon*> [#uses=1]
-	%tmp1 = load %struct.anon** %_zero_		; <%struct.anon*> [#uses=1]
-	%tmp = call int %bc_compare( %struct.anon* %tmp, %struct.anon* %tmp1 )		; <int> [#uses=2]
-	%tmp = setlt int %tmp, 0		; <bool> [#uses=1]
-	br bool %tmp, label %cond_true, label %cond_false
-
+	%tmp1 = load %struct.anon** @_zero_		; <%struct.anon*> [#uses=1]
+	%tmp.upgrd.1 = call i32 @bc_compare( %struct.anon* %tmp, %struct.anon* %tmp1 )		; <i32> [#uses=2]
+	%tmp.upgrd.2 = icmp slt i32 %tmp.upgrd.1, 0		; <i1> [#uses=1]
+	br i1 %tmp.upgrd.2, label %cond_true, label %cond_false
 cond_true:		; preds = %entry
-	ret int 0
-
+	ret i32 0
 cond_false:		; preds = %entry
-	%tmp5 = seteq int %tmp, 0		; <bool> [#uses=1]
-	br bool %tmp5, label %cond_true6, label %cond_next13
-
+	%tmp5 = icmp eq i32 %tmp.upgrd.1, 0		; <i1> [#uses=1]
+	br i1 %tmp5, label %cond_true6, label %cond_next13
 cond_true6:		; preds = %cond_false
-	call void %free_num( %struct.anon** %num )
-	%tmp8 = load %struct.anon** %_zero_		; <%struct.anon*> [#uses=1]
-	%tmp9 = call %struct.anon* %copy_num( %struct.anon* %tmp8 )		; <%struct.anon*> [#uses=1]
+	call void @free_num( %struct.anon** %num )
+	%tmp8 = load %struct.anon** @_zero_		; <%struct.anon*> [#uses=1]
+	%tmp9 = call %struct.anon* @copy_num( %struct.anon* %tmp8 )		; <%struct.anon*> [#uses=1]
 	store %struct.anon* %tmp9, %struct.anon** %num
-	ret int 1
-
+	ret i32 1
 cond_next13:		; preds = %cond_false
 	%tmp15 = load %struct.anon** %num		; <%struct.anon*> [#uses=1]
-	%tmp16 = load %struct.anon** %_one_		; <%struct.anon*> [#uses=1]
-	%tmp17 = call int %bc_compare( %struct.anon* %tmp15, %struct.anon* %tmp16 )		; <int> [#uses=2]
-	%tmp19 = seteq int %tmp17, 0		; <bool> [#uses=1]
-	br bool %tmp19, label %cond_true20, label %cond_next27
-
+	%tmp16 = load %struct.anon** @_one_		; <%struct.anon*> [#uses=1]
+	%tmp17 = call i32 @bc_compare( %struct.anon* %tmp15, %struct.anon* %tmp16 )		; <i32> [#uses=2]
+	%tmp19 = icmp eq i32 %tmp17, 0		; <i1> [#uses=1]
+	br i1 %tmp19, label %cond_true20, label %cond_next27
 cond_true20:		; preds = %cond_next13
-	call void %free_num( %struct.anon** %num )
-	%tmp22 = load %struct.anon** %_one_		; <%struct.anon*> [#uses=1]
-	%tmp23 = call %struct.anon* %copy_num( %struct.anon* %tmp22 )		; <%struct.anon*> [#uses=1]
+	call void @free_num( %struct.anon** %num )
+	%tmp22 = load %struct.anon** @_one_		; <%struct.anon*> [#uses=1]
+	%tmp23 = call %struct.anon* @copy_num( %struct.anon* %tmp22 )		; <%struct.anon*> [#uses=1]
 	store %struct.anon* %tmp23, %struct.anon** %num
-	ret int 1
-
+	ret i32 1
 cond_next27:		; preds = %cond_next13
 	%tmp29 = load %struct.anon** %num		; <%struct.anon*> [#uses=1]
-	%tmp30 = getelementptr %struct.anon* %tmp29, int 0, uint 2		; <int*> [#uses=1]
-	%tmp31 = load int* %tmp30		; <int> [#uses=2]
-	%tmp33 = setge int %tmp31, %scale		; <bool> [#uses=1]
-	%max = select bool %tmp33, int %tmp31, int %scale		; <int> [#uses=4]
-	%tmp35 = add int %max, 2		; <int> [#uses=2]
-	call void %init_num( %struct.anon** %guess )
-	call void %init_num( %struct.anon** %guess1 )
-	%tmp36 = call %struct.anon* %new_num( int 1, int 1 )		; <%struct.anon*> [#uses=2]
+	%tmp30 = getelementptr %struct.anon* %tmp29, i32 0, i32 2		; <i32*> [#uses=1]
+	%tmp31 = load i32* %tmp30		; <i32> [#uses=2]
+	%tmp33 = icmp sge i32 %tmp31, %scale		; <i1> [#uses=1]
+	%max = select i1 %tmp33, i32 %tmp31, i32 %scale		; <i32> [#uses=4]
+	%tmp35 = add i32 %max, 2		; <i32> [#uses=0]
+	call void @init_num( %struct.anon** %guess )
+	call void @init_num( %struct.anon** %guess1 )
+	%tmp36 = call %struct.anon* @new_num( i32 1, i32 1 )		; <%struct.anon*> [#uses=2]
 	store %struct.anon* %tmp36, %struct.anon** %point5
-	%tmp = getelementptr %struct.anon* %tmp36, int 0, uint 4, int 1		; <sbyte*> [#uses=1]
-	store sbyte 5, sbyte* %tmp
-	%tmp39 = setlt int %tmp17, 0		; <bool> [#uses=1]
-	br bool %tmp39, label %cond_true40, label %cond_false43
-
+	%tmp.upgrd.3 = getelementptr %struct.anon* %tmp36, i32 0, i32 4, i32 1		; <i8*> [#uses=1]
+	store i8 5, i8* %tmp.upgrd.3
+	%tmp39 = icmp slt i32 %tmp17, 0		; <i1> [#uses=1]
+	br i1 %tmp39, label %cond_true40, label %cond_false43
 cond_true40:		; preds = %cond_next27
-	%tmp41 = load %struct.anon** %_one_		; <%struct.anon*> [#uses=1]
-	%tmp42 = call %struct.anon* %copy_num( %struct.anon* %tmp41 )		; <%struct.anon*> [#uses=1]
+	%tmp41 = load %struct.anon** @_one_		; <%struct.anon*> [#uses=1]
+	%tmp42 = call %struct.anon* @copy_num( %struct.anon* %tmp41 )		; <%struct.anon*> [#uses=1]
 	store %struct.anon* %tmp42, %struct.anon** %guess
 	br label %bb80.outer
-
 cond_false43:		; preds = %cond_next27
-	call void %int2num( %struct.anon** %guess, int 10 )
+	call void @int2num( %struct.anon** %guess, i32 10 )
 	%tmp45 = load %struct.anon** %num		; <%struct.anon*> [#uses=1]
-	%tmp46 = getelementptr %struct.anon* %tmp45, int 0, uint 1		; <int*> [#uses=1]
-	%tmp47 = load int* %tmp46		; <int> [#uses=1]
-	call void %int2num( %struct.anon** %guess1, int %tmp47 )
+	%tmp46 = getelementptr %struct.anon* %tmp45, i32 0, i32 1		; <i32*> [#uses=1]
+	%tmp47 = load i32* %tmp46		; <i32> [#uses=1]
+	call void @int2num( %struct.anon** %guess1, i32 %tmp47 )
 	%tmp48 = load %struct.anon** %guess1		; <%struct.anon*> [#uses=1]
 	%tmp49 = load %struct.anon** %point5		; <%struct.anon*> [#uses=1]
-	call void %bc_multiply( %struct.anon* %tmp48, %struct.anon* %tmp49, %struct.anon** %guess1, int %max )
+	call void @bc_multiply( %struct.anon* %tmp48, %struct.anon* %tmp49, %struct.anon** %guess1, i32 %max )
 	%tmp51 = load %struct.anon** %guess1		; <%struct.anon*> [#uses=1]
-	%tmp52 = getelementptr %struct.anon* %tmp51, int 0, uint 2		; <int*> [#uses=1]
-	store int 0, int* %tmp52
+	%tmp52 = getelementptr %struct.anon* %tmp51, i32 0, i32 2		; <i32*> [#uses=1]
+	store i32 0, i32* %tmp52
 	%tmp53 = load %struct.anon** %guess		; <%struct.anon*> [#uses=1]
 	%tmp54 = load %struct.anon** %guess1		; <%struct.anon*> [#uses=1]
-	call void %bc_raise( %struct.anon* %tmp53, %struct.anon* %tmp54, %struct.anon** %guess, int %max )
+	call void @bc_raise( %struct.anon* %tmp53, %struct.anon* %tmp54, %struct.anon** %guess, i32 %max )
 	br label %bb80.outer
-
-bb80.outer:		; preds = %cond_true77, %cond_next56
-	%done.1.ph = phi int [ 1, %cond_true83 ], [0, %cond_true40], [0, %cond_false43]		; <int> [#uses=1]
+bb80.outer:		; preds = %cond_true83, %cond_false43, %cond_true40
+	%done.1.ph = phi i32 [ 1, %cond_true83 ], [ 0, %cond_true40 ], [ 0, %cond_false43 ]		; <i32> [#uses=1]
 	br label %bb80
-
-bb80:		; preds = %bb80.outer, %cond_true83
-	%tmp82 = seteq int %done.1.ph, 0		; <bool> [#uses=1]
-	br bool %tmp82, label %cond_true83, label %bb86
-
+bb80:		; preds = %cond_true83, %bb80.outer
+	%tmp82 = icmp eq i32 %done.1.ph, 0		; <i1> [#uses=1]
+	br i1 %tmp82, label %cond_true83, label %bb86
 cond_true83:		; preds = %bb80
-	%tmp71 = call int %_do_compare( %struct.anon* null, %struct.anon* null, int 0, int 1 )		; <int> [#uses=2]
-	%tmp76 = seteq int %tmp71, 0		; <bool> [#uses=1]
-	br bool %tmp76, label %bb80.outer, label %bb80
-
+	%tmp71 = call i32 @_do_compare( %struct.anon* null, %struct.anon* null, i32 0, i32 1 )		; <i32> [#uses=1]
+	%tmp76 = icmp eq i32 %tmp71, 0		; <i1> [#uses=1]
+	br i1 %tmp76, label %bb80.outer, label %bb80
 bb86:		; preds = %bb80
-	call void %free_num( %struct.anon** %num )
+	call void @free_num( %struct.anon** %num )
 	%tmp88 = load %struct.anon** %guess		; <%struct.anon*> [#uses=1]
-	%tmp89 = load %struct.anon** %_one_		; <%struct.anon*> [#uses=1]
-	%tmp92 = call int %bc_divide( %struct.anon* %tmp88, %struct.anon* %tmp89, %struct.anon** %num, int %max )		; <int> [#uses=0]
-	call void %free_num( %struct.anon** %guess )
-	call void %free_num( %struct.anon** %guess1 )
-	call void %free_num( %struct.anon** %point5 )
-	ret int 1
+	%tmp89 = load %struct.anon** @_one_		; <%struct.anon*> [#uses=1]
+	%tmp92 = call i32 @bc_divide( %struct.anon* %tmp88, %struct.anon* %tmp89, %struct.anon** %num, i32 %max )		; <i32> [#uses=0]
+	call void @free_num( %struct.anon** %guess )
+	call void @free_num( %struct.anon** %guess1 )
+	call void @free_num( %struct.anon** %point5 )
+	ret i32 1
 }
-
diff --git a/test/Transforms/SimplifyCFG/2006-02-17-InfiniteUnroll.ll b/test/Transforms/SimplifyCFG/2006-02-17-InfiniteUnroll.ll
index 8b443da..4400624 100644
--- a/test/Transforms/SimplifyCFG/2006-02-17-InfiniteUnroll.ll
+++ b/test/Transforms/SimplifyCFG/2006-02-17-InfiniteUnroll.ll
@@ -1,35 +1,27 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
 
-void %polnel_() {
+define void @polnel_() {
 entry:
-	%tmp595 = setlt int 0, 0		; <bool> [#uses=4]
-	br bool %tmp595, label %bb148.critedge, label %cond_true40
-
+	%tmp595 = icmp slt i32 0, 0		; <i1> [#uses=4]
+	br i1 %tmp595, label %bb148.critedge, label %cond_true40
 bb36:		; preds = %bb43
-	br bool %tmp595, label %bb43, label %cond_true40
-
+	br i1 %tmp595, label %bb43, label %cond_true40
 cond_true40:		; preds = %bb46, %cond_true40, %bb36, %entry
-	%tmp397 = setgt int 0, 0		; <bool> [#uses=1]
-	br bool %tmp397, label %bb43, label %cond_true40
-
+	%tmp397 = icmp sgt i32 0, 0		; <i1> [#uses=1]
+	br i1 %tmp397, label %bb43, label %cond_true40
 bb43:		; preds = %cond_true40, %bb36
-	br bool false, label %bb53, label %bb36
-
+	br i1 false, label %bb53, label %bb36
 bb46:		; preds = %bb53
-	br bool %tmp595, label %bb53, label %cond_true40
-
+	br i1 %tmp595, label %bb53, label %cond_true40
 bb53:		; preds = %bb46, %bb43
-	br bool false, label %bb102, label %bb46
-
+	br i1 false, label %bb102, label %bb46
 bb92.preheader:		; preds = %bb102
 	ret void
-
 bb102:		; preds = %bb53
-	br bool %tmp595, label %bb148, label %bb92.preheader
-
+	br i1 %tmp595, label %bb148, label %bb92.preheader
 bb148.critedge:		; preds = %entry
 	ret void
-
 bb148:		; preds = %bb102
 	ret void
 }
+
diff --git a/test/Transforms/SimplifyCFG/2006-06-12-InfLoop.ll b/test/Transforms/SimplifyCFG/2006-06-12-InfLoop.ll
index c9b1858..4981cf3 100644
--- a/test/Transforms/SimplifyCFG/2006-06-12-InfLoop.ll
+++ b/test/Transforms/SimplifyCFG/2006-06-12-InfLoop.ll
@@ -1,613 +1,413 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
+; END.
 
-void %main(int %c) {
+define void @main(i32 %c) {
 entry:
-	%tmp.9 = seteq int %c, 2		; <bool> [#uses=1]
-	br bool %tmp.9, label %endif.0, label %then.0
-
+	%tmp.9 = icmp eq i32 %c, 2		; <i1> [#uses=1]
+	br i1 %tmp.9, label %endif.0, label %then.0
 then.0:		; preds = %entry
 	ret void
-
 endif.0:		; preds = %entry
-	br bool false, label %then.1, label %endif.1
-
+	br i1 false, label %then.1, label %endif.1
 then.1:		; preds = %endif.0
 	ret void
-
 endif.1:		; preds = %endif.0
-	br bool false, label %then.2, label %endif.2
-
+	br i1 false, label %then.2, label %endif.2
 then.2:		; preds = %endif.1
 	ret void
-
 endif.2:		; preds = %endif.1
-	br bool false, label %then.3, label %loopentry.0
-
+	br i1 false, label %then.3, label %loopentry.0
 then.3:		; preds = %endif.2
 	ret void
-
 loopentry.0:		; preds = %endif.2
-	br bool false, label %no_exit.0.preheader, label %loopexit.0
-
+	br i1 false, label %no_exit.0.preheader, label %loopexit.0
 no_exit.0.preheader:		; preds = %loopentry.0
 	br label %no_exit.0
-
 no_exit.0:		; preds = %endif.4, %no_exit.0.preheader
-	br bool false, label %then.4, label %endif.4
-
+	br i1 false, label %then.4, label %endif.4
 then.4:		; preds = %no_exit.0
 	ret void
-
 endif.4:		; preds = %no_exit.0
-	br bool false, label %no_exit.0, label %loopexit.0.loopexit
-
+	br i1 false, label %no_exit.0, label %loopexit.0.loopexit
 loopexit.0.loopexit:		; preds = %endif.4
 	br label %loopexit.0
-
 loopexit.0:		; preds = %loopexit.0.loopexit, %loopentry.0
-	br bool false, label %then.5, label %loopentry.1
-
+	br i1 false, label %then.5, label %loopentry.1
 then.5:		; preds = %loopexit.0
 	ret void
-
 loopentry.1:		; preds = %loopexit.0
-	%tmp.143 = setgt int 0, 0		; <bool> [#uses=4]
-	br bool %tmp.143, label %no_exit.1.preheader, label %loopexit.1
-
+	%tmp.143 = icmp sgt i32 0, 0		; <i1> [#uses=4]
+	br i1 %tmp.143, label %no_exit.1.preheader, label %loopexit.1
 no_exit.1.preheader:		; preds = %loopentry.1
 	br label %no_exit.1
-
 no_exit.1:		; preds = %endif.6, %no_exit.1.preheader
-	br bool false, label %then.6, label %shortcirc_next.3
-
+	br i1 false, label %then.6, label %shortcirc_next.3
 shortcirc_next.3:		; preds = %no_exit.1
-	br bool false, label %then.6, label %shortcirc_next.4
-
+	br i1 false, label %then.6, label %shortcirc_next.4
 shortcirc_next.4:		; preds = %shortcirc_next.3
-	br bool false, label %then.6, label %endif.6
-
+	br i1 false, label %then.6, label %endif.6
 then.6:		; preds = %shortcirc_next.4, %shortcirc_next.3, %no_exit.1
 	ret void
-
 endif.6:		; preds = %shortcirc_next.4
-	br bool false, label %no_exit.1, label %loopexit.1.loopexit
-
+	br i1 false, label %no_exit.1, label %loopexit.1.loopexit
 loopexit.1.loopexit:		; preds = %endif.6
 	br label %loopexit.1
-
 loopexit.1:		; preds = %loopexit.1.loopexit, %loopentry.1
-	br bool false, label %then.i, label %loopentry.0.i
-
+	br i1 false, label %then.i, label %loopentry.0.i
 then.i:		; preds = %loopexit.1
 	ret void
-
 loopentry.0.i:		; preds = %loopexit.1
-	br bool %tmp.143, label %no_exit.0.i.preheader, label %readvector.exit
-
+	br i1 %tmp.143, label %no_exit.0.i.preheader, label %readvector.exit
 no_exit.0.i.preheader:		; preds = %loopentry.0.i
 	br label %no_exit.0.i
-
 no_exit.0.i:		; preds = %loopexit.1.i, %no_exit.0.i.preheader
-	br bool false, label %no_exit.1.i.preheader, label %loopexit.1.i
-
+	br i1 false, label %no_exit.1.i.preheader, label %loopexit.1.i
 no_exit.1.i.preheader:		; preds = %no_exit.0.i
 	br label %no_exit.1.i
-
 no_exit.1.i:		; preds = %loopexit.2.i, %no_exit.1.i.preheader
-	br bool false, label %no_exit.2.i.preheader, label %loopexit.2.i
-
+	br i1 false, label %no_exit.2.i.preheader, label %loopexit.2.i
 no_exit.2.i.preheader:		; preds = %no_exit.1.i
 	br label %no_exit.2.i
-
 no_exit.2.i:		; preds = %no_exit.2.i, %no_exit.2.i.preheader
-	br bool false, label %no_exit.2.i, label %loopexit.2.i.loopexit
-
+	br i1 false, label %no_exit.2.i, label %loopexit.2.i.loopexit
 loopexit.2.i.loopexit:		; preds = %no_exit.2.i
 	br label %loopexit.2.i
-
 loopexit.2.i:		; preds = %loopexit.2.i.loopexit, %no_exit.1.i
-	br bool false, label %no_exit.1.i, label %loopexit.1.i.loopexit
-
+	br i1 false, label %no_exit.1.i, label %loopexit.1.i.loopexit
 loopexit.1.i.loopexit:		; preds = %loopexit.2.i
 	br label %loopexit.1.i
-
 loopexit.1.i:		; preds = %loopexit.1.i.loopexit, %no_exit.0.i
-	br bool false, label %no_exit.0.i, label %readvector.exit.loopexit
-
+	br i1 false, label %no_exit.0.i, label %readvector.exit.loopexit
 readvector.exit.loopexit:		; preds = %loopexit.1.i
 	br label %readvector.exit
-
 readvector.exit:		; preds = %readvector.exit.loopexit, %loopentry.0.i
-	br bool %tmp.143, label %loopentry.1.preheader.i, label %loopexit.0.i
-
+	br i1 %tmp.143, label %loopentry.1.preheader.i, label %loopexit.0.i
 loopentry.1.preheader.i:		; preds = %readvector.exit
 	br label %loopentry.1.outer.i
-
 loopentry.1.outer.i:		; preds = %loopexit.1.i110, %loopentry.1.preheader.i
 	br label %loopentry.1.i85
-
 loopentry.1.i85.loopexit:		; preds = %hamming.exit16.i
 	br label %loopentry.1.i85
-
 loopentry.1.i85:		; preds = %loopentry.1.i85.loopexit, %loopentry.1.outer.i
-	br bool false, label %no_exit.1.preheader.i, label %loopexit.1.i110.loopexit1
-
+	br i1 false, label %no_exit.1.preheader.i, label %loopexit.1.i110.loopexit1
 no_exit.1.preheader.i:		; preds = %loopentry.1.i85
 	br label %no_exit.1.i87
-
 no_exit.1.i87:		; preds = %then.1.i107, %no_exit.1.preheader.i
-	br bool false, label %no_exit.i.i101.preheader, label %hamming.exit.i104
-
+	br i1 false, label %no_exit.i.i101.preheader, label %hamming.exit.i104
 no_exit.i.i101.preheader:		; preds = %no_exit.1.i87
 	br label %no_exit.i.i101
-
 no_exit.i.i101:		; preds = %no_exit.i.i101, %no_exit.i.i101.preheader
-	br bool false, label %no_exit.i.i101, label %hamming.exit.i104.loopexit
-
+	br i1 false, label %no_exit.i.i101, label %hamming.exit.i104.loopexit
 hamming.exit.i104.loopexit:		; preds = %no_exit.i.i101
 	br label %hamming.exit.i104
-
 hamming.exit.i104:		; preds = %hamming.exit.i104.loopexit, %no_exit.1.i87
-	br bool false, label %no_exit.i15.i.preheader, label %hamming.exit16.i
-
+	br i1 false, label %no_exit.i15.i.preheader, label %hamming.exit16.i
 no_exit.i15.i.preheader:		; preds = %hamming.exit.i104
 	br label %no_exit.i15.i
-
 no_exit.i15.i:		; preds = %no_exit.i15.i, %no_exit.i15.i.preheader
-	br bool false, label %no_exit.i15.i, label %hamming.exit16.i.loopexit
-
+	br i1 false, label %no_exit.i15.i, label %hamming.exit16.i.loopexit
 hamming.exit16.i.loopexit:		; preds = %no_exit.i15.i
 	br label %hamming.exit16.i
-
 hamming.exit16.i:		; preds = %hamming.exit16.i.loopexit, %hamming.exit.i104
-	br bool false, label %loopentry.1.i85.loopexit, label %then.1.i107
-
+	br i1 false, label %loopentry.1.i85.loopexit, label %then.1.i107
 then.1.i107:		; preds = %hamming.exit16.i
-	br bool false, label %no_exit.1.i87, label %loopexit.1.i110.loopexit
-
+	br i1 false, label %no_exit.1.i87, label %loopexit.1.i110.loopexit
 loopexit.1.i110.loopexit:		; preds = %then.1.i107
 	br label %loopexit.1.i110
-
 loopexit.1.i110.loopexit1:		; preds = %loopentry.1.i85
 	br label %loopexit.1.i110
-
 loopexit.1.i110:		; preds = %loopexit.1.i110.loopexit1, %loopexit.1.i110.loopexit
-	br bool false, label %loopentry.1.outer.i, label %loopexit.0.i.loopexit
-
+	br i1 false, label %loopentry.1.outer.i, label %loopexit.0.i.loopexit
 loopexit.0.i.loopexit:		; preds = %loopexit.1.i110
 	br label %loopexit.0.i
-
 loopexit.0.i:		; preds = %loopexit.0.i.loopexit, %readvector.exit
-	br bool false, label %UnifiedReturnBlock.i113, label %then.2.i112
-
+	br i1 false, label %UnifiedReturnBlock.i113, label %then.2.i112
 then.2.i112:		; preds = %loopexit.0.i
 	br label %checkham.exit
-
 UnifiedReturnBlock.i113:		; preds = %loopexit.0.i
 	br label %checkham.exit
-
 checkham.exit:		; preds = %UnifiedReturnBlock.i113, %then.2.i112
-	br bool false, label %loopentry.1.i14.preheader, label %loopentry.3.i.preheader
-
+	br i1 false, label %loopentry.1.i14.preheader, label %loopentry.3.i.preheader
 loopentry.1.i14.preheader:		; preds = %checkham.exit
 	br label %loopentry.1.i14
-
 loopentry.1.i14:		; preds = %loopexit.1.i18, %loopentry.1.i14.preheader
-	br bool false, label %no_exit.1.i16.preheader, label %loopexit.1.i18
-
+	br i1 false, label %no_exit.1.i16.preheader, label %loopexit.1.i18
 no_exit.1.i16.preheader:		; preds = %loopentry.1.i14
 	br label %no_exit.1.i16
-
 no_exit.1.i16:		; preds = %no_exit.1.i16, %no_exit.1.i16.preheader
-	br bool false, label %no_exit.1.i16, label %loopexit.1.i18.loopexit
-
+	br i1 false, label %no_exit.1.i16, label %loopexit.1.i18.loopexit
 loopexit.1.i18.loopexit:		; preds = %no_exit.1.i16
 	br label %loopexit.1.i18
-
 loopexit.1.i18:		; preds = %loopexit.1.i18.loopexit, %loopentry.1.i14
-	br bool false, label %loopentry.1.i14, label %loopentry.3.i.loopexit
-
+	br i1 false, label %loopentry.1.i14, label %loopentry.3.i.loopexit
 loopentry.3.i.loopexit:		; preds = %loopexit.1.i18
 	br label %loopentry.3.i.preheader
-
 loopentry.3.i.preheader:		; preds = %loopentry.3.i.loopexit, %checkham.exit
 	br label %loopentry.3.i
-
 loopentry.3.i:		; preds = %endif.1.i, %loopentry.3.i.preheader
-	br bool false, label %loopentry.4.i.preheader, label %endif.1.i
-
+	br i1 false, label %loopentry.4.i.preheader, label %endif.1.i
 loopentry.4.i.preheader:		; preds = %loopentry.3.i
 	br label %loopentry.4.i
-
 loopentry.4.i:		; preds = %loopexit.4.i, %loopentry.4.i.preheader
-	br bool false, label %no_exit.4.i.preheader, label %loopexit.4.i
-
+	br i1 false, label %no_exit.4.i.preheader, label %loopexit.4.i
 no_exit.4.i.preheader:		; preds = %loopentry.4.i
 	br label %no_exit.4.i
-
 no_exit.4.i:		; preds = %no_exit.4.i.backedge, %no_exit.4.i.preheader
-	br bool false, label %endif.0.i, label %else.i
-
+	br i1 false, label %endif.0.i, label %else.i
 else.i:		; preds = %no_exit.4.i
-	br bool false, label %no_exit.4.i.backedge, label %loopexit.4.i.loopexit
-
+	br i1 false, label %no_exit.4.i.backedge, label %loopexit.4.i.loopexit
 no_exit.4.i.backedge:		; preds = %endif.0.i, %else.i
 	br label %no_exit.4.i
-
 endif.0.i:		; preds = %no_exit.4.i
-	br bool false, label %no_exit.4.i.backedge, label %loopexit.4.i.loopexit
-
+	br i1 false, label %no_exit.4.i.backedge, label %loopexit.4.i.loopexit
 loopexit.4.i.loopexit:		; preds = %endif.0.i, %else.i
 	br label %loopexit.4.i
-
 loopexit.4.i:		; preds = %loopexit.4.i.loopexit, %loopentry.4.i
-	br bool false, label %loopentry.4.i, label %endif.1.i.loopexit
-
+	br i1 false, label %loopentry.4.i, label %endif.1.i.loopexit
 endif.1.i.loopexit:		; preds = %loopexit.4.i
 	br label %endif.1.i
-
 endif.1.i:		; preds = %endif.1.i.loopexit, %loopentry.3.i
-	%exitcond = seteq uint 0, 10		; <bool> [#uses=1]
-	br bool %exitcond, label %generateT.exit, label %loopentry.3.i
-
+	%exitcond = icmp eq i32 0, 10		; <i1> [#uses=1]
+	br i1 %exitcond, label %generateT.exit, label %loopentry.3.i
 generateT.exit:		; preds = %endif.1.i
-	br bool false, label %then.0.i, label %loopentry.1.i30.preheader
-
+	br i1 false, label %then.0.i, label %loopentry.1.i30.preheader
 then.0.i:		; preds = %generateT.exit
 	ret void
-
 loopentry.1.i30.loopexit:		; preds = %loopexit.3.i
 	br label %loopentry.1.i30.backedge
-
 loopentry.1.i30.preheader:		; preds = %generateT.exit
 	br label %loopentry.1.i30
-
 loopentry.1.i30:		; preds = %loopentry.1.i30.backedge, %loopentry.1.i30.preheader
-	br bool %tmp.143, label %no_exit.0.i31.preheader, label %loopentry.1.i30.backedge
-
+	br i1 %tmp.143, label %no_exit.0.i31.preheader, label %loopentry.1.i30.backedge
 loopentry.1.i30.backedge:		; preds = %loopentry.1.i30, %loopentry.1.i30.loopexit
 	br label %loopentry.1.i30
-
 no_exit.0.i31.preheader:		; preds = %loopentry.1.i30
 	br label %no_exit.0.i31
-
 no_exit.0.i31:		; preds = %loopexit.3.i, %no_exit.0.i31.preheader
-	br bool false, label %then.1.i, label %else.0.i
-
+	br i1 false, label %then.1.i, label %else.0.i
 then.1.i:		; preds = %no_exit.0.i31
-	br bool undef, label %then.0.i29, label %loopentry.0.i31
-
+	br i1 undef, label %then.0.i29, label %loopentry.0.i31
 then.0.i29:		; preds = %then.1.i
 	unreachable
-
 loopentry.0.i31:		; preds = %then.1.i
-	br bool false, label %no_exit.0.i38.preheader, label %loopentry.1.i.preheader
-
+	br i1 false, label %no_exit.0.i38.preheader, label %loopentry.1.i.preheader
 no_exit.0.i38.preheader:		; preds = %loopentry.0.i31
 	br label %no_exit.0.i38
-
 no_exit.0.i38:		; preds = %no_exit.0.i38, %no_exit.0.i38.preheader
-	br bool undef, label %no_exit.0.i38, label %loopentry.1.i.preheader.loopexit
-
+	br i1 undef, label %no_exit.0.i38, label %loopentry.1.i.preheader.loopexit
 loopentry.1.i.preheader.loopexit:		; preds = %no_exit.0.i38
 	br label %loopentry.1.i.preheader
-
 loopentry.1.i.preheader:		; preds = %loopentry.1.i.preheader.loopexit, %loopentry.0.i31
 	br label %loopentry.1.i
-
 loopentry.1.i:		; preds = %endif.2.i, %loopentry.1.i.preheader
-	br bool undef, label %loopentry.2.i39.preheader, label %loopexit.1.i79.loopexit2
-
+	br i1 undef, label %loopentry.2.i39.preheader, label %loopexit.1.i79.loopexit2
 loopentry.2.i39.preheader:		; preds = %loopentry.1.i
 	br label %loopentry.2.i39
-
 loopentry.2.i39:		; preds = %loopexit.5.i77, %loopentry.2.i39.preheader
-	br bool false, label %loopentry.3.i40.preheader, label %hamming.exit.i71
-
+	br i1 false, label %loopentry.3.i40.preheader, label %hamming.exit.i71
 loopentry.3.i40.preheader:		; preds = %loopentry.2.i39
 	br label %loopentry.3.i40
-
 loopentry.3.i40:		; preds = %loopexit.3.i51, %loopentry.3.i40.preheader
-	br bool false, label %no_exit.3.preheader.i42, label %loopexit.3.i51
-
+	br i1 false, label %no_exit.3.preheader.i42, label %loopexit.3.i51
 no_exit.3.preheader.i42:		; preds = %loopentry.3.i40
 	br label %no_exit.3.i49
-
 no_exit.3.i49:		; preds = %no_exit.3.i49, %no_exit.3.preheader.i42
-	br bool undef, label %no_exit.3.i49, label %loopexit.3.i51.loopexit
-
+	br i1 undef, label %no_exit.3.i49, label %loopexit.3.i51.loopexit
 loopexit.3.i51.loopexit:		; preds = %no_exit.3.i49
 	br label %loopexit.3.i51
-
 loopexit.3.i51:		; preds = %loopexit.3.i51.loopexit, %loopentry.3.i40
-	br bool undef, label %loopentry.3.i40, label %loopentry.4.i52
-
+	br i1 undef, label %loopentry.3.i40, label %loopentry.4.i52
 loopentry.4.i52:		; preds = %loopexit.3.i51
-	br bool false, label %no_exit.4.i54.preheader, label %hamming.exit.i71
-
+	br i1 false, label %no_exit.4.i54.preheader, label %hamming.exit.i71
 no_exit.4.i54.preheader:		; preds = %loopentry.4.i52
 	br label %no_exit.4.i54
-
 no_exit.4.i54:		; preds = %no_exit.4.backedge.i, %no_exit.4.i54.preheader
-	br bool undef, label %then.1.i55, label %endif.1.i56
-
+	br i1 undef, label %then.1.i55, label %endif.1.i56
 then.1.i55:		; preds = %no_exit.4.i54
-	br bool undef, label %no_exit.4.backedge.i, label %loopexit.4.i57
-
+	br i1 undef, label %no_exit.4.backedge.i, label %loopexit.4.i57
 no_exit.4.backedge.i:		; preds = %endif.1.i56, %then.1.i55
 	br label %no_exit.4.i54
-
 endif.1.i56:		; preds = %no_exit.4.i54
-	br bool undef, label %no_exit.4.backedge.i, label %loopexit.4.i57
-
+	br i1 undef, label %no_exit.4.backedge.i, label %loopexit.4.i57
 loopexit.4.i57:		; preds = %endif.1.i56, %then.1.i55
-	br bool false, label %no_exit.i.i69.preheader, label %hamming.exit.i71
-
+	br i1 false, label %no_exit.i.i69.preheader, label %hamming.exit.i71
 no_exit.i.i69.preheader:		; preds = %loopexit.4.i57
 	br label %no_exit.i.i69
-
 no_exit.i.i69:		; preds = %no_exit.i.i69, %no_exit.i.i69.preheader
-	br bool undef, label %no_exit.i.i69, label %hamming.exit.i71.loopexit
-
+	br i1 undef, label %no_exit.i.i69, label %hamming.exit.i71.loopexit
 hamming.exit.i71.loopexit:		; preds = %no_exit.i.i69
 	br label %hamming.exit.i71
-
 hamming.exit.i71:		; preds = %hamming.exit.i71.loopexit, %loopexit.4.i57, %loopentry.4.i52, %loopentry.2.i39
-	br bool undef, label %endif.2.i, label %loopentry.5.i72
-
+	br i1 undef, label %endif.2.i, label %loopentry.5.i72
 loopentry.5.i72:		; preds = %hamming.exit.i71
-	br bool false, label %shortcirc_next.i74.preheader, label %loopexit.5.i77
-
+	br i1 false, label %shortcirc_next.i74.preheader, label %loopexit.5.i77
 shortcirc_next.i74.preheader:		; preds = %loopentry.5.i72
 	br label %shortcirc_next.i74
-
 shortcirc_next.i74:		; preds = %no_exit.5.i76, %shortcirc_next.i74.preheader
-	br bool undef, label %no_exit.5.i76, label %loopexit.5.i77.loopexit
-
+	br i1 undef, label %no_exit.5.i76, label %loopexit.5.i77.loopexit
 no_exit.5.i76:		; preds = %shortcirc_next.i74
-	br bool undef, label %shortcirc_next.i74, label %loopexit.5.i77.loopexit
-
+	br i1 undef, label %shortcirc_next.i74, label %loopexit.5.i77.loopexit
 loopexit.5.i77.loopexit:		; preds = %no_exit.5.i76, %shortcirc_next.i74
 	br label %loopexit.5.i77
-
 loopexit.5.i77:		; preds = %loopexit.5.i77.loopexit, %loopentry.5.i72
-	br bool undef, label %loopentry.2.i39, label %loopexit.1.i79.loopexit
-
+	br i1 undef, label %loopentry.2.i39, label %loopexit.1.i79.loopexit
 endif.2.i:		; preds = %hamming.exit.i71
 	br label %loopentry.1.i
-
 loopexit.1.i79.loopexit:		; preds = %loopexit.5.i77
 	br label %loopexit.1.i79
-
 loopexit.1.i79.loopexit2:		; preds = %loopentry.1.i
 	br label %loopexit.1.i79
-
 loopexit.1.i79:		; preds = %loopexit.1.i79.loopexit2, %loopexit.1.i79.loopexit
-	br bool undef, label %then.3.i, label %loopentry.6.i80
-
+	br i1 undef, label %then.3.i, label %loopentry.6.i80
 then.3.i:		; preds = %loopexit.1.i79
-	br bool false, label %no_exit.6.i82.preheader, label %run.exit
-
+	br i1 false, label %no_exit.6.i82.preheader, label %run.exit
 loopentry.6.i80:		; preds = %loopexit.1.i79
-	br bool false, label %no_exit.6.i82.preheader, label %run.exit
-
+	br i1 false, label %no_exit.6.i82.preheader, label %run.exit
 no_exit.6.i82.preheader:		; preds = %loopentry.6.i80, %then.3.i
 	br label %no_exit.6.i82
-
 no_exit.6.i82:		; preds = %no_exit.6.i82, %no_exit.6.i82.preheader
-	br bool undef, label %no_exit.6.i82, label %run.exit.loopexit
-
+	br i1 undef, label %no_exit.6.i82, label %run.exit.loopexit
 run.exit.loopexit:		; preds = %no_exit.6.i82
 	br label %run.exit
-
 run.exit:		; preds = %run.exit.loopexit, %loopentry.6.i80, %then.3.i
-	br bool false, label %no_exit.1.i36.preheader, label %loopentry.3.i37
-
+	br i1 false, label %no_exit.1.i36.preheader, label %loopentry.3.i37
 else.0.i:		; preds = %no_exit.0.i31
-	br bool false, label %then.0.i4, label %loopentry.0.i6
-
+	br i1 false, label %then.0.i4, label %loopentry.0.i6
 then.0.i4:		; preds = %else.0.i
 	unreachable
-
 loopentry.0.i6:		; preds = %else.0.i
-	br bool false, label %no_exit.0.i8.preheader, label %loopentry.2.i.preheader
-
+	br i1 false, label %no_exit.0.i8.preheader, label %loopentry.2.i.preheader
 no_exit.0.i8.preheader:		; preds = %loopentry.0.i6
 	br label %no_exit.0.i8
-
 no_exit.0.i8:		; preds = %no_exit.0.i8, %no_exit.0.i8.preheader
-	br bool false, label %no_exit.0.i8, label %loopentry.2.i.preheader.loopexit
-
+	br i1 false, label %no_exit.0.i8, label %loopentry.2.i.preheader.loopexit
 loopentry.2.i.preheader.loopexit:		; preds = %no_exit.0.i8
 	br label %loopentry.2.i.preheader
-
 loopentry.2.i.preheader:		; preds = %loopentry.2.i.preheader.loopexit, %loopentry.0.i6
 	br label %loopentry.2.i
-
 loopentry.2.i:		; preds = %endif.3.i19, %loopentry.2.i.preheader
-	br bool false, label %loopentry.3.i10.preheader, label %loopentry.4.i15
-
+	br i1 false, label %loopentry.3.i10.preheader, label %loopentry.4.i15
 loopentry.3.i10.preheader:		; preds = %loopentry.2.i
 	br label %loopentry.3.i10
-
 loopentry.3.i10:		; preds = %loopexit.3.i14, %loopentry.3.i10.preheader
-	br bool false, label %no_exit.3.preheader.i, label %loopexit.3.i14
-
+	br i1 false, label %no_exit.3.preheader.i, label %loopexit.3.i14
 no_exit.3.preheader.i:		; preds = %loopentry.3.i10
 	br label %no_exit.3.i12
-
 no_exit.3.i12:		; preds = %no_exit.3.i12, %no_exit.3.preheader.i
-	br bool false, label %no_exit.3.i12, label %loopexit.3.i14.loopexit
-
+	br i1 false, label %no_exit.3.i12, label %loopexit.3.i14.loopexit
 loopexit.3.i14.loopexit:		; preds = %no_exit.3.i12
 	br label %loopexit.3.i14
-
 loopexit.3.i14:		; preds = %loopexit.3.i14.loopexit, %loopentry.3.i10
-	br bool false, label %loopentry.3.i10, label %loopentry.4.i15.loopexit
-
+	br i1 false, label %loopentry.3.i10, label %loopentry.4.i15.loopexit
 loopentry.4.i15.loopexit:		; preds = %loopexit.3.i14
 	br label %loopentry.4.i15
-
 loopentry.4.i15:		; preds = %loopentry.4.i15.loopexit, %loopentry.2.i
-	br bool false, label %loopentry.5.outer.i.preheader, label %loopentry.7.i
-
+	br i1 false, label %loopentry.5.outer.i.preheader, label %loopentry.7.i
 loopentry.5.outer.i.preheader:		; preds = %loopentry.4.i15
 	br label %loopentry.5.outer.i
-
 loopentry.5.outer.i:		; preds = %loopexit.5.i, %loopentry.5.outer.i.preheader
 	br label %loopentry.5.i
-
 loopentry.5.i:		; preds = %endif.1.i18, %loopentry.5.outer.i
-	br bool false, label %no_exit.5.i.preheader, label %loopexit.5.i.loopexit3
-
+	br i1 false, label %no_exit.5.i.preheader, label %loopexit.5.i.loopexit3
 no_exit.5.i.preheader:		; preds = %loopentry.5.i
 	br label %no_exit.5.i
-
 no_exit.5.i:		; preds = %then.2.i, %no_exit.5.i.preheader
-	br bool false, label %loopentry.6.i, label %endif.1.i18
-
+	br i1 false, label %loopentry.6.i, label %endif.1.i18
 loopentry.6.i:		; preds = %no_exit.5.i
-	br bool false, label %no_exit.6.preheader.i, label %loopexit.6.i
-
+	br i1 false, label %no_exit.6.preheader.i, label %loopexit.6.i
 no_exit.6.preheader.i:		; preds = %loopentry.6.i
 	br label %no_exit.6.i
-
 no_exit.6.i:		; preds = %no_exit.6.i, %no_exit.6.preheader.i
-	br bool false, label %no_exit.6.i, label %loopexit.6.i.loopexit
-
+	br i1 false, label %no_exit.6.i, label %loopexit.6.i.loopexit
 loopexit.6.i.loopexit:		; preds = %no_exit.6.i
 	br label %loopexit.6.i
-
 loopexit.6.i:		; preds = %loopexit.6.i.loopexit, %loopentry.6.i
-	br bool false, label %then.2.i, label %endif.1.i18
-
+	br i1 false, label %then.2.i, label %endif.1.i18
 then.2.i:		; preds = %loopexit.6.i
-	br bool false, label %no_exit.5.i, label %loopexit.5.i.loopexit
-
+	br i1 false, label %no_exit.5.i, label %loopexit.5.i.loopexit
 endif.1.i18:		; preds = %loopexit.6.i, %no_exit.5.i
 	br label %loopentry.5.i
-
 loopexit.5.i.loopexit:		; preds = %then.2.i
 	br label %loopexit.5.i
-
 loopexit.5.i.loopexit3:		; preds = %loopentry.5.i
 	br label %loopexit.5.i
-
 loopexit.5.i:		; preds = %loopexit.5.i.loopexit3, %loopexit.5.i.loopexit
-	br bool false, label %loopentry.5.outer.i, label %loopentry.7.i.loopexit
-
+	br i1 false, label %loopentry.5.outer.i, label %loopentry.7.i.loopexit
 loopentry.7.i.loopexit:		; preds = %loopexit.5.i
 	br label %loopentry.7.i
-
 loopentry.7.i:		; preds = %loopentry.7.i.loopexit, %loopentry.4.i15
-	br bool false, label %no_exit.7.i.preheader, label %hamming.exit.i
-
+	br i1 false, label %no_exit.7.i.preheader, label %hamming.exit.i
 no_exit.7.i.preheader:		; preds = %loopentry.7.i
 	br label %no_exit.7.i
-
 no_exit.7.i:		; preds = %no_exit.7.i, %no_exit.7.i.preheader
-	br bool false, label %no_exit.7.i, label %loopexit.7.i
-
+	br i1 false, label %no_exit.7.i, label %loopexit.7.i
 loopexit.7.i:		; preds = %no_exit.7.i
-	br bool false, label %no_exit.i.i.preheader, label %hamming.exit.i
-
+	br i1 false, label %no_exit.i.i.preheader, label %hamming.exit.i
 no_exit.i.i.preheader:		; preds = %loopexit.7.i
 	br label %no_exit.i.i
-
 no_exit.i.i:		; preds = %no_exit.i.i, %no_exit.i.i.preheader
-	br bool false, label %no_exit.i.i, label %hamming.exit.i.loopexit
-
+	br i1 false, label %no_exit.i.i, label %hamming.exit.i.loopexit
 hamming.exit.i.loopexit:		; preds = %no_exit.i.i
 	br label %hamming.exit.i
-
 hamming.exit.i:		; preds = %hamming.exit.i.loopexit, %loopexit.7.i, %loopentry.7.i
-	br bool false, label %endif.3.i19, label %loopentry.8.i
-
+	br i1 false, label %endif.3.i19, label %loopentry.8.i
 loopentry.8.i:		; preds = %hamming.exit.i
-	br bool false, label %shortcirc_next.i.preheader, label %loopexit.8.i
-
+	br i1 false, label %shortcirc_next.i.preheader, label %loopexit.8.i
 shortcirc_next.i.preheader:		; preds = %loopentry.8.i
 	br label %shortcirc_next.i
-
 shortcirc_next.i:		; preds = %no_exit.8.i, %shortcirc_next.i.preheader
-	br bool false, label %no_exit.8.i, label %loopexit.8.i.loopexit
-
+	br i1 false, label %no_exit.8.i, label %loopexit.8.i.loopexit
 no_exit.8.i:		; preds = %shortcirc_next.i
-	br bool false, label %shortcirc_next.i, label %loopexit.8.i.loopexit
-
+	br i1 false, label %shortcirc_next.i, label %loopexit.8.i.loopexit
 loopexit.8.i.loopexit:		; preds = %no_exit.8.i, %shortcirc_next.i
 	br label %loopexit.8.i
-
 loopexit.8.i:		; preds = %loopexit.8.i.loopexit, %loopentry.8.i
-	br bool false, label %no_exit.9.i.preheader, label %endif.3.i19
-
+	br i1 false, label %no_exit.9.i.preheader, label %endif.3.i19
 no_exit.9.i.preheader:		; preds = %loopexit.8.i
 	br label %no_exit.9.i
-
 no_exit.9.i:		; preds = %no_exit.9.i, %no_exit.9.i.preheader
-	br bool false, label %no_exit.9.i, label %endif.3.i19.loopexit
-
+	br i1 false, label %no_exit.9.i, label %endif.3.i19.loopexit
 endif.3.i19.loopexit:		; preds = %no_exit.9.i
 	br label %endif.3.i19
-
 endif.3.i19:		; preds = %endif.3.i19.loopexit, %loopexit.8.i, %hamming.exit.i
-	br bool false, label %loopentry.2.i, label %loopexit.1.i20
-
+	br i1 false, label %loopentry.2.i, label %loopexit.1.i20
 loopexit.1.i20:		; preds = %endif.3.i19
-	br bool false, label %then.4.i, label %UnifiedReturnBlock.i
-
+	br i1 false, label %then.4.i, label %UnifiedReturnBlock.i
 then.4.i:		; preds = %loopexit.1.i20
 	br label %runcont.exit
-
 UnifiedReturnBlock.i:		; preds = %loopexit.1.i20
 	br label %runcont.exit
-
 runcont.exit:		; preds = %UnifiedReturnBlock.i, %then.4.i
-	br bool false, label %no_exit.1.i36.preheader, label %loopentry.3.i37
-
+	br i1 false, label %no_exit.1.i36.preheader, label %loopentry.3.i37
 no_exit.1.i36.preheader:		; preds = %runcont.exit, %run.exit
 	br label %no_exit.1.i36
-
 no_exit.1.i36:		; preds = %no_exit.1.i36, %no_exit.1.i36.preheader
-	br bool false, label %no_exit.1.i36, label %loopentry.3.i37.loopexit
-
+	br i1 false, label %no_exit.1.i36, label %loopentry.3.i37.loopexit
 loopentry.3.i37.loopexit:		; preds = %no_exit.1.i36
 	br label %loopentry.3.i37
-
 loopentry.3.i37:		; preds = %loopentry.3.i37.loopexit, %runcont.exit, %run.exit
-	br bool false, label %loopentry.4.i38.preheader, label %loopexit.3.i
-
+	br i1 false, label %loopentry.4.i38.preheader, label %loopexit.3.i
 loopentry.4.i38.preheader:		; preds = %loopentry.3.i37
 	br label %loopentry.4.i38
-
 loopentry.4.i38:		; preds = %loopexit.4.i42, %loopentry.4.i38.preheader
-	br bool false, label %no_exit.3.i.preheader, label %loopexit.4.i42
-
+	br i1 false, label %no_exit.3.i.preheader, label %loopexit.4.i42
 no_exit.3.i.preheader:		; preds = %loopentry.4.i38
 	br label %no_exit.3.i
-
 no_exit.3.i:		; preds = %no_exit.3.i.backedge, %no_exit.3.i.preheader
-	br bool false, label %endif.3.i, label %else.1.i
-
+	br i1 false, label %endif.3.i, label %else.1.i
 else.1.i:		; preds = %no_exit.3.i
-	br bool false, label %no_exit.3.i.backedge, label %loopexit.4.i42.loopexit
-
+	br i1 false, label %no_exit.3.i.backedge, label %loopexit.4.i42.loopexit
 no_exit.3.i.backedge:		; preds = %endif.3.i, %else.1.i
 	br label %no_exit.3.i
-
 endif.3.i:		; preds = %no_exit.3.i
-	br bool false, label %no_exit.3.i.backedge, label %loopexit.4.i42.loopexit
-
+	br i1 false, label %no_exit.3.i.backedge, label %loopexit.4.i42.loopexit
 loopexit.4.i42.loopexit:		; preds = %endif.3.i, %else.1.i
 	br label %loopexit.4.i42
-
 loopexit.4.i42:		; preds = %loopexit.4.i42.loopexit, %loopentry.4.i38
-	br bool false, label %loopentry.4.i38, label %loopexit.3.i.loopexit
-
+	br i1 false, label %loopentry.4.i38, label %loopexit.3.i.loopexit
 loopexit.3.i.loopexit:		; preds = %loopexit.4.i42
 	br label %loopexit.3.i
-
 loopexit.3.i:		; preds = %loopexit.3.i.loopexit, %loopentry.3.i37
-	%tmp.13.i155 = setlt int 0, 0		; <bool> [#uses=1]
-	br bool %tmp.13.i155, label %no_exit.0.i31, label %loopentry.1.i30.loopexit
+	%tmp.13.i155 = icmp slt i32 0, 0		; <i1> [#uses=1]
+	br i1 %tmp.13.i155, label %no_exit.0.i31, label %loopentry.1.i30.loopexit
 }
diff --git a/test/Transforms/SimplifyCFG/2006-08-03-Crash.ll b/test/Transforms/SimplifyCFG/2006-08-03-Crash.ll
index a224a2f..110a440 100644
--- a/test/Transforms/SimplifyCFG/2006-08-03-Crash.ll
+++ b/test/Transforms/SimplifyCFG/2006-08-03-Crash.ll
@@ -1,104 +1,98 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -load-vn -gcse -simplifycfg \
+; RUN: llvm-as < %s | opt -load-vn -gcse -simplifycfg \
 ; RUN:   -disable-output
 ; PR867
+; END.
 
-target endian = big
-target pointersize = 32
+target datalayout = "E-p:32:32"
 target triple = "powerpc-apple-darwin8"
-	%struct.CUMULATIVE_ARGS = type { int, int, int, int, int, int, int, int, int, int, int, int }
+	%struct.CUMULATIVE_ARGS = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
 	%struct.eh_status = type opaque
-	%struct.emit_status = type { int, int, %struct.rtx_def*, %struct.rtx_def*, %struct.sequence_stack*, int, %struct.location_t, int, ubyte*, %struct.rtx_def** }
-	%struct.expr_status = type { int, int, int, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def* }
-	%struct.function = type { %struct.eh_status*, %struct.expr_status*, %struct.emit_status*, %struct.varasm_status*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.function*, int, int, int, int, %struct.rtx_def*, %struct.CUMULATIVE_ARGS, %struct.rtx_def*, %struct.rtx_def*, %struct.initial_value_struct*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, ubyte, int, long, %struct.tree_node*, %struct.tree_node*, %struct.rtx_def*, %struct.varray_head_tag*, %struct.temp_slot*, int, %struct.var_refs_queue*, int, int, %struct.rtvec_def*, %struct.tree_node*, int, int, int, %struct.machine_function*, uint, uint, ubyte, ubyte, %struct.language_function*, %struct.rtx_def*, uint, int, int, int, %struct.location_t, %struct.varray_head_tag*, %struct.tree_node*, ubyte, ubyte, ubyte }
+	%struct.emit_status = type { i32, i32, %struct.rtx_def*, %struct.rtx_def*, %struct.sequence_stack*, i32, %struct.location_t, i32, i8*, %struct.rtx_def** }
+	%struct.expr_status = type { i32, i32, i32, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def* }
+	%struct.function = type { %struct.eh_status*, %struct.expr_status*, %struct.emit_status*, %struct.varasm_status*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.function*, i32, i32, i32, i32, %struct.rtx_def*, %struct.CUMULATIVE_ARGS, %struct.rtx_def*, %struct.rtx_def*, %struct.initial_value_struct*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, %struct.rtx_def*, i8, i32, i64, %struct.tree_node*, %struct.tree_node*, %struct.rtx_def*, %struct.varray_head_tag*, %struct.temp_slot*, i32, %struct.var_refs_queue*, i32, i32, %struct.rtvec_def*, %struct.tree_node*, i32, i32, i32, %struct.machine_function*, i32, i32, i8, i8, %struct.language_function*, %struct.rtx_def*, i32, i32, i32, i32, %struct.location_t, %struct.varray_head_tag*, %struct.tree_node*, i8, i8, i8 }
 	%struct.initial_value_struct = type opaque
 	%struct.lang_decl = type opaque
 	%struct.lang_type = type opaque
 	%struct.language_function = type opaque
-	%struct.location_t = type { sbyte*, int }
-	%struct.machine_function = type { int, uint, sbyte*, int, int }
-	%struct.rtunion = type { int }
-	%struct.rtvec_def = type { int, [1 x %struct.rtx_def*] }
-	%struct.rtx_def = type { ushort, ubyte, ubyte, %struct.u }
+	%struct.location_t = type { i8*, i32 }
+	%struct.machine_function = type { i32, i32, i8*, i32, i32 }
+	%struct.rtunion = type { i32 }
+	%struct.rtvec_def = type { i32, [1 x %struct.rtx_def*] }
+	%struct.rtx_def = type { i16, i8, i8, %struct.u }
 	%struct.sequence_stack = type { %struct.rtx_def*, %struct.rtx_def*, %struct.sequence_stack* }
 	%struct.temp_slot = type opaque
-	%struct.tree_common = type { %struct.tree_node*, %struct.tree_node*, %union.tree_ann_d*, ubyte, ubyte, ubyte, ubyte, ubyte }
-	%struct.tree_decl = type { %struct.tree_common, %struct.location_t, uint, %struct.tree_node*, ubyte, ubyte, ubyte, ubyte, ubyte, ubyte, ubyte, ubyte, uint, %struct.tree_decl_u1, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.rtx_def*, %struct.tree_decl_u2, %struct.tree_node*, %struct.tree_node*, long, %struct.lang_decl* }
-	%struct.tree_decl_u1 = type { long }
+	%struct.tree_common = type { %struct.tree_node*, %struct.tree_node*, %union.tree_ann_d*, i8, i8, i8, i8, i8 }
+	%struct.tree_decl = type { %struct.tree_common, %struct.location_t, i32, %struct.tree_node*, i8, i8, i8, i8, i8, i8, i8, i8, i32, %struct.tree_decl_u1, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.rtx_def*, %struct.tree_decl_u2, %struct.tree_node*, %struct.tree_node*, i64, %struct.lang_decl* }
+	%struct.tree_decl_u1 = type { i64 }
 	%struct.tree_decl_u2 = type { %struct.function* }
 	%struct.tree_node = type { %struct.tree_decl }
-	%struct.tree_type = type { %struct.tree_common, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, uint, ushort, ubyte, ubyte, uint, %struct.tree_node*, %struct.tree_node*, %struct.rtunion, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, long, %struct.lang_type* }
-	%struct.u = type { [1 x long] }
-	%struct.var_refs_queue = type { %struct.rtx_def*, uint, int, %struct.var_refs_queue* }
+	%struct.tree_type = type { %struct.tree_common, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, i32, i16, i8, i8, i32, %struct.tree_node*, %struct.tree_node*, %struct.rtunion, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, %struct.tree_node*, i64, %struct.lang_type* }
+	%struct.u = type { [1 x i64] }
+	%struct.var_refs_queue = type { %struct.rtx_def*, i32, i32, %struct.var_refs_queue* }
 	%struct.varasm_status = type opaque
-	%struct.varray_head_tag = type { uint, uint, uint, sbyte*, %struct.u }
+	%struct.varray_head_tag = type { i32, i32, i32, i8*, %struct.u }
 	%union.tree_ann_d = type opaque
-%mode_class = external global [35 x ubyte]		; <[35 x ubyte]*> [#uses=3]
+@mode_class = external global [35 x i8]		; <[35 x i8]*> [#uses=3]
 
-implementation   ; Functions:
-
-void %fold_builtin_classify() {
+define void @fold_builtin_classify() {
 entry:
-	%tmp63 = load int* null		; <int> [#uses=1]
-	switch int %tmp63, label %bb276 [
-		 int 414, label %bb145
-		 int 417, label %bb
+	%tmp63 = load i32* null		; <i32> [#uses=1]
+	switch i32 %tmp63, label %bb276 [
+		 i32 414, label %bb145
+		 i32 417, label %bb
 	]
-
 bb:		; preds = %entry
 	ret void
-
 bb145:		; preds = %entry
 	%tmp146 = load %struct.tree_node** null		; <%struct.tree_node*> [#uses=1]
-	%tmp148 = getelementptr %struct.tree_node* %tmp146, int 0, uint 0, uint 0, uint 1		; <%struct.tree_node**> [#uses=1]
+	%tmp148 = getelementptr %struct.tree_node* %tmp146, i32 0, i32 0, i32 0, i32 1		; <%struct.tree_node**> [#uses=1]
 	%tmp149 = load %struct.tree_node** %tmp148		; <%struct.tree_node*> [#uses=1]
-	%tmp150 = cast %struct.tree_node* %tmp149 to %struct.tree_type*		; <%struct.tree_type*> [#uses=1]
-	%tmp151 = getelementptr %struct.tree_type* %tmp150, int 0, uint 6		; <ushort*> [#uses=1]
-	%tmp151 = cast ushort* %tmp151 to uint*		; <uint*> [#uses=1]
-	%tmp152 = load uint* %tmp151		; <uint> [#uses=1]
-	%tmp154 = shr uint %tmp152, ubyte 16		; <uint> [#uses=1]
-	%tmp154.mask = and uint %tmp154, 127		; <uint> [#uses=1]
-	%tmp155 = getelementptr [35 x ubyte]* %mode_class, int 0, uint %tmp154.mask		; <ubyte*> [#uses=1]
-	%tmp156 = load ubyte* %tmp155		; <ubyte> [#uses=1]
-	%tmp157 = seteq ubyte %tmp156, 4		; <bool> [#uses=1]
-	br bool %tmp157, label %cond_next241, label %cond_true158
-
+	%tmp150 = bitcast %struct.tree_node* %tmp149 to %struct.tree_type*		; <%struct.tree_type*> [#uses=1]
+	%tmp151 = getelementptr %struct.tree_type* %tmp150, i32 0, i32 6		; <i16*> [#uses=1]
+	%tmp151.upgrd.1 = bitcast i16* %tmp151 to i32*		; <i32*> [#uses=1]
+	%tmp152 = load i32* %tmp151.upgrd.1		; <i32> [#uses=1]
+	%tmp154 = lshr i32 %tmp152, 16		; <i32> [#uses=1]
+	%tmp154.mask = and i32 %tmp154, 127		; <i32> [#uses=1]
+	%gep.upgrd.2 = zext i32 %tmp154.mask to i64		; <i64> [#uses=1]
+	%tmp155 = getelementptr [35 x i8]* @mode_class, i32 0, i64 %gep.upgrd.2		; <i8*> [#uses=1]
+	%tmp156 = load i8* %tmp155		; <i8> [#uses=1]
+	%tmp157 = icmp eq i8 %tmp156, 4		; <i1> [#uses=1]
+	br i1 %tmp157, label %cond_next241, label %cond_true158
 cond_true158:		; preds = %bb145
 	%tmp172 = load %struct.tree_node** null		; <%struct.tree_node*> [#uses=1]
-	%tmp174 = getelementptr %struct.tree_node* %tmp172, int 0, uint 0, uint 0, uint 1		; <%struct.tree_node**> [#uses=1]
+	%tmp174 = getelementptr %struct.tree_node* %tmp172, i32 0, i32 0, i32 0, i32 1		; <%struct.tree_node**> [#uses=1]
 	%tmp175 = load %struct.tree_node** %tmp174		; <%struct.tree_node*> [#uses=1]
-	%tmp176 = cast %struct.tree_node* %tmp175 to %struct.tree_type*		; <%struct.tree_type*> [#uses=1]
-	%tmp177 = getelementptr %struct.tree_type* %tmp176, int 0, uint 6		; <ushort*> [#uses=1]
-	%tmp177 = cast ushort* %tmp177 to uint*		; <uint*> [#uses=1]
-	%tmp178 = load uint* %tmp177		; <uint> [#uses=1]
-	%tmp180 = shr uint %tmp178, ubyte 16		; <uint> [#uses=1]
-	%tmp180.mask = and uint %tmp180, 127		; <uint> [#uses=1]
-	%tmp181 = getelementptr [35 x ubyte]* %mode_class, int 0, uint %tmp180.mask		; <ubyte*> [#uses=1]
-	%tmp182 = load ubyte* %tmp181		; <ubyte> [#uses=1]
-	%tmp183 = seteq ubyte %tmp182, 8		; <bool> [#uses=1]
-	br bool %tmp183, label %cond_next241, label %cond_true184
-
+	%tmp176 = bitcast %struct.tree_node* %tmp175 to %struct.tree_type*		; <%struct.tree_type*> [#uses=1]
+	%tmp177 = getelementptr %struct.tree_type* %tmp176, i32 0, i32 6		; <i16*> [#uses=1]
+	%tmp177.upgrd.3 = bitcast i16* %tmp177 to i32*		; <i32*> [#uses=1]
+	%tmp178 = load i32* %tmp177.upgrd.3		; <i32> [#uses=1]
+	%tmp180 = lshr i32 %tmp178, 16		; <i32> [#uses=1]
+	%tmp180.mask = and i32 %tmp180, 127		; <i32> [#uses=1]
+	%gep.upgrd.4 = zext i32 %tmp180.mask to i64		; <i64> [#uses=1]
+	%tmp181 = getelementptr [35 x i8]* @mode_class, i32 0, i64 %gep.upgrd.4		; <i8*> [#uses=1]
+	%tmp182 = load i8* %tmp181		; <i8> [#uses=1]
+	%tmp183 = icmp eq i8 %tmp182, 8		; <i1> [#uses=1]
+	br i1 %tmp183, label %cond_next241, label %cond_true184
 cond_true184:		; preds = %cond_true158
 	%tmp185 = load %struct.tree_node** null		; <%struct.tree_node*> [#uses=1]
-	%tmp187 = getelementptr %struct.tree_node* %tmp185, int 0, uint 0, uint 0, uint 1		; <%struct.tree_node**> [#uses=1]
+	%tmp187 = getelementptr %struct.tree_node* %tmp185, i32 0, i32 0, i32 0, i32 1		; <%struct.tree_node**> [#uses=1]
 	%tmp188 = load %struct.tree_node** %tmp187		; <%struct.tree_node*> [#uses=1]
-	%tmp189 = cast %struct.tree_node* %tmp188 to %struct.tree_type*		; <%struct.tree_type*> [#uses=1]
-	%tmp190 = getelementptr %struct.tree_type* %tmp189, int 0, uint 6		; <ushort*> [#uses=1]
-	%tmp190 = cast ushort* %tmp190 to uint*		; <uint*> [#uses=1]
-	%tmp191 = load uint* %tmp190		; <uint> [#uses=1]
-	%tmp193 = shr uint %tmp191, ubyte 16		; <uint> [#uses=1]
-	%tmp193.mask = and uint %tmp193, 127		; <uint> [#uses=1]
-	%tmp194 = getelementptr [35 x ubyte]* %mode_class, int 0, uint %tmp193.mask		; <ubyte*> [#uses=1]
-	%tmp195 = load ubyte* %tmp194		; <ubyte> [#uses=1]
-	%tmp196 = seteq ubyte %tmp195, 4		; <bool> [#uses=1]
-	br bool %tmp196, label %cond_next241, label %cond_true197
-
+	%tmp189 = bitcast %struct.tree_node* %tmp188 to %struct.tree_type*		; <%struct.tree_type*> [#uses=1]
+	%tmp190 = getelementptr %struct.tree_type* %tmp189, i32 0, i32 6		; <i16*> [#uses=1]
+	%tmp190.upgrd.5 = bitcast i16* %tmp190 to i32*		; <i32*> [#uses=1]
+	%tmp191 = load i32* %tmp190.upgrd.5		; <i32> [#uses=1]
+	%tmp193 = lshr i32 %tmp191, 16		; <i32> [#uses=1]
+	%tmp193.mask = and i32 %tmp193, 127		; <i32> [#uses=1]
+	%gep.upgrd.6 = zext i32 %tmp193.mask to i64		; <i64> [#uses=1]
+	%tmp194 = getelementptr [35 x i8]* @mode_class, i32 0, i64 %gep.upgrd.6		; <i8*> [#uses=1]
+	%tmp195 = load i8* %tmp194		; <i8> [#uses=1]
+	%tmp196 = icmp eq i8 %tmp195, 4		; <i1> [#uses=1]
+	br i1 %tmp196, label %cond_next241, label %cond_true197
 cond_true197:		; preds = %cond_true184
 	ret void
-
 cond_next241:		; preds = %cond_true184, %cond_true158, %bb145
-	%tmp245 = load uint* null		; <uint> [#uses=0]
+	%tmp245 = load i32* null		; <i32> [#uses=0]
 	ret void
-
 bb276:		; preds = %entry
 	ret void
 }
diff --git a/test/Transforms/SimplifyCFG/2006-10-19-UncondDiv.ll b/test/Transforms/SimplifyCFG/2006-10-19-UncondDiv.ll
index 26fce45..7165c5b 100644
--- a/test/Transforms/SimplifyCFG/2006-10-19-UncondDiv.ll
+++ b/test/Transforms/SimplifyCFG/2006-10-19-UncondDiv.ll
@@ -1,34 +1,26 @@
 ; PR957
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis | \
 ; RUN:   not grep select
 
-uint %test(uint %tmp) {
-cond_false179:          ; preds = %cond_true
-        %tmp181 = seteq uint %tmp, 0            ; <bool> [#uses=1]
-        br bool %tmp181, label %cond_true182, label %cond_next185
-
-cond_true182:           ; preds = %cond_false179
-        br label %cond_next185
-
-cond_next185:           ; preds = %cond_true182, %cond_false179
-        %d0.3 = phi uint [ div (uint 1, uint 0), %cond_true182 ], [ %tmp,
-%cond_false179 ]                ; <uint> [#uses=7]
-
-        ret uint %d0.3
+define i32 @test(i32 %tmp) {
+cond_false179:
+	%tmp181 = icmp eq i32 %tmp, 0		; <i1> [#uses=1]
+	br i1 %tmp181, label %cond_true182, label %cond_next185
+cond_true182:		; preds = %cond_false179
+	br label %cond_next185
+cond_next185:		; preds = %cond_true182, %cond_false179
+	%d0.3 = phi i32 [ udiv (i32 1, i32 0), %cond_true182 ], [ %tmp, %cond_false179 ]		; <i32> [#uses=1]
+	ret i32 %d0.3
 }
 
-uint %test2(uint %tmp) {
-cond_false179:          ; preds = %cond_true
-        %tmp181 = seteq uint %tmp, 0            ; <bool> [#uses=1]
-        br bool %tmp181, label %cond_true182, label %cond_next185
-
-cond_true182:           ; preds = %cond_false179
-        br label %cond_next185
-
-cond_next185:           ; preds = %cond_true182, %cond_false179
-        %d0.3 = phi uint [ div (uint 1, uint 0), %cond_true182 ], [ %tmp,
-%cond_false179 ]                ; <uint> [#uses=7]
-	call uint %test(uint 4)
-        ret uint %d0.3
+define i32 @test2(i32 %tmp) {
+cond_false179:
+	%tmp181 = icmp eq i32 %tmp, 0		; <i1> [#uses=1]
+	br i1 %tmp181, label %cond_true182, label %cond_next185
+cond_true182:		; preds = %cond_false179
+	br label %cond_next185
+cond_next185:		; preds = %cond_true182, %cond_false179
+	%d0.3 = phi i32 [ udiv (i32 1, i32 0), %cond_true182 ], [ %tmp, %cond_false179 ]		; <i32> [#uses=1]
+	call i32 @test( i32 4 )		; <i32>:0 [#uses=0]
+	ret i32 %d0.3
 }
-
diff --git a/test/Transforms/SimplifyCFG/2006-10-29-InvokeCrash.ll b/test/Transforms/SimplifyCFG/2006-10-29-InvokeCrash.ll
index d067ac0..f22ca6c 100644
--- a/test/Transforms/SimplifyCFG/2006-10-29-InvokeCrash.ll
+++ b/test/Transforms/SimplifyCFG/2006-10-29-InvokeCrash.ll
@@ -1,60 +1,58 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg -disable-output
-
+; RUN: llvm-as < %s | opt -simplifycfg -disable-output
+; END.
 	%struct..4._102 = type { %struct.QVectorData* }
 	%struct..5._125 = type { %struct.QMapData* }
 	%struct.QAbstractTextDocumentLayout = type { %struct.QObject }
-	%struct.QBasicAtomic = type { int }
-	%struct.QFont = type { %struct.QFontPrivate*, uint }
+	%struct.QBasicAtomic = type { i32 }
+	%struct.QFont = type { %struct.QFontPrivate*, i32 }
 	%struct.QFontMetrics = type { %struct.QFontPrivate* }
 	%struct.QFontPrivate = type opaque
-	"struct.QFragmentMap<QTextBlockData>" = type { %struct.QFragmentMapData }
-	%struct.QFragmentMapData = type { "struct.QFragmentMapData::._154", int }
-	"struct.QFragmentMapData::._154" = type { "struct.QFragmentMapData::Header"* }
-	"struct.QFragmentMapData::Header" = type { uint, uint, uint, uint, uint, uint, uint, uint }
-	"struct.QHash<uint,QHashDummyValue>" = type { "struct.QHash<uint,QHashDummyValue>::._152" }
-	"struct.QHash<uint,QHashDummyValue>::._152" = type { %struct.QHashData* }
-	%struct.QHashData = type { "struct.QHashData::Node"*, "struct.QHashData::Node"**, %struct.QBasicAtomic, int, int, short, short, int, ubyte }
-	"struct.QHashData::Node" = type { "struct.QHashData::Node"*, uint }
-	"struct.QList<QObject*>::._92" = type { %struct.QListData }
-	"struct.QList<QPointer<QObject> >" = type { "struct.QList<QObject*>::._92" }
-	%struct.QListData = type { "struct.QListData::Data"* }
-	"struct.QListData::Data" = type { %struct.QBasicAtomic, int, int, int, ubyte, [1 x sbyte*] }
-	"struct.QMap<QUrl,QVariant>" = type { %struct..5._125 }
-	%struct.QMapData = type { "struct.QMapData::Node"*, [12 x "struct.QMapData::Node"*], %struct.QBasicAtomic, int, int, uint, ubyte }
-	"struct.QMapData::Node" = type { "struct.QMapData::Node"*, [1 x "struct.QMapData::Node"*] }
-	%struct.QObject = type { int (...)**, %struct.QObjectData* }
-	%struct.QObjectData = type { int (...)**, %struct.QObject*, %struct.QObject*, "struct.QList<QPointer<QObject> >", ubyte, [3 x ubyte], int, int }
-	%struct.QObjectPrivate = type { %struct.QObjectData, int, %struct.QObject*, "struct.QList<QPointer<QObject> >", "struct.QVector<QAbstractTextDocumentLayout::Selection>", %struct.QString }
-	%struct.QPaintDevice = type { int (...)**, ushort }
+	%"struct.QFragmentMap<QTextBlockData>" = type { %struct.QFragmentMapData }
+	%struct.QFragmentMapData = type { %"struct.QFragmentMapData::._154", i32 }
+	%"struct.QFragmentMapData::._154" = type { %"struct.QFragmentMapData::Header"* }
+	%"struct.QFragmentMapData::Header" = type { i32, i32, i32, i32, i32, i32, i32, i32 }
+	%"struct.QHash<uint,QHashDummyValue>" = type { %"struct.QHash<uint,QHashDummyValue>::._152" }
+	%"struct.QHash<uint,QHashDummyValue>::._152" = type { %struct.QHashData* }
+	%struct.QHashData = type { %"struct.QHashData::Node"*, %"struct.QHashData::Node"**, %struct.QBasicAtomic, i32, i32, i16, i16, i32, i8 }
+	%"struct.QHashData::Node" = type { %"struct.QHashData::Node"*, i32 }
+	%"struct.QList<QObject*>::._92" = type { %struct.QListData }
+	%"struct.QList<QPointer<QObject> >" = type { %"struct.QList<QObject*>::._92" }
+	%struct.QListData = type { %"struct.QListData::Data"* }
+	%"struct.QListData::Data" = type { %struct.QBasicAtomic, i32, i32, i32, i8, [1 x i8*] }
+	%"struct.QMap<QUrl,QVariant>" = type { %struct..5._125 }
+	%struct.QMapData = type { %"struct.QMapData::Node"*, [12 x %"struct.QMapData::Node"*], %struct.QBasicAtomic, i32, i32, i32, i8 }
+	%"struct.QMapData::Node" = type { %"struct.QMapData::Node"*, [1 x %"struct.QMapData::Node"*] }
+	%struct.QObject = type { i32 (...)**, %struct.QObjectData* }
+	%struct.QObjectData = type { i32 (...)**, %struct.QObject*, %struct.QObject*, %"struct.QList<QPointer<QObject> >", i8, [3 x i8], i32, i32 }
+	%struct.QObjectPrivate = type { %struct.QObjectData, i32, %struct.QObject*, %"struct.QList<QPointer<QObject> >", %"struct.QVector<QAbstractTextDocumentLayout::Selection>", %struct.QString }
+	%struct.QPaintDevice = type { i32 (...)**, i16 }
 	%struct.QPainter = type { %struct.QPainterPrivate* }
 	%struct.QPainterPrivate = type opaque
 	%struct.QPointF = type { double, double }
 	%struct.QPrinter = type { %struct.QPaintDevice, %struct.QPrinterPrivate* }
 	%struct.QPrinterPrivate = type opaque
 	%struct.QRectF = type { double, double, double, double }
-	"struct.QSet<uint>" = type { "struct.QHash<uint,QHashDummyValue>" }
-	"struct.QSharedDataPointer<QTextFormatPrivate>" = type { %struct.QTextFormatPrivate* }
-	%struct.QString = type { "struct.QString::Data"* }
-	"struct.QString::Data" = type { %struct.QBasicAtomic, int, int, ushort*, ubyte, ubyte, [1 x ushort] }
+	%"struct.QSet<uint>" = type { %"struct.QHash<uint,QHashDummyValue>" }
+	%"struct.QSharedDataPointer<QTextFormatPrivate>" = type { %struct.QTextFormatPrivate* }
+	%struct.QString = type { %"struct.QString::Data"* }
+	%"struct.QString::Data" = type { %struct.QBasicAtomic, i32, i32, i16*, i8, i8, [1 x i16] }
 	%struct.QTextBlockFormat = type { %struct.QTextFormat }
 	%struct.QTextBlockGroup = type { %struct.QAbstractTextDocumentLayout }
 	%struct.QTextDocumentConfig = type { %struct.QString }
-	%struct.QTextDocumentPrivate = type { %struct.QObjectPrivate, %struct.QString, "struct.QVector<QAbstractTextDocumentLayout::Selection>", bool, int, int, bool, int, int, int, int, bool, %struct.QTextFormatCollection, %struct.QTextBlockGroup*, %struct.QAbstractTextDocumentLayout*, "struct.QFragmentMap<QTextBlockData>", "struct.QFragmentMap<QTextBlockData>", int, "struct.QList<QPointer<QObject> >", "struct.QList<QPointer<QObject> >", "struct.QMap<QUrl,QVariant>", "struct.QMap<QUrl,QVariant>", "struct.QMap<QUrl,QVariant>", %struct.QTextDocumentConfig, bool, bool, %struct.QPointF }
-	%struct.QTextFormat = type { "struct.QSharedDataPointer<QTextFormatPrivate>", int }
-	%struct.QTextFormatCollection = type { "struct.QVector<QAbstractTextDocumentLayout::Selection>", "struct.QVector<QAbstractTextDocumentLayout::Selection>", "struct.QSet<uint>", %struct.QFont }
+	%struct.QTextDocumentPrivate = type { %struct.QObjectPrivate, %struct.QString, %"struct.QVector<QAbstractTextDocumentLayout::Selection>", i1, i32, i32, i1, i32, i32, i32, i32, i1, %struct.QTextFormatCollection, %struct.QTextBlockGroup*, %struct.QAbstractTextDocumentLayout*, %"struct.QFragmentMap<QTextBlockData>", %"struct.QFragmentMap<QTextBlockData>", i32, %"struct.QList<QPointer<QObject> >", %"struct.QList<QPointer<QObject> >", %"struct.QMap<QUrl,QVariant>", %"struct.QMap<QUrl,QVariant>", %"struct.QMap<QUrl,QVariant>", %struct.QTextDocumentConfig, i1, i1, %struct.QPointF }
+	%struct.QTextFormat = type { %"struct.QSharedDataPointer<QTextFormatPrivate>", i32 }
+	%struct.QTextFormatCollection = type { %"struct.QVector<QAbstractTextDocumentLayout::Selection>", %"struct.QVector<QAbstractTextDocumentLayout::Selection>", %"struct.QSet<uint>", %struct.QFont }
 	%struct.QTextFormatPrivate = type opaque
-	"struct.QVector<QAbstractTextDocumentLayout::Selection>" = type { %struct..4._102 }
-	%struct.QVectorData = type { %struct.QBasicAtomic, int, int, ubyte }
+	%"struct.QVector<QAbstractTextDocumentLayout::Selection>" = type { %struct..4._102 }
+	%struct.QVectorData = type { %struct.QBasicAtomic, i32, i32, i8 }
 
-implementation   ; Functions:
-
-void %_ZNK13QTextDocument5printEP8QPrinter(%struct.QAbstractTextDocumentLayout* %this, %struct.QPrinter* %printer) {
+define void @_ZNK13QTextDocument5printEP8QPrinter(%struct.QAbstractTextDocumentLayout* %this, %struct.QPrinter* %printer) {
 entry:
 	%tmp = alloca %struct.QPointF, align 16		; <%struct.QPointF*> [#uses=2]
-	%tmp = alloca %struct.QRectF, align 16		; <%struct.QRectF*> [#uses=5]
+	%tmp.upgrd.1 = alloca %struct.QRectF, align 16		; <%struct.QRectF*> [#uses=5]
 	%tmp2 = alloca %struct.QPointF, align 16		; <%struct.QPointF*> [#uses=3]
-	%tmp = alloca %struct.QFontMetrics, align 16		; <%struct.QFontMetrics*> [#uses=4]
-	%tmp = alloca %struct.QFont, align 16		; <%struct.QFont*> [#uses=4]
+	%tmp.upgrd.2 = alloca %struct.QFontMetrics, align 16		; <%struct.QFontMetrics*> [#uses=4]
+	%tmp.upgrd.3 = alloca %struct.QFont, align 16		; <%struct.QFont*> [#uses=4]
 	%tmp3 = alloca %struct.QPointF, align 16		; <%struct.QPointF*> [#uses=2]
 	%p = alloca %struct.QPainter, align 16		; <%struct.QPainter*> [#uses=14]
 	%body = alloca %struct.QRectF, align 16		; <%struct.QRectF*> [#uses=9]
@@ -63,590 +61,495 @@
 	%printerPageSize = alloca %struct.QPointF, align 16		; <%struct.QPointF*> [#uses=3]
 	%fmt = alloca %struct.QTextBlockFormat, align 16		; <%struct.QTextBlockFormat*> [#uses=5]
 	%font = alloca %struct.QFont, align 16		; <%struct.QFont*> [#uses=5]
-	%tmp = call %struct.QTextDocumentPrivate* %_ZNK13QTextDocument6d_funcEv( %struct.QAbstractTextDocumentLayout* %this )		; <%struct.QTextDocumentPrivate*> [#uses=5]
-	%tmp = getelementptr %struct.QPrinter* %printer, int 0, uint 0		; <%struct.QPaintDevice*> [#uses=1]
-	call void %_ZN8QPainterC1EP12QPaintDevice( %struct.QPainter* %p, %struct.QPaintDevice* %tmp )
-	%tmp = invoke bool %_ZNK8QPainter8isActiveEv( %struct.QPainter* %p )
-			to label %invcont unwind label %cleanup329		; <bool> [#uses=1]
-
+	%tmp.upgrd.4 = call %struct.QTextDocumentPrivate* @_ZNK13QTextDocument6d_funcEv( %struct.QAbstractTextDocumentLayout* %this )		; <%struct.QTextDocumentPrivate*> [#uses=5]
+	%tmp.upgrd.5 = getelementptr %struct.QPrinter* %printer, i32 0, i32 0		; <%struct.QPaintDevice*> [#uses=1]
+	call void @_ZN8QPainterC1EP12QPaintDevice( %struct.QPainter* %p, %struct.QPaintDevice* %tmp.upgrd.5 )
+	%tmp.upgrd.6 = invoke i1 @_ZNK8QPainter8isActiveEv( %struct.QPainter* %p )
+			to label %invcont unwind label %cleanup329		; <i1> [#uses=1]
 invcont:		; preds = %entry
-	br bool %tmp, label %cond_next, label %cleanup328
-
+	br i1 %tmp.upgrd.6, label %cond_next, label %cleanup328
 cond_next:		; preds = %invcont
-	%tmp8 = invoke %struct.QAbstractTextDocumentLayout* %_ZNK13QTextDocument14documentLayoutEv( %struct.QAbstractTextDocumentLayout* %this )
+	%tmp8 = invoke %struct.QAbstractTextDocumentLayout* @_ZNK13QTextDocument14documentLayoutEv( %struct.QAbstractTextDocumentLayout* %this )
 			to label %invcont7 unwind label %cleanup329		; <%struct.QAbstractTextDocumentLayout*> [#uses=0]
-
 invcont7:		; preds = %cond_next
-	%tmp10 = getelementptr %struct.QTextDocumentPrivate* %tmp, int 0, uint 26		; <%struct.QPointF*> [#uses=1]
-	call void %_ZN7QPointFC1Edd( %struct.QPointF* %tmp, double 0.000000e+00, double 0.000000e+00 )
-	call void %_ZN6QRectFC1ERK7QPointFRK6QSizeF( %struct.QRectF* %body, %struct.QPointF* %tmp, %struct.QPointF* %tmp10 )
-	call void %_ZN7QPointFC1Ev( %struct.QPointF* %pageNumberPos )
-	%tmp12 = getelementptr %struct.QTextDocumentPrivate* %tmp, int 0, uint 26		; <%struct.QPointF*> [#uses=1]
-	%tmp13 = call bool %_ZNK6QSizeF7isValidEv( %struct.QPointF* %tmp12 )		; <bool> [#uses=1]
-	br bool %tmp13, label %cond_next15, label %bb
-
+	%tmp10 = getelementptr %struct.QTextDocumentPrivate* %tmp.upgrd.4, i32 0, i32 26		; <%struct.QPointF*> [#uses=1]
+	call void @_ZN7QPointFC1Edd( %struct.QPointF* %tmp, double 0.000000e+00, double 0.000000e+00 )
+	call void @_ZN6QRectFC1ERK7QPointFRK6QSizeF( %struct.QRectF* %body, %struct.QPointF* %tmp, %struct.QPointF* %tmp10 )
+	call void @_ZN7QPointFC1Ev( %struct.QPointF* %pageNumberPos )
+	%tmp12 = getelementptr %struct.QTextDocumentPrivate* %tmp.upgrd.4, i32 0, i32 26		; <%struct.QPointF*> [#uses=1]
+	%tmp13 = call i1 @_ZNK6QSizeF7isValidEv( %struct.QPointF* %tmp12 )		; <i1> [#uses=1]
+	br i1 %tmp13, label %cond_next15, label %bb
 cond_next15:		; preds = %invcont7
-	%tmp17 = getelementptr %struct.QTextDocumentPrivate* %tmp, int 0, uint 26		; <%struct.QPointF*> [#uses=1]
-	%tmp = call double %_ZNK6QSizeF6heightEv( %struct.QPointF* %tmp17 )		; <double> [#uses=1]
-	%tmp18 = seteq double %tmp, 0x41DFFFFFFFC00000		; <bool> [#uses=1]
-	br bool %tmp18, label %bb, label %cond_next20
-
+	%tmp17 = getelementptr %struct.QTextDocumentPrivate* %tmp.upgrd.4, i32 0, i32 26		; <%struct.QPointF*> [#uses=1]
+	%tmp.upgrd.7 = call double @_ZNK6QSizeF6heightEv( %struct.QPointF* %tmp17 )		; <double> [#uses=1]
+	%tmp18 = fcmp oeq double %tmp.upgrd.7, 0x41DFFFFFFFC00000		; <i1> [#uses=1]
+	br i1 %tmp18, label %bb, label %cond_next20
 cond_next20:		; preds = %cond_next15
 	br label %bb21
-
 bb:		; preds = %cond_next15, %invcont7
 	br label %bb21
-
 bb21:		; preds = %bb, %cond_next20
-	%iftmp.406.0 = phi bool [ false, %bb ], [ true, %cond_next20 ]		; <bool> [#uses=1]
-	br bool %iftmp.406.0, label %cond_true24, label %cond_false
-
+	%iftmp.406.0 = phi i1 [ false, %bb ], [ true, %cond_next20 ]		; <i1> [#uses=1]
+	br i1 %iftmp.406.0, label %cond_true24, label %cond_false
 cond_true24:		; preds = %bb21
-	%tmp = invoke int %_Z13qt_defaultDpiv( )
-			to label %invcont25 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp.upgrd.8 = invoke i32 @_Z13qt_defaultDpiv( )
+			to label %invcont25 unwind label %cleanup329		; <i32> [#uses=1]
 invcont25:		; preds = %cond_true24
-	%tmp26 = cast int %tmp to double		; <double> [#uses=2]
-	%tmp30 = invoke %struct.QAbstractTextDocumentLayout* %_ZNK13QTextDocument14documentLayoutEv( %struct.QAbstractTextDocumentLayout* %this )
+	%tmp26 = sitofp i32 %tmp.upgrd.8 to double		; <double> [#uses=2]
+	%tmp30 = invoke %struct.QAbstractTextDocumentLayout* @_ZNK13QTextDocument14documentLayoutEv( %struct.QAbstractTextDocumentLayout* %this )
 			to label %invcont29 unwind label %cleanup329		; <%struct.QAbstractTextDocumentLayout*> [#uses=1]
-
 invcont29:		; preds = %invcont25
-	%tmp32 = invoke %struct.QPaintDevice* %_ZNK27QAbstractTextDocumentLayout11paintDeviceEv( %struct.QAbstractTextDocumentLayout* %tmp30 )
+	%tmp32 = invoke %struct.QPaintDevice* @_ZNK27QAbstractTextDocumentLayout11paintDeviceEv( %struct.QAbstractTextDocumentLayout* %tmp30 )
 			to label %invcont31 unwind label %cleanup329		; <%struct.QPaintDevice*> [#uses=3]
-
 invcont31:		; preds = %invcont29
-	%tmp34 = seteq %struct.QPaintDevice* %tmp32, null		; <bool> [#uses=1]
-	br bool %tmp34, label %cond_next42, label %cond_true35
-
+	%tmp34 = icmp eq %struct.QPaintDevice* %tmp32, null		; <i1> [#uses=1]
+	br i1 %tmp34, label %cond_next42, label %cond_true35
 cond_true35:		; preds = %invcont31
-	%tmp38 = invoke int %_ZNK12QPaintDevice11logicalDpiXEv( %struct.QPaintDevice* %tmp32 )
-			to label %invcont37 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp38 = invoke i32 @_ZNK12QPaintDevice11logicalDpiXEv( %struct.QPaintDevice* %tmp32 )
+			to label %invcont37 unwind label %cleanup329		; <i32> [#uses=1]
 invcont37:		; preds = %cond_true35
-	%tmp38 = cast int %tmp38 to double		; <double> [#uses=1]
-	%tmp41 = invoke int %_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp32 )
-			to label %invcont40 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp38.upgrd.9 = sitofp i32 %tmp38 to double		; <double> [#uses=1]
+	%tmp41 = invoke i32 @_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp32 )
+			to label %invcont40 unwind label %cleanup329		; <i32> [#uses=1]
 invcont40:		; preds = %invcont37
-	%tmp41 = cast int %tmp41 to double		; <double> [#uses=1]
+	%tmp41.upgrd.10 = sitofp i32 %tmp41 to double		; <double> [#uses=1]
 	br label %cond_next42
-
 cond_next42:		; preds = %invcont40, %invcont31
-	%sourceDpiY.2 = phi double [ %tmp41, %invcont40 ], [ %tmp26, %invcont31 ]		; <double> [#uses=1]
-	%sourceDpiX.2 = phi double [ %tmp38, %invcont40 ], [ %tmp26, %invcont31 ]		; <double> [#uses=1]
-	%tmp44 = getelementptr %struct.QPrinter* %printer, int 0, uint 0		; <%struct.QPaintDevice*> [#uses=1]
-	%tmp46 = invoke int %_ZNK12QPaintDevice11logicalDpiXEv( %struct.QPaintDevice* %tmp44 )
-			to label %invcont45 unwind label %cleanup329		; <int> [#uses=1]
-
+	%sourceDpiY.2 = phi double [ %tmp41.upgrd.10, %invcont40 ], [ %tmp26, %invcont31 ]		; <double> [#uses=1]
+	%sourceDpiX.2 = phi double [ %tmp38.upgrd.9, %invcont40 ], [ %tmp26, %invcont31 ]		; <double> [#uses=1]
+	%tmp44 = getelementptr %struct.QPrinter* %printer, i32 0, i32 0		; <%struct.QPaintDevice*> [#uses=1]
+	%tmp46 = invoke i32 @_ZNK12QPaintDevice11logicalDpiXEv( %struct.QPaintDevice* %tmp44 )
+			to label %invcont45 unwind label %cleanup329		; <i32> [#uses=1]
 invcont45:		; preds = %cond_next42
-	%tmp46 = cast int %tmp46 to double		; <double> [#uses=1]
-	%tmp48 = fdiv double %tmp46, %sourceDpiX.2		; <double> [#uses=2]
-	%tmp50 = getelementptr %struct.QPrinter* %printer, int 0, uint 0		; <%struct.QPaintDevice*> [#uses=1]
-	%tmp52 = invoke int %_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp50 )
-			to label %invcont51 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp46.upgrd.11 = sitofp i32 %tmp46 to double		; <double> [#uses=1]
+	%tmp48 = fdiv double %tmp46.upgrd.11, %sourceDpiX.2		; <double> [#uses=2]
+	%tmp50 = getelementptr %struct.QPrinter* %printer, i32 0, i32 0		; <%struct.QPaintDevice*> [#uses=1]
+	%tmp52 = invoke i32 @_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp50 )
+			to label %invcont51 unwind label %cleanup329		; <i32> [#uses=1]
 invcont51:		; preds = %invcont45
-	%tmp52 = cast int %tmp52 to double		; <double> [#uses=1]
-	%tmp54 = fdiv double %tmp52, %sourceDpiY.2		; <double> [#uses=2]
-	invoke void %_ZN8QPainter5scaleEdd( %struct.QPainter* %p, double %tmp48, double %tmp54 )
+	%tmp52.upgrd.12 = sitofp i32 %tmp52 to double		; <double> [#uses=1]
+	%tmp54 = fdiv double %tmp52.upgrd.12, %sourceDpiY.2		; <double> [#uses=2]
+	invoke void @_ZN8QPainter5scaleEdd( %struct.QPainter* %p, double %tmp48, double %tmp54 )
 			to label %invcont57 unwind label %cleanup329
-
 invcont57:		; preds = %invcont51
-	%tmp = getelementptr %struct.QPointF* %scaledPageSize, int 0, uint 0		; <double*> [#uses=1]
-	%tmp60 = getelementptr %struct.QTextDocumentPrivate* %tmp, int 0, uint 26, uint 0		; <double*> [#uses=1]
+	%tmp.upgrd.13 = getelementptr %struct.QPointF* %scaledPageSize, i32 0, i32 0		; <double*> [#uses=1]
+	%tmp60 = getelementptr %struct.QTextDocumentPrivate* %tmp.upgrd.4, i32 0, i32 26, i32 0		; <double*> [#uses=1]
 	%tmp61 = load double* %tmp60		; <double> [#uses=1]
-	store double %tmp61, double* %tmp
-	%tmp62 = getelementptr %struct.QPointF* %scaledPageSize, int 0, uint 1		; <double*> [#uses=1]
-	%tmp63 = getelementptr %struct.QTextDocumentPrivate* %tmp, int 0, uint 26, uint 1		; <double*> [#uses=1]
+	store double %tmp61, double* %tmp.upgrd.13
+	%tmp62 = getelementptr %struct.QPointF* %scaledPageSize, i32 0, i32 1		; <double*> [#uses=1]
+	%tmp63 = getelementptr %struct.QTextDocumentPrivate* %tmp.upgrd.4, i32 0, i32 26, i32 1		; <double*> [#uses=1]
 	%tmp64 = load double* %tmp63		; <double> [#uses=1]
 	store double %tmp64, double* %tmp62
-	%tmp65 = call double* %_ZN6QSizeF6rwidthEv( %struct.QPointF* %scaledPageSize )		; <double*> [#uses=2]
+	%tmp65 = call double* @_ZN6QSizeF6rwidthEv( %struct.QPointF* %scaledPageSize )		; <double*> [#uses=2]
 	%tmp67 = load double* %tmp65		; <double> [#uses=1]
 	%tmp69 = mul double %tmp67, %tmp48		; <double> [#uses=1]
 	store double %tmp69, double* %tmp65
-	%tmp71 = call double* %_ZN6QSizeF7rheightEv( %struct.QPointF* %scaledPageSize )		; <double*> [#uses=2]
+	%tmp71 = call double* @_ZN6QSizeF7rheightEv( %struct.QPointF* %scaledPageSize )		; <double*> [#uses=2]
 	%tmp73 = load double* %tmp71		; <double> [#uses=1]
 	%tmp75 = mul double %tmp73, %tmp54		; <double> [#uses=1]
 	store double %tmp75, double* %tmp71
-	%tmp78 = getelementptr %struct.QPrinter* %printer, int 0, uint 0		; <%struct.QPaintDevice*> [#uses=1]
-	%tmp80 = invoke int %_ZNK12QPaintDevice6heightEv( %struct.QPaintDevice* %tmp78 )
-			to label %invcont79 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp78 = getelementptr %struct.QPrinter* %printer, i32 0, i32 0		; <%struct.QPaintDevice*> [#uses=1]
+	%tmp80 = invoke i32 @_ZNK12QPaintDevice6heightEv( %struct.QPaintDevice* %tmp78 )
+			to label %invcont79 unwind label %cleanup329		; <i32> [#uses=1]
 invcont79:		; preds = %invcont57
-	%tmp82 = getelementptr %struct.QPrinter* %printer, int 0, uint 0		; <%struct.QPaintDevice*> [#uses=1]
-	%tmp84 = invoke int %_ZNK12QPaintDevice5widthEv( %struct.QPaintDevice* %tmp82 )
-			to label %invcont83 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp82 = getelementptr %struct.QPrinter* %printer, i32 0, i32 0		; <%struct.QPaintDevice*> [#uses=1]
+	%tmp84 = invoke i32 @_ZNK12QPaintDevice5widthEv( %struct.QPaintDevice* %tmp82 )
+			to label %invcont83 unwind label %cleanup329		; <i32> [#uses=1]
 invcont83:		; preds = %invcont79
-	%tmp80 = cast int %tmp80 to double		; <double> [#uses=1]
-	%tmp84 = cast int %tmp84 to double		; <double> [#uses=1]
-	call void %_ZN6QSizeFC1Edd( %struct.QPointF* %printerPageSize, double %tmp84, double %tmp80 )
-	%tmp85 = call double %_ZNK6QSizeF6heightEv( %struct.QPointF* %printerPageSize )		; <double> [#uses=1]
-	%tmp86 = call double %_ZNK6QSizeF6heightEv( %struct.QPointF* %scaledPageSize )		; <double> [#uses=1]
+	%tmp80.upgrd.14 = sitofp i32 %tmp80 to double		; <double> [#uses=1]
+	%tmp84.upgrd.15 = sitofp i32 %tmp84 to double		; <double> [#uses=1]
+	call void @_ZN6QSizeFC1Edd( %struct.QPointF* %printerPageSize, double %tmp84.upgrd.15, double %tmp80.upgrd.14 )
+	%tmp85 = call double @_ZNK6QSizeF6heightEv( %struct.QPointF* %printerPageSize )		; <double> [#uses=1]
+	%tmp86 = call double @_ZNK6QSizeF6heightEv( %struct.QPointF* %scaledPageSize )		; <double> [#uses=1]
 	%tmp87 = fdiv double %tmp85, %tmp86		; <double> [#uses=1]
-	%tmp88 = call double %_ZNK6QSizeF5widthEv( %struct.QPointF* %printerPageSize )		; <double> [#uses=1]
-	%tmp89 = call double %_ZNK6QSizeF5widthEv( %struct.QPointF* %scaledPageSize )		; <double> [#uses=1]
+	%tmp88 = call double @_ZNK6QSizeF5widthEv( %struct.QPointF* %printerPageSize )		; <double> [#uses=1]
+	%tmp89 = call double @_ZNK6QSizeF5widthEv( %struct.QPointF* %scaledPageSize )		; <double> [#uses=1]
 	%tmp90 = fdiv double %tmp88, %tmp89		; <double> [#uses=1]
-	invoke void %_ZN8QPainter5scaleEdd( %struct.QPainter* %p, double %tmp90, double %tmp87 )
+	invoke void @_ZN8QPainter5scaleEdd( %struct.QPainter* %p, double %tmp90, double %tmp87 )
 			to label %cond_next194 unwind label %cleanup329
-
 cond_false:		; preds = %bb21
-	%tmp = getelementptr %struct.QAbstractTextDocumentLayout* %this, int 0, uint 0		; <%struct.QObject*> [#uses=1]
-	%tmp95 = invoke %struct.QAbstractTextDocumentLayout* %_ZNK13QTextDocument5cloneEP7QObject( %struct.QAbstractTextDocumentLayout* %this, %struct.QObject* %tmp )
+	%tmp.upgrd.16 = getelementptr %struct.QAbstractTextDocumentLayout* %this, i32 0, i32 0		; <%struct.QObject*> [#uses=1]
+	%tmp95 = invoke %struct.QAbstractTextDocumentLayout* @_ZNK13QTextDocument5cloneEP7QObject( %struct.QAbstractTextDocumentLayout* %this, %struct.QObject* %tmp.upgrd.16 )
 			to label %invcont94 unwind label %cleanup329		; <%struct.QAbstractTextDocumentLayout*> [#uses=9]
-
 invcont94:		; preds = %cond_false
-	%tmp99 = invoke %struct.QAbstractTextDocumentLayout* %_ZNK13QTextDocument14documentLayoutEv( %struct.QAbstractTextDocumentLayout* %tmp95 )
+	%tmp99 = invoke %struct.QAbstractTextDocumentLayout* @_ZNK13QTextDocument14documentLayoutEv( %struct.QAbstractTextDocumentLayout* %tmp95 )
 			to label %invcont98 unwind label %cleanup329		; <%struct.QAbstractTextDocumentLayout*> [#uses=1]
-
 invcont98:		; preds = %invcont94
-	%tmp101 = invoke %struct.QPaintDevice* %_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
+	%tmp101 = invoke %struct.QPaintDevice* @_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
 			to label %invcont100 unwind label %cleanup329		; <%struct.QPaintDevice*> [#uses=1]
-
 invcont100:		; preds = %invcont98
-	invoke void %_ZN27QAbstractTextDocumentLayout14setPaintDeviceEP12QPaintDevice( %struct.QAbstractTextDocumentLayout* %tmp99, %struct.QPaintDevice* %tmp101 )
+	invoke void @_ZN27QAbstractTextDocumentLayout14setPaintDeviceEP12QPaintDevice( %struct.QAbstractTextDocumentLayout* %tmp99, %struct.QPaintDevice* %tmp101 )
 			to label %invcont103 unwind label %cleanup329
-
 invcont103:		; preds = %invcont100
-	%tmp105 = invoke %struct.QPaintDevice* %_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
+	%tmp105 = invoke %struct.QPaintDevice* @_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
 			to label %invcont104 unwind label %cleanup329		; <%struct.QPaintDevice*> [#uses=1]
-
 invcont104:		; preds = %invcont103
-	%tmp107 = invoke int %_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp105 )
-			to label %invcont106 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp107 = invoke i32 @_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp105 )
+			to label %invcont106 unwind label %cleanup329		; <i32> [#uses=1]
 invcont106:		; preds = %invcont104
-	%tmp108 = cast int %tmp107 to double		; <double> [#uses=1]
+	%tmp108 = sitofp i32 %tmp107 to double		; <double> [#uses=1]
 	%tmp109 = mul double %tmp108, 0x3FE93264C993264C		; <double> [#uses=1]
-	%tmp109 = cast double %tmp109 to int		; <int> [#uses=3]
-	%tmp = call %struct.QTextBlockGroup* %_ZNK13QTextDocument9rootFrameEv( %struct.QAbstractTextDocumentLayout* %tmp95 )		; <%struct.QTextBlockGroup*> [#uses=1]
-	invoke csretcc void %_ZNK10QTextFrame11frameFormatEv( %struct.QTextBlockFormat* %fmt, %struct.QTextBlockGroup* %tmp )
+	%tmp109.upgrd.17 = fptosi double %tmp109 to i32		; <i32> [#uses=3]
+	%tmp.upgrd.18 = call %struct.QTextBlockGroup* @_ZNK13QTextDocument9rootFrameEv( %struct.QAbstractTextDocumentLayout* %tmp95 )		; <%struct.QTextBlockGroup*> [#uses=1]
+	invoke void @_ZNK10QTextFrame11frameFormatEv( %struct.QTextBlockFormat* sret  %fmt, %struct.QTextBlockGroup* %tmp.upgrd.18 )
 			to label %invcont111 unwind label %cleanup329
-
 invcont111:		; preds = %invcont106
-	%tmp112 = cast int %tmp109 to double		; <double> [#uses=1]
-	invoke void %_ZN16QTextFrameFormat9setMarginEd( %struct.QTextBlockFormat* %fmt, double %tmp112 )
+	%tmp112 = sitofp i32 %tmp109.upgrd.17 to double		; <double> [#uses=1]
+	invoke void @_ZN16QTextFrameFormat9setMarginEd( %struct.QTextBlockFormat* %fmt, double %tmp112 )
 			to label %invcont114 unwind label %cleanup192
-
 invcont114:		; preds = %invcont111
-	%tmp116 = call %struct.QTextBlockGroup* %_ZNK13QTextDocument9rootFrameEv( %struct.QAbstractTextDocumentLayout* %tmp95 )		; <%struct.QTextBlockGroup*> [#uses=1]
-	invoke void %_ZN10QTextFrame14setFrameFormatERK16QTextFrameFormat( %struct.QTextBlockGroup* %tmp116, %struct.QTextBlockFormat* %fmt )
+	%tmp116 = call %struct.QTextBlockGroup* @_ZNK13QTextDocument9rootFrameEv( %struct.QAbstractTextDocumentLayout* %tmp95 )		; <%struct.QTextBlockGroup*> [#uses=1]
+	invoke void @_ZN10QTextFrame14setFrameFormatERK16QTextFrameFormat( %struct.QTextBlockGroup* %tmp116, %struct.QTextBlockFormat* %fmt )
 			to label %invcont117 unwind label %cleanup192
-
 invcont117:		; preds = %invcont114
-	%tmp119 = invoke %struct.QPaintDevice* %_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
+	%tmp119 = invoke %struct.QPaintDevice* @_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
 			to label %invcont118 unwind label %cleanup192		; <%struct.QPaintDevice*> [#uses=1]
-
 invcont118:		; preds = %invcont117
-	%tmp121 = invoke int %_ZNK12QPaintDevice6heightEv( %struct.QPaintDevice* %tmp119 )
-			to label %invcont120 unwind label %cleanup192		; <int> [#uses=1]
-
+	%tmp121 = invoke i32 @_ZNK12QPaintDevice6heightEv( %struct.QPaintDevice* %tmp119 )
+			to label %invcont120 unwind label %cleanup192		; <i32> [#uses=1]
 invcont120:		; preds = %invcont118
-	%tmp121 = cast int %tmp121 to double		; <double> [#uses=1]
-	%tmp123 = invoke %struct.QPaintDevice* %_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
+	%tmp121.upgrd.19 = sitofp i32 %tmp121 to double		; <double> [#uses=1]
+	%tmp123 = invoke %struct.QPaintDevice* @_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
 			to label %invcont122 unwind label %cleanup192		; <%struct.QPaintDevice*> [#uses=1]
-
 invcont122:		; preds = %invcont120
-	%tmp125 = invoke int %_ZNK12QPaintDevice5widthEv( %struct.QPaintDevice* %tmp123 )
-			to label %invcont124 unwind label %cleanup192		; <int> [#uses=1]
-
+	%tmp125 = invoke i32 @_ZNK12QPaintDevice5widthEv( %struct.QPaintDevice* %tmp123 )
+			to label %invcont124 unwind label %cleanup192		; <i32> [#uses=1]
 invcont124:		; preds = %invcont122
-	%tmp125 = cast int %tmp125 to double		; <double> [#uses=1]
-	call void %_ZN6QRectFC1Edddd( %struct.QRectF* %tmp, double 0.000000e+00, double 0.000000e+00, double %tmp125, double %tmp121 )
-	%tmp126 = getelementptr %struct.QRectF* %body, int 0, uint 0		; <double*> [#uses=1]
-	%tmp127 = getelementptr %struct.QRectF* %tmp, int 0, uint 0		; <double*> [#uses=1]
+	%tmp125.upgrd.20 = sitofp i32 %tmp125 to double		; <double> [#uses=1]
+	call void @_ZN6QRectFC1Edddd( %struct.QRectF* %tmp.upgrd.1, double 0.000000e+00, double 0.000000e+00, double %tmp125.upgrd.20, double %tmp121.upgrd.19 )
+	%tmp126 = getelementptr %struct.QRectF* %body, i32 0, i32 0		; <double*> [#uses=1]
+	%tmp127 = getelementptr %struct.QRectF* %tmp.upgrd.1, i32 0, i32 0		; <double*> [#uses=1]
 	%tmp128 = load double* %tmp127		; <double> [#uses=1]
 	store double %tmp128, double* %tmp126
-	%tmp129 = getelementptr %struct.QRectF* %body, int 0, uint 1		; <double*> [#uses=1]
-	%tmp130 = getelementptr %struct.QRectF* %tmp, int 0, uint 1		; <double*> [#uses=1]
+	%tmp129 = getelementptr %struct.QRectF* %body, i32 0, i32 1		; <double*> [#uses=1]
+	%tmp130 = getelementptr %struct.QRectF* %tmp.upgrd.1, i32 0, i32 1		; <double*> [#uses=1]
 	%tmp131 = load double* %tmp130		; <double> [#uses=1]
 	store double %tmp131, double* %tmp129
-	%tmp132 = getelementptr %struct.QRectF* %body, int 0, uint 2		; <double*> [#uses=1]
-	%tmp133 = getelementptr %struct.QRectF* %tmp, int 0, uint 2		; <double*> [#uses=1]
+	%tmp132 = getelementptr %struct.QRectF* %body, i32 0, i32 2		; <double*> [#uses=1]
+	%tmp133 = getelementptr %struct.QRectF* %tmp.upgrd.1, i32 0, i32 2		; <double*> [#uses=1]
 	%tmp134 = load double* %tmp133		; <double> [#uses=1]
 	store double %tmp134, double* %tmp132
-	%tmp135 = getelementptr %struct.QRectF* %body, int 0, uint 3		; <double*> [#uses=1]
-	%tmp136 = getelementptr %struct.QRectF* %tmp, int 0, uint 3		; <double*> [#uses=1]
+	%tmp135 = getelementptr %struct.QRectF* %body, i32 0, i32 3		; <double*> [#uses=1]
+	%tmp136 = getelementptr %struct.QRectF* %tmp.upgrd.1, i32 0, i32 3		; <double*> [#uses=1]
 	%tmp137 = load double* %tmp136		; <double> [#uses=1]
 	store double %tmp137, double* %tmp135
-	%tmp138 = call double %_ZNK6QRectF6heightEv( %struct.QRectF* %body )		; <double> [#uses=1]
-	%tmp139 = cast int %tmp109 to double		; <double> [#uses=1]
+	%tmp138 = call double @_ZNK6QRectF6heightEv( %struct.QRectF* %body )		; <double> [#uses=1]
+	%tmp139 = sitofp i32 %tmp109.upgrd.17 to double		; <double> [#uses=1]
 	%tmp140 = sub double %tmp138, %tmp139		; <double> [#uses=1]
-	%tmp142 = invoke %struct.QPaintDevice* %_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
+	%tmp142 = invoke %struct.QPaintDevice* @_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
 			to label %invcont141 unwind label %cleanup192		; <%struct.QPaintDevice*> [#uses=1]
-
 invcont141:		; preds = %invcont124
-	invoke csretcc void %_ZNK13QTextDocument11defaultFontEv( %struct.QFont* %tmp, %struct.QAbstractTextDocumentLayout* %tmp95 )
+	invoke void @_ZNK13QTextDocument11defaultFontEv( %struct.QFont* sret  %tmp.upgrd.3, %struct.QAbstractTextDocumentLayout* %tmp95 )
 			to label %invcont144 unwind label %cleanup192
-
 invcont144:		; preds = %invcont141
-	invoke void %_ZN12QFontMetricsC1ERK5QFontP12QPaintDevice( %struct.QFontMetrics* %tmp, %struct.QFont* %tmp, %struct.QPaintDevice* %tmp142 )
+	invoke void @_ZN12QFontMetricsC1ERK5QFontP12QPaintDevice( %struct.QFontMetrics* %tmp.upgrd.2, %struct.QFont* %tmp.upgrd.3, %struct.QPaintDevice* %tmp142 )
 			to label %invcont146 unwind label %cleanup173
-
 invcont146:		; preds = %invcont144
-	%tmp149 = invoke int %_ZNK12QFontMetrics6ascentEv( %struct.QFontMetrics* %tmp )
-			to label %invcont148 unwind label %cleanup168		; <int> [#uses=1]
-
+	%tmp149 = invoke i32 @_ZNK12QFontMetrics6ascentEv( %struct.QFontMetrics* %tmp.upgrd.2 )
+			to label %invcont148 unwind label %cleanup168		; <i32> [#uses=1]
 invcont148:		; preds = %invcont146
-	%tmp149 = cast int %tmp149 to double		; <double> [#uses=1]
-	%tmp150 = add double %tmp140, %tmp149		; <double> [#uses=1]
-	%tmp152 = invoke %struct.QPaintDevice* %_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
+	%tmp149.upgrd.21 = sitofp i32 %tmp149 to double		; <double> [#uses=1]
+	%tmp150 = add double %tmp140, %tmp149.upgrd.21		; <double> [#uses=1]
+	%tmp152 = invoke %struct.QPaintDevice* @_ZNK8QPainter6deviceEv( %struct.QPainter* %p )
 			to label %invcont151 unwind label %cleanup168		; <%struct.QPaintDevice*> [#uses=1]
-
 invcont151:		; preds = %invcont148
-	%tmp154 = invoke int %_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp152 )
-			to label %invcont153 unwind label %cleanup168		; <int> [#uses=1]
-
+	%tmp154 = invoke i32 @_ZNK12QPaintDevice11logicalDpiYEv( %struct.QPaintDevice* %tmp152 )
+			to label %invcont153 unwind label %cleanup168		; <i32> [#uses=1]
 invcont153:		; preds = %invcont151
-	%tmp155 = mul int %tmp154, 5		; <int> [#uses=1]
-	%tmp156 = sdiv int %tmp155, 72		; <int> [#uses=1]
-	%tmp156 = cast int %tmp156 to double		; <double> [#uses=1]
-	%tmp157 = add double %tmp150, %tmp156		; <double> [#uses=1]
-	%tmp158 = call double %_ZNK6QRectF5widthEv( %struct.QRectF* %body )		; <double> [#uses=1]
-	%tmp159 = cast int %tmp109 to double		; <double> [#uses=1]
+	%tmp155 = mul i32 %tmp154, 5		; <i32> [#uses=1]
+	%tmp156 = sdiv i32 %tmp155, 72		; <i32> [#uses=1]
+	%tmp156.upgrd.22 = sitofp i32 %tmp156 to double		; <double> [#uses=1]
+	%tmp157 = add double %tmp150, %tmp156.upgrd.22		; <double> [#uses=1]
+	%tmp158 = call double @_ZNK6QRectF5widthEv( %struct.QRectF* %body )		; <double> [#uses=1]
+	%tmp159 = sitofp i32 %tmp109.upgrd.17 to double		; <double> [#uses=1]
 	%tmp160 = sub double %tmp158, %tmp159		; <double> [#uses=1]
-	call void %_ZN7QPointFC1Edd( %struct.QPointF* %tmp2, double %tmp160, double %tmp157 )
-	%tmp161 = getelementptr %struct.QPointF* %pageNumberPos, int 0, uint 0		; <double*> [#uses=1]
-	%tmp162 = getelementptr %struct.QPointF* %tmp2, int 0, uint 0		; <double*> [#uses=1]
+	call void @_ZN7QPointFC1Edd( %struct.QPointF* %tmp2, double %tmp160, double %tmp157 )
+	%tmp161 = getelementptr %struct.QPointF* %pageNumberPos, i32 0, i32 0		; <double*> [#uses=1]
+	%tmp162 = getelementptr %struct.QPointF* %tmp2, i32 0, i32 0		; <double*> [#uses=1]
 	%tmp163 = load double* %tmp162		; <double> [#uses=1]
 	store double %tmp163, double* %tmp161
-	%tmp164 = getelementptr %struct.QPointF* %pageNumberPos, int 0, uint 1		; <double*> [#uses=1]
-	%tmp165 = getelementptr %struct.QPointF* %tmp2, int 0, uint 1		; <double*> [#uses=1]
+	%tmp164 = getelementptr %struct.QPointF* %pageNumberPos, i32 0, i32 1		; <double*> [#uses=1]
+	%tmp165 = getelementptr %struct.QPointF* %tmp2, i32 0, i32 1		; <double*> [#uses=1]
 	%tmp166 = load double* %tmp165		; <double> [#uses=1]
 	store double %tmp166, double* %tmp164
-	invoke void %_ZN12QFontMetricsD1Ev( %struct.QFontMetrics* %tmp )
+	invoke void @_ZN12QFontMetricsD1Ev( %struct.QFontMetrics* %tmp.upgrd.2 )
 			to label %cleanup171 unwind label %cleanup173
-
 cleanup168:		; preds = %invcont151, %invcont148, %invcont146
-	invoke void %_ZN12QFontMetricsD1Ev( %struct.QFontMetrics* %tmp )
+	invoke void @_ZN12QFontMetricsD1Ev( %struct.QFontMetrics* %tmp.upgrd.2 )
 			to label %cleanup173 unwind label %cleanup173
-
 cleanup171:		; preds = %invcont153
-	invoke void %_ZN5QFontD1Ev( %struct.QFont* %tmp )
+	invoke void @_ZN5QFontD1Ev( %struct.QFont* %tmp.upgrd.3 )
 			to label %finally170 unwind label %cleanup192
-
 cleanup173:		; preds = %cleanup168, %cleanup168, %invcont153, %invcont144
-	invoke void %_ZN5QFontD1Ev( %struct.QFont* %tmp )
+	invoke void @_ZN5QFontD1Ev( %struct.QFont* %tmp.upgrd.3 )
 			to label %cleanup192 unwind label %cleanup192
-
 finally170:		; preds = %cleanup171
-	invoke csretcc void %_ZNK13QTextDocument11defaultFontEv( %struct.QFont* %font, %struct.QAbstractTextDocumentLayout* %tmp95 )
+	invoke void @_ZNK13QTextDocument11defaultFontEv( %struct.QFont* sret  %font, %struct.QAbstractTextDocumentLayout* %tmp95 )
 			to label %invcont177 unwind label %cleanup192
-
 invcont177:		; preds = %finally170
-	invoke void %_ZN5QFont12setPointSizeEi( %struct.QFont* %font, int 10 )
+	invoke void @_ZN5QFont12setPointSizeEi( %struct.QFont* %font, i32 10 )
 			to label %invcont179 unwind label %cleanup187
-
 invcont179:		; preds = %invcont177
-	invoke void %_ZN13QTextDocument14setDefaultFontERK5QFont( %struct.QAbstractTextDocumentLayout* %tmp95, %struct.QFont* %font )
+	invoke void @_ZN13QTextDocument14setDefaultFontERK5QFont( %struct.QAbstractTextDocumentLayout* %tmp95, %struct.QFont* %font )
 			to label %invcont181 unwind label %cleanup187
-
 invcont181:		; preds = %invcont179
-	call csretcc void %_ZNK6QRectF4sizeEv( %struct.QPointF* %tmp3, %struct.QRectF* %body )
-	invoke void %_ZN13QTextDocument11setPageSizeERK6QSizeF( %struct.QAbstractTextDocumentLayout* %tmp95, %struct.QPointF* %tmp3 )
+	call void @_ZNK6QRectF4sizeEv( %struct.QPointF* sret  %tmp3, %struct.QRectF* %body )
+	invoke void @_ZN13QTextDocument11setPageSizeERK6QSizeF( %struct.QAbstractTextDocumentLayout* %tmp95, %struct.QPointF* %tmp3 )
 			to label %cleanup185 unwind label %cleanup187
-
 cleanup185:		; preds = %invcont181
-	invoke void %_ZN5QFontD1Ev( %struct.QFont* %font )
+	invoke void @_ZN5QFontD1Ev( %struct.QFont* %font )
 			to label %cleanup190 unwind label %cleanup192
-
 cleanup187:		; preds = %invcont181, %invcont179, %invcont177
-	invoke void %_ZN5QFontD1Ev( %struct.QFont* %font )
+	invoke void @_ZN5QFontD1Ev( %struct.QFont* %font )
 			to label %cleanup192 unwind label %cleanup192
-
 cleanup190:		; preds = %cleanup185
-	invoke void %_ZN16QTextFrameFormatD1Ev( %struct.QTextBlockFormat* %fmt )
+	invoke void @_ZN16QTextFrameFormatD1Ev( %struct.QTextBlockFormat* %fmt )
 			to label %cond_next194 unwind label %cleanup329
-
 cleanup192:		; preds = %cleanup187, %cleanup187, %cleanup185, %finally170, %cleanup173, %cleanup173, %cleanup171, %invcont141, %invcont124, %invcont122, %invcont120, %invcont118, %invcont117, %invcont114, %invcont111
-	invoke void %_ZN16QTextFrameFormatD1Ev( %struct.QTextBlockFormat* %fmt )
+	invoke void @_ZN16QTextFrameFormatD1Ev( %struct.QTextBlockFormat* %fmt )
 			to label %cleanup329 unwind label %cleanup329
-
 cond_next194:		; preds = %cleanup190, %invcont83
 	%clonedDoc.1 = phi %struct.QAbstractTextDocumentLayout* [ null, %invcont83 ], [ %tmp95, %cleanup190 ]		; <%struct.QAbstractTextDocumentLayout*> [#uses=3]
 	%doc.1 = phi %struct.QAbstractTextDocumentLayout* [ %this, %invcont83 ], [ %tmp95, %cleanup190 ]		; <%struct.QAbstractTextDocumentLayout*> [#uses=2]
-	%tmp197 = invoke bool %_ZNK8QPrinter13collateCopiesEv( %struct.QPrinter* %printer )
-			to label %invcont196 unwind label %cleanup329		; <bool> [#uses=1]
-
+	%tmp197 = invoke i1 @_ZNK8QPrinter13collateCopiesEv( %struct.QPrinter* %printer )
+			to label %invcont196 unwind label %cleanup329		; <i1> [#uses=1]
 invcont196:		; preds = %cond_next194
-	br bool %tmp197, label %cond_true200, label %cond_false204
-
+	br i1 %tmp197, label %cond_true200, label %cond_false204
 cond_true200:		; preds = %invcont196
-	%tmp203 = invoke int %_ZNK8QPrinter9numCopiesEv( %struct.QPrinter* %printer )
-			to label %invcont202 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp203 = invoke i32 @_ZNK8QPrinter9numCopiesEv( %struct.QPrinter* %printer )
+			to label %invcont202 unwind label %cleanup329		; <i32> [#uses=1]
 invcont202:		; preds = %cond_true200
 	br label %cond_next208
-
 cond_false204:		; preds = %invcont196
-	%tmp207 = invoke int %_ZNK8QPrinter9numCopiesEv( %struct.QPrinter* %printer )
-			to label %invcont206 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp207 = invoke i32 @_ZNK8QPrinter9numCopiesEv( %struct.QPrinter* %printer )
+			to label %invcont206 unwind label %cleanup329		; <i32> [#uses=1]
 invcont206:		; preds = %cond_false204
 	br label %cond_next208
-
 cond_next208:		; preds = %invcont206, %invcont202
-	%pageCopies.0 = phi int [ %tmp203, %invcont202 ], [ 1, %invcont206 ]		; <int> [#uses=2]
-	%docCopies.0 = phi int [ 1, %invcont202 ], [ %tmp207, %invcont206 ]		; <int> [#uses=2]
-	%tmp211 = invoke int %_ZNK8QPrinter8fromPageEv( %struct.QPrinter* %printer )
-			to label %invcont210 unwind label %cleanup329		; <int> [#uses=3]
-
+	%pageCopies.0 = phi i32 [ %tmp203, %invcont202 ], [ 1, %invcont206 ]		; <i32> [#uses=2]
+	%docCopies.0 = phi i32 [ 1, %invcont202 ], [ %tmp207, %invcont206 ]		; <i32> [#uses=2]
+	%tmp211 = invoke i32 @_ZNK8QPrinter8fromPageEv( %struct.QPrinter* %printer )
+			to label %invcont210 unwind label %cleanup329		; <i32> [#uses=3]
 invcont210:		; preds = %cond_next208
-	%tmp214 = invoke int %_ZNK8QPrinter6toPageEv( %struct.QPrinter* %printer )
-			to label %invcont213 unwind label %cleanup329		; <int> [#uses=3]
-
+	%tmp214 = invoke i32 @_ZNK8QPrinter6toPageEv( %struct.QPrinter* %printer )
+			to label %invcont213 unwind label %cleanup329		; <i32> [#uses=3]
 invcont213:		; preds = %invcont210
-	%tmp216 = seteq int %tmp211, 0		; <bool> [#uses=1]
-	br bool %tmp216, label %cond_true217, label %cond_next225
-
+	%tmp216 = icmp eq i32 %tmp211, 0		; <i1> [#uses=1]
+	br i1 %tmp216, label %cond_true217, label %cond_next225
 cond_true217:		; preds = %invcont213
-	%tmp219 = seteq int %tmp214, 0		; <bool> [#uses=1]
-	br bool %tmp219, label %cond_true220, label %cond_next225
-
+	%tmp219 = icmp eq i32 %tmp214, 0		; <i1> [#uses=1]
+	br i1 %tmp219, label %cond_true220, label %cond_next225
 cond_true220:		; preds = %cond_true217
-	%tmp223 = invoke int %_ZNK13QTextDocument9pageCountEv( %struct.QAbstractTextDocumentLayout* %doc.1 )
-			to label %invcont222 unwind label %cleanup329		; <int> [#uses=1]
-
+	%tmp223 = invoke i32 @_ZNK13QTextDocument9pageCountEv( %struct.QAbstractTextDocumentLayout* %doc.1 )
+			to label %invcont222 unwind label %cleanup329		; <i32> [#uses=1]
 invcont222:		; preds = %cond_true220
 	br label %cond_next225
-
 cond_next225:		; preds = %invcont222, %cond_true217, %invcont213
-	%toPage.1 = phi int [ %tmp223, %invcont222 ], [ %tmp214, %cond_true217 ], [ %tmp214, %invcont213 ]		; <int> [#uses=2]
-	%fromPage.1 = phi int [ 1, %invcont222 ], [ %tmp211, %cond_true217 ], [ %tmp211, %invcont213 ]		; <int> [#uses=2]
-	%tmp.page = invoke uint %_ZNK8QPrinter9pageOrderEv( %struct.QPrinter* %printer )
-			to label %invcont227 unwind label %cleanup329		; <uint> [#uses=1]
-
+	%toPage.1 = phi i32 [ %tmp223, %invcont222 ], [ %tmp214, %cond_true217 ], [ %tmp214, %invcont213 ]		; <i32> [#uses=2]
+	%fromPage.1 = phi i32 [ 1, %invcont222 ], [ %tmp211, %cond_true217 ], [ %tmp211, %invcont213 ]		; <i32> [#uses=2]
+	%tmp.page = invoke i32 @_ZNK8QPrinter9pageOrderEv( %struct.QPrinter* %printer )
+			to label %invcont227 unwind label %cleanup329		; <i32> [#uses=1]
 invcont227:		; preds = %cond_next225
-	%tmp228 = seteq uint %tmp.page, 1		; <bool> [#uses=1]
-	br bool %tmp228, label %cond_true230, label %cond_next234
-
+	%tmp228 = icmp eq i32 %tmp.page, 1		; <i1> [#uses=1]
+	br i1 %tmp228, label %cond_true230, label %cond_next234
 cond_true230:		; preds = %invcont227
 	br label %cond_next234
-
 cond_next234:		; preds = %cond_true230, %invcont227
-	%ascending.1 = phi bool [ false, %cond_true230 ], [ true, %invcont227 ]		; <bool> [#uses=1]
-	%toPage.2 = phi int [ %fromPage.1, %cond_true230 ], [ %toPage.1, %invcont227 ]		; <int> [#uses=1]
-	%fromPage.2 = phi int [ %toPage.1, %cond_true230 ], [ %fromPage.1, %invcont227 ]		; <int> [#uses=1]
+	%ascending.1 = phi i1 [ false, %cond_true230 ], [ true, %invcont227 ]		; <i1> [#uses=1]
+	%toPage.2 = phi i32 [ %fromPage.1, %cond_true230 ], [ %toPage.1, %invcont227 ]		; <i32> [#uses=1]
+	%fromPage.2 = phi i32 [ %toPage.1, %cond_true230 ], [ %fromPage.1, %invcont227 ]		; <i32> [#uses=1]
 	br label %bb309
-
 bb237:		; preds = %cond_true313, %cond_next293
-	%iftmp.410.4 = phi bool [ %iftmp.410.5, %cond_true313 ], [ %iftmp.410.1, %cond_next293 ]		; <bool> [#uses=1]
-	%page.4 = phi int [ %fromPage.2, %cond_true313 ], [ %page.3, %cond_next293 ]		; <int> [#uses=4]
+	%iftmp.410.4 = phi i1 [ %iftmp.410.5, %cond_true313 ], [ %iftmp.410.1, %cond_next293 ]		; <i1> [#uses=1]
+	%page.4 = phi i32 [ %fromPage.2, %cond_true313 ], [ %page.3, %cond_next293 ]		; <i32> [#uses=4]
 	br label %bb273
-
 invcont240:		; preds = %cond_true277
-	%tmp242 = seteq uint %tmp241, 2		; <bool> [#uses=1]
-	br bool %tmp242, label %bb252, label %cond_next244
-
+	%tmp242 = icmp eq i32 %tmp241, 2		; <i1> [#uses=1]
+	br i1 %tmp242, label %bb252, label %cond_next244
 cond_next244:		; preds = %invcont240
-	%tmp247 = invoke uint %_ZNK8QPrinter12printerStateEv( %struct.QPrinter* %printer )
-			to label %invcont246 unwind label %cleanup329		; <uint> [#uses=1]
-
+	%tmp247 = invoke i32 @_ZNK8QPrinter12printerStateEv( %struct.QPrinter* %printer )
+			to label %invcont246 unwind label %cleanup329		; <i32> [#uses=1]
 invcont246:		; preds = %cond_next244
-	%tmp248 = seteq uint %tmp247, 3		; <bool> [#uses=1]
-	br bool %tmp248, label %bb252, label %bb253
-
+	%tmp248 = icmp eq i32 %tmp247, 3		; <i1> [#uses=1]
+	br i1 %tmp248, label %bb252, label %bb253
 bb252:		; preds = %invcont246, %invcont240
 	br label %bb254
-
 bb253:		; preds = %invcont246
 	br label %bb254
-
 bb254:		; preds = %bb253, %bb252
-	%iftmp.410.0 = phi bool [ true, %bb252 ], [ false, %bb253 ]		; <bool> [#uses=2]
-	br bool %iftmp.410.0, label %UserCanceled, label %cond_next258
-
+	%iftmp.410.0 = phi i1 [ true, %bb252 ], [ false, %bb253 ]		; <i1> [#uses=2]
+	br i1 %iftmp.410.0, label %UserCanceled, label %cond_next258
 cond_next258:		; preds = %bb254
-	invoke fastcc void %_Z9printPageiP8QPainterPK13QTextDocumentRK6QRectFRK7QPointF( int %page.4, %struct.QPainter* %p, %struct.QAbstractTextDocumentLayout* %doc.1, %struct.QRectF* %body, %struct.QPointF* %pageNumberPos )
+	invoke fastcc void @_Z9printPageiP8QPainterPK13QTextDocumentRK6QRectFRK7QPointF( i32 %page.4, %struct.QPainter* %p, %struct.QAbstractTextDocumentLayout* %doc.1, %struct.QRectF* %body, %struct.QPointF* %pageNumberPos )
 			to label %invcont261 unwind label %cleanup329
-
 invcont261:		; preds = %cond_next258
-	%tmp263 = add int %pageCopies.0, -1		; <int> [#uses=1]
-	%tmp265 = setgt int %tmp263, %j.4		; <bool> [#uses=1]
-	br bool %tmp265, label %cond_true266, label %cond_next270
-
+	%tmp263 = add i32 %pageCopies.0, -1		; <i32> [#uses=1]
+	%tmp265 = icmp sgt i32 %tmp263, %j.4		; <i1> [#uses=1]
+	br i1 %tmp265, label %cond_true266, label %cond_next270
 cond_true266:		; preds = %invcont261
-	%tmp269 = invoke bool %_ZN8QPrinter7newPageEv( %struct.QPrinter* %printer )
-			to label %cond_next270 unwind label %cleanup329		; <bool> [#uses=0]
-
+	%tmp269 = invoke i1 @_ZN8QPrinter7newPageEv( %struct.QPrinter* %printer )
+			to label %cond_next270 unwind label %cleanup329		; <i1> [#uses=0]
 cond_next270:		; preds = %cond_true266, %invcont261
-	%tmp272 = add int %j.4, 1		; <int> [#uses=1]
+	%tmp272 = add i32 %j.4, 1		; <i32> [#uses=1]
 	br label %bb273
-
 bb273:		; preds = %cond_next270, %bb237
-	%iftmp.410.1 = phi bool [ %iftmp.410.4, %bb237 ], [ %iftmp.410.0, %cond_next270 ]		; <bool> [#uses=2]
-	%j.4 = phi int [ 0, %bb237 ], [ %tmp272, %cond_next270 ]		; <int> [#uses=3]
-	%tmp276 = setlt int %j.4, %pageCopies.0		; <bool> [#uses=1]
-	br bool %tmp276, label %cond_true277, label %bb280
-
+	%iftmp.410.1 = phi i1 [ %iftmp.410.4, %bb237 ], [ %iftmp.410.0, %cond_next270 ]		; <i1> [#uses=2]
+	%j.4 = phi i32 [ 0, %bb237 ], [ %tmp272, %cond_next270 ]		; <i32> [#uses=3]
+	%tmp276 = icmp slt i32 %j.4, %pageCopies.0		; <i1> [#uses=1]
+	br i1 %tmp276, label %cond_true277, label %bb280
 cond_true277:		; preds = %bb273
-	%tmp241 = invoke uint %_ZNK8QPrinter12printerStateEv( %struct.QPrinter* %printer )
-			to label %invcont240 unwind label %cleanup329		; <uint> [#uses=1]
-
+	%tmp241 = invoke i32 @_ZNK8QPrinter12printerStateEv( %struct.QPrinter* %printer )
+			to label %invcont240 unwind label %cleanup329		; <i32> [#uses=1]
 bb280:		; preds = %bb273
-	%tmp283 = seteq int %page.4, %toPage.2		; <bool> [#uses=1]
-	br bool %tmp283, label %bb297, label %cond_next285
-
+	%tmp283 = icmp eq i32 %page.4, %toPage.2		; <i1> [#uses=1]
+	br i1 %tmp283, label %bb297, label %cond_next285
 cond_next285:		; preds = %bb280
-	br bool %ascending.1, label %cond_true287, label %cond_false290
-
+	br i1 %ascending.1, label %cond_true287, label %cond_false290
 cond_true287:		; preds = %cond_next285
-	%tmp289 = add int %page.4, 1		; <int> [#uses=1]
+	%tmp289 = add i32 %page.4, 1		; <i32> [#uses=1]
 	br label %cond_next293
-
 cond_false290:		; preds = %cond_next285
-	%tmp292 = add int %page.4, -1		; <int> [#uses=1]
+	%tmp292 = add i32 %page.4, -1		; <i32> [#uses=1]
 	br label %cond_next293
-
 cond_next293:		; preds = %cond_false290, %cond_true287
-	%page.3 = phi int [ %tmp289, %cond_true287 ], [ %tmp292, %cond_false290 ]		; <int> [#uses=1]
-	%tmp296 = invoke bool %_ZN8QPrinter7newPageEv( %struct.QPrinter* %printer )
-			to label %bb237 unwind label %cleanup329		; <bool> [#uses=0]
-
+	%page.3 = phi i32 [ %tmp289, %cond_true287 ], [ %tmp292, %cond_false290 ]		; <i32> [#uses=1]
+	%tmp296 = invoke i1 @_ZN8QPrinter7newPageEv( %struct.QPrinter* %printer )
+			to label %bb237 unwind label %cleanup329		; <i1> [#uses=0]
 bb297:		; preds = %bb280
-	%tmp299 = add int %docCopies.0, -1		; <int> [#uses=1]
-	%tmp301 = setgt int %tmp299, %i.1		; <bool> [#uses=1]
-	br bool %tmp301, label %cond_true302, label %cond_next306
-
+	%tmp299 = add i32 %docCopies.0, -1		; <i32> [#uses=1]
+	%tmp301 = icmp sgt i32 %tmp299, %i.1		; <i1> [#uses=1]
+	br i1 %tmp301, label %cond_true302, label %cond_next306
 cond_true302:		; preds = %bb297
-	%tmp305 = invoke bool %_ZN8QPrinter7newPageEv( %struct.QPrinter* %printer )
-			to label %cond_next306 unwind label %cleanup329		; <bool> [#uses=0]
-
+	%tmp305 = invoke i1 @_ZN8QPrinter7newPageEv( %struct.QPrinter* %printer )
+			to label %cond_next306 unwind label %cleanup329		; <i1> [#uses=0]
 cond_next306:		; preds = %cond_true302, %bb297
-	%tmp308 = add int %i.1, 1		; <int> [#uses=1]
+	%tmp308 = add i32 %i.1, 1		; <i32> [#uses=1]
 	br label %bb309
-
 bb309:		; preds = %cond_next306, %cond_next234
-	%iftmp.410.5 = phi bool [ undef, %cond_next234 ], [ %iftmp.410.1, %cond_next306 ]		; <bool> [#uses=1]
-	%i.1 = phi int [ 0, %cond_next234 ], [ %tmp308, %cond_next306 ]		; <int> [#uses=3]
-	%tmp312 = setlt int %i.1, %docCopies.0		; <bool> [#uses=1]
-	br bool %tmp312, label %cond_true313, label %UserCanceled
-
+	%iftmp.410.5 = phi i1 [ undef, %cond_next234 ], [ %iftmp.410.1, %cond_next306 ]		; <i1> [#uses=1]
+	%i.1 = phi i32 [ 0, %cond_next234 ], [ %tmp308, %cond_next306 ]		; <i32> [#uses=3]
+	%tmp312 = icmp slt i32 %i.1, %docCopies.0		; <i1> [#uses=1]
+	br i1 %tmp312, label %cond_true313, label %UserCanceled
 cond_true313:		; preds = %bb309
 	br label %bb237
-
 UserCanceled:		; preds = %bb309, %bb254
-	%tmp318 = seteq %struct.QAbstractTextDocumentLayout* %clonedDoc.1, null		; <bool> [#uses=1]
-	br bool %tmp318, label %cleanup327, label %cond_true319
-
+	%tmp318 = icmp eq %struct.QAbstractTextDocumentLayout* %clonedDoc.1, null		; <i1> [#uses=1]
+	br i1 %tmp318, label %cleanup327, label %cond_true319
 cond_true319:		; preds = %UserCanceled
-	%tmp = getelementptr %struct.QAbstractTextDocumentLayout* %clonedDoc.1, int 0, uint 0, uint 0		; <int (...)***> [#uses=1]
-	%tmp = load int (...)*** %tmp		; <int (...)**> [#uses=1]
-	%tmp322 = getelementptr int (...)** %tmp, int 4		; <int (...)**> [#uses=1]
-	%tmp = load int (...)** %tmp322		; <int (...)*> [#uses=1]
-	%tmp = cast int (...)* %tmp to void (%struct.QAbstractTextDocumentLayout*)*		; <void (%struct.QAbstractTextDocumentLayout*)*> [#uses=1]
-	invoke void %tmp( %struct.QAbstractTextDocumentLayout* %clonedDoc.1 )
+	%tmp.upgrd.23 = getelementptr %struct.QAbstractTextDocumentLayout* %clonedDoc.1, i32 0, i32 0, i32 0		; <i32 (...)***> [#uses=1]
+	%tmp.upgrd.24 = load i32 (...)*** %tmp.upgrd.23		; <i32 (...)**> [#uses=1]
+	%tmp322 = getelementptr i32 (...)** %tmp.upgrd.24, i32 4		; <i32 (...)**> [#uses=1]
+	%tmp.upgrd.25 = load i32 (...)** %tmp322		; <i32 (...)*> [#uses=1]
+	%tmp.upgrd.26 = bitcast i32 (...)* %tmp.upgrd.25 to void (%struct.QAbstractTextDocumentLayout*)*		; <void (%struct.QAbstractTextDocumentLayout*)*> [#uses=1]
+	invoke void %tmp.upgrd.26( %struct.QAbstractTextDocumentLayout* %clonedDoc.1 )
 			to label %cleanup327 unwind label %cleanup329
-
 cleanup327:		; preds = %cond_true319, %UserCanceled
-	call void %_ZN8QPainterD1Ev( %struct.QPainter* %p )
+	call void @_ZN8QPainterD1Ev( %struct.QPainter* %p )
 	ret void
-
 cleanup328:		; preds = %invcont
-	call void %_ZN8QPainterD1Ev( %struct.QPainter* %p )
+	call void @_ZN8QPainterD1Ev( %struct.QPainter* %p )
 	ret void
-
 cleanup329:		; preds = %cond_true319, %cond_true302, %cond_next293, %cond_true277, %cond_true266, %cond_next258, %cond_next244, %cond_next225, %cond_true220, %invcont210, %cond_next208, %cond_false204, %cond_true200, %cond_next194, %cleanup192, %cleanup192, %cleanup190, %invcont106, %invcont104, %invcont103, %invcont100, %invcont98, %invcont94, %cond_false, %invcont83, %invcont79, %invcont57, %invcont51, %invcont45, %cond_next42, %invcont37, %cond_true35, %invcont29, %invcont25, %cond_true24, %cond_next, %entry
-	call void %_ZN8QPainterD1Ev( %struct.QPainter* %p )
+	call void @_ZN8QPainterD1Ev( %struct.QPainter* %p )
 	unwind
 }
 
-declare void %_ZN6QSizeFC1Edd(%struct.QPointF*, double, double)
+declare void @_ZN6QSizeFC1Edd(%struct.QPointF*, double, double)
 
-declare bool %_ZNK6QSizeF7isValidEv(%struct.QPointF*)
+declare i1 @_ZNK6QSizeF7isValidEv(%struct.QPointF*)
 
-declare double %_ZNK6QSizeF5widthEv(%struct.QPointF*)
+declare double @_ZNK6QSizeF5widthEv(%struct.QPointF*)
 
-declare double %_ZNK6QSizeF6heightEv(%struct.QPointF*)
+declare double @_ZNK6QSizeF6heightEv(%struct.QPointF*)
 
-declare double* %_ZN6QSizeF6rwidthEv(%struct.QPointF*)
+declare double* @_ZN6QSizeF6rwidthEv(%struct.QPointF*)
 
-declare double* %_ZN6QSizeF7rheightEv(%struct.QPointF*)
+declare double* @_ZN6QSizeF7rheightEv(%struct.QPointF*)
 
-declare %struct.QTextDocumentPrivate* %_ZNK13QTextDocument6d_funcEv(%struct.QAbstractTextDocumentLayout*)
+declare %struct.QTextDocumentPrivate* @_ZNK13QTextDocument6d_funcEv(%struct.QAbstractTextDocumentLayout*)
 
-declare void %_ZN7QPointFC1Ev(%struct.QPointF*)
+declare void @_ZN7QPointFC1Ev(%struct.QPointF*)
 
-declare void %_ZN7QPointFC1Edd(%struct.QPointF*, double, double)
+declare void @_ZN7QPointFC1Edd(%struct.QPointF*, double, double)
 
-declare void %_ZN16QTextFrameFormat9setMarginEd(%struct.QTextBlockFormat*, double)
+declare void @_ZN16QTextFrameFormat9setMarginEd(%struct.QTextBlockFormat*, double)
 
-declare void %_ZN6QRectFC1Edddd(%struct.QRectF*, double, double, double, double)
+declare void @_ZN6QRectFC1Edddd(%struct.QRectF*, double, double, double, double)
 
-declare void %_ZN6QRectFC1ERK7QPointFRK6QSizeF(%struct.QRectF*, %struct.QPointF*, %struct.QPointF*)
+declare void @_ZN6QRectFC1ERK7QPointFRK6QSizeF(%struct.QRectF*, %struct.QPointF*, %struct.QPointF*)
 
-declare double %_ZNK6QRectF5widthEv(%struct.QRectF*)
+declare double @_ZNK6QRectF5widthEv(%struct.QRectF*)
 
-declare double %_ZNK6QRectF6heightEv(%struct.QRectF*)
+declare double @_ZNK6QRectF6heightEv(%struct.QRectF*)
 
-declare void %_ZNK6QRectF4sizeEv(%struct.QPointF*, %struct.QRectF*)
+declare void @_ZNK6QRectF4sizeEv(%struct.QPointF*, %struct.QRectF*)
 
-declare void %_ZN16QTextFrameFormatD1Ev(%struct.QTextBlockFormat*)
+declare void @_ZN16QTextFrameFormatD1Ev(%struct.QTextBlockFormat*)
 
-declare void %_ZNK10QTextFrame11frameFormatEv(%struct.QTextBlockFormat*, %struct.QTextBlockGroup*)
+declare void @_ZNK10QTextFrame11frameFormatEv(%struct.QTextBlockFormat*, %struct.QTextBlockGroup*)
 
-declare void %_ZN10QTextFrame14setFrameFormatERK16QTextFrameFormat(%struct.QTextBlockGroup*, %struct.QTextBlockFormat*)
+declare void @_ZN10QTextFrame14setFrameFormatERK16QTextFrameFormat(%struct.QTextBlockGroup*, %struct.QTextBlockFormat*)
 
-declare int %_ZNK12QPaintDevice5widthEv(%struct.QPaintDevice*)
+declare i32 @_ZNK12QPaintDevice5widthEv(%struct.QPaintDevice*)
 
-declare int %_ZNK12QPaintDevice6heightEv(%struct.QPaintDevice*)
+declare i32 @_ZNK12QPaintDevice6heightEv(%struct.QPaintDevice*)
 
-declare int %_ZNK12QPaintDevice11logicalDpiXEv(%struct.QPaintDevice*)
+declare i32 @_ZNK12QPaintDevice11logicalDpiXEv(%struct.QPaintDevice*)
 
-declare int %_ZNK12QPaintDevice11logicalDpiYEv(%struct.QPaintDevice*)
+declare i32 @_ZNK12QPaintDevice11logicalDpiYEv(%struct.QPaintDevice*)
 
-declare %struct.QAbstractTextDocumentLayout* %_ZNK13QTextDocument5cloneEP7QObject(%struct.QAbstractTextDocumentLayout*, %struct.QObject*)
+declare %struct.QAbstractTextDocumentLayout* @_ZNK13QTextDocument5cloneEP7QObject(%struct.QAbstractTextDocumentLayout*, %struct.QObject*)
 
-declare void %_ZN5QFontD1Ev(%struct.QFont*)
+declare void @_ZN5QFontD1Ev(%struct.QFont*)
 
-declare %struct.QAbstractTextDocumentLayout* %_ZNK13QTextDocument14documentLayoutEv(%struct.QAbstractTextDocumentLayout*)
+declare %struct.QAbstractTextDocumentLayout* @_ZNK13QTextDocument14documentLayoutEv(%struct.QAbstractTextDocumentLayout*)
 
-declare %struct.QTextBlockGroup* %_ZNK13QTextDocument9rootFrameEv(%struct.QAbstractTextDocumentLayout*)
+declare %struct.QTextBlockGroup* @_ZNK13QTextDocument9rootFrameEv(%struct.QAbstractTextDocumentLayout*)
 
-declare int %_ZNK13QTextDocument9pageCountEv(%struct.QAbstractTextDocumentLayout*)
+declare i32 @_ZNK13QTextDocument9pageCountEv(%struct.QAbstractTextDocumentLayout*)
 
-declare void %_ZNK13QTextDocument11defaultFontEv(%struct.QFont*, %struct.QAbstractTextDocumentLayout*)
+declare void @_ZNK13QTextDocument11defaultFontEv(%struct.QFont*, %struct.QAbstractTextDocumentLayout*)
 
-declare void %_ZN13QTextDocument14setDefaultFontERK5QFont(%struct.QAbstractTextDocumentLayout*, %struct.QFont*)
+declare void @_ZN13QTextDocument14setDefaultFontERK5QFont(%struct.QAbstractTextDocumentLayout*, %struct.QFont*)
 
-declare void %_ZN13QTextDocument11setPageSizeERK6QSizeF(%struct.QAbstractTextDocumentLayout*, %struct.QPointF*)
+declare void @_ZN13QTextDocument11setPageSizeERK6QSizeF(%struct.QAbstractTextDocumentLayout*, %struct.QPointF*)
 
-declare void %_Z9printPageiP8QPainterPK13QTextDocumentRK6QRectFRK7QPointF(int, %struct.QPainter*, %struct.QAbstractTextDocumentLayout*, %struct.QRectF*, %struct.QPointF*)
+declare void @_Z9printPageiP8QPainterPK13QTextDocumentRK6QRectFRK7QPointF(i32, %struct.QPainter*, %struct.QAbstractTextDocumentLayout*, %struct.QRectF*, %struct.QPointF*)
 
-declare void %_ZN12QFontMetricsD1Ev(%struct.QFontMetrics*)
+declare void @_ZN12QFontMetricsD1Ev(%struct.QFontMetrics*)
 
-declare void %_ZN8QPainterC1EP12QPaintDevice(%struct.QPainter*, %struct.QPaintDevice*)
+declare void @_ZN8QPainterC1EP12QPaintDevice(%struct.QPainter*, %struct.QPaintDevice*)
 
-declare bool %_ZNK8QPainter8isActiveEv(%struct.QPainter*)
+declare i1 @_ZNK8QPainter8isActiveEv(%struct.QPainter*)
 
-declare int %_Z13qt_defaultDpiv()
+declare i32 @_Z13qt_defaultDpiv()
 
-declare %struct.QPaintDevice* %_ZNK27QAbstractTextDocumentLayout11paintDeviceEv(%struct.QAbstractTextDocumentLayout*)
+declare %struct.QPaintDevice* @_ZNK27QAbstractTextDocumentLayout11paintDeviceEv(%struct.QAbstractTextDocumentLayout*)
 
-declare void %_ZN8QPainter5scaleEdd(%struct.QPainter*, double, double)
+declare void @_ZN8QPainter5scaleEdd(%struct.QPainter*, double, double)
 
-declare %struct.QPaintDevice* %_ZNK8QPainter6deviceEv(%struct.QPainter*)
+declare %struct.QPaintDevice* @_ZNK8QPainter6deviceEv(%struct.QPainter*)
 
-declare void %_ZN27QAbstractTextDocumentLayout14setPaintDeviceEP12QPaintDevice(%struct.QAbstractTextDocumentLayout*, %struct.QPaintDevice*)
+declare void @_ZN27QAbstractTextDocumentLayout14setPaintDeviceEP12QPaintDevice(%struct.QAbstractTextDocumentLayout*, %struct.QPaintDevice*)
 
-declare void %_ZN12QFontMetricsC1ERK5QFontP12QPaintDevice(%struct.QFontMetrics*, %struct.QFont*, %struct.QPaintDevice*)
+declare void @_ZN12QFontMetricsC1ERK5QFontP12QPaintDevice(%struct.QFontMetrics*, %struct.QFont*, %struct.QPaintDevice*)
 
-declare int %_ZNK12QFontMetrics6ascentEv(%struct.QFontMetrics*)
+declare i32 @_ZNK12QFontMetrics6ascentEv(%struct.QFontMetrics*)
 
-declare void %_ZN5QFont12setPointSizeEi(%struct.QFont*, int)
+declare void @_ZN5QFont12setPointSizeEi(%struct.QFont*, i32)
 
-declare bool %_ZNK8QPrinter13collateCopiesEv(%struct.QPrinter*)
+declare i1 @_ZNK8QPrinter13collateCopiesEv(%struct.QPrinter*)
 
-declare int %_ZNK8QPrinter9numCopiesEv(%struct.QPrinter*)
+declare i32 @_ZNK8QPrinter9numCopiesEv(%struct.QPrinter*)
 
-declare int %_ZNK8QPrinter8fromPageEv(%struct.QPrinter*)
+declare i32 @_ZNK8QPrinter8fromPageEv(%struct.QPrinter*)
 
-declare int %_ZNK8QPrinter6toPageEv(%struct.QPrinter*)
+declare i32 @_ZNK8QPrinter6toPageEv(%struct.QPrinter*)
 
-declare uint %_ZNK8QPrinter9pageOrderEv(%struct.QPrinter*)
+declare i32 @_ZNK8QPrinter9pageOrderEv(%struct.QPrinter*)
 
-declare uint %_ZNK8QPrinter12printerStateEv(%struct.QPrinter*)
+declare i32 @_ZNK8QPrinter12printerStateEv(%struct.QPrinter*)
 
-declare bool %_ZN8QPrinter7newPageEv(%struct.QPrinter*)
+declare i1 @_ZN8QPrinter7newPageEv(%struct.QPrinter*)
 
-declare void %_ZN8QPainterD1Ev(%struct.QPainter*)
+declare void @_ZN8QPainterD1Ev(%struct.QPainter*)
diff --git a/test/Transforms/SimplifyCFG/2006-12-08-Ptr-ICmp-Branch.ll b/test/Transforms/SimplifyCFG/2006-12-08-Ptr-ICmp-Branch.ll
index 3756fcb..d433f04 100644
--- a/test/Transforms/SimplifyCFG/2006-12-08-Ptr-ICmp-Branch.ll
+++ b/test/Transforms/SimplifyCFG/2006-12-08-Ptr-ICmp-Branch.ll
@@ -1,145 +1,131 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplifycfg | llvm-dis
+; RUN: llvm-as < %s | opt -simplifycfg | llvm-dis
 ; END.
-; ModuleID = 'bugpoint-tooptimize.bc'
+
+; ModuleID = '2006-12-08-Ptr-ICmp-Branch.ll'
 target datalayout = "e-p:32:32"
-target endian = little
-target pointersize = 32
 target triple = "i686-pc-linux-gnu"
-        %struct.FILE = type { int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct._IO_marker*, %struct.FILE*, int, int, int, ushort, sbyte, [1 x sbyte], sbyte*, long, sbyte*, sbyte*, sbyte*, sbyte*, uint, int, [40 x sbyte] }
-        %struct._IO_FILE = type { int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct._IO_marker*, %struct.FILE*, int, int, int, ushort, sbyte, [1 x sbyte], sbyte*, long, sbyte*, sbyte*, sbyte*, sbyte*, uint, int, [40 x sbyte] }
-        %struct._IO_marker = type { %struct._IO_marker*, %struct.FILE*, int }
-        %struct.charsequence = type { sbyte*, uint, uint }
-        %struct.trie_s = type { [26 x %struct.trie_s*], int }
-%str = external global [14 x sbyte]             ; <[14 x sbyte]*> [#uses=0]
-%str = external global [32 x sbyte]             ; <[32 x sbyte]*> [#uses=0]
-%str = external global [12 x sbyte]             ; <[12 x sbyte]*> [#uses=0]
-%C.0.2294 = external global %struct.charsequence                ; <%struct.charsequence*> [#uses=3]
-%t = external global %struct.trie_s*            ; <%struct.trie_s**> [#uses=0]
-%str = external global [3 x sbyte]              ; <[3 x sbyte]*> [#uses=0]
-%str = external global [26 x sbyte]             ; <[26 x sbyte]*> [#uses=0]
+	%struct.FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i32, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i32, i32, [40 x i8] }
+	%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i32, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i32, i32, [40 x i8] }
+	%struct._IO_marker = type { %struct._IO_marker*, %struct.FILE*, i32 }
+	%struct.charsequence = type { i8*, i32, i32 }
+	%struct.trie_s = type { [26 x %struct.trie_s*], i32 }
+@str = external global [14 x i8]		; <[14 x i8]*> [#uses=0]
+@str.upgrd.1 = external global [32 x i8]		; <[32 x i8]*> [#uses=0]
+@str.upgrd.2 = external global [12 x i8]		; <[12 x i8]*> [#uses=0]
+@C.0.2294 = external global %struct.charsequence		; <%struct.charsequence*> [#uses=3]
+@t = external global %struct.trie_s*		; <%struct.trie_s**> [#uses=0]
+@str.upgrd.3 = external global [3 x i8]		; <[3 x i8]*> [#uses=0]
+@str.upgrd.4 = external global [26 x i8]		; <[26 x i8]*> [#uses=0]
 
-implementation   ; Functions:
+declare void @charsequence_reset(%struct.charsequence*)
 
-declare void %charsequence_reset(%struct.charsequence*)
-declare void %free(sbyte*)
-declare void %charsequence_push(%struct.charsequence*, sbyte)
-declare sbyte* %charsequence_val(%struct.charsequence*)
-declare int %_IO_getc(%struct.FILE*)
-declare int %tolower(int)
-declare %struct.trie_s* %trie_insert(%struct.trie_s*, sbyte*)
-declare int %feof(%struct.FILE*)
+declare void @free(i8*)
 
-void %addfile(%struct.trie_s* %t, %struct.FILE* %f) {
+declare void @charsequence_push(%struct.charsequence*, i8)
+
+declare i8* @charsequence_val(%struct.charsequence*)
+
+declare i32 @_IO_getc(%struct.FILE*)
+
+declare i32 @tolower(i32)
+
+declare %struct.trie_s* @trie_insert(%struct.trie_s*, i8*)
+
+declare i32 @feof(%struct.FILE*)
+
+define void @addfile(%struct.trie_s* %t, %struct.FILE* %f) {
 entry:
-        %t_addr = alloca %struct.trie_s*                ; <%struct.trie_s**> [#uses=2]
-        %f_addr = alloca %struct.FILE*          ; <%struct.FILE**> [#uses=3]
-        %c = alloca sbyte, align 1              ; <sbyte*> [#uses=7]
-        %wstate = alloca int, align 4           ; <int*> [#uses=4]
-        %cs = alloca %struct.charsequence, align 16             ; <%struct.charsequence*> [#uses=7]
-        %str = alloca sbyte*, align 4           ; <sbyte**> [#uses=3]
-        "alloca point" = bitcast int 0 to int           ; <int> [#uses=0]
-        store %struct.trie_s* %t, %struct.trie_s** %t_addr
-        store %struct.FILE* %f, %struct.FILE** %f_addr
-        store int 0, int* %wstate
-        %tmp = getelementptr %struct.charsequence* %cs, uint 0, uint 0          ; <sbyte**> [#uses=1]
-        %tmp1 = getelementptr %struct.charsequence* %C.0.2294, uint 0, uint 0           ; <sbyte**> [#uses=1]
-        %tmp = load sbyte** %tmp1               ; <sbyte*> [#uses=1]
-        store sbyte* %tmp, sbyte** %tmp
-        %tmp = getelementptr %struct.charsequence* %cs, uint 0, uint 1          ; <uint*> [#uses=1]
-        %tmp2 = getelementptr %struct.charsequence* %C.0.2294, uint 0, uint 1           ; <uint*> [#uses=1]
-        %tmp = load uint* %tmp2         ; <uint> [#uses=1]
-        store uint %tmp, uint* %tmp
-        %tmp3 = getelementptr %struct.charsequence* %cs, uint 0, uint 2         ; <uint*> [#uses=1]
-        %tmp4 = getelementptr %struct.charsequence* %C.0.2294, uint 0, uint 2           ; <uint*> [#uses=1]
-        %tmp5 = load uint* %tmp4                ; <uint> [#uses=1]
-        store uint %tmp5, uint* %tmp3
-        br label %bb33
-
-bb:             ; preds = %bb33
-        %tmp = load %struct.FILE** %f_addr              ; <%struct.FILE*> [#uses=1]
-        %tmp = call int %_IO_getc( %struct.FILE* %tmp )         ; <int> [#uses=1]
-        %tmp6 = call int %tolower( int %tmp )           ; <int> [#uses=1]
-        %tmp6 = trunc int %tmp6 to sbyte                ; <sbyte> [#uses=1]
-        store sbyte %tmp6, sbyte* %c
-        %tmp7 = load int* %wstate               ; <int> [#uses=1]
-        %tmp = icmp ne int %tmp7, 0             ; <bool> [#uses=1]
-        br bool %tmp, label %cond_true, label %cond_false
-
-cond_true:              ; preds = %bb
-        %tmp = load sbyte* %c           ; <sbyte> [#uses=1]
-        %tmp8 = icmp sle sbyte %tmp, 96         ; <bool> [#uses=1]
-        br bool %tmp8, label %cond_true9, label %cond_next
-
-cond_true9:             ; preds = %cond_true
-        br label %bb16
-
-cond_next:              ; preds = %cond_true
-        %tmp10 = load sbyte* %c         ; <sbyte> [#uses=1]
-        %tmp11 = icmp sgt sbyte %tmp10, 122             ; <bool> [#uses=1]
-        br bool %tmp11, label %cond_true12, label %cond_next13
-
-cond_true12:            ; preds = %cond_next
-        br label %bb16
-
-cond_next13:            ; preds = %cond_next
-        %tmp14 = load sbyte* %c         ; <sbyte> [#uses=1]
-        %tmp14 = sext sbyte %tmp14 to int               ; <int> [#uses=1]
-        %tmp1415 = trunc int %tmp14 to sbyte            ; <sbyte> [#uses=1]
-        call void %charsequence_push( %struct.charsequence* %cs, sbyte %tmp1415 )
-        br label %bb21
-
-bb16:           ; preds = %cond_true12, %cond_true9
-        %tmp17 = call sbyte* %charsequence_val( %struct.charsequence* %cs )             ; <sbyte*> [#uses=1]
-        store sbyte* %tmp17, sbyte** %str
-        %tmp = load %struct.trie_s** %t_addr            ; <%struct.trie_s*> [#uses=1]
-        %tmp18 = load sbyte** %str              ; <sbyte*> [#uses=1]
-        %tmp19 = call %struct.trie_s* %trie_insert( %struct.trie_s* %tmp, sbyte* %tmp18 )               ; <%struct.trie_s*> [#uses=0]
-        %tmp20 = load sbyte** %str              ; <sbyte*> [#uses=1]
-        call void %free( sbyte* %tmp20 )
-        store int 0, int* %wstate
-        br label %bb21
-
-bb21:           ; preds = %bb16, %cond_next13
-        br label %cond_next32
-
-cond_false:             ; preds = %bb
-        %tmp22 = load sbyte* %c         ; <sbyte> [#uses=1]
-        %tmp23 = icmp sgt sbyte %tmp22, 96              ; <bool> [#uses=1]
-        br bool %tmp23, label %cond_true24, label %cond_next31
-
-cond_true24:            ; preds = %cond_false
-        %tmp25 = load sbyte* %c         ; <sbyte> [#uses=1]
-        %tmp26 = icmp sle sbyte %tmp25, 122             ; <bool> [#uses=1]
-        br bool %tmp26, label %cond_true27, label %cond_next30
-
-cond_true27:            ; preds = %cond_true24
-        call void %charsequence_reset( %struct.charsequence* %cs )
-        %tmp28 = load sbyte* %c         ; <sbyte> [#uses=1]
-        %tmp28 = sext sbyte %tmp28 to int               ; <int> [#uses=1]
-        %tmp2829 = trunc int %tmp28 to sbyte            ; <sbyte> [#uses=1]
-        call void %charsequence_push( %struct.charsequence* %cs, sbyte %tmp2829 )
-        store int 1, int* %wstate
-        br label %cond_next30
-
-cond_next30:            ; preds = %cond_true27, %cond_true24
-        br label %cond_next31
-
-cond_next31:            ; preds = %cond_next30, %cond_false
-        br label %cond_next32
-
-cond_next32:            ; preds = %cond_next31, %bb21
-        br label %bb33
-
-bb33:           ; preds = %cond_next32, %entry
-        %tmp34 = load %struct.FILE** %f_addr            ; <%struct.FILE*> [#uses=1]
-        %tmp35 = call int %feof( %struct.FILE* %tmp34 )         ; <int> [#uses=1]
-        %tmp36 = icmp eq int %tmp35, 0          ; <bool> [#uses=1]
-        br bool %tmp36, label %bb, label %bb37
-
-bb37:           ; preds = %bb33
-        br label %return
-
-return:         ; preds = %bb37
-        ret void
+	%t_addr = alloca %struct.trie_s*		; <%struct.trie_s**> [#uses=2]
+	%f_addr = alloca %struct.FILE*		; <%struct.FILE**> [#uses=3]
+	%c = alloca i8, align 1		; <i8*> [#uses=7]
+	%wstate = alloca i32, align 4		; <i32*> [#uses=4]
+	%cs = alloca %struct.charsequence, align 16		; <%struct.charsequence*> [#uses=7]
+	%str = alloca i8*, align 4		; <i8**> [#uses=3]
+	%"alloca point" = bitcast i32 0 to i32		; <i32> [#uses=0]
+	store %struct.trie_s* %t, %struct.trie_s** %t_addr
+	store %struct.FILE* %f, %struct.FILE** %f_addr
+	store i32 0, i32* %wstate
+	%tmp = getelementptr %struct.charsequence* %cs, i64 0, i32 0		; <i8**> [#uses=1]
+	%tmp1 = getelementptr %struct.charsequence* @C.0.2294, i64 0, i32 0		; <i8**> [#uses=1]
+	%tmp.upgrd.5 = load i8** %tmp1		; <i8*> [#uses=1]
+	store i8* %tmp.upgrd.5, i8** %tmp
+	%tmp.upgrd.6 = getelementptr %struct.charsequence* %cs, i64 0, i32 1		; <i32*> [#uses=1]
+	%tmp2 = getelementptr %struct.charsequence* @C.0.2294, i64 0, i32 1		; <i32*> [#uses=1]
+	%tmp.upgrd.7 = load i32* %tmp2		; <i32> [#uses=1]
+	store i32 %tmp.upgrd.7, i32* %tmp.upgrd.6
+	%tmp3 = getelementptr %struct.charsequence* %cs, i64 0, i32 2		; <i32*> [#uses=1]
+	%tmp4 = getelementptr %struct.charsequence* @C.0.2294, i64 0, i32 2		; <i32*> [#uses=1]
+	%tmp5 = load i32* %tmp4		; <i32> [#uses=1]
+	store i32 %tmp5, i32* %tmp3
+	br label %bb33
+bb:		; preds = %bb33
+	%tmp.upgrd.8 = load %struct.FILE** %f_addr		; <%struct.FILE*> [#uses=1]
+	%tmp.upgrd.9 = call i32 @_IO_getc( %struct.FILE* %tmp.upgrd.8 )		; <i32> [#uses=1]
+	%tmp6 = call i32 @tolower( i32 %tmp.upgrd.9 )		; <i32> [#uses=1]
+	%tmp6.upgrd.10 = trunc i32 %tmp6 to i8		; <i8> [#uses=1]
+	store i8 %tmp6.upgrd.10, i8* %c
+	%tmp7 = load i32* %wstate		; <i32> [#uses=1]
+	%tmp.upgrd.11 = icmp ne i32 %tmp7, 0		; <i1> [#uses=1]
+	br i1 %tmp.upgrd.11, label %cond_true, label %cond_false
+cond_true:		; preds = %bb
+	%tmp.upgrd.12 = load i8* %c		; <i8> [#uses=1]
+	%tmp8 = icmp sle i8 %tmp.upgrd.12, 96		; <i1> [#uses=1]
+	br i1 %tmp8, label %cond_true9, label %cond_next
+cond_true9:		; preds = %cond_true
+	br label %bb16
+cond_next:		; preds = %cond_true
+	%tmp10 = load i8* %c		; <i8> [#uses=1]
+	%tmp11 = icmp sgt i8 %tmp10, 122		; <i1> [#uses=1]
+	br i1 %tmp11, label %cond_true12, label %cond_next13
+cond_true12:		; preds = %cond_next
+	br label %bb16
+cond_next13:		; preds = %cond_next
+	%tmp14 = load i8* %c		; <i8> [#uses=1]
+	%tmp14.upgrd.13 = sext i8 %tmp14 to i32		; <i32> [#uses=1]
+	%tmp1415 = trunc i32 %tmp14.upgrd.13 to i8		; <i8> [#uses=1]
+	call void @charsequence_push( %struct.charsequence* %cs, i8 %tmp1415 )
+	br label %bb21
+bb16:		; preds = %cond_true12, %cond_true9
+	%tmp17 = call i8* @charsequence_val( %struct.charsequence* %cs )		; <i8*> [#uses=1]
+	store i8* %tmp17, i8** %str
+	%tmp.upgrd.14 = load %struct.trie_s** %t_addr		; <%struct.trie_s*> [#uses=1]
+	%tmp18 = load i8** %str		; <i8*> [#uses=1]
+	%tmp19 = call %struct.trie_s* @trie_insert( %struct.trie_s* %tmp.upgrd.14, i8* %tmp18 )		; <%struct.trie_s*> [#uses=0]
+	%tmp20 = load i8** %str		; <i8*> [#uses=1]
+	call void @free( i8* %tmp20 )
+	store i32 0, i32* %wstate
+	br label %bb21
+bb21:		; preds = %bb16, %cond_next13
+	br label %cond_next32
+cond_false:		; preds = %bb
+	%tmp22 = load i8* %c		; <i8> [#uses=1]
+	%tmp23 = icmp sgt i8 %tmp22, 96		; <i1> [#uses=1]
+	br i1 %tmp23, label %cond_true24, label %cond_next31
+cond_true24:		; preds = %cond_false
+	%tmp25 = load i8* %c		; <i8> [#uses=1]
+	%tmp26 = icmp sle i8 %tmp25, 122		; <i1> [#uses=1]
+	br i1 %tmp26, label %cond_true27, label %cond_next30
+cond_true27:		; preds = %cond_true24
+	call void @charsequence_reset( %struct.charsequence* %cs )
+	%tmp28 = load i8* %c		; <i8> [#uses=1]
+	%tmp28.upgrd.15 = sext i8 %tmp28 to i32		; <i32> [#uses=1]
+	%tmp2829 = trunc i32 %tmp28.upgrd.15 to i8		; <i8> [#uses=1]
+	call void @charsequence_push( %struct.charsequence* %cs, i8 %tmp2829 )
+	store i32 1, i32* %wstate
+	br label %cond_next30
+cond_next30:		; preds = %cond_true27, %cond_true24
+	br label %cond_next31
+cond_next31:		; preds = %cond_next30, %cond_false
+	br label %cond_next32
+cond_next32:		; preds = %cond_next31, %bb21
+	br label %bb33
+bb33:		; preds = %cond_next32, %entry
+	%tmp34 = load %struct.FILE** %f_addr		; <%struct.FILE*> [#uses=1]
+	%tmp35 = call i32 @feof( %struct.FILE* %tmp34 )		; <i32> [#uses=1]
+	%tmp36 = icmp eq i32 %tmp35, 0		; <i1> [#uses=1]
+	br i1 %tmp36, label %bb, label %bb37
+bb37:		; preds = %bb33
+	br label %return
+return:		; preds = %bb37
+	ret void
 }
-
diff --git a/test/Transforms/SimplifyLibCalls/2005-05-20-sprintf-crash.ll b/test/Transforms/SimplifyLibCalls/2005-05-20-sprintf-crash.ll
index 5b4fde8..860a6eb 100644
--- a/test/Transforms/SimplifyLibCalls/2005-05-20-sprintf-crash.ll
+++ b/test/Transforms/SimplifyLibCalls/2005-05-20-sprintf-crash.ll
@@ -1,10 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls -disable-output
+; RUN: llvm-as < %s | opt -simplify-libcalls -disable-output
 
-%G = constant [3 x sbyte] c"%s\00"
+@G = constant [3 x i8] c"%s\00"		; <[3 x i8]*> [#uses=1]
 
-declare int %sprintf(sbyte*, sbyte*, ...)
+declare i32 @sprintf(i8*, i8*, ...)
 
-void %foo(sbyte*%P, int *%X) {
-  call int(sbyte*,sbyte*, ...)* %sprintf(sbyte* %P, sbyte* getelementptr ([3 x sbyte]* %G, int 0, int 0), int* %X)
-  ret void
+define void @foo(i8* %P, i32* %X) {
+	call i32 (i8*, i8*, ...)* @sprintf( i8* %P, i8* getelementptr ([3 x i8]* @G, i32 0, i32 0), i32* %X )		; <i32>:1 [#uses=0]
+	ret void
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/ExitInMain.ll b/test/Transforms/SimplifyLibCalls/ExitInMain.ll
index 3fded2c..8abf3b1 100644
--- a/test/Transforms/SimplifyLibCalls/ExitInMain.ll
+++ b/test/Transforms/SimplifyLibCalls/ExitInMain.ll
@@ -1,15 +1,15 @@
 ; Test that the ExitInMainOptimization pass works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:    grep {ret i32 3} | count 1
 ; END.
 
-declare void %exit(int)
-declare void %exitonly(int)
+declare void @exit(i32)
 
-implementation   ; Functions:
+declare void @exitonly(i32)
 
-int %main () {
-        call void %exitonly ( int 3 )
-        call void %exit ( int 3 )
-        ret int 0
+define i32 @main() {
+	call void @exitonly( i32 3 )
+	call void @exit( i32 3 )
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/FFS.ll b/test/Transforms/SimplifyLibCalls/FFS.ll
index 7049b5a..94228f0 100644
--- a/test/Transforms/SimplifyLibCalls/FFS.ll
+++ b/test/Transforms/SimplifyLibCalls/FFS.ll
@@ -1,29 +1,30 @@
 ; Test that the ToAsciiOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*%ffs}
 
-declare int %ffs(int)
-declare int %ffsl(int)
-declare int %ffsll(long)
+@non_const = external global i32		; <i32*> [#uses=1]
 
-%non_const = external global int
+declare i32 @ffs(i32)
 
-implementation   ; Functions:
+declare i32 @ffsl(i32)
 
-int %main () {
-  %arg  = load int* %non_const
-  %val0 = call int %ffs(int %arg)
-  %val1 = call int %ffs(int 1)
-  %val2 = call int %ffs(int 2048)
-  %val3 = call int %ffsl(int 65536)
-  %val4 = call int %ffsll(long 1024)
-  %val5 = call int %ffsll(long 17179869184)
-  %val6 = call int %ffsll(long 1152921504606846976)
-  %rslt1 = add int %val1, %val2
-  %rslt2 = add int %val3, %val4
-  %rslt3 = add int %val5, %val6
-  %rslt4 = add int %rslt1, %rslt2
-  %rslt5 = add int %rslt4, %rslt3
-  %rslt6 = add int %rslt5, %val0
-  ret int %rslt5
+declare i32 @ffsll(i64)
+
+define i32 @main() {
+	%arg = load i32* @non_const		; <i32> [#uses=1]
+	%val0 = call i32 @ffs( i32 %arg )		; <i32> [#uses=1]
+	%val1 = call i32 @ffs( i32 1 )		; <i32> [#uses=1]
+	%val2 = call i32 @ffs( i32 2048 )		; <i32> [#uses=1]
+	%val3 = call i32 @ffsl( i32 65536 )		; <i32> [#uses=1]
+	%val4 = call i32 @ffsll( i64 1024 )		; <i32> [#uses=1]
+	%val5 = call i32 @ffsll( i64 17179869184 )		; <i32> [#uses=1]
+	%val6 = call i32 @ffsll( i64 1152921504606846976 )		; <i32> [#uses=1]
+	%rslt1 = add i32 %val1, %val2		; <i32> [#uses=1]
+	%rslt2 = add i32 %val3, %val4		; <i32> [#uses=1]
+	%rslt3 = add i32 %val5, %val6		; <i32> [#uses=1]
+	%rslt4 = add i32 %rslt1, %rslt2		; <i32> [#uses=1]
+	%rslt5 = add i32 %rslt4, %rslt3		; <i32> [#uses=2]
+	%rslt6 = add i32 %rslt5, %val0		; <i32> [#uses=0]
+	ret i32 %rslt5
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/FPrintF.ll b/test/Transforms/SimplifyLibCalls/FPrintF.ll
index 53b751f..ac6b3c1 100644
--- a/test/Transforms/SimplifyLibCalls/FPrintF.ll
+++ b/test/Transforms/SimplifyLibCalls/FPrintF.ll
@@ -1,29 +1,25 @@
 ; Test that the FPrintFOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*fprintf}
 ;
 
-%struct._IO_FILE = type { int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct._IO_marker*, %struct._IO_FILE*, int, int, int, ushort, sbyte, [1 x sbyte], sbyte*, long, sbyte*, sbyte*, int, [52 x sbyte] }
-%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, int }
+	%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i32, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i32, [52 x i8] }
+	%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 }
+@str = constant [3 x i8] c"%s\00"		; <[3 x i8]*> [#uses=1]
+@chr = constant [3 x i8] c"%c\00"		; <[3 x i8]*> [#uses=1]
+@hello = constant [13 x i8] c"hello world\0A\00"		; <[13 x i8]*> [#uses=1]
+@stdout = external global %struct._IO_FILE*		; <%struct._IO_FILE**> [#uses=3]
 
-%str = constant [3 x sbyte] c"%s\00"		
-%chr = constant [3 x sbyte] c"%c\00"		
-%hello = constant [13 x sbyte] c"hello world\0A\00"
-%stdout = external global %struct._IO_FILE*		
+declare i32 @fprintf(%struct._IO_FILE*, i8*, ...)
 
-declare int %fprintf(%struct._IO_FILE*, sbyte*, ...)
-
-implementation  
-
-int %foo() 
-{
+define i32 @foo() {
 entry:
-	%tmp.1 = load %struct._IO_FILE** %stdout
-	%tmp.0 = call int (%struct._IO_FILE*, sbyte*, ...)* %fprintf( %struct._IO_FILE* %tmp.1, sbyte* getelementptr ([13 x sbyte]* %hello, int 0, int 0) )
-	%tmp.4 = load %struct._IO_FILE** %stdout
-	%tmp.3 = call int (%struct._IO_FILE*, sbyte*, ...)* %fprintf( %struct._IO_FILE* %tmp.4, sbyte* getelementptr ([3 x sbyte]* %str, int 0, int 0), sbyte* getelementptr ([13 x sbyte]* %hello, int 0, int 0) )
-	%tmp.8 = load %struct._IO_FILE** %stdout
-	%tmp.7 = call int (%struct._IO_FILE*, sbyte*, ...)* %fprintf( %struct._IO_FILE* %tmp.8, sbyte* getelementptr ([3 x sbyte]* %chr, int 0, int 0), int 33 )
-	ret int 0
+	%tmp.1 = load %struct._IO_FILE** @stdout		; <%struct._IO_FILE*> [#uses=1]
+	%tmp.0 = call i32 (%struct._IO_FILE*, i8*, ...)* @fprintf( %struct._IO_FILE* %tmp.1, i8* getelementptr ([13 x i8]* @hello, i32 0, i32 0) )		; <i32> [#uses=0]
+	%tmp.4 = load %struct._IO_FILE** @stdout		; <%struct._IO_FILE*> [#uses=1]
+	%tmp.3 = call i32 (%struct._IO_FILE*, i8*, ...)* @fprintf( %struct._IO_FILE* %tmp.4, i8* getelementptr ([3 x i8]* @str, i32 0, i32 0), i8* getelementptr ([13 x i8]* @hello, i32 0, i32 0) )		; <i32> [#uses=0]
+	%tmp.8 = load %struct._IO_FILE** @stdout		; <%struct._IO_FILE*> [#uses=1]
+	%tmp.7 = call i32 (%struct._IO_FILE*, i8*, ...)* @fprintf( %struct._IO_FILE* %tmp.8, i8* getelementptr ([3 x i8]* @chr, i32 0, i32 0), i32 33 )		; <i32> [#uses=0]
+	ret i32 0
 }
 
diff --git a/test/Transforms/SimplifyLibCalls/IsDigit.ll b/test/Transforms/SimplifyLibCalls/IsDigit.ll
index bcdb60c..a290e01 100644
--- a/test/Transforms/SimplifyLibCalls/IsDigit.ll
+++ b/test/Transforms/SimplifyLibCalls/IsDigit.ll
@@ -1,21 +1,21 @@
 ; Test that the IsDigitOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep call
 
-declare int %isdigit(int)
-declare int %isascii(int)
+declare i32 @isdigit(i32)
 
-implementation   ; Functions:
+declare i32 @isascii(i32)
 
-int %main () {
-  %val1 = call int %isdigit(int 47)
-  %val2 = call int %isdigit(int 48)
-  %val3 = call int %isdigit(int 57)
-  %val4 = call int %isdigit(int 58)
-  %rslt1 = add int %val1, %val2
-  %rslt2 = add int %val3, %val4
-  %sum = add int %rslt1, %rslt2
-  %rslt = call int %isdigit(int %sum)
-  %tmp = call int %isascii(int %rslt)
-  ret int %tmp
+define i32 @main() {
+	%val1 = call i32 @isdigit( i32 47 )		; <i32> [#uses=1]
+	%val2 = call i32 @isdigit( i32 48 )		; <i32> [#uses=1]
+	%val3 = call i32 @isdigit( i32 57 )		; <i32> [#uses=1]
+	%val4 = call i32 @isdigit( i32 58 )		; <i32> [#uses=1]
+	%rslt1 = add i32 %val1, %val2		; <i32> [#uses=1]
+	%rslt2 = add i32 %val3, %val4		; <i32> [#uses=1]
+	%sum = add i32 %rslt1, %rslt2		; <i32> [#uses=1]
+	%rslt = call i32 @isdigit( i32 %sum )		; <i32> [#uses=1]
+	%tmp = call i32 @isascii( i32 %rslt )		; <i32> [#uses=1]
+	ret i32 %tmp
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/MemCpy.ll b/test/Transforms/SimplifyLibCalls/MemCpy.ll
index 0a99488..da3261d 100644
--- a/test/Transforms/SimplifyLibCalls/MemCpy.ll
+++ b/test/Transforms/SimplifyLibCalls/MemCpy.ll
@@ -1,22 +1,22 @@
 ; Test that the StrCatOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -constprop -simplify-libcalls | \
+; RUN: llvm-as < %s | opt -constprop -simplify-libcalls | \
 ; RUN:   llvm-dis | not grep {call.*llvm.memcpy.i32}
 
-declare void %llvm.memcpy.i32(sbyte*,sbyte*,uint,uint)
-%h = constant [2 x sbyte] c"h\00"
-%hel = constant [4 x sbyte] c"hel\00"
-%hello_u = constant [8 x sbyte] c"hello_u\00"
+@h = constant [2 x i8] c"h\00"		; <[2 x i8]*> [#uses=1]
+@hel = constant [4 x i8] c"hel\00"		; <[4 x i8]*> [#uses=1]
+@hello_u = constant [8 x i8] c"hello_u\00"		; <[8 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare void @llvm.memcpy.i32(i8*, i8*, i32, i32)
 
-int %main () {
-  %h_p = getelementptr [2 x sbyte]* %h, int 0, int 0
-  %hel_p = getelementptr [4 x sbyte]* %hel, int 0, int 0
-  %hello_u_p = getelementptr [8 x sbyte]* %hello_u, int 0, int 0
-  %target = alloca [1024 x sbyte]
-  %target_p = getelementptr [1024 x sbyte]* %target, int 0, int 0
-  call void %llvm.memcpy.i32(sbyte* %target_p, sbyte* %h_p, uint 2, uint 2)
-  call void %llvm.memcpy.i32(sbyte* %target_p, sbyte* %hel_p, uint 4, uint 4)
-  call void %llvm.memcpy.i32(sbyte* %target_p, sbyte* %hello_u_p, uint 8, uint 8)
-  ret int 0
+define i32 @main() {
+	%h_p = getelementptr [2 x i8]* @h, i32 0, i32 0		; <i8*> [#uses=1]
+	%hel_p = getelementptr [4 x i8]* @hel, i32 0, i32 0		; <i8*> [#uses=1]
+	%hello_u_p = getelementptr [8 x i8]* @hello_u, i32 0, i32 0		; <i8*> [#uses=1]
+	%target = alloca [1024 x i8]		; <[1024 x i8]*> [#uses=1]
+	%target_p = getelementptr [1024 x i8]* %target, i32 0, i32 0		; <i8*> [#uses=3]
+	call void @llvm.memcpy.i32( i8* %target_p, i8* %h_p, i32 2, i32 2 )
+	call void @llvm.memcpy.i32( i8* %target_p, i8* %hel_p, i32 4, i32 4 )
+	call void @llvm.memcpy.i32( i8* %target_p, i8* %hello_u_p, i32 8, i32 8 )
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/MemMove.ll b/test/Transforms/SimplifyLibCalls/MemMove.ll
index 7c89d91..852f8db 100644
--- a/test/Transforms/SimplifyLibCalls/MemMove.ll
+++ b/test/Transforms/SimplifyLibCalls/MemMove.ll
@@ -1,22 +1,22 @@
 ; Test that the StrCatOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -constprop -simplify-libcalls | \
+; RUN: llvm-as < %s | opt -constprop -simplify-libcalls | \
 ; RUN:   llvm-dis | not grep {call.*llvm.memmove.i32}
 
-declare void %llvm.memmove.i32(sbyte*,sbyte*,uint,uint)
-%h = constant [2 x sbyte] c"h\00"
-%hel = constant [4 x sbyte] c"hel\00"
-%hello_u = constant [8 x sbyte] c"hello_u\00"
+@h = constant [2 x i8] c"h\00"		; <[2 x i8]*> [#uses=1]
+@hel = constant [4 x i8] c"hel\00"		; <[4 x i8]*> [#uses=1]
+@hello_u = constant [8 x i8] c"hello_u\00"		; <[8 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare void @llvm.memmove.i32(i8*, i8*, i32, i32)
 
-int %main () {
-  %h_p = getelementptr [2 x sbyte]* %h, int 0, int 0
-  %hel_p = getelementptr [4 x sbyte]* %hel, int 0, int 0
-  %hello_u_p = getelementptr [8 x sbyte]* %hello_u, int 0, int 0
-  %target = alloca [1024 x sbyte]
-  %target_p = getelementptr [1024 x sbyte]* %target, int 0, int 0
-  call void %llvm.memmove.i32(sbyte* %target_p, sbyte* %h_p, uint 2, uint 2)
-  call void %llvm.memmove.i32(sbyte* %target_p, sbyte* %hel_p, uint 4, uint 4)
-  call void %llvm.memmove.i32(sbyte* %target_p, sbyte* %hello_u_p, uint 8, uint 8)
-  ret int 0
+define i32 @main() {
+	%h_p = getelementptr [2 x i8]* @h, i32 0, i32 0		; <i8*> [#uses=1]
+	%hel_p = getelementptr [4 x i8]* @hel, i32 0, i32 0		; <i8*> [#uses=1]
+	%hello_u_p = getelementptr [8 x i8]* @hello_u, i32 0, i32 0		; <i8*> [#uses=1]
+	%target = alloca [1024 x i8]		; <[1024 x i8]*> [#uses=1]
+	%target_p = getelementptr [1024 x i8]* %target, i32 0, i32 0		; <i8*> [#uses=3]
+	call void @llvm.memmove.i32( i8* %target_p, i8* %h_p, i32 2, i32 2 )
+	call void @llvm.memmove.i32( i8* %target_p, i8* %hel_p, i32 4, i32 4 )
+	call void @llvm.memmove.i32( i8* %target_p, i8* %hello_u_p, i32 8, i32 8 )
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/MemSet.ll b/test/Transforms/SimplifyLibCalls/MemSet.ll
index dbeef9d..853dcbe 100644
--- a/test/Transforms/SimplifyLibCalls/MemSet.ll
+++ b/test/Transforms/SimplifyLibCalls/MemSet.ll
@@ -1,19 +1,18 @@
 ; Test that the LLVMMemSetOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*llvm.memset}
 ; END.
 
-declare void %llvm.memset.i32(sbyte*,ubyte,uint,uint)
+declare void @llvm.memset.i32(i8*, i8, i32, i32)
 
-implementation   ; Functions:
-
-int %main () {
-  %target = alloca [1024 x sbyte]
-  %target_p = getelementptr [1024 x sbyte]* %target, int 0, int 0
-  call void %llvm.memset.i32(sbyte* %target_p, ubyte 1, uint 0, uint 1)
-  call void %llvm.memset.i32(sbyte* %target_p, ubyte 1, uint 1, uint 1)
-  call void %llvm.memset.i32(sbyte* %target_p, ubyte 1, uint 2, uint 2)
-  call void %llvm.memset.i32(sbyte* %target_p, ubyte 1, uint 4, uint 4)
-  call void %llvm.memset.i32(sbyte* %target_p, ubyte 1, uint 8, uint 8)
-  ret int 0
+define i32 @main() {
+	%target = alloca [1024 x i8]		; <[1024 x i8]*> [#uses=1]
+	%target_p = getelementptr [1024 x i8]* %target, i32 0, i32 0		; <i8*> [#uses=5]
+	call void @llvm.memset.i32( i8* %target_p, i8 1, i32 0, i32 1 )
+	call void @llvm.memset.i32( i8* %target_p, i8 1, i32 1, i32 1 )
+	call void @llvm.memset.i32( i8* %target_p, i8 1, i32 2, i32 2 )
+	call void @llvm.memset.i32( i8* %target_p, i8 1, i32 4, i32 4 )
+	call void @llvm.memset.i32( i8* %target_p, i8 1, i32 8, i32 8 )
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/Pow.ll b/test/Transforms/SimplifyLibCalls/Pow.ll
index 773ba1e..fa638ef 100644
--- a/test/Transforms/SimplifyLibCalls/Pow.ll
+++ b/test/Transforms/SimplifyLibCalls/Pow.ll
@@ -1,24 +1,24 @@
 ; Testcase for calls to the standard C "pow" function
 ;
 ; Equivalent to: http://gcc.gnu.org/ml/gcc-patches/2003-02/msg01786.html
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call double .pow}
 ; END.
 
-declare double %pow(double, double)
+declare double @pow(double, double)
 
-double %test1(double %X) {
-	%Y = call double %pow(double %X, double 0.0)
-	ret double %Y    ; x^0.0 always equals 1.0
+define double @test1(double %X) {
+	%Y = call double @pow( double %X, double 0.000000e+00 )		; <double> [#uses=1]
+	ret double %Y
 }
 
-double %test2(double %X) {
-	%Y = call double %pow(double %X, double -0.0)
-	ret double %Y    ; x^-0.0 always equals 1.0
+define double @test2(double %X) {
+	%Y = call double @pow( double %X, double -0.000000e+00 )		; <double> [#uses=1]
+	ret double %Y
 }
 
-double %test3(double %X) {
-	%Y = call double %pow(double 1.0, double %X)
-	ret double %Y    ; 1.0^x always equals 1.0
+define double @test3(double %X) {
+	%Y = call double @pow( double 1.000000e+00, double %X )		; <double> [#uses=1]
+	ret double %Y
 }
 
diff --git a/test/Transforms/SimplifyLibCalls/Puts.ll b/test/Transforms/SimplifyLibCalls/Puts.ll
index 795b15c..e9bb2b3 100644
--- a/test/Transforms/SimplifyLibCalls/Puts.ll
+++ b/test/Transforms/SimplifyLibCalls/Puts.ll
@@ -1,27 +1,26 @@
 ; Test that the PutsCatOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*fputs}
 ;
-%struct._IO_FILE = type { int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct._IO_marker*, %struct._IO_FILE*, int, int, int, ushort, sbyte, [1 x sbyte], sbyte*, long, sbyte*, sbyte*, int, [52 x sbyte] }
-%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, int }
-%stdout = external global %struct._IO_FILE*		; <%struct._IO_FILE**> [#uses=1]
 
-declare int %fputs(sbyte*, %struct._IO_FILE*)
+	%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i32, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i32, [52 x i8] }
+	%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 }
+@stdout = external global %struct._IO_FILE*		; <%struct._IO_FILE**> [#uses=1]
+@empty = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
+@len1 = constant [2 x i8] c"A\00"		; <[2 x i8]*> [#uses=1]
+@long = constant [7 x i8] c"hello\0A\00"		; <[7 x i8]*> [#uses=1]
 
-%empty = constant [1 x sbyte] c"\00"
-%len1  = constant [2 x sbyte] c"A\00"
-%long  = constant [7 x sbyte] c"hello\0A\00"
+declare i32 @fputs(i8*, %struct._IO_FILE*)
 
-implementation   ; Functions:
-
-int %main() {
+define i32 @main() {
 entry:
-  %out = load %struct._IO_FILE** %stdout
-  %s1 = getelementptr [1 x sbyte]* %empty, int 0, int 0
-  %s2 = getelementptr [2 x sbyte]* %len1, int 0, int 0
-  %s3 = getelementptr [7 x sbyte]* %long, int 0, int 0
-  %a = call int %fputs( sbyte* %s1, %struct._IO_FILE* %out )
-  %b = call int %fputs( sbyte* %s2, %struct._IO_FILE* %out )
-  %c = call int %fputs( sbyte* %s3, %struct._IO_FILE* %out )
-  ret int 0
+	%out = load %struct._IO_FILE** @stdout		; <%struct._IO_FILE*> [#uses=3]
+	%s1 = getelementptr [1 x i8]* @empty, i32 0, i32 0		; <i8*> [#uses=1]
+	%s2 = getelementptr [2 x i8]* @len1, i32 0, i32 0		; <i8*> [#uses=1]
+	%s3 = getelementptr [7 x i8]* @long, i32 0, i32 0		; <i8*> [#uses=1]
+	%a = call i32 @fputs( i8* %s1, %struct._IO_FILE* %out )		; <i32> [#uses=0]
+	%b = call i32 @fputs( i8* %s2, %struct._IO_FILE* %out )		; <i32> [#uses=0]
+	%c = call i32 @fputs( i8* %s3, %struct._IO_FILE* %out )		; <i32> [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/SPrintF.ll b/test/Transforms/SimplifyLibCalls/SPrintF.ll
index a8ad369..53f5ef1 100644
--- a/test/Transforms/SimplifyLibCalls/SPrintF.ll
+++ b/test/Transforms/SimplifyLibCalls/SPrintF.ll
@@ -1,36 +1,36 @@
 ; Test that the SPrintFOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*sprintf}
 
-declare int %sprintf(sbyte*,sbyte*,...)
-declare int %puts(sbyte*)
-%hello = constant [6 x sbyte] c"hello\00"
-%null = constant [1 x sbyte] c"\00"
-%null_hello = constant [7 x sbyte] c"\00hello\00"
-%fmt1 = constant [3 x sbyte] c"%s\00"
-%fmt2 = constant [3 x sbyte] c"%c\00"
+@hello = constant [6 x i8] c"hello\00"		; <[6 x i8]*> [#uses=1]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
+@null_hello = constant [7 x i8] c"\00hello\00"		; <[7 x i8]*> [#uses=1]
+@fmt1 = constant [3 x i8] c"%s\00"		; <[3 x i8]*> [#uses=1]
+@fmt2 = constant [3 x i8] c"%c\00"		; <[3 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i32 @sprintf(i8*, i8*, ...)
 
-int %foo (sbyte* %p) {
-  %target = alloca [1024 x sbyte]
-  %target_p = getelementptr [1024 x sbyte]* %target, int 0, int 0
-  %hello_p = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %null_p = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %nh_p = getelementptr [7 x sbyte]* %null_hello, int 0, int 0
-  %fmt1_p = getelementptr [3 x sbyte]* %fmt1, int 0, int 0
-  %fmt2_p = getelementptr [3 x sbyte]* %fmt2, int 0, int 0
-  store sbyte 0, sbyte* %target_p
-  %r1 = call int (sbyte*,sbyte*,...)* %sprintf(sbyte* %target_p, sbyte* %hello_p)
-  %r2 = call int (sbyte*,sbyte*,...)* %sprintf(sbyte* %target_p, sbyte* %null_p)
-  %r3 = call int (sbyte*,sbyte*,...)* %sprintf(sbyte* %target_p, sbyte* %nh_p)
-  %r4 = call int (sbyte*,sbyte*,...)* %sprintf(sbyte* %target_p, sbyte* %fmt1_p, sbyte* %hello_p)
-  %r4.1 = call int (sbyte*,sbyte*,...)* %sprintf(sbyte* %target_p, sbyte* %fmt1_p, sbyte* %p)
-  %r5 = call int (sbyte*,sbyte*,...)* %sprintf(sbyte* %target_p, sbyte* %fmt2_p, int 82)
-  %r6 = add int %r1, %r2
-  %r7 = add int %r3, %r6
-  %r8 = add int %r5, %r7
-  %r9 = add int %r8, %r4
-  %r10 = add int %r9, %r4.1
-  ret int %r10
+declare i32 @puts(i8*)
+
+define i32 @foo(i8* %p) {
+	%target = alloca [1024 x i8]		; <[1024 x i8]*> [#uses=1]
+	%target_p = getelementptr [1024 x i8]* %target, i32 0, i32 0		; <i8*> [#uses=7]
+	%hello_p = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=2]
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%nh_p = getelementptr [7 x i8]* @null_hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%fmt1_p = getelementptr [3 x i8]* @fmt1, i32 0, i32 0		; <i8*> [#uses=2]
+	%fmt2_p = getelementptr [3 x i8]* @fmt2, i32 0, i32 0		; <i8*> [#uses=1]
+	store i8 0, i8* %target_p
+	%r1 = call i32 (i8*, i8*, ...)* @sprintf( i8* %target_p, i8* %hello_p )		; <i32> [#uses=1]
+	%r2 = call i32 (i8*, i8*, ...)* @sprintf( i8* %target_p, i8* %null_p )		; <i32> [#uses=1]
+	%r3 = call i32 (i8*, i8*, ...)* @sprintf( i8* %target_p, i8* %nh_p )		; <i32> [#uses=1]
+	%r4 = call i32 (i8*, i8*, ...)* @sprintf( i8* %target_p, i8* %fmt1_p, i8* %hello_p )		; <i32> [#uses=1]
+	%r4.1 = call i32 (i8*, i8*, ...)* @sprintf( i8* %target_p, i8* %fmt1_p, i8* %p )		; <i32> [#uses=1]
+	%r5 = call i32 (i8*, i8*, ...)* @sprintf( i8* %target_p, i8* %fmt2_p, i32 82 )		; <i32> [#uses=1]
+	%r6 = add i32 %r1, %r2		; <i32> [#uses=1]
+	%r7 = add i32 %r3, %r6		; <i32> [#uses=1]
+	%r8 = add i32 %r5, %r7		; <i32> [#uses=1]
+	%r9 = add i32 %r8, %r4		; <i32> [#uses=1]
+	%r10 = add i32 %r9, %r4.1		; <i32> [#uses=1]
+	ret i32 %r10
 }
diff --git a/test/Transforms/SimplifyLibCalls/StrCat.ll b/test/Transforms/SimplifyLibCalls/StrCat.ll
index 06bc833..a6ef677 100644
--- a/test/Transforms/SimplifyLibCalls/StrCat.ll
+++ b/test/Transforms/SimplifyLibCalls/StrCat.ll
@@ -1,25 +1,26 @@
 ; Test that the StrCatOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*strcat}
 
-declare sbyte* %strcat(sbyte*,sbyte*)
-declare int %puts(sbyte*)
-%hello = constant [6 x sbyte] c"hello\00"
-%null = constant [1 x sbyte] c"\00"
-%null_hello = constant [7 x sbyte] c"\00hello\00"
+@hello = constant [6 x i8] c"hello\00"		; <[6 x i8]*> [#uses=1]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
+@null_hello = constant [7 x i8] c"\00hello\00"		; <[7 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i8* @strcat(i8*, i8*)
 
-int %main () {
-  %target = alloca [1024 x sbyte]
-  %arg1 = getelementptr [1024 x sbyte]* %target, int 0, int 0
-  store sbyte 0, sbyte* %arg1
-  %arg2 = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %rslt1 = call sbyte* %strcat(sbyte* %arg1, sbyte* %arg2)
-  %arg3 = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %rslt2 = call sbyte* %strcat(sbyte* %rslt1, sbyte* %arg3)
-  %arg4 = getelementptr [7 x sbyte]* %null_hello, int 0, int 0
-  %rslt3 = call sbyte* %strcat(sbyte* %rslt2, sbyte* %arg4)
-  call int %puts(sbyte* %rslt3)
-  ret int 0
+declare i32 @puts(i8*)
+
+define i32 @main() {
+	%target = alloca [1024 x i8]		; <[1024 x i8]*> [#uses=1]
+	%arg1 = getelementptr [1024 x i8]* %target, i32 0, i32 0		; <i8*> [#uses=2]
+	store i8 0, i8* %arg1
+	%arg2 = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%rslt1 = call i8* @strcat( i8* %arg1, i8* %arg2 )		; <i8*> [#uses=1]
+	%arg3 = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%rslt2 = call i8* @strcat( i8* %rslt1, i8* %arg3 )		; <i8*> [#uses=1]
+	%arg4 = getelementptr [7 x i8]* @null_hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%rslt3 = call i8* @strcat( i8* %rslt2, i8* %arg4 )		; <i8*> [#uses=1]
+	call i32 @puts( i8* %rslt3 )		; <i32>:1 [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/StrChr.ll b/test/Transforms/SimplifyLibCalls/StrChr.ll
index 56e6248..f526db4 100644
--- a/test/Transforms/SimplifyLibCalls/StrChr.ll
+++ b/test/Transforms/SimplifyLibCalls/StrChr.ll
@@ -1,22 +1,22 @@
 ; Test that the StrChrOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*%strchr}
 
-declare sbyte* %strchr(sbyte*,int)
-declare int %puts(sbyte*)
-%hello = constant [14 x sbyte] c"hello world\n\00"
-%null = constant [1 x sbyte] c"\00"
+@hello = constant [14 x i8] c"hello world\5Cn\00"		; <[14 x i8]*> [#uses=1]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i8* @strchr(i8*, i32)
 
-int %main () {
-  %hello_p = getelementptr [14 x sbyte]* %hello, int 0, int 0
-  %null_p = getelementptr [1 x sbyte]* %null, int 0, int 0
+declare i32 @puts(i8*)
 
-  %world  = call sbyte* %strchr(sbyte* %hello_p, int 119 )
-  %ignore = call sbyte* %strchr(sbyte* %null_p, int 119 )
-  %len = call int %puts(sbyte* %world)
-  %index = add int %len, 112
-  %result = call sbyte* %strchr(sbyte* %hello_p, int %index)
-  ret int %index
+define i32 @main() {
+	%hello_p = getelementptr [14 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=2]
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%world = call i8* @strchr( i8* %hello_p, i32 119 )		; <i8*> [#uses=1]
+	%ignore = call i8* @strchr( i8* %null_p, i32 119 )		; <i8*> [#uses=0]
+	%len = call i32 @puts( i8* %world )		; <i32> [#uses=1]
+	%index = add i32 %len, 112		; <i32> [#uses=2]
+	%result = call i8* @strchr( i8* %hello_p, i32 %index )		; <i8*> [#uses=0]
+	ret i32 %index
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/StrCmp.ll b/test/Transforms/SimplifyLibCalls/StrCmp.ll
index ba2a4e0..ae28e4a 100644
--- a/test/Transforms/SimplifyLibCalls/StrCmp.ll
+++ b/test/Transforms/SimplifyLibCalls/StrCmp.ll
@@ -1,27 +1,28 @@
 ; Test that the StrCmpOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*strcmp}
 
-declare int %strcmp(sbyte*,sbyte*)
-declare int %puts(sbyte*)
-%hello = constant [6 x sbyte] c"hello\00"
-%hell = constant [5 x sbyte] c"hell\00"
-%null = constant [1 x sbyte] c"\00"
+@hello = constant [6 x i8] c"hello\00"		; <[6 x i8]*> [#uses=1]
+@hell = constant [5 x i8] c"hell\00"		; <[5 x i8]*> [#uses=1]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i32 @strcmp(i8*, i8*)
 
-int %main () {
-  %hello_p = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %hell_p  = getelementptr [5 x sbyte]* %hell, int 0, int 0
-  %null_p  = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %temp1 = call int %strcmp(sbyte* %hello_p, sbyte* %hello_p)
-  %temp2 = call int %strcmp(sbyte* %null_p, sbyte* %null_p)
-  %temp3 = call int %strcmp(sbyte* %hello_p, sbyte* %null_p)
-  %temp4 = call int %strcmp(sbyte* %null_p, sbyte* %hello_p)
-  %temp5 = call int %strcmp(sbyte* %hell_p, sbyte* %hello_p)
-  %rslt1 = add int %temp1, %temp2
-  %rslt2 = add int %rslt1, %temp3
-  %rslt3 = add int %rslt2, %temp4
-  %rslt4 = add int %rslt3, %temp5
-  ret int %rslt4
+declare i32 @puts(i8*)
+
+define i32 @main() {
+	%hello_p = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=5]
+	%hell_p = getelementptr [5 x i8]* @hell, i32 0, i32 0		; <i8*> [#uses=1]
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=4]
+	%temp1 = call i32 @strcmp( i8* %hello_p, i8* %hello_p )		; <i32> [#uses=1]
+	%temp2 = call i32 @strcmp( i8* %null_p, i8* %null_p )		; <i32> [#uses=1]
+	%temp3 = call i32 @strcmp( i8* %hello_p, i8* %null_p )		; <i32> [#uses=1]
+	%temp4 = call i32 @strcmp( i8* %null_p, i8* %hello_p )		; <i32> [#uses=1]
+	%temp5 = call i32 @strcmp( i8* %hell_p, i8* %hello_p )		; <i32> [#uses=1]
+	%rslt1 = add i32 %temp1, %temp2		; <i32> [#uses=1]
+	%rslt2 = add i32 %rslt1, %temp3		; <i32> [#uses=1]
+	%rslt3 = add i32 %rslt2, %temp4		; <i32> [#uses=1]
+	%rslt4 = add i32 %rslt3, %temp5		; <i32> [#uses=1]
+	ret i32 %rslt4
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/StrCpy.ll b/test/Transforms/SimplifyLibCalls/StrCpy.ll
index 481dccf..f23582c 100644
--- a/test/Transforms/SimplifyLibCalls/StrCpy.ll
+++ b/test/Transforms/SimplifyLibCalls/StrCpy.ll
@@ -1,25 +1,26 @@
 ; Test that the StrCpyOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*strcpy}
 
-declare sbyte* %strcpy(sbyte*,sbyte*)
-declare int %puts(sbyte*)
-%hello = constant [6 x sbyte] c"hello\00"
-%null = constant [1 x sbyte] c"\00"
-%null_hello = constant [7 x sbyte] c"\00hello\00"
+@hello = constant [6 x i8] c"hello\00"		; <[6 x i8]*> [#uses=1]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
+@null_hello = constant [7 x i8] c"\00hello\00"		; <[7 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i8* @strcpy(i8*, i8*)
 
-int %main () {
-  %target = alloca [1024 x sbyte]
-  %arg1 = getelementptr [1024 x sbyte]* %target, int 0, int 0
-  store sbyte 0, sbyte* %arg1
-  %arg2 = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %rslt1 = call sbyte* %strcpy(sbyte* %arg1, sbyte* %arg2)
-  %arg3 = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %rslt2 = call sbyte* %strcpy(sbyte* %rslt1, sbyte* %arg3)
-  %arg4 = getelementptr [7 x sbyte]* %null_hello, int 0, int 0
-  %rslt3 = call sbyte* %strcpy(sbyte* %rslt2, sbyte* %arg4)
-  call int %puts(sbyte* %rslt3)
-  ret int 0
+declare i32 @puts(i8*)
+
+define i32 @main() {
+	%target = alloca [1024 x i8]		; <[1024 x i8]*> [#uses=1]
+	%arg1 = getelementptr [1024 x i8]* %target, i32 0, i32 0		; <i8*> [#uses=2]
+	store i8 0, i8* %arg1
+	%arg2 = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%rslt1 = call i8* @strcpy( i8* %arg1, i8* %arg2 )		; <i8*> [#uses=1]
+	%arg3 = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%rslt2 = call i8* @strcpy( i8* %rslt1, i8* %arg3 )		; <i8*> [#uses=1]
+	%arg4 = getelementptr [7 x i8]* @null_hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%rslt3 = call i8* @strcpy( i8* %rslt2, i8* %arg4 )		; <i8*> [#uses=1]
+	call i32 @puts( i8* %rslt3 )		; <i32>:1 [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/StrLen.ll b/test/Transforms/SimplifyLibCalls/StrLen.ll
index 98a76c8..521a224 100644
--- a/test/Transforms/SimplifyLibCalls/StrLen.ll
+++ b/test/Transforms/SimplifyLibCalls/StrLen.ll
@@ -1,58 +1,56 @@
 ; Test that the StrCatOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:    not grep {call.*strlen}
 
 target datalayout = "e-p:32:32"
+@hello = constant [6 x i8] c"hello\00"		; <[6 x i8]*> [#uses=3]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=3]
+@null_hello = constant [7 x i8] c"\00hello\00"		; <[7 x i8]*> [#uses=1]
 
-declare uint %strlen(sbyte*)
-%hello      = constant [6 x sbyte] c"hello\00"
-%null       = constant [1 x sbyte] c"\00"
-%null_hello = constant [7 x sbyte] c"\00hello\00"
+declare i32 @strlen(i8*)
 
-implementation   ; Functions:
-
-uint %test1() {
-  %hello_p      = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %hello_l      = call uint %strlen(sbyte* %hello_p)
-  ret uint %hello_l
+define i32 @test1() {
+	%hello_p = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%hello_l = call i32 @strlen( i8* %hello_p )		; <i32> [#uses=1]
+	ret i32 %hello_l
 }
 
-uint %test2() {
-  %null_p       = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %null_l       = call uint %strlen(sbyte* %null_p)
-  ret uint %null_l
+define i32 @test2() {
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%null_l = call i32 @strlen( i8* %null_p )		; <i32> [#uses=1]
+	ret i32 %null_l
 }
 
-uint %test3() {
-  %null_hello_p = getelementptr [7 x sbyte]* %null_hello, int 0, int 0
-  %null_hello_l = call uint %strlen(sbyte* %null_hello_p)
-  ret uint %null_hello_l
+define i32 @test3() {
+	%null_hello_p = getelementptr [7 x i8]* @null_hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%null_hello_l = call i32 @strlen( i8* %null_hello_p )		; <i32> [#uses=1]
+	ret i32 %null_hello_l
 }
 
-bool %test4() {
-  %hello_p      = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %hello_l      = call uint %strlen(sbyte* %hello_p)
-  %eq_hello     = seteq uint %hello_l, 0
-  ret bool %eq_hello
+define i1 @test4() {
+	%hello_p = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%hello_l = call i32 @strlen( i8* %hello_p )		; <i32> [#uses=1]
+	%eq_hello = icmp eq i32 %hello_l, 0		; <i1> [#uses=1]
+	ret i1 %eq_hello
 }
 
-bool %test5() {
-  %null_p       = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %null_l       = call uint %strlen(sbyte* %null_p)
-  %eq_null      = seteq uint %null_l, 0
-  ret bool %eq_null
+define i1 @test5() {
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%null_l = call i32 @strlen( i8* %null_p )		; <i32> [#uses=1]
+	%eq_null = icmp eq i32 %null_l, 0		; <i1> [#uses=1]
+	ret i1 %eq_null
 }
 
-bool %test6() {
-  %hello_p      = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %hello_l      = call uint %strlen(sbyte* %hello_p)
-  %ne_hello     = setne uint %hello_l, 0
-  ret bool %ne_hello
+define i1 @test6() {
+	%hello_p = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=1]
+	%hello_l = call i32 @strlen( i8* %hello_p )		; <i32> [#uses=1]
+	%ne_hello = icmp ne i32 %hello_l, 0		; <i1> [#uses=1]
+	ret i1 %ne_hello
 }
 
-bool %test7() {
-  %null_p       = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %null_l       = call uint %strlen(sbyte* %null_p)
-  %ne_null      = setne uint %null_l, 0
-  ret bool %ne_null
+define i1 @test7() {
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=1]
+	%null_l = call i32 @strlen( i8* %null_p )		; <i32> [#uses=1]
+	%ne_null = icmp ne i32 %null_l, 0		; <i1> [#uses=1]
+	ret i1 %ne_null
 }
diff --git a/test/Transforms/SimplifyLibCalls/StrNCmp.ll b/test/Transforms/SimplifyLibCalls/StrNCmp.ll
index 7de3410f..f85394d 100644
--- a/test/Transforms/SimplifyLibCalls/StrNCmp.ll
+++ b/test/Transforms/SimplifyLibCalls/StrNCmp.ll
@@ -1,27 +1,28 @@
 ; Test that the StrNCmpOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*strncmp}
 
-declare int %strncmp(sbyte*,sbyte*,int)
-declare int %puts(sbyte*)
-%hello = constant [6 x sbyte] c"hello\00"
-%hell = constant [5 x sbyte] c"hell\00"
-%null = constant [1 x sbyte] c"\00"
+@hello = constant [6 x i8] c"hello\00"		; <[6 x i8]*> [#uses=1]
+@hell = constant [5 x i8] c"hell\00"		; <[5 x i8]*> [#uses=1]
+@null = constant [1 x i8] zeroinitializer		; <[1 x i8]*> [#uses=1]
 
-implementation   ; Functions:
+declare i32 @strncmp(i8*, i8*, i32)
 
-int %main () {
-  %hello_p = getelementptr [6 x sbyte]* %hello, int 0, int 0
-  %hell_p  = getelementptr [5 x sbyte]* %hell, int 0, int 0
-  %null_p  = getelementptr [1 x sbyte]* %null, int 0, int 0
-  %temp1 = call int %strncmp(sbyte* %hello_p, sbyte* %hello_p,int 5)
-  %temp2 = call int %strncmp(sbyte* %null_p, sbyte* %null_p,int 0)
-  %temp3 = call int %strncmp(sbyte* %hello_p, sbyte* %null_p,int 0)
-  %temp4 = call int %strncmp(sbyte* %null_p, sbyte* %hello_p,int 0)
-  %temp5 = call int %strncmp(sbyte* %hell_p, sbyte* %hello_p,int 4)
-  %rslt1 = add int %temp1, %temp2
-  %rslt2 = add int %rslt1, %temp3
-  %rslt3 = add int %rslt2, %temp4
-  %rslt4 = add int %rslt3, %temp5
-  ret int %rslt4
+declare i32 @puts(i8*)
+
+define i32 @main() {
+	%hello_p = getelementptr [6 x i8]* @hello, i32 0, i32 0		; <i8*> [#uses=5]
+	%hell_p = getelementptr [5 x i8]* @hell, i32 0, i32 0		; <i8*> [#uses=1]
+	%null_p = getelementptr [1 x i8]* @null, i32 0, i32 0		; <i8*> [#uses=4]
+	%temp1 = call i32 @strncmp( i8* %hello_p, i8* %hello_p, i32 5 )		; <i32> [#uses=1]
+	%temp2 = call i32 @strncmp( i8* %null_p, i8* %null_p, i32 0 )		; <i32> [#uses=1]
+	%temp3 = call i32 @strncmp( i8* %hello_p, i8* %null_p, i32 0 )		; <i32> [#uses=1]
+	%temp4 = call i32 @strncmp( i8* %null_p, i8* %hello_p, i32 0 )		; <i32> [#uses=1]
+	%temp5 = call i32 @strncmp( i8* %hell_p, i8* %hello_p, i32 4 )		; <i32> [#uses=1]
+	%rslt1 = add i32 %temp1, %temp2		; <i32> [#uses=1]
+	%rslt2 = add i32 %rslt1, %temp3		; <i32> [#uses=1]
+	%rslt3 = add i32 %rslt2, %temp4		; <i32> [#uses=1]
+	%rslt4 = add i32 %rslt3, %temp5		; <i32> [#uses=1]
+	ret i32 %rslt4
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/ToAscii.ll b/test/Transforms/SimplifyLibCalls/ToAscii.ll
index 0bc2664..9200d2f 100644
--- a/test/Transforms/SimplifyLibCalls/ToAscii.ll
+++ b/test/Transforms/SimplifyLibCalls/ToAscii.ll
@@ -1,22 +1,21 @@
 ; Test that the ToAsciiOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*toascii}
 
-declare int %toascii(int)
+declare i32 @toascii(i32)
 
-implementation   ; Functions:
-
-int %main () {
-  %val1 = call int %toascii(int 1)
-  %val2 = call int %toascii(int 0)
-  %val3 = call int %toascii(int 127)
-  %val4 = call int %toascii(int 128)
-  %val5 = call int %toascii(int 255)
-  %val6 = call int %toascii(int 256)
-  %rslt1 = add int %val1, %val2
-  %rslt2 = add int %val3, %val4
-  %rslt3 = add int %val5, %val6
-  %rslt4 = add int %rslt1, %rslt2
-  %rslt5 = add int %rslt4, %rslt3
-  ret int %rslt5
+define i32 @main() {
+	%val1 = call i32 @toascii( i32 1 )		; <i32> [#uses=1]
+	%val2 = call i32 @toascii( i32 0 )		; <i32> [#uses=1]
+	%val3 = call i32 @toascii( i32 127 )		; <i32> [#uses=1]
+	%val4 = call i32 @toascii( i32 128 )		; <i32> [#uses=1]
+	%val5 = call i32 @toascii( i32 255 )		; <i32> [#uses=1]
+	%val6 = call i32 @toascii( i32 256 )		; <i32> [#uses=1]
+	%rslt1 = add i32 %val1, %val2		; <i32> [#uses=1]
+	%rslt2 = add i32 %val3, %val4		; <i32> [#uses=1]
+	%rslt3 = add i32 %val5, %val6		; <i32> [#uses=1]
+	%rslt4 = add i32 %rslt1, %rslt2		; <i32> [#uses=1]
+	%rslt5 = add i32 %rslt4, %rslt3		; <i32> [#uses=1]
+	ret i32 %rslt5
 }
+
diff --git a/test/Transforms/SimplifyLibCalls/floor.ll b/test/Transforms/SimplifyLibCalls/floor.ll
index 2b940fd..9e9b154 100644
--- a/test/Transforms/SimplifyLibCalls/floor.ll
+++ b/test/Transforms/SimplifyLibCalls/floor.ll
@@ -1,4 +1,4 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis > %t
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis > %t
 ; RUN: not grep {call.*floor(} %t
 ; RUN: grep {call.*floorf(} %t
 ; RUN: not grep {call.*ceil(} %t
@@ -7,28 +7,33 @@
 ; RUN: grep {call.*nearbyintf(} %t
 ; XFAIL: sparc
 
-declare double %floor(double)
-declare double %ceil(double)
-declare double %nearbyint(double)
+declare double @floor(double)
 
-float %test_floor(float %C) {
-	%D = cast float %C to double
-	%E = call double %floor(double %D)  ; --> floorf
-	%F = cast double %E to float
+declare double @ceil(double)
+
+declare double @nearbyint(double)
+
+define float @test_floor(float %C) {
+	%D = fpext float %C to double		; <double> [#uses=1]
+        ; --> floorf
+	%E = call double @floor( double %D )		; <double> [#uses=1]
+	%F = fptrunc double %E to float		; <float> [#uses=1]
 	ret float %F
 }
 
-float %test_ceil(float %C) {
-	%D = cast float %C to double
-	%E = call double %ceil(double %D)  ; --> ceilf
-	%F = cast double %E to float
+define float @test_ceil(float %C) {
+	%D = fpext float %C to double		; <double> [#uses=1]
+	; --> ceilf
+        %E = call double @ceil( double %D )		; <double> [#uses=1]
+	%F = fptrunc double %E to float		; <float> [#uses=1]
 	ret float %F
 }
 
-float %test_nearbyint(float %C) {
-	%D = cast float %C to double
-	%E = call double %nearbyint(double %D)  ; --> floorf
-	%F = cast double %E to float
+define float @test_nearbyint(float %C) {
+	%D = fpext float %C to double		; <double> [#uses=1]
+	; --> floorf
+        %E = call double @nearbyint( double %D )		; <double> [#uses=1]
+	%F = fptrunc double %E to float		; <float> [#uses=1]
 	ret float %F
 }
 
diff --git a/test/Transforms/SimplifyLibCalls/memcmp.ll b/test/Transforms/SimplifyLibCalls/memcmp.ll
index bea9eed..16ae0e7 100644
--- a/test/Transforms/SimplifyLibCalls/memcmp.ll
+++ b/test/Transforms/SimplifyLibCalls/memcmp.ll
@@ -1,24 +1,24 @@
 ; Test that the memcmpOptimizer works correctly
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls | llvm-dis | \
+; RUN: llvm-as < %s | opt -simplify-libcalls | llvm-dis | \
 ; RUN:   not grep {call.*memcmp}
-; RUN: llvm-upgrade < %s | llvm-as | opt -simplify-libcalls -disable-output
+; RUN: llvm-as < %s | opt -simplify-libcalls -disable-output
 
-declare int %memcmp(sbyte*,sbyte*,int)
-%h = constant [2 x sbyte] c"h\00"
-%hel = constant [4 x sbyte] c"hel\00"
-%hello_u = constant [8 x sbyte] c"hello_u\00"
+@h = constant [2 x i8] c"h\00"		; <[2 x i8]*> [#uses=0]
+@hel = constant [4 x i8] c"hel\00"		; <[4 x i8]*> [#uses=0]
+@hello_u = constant [8 x i8] c"hello_u\00"		; <[8 x i8]*> [#uses=0]
 
-implementation
+declare i32 @memcmp(i8*, i8*, i32)
 
-void %test(sbyte *%P, sbyte *%Q, int %N, int* %IP, bool *%BP) {
-  %A = call int %memcmp(sbyte *%P, sbyte* %P, int %N)
-  volatile store int %A, int* %IP
-  %B = call int %memcmp(sbyte *%P, sbyte* %Q, int 0)
-  volatile store int %B, int* %IP
-  %C = call int %memcmp(sbyte *%P, sbyte* %Q, int 1)
-  volatile store int %C, int* %IP
-  %D = call int %memcmp(sbyte *%P, sbyte* %Q, int 2)
-  %E = seteq int %D, 0
-  volatile store bool %E, bool* %BP
-  ret void
+define void @test(i8* %P, i8* %Q, i32 %N, i32* %IP, i1* %BP) {
+	%A = call i32 @memcmp( i8* %P, i8* %P, i32 %N )		; <i32> [#uses=1]
+	volatile store i32 %A, i32* %IP
+	%B = call i32 @memcmp( i8* %P, i8* %Q, i32 0 )		; <i32> [#uses=1]
+	volatile store i32 %B, i32* %IP
+	%C = call i32 @memcmp( i8* %P, i8* %Q, i32 1 )		; <i32> [#uses=1]
+	volatile store i32 %C, i32* %IP
+	%D = call i32 @memcmp( i8* %P, i8* %Q, i32 2 )		; <i32> [#uses=1]
+	%E = icmp eq i32 %D, 0		; <i1> [#uses=1]
+	volatile store i1 %E, i1* %BP
+	ret void
 }
+
diff --git a/test/Transforms/TailCallElim/accum_recursion.ll b/test/Transforms/TailCallElim/accum_recursion.ll
index d82d963..e8c28ec 100644
--- a/test/Transforms/TailCallElim/accum_recursion.ll
+++ b/test/Transforms/TailCallElim/accum_recursion.ll
@@ -1,17 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | not grep call
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | not grep call
 
-int %factorial(int %x) {
+define i32 @factorial(i32 %x) {
 entry:
-        %tmp.1 = setgt int %x, 0
-        br bool %tmp.1, label %then, label %else
-
-then:
-        %tmp.6 = add int %x, -1
-        %tmp.4 = call int %factorial( int %tmp.6 )
-        %tmp.7 = mul int %tmp.4, %x
-        ret int %tmp.7
-
-else:
-        ret int 1
+	%tmp.1 = icmp sgt i32 %x, 0		; <i1> [#uses=1]
+	br i1 %tmp.1, label %then, label %else
+then:		; preds = %entry
+	%tmp.6 = add i32 %x, -1		; <i32> [#uses=1]
+	%tmp.4 = call i32 @factorial( i32 %tmp.6 )		; <i32> [#uses=1]
+	%tmp.7 = mul i32 %tmp.4, %x		; <i32> [#uses=1]
+	ret i32 %tmp.7
+else:		; preds = %entry
+	ret i32 1
 }
 
diff --git a/test/Transforms/TailCallElim/accum_recursion_constant_arg.ll b/test/Transforms/TailCallElim/accum_recursion_constant_arg.ll
index b103d89..4d63b59 100644
--- a/test/Transforms/TailCallElim/accum_recursion_constant_arg.ll
+++ b/test/Transforms/TailCallElim/accum_recursion_constant_arg.ll
@@ -3,20 +3,18 @@
 ; go out to the anonymous users of the demo script for "suggesting" 
 ; optimizations that should be done.  :)
 
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | not grep call
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | not grep call
 
-int %mul(int %x, int %y) {
+define i32 @mul(i32 %x, i32 %y) {
 entry:
-        %tmp.1 = seteq int %y, 0
-        br bool %tmp.1, label %return, label %endif
-
-endif:
-        %tmp.8 = add int %y, -1
-        %tmp.5 = call int %mul( int %x, int %tmp.8 )
-        %tmp.9 = add int %tmp.5, %x
-        ret int %tmp.9
-
-return:
-        ret int %x
+	%tmp.1 = icmp eq i32 %y, 0		; <i1> [#uses=1]
+	br i1 %tmp.1, label %return, label %endif
+endif:		; preds = %entry
+	%tmp.8 = add i32 %y, -1		; <i32> [#uses=1]
+	%tmp.5 = call i32 @mul( i32 %x, i32 %tmp.8 )		; <i32> [#uses=1]
+	%tmp.9 = add i32 %tmp.5, %x		; <i32> [#uses=1]
+	ret i32 %tmp.9
+return:		; preds = %entry
+	ret i32 %x
 }
 
diff --git a/test/Transforms/TailCallElim/ackermann.ll b/test/Transforms/TailCallElim/ackermann.ll
index dd6e276..f65c666 100644
--- a/test/Transforms/TailCallElim/ackermann.ll
+++ b/test/Transforms/TailCallElim/ackermann.ll
@@ -1,30 +1,26 @@
 ; This function contains two tail calls, which should be eliminated
-; RUN: llvm-upgrade < %s | llvm-as | \
+; RUN: llvm-as < %s | \
 ; RUN:   opt -tailcallelim -stats -disable-output |& grep {2 tailcallelim}
 
-int %Ack(int %M.1, int %N.1) {
+define i32 @Ack(i32 %M.1, i32 %N.1) {
 entry:
-        %tmp.1 = seteq int %M.1, 0              ; <bool> [#uses=1]
-        br bool %tmp.1, label %then.0, label %endif.0
-
-then.0:
-        %tmp.4 = add int %N.1, 1                ; <int> [#uses=1]
-        ret int %tmp.4
-
-endif.0:
-        %tmp.6 = seteq int %N.1, 0              ; <bool> [#uses=1]
-        br bool %tmp.6, label %then.1, label %endif.1
-
-then.1:
-        %tmp.10 = add int %M.1, -1              ; <int> [#uses=1]
-        %tmp.8 = call int %Ack( int %tmp.10, int 1 )            ; <int> [#uses=1]
-        ret int %tmp.8
-
-endif.1:
-        %tmp.13 = add int %M.1, -1              ; <int> [#uses=1]
-        %tmp.17 = add int %N.1, -1              ; <int> [#uses=1]
-        %tmp.14 = call int %Ack( int %M.1, int %tmp.17 )                ; <int> [#uses=1]
-        %tmp.11 = call int %Ack( int %tmp.13, int %tmp.14 )             ; <int> [#uses=1]
-        ret int %tmp.11
+	%tmp.1 = icmp eq i32 %M.1, 0		; <i1> [#uses=1]
+	br i1 %tmp.1, label %then.0, label %endif.0
+then.0:		; preds = %entry
+	%tmp.4 = add i32 %N.1, 1		; <i32> [#uses=1]
+	ret i32 %tmp.4
+endif.0:		; preds = %entry
+	%tmp.6 = icmp eq i32 %N.1, 0		; <i1> [#uses=1]
+	br i1 %tmp.6, label %then.1, label %endif.1
+then.1:		; preds = %endif.0
+	%tmp.10 = add i32 %M.1, -1		; <i32> [#uses=1]
+	%tmp.8 = call i32 @Ack( i32 %tmp.10, i32 1 )		; <i32> [#uses=1]
+	ret i32 %tmp.8
+endif.1:		; preds = %endif.0
+	%tmp.13 = add i32 %M.1, -1		; <i32> [#uses=1]
+	%tmp.17 = add i32 %N.1, -1		; <i32> [#uses=1]
+	%tmp.14 = call i32 @Ack( i32 %M.1, i32 %tmp.17 )		; <i32> [#uses=1]
+	%tmp.11 = call i32 @Ack( i32 %tmp.13, i32 %tmp.14 )		; <i32> [#uses=1]
+	ret i32 %tmp.11
 }
 
diff --git a/test/Transforms/TailCallElim/dont-tce-tail-marked-call.ll b/test/Transforms/TailCallElim/dont-tce-tail-marked-call.ll
index d3ba65e..e20fe18 100644
--- a/test/Transforms/TailCallElim/dont-tce-tail-marked-call.ll
+++ b/test/Transforms/TailCallElim/dont-tce-tail-marked-call.ll
@@ -1,12 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | \
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | \
 ; RUN:    grep {call i32 @foo}
 
-declare void %bar(int*)
-int %foo(uint %N) {
-  %A = alloca int, uint %N             ;; Should stay in entry block because of 'tail' marker
-  store int 17, int* %A
-  call void %bar(int* %A)
+declare void @bar(i32*)
 
-  %X = tail call int %foo(uint %N)  ;; Cannot -tailcallelim this without increasing stack usage!
-  ret int %X
+define i32 @foo(i32 %N) {
+	%A = alloca i32, i32 %N		; <i32*> [#uses=2]
+	store i32 17, i32* %A
+	call void @bar( i32* %A )
+	%X = tail call i32 @foo( i32 %N )		; <i32> [#uses=1]
+	ret i32 %X
 }
+
diff --git a/test/Transforms/TailCallElim/intervening-inst.ll b/test/Transforms/TailCallElim/intervening-inst.ll
index a480e3b..ae4f509 100644
--- a/test/Transforms/TailCallElim/intervening-inst.ll
+++ b/test/Transforms/TailCallElim/intervening-inst.ll
@@ -1,19 +1,17 @@
 ; This function contains intervening instructions which should be moved out of the way
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | not grep call
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | not grep call
 
-int %Test(int %X) {
+define i32 @Test(i32 %X) {
 entry:
-        %tmp.1 = seteq int %X, 0
-        br bool %tmp.1, label %then.0, label %endif.0
-
-then.0:
-        %tmp.4 = add int %X, 1
-        ret int %tmp.4
-
-endif.0:
-        %tmp.10 = add int %X, -1
-        %tmp.8 = call int %Test(int %tmp.10)
-	%DUMMY = add int %X, 1                ;; This should not prevent elimination
-        ret int %tmp.8
+	%tmp.1 = icmp eq i32 %X, 0		; <i1> [#uses=1]
+	br i1 %tmp.1, label %then.0, label %endif.0
+then.0:		; preds = %entry
+	%tmp.4 = add i32 %X, 1		; <i32> [#uses=1]
+	ret i32 %tmp.4
+endif.0:		; preds = %entry
+	%tmp.10 = add i32 %X, -1		; <i32> [#uses=1]
+	%tmp.8 = call i32 @Test( i32 %tmp.10 )		; <i32> [#uses=1]
+	%DUMMY = add i32 %X, 1		; <i32> [#uses=0]
+	ret i32 %tmp.8
 }
 
diff --git a/test/Transforms/TailCallElim/move_alloca_for_tail_call.ll b/test/Transforms/TailCallElim/move_alloca_for_tail_call.ll
index 1b1f0d0..bd2b93f 100644
--- a/test/Transforms/TailCallElim/move_alloca_for_tail_call.ll
+++ b/test/Transforms/TailCallElim/move_alloca_for_tail_call.ll
@@ -1,12 +1,13 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | \
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | \
 ; RUN:    %prcontext alloca 1 | grep {i32 @foo}
 
-declare void %bar(int*)
-int %foo() {
-  %A = alloca int             ;; Should stay in entry block because of 'tail' marker
-  store int 17, int* %A
-  call void %bar(int* %A)
+declare void @bar(i32*)
 
-  %X = tail call int %foo()
-  ret int %X
+define i32 @foo() {
+	%A = alloca i32		; <i32*> [#uses=2]
+	store i32 17, i32* %A
+	call void @bar( i32* %A )
+	%X = tail call i32 @foo( )		; <i32> [#uses=1]
+	ret i32 %X
 }
+
diff --git a/test/Transforms/TailCallElim/return_constant.ll b/test/Transforms/TailCallElim/return_constant.ll
index 5802024..ab69a42 100644
--- a/test/Transforms/TailCallElim/return_constant.ll
+++ b/test/Transforms/TailCallElim/return_constant.ll
@@ -1,19 +1,17 @@
 ; Though this case seems to be fairly unlikely to occur in the wild, someone
 ; plunked it into the demo script, so maybe they care about it.
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | not grep call
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | not grep call
 
-int %aaa(int %c) {
+define i32 @aaa(i32 %c) {
 entry:
-        %tmp.1 = seteq int %c, 0                ; <bool> [#uses=1]
-        br bool %tmp.1, label %return, label %else
-
-else:           ; preds = %entry
-        %tmp.5 = add int %c, -1         ; <int> [#uses=1]
-        %tmp.3 = call int %aaa( int %tmp.5 )            ; <int> [#uses=0]
-        ret int 0
-
-return:         ; preds = %entry
-        ret int 0
+	%tmp.1 = icmp eq i32 %c, 0		; <i1> [#uses=1]
+	br i1 %tmp.1, label %return, label %else
+else:		; preds = %entry
+	%tmp.5 = add i32 %c, -1		; <i32> [#uses=1]
+	%tmp.3 = call i32 @aaa( i32 %tmp.5 )		; <i32> [#uses=0]
+	ret i32 0
+return:		; preds = %entry
+	ret i32 0
 }
 
diff --git a/test/Transforms/TailCallElim/trivial_codegen_tailcall.ll b/test/Transforms/TailCallElim/trivial_codegen_tailcall.ll
index 98c2332..90a8163 100644
--- a/test/Transforms/TailCallElim/trivial_codegen_tailcall.ll
+++ b/test/Transforms/TailCallElim/trivial_codegen_tailcall.ll
@@ -1,12 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailcallelim | llvm-dis | \
+; RUN: llvm-as < %s | opt -tailcallelim | llvm-dis | \
 ; RUN:    grep {tail call void @foo}
 
-declare void %foo()
 
+declare void @foo()
 
-void %bar() {
-	call void %foo()
+define void @bar() {
+	call void @foo( )
 	ret void
 }
 
-
diff --git a/test/Transforms/TailDup/2003-06-24-Simpleloop.ll b/test/Transforms/TailDup/2003-06-24-Simpleloop.ll
index e2b979c..5c3b539 100644
--- a/test/Transforms/TailDup/2003-06-24-Simpleloop.ll
+++ b/test/Transforms/TailDup/2003-06-24-Simpleloop.ll
@@ -1,18 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-void %motion_result7() {
+define void @motion_result7() {
 entry:
-        br label %endif
-
-endif:
-        %i.1 = phi int [ %inc, %no_exit ], [ 0, %entry ]
-        %inc = add int %i.1, 1
-        br bool false, label %no_exit, label %UnifiedExitNode
-
-no_exit:
-        br bool false, label %UnifiedExitNode, label %endif
-
-UnifiedExitNode:
-        ret void
+	br label %endif
+endif:		; preds = %no_exit, %entry
+	%i.1 = phi i32 [ %inc, %no_exit ], [ 0, %entry ]		; <i32> [#uses=1]
+	%inc = add i32 %i.1, 1		; <i32> [#uses=1]
+	br i1 false, label %no_exit, label %UnifiedExitNode
+no_exit:		; preds = %endif
+	br i1 false, label %UnifiedExitNode, label %endif
+UnifiedExitNode:		; preds = %no_exit, %endif
+	ret void
 }
 
diff --git a/test/Transforms/TailDup/2003-07-22-InfiniteLoop.ll b/test/Transforms/TailDup/2003-07-22-InfiniteLoop.ll
index 4d65069..705f8bc 100644
--- a/test/Transforms/TailDup/2003-07-22-InfiniteLoop.ll
+++ b/test/Transforms/TailDup/2003-07-22-InfiniteLoop.ll
@@ -1,13 +1,11 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-implementation
-
-int %sum() {
+define i32 @sum() {
 entry:
 	br label %loopentry
-
-loopentry:
-	%i.0 = phi int [ 1, %entry ], [ %tmp.3, %loopentry ]
-	%tmp.3 = add int %i.0, 1
+loopentry:		; preds = %loopentry, %entry
+	%i.0 = phi i32 [ 1, %entry ], [ %tmp.3, %loopentry ]		; <i32> [#uses=1]
+	%tmp.3 = add i32 %i.0, 1		; <i32> [#uses=1]
 	br label %loopentry
 }
+
diff --git a/test/Transforms/TailDup/2003-08-23-InvalidatedPointers.ll b/test/Transforms/TailDup/2003-08-23-InvalidatedPointers.ll
index 72e03e1..1fae77b 100644
--- a/test/Transforms/TailDup/2003-08-23-InvalidatedPointers.ll
+++ b/test/Transforms/TailDup/2003-08-23-InvalidatedPointers.ll
@@ -1,40 +1,29 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-implementation
-
-int %sell_haggle() {
-entry:		; No predecessors!
-	br bool false, label %then.5, label %UnifiedExitNode
-
+define i32 @sell_haggle() {
+entry:
+	br i1 false, label %then.5, label %UnifiedExitNode
 then.5:		; preds = %entry
-	br bool false, label %loopentry.1.preheader, label %else.1
-
+	br i1 false, label %loopentry.1.preheader, label %else.1
 else.1:		; preds = %then.5
 	br label %loopentry.1.preheader
-
-loopentry.1.preheader:		; preds = %then.5, %else.1
-	%final_ask.0 = phi int [ 0, %else.1 ], [ 0, %then.5 ]		; <int> [#uses=2]
+loopentry.1.preheader:		; preds = %else.1, %then.5
+	%final_ask.0 = phi i32 [ 0, %else.1 ], [ 0, %then.5 ]		; <i32> [#uses=2]
 	br label %loopentry.1
-
-loopentry.1:		; preds = %loopentry.1.preheader, %endif.17
-	switch uint 0, label %UnifiedExitNode [
-		 uint 2, label %UnifiedExitNode
-		 uint 1, label %endif.16
+loopentry.1:		; preds = %endif.17, %loopentry.1.preheader
+	switch i32 0, label %UnifiedExitNode [
+		 i32 2, label %UnifiedExitNode
+		 i32 1, label %endif.16
 	]
-
 endif.16:		; preds = %loopentry.1
-	br bool false, label %then.17, label %UnifiedExitNode
-
+	br i1 false, label %then.17, label %UnifiedExitNode
 then.17:		; preds = %endif.16
-	br bool false, label %then.18, label %endif.17
-
+	br i1 false, label %then.18, label %endif.17
 then.18:		; preds = %then.17
-	br bool false, label %endif.17, label %UnifiedExitNode
-
-endif.17:		; preds = %then.17, %then.18
-	%cur_ask.3 = phi int [ %final_ask.0, %then.17 ], [ %final_ask.0, %then.18 ]		; <int> [#uses=0]
-	br bool false, label %loopentry.1, label %UnifiedExitNode
-
-UnifiedExitNode:		; preds = %entry, %endif.17, %then.18, %endif.16, %loopentry.1, %loopentry.1
-	ret int 0
+	br i1 false, label %endif.17, label %UnifiedExitNode
+endif.17:		; preds = %then.18, %then.17
+	%cur_ask.3 = phi i32 [ %final_ask.0, %then.17 ], [ %final_ask.0, %then.18 ]		; <i32> [#uses=0]
+	br i1 false, label %loopentry.1, label %UnifiedExitNode
+UnifiedExitNode:		; preds = %endif.17, %then.18, %endif.16, %loopentry.1, %loopentry.1, %entry
+	ret i32 0
 }
diff --git a/test/Transforms/TailDup/2003-08-31-UnreachableBlocks.ll b/test/Transforms/TailDup/2003-08-31-UnreachableBlocks.ll
index 416a5df..e464713 100644
--- a/test/Transforms/TailDup/2003-08-31-UnreachableBlocks.ll
+++ b/test/Transforms/TailDup/2003-08-31-UnreachableBlocks.ll
@@ -1,20 +1,17 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-int %foo() {
+define i32 @foo() {
 entry:
 	br label %return.i
-
-after_ret.i:
+after_ret.i:		; No predecessors!
 	br label %return.i
-
-return.i:
-	%tmp.3 = cast int* null to int
+return.i:		; preds = %after_ret.i, %entry
+	%tmp.3 = ptrtoint i32* null to i32		; <i32> [#uses=1]
 	br label %return.i1
-
-after_ret.i1:
+after_ret.i1:		; No predecessors!
 	br label %return.i1
-
-return.i1:
-	%tmp.8 = sub int %tmp.3, 0
-	ret int 0
+return.i1:		; preds = %after_ret.i1, %return.i
+	%tmp.8 = sub i32 %tmp.3, 0		; <i32> [#uses=0]
+	ret i32 0
 }
+
diff --git a/test/Transforms/TailDup/2004-04-01-DemoteRegToStack.llx b/test/Transforms/TailDup/2004-04-01-DemoteRegToStack.llx
index 4ea8490..81624ff 100644
--- a/test/Transforms/TailDup/2004-04-01-DemoteRegToStack.llx
+++ b/test/Transforms/TailDup/2004-04-01-DemoteRegToStack.llx
@@ -1,22 +1,20 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-void %interpret() {
+define void @interpret() {
 entry:
 	br label %retry
-
-retry:
-	%tmp.8 = call int %interp()
-	switch uint 0, label %endif.4 [
-		 uint 4294967271, label %return
-		 uint 4294967280, label %return
+retry:		; preds = %endif.4, %entry
+	%tmp.8 = call i32 @interp( )		; <i32> [#uses=3]
+	switch i32 0, label %endif.4 [
+		 i32 -25, label %return
+		 i32 -16, label %return
 	]
-
-endif.4:
-	br bool false, label %return, label %retry
-
-return:
-	%result.0 = phi int [ %tmp.8, %retry ], [%tmp.8, %retry], [ %tmp.8, %endif.4 ]
+endif.4:		; preds = %retry
+	br i1 false, label %return, label %retry
+return:		; preds = %endif.4, %retry, %retry
+	%result.0 = phi i32 [ %tmp.8, %retry ], [ %tmp.8, %retry ], [ %tmp.8, %endif.4 ]		; <i32> [#uses=0]
 	ret void
 }
 
-declare int %interp()
+declare i32 @interp()
+
diff --git a/test/Transforms/TailDup/MergeTest.ll b/test/Transforms/TailDup/MergeTest.ll
index c11d735..252bf56 100644
--- a/test/Transforms/TailDup/MergeTest.ll
+++ b/test/Transforms/TailDup/MergeTest.ll
@@ -1,31 +1,27 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate  | llvm-dis | grep add | not grep uses=1
+; RUN: llvm-as < %s | opt -tailduplicate  | llvm-dis | grep add | not grep uses=1
 
-int %test1(bool %C, int %A, int* %P) {
+define i32 @test1(i1 %C, i32 %A, i32* %P) {
 entry:
-        br bool %C, label %L1, label %L2
-
-L1:
-	store int 1, int* %P
-        br label %L2
-
-L2:
-	%X = add int %A, 17
-	ret int %X
+	br i1 %C, label %L1, label %L2
+L1:		; preds = %entry
+	store i32 1, i32* %P
+	br label %L2
+L2:		; preds = %L1, %entry
+	%X = add i32 %A, 17		; <i32> [#uses=1]
+	ret i32 %X
 }
 
-int %test2(bool %C, int %A, int* %P) {
+define i32 @test2(i1 %C, i32 %A, i32* %P) {
 entry:
-        br bool %C, label %L1, label %L2
-
-L1:
-	store int 1, int* %P
-        br label %L3
-
-L2:
-	store int 7, int* %P
+	br i1 %C, label %L1, label %L2
+L1:		; preds = %entry
+	store i32 1, i32* %P
 	br label %L3
-L3:
-	%X = add int %A, 17
-	ret int %X
+L2:		; preds = %entry
+	store i32 7, i32* %P
+	br label %L3
+L3:		; preds = %L2, %L1
+	%X = add i32 %A, 17		; <i32> [#uses=1]
+	ret i32 %X
 }
 
diff --git a/test/Transforms/TailDup/PHIUpdateTest.ll b/test/Transforms/TailDup/PHIUpdateTest.ll
index ae591a0..6f86587 100644
--- a/test/Transforms/TailDup/PHIUpdateTest.ll
+++ b/test/Transforms/TailDup/PHIUpdateTest.ll
@@ -1,20 +1,16 @@
 ; This test checks to make sure phi nodes are updated properly
 ;
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-
-
-int %test(bool %c, int %X, int %Y) {
+define i32 @test(i1 %c, i32 %X, i32 %Y) {
 	br label %L
-
-L:
-	%A = add int %X, %Y
-	br bool %c, label %T, label %F
-
-F:
-	br bool %c, label %L, label %T
-
-T:
-	%V = phi int [%A, %L], [0, %F]
-	ret int %V
+L:		; preds = %F, %0
+	%A = add i32 %X, %Y		; <i32> [#uses=1]
+	br i1 %c, label %T, label %F
+F:		; preds = %L
+	br i1 %c, label %L, label %T
+T:		; preds = %F, %L
+	%V = phi i32 [ %A, %L ], [ 0, %F ]		; <i32> [#uses=1]
+	ret i32 %V
 }
+
diff --git a/test/Transforms/TailDup/basictest.ll b/test/Transforms/TailDup/basictest.ll
index 085acf5..ef36890 100644
--- a/test/Transforms/TailDup/basictest.ll
+++ b/test/Transforms/TailDup/basictest.ll
@@ -1,22 +1,20 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-declare void %__main()
+declare void @__main()
 
-int %main() {
-entry:		; No predecessors!
-	call void %__main( )
+define i32 @main() {
+entry:
+	call void @__main( )
 	br label %loopentry
-
-loopentry:		; preds = %entry, %no_exit
-	%i.0 = phi int [ %inc, %no_exit ], [ 0, %entry ]		; <int> [#uses=2]
-	%tmp.1 = setle int %i.0, 99		; <bool> [#uses=1]
-	br bool %tmp.1, label %no_exit, label %return
-
+loopentry:		; preds = %no_exit, %entry
+	%i.0 = phi i32 [ %inc, %no_exit ], [ 0, %entry ]		; <i32> [#uses=3]
+	%tmp.1 = icmp sle i32 %i.0, 99		; <i1> [#uses=1]
+	br i1 %tmp.1, label %no_exit, label %return
 no_exit:		; preds = %loopentry
-	%tmp.51 = call int %main( )		; <int> [#uses=0]
-	%inc = add int %i.0, 1		; <int> [#uses=1]
+	%tmp.51 = call i32 @main( )		; <i32> [#uses=0]
+	%inc = add i32 %i.0, 1		; <i32> [#uses=1]
 	br label %loopentry
-
 return:		; preds = %loopentry
-	ret int %i.0
+	ret i32 %i.0
 }
+
diff --git a/test/Transforms/TailDup/basictest2.ll b/test/Transforms/TailDup/basictest2.ll
index c67b3d5..f79d718 100644
--- a/test/Transforms/TailDup/basictest2.ll
+++ b/test/Transforms/TailDup/basictest2.ll
@@ -1,17 +1,15 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate -disable-output
+; RUN: llvm-as < %s | opt -tailduplicate -disable-output
 
-void %ab() {
+define void @ab() {
 entry:
 	br label %loopentry.5
-
-loopentry.5:
-	%poscnt.1 = phi long [ 0, %entry ], [ %tmp.289, %no_exit.5 ]
-	%tmp.289 = shr long %poscnt.1, ubyte 1
-	br bool false, label %no_exit.5, label %loopexit.5
-
-no_exit.5:
+loopentry.5:		; preds = %no_exit.5, %entry
+	%poscnt.1 = phi i64 [ 0, %entry ], [ %tmp.289, %no_exit.5 ]		; <i64> [#uses=1]
+	%tmp.289 = ashr i64 %poscnt.1, 1		; <i64> [#uses=1]
+	br i1 false, label %no_exit.5, label %loopexit.5
+no_exit.5:		; preds = %loopentry.5
 	br label %loopentry.5
-
-loopexit.5:
+loopexit.5:		; preds = %loopentry.5
 	ret void
 }
+
diff --git a/test/Transforms/TailDup/if-tail-dup.ll b/test/Transforms/TailDup/if-tail-dup.ll
index 952a2e8..7c4d9c2 100644
--- a/test/Transforms/TailDup/if-tail-dup.ll
+++ b/test/Transforms/TailDup/if-tail-dup.ll
@@ -1,4 +1,4 @@
-; RUN: llvm-upgrade < %s | llvm-as | opt -tailduplicate | \
+; RUN: llvm-as < %s | opt -tailduplicate | \
 ; RUN:   llc -march=x86 -o %t -f
 ; RUN: grep {\\\<je\\\>} %t
 ; RUN: not grep jmp %t
@@ -12,50 +12,38 @@
 ;  if (c & 8)  P[3] = 1;
 ;}
 
-implementation
-
-void %foo(int %c, int* %P) {
+define void @foo(i32 %c, i32* %P) {
 entry:
-        %tmp1 = and int %c, 1           ; <int> [#uses=1]
-        %tmp1 = seteq int %tmp1, 0              ; <bool> [#uses=1]
-        br bool %tmp1, label %cond_next, label %cond_true
-
-cond_true:              ; preds = %entry
-        store int 1, int* %P
-        br label %cond_next
-
-cond_next:              ; preds = %entry, %cond_true
-        %tmp5 = and int %c, 2           ; <int> [#uses=1]
-        %tmp5 = seteq int %tmp5, 0              ; <bool> [#uses=1]
-        br bool %tmp5, label %cond_next10, label %cond_true6
-
-cond_true6:             ; preds = %cond_next
-        %tmp8 = getelementptr int* %P, int 1            ; <int*> [#uses=1]
-        store int 1, int* %tmp8
-        br label %cond_next10
-
-cond_next10:            ; preds = %cond_next, %cond_true6
-        %tmp13 = and int %c, 4          ; <int> [#uses=1]
-        %tmp13 = seteq int %tmp13, 0            ; <bool> [#uses=1]
-        br bool %tmp13, label %cond_next18, label %cond_true14
-
-cond_true14:            ; preds = %cond_next10
-        %tmp16 = getelementptr int* %P, int 2           ; <int*> [#uses=1]
-        store int 1, int* %tmp16
-        br label %cond_next18
-
-cond_next18:            ; preds = %cond_next10, %cond_true14
-        %tmp21 = and int %c, 8          ; <int> [#uses=1]
-        %tmp21 = seteq int %tmp21, 0            ; <bool> [#uses=1]
-        br bool %tmp21, label %return, label %cond_true22
-
-cond_true22:            ; preds = %cond_next18
-        %tmp24 = getelementptr int* %P, int 3           ; <int*> [#uses=1]
-        store int 1, int* %tmp24
-        ret void
-
-return:         ; preds = %cond_next18
-        ret void
+	%tmp1 = and i32 %c, 1		; <i32> [#uses=1]
+	%tmp1.upgrd.1 = icmp eq i32 %tmp1, 0		; <i1> [#uses=1]
+	br i1 %tmp1.upgrd.1, label %cond_next, label %cond_true
+cond_true:		; preds = %entry
+	store i32 1, i32* %P
+	br label %cond_next
+cond_next:		; preds = %cond_true, %entry
+	%tmp5 = and i32 %c, 2		; <i32> [#uses=1]
+	%tmp5.upgrd.2 = icmp eq i32 %tmp5, 0		; <i1> [#uses=1]
+	br i1 %tmp5.upgrd.2, label %cond_next10, label %cond_true6
+cond_true6:		; preds = %cond_next
+	%tmp8 = getelementptr i32* %P, i32 1		; <i32*> [#uses=1]
+	store i32 1, i32* %tmp8
+	br label %cond_next10
+cond_next10:		; preds = %cond_true6, %cond_next
+	%tmp13 = and i32 %c, 4		; <i32> [#uses=1]
+	%tmp13.upgrd.3 = icmp eq i32 %tmp13, 0		; <i1> [#uses=1]
+	br i1 %tmp13.upgrd.3, label %cond_next18, label %cond_true14
+cond_true14:		; preds = %cond_next10
+	%tmp16 = getelementptr i32* %P, i32 2		; <i32*> [#uses=1]
+	store i32 1, i32* %tmp16
+	br label %cond_next18
+cond_next18:		; preds = %cond_true14, %cond_next10
+	%tmp21 = and i32 %c, 8		; <i32> [#uses=1]
+	%tmp21.upgrd.4 = icmp eq i32 %tmp21, 0		; <i1> [#uses=1]
+	br i1 %tmp21.upgrd.4, label %return, label %cond_true22
+cond_true22:		; preds = %cond_next18
+	%tmp24 = getelementptr i32* %P, i32 3		; <i32*> [#uses=1]
+	store i32 1, i32* %tmp24
+	ret void
+return:		; preds = %cond_next18
+	ret void
 }
-
-
diff --git a/test/Verifier/invoke-1.ll b/test/Verifier/invoke-1.ll
index 36bb9d0..427abe0 100644
--- a/test/Verifier/invoke-1.ll
+++ b/test/Verifier/invoke-1.ll
@@ -1,10 +1,10 @@
-; RUN: llvm-upgrade < %s | not llvm-as |& grep {not verify as correct}
+; RUN: not llvm-as < %s |& grep {not verify as correct}
 ; PR1042
 
-int %foo() {
-   %A = invoke int %foo( )
-        to label %L unwind label %L             ; <int> [#uses=1]
-
-L: ; preds = %0, %0
-   ret int %A
+define i32 @foo() {
+	%A = invoke i32 @foo( )
+			to label %L unwind label %L		; <i32> [#uses=1]
+L:		; preds = %0, %0
+	ret i32 %A
 }
+
diff --git a/test/Verifier/invoke-2.ll b/test/Verifier/invoke-2.ll
index e544eed..27375fa 100644
--- a/test/Verifier/invoke-2.ll
+++ b/test/Verifier/invoke-2.ll
@@ -1,13 +1,14 @@
-; RUN: llvm-upgrade < %s | not llvm-as -f |& grep {not verify as correct}
+; RUN: not llvm-as < %s -f |& grep {not verify as correct}
 ; PR1042
 
-int %foo() {
-        br bool false, label %L1, label %L2
-L1:
-        %A = invoke int %foo() to label %L unwind label %L
-
-L2:
-        br label %L
-L:
-        ret int %A
+define i32 @foo() {
+	br i1 false, label %L1, label %L2
+L1:		; preds = %0
+	%A = invoke i32 @foo( )
+			to label %L unwind label %L		; <i32> [#uses=1]
+L2:		; preds = %0
+	br label %L
+L:		; preds = %L2, %L1, %L1
+	ret i32 %A
 }
+