[compiler-rt] Add back ARM EABI aliases where legal.

[efriedma]

Summary

r303188 removed all the uses of aliases for EABI functions from compiler-rt, because some of them had mismatched calling conventions. Obviously, we can't use aliases for functions which don't have the same calling convention, but that's only an issue for floating-point functions with the hardfloat ABI. In other cases, the stubs increase size and reduce performance for no benefit.

This patch adds back the aliases, with appropriate checks to make sure they're only used in cases where the calling convention matches.

[compnerd]

These functions would only really compile down to an additional branch. I can understand the desire to micro-optimize away the additional branch. However, I think that I would rather that the following pattern is used:

#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) __attribute__((__alias__("__truncsfhf2")));
#endif
#endif

This way the signature information is fully preserved in what LLVM seems. Otherwise, it just so happens that the compiler backend doesn't change the parameter registers, but is free to do so. I would be happy with a COMPILER_RT_ALIAS macro as:

#define COMPILER_RT_ALIAS(aliasee) __attribute__((__alias__(#aliasee)))

to use in place of the alias attribute.

[efriedma]

These functions would only really compile down to an additional branch.

We don't support tail call optimization for Thumb1, so it's a little worse there. I measured a 20% performance reduction in compiler-rt's soft-float divide.

---

I'm not sure the function type thing has any practical impact (at least, LLVM doesn't make assumptions about a function's actual type or calling convention based on a declaration), but sure, I can change it.

[efriedma]

Updated to preserve function signatures for EABI functions.

[compnerd]

Thanks for finding and fixing the performance regression on the older targets!

lib/builtins/fixdfdi.c

49

Nice, thanks for the drive-by fix here.

lib/builtins/int_lib.h

26

Please use the reserved spelling __attribute__((__alias__(#aliasee)))

[efriedma]

r314851

lib/builtins/adddf3.c

 #define DOUBLE_PRECISION
 #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);
+#endif
 #endif
-

lib/builtins/addsf3.c

 #define SINGLE_PRECISION
 #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);
+#endif
 #endif
-

lib/builtins/ashldi3.c

else  /* 0 <= b < bits_in_word */
             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) {
-  return __ashldi3(a, b);
-}
+AEABI_RTABI di_int __aeabi_llsl(di_int a, si_int b) COMPILER_RT_ALIAS(__ashldi3);
 #endif
-

lib/builtins/ashrdi3.c

else  /* 0 <= b < bits_in_word */
             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) {
-  return __ashrdi3(a, b);
-}
+AEABI_RTABI di_int __aeabi_lasr(di_int a, si_int b) COMPILER_RT_ALIAS(__ashrdi3);
 #endif
-

lib/builtins/comparedf2.c

 }
 
 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);
+#endif
 #endif
-

lib/builtins/comparesf2.c

__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(__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);
+#endif
 #endif
-

lib/builtins/divdf3.c

else {
         absResult += round;
         // Insert the sign and return
         const double result = fromRep(absResult | quotientSign);
         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);
+#endif
 #endif
-

lib/builtins/divsf3.c

else {
         // Round
         absResult += round;
         // Insert the sign and return
         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);
+#endif
 #endif
-

lib/builtins/divsi3.c

__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) {
-  return __divsi3(a, b);
-}
+AEABI_RTABI si_int __aeabi_idiv(si_int a, si_int b) COMPILER_RT_ALIAS(__divsi3);
 #endif
-

lib/builtins/extendhfsf2.c

COMPILER_RT_ABI NOINLINE float __extendhfsf2(uint16_t a) {
     return __extendXfYf2__(a);
 }
 
 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);
+#endif
 #endif
-

lib/builtins/extendsfdf2.c

 #define DST_DOUBLE
 #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);
+#endif
 #endif
-

