Comparison primops return Int# (Fixes #6135)
authorJan Stolarek <jan.stolarek@p.lodz.pl>
Wed, 14 Aug 2013 15:15:43 +0000 (16:15 +0100)
committerJan Stolarek <jan.stolarek@p.lodz.pl>
Wed, 14 Aug 2013 15:15:43 +0000 (16:15 +0100)
This patch adds tests for new primops and fixes the existing ones.
For a deatiled discussion of this changes please visit the wiki page:
http://hackage.haskell.org/trac/ghc/wiki/PrimBool

15 files changed:
testsuite/tests/lib/integer/Makefile
testsuite/tests/lib/integer/integerConstantFolding.hs
testsuite/tests/lib/integer/integerConstantFolding.stdout
testsuite/tests/perf/compiler/T4007.stdout
testsuite/tests/primops/Makefile [new file with mode: 0644]
testsuite/tests/primops/should_compile/T6135_should_compile.hs [new file with mode: 0644]
testsuite/tests/primops/should_compile/all.T [new file with mode: 0644]
testsuite/tests/primops/should_run/T6135.hs [new file with mode: 0644]
testsuite/tests/primops/should_run/T6135.stdout [new file with mode: 0644]
testsuite/tests/primops/should_run/all.T [new file with mode: 0644]
testsuite/tests/simplCore/should_compile/Makefile
testsuite/tests/simplCore/should_compile/T3772.stdout
testsuite/tests/simplCore/should_compile/T4930.stderr
testsuite/tests/simplCore/should_compile/T5658b.hs
testsuite/tests/simplCore/should_compile/spec-inline.stderr

index 34d5a17..aa2704a 100644 (file)
@@ -30,6 +30,8 @@ integerConstantFolding:
        $(call CHECK,\<6253\>,shiftRInteger)
        $(call CHECK,\<641\>,quotInteger)
        $(call CHECK,\<68\>,remInteger)
+       $(call CHECK,\<642\>,divInteger)
+       $(call CHECK,\<90\>,modInteger)
        $(call CHECK,\<200131.0\>,doubleFromInteger)
        $(call CHECK,\<200135.0\>,floatFromInteger)
        $(call CHECK,\<400276.0\>,encodeIntegerDouble)
index 0666e2f..b8a6ae6 100644 (file)
@@ -48,6 +48,8 @@ main = do p "plusInteger"        plusInteger
           p "shiftRInteger"     shiftRInteger
           p "quotInteger"       quotInteger
           p "remInteger"        remInteger
+          p "divInteger"        divInteger
+          p "modInteger"        modInteger
           p "doubleFromInteger" doubleFromInteger
           p "floatFromInteger"  floatFromInteger
           p "decodeIntegerDouble" decodeIntegerDouble
@@ -172,6 +174,12 @@ quotInteger = 100063 `quot` 156
 remInteger :: Integer
 remInteger = 100064 `rem` 156
 
+divInteger :: Integer
+divInteger = 100286 `div` 156
+
+modInteger :: Integer
+modInteger = 100086 `mod` 156
+
 -- For the conversion functions, we can't just check that e.g. 100065
 -- is in the resulting core, because it will be regardless of whether
 -- the rules fire or not. So we add 100066, and thus rely on the
index 960cfff..b9ee306 100644 (file)
@@ -40,6 +40,8 @@ shiftLInteger: 1600976
 shiftRInteger: 6253
 quotInteger: 641
 remInteger: 68
+divInteger: 642
+modInteger: 90
 doubleFromInteger: 200131.0
 floatFromInteger: 200135.0
 decodeIntegerDouble: (6877651390169088,-36)
index 9b825fd..6319c45 100644 (file)
@@ -1,6 +1,7 @@
 Rule fired: unpack
 Rule fired: Class op >>
 Rule fired: Class op return
-Rule fired: <=#
+Rule fired: <=$#
+Rule fired: tagToEnum#
 Rule fired: fold/build
 Rule fired: unpack-list
