Let's break down what's happening here and why you're seeing that extra +1 when skipping finit, even though your GDB debug session shows identical FPU register states.

First, let's recap your code for clarity:

; Without finit, result is A + B + 1
fildq A
fildq B
faddp
fistpq C

When you prepend finit, the result is correct (A + B), but you're confused because GDB reports the same control register (0x27F), tag register (0xFFFF, empty stack), and zeroed status registers in both scenarios.

Possible Explanations for the Extra +1 #

1. Debugger Limitations: Hidden FPU State

GDB does a solid job showing the visible FPU registers (control, status, tag), but it doesn't expose every single hardware state bit of the x87 unit. There could be subtle, unreported state left over from process initialization—like residual values in stack registers that the tag register marks as "empty", or unprocessed exception flags that don't show up in the status register.

Even though the tag register says the stack is empty, the x87 stack registers themselves might hold garbage values from the previous process or OS initialization code. While fildq should overwrite the top-of-stack register (ST0) regardless of its prior value, there's a tiny chance of hardware edge cases where residual data interferes with the addition or conversion back to integer.

2. OS-Level FPU Initialization Gaps

Some operating systems don't fully reset the x87 FPU when launching a new process—they only set the visible control/status/tag registers to default values, but leave other hidden state (like internal pipeline flags or precision caching) untouched. The finit instruction does a full hardware reset of the entire FPU, clearing these hidden states that your debugger can't see.

For example, even if the control register shows the correct rounding mode (0x27F means round-to-nearest, which should preserve integer precision), the actual hardware rounding logic might be in a weird state from prior use until finit resets it.

3. Subtle Rounding Edge Cases (Unlikely, But Worth Checking)

You mentioned the result is always A+B+1, not sometimes. That rules out random garbage or rounding-to-even for midpoint values (since 64-bit integers fit perfectly in x87's 80-bit extended precision format, addition should be exact). But double-check your test values: are you using large positive integers that push the limits? No, even the maximum 64-bit integer (2^63-1) can be represented exactly in 80-bit floats.

How to Diagnose Further #

If you want to dig deeper without relying on finit, try these steps:

• Save the full FPU environment before your code runs using fnstenv:

  .section .bss
  env_buf: .space 14  ; x87 environment is 14 bytes
  .section .text
  fnstenv env_buf     ; Save initial FPU state
  ; Your original code here
  

  Compare the env_buf contents with and without finit—you might spot differences GDB doesn't show.
• Lightweight stack cleanup: Instead of finit, try clearing the x87 stack explicitly before your code:

  fldz                ; Load 0 into ST0
  fstp %st(0)         ; Pop it, ensuring stack is empty
  ; Your original code here
  

  This might fix the issue without a full reset, confirming the problem was related to stack state.

Is finit Really "Too生硬"? #

Honestly, finit is a standard, lightweight way to ensure the FPU is in a known state before using it. In most production code, it's perfectly acceptable to include it if you're using x87 instructions, especially since OS initialization can be inconsistent. If you really want to avoid it, the stack cleanup above might work, but finit is the most reliable approach.

内容的提问来源于stack exchange，提问作者user1636349