lib/builtins/fixdfdi.c

 COMPILER_RT_ABI di_int
 __fixdfdi(fp_t a) {
     return __fixint(a);
 }
 
 #endif
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI di_int
-#if defined(__SOFT_FP__)
-__aeabi_d2lz(fp_t a) {
-#else
-__aeabi_d2lz(double a) {
-#endif
+#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);
+#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);
+#endif
 #endif
-

lib/builtins/fixsfdi.c

 COMPILER_RT_ABI di_int
 __fixsfdi(fp_t a) {
     return __fixint(a);
 }
 
 #endif
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI di_int
-#if defined(__SOFT_FP__)
-__aeabi_f2lz(fp_t a) {
-#else
-__aeabi_f2lz(float a) {
-#endif
+#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);
+#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);
+#endif
 #endif
-

lib/builtins/fixunsdfdi.c

 COMPILER_RT_ABI du_int
 __fixunsdfdi(fp_t a) {
     return __fixuint(a);
 }
 
 #endif
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI du_int
-#if defined(__SOFT_FP__)
-__aeabi_d2ulz(fp_t a) {
-#else
-__aeabi_d2ulz(double a) {
-#endif
+#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);
+#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);
+#endif
 #endif
-

lib/builtins/fixunssfdi.c

 COMPILER_RT_ABI du_int
 __fixunssfdi(fp_t a) {
     return __fixuint(a);
 }
 
 #endif
 
 #if defined(__ARM_EABI__)
-AEABI_RTABI du_int
-#if defined(__SOFT_FP__)
-__aeabi_f2ulz(fp_t a) {
-#else
-__aeabi_f2ulz(float a) {
-#endif
+#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);
+#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);
+#endif
 #endif
-

lib/builtins/floatdidf.c

fb.u.s.high = ((su_int)s & 0x80000000) |        /* sign */
                   ((e + 1023) << 20)       |        /* exponent */
                   ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
     fb.u.s.low = (su_int)a;                         /* mantissa-low */
     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);
+#endif
 #endif
-

lib/builtins/floatdisf.c

__floatdisf(di_int a)
     float_bits fb;
     fb.u = ((su_int)s & 0x80000000) |  /* sign */
            ((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_l2f(di_int a) {
   return __floatdisf(a);
 }
+#else
+AEABI_RTABI float __aeabi_l2f(di_int a) COMPILER_RT_ALIAS(__floatdisf);
+#endif
 #endif
-

lib/builtins/floatsidf.c

__floatsidf(int a) {
     
     // Insert the exponent
     result += (rep_t)(exponent + exponentBias) << significandBits;
     // 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);
+#endif
 #endif
-

lib/builtins/floatsisf.c

__floatsisf(int a) {
     }
     
     // Insert the exponent
     result += (rep_t)(exponent + exponentBias) << significandBits;
     // Insert the sign bit and return
     return fromRep(result | sign);
 }
 
-#if defined(__ARM_EABI__)
+#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);
+#endif
 #endif
-

lib/builtins/floatundidf.c

__floatundidf(du_int a)
     fb.u.s.high = ((e + 1023) << 20)       |        /* exponent */
                   ((su_int)(a >> 32) & 0x000FFFFF); /* mantissa-high */
     fb.u.s.low = (su_int)a;                         /* mantissa-low  */
     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);
+#endif
 #endif
-

lib/builtins/floatundisf.c

__floatundisf(du_int a)
     }
     float_bits fb;
     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);
+#endif
 #endif
-

lib/builtins/floatunsidf.c

__floatunsidf(unsigned int a) {
     result = (rep_t)a << shift ^ implicitBit;
     
     // Insert the exponent
     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);
+#endif
 #endif
-

lib/builtins/floatunsisf.c

__floatunsisf(unsigned int a) {
     }
     
     // Insert the exponent
     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);
+#endif
 #endif
-

lib/builtins/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

lib/builtins/lshrdi3.c

else  /* 0 <= b < bits_in_word */
             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) {
-  return __lshrdi3(a, b);
-}
+AEABI_RTABI di_int __aeabi_llsr(di_int a, si_int b) COMPILER_RT_ALIAS(__lshrdi3);
 #endif
-

lib/builtins/muldf3.c

 #define DOUBLE_PRECISION
 #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);
+#endif
 #endif
-

lib/builtins/muldi3.c

__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) {
-  return __muldi3(a, b);
-}
+AEABI_RTABI di_int __aeabi_lmul(di_int a, di_int b) COMPILER_RT_ALIAS(__muldi3);
 #endif
-

lib/builtins/mulsf3.c

 #define SINGLE_PRECISION
 #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);
+#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);
+#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);
+#endif
 #endif
-

lib/builtins/subdf3.c

 
 // Subtraction; flip the sign bit of b and add.
 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);
+#endif
 #endif
-

lib/builtins/subsf3.c

 
 // Subtraction; flip the sign bit of b and add.
 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);
+#endif
 #endif
-

lib/builtins/truncdfhf2.c

 #define DST_HALF
 #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);
+#endif
 #endif
-

lib/builtins/truncdfsf2.c

 #define DST_SINGLE
 #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);
+#endif
 #endif
-

lib/builtins/truncsfhf2.c

COMPILER_RT_ABI NOINLINE uint16_t __truncsfhf2(float a) {
     return __truncXfYf2__(a);
 }
 
 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);
+#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) {
-  return __udivsi3(n, d);
-}
+AEABI_RTABI su_int __aeabi_uidiv(su_int n, su_int d) COMPILER_RT_ALIAS(__udivsi3);
 #endif
-