HiroIshida's questions

Este código c++ é

#include<cmath>
double f1(double a){
    return std::cos(a);
}

double f2(double a){
    return std::cos(a) + std::sin(a);
}

é compilado no seguinte assembly ( https://godbolt.org/z/Y578h1TKx )

f1(double):
        jmp     cos
f2(double):
        sub     rsp, 24
        lea     rdi, [rsp+8]
        mov     rsi, rsp
        call    sincos
        movsd   xmm0, QWORD PTR [rsp+8]
        addsd   xmm0, QWORD PTR [rsp]
        add     rsp, 24
        ret

Isso significa que o gcc conhece as funções padrão da glibc e tem técnicas de otimização para casos específicos que as utilizam?

Recentemente, tentei ler assemblies do binário do meu código e descobri que muitas operações de ponto flutuante são feitas usando registradores XMM e instruções SSE. Por exemplo, o código a seguir:

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

será compilado em

        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

e o resultado é semelhante para outros compiladores. https://godbolt.org/z/G988PGo6j

E com -O3bandeira

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

Isso significa que as operações que usam registradores e instruções SIMD são geralmente mais rápidas do que usar registradores normais e a FPU?

Também estou curioso sobre casos específicos em que a decisão do compilador de usar SSE pode falhar.