User talk:Gelyon

Your edit to x86-64
What documentation have you found that states that Windows supports f.p. operations in long mode? Given the long history otherwise, this claim really should have a reference. Jeh 06:18, 25 September 2007 (UTC)

Visual C++ Legacy Floating-Point Support

x87/MMX code on x64 applications in Windows

[http://www.agner.org/optimize/calling_conventions.pdf Agner Fog Research - Software optimization resources - Optimization manuals - 5. Calling conventions for different C++ compilers and operating systems]

6.1 Can floating point registers be used in 64-bit Windows? There has been widespread confusion about whether 64-bit Windows allows the use of the floating point registers ST(0)-ST(7) and the MM0 - MM7 registers that are aliased upon these. One early technical document found at Microsoft's website says "x87/MMX registers are unavailable to Native Windows64 applications" (Rich Brunner: Technical Details Of Microsoft® Windows® For The AMD64 Platform, Dec. 2003). An AMD document says: "64- bit Microsoft Windows does not strongly support MMX and 3Dnow! instruction sets in the 64-bit native mode" (Porting and Optimizing Multimedia Codecs for AMD64 architecture on Microsoft® Windows®, July 21, 2004). A document in Microsoft's MSDN says: "A caller must also handle the following issues when calling a callee: [...] Legacy Floating-Point Support: The MMX and floating-point stack registers (MM0-MM7/ST0-ST7) are volatile. That is, these legacy floating-point stack registers do not have their state preserved across context switches" (MSDN: Kernel-Mode Driver Architecture: Windows DDK: Other Calling Convention Process Issues. Preliminary, June 14, 2004; February 18, 2005). This description is nonsense because it confuses saving registers across function calls and saving registers across context switches. Some versions of the Microsoft assembler ml64 (e.g. v. 8.00.40310) gives the following message when attempts are made to use floating point registers in 64 bit mode: "error A2222: x87 and MMX instructions disallowed; legacy FP state not saved in Win64". However, a public discussion forum quotes the following answers from Microsoft engineers regarding this issue: "From: Program Manager in Visual C++ Group, Sent: Thursday, May 26, 2005 10:38 AM. It does preserve the state. It's the DDK page that has stale information, which I've requested it to be changed. Let them know that the OS does preserve state of x87 and MMX registers on context switches." and "From: Software Engineer in Windows Kernel Group, Sent: Thursday, May 26, 2005 11:06 AM. For user threads the state of legacy floating point is preserved at context switch. But it is not true for kernel threads. Kernel mode drivers can not use legacy floating point instructions." (www.planetamd64.com/index.php?showtopic=3458&st=100). The issue has finally been resolved with the long overdue publication of a more detailed ABI for x64 Windows in the form of a document entitled "x64 Software Conventions", well hidden in the bin directory (not the help directory) of some compiler packages. This document says: "The MMX and floating-point stack registers (MM0-MM7/ST0-ST7) are preserved across context switches. There is no explicit calling convention for these registers.  The use of these registers is strictly prohibited in kernel mode code." The same text has later appeared ). at the Microsoft website (msdn2.microsoft.com/en-us/library/a32tsf7t(VS.80).aspx My tests indicate that these registers are saved correctly during task switches and thread switches in 64-bit mode, even in an early beta version of x64 Windows. Furthermore, I see no reason to not save these registers. If the floating point registers were not saved during a task switch then they would have to be cleared for security reasons; and the time required for clearing these registers would be no less than the time required for saving these registers. The floating point registers must be supported when running legacy 32-bit programs as well. These considerations do not apply to kernel mode where information security is less of an issue. According to the above information, the operating system may not save the floating point registers across kernel mode context switches. The Microsoft C++ compiler version 14.0 never uses these registers in 64-bit mode, and doesn't support long double precision. The Intel C++ compiler for x64 Windows supports __m64 in version 9.0 and later, while earlier versions do not. long double precision and

The conclusion is that it is safe to use floating point registers and MMX registers in 64-bit Windows, except in kernel mode drivers. --gelyon 17:33, 25 September 2007 (UTC)


 * Thanks. We should really 'do this' on the x86-64 talk page, but... Looking at the text you changed, I remember contributing to it... but if I wrote it exactly as it was just before you fixed it, I must have been seriously deranged. Upon re-reading my query to you above, I see that my derangement must have either continued until just now, or else suffered a recent relapse... The issue was always whether fp would work in ring 0 (e.g. kernel mode drivers). Of course fp would work in ring 3! Who would have thought otherwise! But the previous text there says it wouldn't. Good job correcting it, but we still need a note about kernel mode drivers there. The references you have here would be good to include on the main page, too. Jeh 01:13, 29 September 2007 (UTC)


 * Go ahead and make the changes, I don't know much about editing this stuff but I really did want to make that correction. --gelyon 23:17, 30 September 2007 (UTC)