diff --git a/cranelift/codegen/src/data_value.rs b/cranelift/codegen/src/data_value.rs
index fd9bcab131..affc5b711a 100644
--- a/cranelift/codegen/src/data_value.rs
+++ b/cranelift/codegen/src/data_value.rs
@@ -154,6 +154,25 @@ impl DataValue {
             ty,
         )
     }
+
+    /// Performs a bitwise comparison over the contents of [DataValue].
+    ///
+    /// Returns true if all bits are equal.
+    ///
+    /// This behaviour is different from PartialEq for NaN floats.
+    pub fn bitwise_eq(&self, other: &DataValue) -> bool {
+        match (self, other) {
+            // We need to bit compare the floats to ensure that we produce the correct values
+            // on NaN's. The test suite expects to assert the precise bit pattern on NaN's or
+            // works around it in the tests themselves.
+            (DataValue::F32(a), DataValue::F32(b)) => a.bits() == b.bits(),
+            (DataValue::F64(a), DataValue::F64(b)) => a.bits() == b.bits(),
+
+            // We don't need to worry about F32x4 / F64x2 Since we compare V128 which is already the
+            // raw bytes anyway
+            (a, b) => a == b,
+        }
+    }
 }
 
 /// Record failures to cast [DataValue].
diff --git a/cranelift/reader/src/run_command.rs b/cranelift/reader/src/run_command.rs
index e0820ed187..643ceaeee7 100644
--- a/cranelift/reader/src/run_command.rs
+++ b/cranelift/reader/src/run_command.rs
@@ -54,20 +54,11 @@ impl RunCommand {
         actual: &Vec<DataValue>,
         expected: &Vec<DataValue>,
     ) -> bool {
-        let are_equal = actual
-            .into_iter()
-            .zip(expected.into_iter())
-            .all(|(a, b)| match (a, b) {
-                // We need to bit compare the floats to ensure that we produce the correct values
-                // on NaN's. The test suite expects to assert the precise bit pattern on NaN's or
-                // works around it in the tests themselves.
-                (DataValue::F32(a), DataValue::F32(b)) => a.bits() == b.bits(),
-                (DataValue::F64(a), DataValue::F64(b)) => a.bits() == b.bits(),
-
-                // We don't need to worry about F32x4 / F64x2 Since we compare V128 which is already the
-                // raw bytes anyway
-                (a, b) => a == b,
-            });
+        let are_equal = actual.len() == expected.len()
+            && actual
+                .into_iter()
+                .zip(expected.into_iter())
+                .all(|(a, b)| a.bitwise_eq(b));
 
         match compare {
             Comparison::Equals => are_equal,
diff --git a/fuzz/fuzz_targets/cranelift-fuzzgen.rs b/fuzz/fuzz_targets/cranelift-fuzzgen.rs
index 77d5f12bac..859007c3a3 100644
--- a/fuzz/fuzz_targets/cranelift-fuzzgen.rs
+++ b/fuzz/fuzz_targets/cranelift-fuzzgen.rs
@@ -27,11 +27,12 @@ enum RunResult {
     Error(Box<dyn std::error::Error>),
 }
 
-impl RunResult {
-    pub fn unwrap(self) -> Vec<DataValue> {
-        match self {
-            RunResult::Success(d) => d,
-            _ => panic!("Expected RunResult::Success in unwrap but got: {:?}", self),
+impl PartialEq for RunResult {
+    fn eq(&self, other: &Self) -> bool {
+        if let (RunResult::Success(l), RunResult::Success(r)) = (self, other) {
+            l.len() == r.len() && l.iter().zip(r).all(|(l, r)| l.bitwise_eq(r))
+        } else {
+            false
         }
     }
 }
@@ -123,6 +124,6 @@ fuzz_target!(|testcase: TestCase| {
             _ => panic!("host failed: {:?}", host_res),
         }
 
-        assert_eq!(int_res.unwrap(), host_res.unwrap());
+        assert_eq!(int_res, host_res);
     }
 });