[compiler-rt] [builtins] Remove unused/misnamed x86 chkstk functions

[mstorsjo]

Summary

For both MSVC and MinGW targets, the compiler generates calls to
functions for probing the stack, in functions that allocate a larger
amount of stack space.

The exact behaviour of these functions differ per architecture (some
decrement the stack, some actually decrement the stack pointer,
some only probe the stack). In MSVC mode, the compiler always
generates calls to a symbol named "chkstk". In MinGW mode, the
symbol is named "alloca" on i386 and "___chkstk_ms" on x86_64,
but the functions behave exactly the same as their MSVC counterparts
despite the differing names.

(On i386, these names are the raw symbol names - if considering
a C level function name with the extra implicit leading underscore,
they would be called "_chkstk" and "_alloca".)

Remove the misleading duplicate and unused functions. These were
added in fbfed869106cc9c9cad7538db5e65bcd24f4d92e /
c27de5b2790b65394c50ba13fab319995dbf5956 (adding "___chkstk_ms"
for both architectures, even if that symbol name only was used
on x86_64) and 40eb83ba56ba9c1d2e6de44deacf889ac0143cf7
(adding "alloca" and "_chkstk", even if the former only was
used on i386, and the latter seeming like a misspelled form of
the MSVC function, with three underscores instead of two).

The x86_64 "___chkstk" was doubly surprising as that function had
the same behaviour as the function used on i386, while the
"chkstk" that MSVC emitted calls to should behave exactly like
the preexisting "_chkstk_ms".

Remove the unused functions, and rename the misspelled MSVC-like
symbols to the correct name that MSVC mode actually uses.

Note that these files aren't assembled at all when building
compiler-rt builtins in MSVC mode, as they are expected to be
provided by MSVC libraries when building code in MSVC mode.

The i386 chkstk2.S could be renamed to plain chkstk.S in a separate
commit (not including the change here, for clarity).

[rnk]

lgtm

At various points I have tried to untangle the meaning, purpose, and function of these various stack adjustment routines, and I never felt like I had a satisfactory understanding. I trust that you got to the bottom of this.

[mstorsjo]

In D159139#4629039, @rnk wrote:

At various points I have tried to untangle the meaning, purpose, and function of these various stack adjustment routines, and I never felt like I had a satisfactory understanding. I trust that you got to the bottom of this.

I thought I did at least; it looked to me like over-genericity from when these functions were added in the linked commits. However I just happened to look at libgcc sources, and they also have these duplicate functions (i386/x86_64 versions of both functions, complete with the unused ___chkstk function name). So I guess the duplication and extra code stems from how they've come into place there, historically, even if not all of them actually are used. Anyway, for our purposes, I'd prefer to get rid of the unused/misleading ones, and concentrate on providing the exact ones that mingw and MSVC mode stack probes use, and nothing else.

[rnk]

I think that's reasonable. libgcc probably retains them out of some desire for longer term backward compatibility, and I think we're a little less constrained there.

compiler-rt/lib/builtins/CMakeLists.txt

