[compiler-rt] builtins: Allow building windows arm functions for mingw

[mstorsjo]

Summary

When building with clang/LLVM in MSVC mode, the msvcrt libraries contain these functions.

When building in a mingw environment, we need to provide them somehow, e.g. via compiler-rt.

The aeabi divmod functions work in the same way as the corresponding __rt_*div* functions for windows, but their parameters are swapped. The functions for converting float to integer and vice versa are the same as their aeabi equivalents, only with different function names.

[compnerd]

I think its nicer to split out the conversion functions for windows into a separate file that can be conditionally built.

lib/builtins/arm/aeabi_idivmod.S

20 ↗

(On Diff #76543)

Id rather sink this around the DEFINE_COMPILERRT_FUNCTION. There is a single use, and that makes it more apparent that we are trying to rename the function.

lib/builtins/arm/aeabi_ldivmod.S

21 ↗

(On Diff #76543)

Similar.

[mstorsjo]

In D26183#596097, @compnerd wrote:

I think its nicer to split out the conversion functions for windows into a separate file that can be conditionally built.

Sure, will do.

lib/builtins/arm/aeabi_idivmod.S

20 ↗

(On Diff #76543)

Well, the same name is used at the end in END_COMPILERRT_FUNCTION as well, although that's a no-op on non-elf platforms. Do you still want the ifdef moved around DEFINE_COMPILERRT_FUNCTION, even though it no longer properly matches the corresponding no-op END_COMPILERRT_FUNCTION in that case?

[mstorsjo]

Moved the int/float conversion wrappers to a separate file. Didn't change the ifdefs for renaming aeabi div functions yet, while awaiting feedback on whether that's really desired.

[compnerd]

lib/builtins/arm/aeabi_idivmod.S

18 ↗

(On Diff #78257)

Can you please use the

#if defined(__MINGW32__)

form? It makes modifying it easier in the future. (Throughout)

20 ↗

(On Diff #76543)

Thats a good point. Lets avoid that then.

lib/builtins/mingw_fixfloat.c

68 ↗

(On Diff #78257)

Please clang-format this file.

[mstorsjo]

Changed to use "#if defined(MINGW32)" instead of "#ifdef MINGW32", ran "clang-format -style=LLVM" on the new source file.

[compnerd]

lib/builtins/arm/aeabi_uldivmod.S

36 ↗

(On Diff #78573)

Prefer ip over r12. Its easier to remember that as a mnemonic (intra-procedural [scratch]).

[mstorsjo]

lib/builtins/arm/aeabi_uldivmod.S

36 ↗

(On Diff #78573)

Ok, I can change that, but do note that the existing code already uses r12 and not ip, right above this block. Do you still prefer ip while making it inconsistent with the rest?

compiler-rt/trunk/lib/builtins/CMakeLists.txt

 set(arm_Thumb1_icache_SOURCES
   arm/sync_synchronize.S)
 set(arm_Thumb1_SOURCES
   ${arm_Thumb1_JT_SOURCES}
   ${arm_Thumb1_SjLj_EH_SOURCES}
   ${arm_Thumb1_VFPv2_SOURCES}
   ${arm_Thumb1_icache_SOURCES})
 
-if(NOT WIN32)
+if(MINGW)
+  set(arm_SOURCES
+      arm/aeabi_idivmod.S
+      arm/aeabi_ldivmod.S
+      arm/aeabi_uidivmod.S
+      arm/aeabi_uldivmod.S
+      divmoddi4.c
+      divmodsi4.c
+      divdi3.c
+      divsi3.c
+      fixdfdi.c
+      fixsfdi.c
+      fixunsdfdi.c
+      fixunssfdi.c
+      floatdidf.c
+      floatdisf.c
+      floatundidf.c
+      floatundisf.c
+      mingw_fixfloat.c
+      moddi3.c
+      udivmoddi4.c
+      udivmodsi4.c
+      udivsi3.c
+      umoddi3.c)
+else(MINGW)
   # TODO the EABI sources should only be added to EABI targets
   set(arm_SOURCES
     ${arm_SOURCES}
     ${arm_EABI_SOURCES}
     ${arm_Thumb1_SOURCES})
 endif()
 
 set(aarch64_SOURCES

compiler-rt/trunk/lib/builtins/arm/aeabi_idivmod.S

 #include "../assembly.h"
 
 // struct { int quot, int rem} __aeabi_idivmod(int numerator, int denominator) {
 //   int rem, quot;
 //   quot = __divmodsi4(numerator, denominator, &rem);
 //   return {quot, rem};
 // }
 
+#if defined(__MINGW32__)
+#define __aeabi_idivmod __rt_sdiv
+#endif
+
         .syntax unified
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_idivmod)
         push    { lr }
         sub     sp, sp, #4
         mov     r2, sp
+#if defined(__MINGW32__)
+        mov     r3, r0
+        mov     r0, r1
+        mov     r1, r3
+#endif
         bl      SYMBOL_NAME(__divmodsi4)
         ldr     r1, [sp]
         add     sp, sp, #4
         pop     { pc }
 END_COMPILERRT_FUNCTION(__aeabi_idivmod)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/arm/aeabi_ldivmod.S

 
 // struct { int64_t quot, int64_t rem}
 //        __aeabi_ldivmod(int64_t numerator, int64_t denominator) {
 //   int64_t rem, quot;
 //   quot = __divmoddi4(numerator, denominator, &rem);
 //   return {quot, rem};
 // }
 
+#if defined(__MINGW32__)
+#define __aeabi_ldivmod __rt_sdiv64
+#endif
+
         .syntax unified
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_ldivmod)
         push    {r11, lr}
         sub     sp, sp, #16
         add     r12, sp, #8
         str     r12, [sp]
+#if defined(__MINGW32__)
+        mov     r12, r0
+        mov     r0, r2
+        mov     r2, r12
+        mov     r12, r1
+        mov     r1, r3
+        mov     r3, r12
+#endif
         bl      SYMBOL_NAME(__divmoddi4)
         ldr     r2, [sp, #8]
         ldr     r3, [sp, #12]
         add     sp, sp, #16
         pop     {r11, pc}
 END_COMPILERRT_FUNCTION(__aeabi_ldivmod)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/arm/aeabi_uidivmod.S

 
 // struct { unsigned quot, unsigned rem}
 //        __aeabi_uidivmod(unsigned numerator, unsigned denominator) {
 //   unsigned rem, quot;
 //   quot = __udivmodsi4(numerator, denominator, &rem);
 //   return {quot, rem};
 // }
 
+#if defined(__MINGW32__)
+#define __aeabi_uidivmod __rt_udiv
+#endif
+
         .syntax unified
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_uidivmod)
         push    { lr }
         sub     sp, sp, #4
         mov     r2, sp
+#if defined(__MINGW32__)
+        mov     r3, r0
+        mov     r0, r1
+        mov     r1, r3
+#endif
         bl      SYMBOL_NAME(__udivmodsi4)
         ldr     r1, [sp]
         add     sp, sp, #4
         pop     { pc }
 END_COMPILERRT_FUNCTION(__aeabi_uidivmod)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/arm/aeabi_uldivmod.S

 
 // struct { uint64_t quot, uint64_t rem}
 //        __aeabi_uldivmod(uint64_t numerator, uint64_t denominator) {
 //   uint64_t rem, quot;
 //   quot = __udivmoddi4(numerator, denominator, &rem);
 //   return {quot, rem};
 // }
 
+#if defined(__MINGW32__)
+#define __aeabi_uldivmod __rt_udiv64
+#endif
+
         .syntax unified
         .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__aeabi_uldivmod)
         push  {r11, lr}
         sub sp, sp, #16
         add r12, sp, #8
         str r12, [sp]
+#if defined(__MINGW32__)
+        mov     r12, r0
+        mov     r0, r2
+        mov     r2, r12
+        mov     r12, r1
+        mov     r1, r3
+        mov     r3, r12
+#endif
         bl  SYMBOL_NAME(__udivmoddi4)
         ldr r2, [sp, #8]
         ldr r3, [sp, #12]
         add sp, sp, #16
         pop {r11, pc}
 END_COMPILERRT_FUNCTION(__aeabi_uldivmod)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/trunk/lib/builtins/mingw_fixfloat.c

+/* ===-- mingw_fixfloat.c - Wrap int/float conversions for arm/windows -----===
+ *
+ *                     The LLVM Compiler Infrastructure
+ *
+ * This file is dual licensed under the MIT and the University of Illinois Open
+ * Source Licenses. See LICENSE.TXT for details.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#include "int_lib.h"
+
+COMPILER_RT_ABI di_int __fixdfdi(double a);
+COMPILER_RT_ABI di_int __fixsfdi(float a);
+COMPILER_RT_ABI du_int __fixunsdfdi(double a);
+COMPILER_RT_ABI du_int __fixunssfdi(float a);
+COMPILER_RT_ABI double __floatdidf(di_int a);
+COMPILER_RT_ABI float __floatdisf(di_int a);
+COMPILER_RT_ABI double __floatundidf(du_int a);
+COMPILER_RT_ABI float __floatundisf(du_int a);
+
+COMPILER_RT_ABI di_int __dtoi64(double a) { return __fixdfdi(a); }
+
+COMPILER_RT_ABI di_int __stoi64(float a) { return __fixsfdi(a); }
+
+COMPILER_RT_ABI du_int __dtou64(double a) { return __fixunsdfdi(a); }
+
+COMPILER_RT_ABI du_int __stou64(float a) { return __fixunssfdi(a); }
+
+COMPILER_RT_ABI double __i64tod(di_int a) { return __floatdidf(a); }
+
+COMPILER_RT_ABI float __i64tos(di_int a) { return __floatdisf(a); }
+
+COMPILER_RT_ABI double __u64tod(du_int a) { return __floatundidf(a); }
+
+COMPILER_RT_ABI float __u64tos(du_int a) { return __floatundisf(a); }