[builtins] Use aliases for function redirects

[phosek]

Summary

Symbol aliases are supported by all platforms that compiler-rt builtins
target, and we can use these instead of function redirects to avoid the
extra indirection.

This is part of the cleanup proposed in "[RFC] compiler-rt builtins
cleanup and refactoring".

[phosek]

@mstorsjo the alias implementation is the same as the one used in D59921 (except we're not using weak aliases in this case), can you check that this looks okay to you?

[mstorsjo]

Works fine for mingw setups.

However, the alias mechanism used for MSVC, alternatename directives, doesn't quite work the right way for compiler-rt. If the object file containing the alternatename directive hasn't been brought in by some other symbol, the linker won't find the alias symbol at all.

Normally, I would presume that compiler-rt builtins aren't used in MSVC style builds though, but I'm not sure if we want to exclude them outright either. Reid, do you have opinions or creative ideas? (Afaik, the gnu alias attribute will work with clang-cl, but not with MSVC proper.)

[rnk]

In D60931#1473456, @mstorsjo wrote:

However, the alias mechanism used for MSVC, alternatename directives, doesn't quite work the right way for compiler-rt. If the object file containing the alternatename directive hasn't been brought in by some other symbol, the linker won't find the alias symbol at all.

Normally, I would presume that compiler-rt builtins aren't used in MSVC style builds though, but I'm not sure if we want to exclude them outright either. Reid, do you have opinions or creative ideas? (Afaik, the gnu alias attribute will work with clang-cl, but not with MSVC proper.)

The best alternative to /alternatename: that I could find is /export:fn1=fn2, but it suffers from the same problem: fn1 isn't in the symbol table, so it won't be found if the object is in an archive. I'm surprised MSVC doesn't have a way to do this, since it's quite representable in COFF.

I think you're right, none of these aliases are needed on Windows. They are all for aebi compat or libgcc compat. Maybe the best thing to do would be to define the macro to nothing in the defined(_WIN32) case.

[phosek]

In D60931#1476367, @rnk wrote:

In D60931#1473456, @mstorsjo wrote:

However, the alias mechanism used for MSVC, alternatename directives, doesn't quite work the right way for compiler-rt. If the object file containing the alternatename directive hasn't been brought in by some other symbol, the linker won't find the alias symbol at all.

Normally, I would presume that compiler-rt builtins aren't used in MSVC style builds though, but I'm not sure if we want to exclude them outright either. Reid, do you have opinions or creative ideas? (Afaik, the gnu alias attribute will work with clang-cl, but not with MSVC proper.)

The best alternative to /alternatename: that I could find is /export:fn1=fn2, but it suffers from the same problem: fn1 isn't in the symbol table, so it won't be found if the object is in an archive. I'm surprised MSVC doesn't have a way to do this, since it's quite representable in COFF.

I think you're right, none of these aliases are needed on Windows. They are all for aebi compat or libgcc compat. Maybe the best thing to do would be to define the macro to nothing in the defined(_WIN32) case.

Done

[mstorsjo]

Looks good from my perspective at least

lib/builtins/adddf3.c

 #include "fp_add_impl.inc"
 
 COMPILER_RT_ABI double __adddf3(double a, double b) { return __addXf3__(a, b); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI double __aeabi_dadd(double a, double b) { return __adddf3(a, b); }
 #else
-AEABI_RTABI double __aeabi_dadd(double a, double b) COMPILER_RT_ALIAS(__adddf3);
+COMPILER_RT_ALIAS(__adddf3, __aeabi_dadd)
 #endif
 #endif

lib/builtins/addsf3.c

 #include "fp_add_impl.inc"
 
 COMPILER_RT_ABI float __addsf3(float a, float b) { return __addXf3__(a, b); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI float __aeabi_fadd(float a, float b) { return __addsf3(a, b); }
 #else
-AEABI_RTABI float __aeabi_fadd(float a, float b) COMPILER_RT_ALIAS(__addsf3);
+COMPILER_RT_ALIAS(__addsf3, __aeabi_fadd)
 #endif
 #endif

lib/builtins/ashldi3.c

if (b == 0)
       return a;
     result.s.low = input.s.low << b;
     result.s.high = (input.s.high << b) | (input.s.low >> (bits_in_word - b));
   }
   return result.all;
 }
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI di_int __aeabi_llsl(di_int a, si_int b)
-    COMPILER_RT_ALIAS(__ashldi3);
+COMPILER_RT_ALIAS(__ashldi3, __aeabi_llsl)
 #endif

lib/builtins/ashrdi3.c

if (b == 0)
       return a;
     result.s.high = input.s.high >> b;
     result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b);
   }
   return result.all;
 }
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI di_int __aeabi_lasr(di_int a, si_int b)
-    COMPILER_RT_ALIAS(__ashrdi3);
+COMPILER_RT_ALIAS(__ashrdi3, __aeabi_lasr)
 #endif