if (NOT MSVC)
 
   # Darwin x86_64 Haswell
   set(x86_64h_SOURCES ${x86_64_SOURCES})
 
   if (WIN32)
     set(x86_64_SOURCES
       ${x86_64_SOURCES}
       x86_64/chkstk.S
-      x86_64/chkstk2.S
     )
   endif()
 
   set(i386_SOURCES
     ${GENERIC_SOURCES}
     ${x86_ARCH_SOURCES}
     i386/ashldi3.S
     i386/ashrdi3.S
set(i386_SOURCES
       i386/floatdixf.S
       i386/floatundixf.S
     )
   endif()
 
   if (WIN32)
     set(i386_SOURCES
       ${i386_SOURCES}
-      i386/chkstk.S
       i386/chkstk2.S
     )
   endif()
 else () # MSVC
   # Use C versions of functions when building on MSVC
   # MSVC's assembler takes Intel syntax, not AT&T syntax.
   # Also use only MSVC compilable builtin implementations.
   set(x86_64_SOURCES

compiler-rt/lib/builtins/i386/chkstk.S

-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include "../assembly.h"
-
-// _chkstk routine
-// This routine is windows specific
-// http://msdn.microsoft.com/en-us/library/ms648426.aspx
-
-#ifdef __i386__
-
-.text
-.balign 4
-DEFINE_COMPILERRT_FUNCTION(__chkstk_ms)
-        push   %ecx
-        push   %eax
-        cmp    $0x1000,%eax
-        lea    12(%esp),%ecx
-        jb     1f
-2:
-        sub    $0x1000,%ecx
-        test   %ecx,(%ecx)
-        sub    $0x1000,%eax
-        cmp    $0x1000,%eax
-        ja     2b
-1:
-        sub    %eax,%ecx
-        test   %ecx,(%ecx)
-        pop    %eax
-        pop    %ecx
-        ret
-END_COMPILERRT_FUNCTION(__chkstk_ms)
-
-#endif // __i386__

compiler-rt/lib/builtins/i386/chkstk2.S

 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "../assembly.h"
 
 #ifdef __i386__
 
 // _chkstk (_alloca) routine - probe stack between %esp and (%esp-%eax) in 4k increments,
 // then decrement %esp by %eax.  Preserves all registers except %esp and flags.
 // This routine is windows specific
 // http://msdn.microsoft.com/en-us/library/ms648426.aspx
 
 .text
 .balign 4
 DEFINE_COMPILERRT_FUNCTION(_alloca) // _chkstk and _alloca are the same function
-DEFINE_COMPILERRT_FUNCTION(__chkstk)
+DEFINE_COMPILERRT_FUNCTION(_chkstk)
         push   %ecx
         cmp    $0x1000,%eax
         lea    8(%esp),%ecx     // esp before calling this routine -> ecx
         jb     1f
 2:
         sub    $0x1000,%ecx
         test   %ecx,(%ecx)
         sub    $0x1000,%eax
         cmp    $0x1000,%eax
         ja     2b
 1:
         sub    %eax,%ecx
         test   %ecx,(%ecx)
 
         lea    4(%esp),%eax     // load pointer to the return address into eax
         mov    %ecx,%esp        // install the new top of stack pointer into esp
         mov    -4(%eax),%ecx    // restore ecx
         push   (%eax)           // push return address onto the stack
         sub    %esp,%eax        // restore the original value in eax
         ret
-END_COMPILERRT_FUNCTION(__chkstk)
+END_COMPILERRT_FUNCTION(_chkstk)
 END_COMPILERRT_FUNCTION(_alloca)
 
 #endif // __i386__

compiler-rt/lib/builtins/x86_64/chkstk.S

 // themselves. It also does not clobber %rax so we can reuse it when
 // adjusting %rsp.
 
 #ifdef __x86_64__
 
 .text
 .balign 4
 DEFINE_COMPILERRT_FUNCTION(___chkstk_ms)
+DEFINE_COMPILERRT_FUNCTION(__chkstk)
         push   %rcx
         push   %rax
         cmp    $0x1000,%rax
         lea    24(%rsp),%rcx
         jb     1f
 2:
         sub    $0x1000,%rcx
         test   %rcx,(%rcx)
         sub    $0x1000,%rax
         cmp    $0x1000,%rax
         ja     2b
 1:
         sub    %rax,%rcx
         test   %rcx,(%rcx)
         pop    %rax
         pop    %rcx
         ret
+END_COMPILERRT_FUNCTION(__chkstk)
 END_COMPILERRT_FUNCTION(___chkstk_ms)
 
 #endif // __x86_64__

compiler-rt/lib/builtins/x86_64/chkstk2.S

-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include "../assembly.h"
-
-#ifdef __x86_64__
-
-// _chkstk (_alloca) routine - probe stack between %rsp and (%rsp-%rax) in 4k increments,
-// then decrement %rsp by %rax.  Preserves all registers except %rsp and flags.
-// This routine is windows specific
-// http://msdn.microsoft.com/en-us/library/ms648426.aspx
-
-.text
-.balign 4
-DEFINE_COMPILERRT_FUNCTION(__alloca)
-        mov    %rcx,%rax        // x64 _alloca is a normal function with parameter in rcx
-        // fallthrough
-DEFINE_COMPILERRT_FUNCTION(___chkstk)
-        push   %rcx
-        cmp    $0x1000,%rax
-        lea    16(%rsp),%rcx     // rsp before calling this routine -> rcx
-        jb     1f
-2:
-        sub    $0x1000,%rcx
-        test   %rcx,(%rcx)
-        sub    $0x1000,%rax
-        cmp    $0x1000,%rax
-        ja     2b
-1:
-        sub    %rax,%rcx
-        test   %rcx,(%rcx)
-
-        lea    8(%rsp),%rax     // load pointer to the return address into rax
-        mov    %rcx,%rsp        // install the new top of stack pointer into rsp
-        mov    -8(%rax),%rcx    // restore rcx
-        push   (%rax)           // push return address onto the stack
-        sub    %rsp,%rax        // restore the original value in rax
-        ret
-END_COMPILERRT_FUNCTION(___chkstk)
-END_COMPILERRT_FUNCTION(__alloca)
-
-#endif // __x86_64__