In this question, the asker wondered whether or not one could expect floating point operations to behave similarly between debug and release configurations.
The answers given there show that this is not the case, that the language specification allows floating point operations to take place at higher precision than that of the types that are used as inputs, and that in practice, the .NET Framework CLR tends to make use of the possible optimizations that are possible of a result, for instance by doing single and double precision math in the 80-bit registers of the x87 FPU. (I added an answer myself with a concrete example of what this looks like in practice.)
The question here is the same thing, but restricted to what's happening when we specify x64 as the build platform. Then, the .NET Framework runtime compiles floating point math to SSE instructions for which it becomes possible to specify the desired precision of each operation so that the compiler has much greater flexibility when it comes to what it wants to promise its user. Yet, the language specification seem unchanged and, as far as I can tell, we are still left with no guarantees about the precision of the floating point instructions.
So, the question becomes:
Is there a concrete example of floating point operations giving different results between debug and release configurations on an x64 build? If not, does the language itself guarantee that no such examples exist?