lib/builtins/comparedf2.c

else if (aInt == bInt)
       return LE_EQUAL;
     else
       return LE_GREATER;
   }
 }
 
 #if defined(__ELF__)
 // Alias for libgcc compatibility
-FNALIAS(__cmpdf2, __ledf2);
+COMPILER_RT_ALIAS(__ledf2, __cmpdf2)
 #endif
+COMPILER_RT_ALIAS(__ledf2, __eqdf2)
+COMPILER_RT_ALIAS(__ledf2, __ltdf2)
+COMPILER_RT_ALIAS(__ledf2, __nedf2)
 
 enum GE_RESULT {
   GE_LESS = -1,
   GE_EQUAL = 0,
   GE_GREATER = 1,
   GE_UNORDERED = -1 // Note: different from LE_UNORDERED
 };
 
if (aInt > bInt)
       return GE_LESS;
     else if (aInt == bInt)
       return GE_EQUAL;
     else
       return GE_GREATER;
   }
 }
 
-COMPILER_RT_ABI int __unorddf2(fp_t a, fp_t b) {
+COMPILER_RT_ALIAS(__gedf2, __gtdf2)
+
+COMPILER_RT_ABI int
+__unorddf2(fp_t a, fp_t b) {
     const rep_t aAbs = toRep(a) & absMask;
     const rep_t bAbs = toRep(b) & absMask;
     return aAbs > infRep || bAbs > infRep;
 }
 
-// The following are alternative names for the preceding routines.
-
-COMPILER_RT_ABI enum LE_RESULT __eqdf2(fp_t a, fp_t b) { return __ledf2(a, b); }
-
-COMPILER_RT_ABI enum LE_RESULT __ltdf2(fp_t a, fp_t b) { return __ledf2(a, b); }
-
-COMPILER_RT_ABI enum LE_RESULT __nedf2(fp_t a, fp_t b) { return __ledf2(a, b); }
-
-COMPILER_RT_ABI enum GE_RESULT __gtdf2(fp_t a, fp_t b) { return __gedf2(a, b); }
-
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) { return __unorddf2(a, b); }
 #else
-AEABI_RTABI int __aeabi_dcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unorddf2);
+COMPILER_RT_ALIAS(__unorddf2, __aeabi_dcmpun)
 #endif
 #endif

lib/builtins/comparesf2.c

else if (aInt == bInt)
       return LE_EQUAL;
     else
       return LE_GREATER;
   }
 }
 
 #if defined(__ELF__)
 // Alias for libgcc compatibility
-FNALIAS(__cmpsf2, __lesf2);
+COMPILER_RT_ALIAS(__lesf2, __cmpsf2)
 #endif
+COMPILER_RT_ALIAS(__lesf2, __eqsf2)
+COMPILER_RT_ALIAS(__lesf2, __ltsf2)
+COMPILER_RT_ALIAS(__lesf2, __nesf2)
 
 enum GE_RESULT {
   GE_LESS = -1,
   GE_EQUAL = 0,
   GE_GREATER = 1,
   GE_UNORDERED = -1 // Note: different from LE_UNORDERED
 };
 
if (aInt > bInt)
       return GE_LESS;
     else if (aInt == bInt)
       return GE_EQUAL;
     else
       return GE_GREATER;
   }
 }
 
