Why do modern compilers prefer SSE over FPU for single floating-point operations

I recently tried to read assemblies of the binary of my code and found that a lot of floating-point operations are done using XMM registers and SSE instructions. For example, the following code:

float square(float a) {
    float b = a + (a * a);
    return b;
}

will be compiled into

push    rbp
mov     rbp, rsp
movss   DWORD PTR [rbp-20], xmm0
movss   xmm0, DWORD PTR [rbp-20]
mulss   xmm0, xmm0
movss   xmm1, DWORD PTR [rbp-20]
addss   xmm0, xmm1
movss   DWORD PTR [rbp-4], xmm0
movss   xmm0, DWORD PTR [rbp-4]
pop     rbp
ret

and the result is similar for other compilers. https://godbolt.org/z/G988PGo6j

And with -O3 flag

movaps  xmm1, xmm0
mulss   xmm0, xmm0
addss   xmm0, xmm1
ret

Does this mean operations using SIMD registers and instructions are usually faster than using normal registers and the FPU?

Also, I'm curious about specific cases where the compiler's decision to use SSE might fail.

Solution

SSE was developed as a replacement for the x87 FPU as the x87 FPU's design is a bit idiosyncratic and hard to generate code for. The main issues are:

code generation for stack-based processors like the x87 FPU is not as well understood as for register-based processors, making the code generated by many compilers full of inefficient extra fxch, fld, and fst(p) instructions. This is much easier to get right with a register-based architecture like SSE.
SSE supports SIMD operation, greatly speeding up floating point operations on arrays if used. X87 supports no such thing
on the x87 FPU, the data type used is Intel's 80 bit floating point format. The precision of floating-point operations is configured using a control register and is expensive to change. Therefore, compilers generating code for the x87 unit would run all computations with full precision, even when only single precision is called for by the programmer. This both changes the result slightly and reduces performance as higher precision operations may take more time to complete. Additionally, each load and store from/to the x87 unit involves an implicit data type conversion. The SSE unit on the other hand encodes precision in the instruction used, allowing the compiler to use exactly the precision the programmer called for.
recently, CPU manufacturers have reduced investments into improving the x87 FPU (or even took back existing improvements, like fxch being a rename), leading to a widening gap in performance between x87 and SSE.

I recommend to only use the x87 FPU if code size is an issue or if you require the 80 bits floating point format. Otherwise stick with SSE or (on recent processors) AVX.