test: add versions of some tests for LLVM 3.7

Clone some tests to have their 3.7 version. 'call's, 'load's and
'getelementptr's match the new specification in them.

@andreamattavelli: Fixed test cases: BitCastAlias test cases included
modification to alias specifications that require LLVM 3.8

[v2] added comments what was changed and why
[v3] the new tests are without suffix, the old ones have ".leq36".

Signed-off-by: Jiri Slaby <jirislaby@gmail.com>

12 files changed, 1126 insertions, 121 deletions

diff --git a/test/Concrete/BoolReadWrite.leq36.ll b/test/Concrete/BoolReadWrite.leq36.ll
new file mode 100644
index 00000000..34a50447
--- /dev/null
+++ b/test/Concrete/BoolReadWrite.leq36.ll
@@ -0,0 +1,16 @@
+; REQUIRES: lt-llvm-3.7
+; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
+
+declare void @print_i1(i1)
+
+define i32 @main() {
+        %mem = alloca i1
+        store i1 1, i1* %mem
+        %v = load i1* %mem
+        br i1 %v, label %ok, label %exit
+ok:
+	call void @print_i1(i1 %v)
+        br label %exit
+exit:
+	ret i32 0
+}
diff --git a/test/Concrete/BoolReadWrite.ll b/test/Concrete/BoolReadWrite.ll
index f818ecaf..4dfb49e0 100644
--- a/test/Concrete/BoolReadWrite.ll
+++ b/test/Concrete/BoolReadWrite.ll
@@ -1,3 +1,5 @@
+; LLVM 3.7 requires a type as the first argument to 'load'
+; REQUIRES: geq-llvm-3.7
 ; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
 
 declare void @print_i1(i1)