-COMPILER_RT_ABI int __unordsf2(fp_t a, fp_t b) {
+COMPILER_RT_ALIAS(__gesf2, __gtsf2)
+
+COMPILER_RT_ABI int
+__unordsf2(fp_t a, fp_t b) {
     const rep_t aAbs = toRep(a) & absMask;
     const rep_t bAbs = toRep(b) & absMask;
     return aAbs > infRep || bAbs > infRep;
 }
 
-// The following are alternative names for the preceding routines.
-
-COMPILER_RT_ABI enum LE_RESULT __eqsf2(fp_t a, fp_t b) { return __lesf2(a, b); }
-
-COMPILER_RT_ABI enum LE_RESULT __ltsf2(fp_t a, fp_t b) { return __lesf2(a, b); }
-
-COMPILER_RT_ABI enum LE_RESULT __nesf2(fp_t a, fp_t b) { return __lesf2(a, b); }
-
-COMPILER_RT_ABI enum GE_RESULT __gtsf2(fp_t a, fp_t b) { return __gesf2(a, b); }
-
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) { return __unordsf2(a, b); }
 #else
-AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unordsf2);
+COMPILER_RT_ALIAS(__unordsf2, __aeabi_fcmpun)
 #endif
 #endif

lib/builtins/comparetf2.c

else if (aInt == bInt)
       return LE_EQUAL;
     else
       return LE_GREATER;
   }
 }
 
 #if defined(__ELF__)
 // Alias for libgcc compatibility
-FNALIAS(__cmptf2, __letf2);
+COMPILER_RT_ALIAS(__letf2, __cmptf2)
 #endif
+COMPILER_RT_ALIAS(__letf2, __eqtf2)
+COMPILER_RT_ALIAS(__letf2, __lttf2)
+COMPILER_RT_ALIAS(__letf2, __netf2)
 
 enum GE_RESULT {
   GE_LESS = -1,
   GE_EQUAL = 0,
   GE_GREATER = 1,
   GE_UNORDERED = -1 // Note: different from LE_UNORDERED
 };
 
if (aInt > bInt)
       return GE_LESS;
     else if (aInt == bInt)
       return GE_EQUAL;
     else
       return GE_GREATER;
   }
 }
 
+COMPILER_RT_ALIAS(__getf2, __gttf2)
+
 COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) {
   const rep_t aAbs = toRep(a) & absMask;
   const rep_t bAbs = toRep(b) & absMask;
   return aAbs > infRep || bAbs > infRep;
 }
 
-// The following are alternative names for the preceding routines.
-
-COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) { return __letf2(a, b); }
-
-COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) { return __letf2(a, b); }
-
-COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) { return __letf2(a, b); }
-
-COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) { return __getf2(a, b); }
-
 #endif

lib/builtins/divdf3.c

else {
     return result;
   }
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) { return __divdf3(a, b); }
 #else
-AEABI_RTABI fp_t __aeabi_ddiv(fp_t a, fp_t b) COMPILER_RT_ALIAS(__divdf3);
+COMPILER_RT_ALIAS(__divdf3, __aeabi_ddiv)
 #endif
 #endif

lib/builtins/divsf3.c

else {
     return fromRep(absResult | quotientSign);
   }
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) { return __divsf3(a, b); }
 #else
-AEABI_RTABI fp_t __aeabi_fdiv(fp_t a, fp_t b) COMPILER_RT_ALIAS(__divsf3);
+COMPILER_RT_ALIAS(__divsf3, __aeabi_fdiv)
 #endif
 #endif

lib/builtins/divsi3.c

COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b) {
   //  this calls __udivsi3 (notice the cast to su_int).
   // On CPUs with unsigned hardware division support,
   //  this uses the unsigned division instruction.
   //
   return ((su_int)a / (su_int)b ^ s_a) - s_a; // negate if s_a == -1
 }
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI si_int __aeabi_idiv(si_int a, si_int b) COMPILER_RT_ALIAS(__divsi3);
+COMPILER_RT_ALIAS(__divsi3, __aeabi_idiv)
 #endif

