Suboptimal code generated for __buitlin_floor on AMD64 without SS4_4.1

Suboptimal code generated for __buitlin_floor on AMD64 without SS4_4.1

[Stefan Kanthak]

Hi,

targeting AMD64 alias x86_64 with -O3, GCC 10.2.0 generates the
following code (19 instructions using 86 bytes, plus 6 quadwords
using 48 bytes) for __builtin_floor() when -msse4.1 is NOT given:

                                .text
   0:   f2 0f 10 15 10 00 00 00 movsd   .LC1(%rip), %xmm2
                        4: R_X86_64_PC32        .rdata
   8:   f2 0f 10 25 00 00 00 00 movsd   .LC0(%rip), %xmm4
                        c: R_X86_64_PC32        .rdata
  10:   66 0f 28 d8             movapd %xmm0, %xmm3
  14:   66 0f 28 c8             movapd %xmm0, %xmm1
  18:   66 0f 54 da             andpd  %xmm2, %xmm3
  1c:   66 0f 2e e3             ucomisd %xmm3, %xmm4
  20:   76 33                   jbe    55 <_floor+0x55>
  22:   f2 48 0f 2c c0          cvttsd2si %xmm0, %rax
  27:   66 0f ef db             pxor   %xmm3, %xmm3
  2b:   66 0f 55 d1             andnpd %xmm1, %xmm2
  2f:   f2 48 0f 2a d8          cvtsi2sd %rax, %xmm3
  34:   66 0f 28 e3             movapd %xmm3, %xmm4
  38:   f2 0f c2 e0 06          cmpnlesd %xmm0, %xmm4
  3d:   f2 0f 10 05 20 00 00 00 movsd  .LC2(%rip), %xmm0
                        91: R_X86_64_PC32       .rdata
  45:   66 0f 54 e0             andpd  %xmm0, %xmm4
  49:   f2 0f 5c dc             subsd  %xmm4, %xmm3
  4d:   66 0f 28 c3             movapd %xmm3, %xmm0
  51:   66 0f 56 c2             orpd   %xmm2, %xmm0
  55:   c3                      retq

                                .rdata
                                .align 8
   0:   00 00 00 00     .LC0:   .quad  0x1.0p52
        00 00 30 43
        00 00 00 00
        00 00 00 00
                                .align 16
  10:   ff ff ff ff     .LC1:   .quad  ~(-0.0)
        ff ff ff 7f
  18:   00 00 00 00             .quad  0.0
        00 00 00 00
                                .align 8
  20:   00 00 00 00     .LC2:   .quad  0x1.0p0
        00 00 f0 3f
        00 00 00 00
        00 00 00 00
                                .end

JFTR: in the best case, the memory accesses cost several cycles,
      while in the worst case they yield a page fault!


Properly optimized, shorter and faster code, using only 15 instructions
in just 65 bytes, WITHOUT superfluous constants, thus avoiding costly
memory accesses and saving at least 16 + 48 bytes, follows:

                              .intel_syntax
                              .equ    BIAS, 1023
                              .text
   0:   f2 48 0f 2c c0        cvttsd2si rax, xmm0  # rax = trunc(argument)
   5:   48 f7 d8              neg     rax
                        #     jz      .L0          # argument zero?
   8:   70 36                 jo      .L0          # argument indefinite?
                                                   # argument overflows 64-bit integer?
   a:   48 f7 d8              neg     rax
   d:   f2 48 0f 2a c8        cvtsi2sd xmm1, rax   # xmm1 = trunc(argument)
  12:   48 a1 00 00 00        mov     rax, (1 << 63) | (BIAS << 52)
  19:   00 00 00 f0 bf
  1c:   66 48 0f 6e d0        movq    xmm2, rax    # xmm2 = -0x1.0p0
  21:   f2 0f 10 d8           movsd   xmm3, xmm0   # xmm3 = argument
  25:   f2 0f c2 d9 01        cmpltsd xmm3, xmm1   # xmm3 = (argument < trunc(argument)) ? ~0L : 0L
  2a:   66 0f 54 da           andpd   xmm3, xmm2   # xmm3 = (argument < trunc(argument)) ? -1.0 : 0.0
  2e:   f2 0f 58 d9           addsd   xmm3, xmm1   # xmm3 = (argument < trunc(argument)) ? -1.0 : 0.0
                                                   #      + trunc(argument)
                                                   #      = floor(argument)
  32:   66 0f 73 d0 3f        psrlq   xmm0, 63
  37:   66 0f 73 f0 3f        psllq   xmm0, 63     # xmm0 = (argument & -0.0) ? -0.0 : 0.0
  3c:   66 0f 56 c3           orpd    xmm0, xmm3   # xmm0 = floor(argument)
  40:   c3              .L0:  ret
                              .end

regards
Stefan