@@ -5,7 +7,7 @@ declare void @print_i1(i1)
 define i32 @main() {
         %mem = alloca i1
         store i1 1, i1* %mem
-        %v = load i1* %mem
+        %v = load i1, i1* %mem
         br i1 %v, label %ok, label %exit
 ok:
 	call void @print_i1(i1 %v)
diff --git a/test/Concrete/ConstantExpr.leq36.ll b/test/Concrete/ConstantExpr.leq36.ll
new file mode 100644
index 00000000..2d8e5bc6
--- /dev/null
+++ b/test/Concrete/ConstantExpr.leq36.ll
@@ -0,0 +1,166 @@
+; REQUIRES: lt-llvm-3.7
+; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
+
+; Most of the test below use the *address* of gInt as part of their computation,
+; and then perform some operation (like x | ~x) which makes the result
+; deterministic. They do, however, assume that the sign bit of the address as a
+; 64-bit value will never be set.
+@gInt = global i32 10
+@gIntWithConstant = global i32 sub(i32 ptrtoint(i32* @gInt to i32), 
+                                 i32 ptrtoint(i32* @gInt to i32))
+
+define void @"test_int_to_ptr"() {
+  %t1 = add i8 ptrtoint(i8* inttoptr(i32 100 to i8*) to i8), 0
+  %t2 = add i32 ptrtoint(i32* inttoptr(i8 100 to i32*) to i32), 0
+  %t3 = add i32 ptrtoint(i32* inttoptr(i64 100 to i32*) to i32), 0
+  %t4 = add i64 ptrtoint(i8* inttoptr(i32 100 to i8*) to i64), 0
+
+  call void @print_i8(i8 %t1)
+  call void @print_i32(i32 %t2)
+  call void @print_i32(i32 %t3)
+  call void @print_i64(i64 %t4)
+    
+  ret void
+}
+
+define void @"test_constant_ops"() {
+  %t1 = add i8 trunc(i64 add(i64 ptrtoint(i32* @gInt to i64), i64 -10) to i8), 10
+  %t2 = and i64 sub(i64 sext(i32 ptrtoint(i32* @gInt to i32) to i64), i64 ptrtoint(i32* @gInt to i64)), 4294967295
+  %t3 = and i64 sub(i64 zext(i32 ptrtoint(i32* @gInt to i32) to i64), i64 ptrtoint(i32* @gInt to i64)), 4294967295
+
+  %t4 = icmp eq i8 trunc(i64 ptrtoint(i32* @gInt to i64) to i8), %t1
+  %t5 = zext i1 %t4 to i8
+    
+  call void @print_i8(i8 %t5)
+  call void @print_i64(i64 %t2)
+  call void @print_i64(i64 %t3)
+  
+  ret void
+}
+
+define void @"test_logical_ops"() {
+  %t1 = add i32 -10, and(i32 ptrtoint(i32* @gInt to i32), i32 xor(i32 ptrtoint(i32* @gInt to i32), i32 -1))
+  %t2 = add i32 -10, or(i32 ptrtoint(i32* @gInt to i32), i32 xor(i32 ptrtoint(i32* @gInt to i32), i32 -1))
+  %t3 = add i32 -10, xor(i32 xor(i32 ptrtoint(i32* @gInt to i32), i32 1024),  i32 ptrtoint(i32* @gInt to i32))
+
+  call void @print_i32(i32 %t1)
+  call void @print_i32(i32 %t2)
+  call void @print_i32(i32 %t3)
+
+  ; or the address with 1 to ensure the addresses will differ in 'ne' below
+  %t4 = shl i64 lshr(i64 or(i64 ptrtoint(i32* @gInt to i64), i64 1), i64 8), 8
+  %t5 = shl i64 ashr(i64 or(i64 ptrtoint(i32* @gInt to i64), i64 1), i64 8), 8
+  %t6 = lshr i64 shl(i64 or(i64 ptrtoint(i32* @gInt to i64), i64 1), i64 8), 8
+  
+  %t7 = icmp eq i64 %t4, %t5
+  %t8 = icmp ne i64 %t4, %t6
+  
+  %t9 = zext i1 %t7 to i8
+  %t10 = zext i1 %t8 to i8
+  
+  call void @print_i8(i8 %t9)
+  call void @print_i8(i8 %t10)
+  
+  ret void   
+}
+
+%test.struct.type = type { i32, i32 }
+@test_struct = global %test.struct.type { i32 0, i32 10 }
+
+define void @"test_misc"() {
+  ; probability that @gInt == 100 is very very low 
+  %t1 = add i32 select(i1 icmp eq (i32* @gInt, i32* inttoptr(i32 100 to i32*)), i32 10, i32 0), 0
+  call void @print_i32(i32 %t1)
+
+  %t2 = load i32* getelementptr(%test.struct.type* @test_struct, i32 0, i32 1)
+  call void @print_i32(i32 %t2)                             
+        
+  ret void
+}
+
+define void @"test_simple_arith"() {
+  %t1 = add i32 add(i32 ptrtoint(i32* @gInt to i32), i32 0), 0
+  %t2 = add i32 sub(i32 0, i32 ptrtoint(i32* @gInt to i32)), %t1
+  %t3 = mul i32 mul(i32 ptrtoint(i32* @gInt to i32), i32 10), %t2
+
+  call void @print_i32(i32 %t3)
+
+  ret void     
+}
+
+define void @"test_div_and_mod"() {
+  %t1 = add i32 udiv(i32 ptrtoint(i32* @gInt to i32), i32 13), 0
+  %t2 = add i32 urem(i32 ptrtoint(i32* @gInt to i32), i32 13), 0
+  %t3 = add i32 sdiv(i32 ptrtoint(i32* @gInt to i32), i32 13), 0
+  %t4 = add i32 srem(i32 ptrtoint(i32* @gInt to i32), i32 13), 0
+
+  %p = ptrtoint i32* @gInt to i32
+
+  %i1 = udiv i32 %p, 13
+  %i2 = urem i32 %p, 13
+  %i3 = sdiv i32 %p, 13
+  %i4 = srem i32 %p, 13
+
+  %x1 = sub i32 %t1, %i1
+  %x2 = sub i32 %t2, %i2
+  %x3 = sub i32 %t3, %i3
+  %x4 = sub i32 %t4, %i4
+
+  call void @print_i32(i32 %x1)
+  call void @print_i32(i32 %x2)
+  call void @print_i32(i32 %x3)
+  call void @print_i32(i32 %x4)
+
+  ret void     
+}
+        
+define void @test_cmp() {
+  %t1 = add i8 zext(i1 icmp ult (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t2 = add i8 zext(i1 icmp ule (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t3 = add i8 zext(i1 icmp uge (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t4 = add i8 zext(i1 icmp ugt (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t5 = add i8 zext(i1 icmp slt (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t6 = add i8 zext(i1 icmp sle (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t7 = add i8 zext(i1 icmp sge (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t8 = add i8 zext(i1 icmp sgt (i64 ptrtoint(i32* @gInt to i64), i64 0) to i8), 1
+  %t9 = add i8 zext(i1 icmp eq (i64 ptrtoint(i32* @gInt to i64), i64 10) to i8), 1
+  %t10 = add i8 zext(i1 icmp ne (i64 ptrtoint(i32* @gInt to i64), i64 10) to i8), 1
+
+  call void @print_i1(i8 %t1)
+  call void @print_i1(i8 %t2)
+  call void @print_i1(i8 %t3)
+  call void @print_i1(i8 %t4)
+  call void @print_i1(i8 %t5)
+  call void @print_i1(i8 %t6)
+  call void @print_i1(i8 %t7)
+  call void @print_i1(i8 %t8)
+  call void @print_i1(i8 %t9)
+  call void @print_i1(i8 %t10)
+
+  ret void
+}
+
+define i32 @main() {
+    call void @test_simple_arith()
+
+    call void @test_div_and_mod()
+
+    call void @test_cmp()
+ 
+    call void @test_int_to_ptr()
+
+    call void @test_constant_ops()
+
+    call void @test_logical_ops()
+
+    call void @test_misc()
+    
+    ret i32 0
+}
+
+; defined in print_int.c
+declare void @print_i1(i8)
+declare void @print_i8(i8)
+declare void @print_i16(i16)
+declare void @print_i32(i32)
+declare void @print_i64(i64)
diff --git a/test/Concrete/ConstantExpr.ll b/test/Concrete/ConstantExpr.ll
index d00c59a6..38577f70 100644
--- a/test/Concrete/ConstantExpr.ll
+++ b/test/Concrete/ConstantExpr.ll
@@ -1,3 +1,5 @@
+; LLVM 3.7 requires a type as the first argument to 'getelementptr'
+; REQUIRES: geq-llvm-3.7
 ; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
 
 ; Most of the test below use the *address* of gInt as part of their computation,
@@ -71,7 +73,7 @@ define void @"test_misc"() {
   %t1 = add i32 select(i1 icmp eq (i32* @gInt, i32* inttoptr(i32 100 to i32*)), i32 10, i32 0), 0
   call void @print_i32(i32 %t1)
 
-  %t2 = load i32* getelementptr(%test.struct.type* @test_struct, i32 0, i32 1)
+  %t2 = load i32, i32* getelementptr(%test.struct.type, %test.struct.type* @test_struct, i32 0, i32 1)
   call void @print_i32(i32 %t2)                             
         
   ret void
diff --git a/test/Concrete/ConstantInit.leq36.ll b/test/Concrete/ConstantInit.leq36.ll
new file mode 100644
index 00000000..44f85212
--- /dev/null
+++ b/test/Concrete/ConstantInit.leq36.ll
@@ -0,0 +1,60 @@
+; REQUIRES: lt-llvm-3.7
+; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
+
+%struct.dirent = type { i64, i64, i16, i8 }
+declare void @print_i64(i64)
+
+define void @test_constant_vector_simple() {
+  entry:
+	%a = alloca %struct.dirent
+	%tmp1 = getelementptr %struct.dirent* %a, i32 0
+	%tmp2 = bitcast %struct.dirent* %tmp1 to <2 x i64>*
+	; Initialize with constant vector parsed as ConstantDataSequential
+	store <2 x i64> <i64 0, i64 4096>, <2 x i64>* %tmp2, align 8
+	
+	br label %exit
+exit:
+	; Print first initialized element
+	%idx = getelementptr %struct.dirent* %a, i32 0, i32 0
+	%val = load i64* %idx	
+	call void @print_i64(i64 %val)
+
+	; Print second initialized element	
+	%idx2 = getelementptr %struct.dirent* %a, i32 0, i32 1
+	%val2 = load i64* %idx2	
+	call void @print_i64(i64 %val2)
+	ret void	
+}
+
+define void @test_constant_vector_complex() {
+entry:
+    ; Create a vector using an uncommon type: i1024: Force usage of constant vector
+	%a = alloca <2 x i1024>
+	store <2 x i1024> <i1024 5, i1024 1024>, <2 x i1024>* %a, align 8
+
+	br label %exit
+exit:
+	; Print first initialized element
+	%idx = getelementptr <2 x i1024>* %a, i32 0, i32 0
+	%narrow = bitcast i1024* %idx to i64*
+	%val = load i64* %narrow
+	call void @print_i64(i64 %val)
+
+	; Print second initialized element
+	%idx2 = getelementptr <2 x i1024>* %a, i32 0, i32 1
+	%narrow2 = bitcast i1024* %idx2 to i64*
+	%val2 = load i64* %narrow2
+	call void @print_i64(i64 %val2)
+
+	ret void	
+}
+
+define i32 @main() {
+entry:
+	call void @test_constant_vector_simple()
+	call void @test_constant_vector_complex()
+
+	br label %exit
+exit:
+	ret i32 0
+}
diff --git a/test/Concrete/ConstantInit.ll b/test/Concrete/ConstantInit.ll
index 2127d27b..c30b7f09 100644
--- a/test/Concrete/ConstantInit.ll
+++ b/test/Concrete/ConstantInit.ll
@@ -1,3 +1,6 @@
+; LLVM 3.7 requires a type as the first argument to 'load'
+; LLVM 3.7 requires a type as the first argument to 'getelementptr'
+; REQUIRES: geq-llvm-3.7
 ; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
 
 %struct.dirent = type { i64, i64, i16, i8 }
@@ -6,23 +9,23 @@ declare void @print_i64(i64)
 define void @test_constant_vector_simple() {
   entry:
 	%a = alloca %struct.dirent
-	%tmp1 = getelementptr %struct.dirent* %a, i32 0
+	%tmp1 = getelementptr %struct.dirent, %struct.dirent* %a, i32 0
 	%tmp2 = bitcast %struct.dirent* %tmp1 to <2 x i64>*
 	; Initialize with constant vector parsed as ConstantDataSequential
 	store <2 x i64> <i64 0, i64 4096>, <2 x i64>* %tmp2, align 8
-	
+
 	br label %exit
 exit:
 	; Print first initialized element
-	%idx = getelementptr %struct.dirent* %a, i32 0, i32 0
-	%val = load i64* %idx	
+	%idx = getelementptr %struct.dirent, %struct.dirent* %a, i32 0, i32 0
+	%val = load i64, i64* %idx
 	call void @print_i64(i64 %val)
 
-	; Print second initialized element	
-	%idx2 = getelementptr %struct.dirent* %a, i32 0, i32 1
-	%val2 = load i64* %idx2	
+	; Print second initialized element
+	%idx2 = getelementptr %struct.dirent, %struct.dirent* %a, i32 0, i32 1
+	%val2 = load i64, i64* %idx2
 	call void @print_i64(i64 %val2)
-	ret void	
+	ret void
 }
 
 define void @test_constant_vector_complex() {
@@ -34,18 +37,18 @@ entry:
 	br label %exit
 exit:
 	; Print first initialized element
-	%idx = getelementptr <2 x i1024>* %a, i32 0, i32 0
+	%idx = getelementptr <2 x i1024>, <2 x i1024>* %a, i32 0, i32 0
 	%narrow = bitcast i1024* %idx to i64*
-	%val = load i64* %narrow
+	%val = load i64, i64* %narrow
 	call void @print_i64(i64 %val)
 
 	; Print second initialized element
-	%idx2 = getelementptr <2 x i1024>* %a, i32 0, i32 1
+	%idx2 = getelementptr <2 x i1024>, <2 x i1024>* %a, i32 0, i32 1
 	%narrow2 = bitcast i1024* %idx2 to i64*
-	%val2 = load i64* %narrow2
+	%val2 = load i64, i64* %narrow2
 	call void @print_i64(i64 %val2)
 
-	ret void	
+	ret void
 }
 
 define i32 @main() {
diff --git a/test/Concrete/FloatingPointOps.leq36.ll b/test/Concrete/FloatingPointOps.leq36.ll
new file mode 100644
index 00000000..b81a3b8d
--- /dev/null
+++ b/test/Concrete/FloatingPointOps.leq36.ll
@@ -0,0 +1,678 @@
+; REQUIRES: lt-llvm-3.7
+; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
+
+; casting error messages
+@.strTrunc     = internal constant [15 x i8] c"FPTrunc broken\00"
+@.strExt       = internal constant [13 x i8] c"FPExt broken\00"
+@.strFPToUIFlt = internal constant [20 x i8] c"FPToUI float broken\00"
+@.strFPToUIDbl = internal constant [21 x i8] c"FPToUI double broken\00"
+@.strFPToSIFlt = internal constant [20 x i8] c"FPToSI float broken\00"
+@.strFPToSIDbl = internal constant [21 x i8] c"FPToSI double broken\00"
+@.strUIToFPFlt = internal constant [20 x i8] c"UIToFP float broken\00"
+@.strUIToFPDbl = internal constant [21 x i8] c"UIToFP double broken\00"
+@.strSIToFPFlt = internal constant [20 x i8] c"SIToFP float broken\00"
+@.strSIToFPDbl = internal constant [21 x i8] c"SIToFP double broken\00"
+
+; mathematical operator error messages
+@.strDivFlt    = internal constant [18 x i8] c"FDiv float broken\00"
+@.strDivDbl    = internal constant [19 x i8] c"FDiv double broken\00"
+@.strRemFlt    = internal constant [18 x i8] c"FRem float broken\00"
+@.strRemDbl    = internal constant [19 x i8] c"FRem double broken\00"
+@.strAddInt    = internal constant [16 x i8] c"Add ints broken\00"
+@.strAddFlt    = internal constant [18 x i8] c"Add floats broken\00"
+@.strAddDbl    = internal constant [19 x i8] c"Add doubles broken\00"
+@.strSubInt    = internal constant [16 x i8] c"Sub ints broken\00"
+@.strSubFlt    = internal constant [18 x i8] c"Sub floats broken\00"
+@.strSubDbl    = internal constant [19 x i8] c"Sub doubles broken\00"
+@.strMulInt    = internal constant [16 x i8] c"Mul ints broken\00"
+@.strMulFlt    = internal constant [18 x i8] c"Mul floats broken\00"
+@.strMulDbl    = internal constant [19 x i8] c"Mul doubles broken\00"
+
+; fcmp error messages
+@.strCmpTrFlt  = internal constant [19 x i8] c"floats TRUE broken\00" ; fcmp::generic broken msgs
+@.strCmpFaFlt  = internal constant [20 x i8] c"floats FALSE broken\00"
+@.strCmpTrDbl  = internal constant [19 x i8] c"double TRUE broken\00"
+@.strCmpFaDbl  = internal constant [20 x i8] c"double FALSE broken\00"
+@.strCmpEqFlt  = internal constant [17 x i8] c"floats == broken\00" ; fcmp::ordered broken msgs
+@.strCmpGeFlt  = internal constant [17 x i8] c"floats >= broken\00"
+@.strCmpGtFlt  = internal constant [17 x i8] c"floats >  broken\00"
+@.strCmpLeFlt  = internal constant [17 x i8] c"floats <= broken\00"
+@.strCmpLtFlt  = internal constant [17 x i8] c"floats <  broken\00"
+@.strCmpNeFlt  = internal constant [17 x i8] c"floats != broken\00"
+@.strCmpOrdFlt = internal constant [18 x i8] c"floats ORD broken\00"
+@.strCmpEqDbl  = internal constant [18 x i8] c"doubles == broken\00"
+@.strCmpGeDbl  = internal constant [18 x i8] c"doubles >= broken\00"
+@.strCmpGtDbl  = internal constant [18 x i8] c"doubles >  broken\00"
+@.strCmpLeDbl  = internal constant [18 x i8] c"doubles <= broken\00"
+@.strCmpLtDbl  = internal constant [18 x i8] c"doubles <  broken\00"
+@.strCmpNeDbl  = internal constant [18 x i8] c"doubles != broken\00"
+@.strCmpOrdDbl = internal constant [19 x i8] c"doubles ORD broken\00"
+@.strCmpEqFltU = internal constant [17 x i8] c"U:floats==broken\00" ; fcmp::unordered broken msgs
+@.strCmpGeFltU = internal constant [17 x i8] c"U:floats>=broken\00"
+@.strCmpGtFltU = internal constant [17 x i8] c"U:floats> broken\00"
+@.strCmpLeFltU = internal constant [17 x i8] c"U:floats<=broken\00"
+@.strCmpLtFltU = internal constant [17 x i8] c"U:floats< broken\00"
+@.strCmpNeFltU = internal constant [17 x i8] c"U:floats!=broken\00"
+@.strCmpUnoFlt = internal constant [20 x i8] c"U:floats UNO broken\00"
+@.strCmpEqDblU = internal constant [18 x i8] c"U:doubles==broken\00"
+@.strCmpGeDblU = internal constant [18 x i8] c"U:doubles>=broken\00"
+@.strCmpGtDblU = internal constant [18 x i8] c"U:doubles> broken\00"
+@.strCmpLeDblU = internal constant [18 x i8] c"U:doubles<=broken\00"
+@.strCmpLtDblU = internal constant [18 x i8] c"U:doubles< broken\00"
+@.strCmpNeDblU = internal constant [18 x i8] c"U:doubles!=broken\00"
+@.strCmpUnoDbl = internal constant [21 x i8] c"U:doubles UNO broken\00"
+
+@.strWorks     = internal constant [20 x i8] c"Everything works!\0D\0A\00"
+@.strNL        = internal constant [3 x i8]  c"\0D\0A\00"
+
+declare i32 @printf(i8*, ...)
+declare void @exit(i32)
+
+; if isOk is false, then print errMsg to stdout and exit(1)
+define void @failCheck(i1 %isOk, i8* %errMsg) {
+entry:
+  %fail = icmp eq i1 %isOk, 0
+  br i1 %fail, label %failed, label %return
+
+failed:
+  ; print the error msg
+  %ret = call i32 (i8*, ...)* @printf( i8* %errMsg )
+
+  ; add a newline to the ostream
+  %nl = getelementptr [3 x i8]* @.strNL, i32 0, i32 0
+  %ret2 = call i32 (i8*, ...)* @printf( i8* %nl )
+
+  ; exit with return value 1 to denote that an error occurred
+  call void @exit( i32 1 )
+  unreachable
+
+return:
+  ret void
+}
+
+; test FPTrunc which casts doubles to floats
+define void @testFPTrunc() {
+entry:
+  %d_addr = alloca double, align 8
+  store double 8.000000e+00, double* %d_addr
+  %d = load double* %d_addr
+  %f = fptrunc double %d to float
+  %matches = fcmp oeq float %f, 8.000000e+00
+  %err_msg = getelementptr [15 x i8]* @.strTrunc, i32 0, i32 0
+  call void @failCheck( i1 %matches, i8* %err_msg )
+  ret void
+}
+
+; test FPExt which casts floats to doubles
+define void @testFPExt() {
+entry:
+  %f_addr = alloca float, align 4
+  store float 8.000000e+00, float* %f_addr
+  %f = load float* %f_addr
+  %d = fpext float %f to double
+  %matches = fcmp oeq double %d, 8.000000e+00
+  %err_msg = getelementptr [13 x i8]* @.strExt, i32 0, i32 0
+  call void @failCheck( i1 %matches, i8* %err_msg )
+  ret void
+}
+
+; test casting fp to an unsigned int
+define void @testFPToUI() {
+entry:
+  %f_addr = alloca float, align 4
+  %d_addr = alloca double, align 8
+
+  ; test float to UI
+  store float 0x4020333340000000, float* %f_addr; %f = 8.1
+  %f = load float* %f_addr
+  %uf = fptoui float %f to i32
+  %matchesf = icmp eq i32 %uf, 8
+  %err_msgf = getelementptr [20 x i8]* @.strFPToUIFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; test double to UI
+  store double 8.100000e+00, double* %d_addr
+  %d = load double* %d_addr
+  %ud = fptoui double %d to i32
+  %matchesd = icmp eq i32 %ud, 8
+  %err_msgd = getelementptr [21 x i8]* @.strFPToUIDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test casting fp to a signed int
+define void @testFPToSI() {
+entry:
+  %f_addr = alloca float, align 4
+  %d_addr = alloca double, align 8
+
+  ; test float 8.1 to signed int
+  store float 0x4020333340000000, float* %f_addr
+  %f = load float* %f_addr
+  %sf = fptosi float %f to i32
+  %matchesf = icmp eq i32 %sf, 8
+  %err_msgf = getelementptr [20 x i8]* @.strFPToSIFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; test double -8.1 to signed int
+  store double -8.100000e+00, double* %d_addr
+  %d = load double* %d_addr
+  %sd = fptosi double %d to i32
+  %matchesd = icmp eq i32 %sd, -8
+  %err_msgd = getelementptr [21 x i8]* @.strFPToSIDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test casting unsigned int to fp
+define void @testUIToFP() {
+entry:
+  ; unsigned int to float
+  %f = uitofp i32 7 to float
+  %matchesf = fcmp oeq float %f, 7.000000e+00
+  %err_msgf = getelementptr [20 x i8]* @.strUIToFPFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; unsigned int to double
+  %d = uitofp i32 7 to double
+  %matchesd = fcmp oeq double %d, 7.000000e+00
+  %err_msgd = getelementptr [21 x i8]* @.strUIToFPDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test casting signed int to fp
+define void @testSIToFP() {
+entry:
+  ; signed int to float
+  %f = sitofp i32 -7 to float
+  %matchesf = fcmp oeq float %f, -7.000000e+00
+  %err_msgf = getelementptr [20 x i8]* @.strSIToFPFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; signed int to double
+  %d = sitofp i32 -7 to double
+  %matchesd = fcmp oeq double %d, -7.000000e+00
+  %err_msgd = getelementptr [21 x i8]* @.strSIToFPDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; testing fp division
+define void @testFDiv() {
+entry:
+  %fN_addr = alloca float, align 4
+  %fD_addr = alloca float, align 4
+  %dN_addr = alloca double, align 8
+  %dD_addr = alloca double, align 8
+
+  ; float division
+  store float 2.200000e+01, float* %fN_addr
+  store float 4.000000e+00, float* %fD_addr
+  %fN = load float* %fN_addr
+  %fD = load float* %fD_addr
+  %f = fdiv float %fN, %fD
+  %matchesf = fcmp oeq float %f, 5.500000e+00
+  %err_msgf = getelementptr [18 x i8]* @.strDivFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; double division
+  store double 2.200000e+01, double* %dN_addr
+  store double -4.000000e+00, double* %dD_addr
+  %dN = load double* %dN_addr
+  %dD = load double* %dD_addr
+  %d = fdiv double %dN, %dD
+  %matchesd = fcmp oeq double %d, -5.500000e+00
+  %err_msgd = getelementptr [19 x i8]* @.strDivDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; testing fp modulo
+define void @testFRem() {
+entry:
+  %fN_addr = alloca float, align 4
+  %fD_addr = alloca float, align 4
+  %dN_addr = alloca double, align 8
+  %dD_addr = alloca double, align 8
+
+  ; float modoulo
+  store float 2.200000e+01, float* %fN_addr
+  store float 4.000000e+00, float* %fD_addr
+  %fN = load float* %fN_addr
+  %fD = load float* %fD_addr
+  %f = frem float %fN, %fD
+  %matchesf = fcmp oeq float %f, 2.000000e+00
+  %err_msgf = getelementptr [18 x i8]* @.strRemFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; double modulo
+  store double -2.200000e+01, double* %dN_addr
+  store double 4.000000e+00, double* %dD_addr
+  %dN = load double* %dN_addr
+  %dD = load double* %dD_addr
+  %d = frem double %dN, %dD
+  %matchesd = fcmp oeq double %d, -2.000000e+00
+  %err_msgd = getelementptr [19 x i8]* @.strRemDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test addition
+define void @testAdd() {
+entry:
+  %f1_addr = alloca float, align 4
+  %f2_addr = alloca float, align 4
+  %d1_addr = alloca double, align 8
+  %d2_addr = alloca double, align 8
+
+  ; test integer addition (3 + 4)
+  %sumi = add i32 3, 4
+  %matchesi = icmp eq i32 %sumi, 7
+  %err_msgi = getelementptr [16 x i8]* @.strAddInt, i32 0, i32 0
+  call void @failCheck( i1 %matchesi, i8* %err_msgi )
+
+  ; test float addition (3.5 + 4.2)
+  store float 3.500000e+00, float* %f1_addr
+  store float 0x4010CCCCC0000000, float* %f2_addr
+  %f1 = load float* %f1_addr
+  %f2 = load float* %f2_addr
+  %sumf = fadd float %f1, %f2
+  %matchesf = fcmp oeq float %sumf, 0x401ECCCCC0000000
+  %err_msgf = getelementptr [18 x i8]* @.strAddFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; test double addition (3.5 + -4.2)
+  store double 3.500000e+00, double* %d1_addr
+  store double -4.200000e+00, double* %d2_addr
+  %d1 = load double* %d1_addr
+  %d2 = load double* %d2_addr
+  %sumd = fadd double %d1, %d2
+  %matchesd = fcmp oeq double %sumd, 0xBFE6666666666668
+  %err_msgd = getelementptr [19 x i8]* @.strAddDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test subtraction
+define void @testSub() {
+entry:
+  %f1_addr = alloca float, align 4
+  %f2_addr = alloca float, align 4
+  %d1_addr = alloca double, align 8
+  %d2_addr = alloca double, align 8
+
+  ; test integer subtraction (3 - 4)
+  %subi = sub i32 3, 4
+  %matchesi = icmp eq i32 %subi, -1
+  %err_msgi = getelementptr [16 x i8]* @.strSubInt, i32 0, i32 0
+  call void @failCheck( i1 %matchesi, i8* %err_msgi )
+
+  ; test float subtraction (3.5 - 4.2)
+  store float 3.500000e+00, float* %f1_addr
+  store float 0x4010CCCCC0000000, float* %f2_addr
+  %f1 = load float* %f1_addr
+  %f2 = load float* %f2_addr
+  %subf = fsub float %f1, %f2
+  %matchesf = fcmp oeq float %subf, 0xBFE6666600000000
+  %err_msgf = getelementptr [18 x i8]* @.strSubFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; test double subtraction (3.5 - -4.2)
+  store double 3.500000e+00, double* %d1_addr
+  store double -4.200000e+00, double* %d2_addr
+  %d1 = load double* %d1_addr
+  %d2 = load double* %d2_addr
+  %subd = fsub double %d1, %d2
+  %matchesd = fcmp oeq double %subd, 7.700000e+00
+  %err_msgd = getelementptr [19 x i8]* @.strSubDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test multiplication
+define void @testMul() {
+entry:
+  %f1_addr = alloca float, align 4
+  %f2_addr = alloca float, align 4
+  %d1_addr = alloca double, align 8
+  %d2_addr = alloca double, align 8
+
+  ; test integer multiplication (3 * 4)
+  %muli = mul i32 3, 4
+  %matchesi = icmp eq i32 %muli, 12
+  %err_msgi = getelementptr [16 x i8]* @.strMulInt, i32 0, i32 0
+  call void @failCheck( i1 %matchesi, i8* %err_msgi )
+
+  ; test float multiplication (3.5 * 4.2)
+  store float 3.500000e+00, float* %f1_addr
+  store float 0x4010CCCCC0000000, float* %f2_addr
+  %f1 = load float* %f1_addr
+  %f2 = load float* %f2_addr
+  %mulf = fmul float %f1, %f2
+  %matchesf = fcmp oeq float %mulf, 0x402D666640000000
+  %err_msgf = getelementptr [18 x i8]* @.strMulFlt, i32 0, i32 0
+  call void @failCheck( i1 %matchesf, i8* %err_msgf )
+
+  ; test double multiplication (3.5 * -4.2)
+  store double 3.500000e+00, double* %d1_addr
+  store double -4.200000e+00, double* %d2_addr
+  %d1 = load double* %d1_addr
+  %d2 = load double* %d2_addr
+  %muld = fmul double %d1, %d2
+  %matchesd = fcmp oeq double %muld, 0xC02D666666666667
+  %err_msgd = getelementptr [19 x i8]* @.strMulDbl, i32 0, i32 0
+  call void @failCheck( i1 %matchesd, i8* %err_msgd )
+
+  ret void
+}
+
+; test float comparisons (ordered)
+define void @testFCmpFOrdered(float %f1, float %f2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord) {
+entry:
+  ; test fcmp::true -- should always return true
+  %cmp_t    = fcmp true float %f1, %f2
+  %cmp_t_ok = icmp eq i1 %cmp_t, 1
+  %cmp_t_em = getelementptr [19 x i8]* @.strCmpTrFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_t_ok, i8* %cmp_t_em )
+
+  ; test fcmp::false -- should always return false
+  %cmp_f    = fcmp false float %f1, %f2
+  %cmp_f_ok = icmp eq i1 %cmp_f, 0
+  %cmp_f_em = getelementptr [20 x i8]* @.strCmpFaFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_f_ok, i8* %cmp_f_em )
+
+  ; test fcmp::ord -- should return true if neither operand is NaN
+  %cmp_o    = fcmp ord float %f1, %f2
+  %cmp_o_ok = icmp eq i1 %cmp_o, %ord
+  %cmp_o_em = getelementptr [18 x i8]* @.strCmpOrdFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
+
+  ; test fcmp::oeq -- should return true if neither operand is a NaN and they are equal
+  %cmp_eq    = fcmp oeq float %f1, %f2
+  %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
+  %cmp_eq_em = getelementptr [17 x i8]* @.strCmpEqFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
+
+  ; test fcmp::oge -- should return true if neither operand is a NaN and the first is greater or equal
+  %cmp_ge    = fcmp oge float %f1, %f2
+  %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
+  %cmp_ge_em = getelementptr [17 x i8]* @.strCmpGeFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
+
+  ; test fcmp::ogt -- should return true if neither operand is a NaN and the first is greater
+  %cmp_gt    = fcmp ogt float %f1, %f2
+  %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
+  %cmp_gt_em = getelementptr [17 x i8]* @.strCmpGtFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
+
+  ; test fcmp::ole -- should return true if neither operand is a NaN and the first is less or equal
+  %cmp_le    = fcmp ole float %f1, %f2
+  %cmp_le_ok = icmp eq i1 %cmp_le, %le
+  %cmp_le_em = getelementptr [17 x i8]* @.strCmpLeFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
+
+  ; test fcmp::olt -- should return true if neither operand is a NaN and the first is less
+  %cmp_lt    = fcmp olt float %f1, %f2
+  %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
+  %cmp_lt_em = getelementptr [17 x i8]* @.strCmpLtFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
+
+  ; test fcmp::one -- should return true if neither operand is a NaN and they are not equal
+  %cmp_ne    = fcmp one float %f1, %f2
+  %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
+  %cmp_ne_em = getelementptr [17 x i8]* @.strCmpNeFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
+
+  ret void
+}
+
+; test double comparisons (ordered)
+define void @testFCmpDOrdered(double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord) {
+entry:
+  ; test fcmp::true -- should always return true
+  %cmp_t    = fcmp true double %d1, %d2
+  %cmp_t_ok = icmp eq i1 %cmp_t, 1
+  %cmp_t_em = getelementptr [19 x i8]* @.strCmpTrDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_t_ok, i8* %cmp_t_em )
+
+  ; test fcmp::false -- should always return false
+  %cmp_f    = fcmp false double %d1, %d2
+  %cmp_f_ok = icmp eq i1 %cmp_f, 0
+  %cmp_f_em = getelementptr [20 x i8]* @.strCmpFaDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_f_ok, i8* %cmp_f_em )
+
+  ; test fcmp::ord -- should return true if neither operand is NaN
+  %cmp_o    = fcmp ord double %d1, %d2
+  %cmp_o_ok = icmp eq i1 %cmp_o, %ord
+  %cmp_o_em = getelementptr [19 x i8]* @.strCmpOrdDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
+
+  ; test fcmp::oeq -- should return true if neither operand is a NaN and they are equal
+  %cmp_eq    = fcmp oeq double %d1, %d2
+  %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
+  %cmp_eq_em = getelementptr [18 x i8]* @.strCmpEqDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
+
+  ; test fcmp::oge -- should return true if neither operand is a NaN and the first is greater or equal
+  %cmp_ge    = fcmp oge double %d1, %d2
+  %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
+  %cmp_ge_em = getelementptr [18 x i8]* @.strCmpGeDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
+
+  ; test fcmp::ogt -- should return true if neither operand is a NaN and the first is greater
+  %cmp_gt    = fcmp ogt double %d1, %d2
+  %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
+  %cmp_gt_em = getelementptr [18 x i8]* @.strCmpGtDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
+
+  ; test fcmp::ole -- should return true if neither operand is a NaN and the first is less or equal
+  %cmp_le    = fcmp ole double %d1, %d2
+  %cmp_le_ok = icmp eq i1 %cmp_le, %le
+  %cmp_le_em = getelementptr [18 x i8]* @.strCmpLeDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
+
+  ; test fcmp::olt -- should return true if neither operand is a NaN and the first is less
+  %cmp_lt    = fcmp olt double %d1, %d2
+  %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
+  %cmp_lt_em = getelementptr [18 x i8]* @.strCmpLtDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
+
+  ; test fcmp::one -- should return true if neither operand is a NaN and they are not equal
+  %cmp_ne    = fcmp one double %d1, %d2
+  %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
+  %cmp_ne_em = getelementptr [18 x i8]* @.strCmpNeDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
+
+  ret void
+}
+
+; test floating point comparisons (ordered)
+define void @testFCmpBothOrdered(double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord) {
+entry:
+  call void @testFCmpDOrdered( double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord )
+
+  %f1 = fptrunc double %d1 to float
+  %f2 = fptrunc double %d2 to float
+  call void @testFCmpFOrdered( float %f1, float %f2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord )
+
+  ret void
+}
+
+; test float comparisons (unordered)
+define void @testFCmpFUnordered(float %f1, float %f2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %uno) {
+entry:
+  ; test fcmp::uno -- should return true if either operand is NaN
+  %cmp_o    = fcmp uno float %f1, %f2
+  %cmp_o_ok = icmp eq i1 %cmp_o, %uno
+  %cmp_o_em = getelementptr [20 x i8]* @.strCmpUnoFlt, i32 0, i32 0
+  call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
+
+  ; test fcmp::oeq -- should return true if either operand is a NaN and they are equal
+  %cmp_eq    = fcmp ueq float %f1, %f2
+  %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
+  %cmp_eq_em = getelementptr [17 x i8]* @.strCmpEqFltU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
+
+  ; test fcmp::oge -- should return true if either operand is a NaN and the first is greater or equal
+  %cmp_ge    = fcmp uge float %f1, %f2
+  %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
+  %cmp_ge_em = getelementptr [17 x i8]* @.strCmpGeFltU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
+
+  ; test fcmp::ogt -- should return true if either operand is a NaN and the first is greater
+  %cmp_gt    = fcmp ugt float %f1, %f2
+  %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
+  %cmp_gt_em = getelementptr [17 x i8]* @.strCmpGtFltU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
+
+  ; test fcmp::ole -- should return true if either operand is a NaN and the first is less or equal
+  %cmp_le    = fcmp ule float %f1, %f2
+  %cmp_le_ok = icmp eq i1 %cmp_le, %le
+  %cmp_le_em = getelementptr [17 x i8]* @.strCmpLeFltU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
+
+  ; test fcmp::olt -- should return true if either operand is a NaN and the first is less
+  %cmp_lt    = fcmp ult float %f1, %f2
+  %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
+  %cmp_lt_em = getelementptr [17 x i8]* @.strCmpLtFltU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
+
+  ; test fcmp::one -- should return true if either operand is a NaN and they are not equal
+  %cmp_ne    = fcmp une float %f1, %f2
+  %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
+  %cmp_ne_em = getelementptr [17 x i8]* @.strCmpNeFltU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
+
+  ret void
+}
+
+; test double comparisons (unordered)
+define void @testFCmpDUnordered(double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %uno) {
+entry:
+  ; test fcmp::uno -- should return true if either operand is NaN
+  %cmp_o    = fcmp uno double %d1, %d2
+  %cmp_o_ok = icmp eq i1 %cmp_o, %uno
+  %cmp_o_em = getelementptr [21 x i8]* @.strCmpUnoDbl, i32 0, i32 0
+  call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
+
+  ; test fcmp::ueq -- should return true if either operand is a NaN and they are equal
+  %cmp_eq    = fcmp ueq double %d1, %d2
+  %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
+  %cmp_eq_em = getelementptr [18 x i8]* @.strCmpEqDblU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
+
+  ; test fcmp::uge -- should return true if either operand is a NaN and the first is greater or equal
+  %cmp_ge    = fcmp uge double %d1, %d2
+  %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
+  %cmp_ge_em = getelementptr [18 x i8]* @.strCmpGeDblU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
+
+  ; test fcmp::ugt -- should return true if either operand is a NaN and the first is greater
+  %cmp_gt    = fcmp ugt double %d1, %d2
+  %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
+  %cmp_gt_em = getelementptr [18 x i8]* @.strCmpGtDblU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
+
+  ; test fcmp::ule -- should return true if either operand is a NaN and the first is less or equal
+  %cmp_le    = fcmp ule double %d1, %d2
+  %cmp_le_ok = icmp eq i1 %cmp_le, %le
+  %cmp_le_em = getelementptr [18 x i8]* @.strCmpLeDblU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
+
+  ; test fcmp::ult -- should return true if either operand is a NaN and the first is less
+  %cmp_lt    = fcmp ult double %d1, %d2
+  %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
+  %cmp_lt_em = getelementptr [18 x i8]* @.strCmpLtDblU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
+
+  ; test fcmp::une -- should return true if either operand is a NaN and they are not equal
+  %cmp_ne    = fcmp une double %d1, %d2
+  %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
+  %cmp_ne_em = getelementptr [18 x i8]* @.strCmpNeDblU, i32 0, i32 0
+  call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
+
+  ret void
+}
+
+; test floating point comparisons (unordered)
+define void @testFCmpBothUnordered(double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %uno) {
+entry:
+  call void @testFCmpDUnordered( double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %uno )
+
+  %f1 = fptrunc double %d1 to float
+  %f2 = fptrunc double %d2 to float
+  call void @testFCmpFUnordered( float %f1, float %f2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %uno )
+
+  ret void
+}
+
+; test floating point comparisons (ordered and unordered)
+define void @testFCmpBoth(double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord, i1 %uno) {
+entry:
+  call void @testFCmpBothOrdered( double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %ord )
+  call void @testFCmpBothUnordered( double %d1, double %d2, i1 %eq, i1 %ge, i1 %gt, i1 %le, i1 %lt, i1 %ne, i1 %uno )
+
+  ret void
+}
+
+; test floating point comparisons (ordered and unordered) with a variety of real numbers and NaNs as operands
+define void @testFCmp() {
+entry:
+  %x = alloca i64, align 8
+  %nan = alloca double, align 8
+
+  ; test FCmp on some real number inputs
+  call void @testFCmpBoth( double 0.000000e+00, double 0.000000e+00, i1 1, i1 1, i1 0, i1 1, i1 0, i1 0, i1 1, i1 0 )
+  call void @testFCmpBoth( double 0.000000e+00, double 1.000000e+00, i1 0, i1 0, i1 0, i1 1, i1 1, i1 1, i1 1, i1 0 )
+  call void @testFCmpBoth( double 1.000000e+00, double 0.000000e+00, i1 0, i1 1, i1 1, i1 0, i1 0, i1 1, i1 1, i1 0 )
+
+  ; build NaN
+  %nan_as_i64 = bitcast double* %nan to i64*
+  store i64 -1, i64* %nan_as_i64
+
+  ; load two copies of our NaN
+  %nan1 = load double* %nan
+  %nan2 = load double* %nan
+
+  ; NaNs do different things depending on ordered vs unordered
+  call void @testFCmpBothOrdered( double %nan1, double 0.000000e+00, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0 )
+  call void @testFCmpBothOrdered( double %nan1, double %nan2, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0 )
+  call void @testFCmpBothUnordered( double %nan1, double 0.000000e+00, i1 1, i1 1, i1 1, i1 1, i1 1, i1 1, i1 1 )
+  call void @testFCmpBothUnordered( double %nan1, double %nan2, i1 1, i1 1, i1 1, i1 1, i1 1, i1 1, i1 1 )
+
+  ret void
+}
+
+; test all floating point instructions
+define i32 @main() {
+entry:
+  call void @testFPTrunc( )
+  call void @testFPExt( )
+  call void @testFPToUI( )
+  call void @testFPToSI( )
+  call void @testUIToFP( )
+  call void @testSIToFP( )
+
+  call void @testFDiv( )
+  call void @testFRem( )
+  call void @testAdd( )
+  call void @testSub( )
+  call void @testMul( )
+
+  call void @testFCmp( )
+
+  ; everything worked -- print a message saying so
+  %works_msg = getelementptr [20 x i8]* @.strWorks, i32 0, i32 0
+  %ret = call i32 (i8*, ...)* @printf( i8* %works_msg )
+
+  ret i32 0
+}
diff --git a/test/Concrete/FloatingPointOps.ll b/test/Concrete/FloatingPointOps.ll
index 00d4e877..4c96e336 100644
--- a/test/Concrete/FloatingPointOps.ll
+++ b/test/Concrete/FloatingPointOps.ll
@@ -1,3 +1,7 @@
+; LLVM 3.7 requires a type as the first argument to 'load'
+; LLVM 3.7 requires a type as the first argument to 'getelementptr'
+; LLVM 3.7 no longer accepts '*' with a 'call'
+; REQUIRES: geq-llvm-3.7
 ; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
 
 ; casting error messages
@@ -75,11 +79,11 @@ entry:
 
 failed:
   ; print the error msg
-  %ret = call i32 (i8*, ...)* @printf( i8* %errMsg )
+  %ret = call i32 (i8*, ...) @printf( i8* %errMsg )
 
   ; add a newline to the ostream
-  %nl = getelementptr [3 x i8]* @.strNL, i32 0, i32 0
-  %ret2 = call i32 (i8*, ...)* @printf( i8* %nl )
+  %nl = getelementptr [3 x i8], [3 x i8]* @.strNL, i32 0, i32 0
+  %ret2 = call i32 (i8*, ...) @printf( i8* %nl )
 
   ; exit with return value 1 to denote that an error occurred
   call void @exit( i32 1 )
@@ -94,10 +98,10 @@ define void @testFPTrunc() {
 entry:
   %d_addr = alloca double, align 8
   store double 8.000000e+00, double* %d_addr
-  %d = load double* %d_addr
+  %d = load double, double* %d_addr
   %f = fptrunc double %d to float
   %matches = fcmp oeq float %f, 8.000000e+00
-  %err_msg = getelementptr [15 x i8]* @.strTrunc, i32 0, i32 0
+  %err_msg = getelementptr [15 x i8], [15 x i8]* @.strTrunc, i32 0, i32 0
   call void @failCheck( i1 %matches, i8* %err_msg )
   ret void
 }
@@ -107,10 +111,10 @@ define void @testFPExt() {
 entry:
   %f_addr = alloca float, align 4
   store float 8.000000e+00, float* %f_addr
-  %f = load float* %f_addr
+  %f = load float, float* %f_addr
   %d = fpext float %f to double
   %matches = fcmp oeq double %d, 8.000000e+00
-  %err_msg = getelementptr [13 x i8]* @.strExt, i32 0, i32 0
+  %err_msg = getelementptr [13 x i8], [13 x i8]* @.strExt, i32 0, i32 0
   call void @failCheck( i1 %matches, i8* %err_msg )
   ret void
 }
@@ -123,18 +127,18 @@ entry:
 
   ; test float to UI
   store float 0x4020333340000000, float* %f_addr; %f = 8.1
-  %f = load float* %f_addr
+  %f = load float, float* %f_addr
   %uf = fptoui float %f to i32
   %matchesf = icmp eq i32 %uf, 8
-  %err_msgf = getelementptr [20 x i8]* @.strFPToUIFlt, i32 0, i32 0
+  %err_msgf = getelementptr [20 x i8], [20 x i8]* @.strFPToUIFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; test double to UI
   store double 8.100000e+00, double* %d_addr
-  %d = load double* %d_addr
+  %d = load double, double* %d_addr
   %ud = fptoui double %d to i32
   %matchesd = icmp eq i32 %ud, 8
-  %err_msgd = getelementptr [21 x i8]* @.strFPToUIDbl, i32 0, i32 0
+  %err_msgd = getelementptr [21 x i8], [21 x i8]* @.strFPToUIDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -148,18 +152,18 @@ entry:
 
   ; test float 8.1 to signed int
   store float 0x4020333340000000, float* %f_addr
-  %f = load float* %f_addr
+  %f = load float, float* %f_addr
   %sf = fptosi float %f to i32
   %matchesf = icmp eq i32 %sf, 8
-  %err_msgf = getelementptr [20 x i8]* @.strFPToSIFlt, i32 0, i32 0
+  %err_msgf = getelementptr [20 x i8], [20 x i8]* @.strFPToSIFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; test double -8.1 to signed int
   store double -8.100000e+00, double* %d_addr
-  %d = load double* %d_addr
+  %d = load double, double* %d_addr
   %sd = fptosi double %d to i32
   %matchesd = icmp eq i32 %sd, -8
-  %err_msgd = getelementptr [21 x i8]* @.strFPToSIDbl, i32 0, i32 0
+  %err_msgd = getelementptr [21 x i8], [21 x i8]* @.strFPToSIDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -171,13 +175,13 @@ entry:
   ; unsigned int to float
   %f = uitofp i32 7 to float
   %matchesf = fcmp oeq float %f, 7.000000e+00
-  %err_msgf = getelementptr [20 x i8]* @.strUIToFPFlt, i32 0, i32 0
+  %err_msgf = getelementptr [20 x i8], [20 x i8]* @.strUIToFPFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; unsigned int to double
   %d = uitofp i32 7 to double
   %matchesd = fcmp oeq double %d, 7.000000e+00
-  %err_msgd = getelementptr [21 x i8]* @.strUIToFPDbl, i32 0, i32 0
+  %err_msgd = getelementptr [21 x i8], [21 x i8]* @.strUIToFPDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -189,13 +193,13 @@ entry:
   ; signed int to float
   %f = sitofp i32 -7 to float
   %matchesf = fcmp oeq float %f, -7.000000e+00
-  %err_msgf = getelementptr [20 x i8]* @.strSIToFPFlt, i32 0, i32 0
+  %err_msgf = getelementptr [20 x i8], [20 x i8]* @.strSIToFPFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; signed int to double
   %d = sitofp i32 -7 to double
   %matchesd = fcmp oeq double %d, -7.000000e+00
-  %err_msgd = getelementptr [21 x i8]* @.strSIToFPDbl, i32 0, i32 0
+  %err_msgd = getelementptr [21 x i8], [21 x i8]* @.strSIToFPDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -212,21 +216,21 @@ entry:
   ; float division
   store float 2.200000e+01, float* %fN_addr
   store float 4.000000e+00, float* %fD_addr
-  %fN = load float* %fN_addr
-  %fD = load float* %fD_addr
+  %fN = load float, float* %fN_addr
+  %fD = load float, float* %fD_addr
   %f = fdiv float %fN, %fD
   %matchesf = fcmp oeq float %f, 5.500000e+00
-  %err_msgf = getelementptr [18 x i8]* @.strDivFlt, i32 0, i32 0
+  %err_msgf = getelementptr [18 x i8], [18 x i8]* @.strDivFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; double division
   store double 2.200000e+01, double* %dN_addr
   store double -4.000000e+00, double* %dD_addr
-  %dN = load double* %dN_addr
-  %dD = load double* %dD_addr
+  %dN = load double, double* %dN_addr
+  %dD = load double, double* %dD_addr
   %d = fdiv double %dN, %dD
   %matchesd = fcmp oeq double %d, -5.500000e+00
-  %err_msgd = getelementptr [19 x i8]* @.strDivDbl, i32 0, i32 0
+  %err_msgd = getelementptr [19 x i8], [19 x i8]* @.strDivDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -243,21 +247,21 @@ entry:
   ; float modoulo
   store float 2.200000e+01, float* %fN_addr
   store float 4.000000e+00, float* %fD_addr
-  %fN = load float* %fN_addr
-  %fD = load float* %fD_addr
+  %fN = load float, float* %fN_addr
+  %fD = load float, float* %fD_addr
   %f = frem float %fN, %fD
   %matchesf = fcmp oeq float %f, 2.000000e+00
-  %err_msgf = getelementptr [18 x i8]* @.strRemFlt, i32 0, i32 0
+  %err_msgf = getelementptr [18 x i8], [18 x i8]* @.strRemFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; double modulo
   store double -2.200000e+01, double* %dN_addr
   store double 4.000000e+00, double* %dD_addr
-  %dN = load double* %dN_addr
-  %dD = load double* %dD_addr
+  %dN = load double, double* %dN_addr
+  %dD = load double, double* %dD_addr
   %d = frem double %dN, %dD
   %matchesd = fcmp oeq double %d, -2.000000e+00
-  %err_msgd = getelementptr [19 x i8]* @.strRemDbl, i32 0, i32 0
+  %err_msgd = getelementptr [19 x i8], [19 x i8]* @.strRemDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -274,27 +278,27 @@ entry:
   ; test integer addition (3 + 4)
   %sumi = add i32 3, 4
   %matchesi = icmp eq i32 %sumi, 7
-  %err_msgi = getelementptr [16 x i8]* @.strAddInt, i32 0, i32 0
+  %err_msgi = getelementptr [16 x i8], [16 x i8]* @.strAddInt, i32 0, i32 0
   call void @failCheck( i1 %matchesi, i8* %err_msgi )
 
   ; test float addition (3.5 + 4.2)
   store float 3.500000e+00, float* %f1_addr
   store float 0x4010CCCCC0000000, float* %f2_addr
-  %f1 = load float* %f1_addr
-  %f2 = load float* %f2_addr
+  %f1 = load float, float* %f1_addr
+  %f2 = load float, float* %f2_addr
   %sumf = fadd float %f1, %f2
   %matchesf = fcmp oeq float %sumf, 0x401ECCCCC0000000
-  %err_msgf = getelementptr [18 x i8]* @.strAddFlt, i32 0, i32 0
+  %err_msgf = getelementptr [18 x i8], [18 x i8]* @.strAddFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; test double addition (3.5 + -4.2)
   store double 3.500000e+00, double* %d1_addr
   store double -4.200000e+00, double* %d2_addr
-  %d1 = load double* %d1_addr
-  %d2 = load double* %d2_addr
+  %d1 = load double, double* %d1_addr
+  %d2 = load double, double* %d2_addr
   %sumd = fadd double %d1, %d2
   %matchesd = fcmp oeq double %sumd, 0xBFE6666666666668
-  %err_msgd = getelementptr [19 x i8]* @.strAddDbl, i32 0, i32 0
+  %err_msgd = getelementptr [19 x i8], [19 x i8]* @.strAddDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -311,27 +315,27 @@ entry:
   ; test integer subtraction (3 - 4)
   %subi = sub i32 3, 4
   %matchesi = icmp eq i32 %subi, -1
-  %err_msgi = getelementptr [16 x i8]* @.strSubInt, i32 0, i32 0
+  %err_msgi = getelementptr [16 x i8], [16 x i8]* @.strSubInt, i32 0, i32 0
   call void @failCheck( i1 %matchesi, i8* %err_msgi )
 
   ; test float subtraction (3.5 - 4.2)
   store float 3.500000e+00, float* %f1_addr
   store float 0x4010CCCCC0000000, float* %f2_addr
-  %f1 = load float* %f1_addr
-  %f2 = load float* %f2_addr
+  %f1 = load float, float* %f1_addr
+  %f2 = load float, float* %f2_addr
   %subf = fsub float %f1, %f2
   %matchesf = fcmp oeq float %subf, 0xBFE6666600000000
-  %err_msgf = getelementptr [18 x i8]* @.strSubFlt, i32 0, i32 0
+  %err_msgf = getelementptr [18 x i8], [18 x i8]* @.strSubFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; test double subtraction (3.5 - -4.2)
   store double 3.500000e+00, double* %d1_addr
   store double -4.200000e+00, double* %d2_addr
-  %d1 = load double* %d1_addr
-  %d2 = load double* %d2_addr
+  %d1 = load double, double* %d1_addr
+  %d2 = load double, double* %d2_addr
   %subd = fsub double %d1, %d2
   %matchesd = fcmp oeq double %subd, 7.700000e+00
-  %err_msgd = getelementptr [19 x i8]* @.strSubDbl, i32 0, i32 0
+  %err_msgd = getelementptr [19 x i8], [19 x i8]* @.strSubDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -348,27 +352,27 @@ entry:
   ; test integer multiplication (3 * 4)
   %muli = mul i32 3, 4
   %matchesi = icmp eq i32 %muli, 12
-  %err_msgi = getelementptr [16 x i8]* @.strMulInt, i32 0, i32 0
+  %err_msgi = getelementptr [16 x i8], [16 x i8]* @.strMulInt, i32 0, i32 0
   call void @failCheck( i1 %matchesi, i8* %err_msgi )
 
   ; test float multiplication (3.5 * 4.2)
   store float 3.500000e+00, float* %f1_addr
   store float 0x4010CCCCC0000000, float* %f2_addr
-  %f1 = load float* %f1_addr
-  %f2 = load float* %f2_addr
+  %f1 = load float, float* %f1_addr
+  %f2 = load float, float* %f2_addr
   %mulf = fmul float %f1, %f2
   %matchesf = fcmp oeq float %mulf, 0x402D666640000000
-  %err_msgf = getelementptr [18 x i8]* @.strMulFlt, i32 0, i32 0
+  %err_msgf = getelementptr [18 x i8], [18 x i8]* @.strMulFlt, i32 0, i32 0
   call void @failCheck( i1 %matchesf, i8* %err_msgf )
 
   ; test double multiplication (3.5 * -4.2)
   store double 3.500000e+00, double* %d1_addr
   store double -4.200000e+00, double* %d2_addr
-  %d1 = load double* %d1_addr
-  %d2 = load double* %d2_addr
+  %d1 = load double, double* %d1_addr
+  %d2 = load double, double* %d2_addr
   %muld = fmul double %d1, %d2
   %matchesd = fcmp oeq double %muld, 0xC02D666666666667
-  %err_msgd = getelementptr [19 x i8]* @.strMulDbl, i32 0, i32 0
+  %err_msgd = getelementptr [19 x i8], [19 x i8]* @.strMulDbl, i32 0, i32 0
   call void @failCheck( i1 %matchesd, i8* %err_msgd )
 
   ret void
@@ -380,55 +384,55 @@ entry:
   ; test fcmp::true -- should always return true
   %cmp_t    = fcmp true float %f1, %f2
   %cmp_t_ok = icmp eq i1 %cmp_t, 1
-  %cmp_t_em = getelementptr [19 x i8]* @.strCmpTrFlt, i32 0, i32 0
+  %cmp_t_em = getelementptr [19 x i8], [19 x i8]* @.strCmpTrFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_t_ok, i8* %cmp_t_em )
 
   ; test fcmp::false -- should always return false
   %cmp_f    = fcmp false float %f1, %f2
   %cmp_f_ok = icmp eq i1 %cmp_f, 0
-  %cmp_f_em = getelementptr [20 x i8]* @.strCmpFaFlt, i32 0, i32 0
+  %cmp_f_em = getelementptr [20 x i8], [20 x i8]* @.strCmpFaFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_f_ok, i8* %cmp_f_em )
 
   ; test fcmp::ord -- should return true if neither operand is NaN
   %cmp_o    = fcmp ord float %f1, %f2
   %cmp_o_ok = icmp eq i1 %cmp_o, %ord
-  %cmp_o_em = getelementptr [18 x i8]* @.strCmpOrdFlt, i32 0, i32 0
+  %cmp_o_em = getelementptr [18 x i8], [18 x i8]* @.strCmpOrdFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
 
   ; test fcmp::oeq -- should return true if neither operand is a NaN and they are equal
   %cmp_eq    = fcmp oeq float %f1, %f2
   %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
-  %cmp_eq_em = getelementptr [17 x i8]* @.strCmpEqFlt, i32 0, i32 0
+  %cmp_eq_em = getelementptr [17 x i8], [17 x i8]* @.strCmpEqFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
 
   ; test fcmp::oge -- should return true if neither operand is a NaN and the first is greater or equal
   %cmp_ge    = fcmp oge float %f1, %f2
   %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
-  %cmp_ge_em = getelementptr [17 x i8]* @.strCmpGeFlt, i32 0, i32 0
+  %cmp_ge_em = getelementptr [17 x i8], [17 x i8]* @.strCmpGeFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
 
   ; test fcmp::ogt -- should return true if neither operand is a NaN and the first is greater
   %cmp_gt    = fcmp ogt float %f1, %f2
   %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
-  %cmp_gt_em = getelementptr [17 x i8]* @.strCmpGtFlt, i32 0, i32 0
+  %cmp_gt_em = getelementptr [17 x i8], [17 x i8]* @.strCmpGtFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
 
   ; test fcmp::ole -- should return true if neither operand is a NaN and the first is less or equal
   %cmp_le    = fcmp ole float %f1, %f2
   %cmp_le_ok = icmp eq i1 %cmp_le, %le
-  %cmp_le_em = getelementptr [17 x i8]* @.strCmpLeFlt, i32 0, i32 0
+  %cmp_le_em = getelementptr [17 x i8], [17 x i8]* @.strCmpLeFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
 
   ; test fcmp::olt -- should return true if neither operand is a NaN and the first is less
   %cmp_lt    = fcmp olt float %f1, %f2
   %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
-  %cmp_lt_em = getelementptr [17 x i8]* @.strCmpLtFlt, i32 0, i32 0
+  %cmp_lt_em = getelementptr [17 x i8], [17 x i8]* @.strCmpLtFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
 
   ; test fcmp::one -- should return true if neither operand is a NaN and they are not equal
   %cmp_ne    = fcmp one float %f1, %f2
   %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
-  %cmp_ne_em = getelementptr [17 x i8]* @.strCmpNeFlt, i32 0, i32 0
+  %cmp_ne_em = getelementptr [17 x i8], [17 x i8]* @.strCmpNeFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
 
   ret void
@@ -440,55 +444,55 @@ entry:
   ; test fcmp::true -- should always return true
   %cmp_t    = fcmp true double %d1, %d2
   %cmp_t_ok = icmp eq i1 %cmp_t, 1
-  %cmp_t_em = getelementptr [19 x i8]* @.strCmpTrDbl, i32 0, i32 0
+  %cmp_t_em = getelementptr [19 x i8], [19 x i8]* @.strCmpTrDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_t_ok, i8* %cmp_t_em )
 
   ; test fcmp::false -- should always return false
   %cmp_f    = fcmp false double %d1, %d2
   %cmp_f_ok = icmp eq i1 %cmp_f, 0
-  %cmp_f_em = getelementptr [20 x i8]* @.strCmpFaDbl, i32 0, i32 0
+  %cmp_f_em = getelementptr [20 x i8], [20 x i8]* @.strCmpFaDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_f_ok, i8* %cmp_f_em )
 
   ; test fcmp::ord -- should return true if neither operand is NaN
   %cmp_o    = fcmp ord double %d1, %d2
   %cmp_o_ok = icmp eq i1 %cmp_o, %ord
-  %cmp_o_em = getelementptr [19 x i8]* @.strCmpOrdDbl, i32 0, i32 0
+  %cmp_o_em = getelementptr [19 x i8], [19 x i8]* @.strCmpOrdDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
 
   ; test fcmp::oeq -- should return true if neither operand is a NaN and they are equal
   %cmp_eq    = fcmp oeq double %d1, %d2
   %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
-  %cmp_eq_em = getelementptr [18 x i8]* @.strCmpEqDbl, i32 0, i32 0
+  %cmp_eq_em = getelementptr [18 x i8], [18 x i8]* @.strCmpEqDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
 
   ; test fcmp::oge -- should return true if neither operand is a NaN and the first is greater or equal
   %cmp_ge    = fcmp oge double %d1, %d2
   %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
-  %cmp_ge_em = getelementptr [18 x i8]* @.strCmpGeDbl, i32 0, i32 0
+  %cmp_ge_em = getelementptr [18 x i8], [18 x i8]* @.strCmpGeDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
 
   ; test fcmp::ogt -- should return true if neither operand is a NaN and the first is greater
   %cmp_gt    = fcmp ogt double %d1, %d2
   %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
-  %cmp_gt_em = getelementptr [18 x i8]* @.strCmpGtDbl, i32 0, i32 0
+  %cmp_gt_em = getelementptr [18 x i8], [18 x i8]* @.strCmpGtDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
 
   ; test fcmp::ole -- should return true if neither operand is a NaN and the first is less or equal
   %cmp_le    = fcmp ole double %d1, %d2
   %cmp_le_ok = icmp eq i1 %cmp_le, %le
-  %cmp_le_em = getelementptr [18 x i8]* @.strCmpLeDbl, i32 0, i32 0
+  %cmp_le_em = getelementptr [18 x i8], [18 x i8]* @.strCmpLeDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
 
   ; test fcmp::olt -- should return true if neither operand is a NaN and the first is less
   %cmp_lt    = fcmp olt double %d1, %d2
   %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
-  %cmp_lt_em = getelementptr [18 x i8]* @.strCmpLtDbl, i32 0, i32 0
+  %cmp_lt_em = getelementptr [18 x i8], [18 x i8]* @.strCmpLtDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
 
   ; test fcmp::one -- should return true if neither operand is a NaN and they are not equal
   %cmp_ne    = fcmp one double %d1, %d2
   %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
-  %cmp_ne_em = getelementptr [18 x i8]* @.strCmpNeDbl, i32 0, i32 0
+  %cmp_ne_em = getelementptr [18 x i8], [18 x i8]* @.strCmpNeDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
 
   ret void
@@ -512,43 +516,43 @@ entry:
   ; test fcmp::uno -- should return true if either operand is NaN
   %cmp_o    = fcmp uno float %f1, %f2
   %cmp_o_ok = icmp eq i1 %cmp_o, %uno
-  %cmp_o_em = getelementptr [20 x i8]* @.strCmpUnoFlt, i32 0, i32 0
+  %cmp_o_em = getelementptr [20 x i8], [20 x i8]* @.strCmpUnoFlt, i32 0, i32 0
   call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
 
   ; test fcmp::oeq -- should return true if either operand is a NaN and they are equal
   %cmp_eq    = fcmp ueq float %f1, %f2
   %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
-  %cmp_eq_em = getelementptr [17 x i8]* @.strCmpEqFltU, i32 0, i32 0
+  %cmp_eq_em = getelementptr [17 x i8], [17 x i8]* @.strCmpEqFltU, i32 0, i32 0
   call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
 
   ; test fcmp::oge -- should return true if either operand is a NaN and the first is greater or equal
   %cmp_ge    = fcmp uge float %f1, %f2
   %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
-  %cmp_ge_em = getelementptr [17 x i8]* @.strCmpGeFltU, i32 0, i32 0
+  %cmp_ge_em = getelementptr [17 x i8], [17 x i8]* @.strCmpGeFltU, i32 0, i32 0
   call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
 
   ; test fcmp::ogt -- should return true if either operand is a NaN and the first is greater
   %cmp_gt    = fcmp ugt float %f1, %f2
   %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
-  %cmp_gt_em = getelementptr [17 x i8]* @.strCmpGtFltU, i32 0, i32 0
+  %cmp_gt_em = getelementptr [17 x i8], [17 x i8]* @.strCmpGtFltU, i32 0, i32 0
   call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
 
   ; test fcmp::ole -- should return true if either operand is a NaN and the first is less or equal
   %cmp_le    = fcmp ule float %f1, %f2
   %cmp_le_ok = icmp eq i1 %cmp_le, %le
-  %cmp_le_em = getelementptr [17 x i8]* @.strCmpLeFltU, i32 0, i32 0
+  %cmp_le_em = getelementptr [17 x i8], [17 x i8]* @.strCmpLeFltU, i32 0, i32 0
   call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
 
   ; test fcmp::olt -- should return true if either operand is a NaN and the first is less
   %cmp_lt    = fcmp ult float %f1, %f2
   %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
-  %cmp_lt_em = getelementptr [17 x i8]* @.strCmpLtFltU, i32 0, i32 0
+  %cmp_lt_em = getelementptr [17 x i8], [17 x i8]* @.strCmpLtFltU, i32 0, i32 0
   call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
 
   ; test fcmp::one -- should return true if either operand is a NaN and they are not equal
   %cmp_ne    = fcmp une float %f1, %f2
   %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
-  %cmp_ne_em = getelementptr [17 x i8]* @.strCmpNeFltU, i32 0, i32 0
+  %cmp_ne_em = getelementptr [17 x i8], [17 x i8]* @.strCmpNeFltU, i32 0, i32 0
   call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
 
   ret void
@@ -560,43 +564,43 @@ entry:
   ; test fcmp::uno -- should return true if either operand is NaN
   %cmp_o    = fcmp uno double %d1, %d2
   %cmp_o_ok = icmp eq i1 %cmp_o, %uno
-  %cmp_o_em = getelementptr [21 x i8]* @.strCmpUnoDbl, i32 0, i32 0
+  %cmp_o_em = getelementptr [21 x i8], [21 x i8]* @.strCmpUnoDbl, i32 0, i32 0
   call void @failCheck( i1 %cmp_o_ok, i8* %cmp_o_em )
 
   ; test fcmp::ueq -- should return true if either operand is a NaN and they are equal
   %cmp_eq    = fcmp ueq double %d1, %d2
   %cmp_eq_ok = icmp eq i1 %cmp_eq, %eq
-  %cmp_eq_em = getelementptr [18 x i8]* @.strCmpEqDblU, i32 0, i32 0
+  %cmp_eq_em = getelementptr [18 x i8], [18 x i8]* @.strCmpEqDblU, i32 0, i32 0
   call void @failCheck( i1 %cmp_eq_ok, i8* %cmp_eq_em )
 
   ; test fcmp::uge -- should return true if either operand is a NaN and the first is greater or equal
   %cmp_ge    = fcmp uge double %d1, %d2
   %cmp_ge_ok = icmp eq i1 %cmp_ge, %ge
-  %cmp_ge_em = getelementptr [18 x i8]* @.strCmpGeDblU, i32 0, i32 0
+  %cmp_ge_em = getelementptr [18 x i8], [18 x i8]* @.strCmpGeDblU, i32 0, i32 0
   call void @failCheck( i1 %cmp_ge_ok, i8* %cmp_ge_em )
 
   ; test fcmp::ugt -- should return true if either operand is a NaN and the first is greater
   %cmp_gt    = fcmp ugt double %d1, %d2
   %cmp_gt_ok = icmp eq i1 %cmp_gt, %gt
-  %cmp_gt_em = getelementptr [18 x i8]* @.strCmpGtDblU, i32 0, i32 0
+  %cmp_gt_em = getelementptr [18 x i8], [18 x i8]* @.strCmpGtDblU, i32 0, i32 0
   call void @failCheck( i1 %cmp_gt_ok, i8* %cmp_gt_em )
 
   ; test fcmp::ule -- should return true if either operand is a NaN and the first is less or equal
   %cmp_le    = fcmp ule double %d1, %d2
   %cmp_le_ok = icmp eq i1 %cmp_le, %le
-  %cmp_le_em = getelementptr [18 x i8]* @.strCmpLeDblU, i32 0, i32 0
+  %cmp_le_em = getelementptr [18 x i8], [18 x i8]* @.strCmpLeDblU, i32 0, i32 0
   call void @failCheck( i1 %cmp_le_ok, i8* %cmp_le_em )
 
   ; test fcmp::ult -- should return true if either operand is a NaN and the first is less
   %cmp_lt    = fcmp ult double %d1, %d2
   %cmp_lt_ok = icmp eq i1 %cmp_lt, %lt
-  %cmp_lt_em = getelementptr [18 x i8]* @.strCmpLtDblU, i32 0, i32 0
+  %cmp_lt_em = getelementptr [18 x i8], [18 x i8]* @.strCmpLtDblU, i32 0, i32 0
   call void @failCheck( i1 %cmp_lt_ok, i8* %cmp_lt_em )
 
   ; test fcmp::une -- should return true if either operand is a NaN and they are not equal
   %cmp_ne    = fcmp une double %d1, %d2
   %cmp_ne_ok = icmp eq i1 %cmp_ne, %ne
-  %cmp_ne_em = getelementptr [18 x i8]* @.strCmpNeDblU, i32 0, i32 0
+  %cmp_ne_em = getelementptr [18 x i8], [18 x i8]* @.strCmpNeDblU, i32 0, i32 0
   call void @failCheck( i1 %cmp_ne_ok, i8* %cmp_ne_em )
 
   ret void
@@ -639,8 +643,8 @@ entry:
   store i64 -1, i64* %nan_as_i64
 
   ; load two copies of our NaN
-  %nan1 = load double* %nan
-  %nan2 = load double* %nan
+  %nan1 = load double, double* %nan
+  %nan2 = load double, double* %nan
 
   ; NaNs do different things depending on ordered vs unordered
   call void @testFCmpBothOrdered( double %nan1, double 0.000000e+00, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0 )
@@ -670,8 +674,8 @@ entry:
   call void @testFCmp( )
 
   ; everything worked -- print a message saying so
-  %works_msg = getelementptr [20 x i8]* @.strWorks, i32 0, i32 0
-  %ret = call i32 (i8*, ...)* @printf( i8* %works_msg )
+  %works_msg = getelementptr [20 x i8], [20 x i8]* @.strWorks, i32 0, i32 0
+  %ret = call i32 (i8*, ...) @printf( i8* %works_msg )
 
   ret i32 0
 }
diff --git a/test/Concrete/GlobalInitializers.leq36.ll b/test/Concrete/GlobalInitializers.leq36.ll
new file mode 100755
index 00000000..ba7e53eb
--- /dev/null
+++ b/test/Concrete/GlobalInitializers.leq36.ll
@@ -0,0 +1,48 @@
+; REQUIRES: lt-llvm-3.7
+; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
+
+declare void @print_i32(i32)
+
+%simple = type { i8, i16, i32, i64 }
+@gInt = global i32 2
+@gInts = global [2 x i32] [ i32 3, i32 5 ]
+@gStruct = global %simple { i8 7, i16 11, i32 13, i64 17 }
+@gZero = global %simple zeroinitializer
+
+define i32 @main() {
+entry:
+	%addr0 = getelementptr i32* @gInt, i32 0
+	%addr1 = getelementptr [2 x i32]* @gInts, i32 0, i32 0
+	%addr2 = getelementptr [2 x i32]* @gInts, i32 0, i32 1
+	%addr3 = getelementptr %simple* @gStruct, i32 0, i32 0
+	%addr4 = getelementptr %simple* @gStruct, i32 0, i32 1
+	%addr5 = getelementptr %simple* @gStruct, i32 0, i32 2
+	%addr6 = getelementptr %simple* @gStruct, i32 0, i32 3
+	%addr7 = getelementptr %simple* @gZero, i32 0, i32 2
+	%contents0 = load i32* %addr0
+	%contents1 = load i32* %addr1
+	%contents2 = load i32* %addr2
+	%contents3tmp = load i8* %addr3
+	%contents3 = zext i8 %contents3tmp to i32
+	%contents4tmp = load i16* %addr4
+	%contents4 = zext i16 %contents4tmp to i32
+	%contents5 = load i32* %addr5
+	%contents6tmp = load i64* %addr6
+	%contents6 = trunc i64 %contents6tmp to i32
+	%contents7 = load i32* %addr7
+	%tmp0 = mul i32 %contents0, %contents1
+	%tmp1 = mul i32 %tmp0, %contents2
+	%tmp2 = mul i32 %tmp1, %contents3
+	%tmp3 = mul i32 %tmp2, %contents4
+	%tmp4 = mul i32 %tmp3, %contents5
+	%tmp5 = mul i32 %tmp4, %contents6
+	%tmp6 = add i32 %tmp5, %contents7
+	%p = icmp eq i32 %tmp5, 510510
+	br i1 %p, label %exitTrue, label %exitFalse
+exitTrue:
+	call void @print_i32(i32 1)
+	ret i32 0
+exitFalse:
+	call void @print_i32(i32 0)
+	ret i32 0
+}
diff --git a/test/Concrete/GlobalInitializers.ll b/test/Concrete/GlobalInitializers.ll
index e3657dad..57e702dc 100755
--- a/test/Concrete/GlobalInitializers.ll
+++ b/test/Concrete/GlobalInitializers.ll
@@ -1,3 +1,6 @@
+; LLVM 3.7 requires a type as the first argument to 'getelementptr'
+; LLVM 3.7 requires a type as the first argument to 'load'
+; REQUIRES: geq-llvm-3.7
 ; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
 
 declare void @print_i32(i32)
@@ -10,25 +13,25 @@ declare void @print_i32(i32)
 
 define i32 @main() {
 entry:
-	%addr0 = getelementptr i32* @gInt, i32 0
-	%addr1 = getelementptr [2 x i32]* @gInts, i32 0, i32 0
-	%addr2 = getelementptr [2 x i32]* @gInts, i32 0, i32 1
-	%addr3 = getelementptr %simple* @gStruct, i32 0, i32 0
-	%addr4 = getelementptr %simple* @gStruct, i32 0, i32 1
-	%addr5 = getelementptr %simple* @gStruct, i32 0, i32 2
-	%addr6 = getelementptr %simple* @gStruct, i32 0, i32 3
-	%addr7 = getelementptr %simple* @gZero, i32 0, i32 2
-	%contents0 = load i32* %addr0
-	%contents1 = load i32* %addr1
-	%contents2 = load i32* %addr2
-	%contents3tmp = load i8* %addr3
+	%addr0 = getelementptr i32, i32* @gInt, i32 0
+	%addr1 = getelementptr [2 x i32], [2 x i32]* @gInts, i32 0, i32 0
+	%addr2 = getelementptr [2 x i32], [2 x i32]* @gInts, i32 0, i32 1
+	%addr3 = getelementptr %simple, %simple* @gStruct, i32 0, i32 0
+	%addr4 = getelementptr %simple, %simple* @gStruct, i32 0, i32 1
+	%addr5 = getelementptr %simple, %simple* @gStruct, i32 0, i32 2
+	%addr6 = getelementptr %simple, %simple* @gStruct, i32 0, i32 3
+	%addr7 = getelementptr %simple, %simple* @gZero, i32 0, i32 2
+	%contents0 = load i32, i32* %addr0
+	%contents1 = load i32, i32* %addr1
+	%contents2 = load i32, i32* %addr2
+	%contents3tmp = load i8, i8* %addr3
 	%contents3 = zext i8 %contents3tmp to i32
-	%contents4tmp = load i16* %addr4
+	%contents4tmp = load i16, i16* %addr4
 	%contents4 = zext i16 %contents4tmp to i32
-	%contents5 = load i32* %addr5
-	%contents6tmp = load i64* %addr6
+	%contents5 = load i32, i32* %addr5
+	%contents6tmp = load i64, i64* %addr6
 	%contents6 = trunc i64 %contents6tmp to i32
-	%contents7 = load i32* %addr7
+	%contents7 = load i32, i32* %addr7
 	%tmp0 = mul i32 %contents0, %contents1
 	%tmp1 = mul i32 %tmp0, %contents2
 	%tmp2 = mul i32 %tmp1, %contents3
diff --git a/test/Concrete/SimpleStoreAndLoad.leq36.ll b/test/Concrete/SimpleStoreAndLoad.leq36.ll
new file mode 100644
index 00000000..7bb65ea7
--- /dev/null
+++ b/test/Concrete/SimpleStoreAndLoad.leq36.ll
@@ -0,0 +1,20 @@
+; REQUIRES: lt-llvm-3.7
+; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
+
+declare void @print_i32(i32)
+
+define i32 @main() {
+entry:
+	%a = alloca i32, i32 4
+	%tmp1 = getelementptr i32* %a, i32 0
+	store i32 0, i32* %tmp1
+	%tmp2 = load i32* %tmp1
+	%tmp3 = icmp eq i32 %tmp2, 0
+	br i1 %tmp3, label %exitTrue, label %exitFalse
+exitTrue:
+	call void @print_i32(i32 1)
+	ret i32 0
+exitFalse:
+	call void @print_i32(i32 0)
+	ret i32 0
+}
diff --git a/test/Concrete/SimpleStoreAndLoad.ll b/test/Concrete/SimpleStoreAndLoad.ll
index 1edad038..951a474e 100644
--- a/test/Concrete/SimpleStoreAndLoad.ll
+++ b/test/Concrete/SimpleStoreAndLoad.ll
@@ -1,3 +1,6 @@
+; LLVM 3.7 requires a type as the first argument to 'getelementptr'
+; LLVM 3.7 requires a type as the first argument to 'load'
+; REQUIRES: geq-llvm-3.7
 ; RUN: %S/ConcreteTest.py --klee='%klee' --lli=%lli %s
 
 declare void @print_i32(i32)
@@ -5,9 +8,9 @@ declare void @print_i32(i32)
 define i32 @main() {
 entry:
 	%a = alloca i32, i32 4
-	%tmp1 = getelementptr i32* %a, i32 0
+	%tmp1 = getelementptr i32, i32* %a, i32 0
 	store i32 0, i32* %tmp1
-	%tmp2 = load i32* %tmp1
+	%tmp2 = load i32, i32* %tmp1
 	%tmp3 = icmp eq i32 %tmp2, 0
 	br i1 %tmp3, label %exitTrue, label %exitFalse
 exitTrue: