[interpreter] fp tests fail on Windows 32 due to bit pattern mismatches

[kg]

test/f64.wast:2326.1-2326.103: assert_return f64 operands have different bit patterns
test/float_misc.wast:92.1-92.141: assert_return f64 operands have different bit patterns

======================================================================
FAIL: test/f64.wast (__main__.RunTests)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./runtests.py", line 37, in <lambda>
    return lambda self : self._runTestFile(*rec)
  File "./runtests.py", line 20, in _runTestFile
    self.assertEqual(0, exitCode, "test runner failed with exit code %i" % exitCode)
AssertionError: test runner failed with exit code 1

======================================================================
FAIL: test/float_misc.wast (__main__.RunTests)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./runtests.py", line 37, in <lambda>
    return lambda self : self._runTestFile(*rec)
  File "./runtests.py", line 20, in _runTestFile
    self.assertEqual(0, exitCode, "test runner failed with exit code %i" % exitCode)
AssertionError: test runner failed with exit code 1

[sunfishcode]

The test at float_misc.wast:92 is the first of a series of tests with the comment "Computations that round differently on x87", so it's likely that the bug here is OCaml using x87 arithmetic on Windows.

The problem with x87 math in this case is double rounding, with results being first rounded to 80-bit precision and then rounded from there to 64-bit precision. This gives different results in some cases than if the value had been rounded to 64-bit precision directly.

Possible workarounds

Is this a debug or opt build? If an opt build, does anyone know if there's a way to force ocaml to use sse math instead of x87 math? Alternatively, is this a 32-bit or 64-bit build? If 32-bit, are you able to try 64-bit? 64-bit is more likely to default to sse math. If a debug build, if I read the OCaml source correctly, fp math is implemented in C code, so would it be possible to recompile your OCaml installation with sse enabled? I see mentions of mingw in the documentation; if so, the requisite command-line flags may be -msse2 -mfp-math=sse. Alternatively, a 64-bit may be more likely to default to sse math.

Possible fixes

It's also theoretically possible to write the spec interpreter to work around this problem. While there are techniques for achieving the desired rounding behavior in terms of x87 operations, I think someone at some point mentioned that there are software floating point implementations available for OCaml, and for the spec repo that might be best, keeping things simple. All floating point logic in the spec is factored out into spec/f32.ml, spec/f64.ml, and spec/*_convert.ml, so it should be fairly straightforward to port.

[kripken]

I see this issue on 32-bit Linux as well, but not on 64-bit. So it definitely looks like an issue with 32-bit ocaml.

Btw, I also saw the problem on 32-bit gcc as well, on the binaryen interpreter. @sunfishcode showed me that can be avoided by telling gcc to not use x87, with the flags -msse2 -mfpmath=sse. So this looks like a common issue on 32-bit compilers.

[ericprud]

Is this still an issue or can it be closed now?

[rossberg]

Still an issue for those who care about compiling on x86-32.