diff --git a/testsuite/tests/primops/Makefile b/testsuite/tests/primops/Makefile
new file mode 100644 (file)
index 0000000..9a36a1c
--- /dev/null
@@ -0,0 +1,3 @@
+TOP=../..
+include $(TOP)/mk/boilerplate.mk
+include $(TOP)/mk/test.mk
diff --git a/testsuite/tests/primops/should_compile/T6135_should_compile.hs b/testsuite/tests/primops/should_compile/T6135_should_compile.hs
new file mode 100644 (file)
index 0000000..b27c6cd
--- /dev/null
@@ -0,0 +1,22 @@
+-- Tests created by Jan Stolarek <jan.stolarek@p.lodz.pl>
+
+{-# LANGUAGE MagicHash #-}
+module Main where
+
+import GHC.Exts
+
+main :: IO ()
+main = do
+  print (h 3.0##)
+  print g
+  print 3.14159
+
+h :: Double# -> String
+h n = if (n ==## 3.0##) || (n ==## 4.0##)
+      then "First branch"
+      else "Second branch"
+
+g :: String
+g = if ((fromInteger 1 :: Integer) == 1)
+    then "First branch"
+    else "Second branch"
diff --git a/testsuite/tests/primops/should_compile/all.T b/testsuite/tests/primops/should_compile/all.T
new file mode 100644 (file)
index 0000000..77f560a
--- /dev/null
@@ -0,0 +1 @@
+test('T6135_should_compile', only_compiler_types(['ghc']), compile, [''])
diff --git a/testsuite/tests/primops/should_run/T6135.hs b/testsuite/tests/primops/should_run/T6135.hs
new file mode 100644 (file)
index 0000000..e93bb08
--- /dev/null
@@ -0,0 +1,836 @@
+-- Tests created by Jan Stolarek <jan.stolarek@p.lodz.pl>
+
+{-# LANGUAGE BangPatterns, MagicHash #-}
+module Main where
+
+import GHC.Exts
+
+main :: IO ()
+main = do
+  -- PrimOps for comparing Char#
+  putStrLn "=== testing gtCharI# ==="
+  test "gtCharI#" (a#    `gtCharI#` a#   ) -- False
+  test "gtCharI#" (b#    `gtCharI#` a#   ) -- True
+  test "gtCharI#" (a#    `gtCharI#` b#   ) -- False
+  test "gtCharI#" (minC# `gtCharI#` minC#) -- False
+  test "gtCharI#" (maxC# `gtCharI#` maxC#) -- False
+  test "gtCharI#" (minC# `gtCharI#` maxC#) -- False
+  test "gtCharI#" (maxC# `gtCharI#` minC#) -- True
+
+  putStrLn "=== testing geCharI# ==="
+  test "geCharI#" (a#    `geCharI#` a#   ) -- True
+  test "geCharI#" (b#    `geCharI#` a#   ) -- True
+  test "geCharI#" (a#    `geCharI#` b#   ) -- False
+  test "geCharI#" (minC# `geCharI#` minC#) -- True
+  test "geCharI#" (maxC# `geCharI#` maxC#) -- True
+  test "geCharI#" (minC# `geCharI#` maxC#) -- False
+  test "geCharI#" (maxC# `geCharI#` minC#) -- True
+
+  putStrLn "=== testing ltCharI# ==="
+  test "ltCharI#" (a#    `ltCharI#` a#   ) -- False
+  test "ltCharI#" (b#    `ltCharI#` a#   ) -- False
+  test "ltCharI#" (a#    `ltCharI#` b#   ) -- True
+  test "ltCharI#" (minC# `ltCharI#` minC#) -- False
+  test "ltCharI#" (maxC# `ltCharI#` maxC#) -- False
+  test "ltCharI#" (minC# `ltCharI#` maxC#) -- True
+  test "ltCharI#" (maxC# `ltCharI#` minC#) -- False
+
+  putStrLn "=== testing leCharI# ==="
+  test "leCharI#" (a#    `leCharI#` a#   ) -- True
+  test "leCharI#" (b#    `leCharI#` a#   ) -- False
+  test "leCharI#" (a#    `leCharI#` b#   ) -- True
+  test "leCharI#" (minC# `leCharI#` minC#) -- True
+  test "leCharI#" (maxC# `leCharI#` maxC#) -- True
+  test "leCharI#" (minC# `leCharI#` maxC#) -- True
+  test "leCharI#" (maxC# `leCharI#` minC#) -- False
+
+  putStrLn "=== testing eqCharI# ==="
+  test "eqCharI#" (a#    `eqCharI#` a#   ) -- True
+  test "eqCharI#" (b#    `eqCharI#` a#   ) -- False
+  test "eqCharI#" (a#    `eqCharI#` b#   ) -- False
+  test "eqCharI#" (minC# `eqCharI#` minC#) -- True
+  test "eqCharI#" (maxC# `eqCharI#` maxC#) -- True
+  test "eqCharI#" (minC# `eqCharI#` maxC#) -- False
+  test "eqCharI#" (maxC# `eqCharI#` minC#) -- False
+
+  putStrLn "=== testing neCharI# ==="
+  test "neCharI#" (a#    `neCharI#` a#   ) -- False
+  test "neCharI#" (b#    `neCharI#` a#   ) -- True
+  test "neCharI#" (a#    `neCharI#` b#   ) -- True
+  test "neCharI#" (minC# `neCharI#` minC#) -- False
+  test "neCharI#" (maxC# `neCharI#` maxC#) -- False
+  test "neCharI#" (minC# `neCharI#` maxC#) -- True
+  test "neCharI#" (maxC# `neCharI#` minC#) -- True
+
+  -- PrimOps for comparing Int#
+  putStrLn "=== testing >$# ==="
+  test ">$#" (0#          >$# 0#         ) -- False
+  test ">$#" (1#          >$# 0#         ) -- True
+  test ">$#" (0#          >$# 1#         ) -- False
+  test ">$#" (minI#       >$# minI#      ) -- False
+  test ">$#" (maxI#       >$# maxI#      ) -- False
+  test ">$#" (minI# +# 1# >$# minI#      ) -- True
+  test ">$#" (minI#       >$# minI# -# 1#) -- False (overflow)
+  test ">$#" (maxI# +# 1# >$# maxI#      ) -- False (overflow)
+  test ">$#" (maxI#       >$# maxI# -# 1#) -- True
+
+  putStrLn "=== testing <$# ==="
+  test "<$#" (0#          <$# 0#         ) -- False
+  test "<$#" (1#          <$# 0#         ) -- False
+  test "<$#" (0#          <$# 1#         ) -- True
+  test "<$#" (minI#       <$# minI#      ) -- False
+  test "<$#" (maxI#       <$# maxI#      ) -- False
+  test "<$#" (minI#       <$# minI# +# 1#) -- True
+  test "<$#" (minI# -# 1# <$# minI#      ) -- False (overflow)
+  test "<$#" (maxI#       <$# maxI# +# 1#) -- False (overflow)
+  test "<$#" (maxI# -# 1# <$# maxI#      ) -- True
+
+  putStrLn "=== testing >=$# ==="
+  test ">=$#" (0#          >=$# 0#         ) -- True
+  test ">=$#" (1#          >=$# 0#         ) -- True
+  test ">=$#" (0#          >=$# 1#         ) -- False
+  test ">=$#" (minI#       >=$# minI#      ) -- True
+  test ">=$#" (maxI#       >=$# maxI#      ) -- True
+  test ">=$#" (minI# +# 1# >=$# minI#      ) -- True
+  test ">=$#" (minI#       >=$# minI# -# 1#) -- False (overflow)
+  test ">=$#" (maxI# +# 1# >=$# maxI#      ) -- False (overflow)
+  test ">=$#" (maxI#       >=$# maxI# -# 1#) -- True
+
+  putStrLn "=== testing <=$# ==="
+  test "<=$#" (0#          <=$# 0#         ) -- True
+  test "<=$#" (1#          <=$# 0#         ) -- False
+  test "<=$#" (0#          <=$# 1#         ) -- True
+  test "<=$#" (minI#       <=$# minI#      ) -- True
+  test "<=$#" (maxI#       <=$# maxI#      ) -- True
+  test "<=$#" (minI#       <=$# minI# +# 1#) -- True
+  test "<=$#" (minI# -# 1# <=$# minI#      ) -- False (overflow)
+  test "<=$#" (maxI#       <=$# maxI# +# 1#) -- False (overflow)
+  test "<=$#" (maxI# -# 1# <=$# maxI#      ) -- True
+
+  putStrLn "=== testing ==$# ==="
+  test "==$#" (0#          ==$# 0#         ) -- True
+  test "==$#" (1#          ==$# 0#         ) -- False
+  test "==$#" (0#          ==$# 1#         ) -- False
+  test "==$#" (maxI#       ==$# maxI#      ) -- True
+  test "==$#" (maxI# -# 1# ==$# maxI#      ) -- False
+  test "==$#" (minI#       ==$# minI#      ) -- True
+  test "==$#" (minI#       ==$# minI# +# 1#) -- False
+  test "==$#" (minI#       ==$# maxI# +# 1#) -- True (overflow)
+  test "==$#" (maxI# +# 1# ==$# minI#      ) -- True (overflow)
+  test "==$#" (maxI#       ==$# minI# -# 1#) -- True (overflow)
+  test "==$#" (minI# -# 1# ==$# maxI#      ) -- True (overflow)
+
+  putStrLn "=== testing /=$# ==="
+  test "/=$#" (0#          /=$# 0#         ) -- False
+  test "/=$#" (1#          /=$# 0#         ) -- True
+  test "/=$#" (0#          /=$# 1#         ) -- True
+  test "/=$#" (maxI#       /=$# maxI#      ) -- False
+  test "/=$#" (maxI# -# 1# /=$# maxI#      ) -- True
+  test "/=$#" (minI#       /=$# minI#      ) -- False
+  test "/=$#" (minI#       /=$# minI# +# 1#) -- True
+  test "/=$#" (minI#       /=$# maxI# +# 1#) -- False (overflow)
+  test "/=$#" (maxI# +# 1# /=$# minI#      ) -- False (overflow)
+  test "/=$#" (maxI#       /=$# minI# -# 1#) -- False (overflow)
+  test "/=$#" (minI# -# 1# /=$# maxI#      ) -- False (overflow)
+
+  -- PrimOps for comparing Word#
+  putStrLn "=== testing gtWordI# ==="
+  test "gtWordI#" (zeroW#                    `gtWordI#` zeroW#                    ) -- False
+  test "gtWordI#" (oneW#                     `gtWordI#` zeroW#                    ) -- True
+  test "gtWordI#" (zeroW#                    `gtWordI#` oneW#                     ) -- False
+  test "gtWordI#" (minW#                     `gtWordI#` minW#                     ) -- False
+  test "gtWordI#" (maxW#                     `gtWordI#` maxW#                     ) -- False
+  test "gtWordI#" ((minW# `plusWord#` oneW#) `gtWordI#` minW#                     ) -- True
+  test "gtWordI#" (minW#                     `gtWordI#` (minW# `minusWord#` oneW#)) -- False (overflow)
+  test "gtWordI#" ((maxW# `plusWord#` oneW#) `gtWordI#` maxW#                     ) -- False (overflow)
+  test "gtWordI#" (maxW#                     `gtWordI#` (maxW# `minusWord#` oneW#)) -- True
+
+  putStrLn "=== testing ltWordI# ==="
+  test "ltWordI#" (zeroW#                     `ltWordI#` zeroW#                   ) -- False
+  test "ltWordI#" (oneW#                      `ltWordI#` zeroW#                   ) -- False
+  test "ltWordI#" (zeroW#                     `ltWordI#` oneW#                    ) -- True
+  test "ltWordI#" (minW#                      `ltWordI#` minW#                    ) -- False
+  test "ltWordI#" (maxW#                      `ltWordI#` maxW#                    ) -- False
+  test "ltWordI#" (minW#                      `ltWordI#` (minW# `plusWord#` oneW#)) -- True
+  test "ltWordI#" ((minW# `minusWord#` oneW#) `ltWordI#` minW#                    ) -- False (overflow)
+  test "ltWordI#" (maxW#                      `ltWordI#` (maxW# `plusWord#` oneW#)) -- False (overflow)
+  test "ltWordI#" ((maxW# `minusWord#` oneW#) `ltWordI#` maxW#                    ) -- True
+
+  putStrLn "=== testing geWordI# ==="
+  test "geWordI#" (zeroW#                    `geWordI#` zeroW#                    ) -- True
+  test "geWordI#" (oneW#                     `geWordI#` zeroW#                    ) -- True
+  test "geWordI#" (zeroW#                    `geWordI#` oneW#                     ) -- False
+  test "geWordI#" (minW#                     `geWordI#` minW#                     ) -- True
+  test "geWordI#" (maxW#                     `geWordI#` maxW#                     ) -- True
+  test "geWordI#" ((minW# `plusWord#` oneW#) `geWordI#` minW#                     ) -- True
+  test "geWordI#" (minW#                     `geWordI#` (minW# `minusWord#` oneW#)) -- False (overflow)
+  test "geWordI#" ((maxW# `plusWord#` oneW#) `geWordI#` maxW#                     ) -- False (overflow)
+  test "geWordI#" (maxW#                     `geWordI#` (maxW# `minusWord#` oneW#)) -- True
+
+  putStrLn "=== testing leWordI# ==="
+  test "leWordI#" (zeroW#                     `leWordI#` zeroW#                   ) -- True
+  test "leWordI#" (oneW#                      `leWordI#` zeroW#                   ) -- False
+  test "leWordI#" (zeroW#                     `leWordI#` oneW#                    ) -- True
+  test "leWordI#" (minW#                      `leWordI#` minW#                    ) -- True
+  test "leWordI#" (maxW#                      `leWordI#` maxW#                    ) -- True
+  test "leWordI#" (minW#                      `leWordI#` (minW# `plusWord#` oneW#)) -- True
+  test "leWordI#" ((minW# `minusWord#` oneW#) `leWordI#` minW#                    ) -- False (overflow)
+  test "leWordI#" (maxW#                      `leWordI#` (maxW# `plusWord#` oneW#)) -- False (overflow)
+  test "leWordI#" ((maxW# `minusWord#` oneW#) `leWordI#` maxW#                    ) -- True
+
+  putStrLn "=== testing eqWordI# ==="
+  test "eqWordI#" (zeroW#                     `eqWordI#` zeroW#                    ) -- True
+  test "eqWordI#" (oneW#                      `eqWordI#` zeroW#                    ) -- False
+  test "eqWordI#" (zeroW#                     `eqWordI#` oneW#                     ) -- False
+  test "eqWordI#" (maxW#                      `eqWordI#` maxW#                     ) -- True
+  test "eqWordI#" ((maxW# `minusWord#` oneW#) `eqWordI#` maxW#                     ) -- False
+  test "eqWordI#" (minW#                      `eqWordI#` minW#                     ) -- True
+  test "eqWordI#" (minW#                      `eqWordI#` (minW# `plusWord#` oneW#) ) -- False
+  test "eqWordI#" (minW#                      `eqWordI#` (maxW# `plusWord#` oneW#) ) -- True (overflow)
+  test "eqWordI#" ((maxW# `plusWord#` oneW#)  `eqWordI#` minW#                     ) -- True (overflow)
+  test "eqWordI#" (maxW#                      `eqWordI#` (minW# `minusWord#` oneW#)) -- True (overflow)
+  test "eqWordI#" ((minW# `minusWord#` oneW#) `eqWordI#` maxW#                     ) -- True (overflow)
+
+  putStrLn "=== testing neWordI# ==="
+  test "neWordI#" (zeroW#                     `neWordI#` zeroW#                    ) -- False
+  test "neWordI#" (oneW#                      `neWordI#` zeroW#                    ) -- True
+  test "neWordI#" (zeroW#                     `neWordI#` oneW#                     ) -- True
+  test "neWordI#" (maxW#                      `neWordI#` maxW#                     ) -- False
+  test "neWordI#" ((maxW# `minusWord#` oneW#) `neWordI#` maxW#                     ) -- True
+  test "neWordI#" (minW#                      `neWordI#` minW#                     ) -- False
+  test "neWordI#" (minW#                      `neWordI#` (minW# `plusWord#` oneW#) ) -- True
+  test "neWordI#" (minW#                      `neWordI#` (maxW# `plusWord#` oneW#) ) -- False (overflow)
+  test "neWordI#" ((maxW# `plusWord#` oneW#)  `neWordI#` minW#                     ) -- False (overflow)
+  test "neWordI#" (maxW#                      `neWordI#` (minW# `minusWord#` oneW#)) -- False (overflow)
+  test "neWordI#" ((minW# `minusWord#` oneW#) `neWordI#` maxW#                     ) -- False (overflow)
+
+  -- PrimOps for comparing Double#
+  putStrLn "=== testing >$## ==="
+  test ">$##" (0.0##  >$## 0.0## ) -- False
+  test ">$##" (1.0##  >$## 0.0## ) -- True
+  test ">$##" (0.0##  >$## 1.0## ) -- False
+  test ">$##" (0.0##  >$## nan## ) -- False
+  test ">$##" (nan##  >$## 0.0## ) -- False
+  test ">$##" (nan##  >$## nan## ) -- False
+  test ">$##" (infp## >$## infp##) -- False
+  test ">$##" (infn## >$## infn##) -- False
+  test ">$##" (infp## >$## infn##) -- True
+  test ">$##" (infn## >$## infp##) -- False
+  test ">$##" (infp## >$## nan## ) -- False
+  test ">$##" (infn## >$## nan## ) -- False
+  test ">$##" (nan##  >$## infp##) -- False
+  test ">$##" (nan##  >$## infn##) -- False
+
+  putStrLn "=== testing <$## ==="
+  test "<$##" (0.0##  <$## 0.0## ) -- False
+  test "<$##" (1.0##  <$## 0.0## ) -- False
+  test "<$##" (0.0##  <$## 1.0## ) -- True
+  test "<$##" (0.0##  <$## nan## ) -- False
+  test "<$##" (nan##  <$## 0.0## ) -- False
+  test "<$##" (nan##  <$## nan## ) -- False
+  test "<$##" (infp## <$## infp##) -- False
+  test "<$##" (infn## <$## infn##) -- False
+  test "<$##" (infp## <$## infn##) -- False
+  test "<$##" (infn## <$## infp##) -- True
+  test "<$##" (infp## <$## nan## ) -- False
+  test "<$##" (infn## <$## nan## ) -- False
+  test "<$##" (nan##  <$## infp##) -- False
+  test "<$##" (nan##  <$## infn##) -- False
+
+  putStrLn "=== testing >=$## ==="
+  test ">=$##" (0.0##  >=$## 0.0## ) -- True
+  test ">=$##" (1.0##  >=$## 0.0## ) -- True
+  test ">=$##" (0.0##  >=$## 1.0## ) -- False
+  test ">=$##" (0.0##  >=$## nan## ) -- False
+  test ">=$##" (nan##  >=$## 0.0## ) -- False
+  test ">=$##" (nan##  >=$## nan## ) -- False
+  test ">=$##" (infp## >=$## infp##) -- True
+  test ">=$##" (infn## >=$## infn##) -- True
+  test ">=$##" (infp## >=$## infn##) -- True
+  test ">=$##" (infn## >=$## infp##) -- False
+  test ">=$##" (infp## >=$## nan## ) -- False
+  test ">=$##" (infn## >=$## nan## ) -- False
+  test ">=$##" (nan##  >=$## infp##) -- False
+  test ">=$##" (nan##  >=$## infn##) -- False
+
+  putStrLn "=== testing <=$## ==="
+  test "<=$##" (0.0##  <=$## 0.0## ) -- True
+  test "<=$##" (1.0##  <=$## 0.0## ) -- False
+  test "<=$##" (0.0##  <=$## 1.0## ) -- True
+  test "<=$##" (0.0##  <=$## nan## ) -- False
+  test "<=$##" (nan##  <=$## 0.0## ) -- False
+  test "<=$##" (nan##  <=$## nan## ) -- False
+  test "<=$##" (infp## <=$## infp##) -- True
+  test "<=$##" (infn## <=$## infn##) -- True
+  test "<=$##" (infp## <=$## infn##) -- False
+  test "<=$##" (infn## <=$## infp##) -- True
+  test "<=$##" (infp## <=$## nan## ) -- False
+  test "<=$##" (infn## <=$## nan## ) -- False
+  test "<=$##" (nan##  <=$## infp##) -- False
+  test "<=$##" (nan##  <=$## infn##) -- False
+
+  putStrLn "=== testing ==$## ==="
+  test "==$##" (0.0##  ==$## 0.0## ) -- True
+  test "==$##" (1.0##  ==$## 0.0## ) -- False
+  test "==$##" (0.0##  ==$## 1.0## ) -- False
+  test "==$##" (0.0##  ==$## nan## ) -- False
+  test "==$##" (nan##  ==$## 0.0## ) -- False
+  test "==$##" (nan##  ==$## nan## ) -- False
+  test "==$##" (infp## ==$## infp##) -- True
+  test "==$##" (infn## ==$## infn##) -- True
+  test "==$##" (infp## ==$## infn##) -- False
+  test "==$##" (infn## ==$## infp##) -- False
+  test "==$##" (infp## ==$## nan## ) -- False
+  test "==$##" (infn## ==$## nan## ) -- False
+  test "==$##" (nan##  ==$## infp##) -- False
+  test "==$##" (nan##  ==$## infn##) -- False
+
+  putStrLn "=== testing /=$## ==="
+  test "/=$##" (0.0##  /=$## 0.0## ) -- False
+  test "/=$##" (1.0##  /=$## 0.0## ) -- True
+  test "/=$##" (0.0##  /=$## 1.0## ) -- True
+  test "/=$##" (0.0##  /=$## nan## ) -- True
+  test "/=$##" (nan##  /=$## 0.0## ) -- True
+  test "/=$##" (nan##  /=$## nan## ) -- True
+  test "/=$##" (infp## /=$## infp##) -- False
+  test "/=$##" (infn## /=$## infn##) -- False
+  test "/=$##" (infp## /=$## infn##) -- True
+  test "/=$##" (infn## /=$## infp##) -- True
+  test "/=$##" (infp## /=$## nan## ) -- True
+  test "/=$##" (infn## /=$## nan## ) -- True
+  test "/=$##" (nan##  /=$## infp##) -- True
+  test "/=$##" (nan##  /=$## infn##) -- True
+
+  -- PrimOps for comparing Float#
+  putStrLn "=== testing gtFloatI# ==="
+  test "gtFloatI#" (zeroF# `gtFloatI#` zeroF#) -- False
+  test "gtFloatI#" (oneF#  `gtFloatI#` zeroF#) -- True
+  test "gtFloatI#" (zeroF# `gtFloatI#` oneF# ) -- False
+  test "gtFloatI#" (zeroF# `gtFloatI#` nanF# ) -- False
+  test "gtFloatI#" (nanF#  `gtFloatI#` zeroF#) -- False
+  test "gtFloatI#" (nanF#  `gtFloatI#` nanF# ) -- False
+  test "gtFloatI#" (infpF# `gtFloatI#` infpF#) -- False
+  test "gtFloatI#" (infnF# `gtFloatI#` infnF#) -- False
+  test "gtFloatI#" (infpF# `gtFloatI#` infnF#) -- True
+  test "gtFloatI#" (infnF# `gtFloatI#` infpF#) -- False
+  test "gtFloatI#" (infpF# `gtFloatI#` nanF# ) -- False
+  test "gtFloatI#" (infnF# `gtFloatI#` nanF# ) -- False
+  test "gtFloatI#" (nanF#  `gtFloatI#` infpF#) -- False
+  test "gtFloatI#" (nanF#  `gtFloatI#` infnF#) -- False
+
+  putStrLn "=== testing ltFloatI# ==="
+  test "ltFloatI#" (zeroF# `ltFloatI#` zeroF#) -- False
+  test "ltFloatI#" (oneF#  `ltFloatI#` zeroF#) -- False
+  test "ltFloatI#" (zeroF# `ltFloatI#` oneF# ) -- True
+  test "ltFloatI#" (zeroF# `ltFloatI#` nanF# ) -- False
+  test "ltFloatI#" (nanF#  `ltFloatI#` zeroF#) -- False
+  test "ltFloatI#" (nanF#  `ltFloatI#` nanF# ) -- False
+  test "ltFloatI#" (infpF# `ltFloatI#` infpF#) -- False
+  test "ltFloatI#" (infnF# `ltFloatI#` infnF#) -- False
+  test "ltFloatI#" (infpF# `ltFloatI#` infnF#) -- False
+  test "ltFloatI#" (infnF# `ltFloatI#` infpF#) -- True
+  test "ltFloatI#" (infpF# `ltFloatI#` nanF# ) -- False
+  test "ltFloatI#" (infnF# `ltFloatI#` nanF# ) -- False
+  test "ltFloatI#" (nanF#  `ltFloatI#` infpF#) -- False
+  test "ltFloatI#" (nanF#  `ltFloatI#` infnF#) -- False
+
+  putStrLn "=== testing geFloatI# ==="
+  test "geFloatI#" (zeroF# `geFloatI#` zeroF#) -- True
+  test "geFloatI#" (oneF#  `geFloatI#` zeroF#) -- True
+  test "geFloatI#" (zeroF# `geFloatI#` oneF# ) -- False
+  test "geFloatI#" (zeroF# `geFloatI#` nanF# ) -- False
+  test "geFloatI#" (nanF#  `geFloatI#` zeroF#) -- False
+  test "geFloatI#" (nanF#  `geFloatI#` nanF# ) -- False
+  test "geFloatI#" (infpF# `geFloatI#` infpF#) -- True
+  test "geFloatI#" (infnF# `geFloatI#` infnF#) -- True
+  test "geFloatI#" (infpF# `geFloatI#` infnF#) -- True
+  test "geFloatI#" (infnF# `geFloatI#` infpF#) -- False
+  test "geFloatI#" (infpF# `geFloatI#` nanF# ) -- False
+  test "geFloatI#" (infnF# `geFloatI#` nanF# ) -- False
+  test "geFloatI#" (nanF#  `geFloatI#` infpF#) -- False
+  test "geFloatI#" (nanF#  `geFloatI#` infnF#) -- False
+
+  putStrLn "=== testing leFloatI# ==="
+  test "leFloatI#" (zeroF# `leFloatI#` zeroF#) -- True
+  test "leFloatI#" (oneF#  `leFloatI#` zeroF#) -- False
+  test "leFloatI#" (zeroF# `leFloatI#` oneF# ) -- True
+  test "leFloatI#" (zeroF# `leFloatI#` nanF# ) -- False
+  test "leFloatI#" (nanF#  `leFloatI#` zeroF#) -- False
+  test "leFloatI#" (nanF#  `leFloatI#` nanF# ) -- False
+  test "leFloatI#" (infpF# `leFloatI#` infpF#) -- True
+  test "leFloatI#" (infnF# `leFloatI#` infnF#) -- True
+  test "leFloatI#" (infpF# `leFloatI#` infnF#) -- False
+  test "leFloatI#" (infnF# `leFloatI#` infpF#) -- True
+  test "leFloatI#" (infpF# `leFloatI#` nanF# ) -- False
+  test "leFloatI#" (infnF# `leFloatI#` nanF# ) -- False
+  test "leFloatI#" (nanF#  `leFloatI#` infpF#) -- False
+  test "leFloatI#" (nanF#  `leFloatI#` infnF#) -- False
+
+  putStrLn "=== testing eqFloatI# ==="
+  test "eqFloatI#" (zeroF# `eqFloatI#` zeroF#) -- True
+  test "eqFloatI#" (oneF#  `eqFloatI#` zeroF#) -- False
+  test "eqFloatI#" (zeroF# `eqFloatI#` oneF# ) -- False
+  test "eqFloatI#" (zeroF# `eqFloatI#` nanF# ) -- False
+  test "eqFloatI#" (nanF#  `eqFloatI#` zeroF#) -- False
+  test "eqFloatI#" (nanF#  `eqFloatI#` nanF# ) -- False
+  test "eqFloatI#" (infpF# `eqFloatI#` infpF#) -- True
+  test "eqFloatI#" (infnF# `eqFloatI#` infnF#) -- True
+  test "eqFloatI#" (infpF# `eqFloatI#` infnF#) -- False
+  test "eqFloatI#" (infnF# `eqFloatI#` infpF#) -- False
+  test "eqFloatI#" (infpF# `eqFloatI#` nanF# ) -- False
+  test "eqFloatI#" (infnF# `eqFloatI#` nanF# ) -- False
+  test "eqFloatI#" (nanF#  `eqFloatI#` infpF#) -- False
+  test "eqFloatI#" (nanF#  `eqFloatI#` infnF#) -- False
+
+  putStrLn "=== testing neFloatI# ==="
+  test "neFloatI#" (zeroF# `neFloatI#` zeroF#) -- False
+  test "neFloatI#" (oneF#  `neFloatI#` zeroF#) -- True
+  test "neFloatI#" (zeroF# `neFloatI#` oneF# ) -- True
+  test "neFloatI#" (zeroF# `neFloatI#` nanF# ) -- True
+  test "neFloatI#" (nanF#  `neFloatI#` zeroF#) -- True
+  test "neFloatI#" (nanF#  `neFloatI#` nanF# ) -- True
+  test "neFloatI#" (infpF# `neFloatI#` infpF#) -- False
+  test "neFloatI#" (infnF# `neFloatI#` infnF#) -- False
+  test "neFloatI#" (infpF# `neFloatI#` infnF#) -- True
+  test "neFloatI#" (infnF# `neFloatI#` infpF#) -- True
+  test "neFloatI#" (infpF# `neFloatI#` nanF# ) -- True
+  test "neFloatI#" (infnF# `neFloatI#` nanF# ) -- True
+  test "neFloatI#" (nanF#  `neFloatI#` infpF#) -- True
+  test "neFloatI#" (nanF#  `neFloatI#` infnF#) -- True
+
+  --- Now all the above tests are repeated for primop wrappers
+  putStrLn "=== TESTING WRAPPERS ==="
+  -- Wrappers for comparing Char
+  putStrLn "=== testing Char > ==="
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) a    a   ) -- False
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) b    a   ) -- True
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) a    b   ) -- False
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) minC minC) -- False
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) maxC maxC) -- False
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) minC maxC) -- False
+  testw "Char >" ((\(C# a#) (C# b#) -> a# `gtChar#` b#) maxC minC) -- True
+
+  putStrLn "=== testing Char >= ==="
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) a    a   ) -- True
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) b    a   ) -- True
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) a    b   ) -- False
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) minC minC) -- True
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) maxC maxC) -- True
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) minC maxC) -- False
+  testw "Char >=" ((\(C# a#) (C# b#) -> a# `geChar#` b#) maxC minC) -- True
+
+  putStrLn "=== testing Char < ==="
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) a    a   ) -- False
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) b    a   ) -- False
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) a    b   ) -- True
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) minC minC) -- False
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) maxC maxC) -- False
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) minC maxC) -- True
+  testw "Char <" ((\(C# a#) (C# b#) -> a# `ltChar#` b#) maxC minC) -- False
+
+  putStrLn "=== testing Char <= ==="
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) a    a   ) -- True
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) b    a   ) -- False
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) a    b   ) -- True
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) minC minC) -- True
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) maxC maxC) -- True
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) minC maxC) -- True
+  testw "Char <=" ((\(C# a#) (C# b#) -> a# `leChar#` b#) maxC minC) -- False
+
+  putStrLn "=== testing Char == ==="
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) a    a   ) -- True
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) b    a   ) -- False
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) a    b   ) -- False
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) minC minC) -- True
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) maxC maxC) -- True
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) minC maxC) -- False
+  testw "Char ==" ((\(C# a#) (C# b#) -> a# `eqChar#` b#) maxC minC) -- False
+
+  putStrLn "=== testing Char /= ==="
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) a    a   ) -- False
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) b    a   ) -- True
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) a    b   ) -- True
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) minC minC) -- False
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) maxC maxC) -- False
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) minC maxC) -- True
+  testw "Char /=" ((\(C# a#) (C# b#) -> a# `neChar#` b#) maxC minC) -- True
+
+  -- Wrappers for comparing Int
+  putStrLn "=== testing Int > ==="
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) 0        0       ) -- False
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) 1        0       ) -- True
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) 0        1       ) -- False
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) minI     minI    ) -- False
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) maxI     maxI    ) -- False
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) (minI+1) minI    ) -- True
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) minI     (minI-1)) -- False (overflow)
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) (maxI+1) maxI    ) -- False (overflow)
+  testw "Int >" ((\(I# a#) (I# b#) -> a# ># b#) maxI     (maxI-1)) -- True
+
+  putStrLn "=== testing Int < ==="
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) 0        0       ) -- False
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) 1        0       ) -- False
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) 0        1       ) -- True
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) minI     minI    ) -- False
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) maxI     maxI    ) -- False
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) minI     (minI+1)) -- True
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) (minI-1) minI    ) -- False (overflow)
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) maxI     (maxI+1)) -- False (overflow)
+  testw "Int <" ((\(I# a#) (I# b#) -> a# <# b#) (maxI-1) maxI    ) -- True
+
+  putStrLn "=== testing Int >= ==="
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) 0        0       ) -- True
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) 1        0       ) -- True
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) 0        1       ) -- False
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) minI     minI    ) -- True
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) maxI     maxI    ) -- True
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) (minI+1) minI    ) -- True
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) minI     (minI-1)) -- False (overflow)
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) (maxI+1) maxI    ) -- False (overflow)
+  testw "Int >=" ((\(I# a#) (I# b#) -> a# >=# b#) maxI     (maxI-1)) -- True
+
+  putStrLn "=== testing Int <= ==="
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) 0        0       ) -- True
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) 1        0       ) -- False
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) 0        1       ) -- True
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) minI     minI    ) -- True
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) maxI     maxI    ) -- True
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) minI     (minI+1)) -- True
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) (minI-1) minI    ) -- False (overflow)
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) maxI     (maxI+1)) -- False (overflow)
+  testw "Int <=" ((\(I# a#) (I# b#) -> a# <=# b#) (maxI-1) maxI    ) -- True
+
+  putStrLn "=== testing Int == ==="
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) 0        0       ) -- True
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) 1        0       ) -- False
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) 0        1       ) -- False
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) maxI     maxI    ) -- True
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) (maxI-1) maxI    ) -- False
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) minI     minI    ) -- True
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) minI     (minI+1)) -- False
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) minI     (maxI+1)) -- True (overflow)
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) (maxI+1) minI    ) -- True (overflow)
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) maxI     (minI-1)) -- True (overflow)
+  testw "Int ==" ((\(I# a#) (I# b#) -> a# ==# b#) (minI-1) maxI    ) -- True (overflow)
+
+  putStrLn "=== testing Int /= ==="
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) 0        0       ) -- False
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) 1        0       ) -- True
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) 0        1       ) -- True
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) maxI     maxI    ) -- False
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) (maxI-1) maxI    ) -- True
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) minI     minI    ) -- False
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) minI     (minI+1)) -- True
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) minI     (maxI+1)) -- False (overflow)
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) (maxI+1) minI    ) -- False (overflow)
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) maxI     (minI-1)) -- False (overflow)
+  testw "Int /=" ((\(I# a#) (I# b#) -> a# /=# b#) (minI-1) maxI    ) -- False (overflow)
+
+  -- Wrappers for comparing Word
+  putStrLn "=== testing Word > ==="
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) zeroW       zeroW      ) -- False
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) oneW        zeroW      ) -- True
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) zeroW       oneW       ) -- False
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) minW        minW       ) -- False
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) maxW        maxW       ) -- False
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) (minW+oneW) minW       ) -- True
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) minW        (minW-oneW)) -- False (overflow)
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) (maxW+oneW) maxW       ) -- False (overflow)
+  testw "Word >" ((\(W# a#) (W# b#) -> a# `gtWord#` b#) maxW        (maxW-oneW)) -- True
+
+  putStrLn "=== testing Word < ==="
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) zeroW       zeroW      ) -- False
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) oneW        zeroW      ) -- False
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) zeroW       oneW       ) -- True
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) minW        minW       ) -- False
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) maxW        maxW       ) -- False
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) minW        (minW+oneW)) -- True
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) (minW-oneW) minW       ) -- False (overflow)
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) maxW        (maxW+oneW)) -- False (overflow)
+  testw "Word <" ((\(W# a#) (W# b#) -> a# `ltWord#` b#) (maxW-oneW) maxW       ) -- True
+
+  putStrLn "=== testing Word >= ==="
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) zeroW       zeroW      ) -- True
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) oneW        zeroW      ) -- True
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) zeroW       oneW       ) -- False
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) minW        minW       ) -- True
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) maxW        maxW       ) -- True
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) (minW+oneW) minW       ) -- True
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) minW        (minW-oneW)) -- False (overflow)
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) (maxW+oneW) maxW       ) -- False (overflow)
+  testw "Word >=" ((\(W# a#) (W# b#) -> a# `geWord#` b#) maxW        (maxW-oneW)) -- True
+
+  putStrLn "=== testing Word <= ==="
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) zeroW       zeroW      ) -- True
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) oneW        zeroW      ) -- False
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) zeroW       oneW       ) -- True
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) minW        minW       ) -- True
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) maxW        maxW       ) -- True
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) minW        (minW+oneW)) -- True
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) (minW-oneW) minW       ) -- False (overflow)
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) maxW        (maxW+oneW)) -- False (overflow)
+  testw "Word <=" ((\(W# a#) (W# b#) -> a# `leWord#` b#) (maxW-oneW) maxW       ) -- True
+
+  putStrLn "=== testing Word == ==="
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) zeroW       zeroW      ) -- True
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) oneW        zeroW      ) -- False
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) zeroW       oneW       ) -- False
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) maxW        maxW       ) -- True
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) (maxW-oneW) maxW       ) -- False
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) minW        minW       ) -- True
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) minW        (minW+oneW)) -- False
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) minW        (maxW+oneW)) -- True (overflow)
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) (maxW+oneW) minW       ) -- True (overflow)
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) maxW        (minW-oneW)) -- True (overflow)
+  testw "Word ==" ((\(W# a#) (W# b#) -> a# `eqWord#` b#) (minW-oneW) maxW       ) -- True (overflow)
+
+  putStrLn "=== testing Word /= ==="
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) zeroW       zeroW      ) -- False
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) oneW        zeroW      ) -- True
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) zeroW       oneW       ) -- True
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) maxW        maxW       ) -- False
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) (maxW-oneW) maxW       ) -- True
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) minW        minW       ) -- False
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) minW        (minW+oneW)) -- True
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) minW        (maxW+oneW)) -- False (overflow)
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) (maxW+oneW) minW       ) -- False (overflow)
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) maxW        (minW-oneW)) -- False (overflow)
+  testw "Word /=" ((\(W# a#) (W# b#) -> a# `neWord#` b#) (minW-oneW) maxW       ) -- False (overflow)
+
+  -- Wrappers for comparing Double
+  putStrLn "=== testing Double > ==="
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  0.0  0.0 ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  1.0  0.0 ) -- True
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  0.0  1.0 ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  0.0  nan ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  nan  0.0 ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  nan  nan ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  infp infp) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  infn infn) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  infp infn) -- True
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  infn infp) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  infp nan ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  infn nan ) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  nan  infp) -- False
+  testw "Double >"  ((\(D# a) (D# b) -> a >## b)  nan  infn) -- False
+
+  putStrLn "=== testing Double < ==="
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  0.0  0.0 ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  1.0  0.0 ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  0.0  1.0 ) -- True
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  0.0  nan ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  nan  0.0 ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  nan  nan ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  infp infp) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  infn infn) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  infp infn) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  infn infp) -- True
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  infp nan ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  infn nan ) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  nan  infp) -- False
+  testw "Double <"  ((\(D# a) (D# b) -> a <## b)  nan  infn) -- False
+
+  putStrLn "=== testing Double >= ==="
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) 0.0  0.0 ) -- True
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) 1.0  0.0 ) -- True
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) 0.0  1.0 ) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) 0.0  nan ) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) nan  0.0 ) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) nan  nan ) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) infp infp) -- True
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) infn infn) -- True
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) infp infn) -- True
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) infn infp) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) infp nan ) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) infn nan ) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) nan  infp) -- False
+  testw "Double >=" ((\(D# a) (D# b) -> a >=## b) nan  infn) -- False
+
+  putStrLn "=== testing Double <= ==="
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) 0.0  0.0 ) -- True
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) 1.0  0.0 ) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) 0.0  1.0 ) -- True
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) 0.0  nan ) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) nan  0.0 ) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) nan  nan ) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) infp infp) -- True
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) infn infn) -- True
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) infp infn) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) infn infp) -- True
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) infp nan ) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) infn nan ) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) nan  infp) -- False
+  testw "Double <=" ((\(D# a) (D# b) -> a <=## b) nan  infn) -- False
+
+  putStrLn "=== testing Double == ==="
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) 0.0  0.0 ) -- True
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) 1.0  0.0 ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) 0.0  1.0 ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) 0.0  nan ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) nan  0.0 ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) nan  nan ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) infp infp) -- True
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) infn infn) -- True
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) infp infn) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) infn infp) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) infp nan ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) infn nan ) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) nan  infp) -- False
+  testw "Double ==" ((\(D# a) (D# b) -> a ==## b) nan  infn) -- False
+
+  putStrLn "=== testing Double /= ==="
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) 0.0  0.0 ) -- False
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) 1.0  0.0 ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) 0.0  1.0 ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) 0.0  nan ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) nan  0.0 ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) nan  nan ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) infp infp) -- False
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) infn infn) -- False
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) infp infn) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) infn infp) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) infp nan ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) infn nan ) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) nan  infp) -- True
+  testw "Double /=" ((\(D# a) (D# b) -> a /=## b) nan  infn) -- True
+
+  -- Wrappers for comparing Float
+  putStrLn "=== testing Float > ==="
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) zeroF zeroF) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) oneF  zeroF) -- True
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) zeroF oneF ) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) zeroF nanF ) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) nanF  zeroF) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) nanF  nanF ) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) infpF infpF) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) infnF infnF) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) infpF infnF) -- True
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) infnF infpF) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) infpF nanF ) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) infnF nanF ) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) nanF  infpF) -- False
+  testw "Float >"  ((\(F# a) (F# b) -> a `gtFloat#` b) nanF  infnF) -- False
+
+  putStrLn "=== testing Float < ==="
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) zeroF zeroF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) oneF  zeroF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) zeroF oneF ) -- True
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) zeroF nanF ) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) nanF  zeroF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) nanF  nanF ) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) infpF infpF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) infnF infnF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) infpF infnF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) infnF infpF) -- True
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) infpF nanF ) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) infnF nanF ) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) nanF  infpF) -- False
+  testw "Float <"  ((\(F# a) (F# b) -> a `ltFloat#` b) nanF  infnF) -- False
+
+  putStrLn "=== testing Float >= ==="
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) zeroF zeroF) -- True
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) oneF  zeroF) -- True
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) zeroF oneF ) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) zeroF nanF ) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) nanF  zeroF) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) nanF  nanF ) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) infpF infpF) -- True
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) infnF infnF) -- True
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) infpF infnF) -- True
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) infnF infpF) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) infpF nanF ) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) infnF nanF ) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) nanF  infpF) -- False
+  testw "Float >=" ((\(F# a) (F# b) -> a `geFloat#` b) nanF  infnF) -- False
+
+  putStrLn "=== testing Float <= ==="
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) zeroF zeroF) -- True
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) oneF  zeroF) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) zeroF oneF ) -- True
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) zeroF nanF ) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) nanF  zeroF) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) nanF  nanF ) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) infpF infpF) -- True
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) infnF infnF) -- True
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) infpF infnF) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) infnF infpF) -- True
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) infpF nanF ) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) infnF nanF ) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) nanF  infpF) -- False
+  testw "Float <=" ((\(F# a) (F# b) -> a `leFloat#` b) nanF  infnF) -- False
+
+  putStrLn "=== testing Float == ==="
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) zeroF zeroF) -- True
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) oneF  zeroF) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) zeroF oneF ) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) zeroF nanF ) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) nanF  zeroF) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) nanF  nanF ) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) infpF infpF) -- True
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) infnF infnF) -- True
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) infpF infnF) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) infnF infpF) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) infpF nanF ) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) infnF nanF ) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) nanF  infpF) -- False
+  testw "Float ==" ((\(F# a) (F# b) -> a `eqFloat#` b) nanF  infnF) -- False
+
+  putStrLn "=== testing Float /= ==="
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) zeroF zeroF) -- False
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) oneF  zeroF) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) zeroF oneF ) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) zeroF nanF ) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) nanF  zeroF) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) nanF  nanF ) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) infpF infpF) -- False
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) infnF infnF) -- False
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) infpF infnF) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) infnF infpF) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) infpF nanF ) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) infnF nanF ) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) nanF  infpF) -- True
+  testw "Float /=" ((\(F# a) (F# b) -> a `neFloat#` b) nanF  infnF) -- True
+    where
+      -- every integer is compared to 1 representing True. This
+      -- results in printing "True" when the primop should return True
+      -- and printing "False" when it should return False
+      test :: String -> Int# -> IO ()
+      test str x = putStrLn $ str ++ " " ++ (show (I# x == 1))
+      testw :: String -> Bool -> IO ()
+      testw str x = putStrLn $ str ++ " " ++ (show x)
+      a            = 'a'
+      b            = 'b'
+      !(C# a#)     = a
+      !(C# b#)     = b
+      zeroW        = 0 :: Word
+      oneW         = 1 :: Word
+      !(W# zeroW#) =  zeroW
+      !(W# oneW#)  =  oneW
+      nan          =  0.0 / 0.0 :: Double
+      infp         =  1.0 / 0.0 :: Double
+      infn         = -1.0 / 0.0 :: Double
+      !(D# nan##)  =  0.0 / 0.0
+      !(D# infp##) =  1.0 / 0.0
+      !(D# infn##) = -1.0 / 0.0
+      zeroF        = 0.0 :: Float
+      oneF         = 1.0 :: Float
+      nanF         = 0.0 / 0.0 :: Float
+      infpF        = 1.0 / 0.0 :: Float
+      infnF        = -1.0 / 0.0 :: Float
+      !(F# zeroF#) =  0.0
+      !(F# oneF#)  =  1.0
+      !(F# nanF#)  =  0.0 / 0.0
+      !(F# infpF#) =  1.0 / 0.0
+      !(F# infnF#) = -1.0 / 0.0
+      minC         = minBound :: Char
+      maxC         = maxBound :: Char
+      !(C# minC#)  = minC
+      !(C# maxC#)  = maxC
+      minI         = minBound :: Int
+      maxI         = maxBound :: Int
+      !(I# minI#)  = minI
+      !(I# maxI#)  = maxI
+      minW         = minBound :: Word
+      maxW         = maxBound :: Word
+      !(W# minW#)  = minW
+      !(W# maxW#)  = maxW
diff --git a/testsuite/tests/primops/should_run/T6135.stdout b/testsuite/tests/primops/should_run/T6135.stdout
new file mode 100644 (file)
index 0000000..3b1e22b
--- /dev/null
@@ -0,0 +1,713 @@
+=== testing gtCharI# ===
+gtCharI# False
+gtCharI# True
+gtCharI# False
+gtCharI# False
+gtCharI# False
+gtCharI# False
+gtCharI# True
+=== testing geCharI# ===
+geCharI# True
+geCharI# True
+geCharI# False
+geCharI# True
+geCharI# True
+geCharI# False
+geCharI# True
+=== testing ltCharI# ===
+ltCharI# False
+ltCharI# False
+ltCharI# True
+ltCharI# False
+ltCharI# False
+ltCharI# True
+ltCharI# False
+=== testing leCharI# ===
+leCharI# True
+leCharI# False
+leCharI# True
+leCharI# True
+leCharI# True
+leCharI# True
+leCharI# False
+=== testing eqCharI# ===
+eqCharI# True
+eqCharI# False
+eqCharI# False
+eqCharI# True
+eqCharI# True
+eqCharI# False
+eqCharI# False
+=== testing neCharI# ===
+neCharI# False
+neCharI# True
+neCharI# True
+neCharI# False
+neCharI# False
+neCharI# True
+neCharI# True
+=== testing >$# ===
+>$# False
+>$# True
+>$# False
+>$# False
+>$# False
+>$# True
+>$# False
+>$# False
+>$# True
+=== testing <$# ===
+<$# False
+<$# False
+<$# True
+<$# False
+<$# False
+<$# True
+<$# False
+<$# False
+<$# True
+=== testing >=$# ===
+>=$# True
+>=$# True
+>=$# False
+>=$# True
+>=$# True
+>=$# True
+>=$# False
+>=$# False
+>=$# True
+=== testing <=$# ===
+<=$# True
+<=$# False
+<=$# True
+<=$# True
+<=$# True
+<=$# True
+<=$# False
+<=$# False
+<=$# True
+=== testing ==$# ===
+==$# True
+==$# False
+==$# False
+==$# True
+==$# False
+==$# True
+==$# False
+==$# True
+==$# True
+==$# True
+==$# True
+=== testing /=$# ===
+/=$# False
+/=$# True
+/=$# True
+/=$# False
+/=$# True
+/=$# False
+/=$# True
+/=$# False
+/=$# False
+/=$# False
+/=$# False
+=== testing gtWordI# ===
+gtWordI# False
+gtWordI# True
+gtWordI# False
+gtWordI# False
+gtWordI# False
+gtWordI# True
+gtWordI# False
+gtWordI# False
+gtWordI# True
+=== testing ltWordI# ===
+ltWordI# False
+ltWordI# False
+ltWordI# True
+ltWordI# False
+ltWordI# False
+ltWordI# True
+ltWordI# False
+ltWordI# False
+ltWordI# True
+=== testing geWordI# ===
+geWordI# True
+geWordI# True
+geWordI# False
+geWordI# True
+geWordI# True
+geWordI# True
+geWordI# False
+geWordI# False
+geWordI# True
+=== testing leWordI# ===
+leWordI# True
+leWordI# False
+leWordI# True
+leWordI# True
+leWordI# True
+leWordI# True
+leWordI# False
+leWordI# False
+leWordI# True
+=== testing eqWordI# ===
+eqWordI# True
+eqWordI# False
+eqWordI# False
+eqWordI# True
+eqWordI# False
+eqWordI# True
+eqWordI# False
+eqWordI# True
+eqWordI# True
+eqWordI# True
+eqWordI# True
+=== testing neWordI# ===
+neWordI# False
+neWordI# True
+neWordI# True
+neWordI# False
+neWordI# True
+neWordI# False
+neWordI# True
+neWordI# False
+neWordI# False
+neWordI# False
+neWordI# False
+=== testing >$## ===
+>$## False
+>$## True
+>$## False
+>$## False
+>$## False
+>$## False
+>$## False
+>$## False
+>$## True
+>$## False
+>$## False
+>$## False
+>$## False
+>$## False
+=== testing <$## ===
+<$## False
+<$## False
+<$## True
+<$## False
+<$## False
+<$## False
+<$## False
+<$## False
+<$## False
+<$## True
+<$## False
+<$## False
+<$## False
+<$## False
+=== testing >=$## ===
+>=$## True
+>=$## True
+>=$## False
+>=$## False
+>=$## False
+>=$## False
+>=$## True
+>=$## True
+>=$## True
+>=$## False
+>=$## False
+>=$## False
+>=$## False
+>=$## False
+=== testing <=$## ===
+<=$## True
+<=$## False
+<=$## True
+<=$## False
+<=$## False
+<=$## False
+<=$## True
+<=$## True
+<=$## False
+<=$## True
+<=$## False
+<=$## False
+<=$## False
+<=$## False
+=== testing ==$## ===
+==$## True
+==$## False
+==$## False
+==$## False
+==$## False
+==$## False
+==$## True
+==$## True
+==$## False
+==$## False
+==$## False
+==$## False
+==$## False
+==$## False
+=== testing /=$## ===
+/=$## False
+/=$## True
+/=$## True
+/=$## True
+/=$## True
+/=$## True
+/=$## False
+/=$## False
+/=$## True
+/=$## True
+/=$## True
+/=$## True
+/=$## True
+/=$## True
+=== testing gtFloatI# ===
+gtFloatI# False
+gtFloatI# True
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+gtFloatI# True
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+gtFloatI# False
+=== testing ltFloatI# ===
+ltFloatI# False
+ltFloatI# False
+ltFloatI# True
+ltFloatI# False
+ltFloatI# False
+ltFloatI# False
+ltFloatI# False
+ltFloatI# False
+ltFloatI# False
+ltFloatI# True
+ltFloatI# False
+ltFloatI# False
+ltFloatI# False
+ltFloatI# False
+=== testing geFloatI# ===
+geFloatI# True
+geFloatI# True
+geFloatI# False
+geFloatI# False
+geFloatI# False
+geFloatI# False
+geFloatI# True
+geFloatI# True
+geFloatI# True
+geFloatI# False
+geFloatI# False
+geFloatI# False
+geFloatI# False
+geFloatI# False
+=== testing leFloatI# ===
+leFloatI# True
+leFloatI# False
+leFloatI# True
+leFloatI# False
+leFloatI# False
+leFloatI# False
+leFloatI# True
+leFloatI# True
+leFloatI# False
+leFloatI# True
+leFloatI# False
+leFloatI# False
+leFloatI# False
+leFloatI# False
+=== testing eqFloatI# ===
+eqFloatI# True
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+eqFloatI# True
+eqFloatI# True
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+eqFloatI# False
+=== testing neFloatI# ===
+neFloatI# False
+neFloatI# True
+neFloatI# True
+neFloatI# True
+neFloatI# True
+neFloatI# True
+neFloatI# False
+neFloatI# False
+neFloatI# True
+neFloatI# True
+neFloatI# True
+neFloatI# True
+neFloatI# True
+neFloatI# True
+=== TESTING WRAPPERS ===
+=== testing Char > ===
+Char > False
+Char > True
+Char > False
+Char > False
+Char > False
+Char > False
+Char > True
+=== testing Char >= ===
+Char >= True
+Char >= True
+Char >= False
+Char >= True
+Char >= True
+Char >= False
+Char >= True
+=== testing Char < ===
+Char < False
+Char < False
+Char < True
+Char < False
+Char < False
+Char < True
+Char < False
+=== testing Char <= ===
+Char <= True
+Char <= False
+Char <= True
+Char <= True
+Char <= True
+Char <= True
+Char <= False
+=== testing Char == ===
+Char == True
+Char == False
+Char == False
+Char == True
+Char == True
+Char == False
+Char == False
+=== testing Char /= ===
+Char /= False
+Char /= True
+Char /= True
+Char /= False
+Char /= False
+Char /= True
+Char /= True
+=== testing Int > ===
+Int > False
+Int > True
+Int > False
+Int > False
+Int > False
+Int > True
+Int > False
+Int > False
+Int > True
+=== testing Int < ===
+Int < False
+Int < False
+Int < True
+Int < False
+Int < False
+Int < True
+Int < False
+Int < False
+Int < True
+=== testing Int >= ===
+Int >= True
+Int >= True
+Int >= False
+Int >= True
+Int >= True
+Int >= True
+Int >= False
+Int >= False
+Int >= True
+=== testing Int <= ===
+Int <= True
+Int <= False
+Int <= True
+Int <= True
+Int <= True
+Int <= True
+Int <= False
+Int <= False
+Int <= True
+=== testing Int == ===
+Int == True
+Int == False
+Int == False
+Int == True
+Int == False
+Int == True
+Int == False
+Int == True
+Int == True
+Int == True
+Int == True
+=== testing Int /= ===
+Int /= False
+Int /= True
+Int /= True
+Int /= False
+Int /= True
+Int /= False
+Int /= True
+Int /= False
+Int /= False
+Int /= False
+Int /= False
+=== testing Word > ===
+Word > False
+Word > True
+Word > False
+Word > False
+Word > False
+Word > True
+Word > False
+Word > False
+Word > True
+=== testing Word < ===
+Word < False
+Word < False
+Word < True
+Word < False
+Word < False
+Word < True
+Word < False
+Word < False
+Word < True
+=== testing Word >= ===
+Word >= True
+Word >= True
+Word >= False
+Word >= True
+Word >= True
+Word >= True
+Word >= False
+Word >= False
+Word >= True
+=== testing Word <= ===
+Word <= True
+Word <= False
+Word <= True
+Word <= True
+Word <= True
+Word <= True
+Word <= False
+Word <= False
+Word <= True
+=== testing Word == ===
+Word == True
+Word == False
+Word == False
+Word == True
+Word == False
+Word == True
+Word == False
+Word == True
+Word == True
+Word == True
+Word == True
+=== testing Word /= ===
+Word /= False
+Word /= True
+Word /= True
+Word /= False
+Word /= True
+Word /= False
+Word /= True
+Word /= False
+Word /= False
+Word /= False
+Word /= False
+=== testing Double > ===
+Double > False
+Double > True
+Double > False
+Double > False
+Double > False
+Double > False
+Double > False
+Double > False
+Double > True
+Double > False
+Double > False
+Double > False
+Double > False
+Double > False
+=== testing Double < ===
+Double < False
+Double < False
+Double < True
+Double < False
+Double < False
+Double < False
+Double < False
+Double < False
+Double < False
+Double < True
+Double < False
+Double < False
+Double < False
+Double < False
+=== testing Double >= ===
+Double >= True
+Double >= True
+Double >= False
+Double >= False
+Double >= False
+Double >= False
+Double >= True
+Double >= True
+Double >= True
+Double >= False
+Double >= False
+Double >= False
+Double >= False
+Double >= False
+=== testing Double <= ===
+Double <= True
+Double <= False
+Double <= True
+Double <= False
+Double <= False
+Double <= False
+Double <= True
+Double <= True
+Double <= False
+Double <= True
+Double <= False
+Double <= False
+Double <= False
+Double <= False
+=== testing Double == ===
+Double == True
+Double == False
+Double == False
+Double == False
+Double == False
+Double == False
+Double == True
+Double == True
+Double == False
+Double == False
+Double == False
+Double == False
+Double == False
+Double == False
+=== testing Double /= ===
+Double /= False
+Double /= True
+Double /= True
+Double /= True
+Double /= True
+Double /= True
+Double /= False
+Double /= False
+Double /= True
+Double /= True
+Double /= True
+Double /= True
+Double /= True
+Double /= True
+=== testing Float > ===
+Float > False
+Float > True
+Float > False
+Float > False
+Float > False
+Float > False
+Float > False
+Float > False
+Float > True
+Float > False
+Float > False
+Float > False
+Float > False
+Float > False
+=== testing Float < ===
+Float < False
+Float < False
+Float < True
+Float < False
+Float < False
+Float < False
+Float < False
+Float < False
+Float < False
+Float < True
+Float < False
+Float < False
+Float < False
+Float < False
+=== testing Float >= ===
+Float >= True
+Float >= True
+Float >= False
+Float >= False
+Float >= False
+Float >= False
+Float >= True
+Float >= True
+Float >= True
+Float >= False
+Float >= False
+Float >= False
+Float >= False
+Float >= False
+=== testing Float <= ===
+Float <= True
+Float <= False
+Float <= True
+Float <= False
+Float <= False
+Float <= False
+Float <= True
+Float <= True
+Float <= False
+Float <= True
+Float <= False
+Float <= False
+Float <= False
+Float <= False
+=== testing Float == ===
+Float == True
+Float == False
+Float == False
+Float == False
+Float == False
+Float == False
+Float == True
+Float == True
+Float == False
+Float == False
+Float == False
+Float == False
+Float == False
+Float == False
+=== testing Float /= ===
+Float /= False
+Float /= True
+Float /= True
+Float /= True
+Float /= True
+Float /= True
+Float /= False
+Float /= False
+Float /= True
+Float /= True
+Float /= True
+Float /= True
+Float /= True
+Float /= True
diff --git a/testsuite/tests/primops/should_run/all.T b/testsuite/tests/primops/should_run/all.T
new file mode 100644 (file)
index 0000000..ddd6060
--- /dev/null
@@ -0,0 +1 @@
+test('T6135', normal, compile_and_run, [''])
index 6fb26b2..417c948 100644 (file)
@@ -72,7 +72,7 @@ simpl021:
 .PHONY: T5327
 T5327:
        $(RM) -f T5327.hi T5327.o
-       '$(TEST_HC)' $(TEST_HC_OPTS) -c T5327.hs -O -ddump-simpl | grep -c "GHC.Prim.># 34 "
+       '$(TEST_HC)' $(TEST_HC_OPTS) -c T5327.hs -O -ddump-simpl | grep -c 'GHC.Prim.>$$# 34 '
 
 .PHONY: T5623
 T5623:
index 5dadfec..e42c76e 100644 (file)
@@ -1,13 +1,14 @@
 
 ==================== Tidy Core ====================
-Result size of Tidy Core = {terms: 27, types: 10, coercions: 0}
+Result size of Tidy Core = {terms: 29, types: 12, coercions: 0}
 
 Rec {
 xs :: GHC.Prim.Int# -> ()
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <L,U>]
 xs =
   \ (m :: GHC.Prim.Int#) ->
-    case GHC.Prim.<=# m 1 of _ {
+    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=$# m 1)
+    of _ {
       GHC.Types.False -> xs (GHC.Prim.-# m 1);
       GHC.Types.True -> GHC.Tuple.()
     }
@@ -18,7 +19,8 @@ T3772.foo [InlPrag=NOINLINE] :: GHC.Types.Int -> ()
 T3772.foo =
   \ (n :: GHC.Types.Int) ->
     case n of _ { GHC.Types.I# n# ->
-    case GHC.Prim.<=# n# 0 of _ {
+    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=$# n# 0)
+    of _ {
       GHC.Types.False -> xs n#;
       GHC.Types.True -> GHC.Tuple.()
     }
index 5cde5c0..fcc1d1c 100644 (file)
@@ -1,6 +1,6 @@
 
 ==================== Tidy Core ====================
-Result size of Tidy Core = {terms: 22, types: 10, coercions: 0}
+Result size of Tidy Core = {terms: 23, types: 11, coercions: 0}
 
 lvl :: [GHC.Types.Char]
 [GblId, Str=DmdType]
@@ -19,7 +19,7 @@ T4930.foo :: GHC.Types.Int -> GHC.Types.Int
          Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
          Tmpl= \ (n [Occ=Once!] :: GHC.Types.Int) ->
                  case n of _ { GHC.Types.I# x ->
-                 case GHC.Prim.<# x 5 of _ {
+                 case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# x 5) of _ {
                    GHC.Types.False -> GHC.Types.I# (GHC.Prim.+# x 5);
                    GHC.Types.True -> T4930.foo1
                  }
@@ -27,7 +27,7 @@ T4930.foo :: GHC.Types.Int -> GHC.Types.Int
 T4930.foo =
   \ (n :: GHC.Types.Int) ->
     case n of _ { GHC.Types.I# x ->
-    case GHC.Prim.<# x 5 of _ {
+    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# x 5) of _ {
       GHC.Types.False -> GHC.Types.I# (GHC.Prim.+# x 5);
       GHC.Types.True -> T4930.foo1
     }
index 2c1c9ca..61454a1 100644 (file)
@@ -1,6 +1,7 @@
 {-# LANGUAGE MagicHash, BangPatterns #-}
 module T5658b where
 import GHC.Prim
+import GHC.PrimWrappers
 
 foo :: ByteArray# -> ByteArray# -> Int# -> Int# -> Bool
 foo xs ys m n = go 0# 0#
index 28e54da..8700b95 100644 (file)
@@ -1,6 +1,6 @@
 
 ==================== Tidy Core ====================
-Result size of Tidy Core = {terms: 156, types: 55, coercions: 0}
+Result size of Tidy Core = {terms: 162, types: 61, coercions: 0}
 
 Roman.foo3 :: GHC.Types.Int
 [GblId, Str=DmdType b]
@@ -24,11 +24,13 @@ Roman.foo_$s$wgo =
                 (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# sc1 sc1) sc1) sc1) sc1)
              sc1)
           sc1 } in
-    case GHC.Prim.<=# sc 0 of _ {
+    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=$# sc 0)
+    of _ {
       GHC.Types.False ->
-        case GHC.Prim.<# sc 100 of _ {
+        case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# sc 100)
+        of _ {
           GHC.Types.False ->
-            case GHC.Prim.<# sc 500 of _ {
+            case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# sc 500) of _ {
               GHC.Types.False ->
                 Roman.foo_$s$wgo (GHC.Prim.-# sc 1) (GHC.Prim.+# a a);
               GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# sc 3) a
@@ -47,7 +49,7 @@ Roman.$wgo
  Str=DmdType <S,1*U><S,1*U>,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=2, Value=True,
          ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=IF_ARGS [60 30] 253 0}]
+         Guidance=IF_ARGS [60 30] 256 0}]
 Roman.$wgo =
   \ (w :: Data.Maybe.Maybe GHC.Types.Int)
     (w1 :: Data.Maybe.Maybe GHC.Types.Int) ->
@@ -69,11 +71,14 @@ Roman.$wgo =
           Data.Maybe.Nothing -> Roman.foo_$s$wgo 10 a;
           Data.Maybe.Just n ->
             case n of _ { GHC.Types.I# x2 ->
-            case GHC.Prim.<=# x2 0 of _ {
+            case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=$# x2 0)
+            of _ {
               GHC.Types.False ->
-                case GHC.Prim.<# x2 100 of _ {
+                case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# x2 100)
+                of _ {
                   GHC.Types.False ->
-                    case GHC.Prim.<# x2 500 of _ {
+                    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# x2 500)
+                    of _ {
                       GHC.Types.False ->
                         Roman.foo_$s$wgo (GHC.Prim.-# x2 1) (GHC.Prim.+# a a);
                       GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# x2 3) a