lib/builtins/extendhfsf2.c

 }
 
 COMPILER_RT_ABI float __gnu_h2f_ieee(uint16_t a) { return __extendhfsf2(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI float __aeabi_h2f(uint16_t a) { return __extendhfsf2(a); }
 #else
-AEABI_RTABI float __aeabi_h2f(uint16_t a) COMPILER_RT_ALIAS(__extendhfsf2);
+COMPILER_RT_ALIAS(__extendhfsf2, __aeabi_h2f)
 #endif
 #endif

lib/builtins/extendsfdf2.c

 #include "fp_extend_impl.inc"
 
 COMPILER_RT_ABI double __extendsfdf2(float a) { return __extendXfYf2__(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI double __aeabi_f2d(float a) { return __extendsfdf2(a); }
 #else
-AEABI_RTABI double __aeabi_f2d(float a) COMPILER_RT_ALIAS(__extendsfdf2);
+COMPILER_RT_ALIAS(__extendsfdf2, __aeabi_f2d)
 #endif
 #endif

lib/builtins/fixdfdi.c

 COMPILER_RT_ABI di_int __fixdfdi(fp_t a) { return __fixint(a); }
 
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI di_int __aeabi_d2lz(fp_t a) { return __fixdfdi(a); }
 #else
-AEABI_RTABI di_int __aeabi_d2lz(fp_t a) COMPILER_RT_ALIAS(__fixdfdi);
+COMPILER_RT_ALIAS(__fixdfdi, __aeabi_d2lz)
 #endif
 #endif

lib/builtins/fixdfsi.c

 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI si_int __fixdfsi(fp_t a) { return __fixint(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI si_int __aeabi_d2iz(fp_t a) { return __fixdfsi(a); }
 #else
-AEABI_RTABI si_int __aeabi_d2iz(fp_t a) COMPILER_RT_ALIAS(__fixdfsi);
+COMPILER_RT_ALIAS(__fixdfsi, __aeabi_d2iz)
 #endif
 #endif

lib/builtins/fixsfdi.c

 COMPILER_RT_ABI di_int __fixsfdi(fp_t a) { return __fixint(a); }
 
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI di_int __aeabi_f2lz(fp_t a) { return __fixsfdi(a); }
 #else
-AEABI_RTABI di_int __aeabi_f2lz(fp_t a) COMPILER_RT_ALIAS(__fixsfdi);
+COMPILER_RT_ALIAS(__fixsfdi, __aeabi_f2lz)
 #endif
 #endif

lib/builtins/fixsfsi.c

 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI si_int __fixsfsi(fp_t a) { return __fixint(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI si_int __aeabi_f2iz(fp_t a) { return __fixsfsi(a); }
 #else
-AEABI_RTABI si_int __aeabi_f2iz(fp_t a) COMPILER_RT_ALIAS(__fixsfsi);
+COMPILER_RT_ALIAS(__fixsfsi, __aeabi_f2iz)
 #endif
 #endif

lib/builtins/fixunsdfdi.c

 COMPILER_RT_ABI du_int __fixunsdfdi(fp_t a) { return __fixuint(a); }
 
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) { return __fixunsdfdi(a); }
 #else
-AEABI_RTABI du_int __aeabi_d2ulz(fp_t a) COMPILER_RT_ALIAS(__fixunsdfdi);
+COMPILER_RT_ALIAS(__fixunsdfdi, __aeabi_d2ulz)
 #endif
 #endif

lib/builtins/fixunsdfsi.c

 #include "fp_fixuint_impl.inc"
 
 COMPILER_RT_ABI su_int __fixunsdfsi(fp_t a) { return __fixuint(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) { return __fixunsdfsi(a); }
 #else
-AEABI_RTABI su_int __aeabi_d2uiz(fp_t a) COMPILER_RT_ALIAS(__fixunsdfsi);
+COMPILER_RT_ALIAS(__fixunsdfsi, __aeabi_d2uiz)
 #endif
 #endif

lib/builtins/fixunssfdi.c

 COMPILER_RT_ABI du_int __fixunssfdi(fp_t a) { return __fixuint(a); }
 
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) { return __fixunssfdi(a); }
 #else
-AEABI_RTABI du_int __aeabi_f2ulz(fp_t a) COMPILER_RT_ALIAS(__fixunssfdi);
+COMPILER_RT_ALIAS(__fixunssfdi, __aeabi_f2ulz)
 #endif
 #endif

lib/builtins/fixunssfsi.c

 #include "fp_fixuint_impl.inc"
 
 COMPILER_RT_ABI su_int __fixunssfsi(fp_t a) { return __fixuint(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) { return __fixunssfsi(a); }
 #else
-AEABI_RTABI su_int __aeabi_f2uiz(fp_t a) COMPILER_RT_ALIAS(__fixunssfsi);
+COMPILER_RT_ALIAS(__fixunssfsi, __aeabi_f2uiz)
 #endif
 #endif

lib/builtins/floatdidf.c

COMPILER_RT_ABI double __floatdidf(di_int a) {
   return fb.f;
 }
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI double __aeabi_l2d(di_int a) { return __floatdidf(a); }
 #else
-AEABI_RTABI double __aeabi_l2d(di_int a) COMPILER_RT_ALIAS(__floatdidf);
+COMPILER_RT_ALIAS(__floatdidf, __aeabi_l2d)
 #endif
 #endif

lib/builtins/floatdisf.c

fb.u = ((su_int)s & 0x80000000) | // sign
          ((su_int)a & 0x007FFFFF);  // mantissa
   return fb.f;
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI float __aeabi_l2f(di_int a) { return __floatdisf(a); }
 #else
-AEABI_RTABI float __aeabi_l2f(di_int a) COMPILER_RT_ALIAS(__floatdisf);
+COMPILER_RT_ALIAS(__floatdisf, __aeabi_l2f)
 #endif
 #endif

lib/builtins/floatsidf.c

COMPILER_RT_ABI fp_t __floatsidf(int a) {
   // Insert the sign bit and return
   return fromRep(result | sign);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_i2d(int a) { return __floatsidf(a); }
 #else
-AEABI_RTABI fp_t __aeabi_i2d(int a) COMPILER_RT_ALIAS(__floatsidf);
+COMPILER_RT_ALIAS(__floatsidf, __aeabi_i2d)
 #endif
 #endif

lib/builtins/floatsisf.c

COMPILER_RT_ABI fp_t __floatsisf(int a) {
   // Insert the sign bit and return
   return fromRep(result | sign);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_i2f(int a) { return __floatsisf(a); }
 #else
-AEABI_RTABI fp_t __aeabi_i2f(int a) COMPILER_RT_ALIAS(__floatsisf);
+COMPILER_RT_ALIAS(__floatsisf, __aeabi_i2f)
 #endif
 #endif

lib/builtins/floatundidf.c

COMPILER_RT_ABI double __floatundidf(du_int a) {
   return fb.f;
 }
 #endif
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI double __aeabi_ul2d(du_int a) { return __floatundidf(a); }
 #else
-AEABI_RTABI double __aeabi_ul2d(du_int a) COMPILER_RT_ALIAS(__floatundidf);
+COMPILER_RT_ALIAS(__floatundidf, __aeabi_ul2d)
 #endif
 #endif

lib/builtins/floatundisf.c

fb.u = ((e + 127) << 23) |       // exponent
          ((su_int)a & 0x007FFFFF); // mantissa
   return fb.f;
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI float __aeabi_ul2f(du_int a) { return __floatundisf(a); }
 #else
-AEABI_RTABI float __aeabi_ul2f(du_int a) COMPILER_RT_ALIAS(__floatundisf);
+COMPILER_RT_ALIAS(__floatundisf, __aeabi_ul2f)
 #endif
 #endif

lib/builtins/floatunsidf.c

COMPILER_RT_ABI fp_t __floatunsidf(unsigned int a) {
   result += (rep_t)(exponent + exponentBias) << significandBits;
   return fromRep(result);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) { return __floatunsidf(a); }
 #else
-AEABI_RTABI fp_t __aeabi_ui2d(unsigned int a) COMPILER_RT_ALIAS(__floatunsidf);
+COMPILER_RT_ALIAS(__floatunsidf, __aeabi_ui2d)
 #endif
 #endif

lib/builtins/floatunsisf.c

COMPILER_RT_ABI fp_t __floatunsisf(unsigned int a) {
   result += (rep_t)(exponent + exponentBias) << significandBits;
   return fromRep(result);
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) { return __floatunsisf(a); }
 #else
-AEABI_RTABI fp_t __aeabi_ui2f(unsigned int a) COMPILER_RT_ALIAS(__floatunsisf);
+COMPILER_RT_ALIAS(__floatunsisf, __aeabi_ui2f)
 #endif
 #endif

lib/builtins/int_lib.h

 
 #ifndef INT_LIB_H
 #define INT_LIB_H
 
 // Assumption: Signed integral is 2's complement.
 // Assumption: Right shift of signed negative is arithmetic shift.
 // Assumption: Endianness is little or big (not mixed).
 
-#if defined(__ELF__)
-#define FNALIAS(alias_name, original_name)                                     \
-  void alias_name() __attribute__((__alias__(#original_name)))
-#define COMPILER_RT_ALIAS(aliasee) __attribute__((__alias__(#aliasee)))
-#else
-#define FNALIAS(alias, name)                                                   \
-  _Pragma("GCC error(\"alias unsupported on this file format\")")
-#define COMPILER_RT_ALIAS(aliasee)                                             \
-  _Pragma("GCC error(\"alias unsupported on this file format\")")
-#endif
-
 // ABI macro definitions
 
 #if __ARM_EABI__
 #ifdef COMPILER_RT_ARMHF_TARGET
 #define COMPILER_RT_ABI
 #else
 #define COMPILER_RT_ABI __attribute__((__pcs__("aapcs")))
 #endif

 #define UNUSED
 #else
 #define ALWAYS_INLINE __attribute__((always_inline))
 #define NOINLINE __attribute__((noinline))
 #define NORETURN __attribute__((noreturn))
 #define UNUSED __attribute__((unused))
 #endif
 
+#define STR(a) #a
+#define XSTR(a) STR(a)
+#define SYMBOL_NAME(name) XSTR(__USER_LABEL_PREFIX__) #name
+
+#if defined(__ELF__) || defined(__MINGW32__) || defined(__wasm__)
+#define COMPILER_RT_ALIAS(name, aliasname) \
+  COMPILER_RT_ABI __typeof(name) aliasname __attribute__((__alias__(#name)));
+#elif defines(__MACH__)
+#define COMPILER_RT_ALIAS(name, aliasname) \
+  __asm__(".globl " SYMBOL_NAME(aliasname)); \
+  __asm__(SYMBOL_NAME(aliasname) " = " SYMBOL_NAME(name)) \
+  COMPILER_RT_ABI __typeof(name) aliasname;
+#elif defined(_WIN32)
+#define COMPILER_RT_ALIAS(name, aliasname)
+#else
+#error Unsupported target
+#endif
+
 #if defined(__NetBSD__) && (defined(_KERNEL) || defined(_STANDALONE))
 //
 // Kernel and boot environment can't use normal headers,
 // so use the equivalent system headers.
 //
 #include <machine/limits.h>
 #include <sys/stdint.h>
 #include <sys/types.h>

lib/builtins/lshrdi3.c

if (b == 0)
       return a;
     result.s.high = input.s.high >> b;
     result.s.low = (input.s.high << (bits_in_word - b)) | (input.s.low >> b);
   }
   return result.all;
 }
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI di_int __aeabi_llsr(di_int a, si_int b)
-    COMPILER_RT_ALIAS(__lshrdi3);
+COMPILER_RT_ALIAS(__lshrdi3, __aeabi_llsr)
 #endif

lib/builtins/muldf3.c

 #include "fp_mul_impl.inc"
 
 COMPILER_RT_ABI fp_t __muldf3(fp_t a, fp_t b) { return __mulXf3__(a, b); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) { return __muldf3(a, b); }
 #else
-AEABI_RTABI fp_t __aeabi_dmul(fp_t a, fp_t b) COMPILER_RT_ALIAS(__muldf3);
+COMPILER_RT_ALIAS(__muldf3, __aeabi_dmul)
 #endif
 #endif

lib/builtins/muldi3.c

COMPILER_RT_ABI di_int __muldi3(di_int a, di_int b) {
   y.all = b;
   dwords r;
   r.all = __muldsi3(x.s.low, y.s.low);
   r.s.high += x.s.high * y.s.low + x.s.low * y.s.high;
   return r.all;
 }
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI di_int __aeabi_lmul(di_int a, di_int b) COMPILER_RT_ALIAS(__muldi3);
+COMPILER_RT_ALIAS(__muldi3, __aeabi_lmul)
 #endif

lib/builtins/mulsf3.c

 #include "fp_mul_impl.inc"
 
 COMPILER_RT_ABI fp_t __mulsf3(fp_t a, fp_t b) { return __mulXf3__(a, b); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) { return __mulsf3(a, b); }
 #else
-AEABI_RTABI fp_t __aeabi_fmul(fp_t a, fp_t b) COMPILER_RT_ALIAS(__mulsf3);
+COMPILER_RT_ALIAS(__mulsf3, __aeabi_fmul)
 #endif
 #endif

lib/builtins/negdf2.c

 #include "fp_lib.h"
 
 COMPILER_RT_ABI fp_t __negdf2(fp_t a) { return fromRep(toRep(a) ^ signBit); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_dneg(fp_t a) { return __negdf2(a); }
 #else
-AEABI_RTABI fp_t __aeabi_dneg(fp_t a) COMPILER_RT_ALIAS(__negdf2);
+COMPILER_RT_ALIAS(__negdf2, __aeabi_dneg)
 #endif
 #endif

lib/builtins/negsf2.c

 #include "fp_lib.h"
 
 COMPILER_RT_ABI fp_t __negsf2(fp_t a) { return fromRep(toRep(a) ^ signBit); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_fneg(fp_t a) { return __negsf2(a); }
 #else
-AEABI_RTABI fp_t __aeabi_fneg(fp_t a) COMPILER_RT_ALIAS(__negsf2);
+COMPILER_RT_ALIAS(__negsf2, __aeabi_fneg)
 #endif
 #endif

lib/builtins/subdf3.c

 COMPILER_RT_ABI fp_t __subdf3(fp_t a, fp_t b) {
   return __adddf3(a, fromRep(toRep(b) ^ signBit));
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) { return __subdf3(a, b); }
 #else
-AEABI_RTABI fp_t __aeabi_dsub(fp_t a, fp_t b) COMPILER_RT_ALIAS(__subdf3);
+COMPILER_RT_ALIAS(__subdf3, __aeabi_dsub)
 #endif
 #endif

lib/builtins/subsf3.c

 COMPILER_RT_ABI fp_t __subsf3(fp_t a, fp_t b) {
   return __addsf3(a, fromRep(toRep(b) ^ signBit));
 }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) { return __subsf3(a, b); }
 #else
-AEABI_RTABI fp_t __aeabi_fsub(fp_t a, fp_t b) COMPILER_RT_ALIAS(__subsf3);
+COMPILER_RT_ALIAS(__subsf3, __aeabi_fsub)
 #endif
 #endif

lib/builtins/truncdfhf2.c

 #include "fp_trunc_impl.inc"
 
 COMPILER_RT_ABI uint16_t __truncdfhf2(double a) { return __truncXfYf2__(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI uint16_t __aeabi_d2h(double a) { return __truncdfhf2(a); }
 #else
-AEABI_RTABI uint16_t __aeabi_d2h(double a) COMPILER_RT_ALIAS(__truncdfhf2);
+COMPILER_RT_ALIAS(__truncdfhf2, __aeabi_d2h)
 #endif
 #endif

lib/builtins/truncdfsf2.c

 #include "fp_trunc_impl.inc"
 
 COMPILER_RT_ABI float __truncdfsf2(double a) { return __truncXfYf2__(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI float __aeabi_d2f(double a) { return __truncdfsf2(a); }
 #else
-AEABI_RTABI float __aeabi_d2f(double a) COMPILER_RT_ALIAS(__truncdfsf2);
+COMPILER_RT_ALIAS(__truncdfsf2, __aeabi_d2f)
 #endif
 #endif

lib/builtins/truncsfhf2.c

 }
 
 COMPILER_RT_ABI uint16_t __gnu_f2h_ieee(float a) { return __truncsfhf2(a); }
 
 #if defined(__ARM_EABI__)
 #if defined(COMPILER_RT_ARMHF_TARGET)
 AEABI_RTABI uint16_t __aeabi_f2h(float a) { return __truncsfhf2(a); }
 #else
-AEABI_RTABI uint16_t __aeabi_f2h(float a) COMPILER_RT_ALIAS(__truncsfhf2);
+COMPILER_RT_ALIAS(__truncsfhf2, __aeabi_f2h)
 #endif
 #endif

lib/builtins/udivsi3.c

for (; sr > 0; --sr) {
     carry = s & 1;
     r -= d & s;
   }
   q = (q << 1) | carry;
   return q;
 }
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI su_int __aeabi_uidiv(su_int n, su_int d)
-    COMPILER_RT_ALIAS(__udivsi3);
+COMPILER_RT_ALIAS(__udivsi3, __aeabi_uidiv)
 #endif