cbe: improve support for non-native float types

 * Fix _start on aarch64.
 * Add fallbacks when a float type is unsupported.

Fixes #13357

3 files changed, 323 insertions, 137 deletions

diff --git a/lib/include/zig.h b/lib/include/zig.h
index ea2bbca132..32d0c8277e 100644
--- a/lib/include/zig.h
+++ b/lib/include/zig.h
@@ -20,7 +20,7 @@
 
 #if __STDC_VERSION__ >= 201112L
 #define zig_threadlocal thread_local
-#elif __GNUC__
+#elif defined(__GNUC__)
 #define zig_threadlocal __thread
 #elif _MSC_VER
 #define zig_threadlocal __declspec(thread)
@@ -28,7 +28,7 @@
 #define zig_threadlocal zig_threadlocal_unavailable
 #endif
 
-#if zig_has_attribute(naked)
+#if zig_has_attribute(naked) || defined(__GNUC__)
 #define zig_naked __attribute__((naked))
 #elif defined(_MSC_VER)
 #define zig_naked __declspec(naked)
@@ -128,7 +128,7 @@
 #define   zig_atomic_store(obj, arg, order) atomic_store_explicit     (obj, arg, order)
 #define    zig_atomic_load(obj,      order) atomic_load_explicit      (obj,      order)
 #define zig_fence(order) atomic_thread_fence(order)
-#elif __GNUC__
+#elif defined(__GNUC__)
 #define memory_order_relaxed __ATOMIC_RELAXED
 #define memory_order_consume __ATOMIC_CONSUME
 #define memory_order_acquire __ATOMIC_ACQUIRE
@@ -176,7 +176,7 @@
 
 #if __STDC_VERSION__ >= 201112L
 #define zig_noreturn _Noreturn void
-#elif zig_has_attribute(noreturn)
+#elif zig_has_attribute(noreturn) || defined(__GNUC__)
 #define zig_noreturn __attribute__((noreturn)) void
 #elif _MSC_VER
 #define zig_noreturn __declspec(noreturn) void
@@ -184,6 +184,9 @@
 #define zig_noreturn void
 #endif
 
+#define zig_concat(lhs, rhs) lhs##rhs
+#define zig_expand_concat(lhs, rhs) zig_concat(lhs, rhs)
+
 #define zig_bitSizeOf(T) (CHAR_BIT * sizeof(T))
 
 typedef void zig_void;
@@ -250,110 +253,17 @@ typedef  int64_t zig_i64;
 #define zig_minInt_i64  INT64_MIN
 #define zig_maxInt_i64  INT64_MAX
 
-#define zig_builtin_f16(name) __##name##h
-#define zig_builtin_constant_f16(name) zig_suffix_f16(__builtin_##name)
-#if FLT_MANT_DIG == 11
-typedef float zig_f16;
-#define zig_suffix_f16(x) x##f
-#elif DBL_MANT_DIG == 11
-typedef double zig_f16;
-#define zig_suffix_f16(x) x
-#elif LDBL_MANT_DIG == 11
-typedef long double zig_f16;
-#define zig_suffix_f16(x) x##l
-#elif FLT16_MANT_DIG == 11
-typedef _Float16 zig_f16;
-#define zig_suffix_f16(x) x##f16
-#elif defined(__SIZEOF_FP16__)
-typedef __fp16 zig_f16;
-#define zig_suffix_f16(x) x##f16
-#endif
-
-#define zig_builtin_f32(name) name##f
-#define zig_builtin_constant_f32(name) zig_suffix_f32(__builtin_##name)
-#if FLT_MANT_DIG == 24
-typedef float zig_f32;
-#define zig_suffix_f32(x) x##f
-#elif DBL_MANT_DIG == 24
-typedef double zig_f32;
-#define zig_suffix_f32(x) x
-#elif LDBL_MANT_DIG == 24
-typedef long double zig_f32;
-#define zig_suffix_f32(x) x##l
-#elif FLT32_MANT_DIG == 24
-typedef _Float32 zig_f32;
-#define zig_suffix_f32(x) x##f32
-#endif
-
-#define zig_builtin_f64(name) name
-#define zig_builtin_constant_f64(name) zig_suffix_f64(__builtin_##name)
-#if FLT_MANT_DIG == 53
-typedef float zig_f64;
-#define zig_suffix_f64(x) x##f
-#elif DBL_MANT_DIG == 53
-typedef double zig_f64;
-#define zig_suffix_f64(x) x
-#elif LDBL_MANT_DIG == 53
-typedef long double zig_f64;
-#define zig_suffix_f64(x) x##l
-#elif FLT64_MANT_DIG == 53
-typedef _Float64 zig_f64;
-#define zig_suffix_f64(x) x##f64
-#elif FLT32X_MANT_DIG == 53
-typedef _Float32x zig_f64;
-#define zig_suffix_f64(x) x##f32x
-#endif
-
-#define zig_builtin_f80(name) __##name##x
-#define zig_builtin_constant_f80(name) zig_suffix_f80(__builtin_##name)
-#if FLT_MANT_DIG == 64
-typedef float zig_f80;
-#define zig_suffix_f80(x) x##f
-#elif DBL_MANT_DIG == 64
-typedef double zig_f80;
-#define zig_suffix_f80(x) x
-#elif LDBL_MANT_DIG == 64
-typedef long double zig_f80;
-#define zig_suffix_f80(x) x##l
-#elif FLT80_MANT_DIG == 64
-typedef _Float80 zig_f80;
-#define zig_suffix_f80(x) x##f80
-#elif FLT64X_MANT_DIG == 64
-typedef _Float64x zig_f80;
-#define zig_suffix_f80(x) x##f64x
-#elif defined(__SIZEOF_FLOAT80__)
-typedef __float80 zig_f80;
-#define zig_suffix_f80(x) x##l
-#endif
-
-#define zig_builtin_f128(name) name##q
-#define zig_builtin_constant_f128(name) zig_suffix_f80(__builtin_##name)
-#if FLT_MANT_DIG == 113
-typedef float zig_f128;
-#define zig_suffix_f128(x) x##f
-#elif DBL_MANT_DIG == 113
-typedef double zig_f128;
-#define zig_suffix_f128(x) x
-#elif LDBL_MANT_DIG == 113
-typedef long double zig_f128;
-#define zig_suffix_f128(x) x##l
-#elif FLT128_MANT_DIG == 113
-typedef _Float128 zig_f128;
-#define zig_suffix_f128(x) x##f128
-#elif FLT64X_MANT_DIG == 113
-typedef _Float64x zig_f128;
-#define zig_suffix_f128(x) x##f64x
-#elif defined(__SIZEOF_FLOAT128__)
-typedef __float128 zig_f128;
-#define zig_suffix_f128(x) x##q
-#undef zig_builtin_constant_f128
-#define zig_builtin_constant_f128(name) __builtin_##name##f128
-#endif
-
-typedef long double zig_c_longdouble;
-#define zig_suffix_c_longdouble(x) x##l
-#define zig_builtin_c_longdouble(name) zig_suffix_c_longdouble(name)
-#define zig_builtin_constant_c_longdouble(name) zig_suffix_c_longdouble(__builtin_##name)
+#define zig_compiler_rt_abbrev_u32  si
+#define zig_compiler_rt_abbrev_i32  si
+#define zig_compiler_rt_abbrev_u64  di
+#define zig_compiler_rt_abbrev_i64  di
+#define zig_compiler_rt_abbrev_u128 ti
+#define zig_compiler_rt_abbrev_i128 ti
+#define zig_compiler_rt_abbrev_f16  hf
+#define zig_compiler_rt_abbrev_f32  sf
+#define zig_compiler_rt_abbrev_f64  df
+#define zig_compiler_rt_abbrev_f80  xf
+#define zig_compiler_rt_abbrev_f128 tf
 
 zig_extern_c void *memcpy (void *zig_restrict, void const *zig_restrict, zig_usize);
 zig_extern_c void *memset (void *, int, zig_usize);
@@ -361,7 +271,9 @@ zig_extern_c void *memset (void *, int, zig_usize);
 /* ==================== 8/16/32/64-bit Integer Routines ===================== */
 
 #define zig_maxInt(Type, bits) zig_shr_##Type(zig_maxInt_##Type, (zig_bitSizeOf(zig_##Type) - bits))
+#define zig_expand_maxInt(Type, bits) zig_maxInt(Type, bits)
 #define zig_minInt(Type, bits) zig_not_##Type(zig_maxInt(Type, bits), bits)
+#define zig_expand_minInt(Type, bits) zig_minInt(Type, bits)
 
 #define zig_int_operator(Type, RhsType, operation, operator) \
     static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##RhsType rhs) { \
@@ -954,8 +866,8 @@ static inline zig_u16 zig_bit_reverse_u16(zig_u16 val, zig_u8 bits) {
 #if zig_has_builtin(bitreverse16)
     full_res = __builtin_bitreverse16(val);
 #else
-    full_res = (zig_u16)zig_bit_reverse_u8((zig_u8)(val >>  0)) <<  8 |
-               (zig_u16)zig_bit_reverse_u8((zig_u8)(val >>  8)) >>  0;
+    full_res = (zig_u16)zig_bit_reverse_u8((zig_u8)(val >>  0), 8) <<  8 |
+               (zig_u16)zig_bit_reverse_u8((zig_u8)(val >>  8), 8) >>  0;
 #endif
     return zig_wrap_u16(full_res >> (16 - bits), bits);
 }
@@ -969,8 +881,8 @@ static inline zig_u32 zig_bit_reverse_u32(zig_u32 val, zig_u8 bits) {
 #if zig_has_builtin(bitreverse32)
     full_res = __builtin_bitreverse32(val);
 #else
-    full_res = (zig_u32)zig_bit_reverse_u16((zig_u16)(val >>  0)) << 16 |
-               (zig_u32)zig_bit_reverse_u16((zig_u16)(val >> 16)) >>  0;
+    full_res = (zig_u32)zig_bit_reverse_u16((zig_u16)(val >>  0), 16) << 16 |
+               (zig_u32)zig_bit_reverse_u16((zig_u16)(val >> 16), 16) >>  0;
 #endif
     return zig_wrap_u32(full_res >> (32 - bits), bits);
 }
@@ -984,8 +896,8 @@ static inline zig_u64 zig_bit_reverse_u64(zig_u64 val, zig_u8 bits) {
 #if zig_has_builtin(bitreverse64)
     full_res = __builtin_bitreverse64(val);
 #else
-    full_res = (zig_u64)zig_bit_reverse_u32((zig_u32)(val >>  0)) << 32 |
-               (zig_u64)zig_bit_reverse_u32((zig_u32)(val >> 32)) >>  0;
+    full_res = (zig_u64)zig_bit_reverse_u32((zig_u32)(val >>  0), 32) << 32 |
+               (zig_u64)zig_bit_reverse_u32((zig_u32)(val >> 32), 32) >>  0;
 #endif
     return zig_wrap_u64(full_res >> (64 - bits), bits);
 }
@@ -1019,7 +931,7 @@ typedef   signed __int128 zig_i128;
 #define zig_bitcast_i128(val) ((zig_i128)(val))
 #define zig_cmp_int128(Type) \
     static inline zig_i8 zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \
-        return (lhs > rhs) - (lhs < rhs); \
+        return (zig_i8)((lhs > rhs) - (lhs < rhs)); \
     }
 #define zig_bit_int128(Type, operation, operator) \
     static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
@@ -1211,6 +1123,22 @@ static inline zig_i128 zig_mod_i128(zig_i128 lhs, zig_i128 rhs) {
 #define zig_div_floor_u128 zig_div_trunc_u128
 #define zig_mod_u128 zig_rem_u128
 
+static inline zig_u128 zig_min_u128(zig_u128 lhs, zig_u128 rhs) {
+    return zig_cmp_u128(lhs, rhs) < 0 ? lhs : rhs;
+}
+
+static inline zig_i128 zig_min_i128(zig_i128 lhs, zig_i128 rhs) {
+    return zig_cmp_i128(lhs, rhs) < 0 ? lhs : rhs;
+}
+
+static inline zig_u128 zig_max_u128(zig_u128 lhs, zig_u128 rhs) {
+    return zig_cmp_u128(lhs, rhs) > 0 ? lhs : rhs;
+}
+
+static inline zig_i128 zig_max_i128(zig_i128 lhs, zig_i128 rhs) {
+    return zig_cmp_i128(lhs, rhs) > 0 ? lhs : rhs;
+}
+
 static inline zig_i128 zig_shr_i128(zig_i128 lhs, zig_u8 rhs) {
     zig_i128 sign_mask = zig_cmp_i128(lhs, zig_as_i128(0, 0)) < zig_as_i8(0) ? -zig_as_i128(0, 1) : zig_as_i128(0, 0);
     return zig_xor_i128(zig_bitcast_i128(zig_shr_u128(zig_bitcast_u128(zig_xor_i128(lhs, sign_mask)), rhs)), sign_mask);
@@ -1460,36 +1388,285 @@ static inline zig_i128 zig_bit_reverse_i128(zig_i128 val, zig_u8 bits) {
     return zig_bit_reverse_u128(zig_bitcast_u128(val), bits);
 }
 
-/* ========================== Float Point Routines ========================== */
+/* ========================= Floating Point Support ========================= */
+
+#define zig_has_f16 1
+#define zig_bitSizeOf_f16 16
+#define zig_libc_name_f16(name) __##name##h
+#define zig_as_special_f16(sign, name, arg, repr) sign zig_as_f16(__builtin_##name, )(arg)
+#if FLT_MANT_DIG == 11
+typedef float zig_f16;
+#define zig_as_f16(fp, repr) fp##f
+#elif DBL_MANT_DIG == 11
+typedef double zig_f16;
+#define zig_as_f16(fp, repr) fp
+#elif LDBL_MANT_DIG == 11
+#define zig_bitSizeOf_c_longdouble 16
+typedef long double zig_f16;
+#define zig_as_f16(fp, repr) fp##l
+#elif FLT16_MANT_DIG == 11
+typedef _Float16 zig_f16;
+#define zig_as_f16(fp, repr) fp##f16
+#elif defined(__SIZEOF_FP16__)
+typedef __fp16 zig_f16;
+#define zig_as_f16(fp, repr) fp##f16
+#else
+#undef zig_has_f16
+#define zig_has_f16 0
+#define zig_repr_f16 i16
+typedef zig_i16 zig_f16;
+#define zig_as_f16(fp, repr) repr
+#undef zig_as_special_f16
+#define zig_as_special_f16(sign, name, arg, repr) repr
+#endif
+
+#define zig_has_f32 1
+#define zig_bitSizeOf_f32 32
+#define zig_libc_name_f32(name) name##f
+#define zig_as_special_f32(sign, name, arg, repr) sign zig_as_f32(__builtin_##name, )(arg)
+#if FLT_MANT_DIG == 24
+typedef float zig_f32;
+#define zig_as_f32(fp, repr) fp##f
+#elif DBL_MANT_DIG == 24
+typedef double zig_f32;
+#define zig_as_f32(fp, repr) fp
+#elif LDBL_MANT_DIG == 24
+#define zig_bitSizeOf_c_longdouble 32
+typedef long double zig_f32;
+#define zig_as_f32(fp, repr) fp##l
+#elif FLT32_MANT_DIG == 24
+typedef _Float32 zig_f32;
+#define zig_as_f32(fp, repr) fp##f32
+#else
+#undef zig_has_f32
+#define zig_has_f32 0
+#define zig_repr_f32 i32
+typedef zig_i32 zig_f32;
+#define zig_as_f32(fp, repr) repr
+#undef zig_as_special_f32
+#define zig_as_special_f32(sign, name, arg, repr) repr
+#endif
+
+#define zig_has_f64 1
+#define zig_bitSizeOf_f64 64
+#define zig_libc_name_f64(name) name
+#define zig_as_special_f64(sign, name, arg, repr) sign zig_as_f64(__builtin_##name, )(arg)
+#if FLT_MANT_DIG == 53
+typedef float zig_f64;
+#define zig_as_f64(fp, repr) fp##f
+#elif DBL_MANT_DIG == 53
+typedef double zig_f64;
+#define zig_as_f64(fp, repr) fp
+#elif LDBL_MANT_DIG == 53
+#define zig_bitSizeOf_c_longdouble 64
+typedef long double zig_f64;
+#define zig_as_f64(fp, repr) fp##l
+#elif FLT64_MANT_DIG == 53
+typedef _Float64 zig_f64;
+#define zig_as_f64(fp, repr) fp##f64
+#elif FLT32X_MANT_DIG == 53
+typedef _Float32x zig_f64;
+#define zig_as_f64(fp, repr) fp##f32x
+#else
+#undef zig_has_f64
+#define zig_has_f64 0
+#define zig_repr_f64 i64
+typedef zig_i64 zig_f64;
+#define zig_as_f64(fp, repr) repr
+#undef zig_as_special_f64
+#define zig_as_special_f64(sign, name, arg, repr) repr
+#endif
+
+#define zig_has_f80 1
+#define zig_bitSizeOf_f80 80
+#define zig_libc_name_f80(name) __##name##x
+#define zig_as_special_f80(sign, name, arg, repr) sign zig_as_f80(__builtin_##name, )(arg)
+#if FLT_MANT_DIG == 64
+typedef float zig_f80;
+#define zig_as_f80(fp, repr) fp##f
+#elif DBL_MANT_DIG == 64
+typedef double zig_f80;
+#define zig_as_f80(fp, repr) fp
+#elif LDBL_MANT_DIG == 64
+#define zig_bitSizeOf_c_longdouble 80
+typedef long double zig_f80;
+#define zig_as_f80(fp, repr) fp##l
+#elif FLT80_MANT_DIG == 64
+typedef _Float80 zig_f80;
+#define zig_as_f80(fp, repr) fp##f80
+#elif FLT64X_MANT_DIG == 64
+typedef _Float64x zig_f80;
+#define zig_as_f80(fp, repr) fp##f64x
+#elif defined(__SIZEOF_FLOAT80__)
+typedef __float80 zig_f80;
+#define zig_as_f80(fp, repr) fp##l
+#else
+#undef zig_has_f80
+#define zig_has_f80 0
+#define zig_repr_f80 i128
+typedef zig_i128 zig_f80;
+#define zig_as_f80(fp, repr) repr
+#undef zig_as_special_f80
+#define zig_as_special_f80(sign, name, arg, repr) repr
+#endif
+
+#define zig_has_f128 1
+#define zig_bitSizeOf_f128 128
+#define zig_libc_name_f128(name) name##q
+#define zig_as_special_f128(sign, name, arg, repr) sign zig_as_f128(__builtin_##name, )(arg)
+#if FLT_MANT_DIG == 113
+typedef float zig_f128;
+#define zig_as_f128(fp, repr) fp##f
+#elif DBL_MANT_DIG == 113
+typedef double zig_f128;
+#define zig_as_f128(fp, repr) fp
+#elif LDBL_MANT_DIG == 113
+#define zig_bitSizeOf_c_longdouble 128
+typedef long double zig_f128;
+#define zig_as_f128(fp, repr) fp##l
+#elif FLT128_MANT_DIG == 113
+typedef _Float128 zig_f128;
+#define zig_as_f128(fp, repr) fp##f128
+#elif FLT64X_MANT_DIG == 113
+typedef _Float64x zig_f128;
+#define zig_as_f128(fp, repr) fp##f64x
+#elif defined(__SIZEOF_FLOAT128__)
+typedef __float128 zig_f128;
+#define zig_as_f128(fp, repr) fp##q
+#undef zig_as_special_f128
+#define zig_as_special_f128(sign, name, arg, repr) sign __builtin_##name##f128(arg)
+#else
+#undef zig_has_f128
+#define zig_has_f128 0
+#define zig_repr_f128 i128
+typedef zig_i128 zig_f128;
+#define zig_as_f128(fp, repr) repr
+#undef zig_as_special_f128
+#define zig_as_special_f128(sign, name, arg, repr) repr
+#endif
+
+#define zig_has_c_longdouble 1
+typedef long double zig_c_longdouble;
+#define zig_as_c_longdouble(fp, repr) fp##l
+#define zig_libc_name_c_longdouble(name) name##l
+#define zig_as_special_c_longdouble(sign, name, arg, repr) sign __builtin_##name##l(arg)
+
+#define zig_convert_builtin(ResType, operation, ArgType, version) \
+    zig_extern_c zig_##ResType zig_expand_concat(zig_expand_concat(zig_expand_concat(__##operation, \
+        zig_compiler_rt_abbrev_##ArgType), zig_compiler_rt_abbrev_##ResType), version)(zig_##ArgType);
+zig_convert_builtin(f16,  trunc,  f32,  2)
+zig_convert_builtin(f16,  trunc,  f64,  2)
+zig_convert_builtin(f16,  trunc,  f80,  2)
+zig_convert_builtin(f16,  trunc,  f128, 2)
+zig_convert_builtin(f32,  extend, f16,  2)
+zig_convert_builtin(f32,  trunc,  f64,  2)
+zig_convert_builtin(f32,  trunc,  f80,  2)
+zig_convert_builtin(f32,  trunc,  f128, 2)
+zig_convert_builtin(f64,  extend, f16,  2)
+zig_convert_builtin(f64,  extend, f32,  2)
+zig_convert_builtin(f64,  trunc,  f80,  2)
+zig_convert_builtin(f64,  trunc,  f128, 2)
+zig_convert_builtin(f80,  extend, f16,  2)
+zig_convert_builtin(f80,  extend, f32,  2)
+zig_convert_builtin(f80,  extend, f64,  2)
+zig_convert_builtin(f80,  trunc,  f128, 2)
+zig_convert_builtin(f128, extend, f16,  2)
+zig_convert_builtin(f128, extend, f32,  2)
+zig_convert_builtin(f128, extend, f64,  2)
+zig_convert_builtin(f128, extend, f80,  2)
+
+#define zig_float_negate_builtin_0(Type) \
+    static inline zig_##Type zig_neg_##Type(zig_##Type arg) { \
+        return zig_expand_concat(zig_xor_, zig_repr_##Type)(arg, zig_expand_minInt(zig_repr_##Type, zig_bitSizeOf_##Type)); \
+    }
+#define zig_float_negate_builtin_1(Type) \
+    static inline zig_##Type zig_neg_##Type(zig_##Type arg) { \
+        return -arg; \
+    }
+
+#define zig_float_less_builtin_0(Type, operation) \
+    zig_extern_c zig_i8 zig_expand_concat(zig_expand_concat(__##operation, \
+        zig_compiler_rt_abbrev_##Type), 2)(zig_##Type, zig_##Type); \
+    static inline zig_i8 zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
+        return (zig_i8)zig_expand_concat(zig_expand_concat(__##operation, zig_compiler_rt_abbrev_##Type), 2)(lhs, rhs); \
+    }
+#define zig_float_less_builtin_1(Type, operation) \
+    static inline zig_i8 zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
+        return (zig_i8)(!(lhs <= rhs) - (lhs < rhs)); \
+    }
+
+#define zig_float_greater_builtin_0(Type, operation) \
+    zig_float_less_builtin_0(Type, operation)
+#define zig_float_greater_builtin_1(Type, operation) \
+    static inline zig_i8 zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
+        return (zig_i8)((lhs > rhs) - !(lhs >= rhs)); \
+    }
+
+#define zig_float_binary_builtin_0(Type, operation, operator) \
+    zig_extern_c zig_##Type zig_expand_concat(zig_expand_concat(__##operation, \
+        zig_compiler_rt_abbrev_##Type), 3)(zig_##Type, zig_##Type); \
+    static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
+        return zig_expand_concat(zig_expand_concat(__##operation, zig_compiler_rt_abbrev_##Type), 3)(lhs, rhs); \
+    }
+#define zig_float_binary_builtin_1(Type, operation, operator) \
+    static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
+        return lhs operator rhs; \
+    }
 
 #define zig_float_builtins(Type) \
-    zig_extern_c zig_##Type zig_builtin_##Type(sqrt)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(sin)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(cos)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(tan)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(exp)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(exp2)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(log)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(log2)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(log10)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(fabs)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(floor)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(ceil)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(round)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(trunc)(zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(fmod)(zig_##Type, zig_##Type); \
-    zig_extern_c zig_##Type zig_builtin_##Type(fma)(zig_##Type, zig_##Type, zig_##Type); \
+    zig_convert_builtin(i32,  fix,     Type, ) \
+    zig_convert_builtin(u32,  fixuns,  Type, ) \
+    zig_convert_builtin(i64,  fix,     Type, ) \
+    zig_convert_builtin(u64,  fixuns,  Type, ) \
+    zig_convert_builtin(i128, fix,     Type, ) \
+    zig_convert_builtin(u128, fixuns,  Type, ) \
+    zig_convert_builtin(Type, float,   i32,  ) \
+    zig_convert_builtin(Type, floatun, u32,  ) \
+    zig_convert_builtin(Type, float,   i64,  ) \
+    zig_convert_builtin(Type, floatun, u64,  ) \
+    zig_convert_builtin(Type, float,   i128, ) \
+    zig_convert_builtin(Type, floatun, u128, ) \
+    zig_expand_concat(zig_float_negate_builtin_,  zig_has_##Type)(Type) \
+    zig_expand_concat(zig_float_less_builtin_,    zig_has_##Type)(Type, cmp) \
+    zig_expand_concat(zig_float_less_builtin_,    zig_has_##Type)(Type, ne) \
+    zig_expand_concat(zig_float_less_builtin_,    zig_has_##Type)(Type, eq) \
+    zig_expand_concat(zig_float_less_builtin_,    zig_has_##Type)(Type, lt) \
+    zig_expand_concat(zig_float_less_builtin_,    zig_has_##Type)(Type, le) \
+    zig_expand_concat(zig_float_greater_builtin_, zig_has_##Type)(Type, gt) \
+    zig_expand_concat(zig_float_greater_builtin_, zig_has_##Type)(Type, ge) \
+    zig_expand_concat(zig_float_binary_builtin_,  zig_has_##Type)(Type, add, +) \
+    zig_expand_concat(zig_float_binary_builtin_,  zig_has_##Type)(Type, sub, -) \
+    zig_expand_concat(zig_float_binary_builtin_,  zig_has_##Type)(Type, mul, *) \
+    zig_expand_concat(zig_float_binary_builtin_,  zig_has_##Type)(Type, div, /) \
+    zig_extern_c zig_##Type zig_libc_name_##Type(sqrt)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(sin)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(cos)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(tan)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(exp)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(exp2)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(log)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(log2)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(log10)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(fabs)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(floor)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(ceil)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(round)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(trunc)(zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(fmod)(zig_##Type, zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(fmin)(zig_##Type, zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(fmax)(zig_##Type, zig_##Type); \
+    zig_extern_c zig_##Type zig_libc_name_##Type(fma)(zig_##Type, zig_##Type, zig_##Type); \
 \
     static inline zig_##Type zig_div_trunc_##Type(zig_##Type lhs, zig_##Type rhs) { \
-        return zig_builtin_##Type(trunc)(lhs / rhs); \
+        return zig_libc_name_##Type(trunc)(zig_div_##Type(lhs, rhs)); \
     } \
 \
     static inline zig_##Type zig_div_floor_##Type(zig_##Type lhs, zig_##Type rhs) { \
-        return zig_builtin_##Type(floor)(lhs / rhs); \
+        return zig_libc_name_##Type(floor)(zig_div_##Type(lhs, rhs)); \
     } \
 \
     static inline zig_##Type zig_mod_##Type(zig_##Type lhs, zig_##Type rhs) { \
-        return lhs - zig_div_floor_##Type(lhs, rhs) * rhs; \
+        return zig_sub_##Type(lhs, zig_mul_##Type(zig_div_floor_##Type(lhs, rhs), rhs)); \
     }
 zig_float_builtins(f16)
 zig_float_builtins(f32)
diff --git a/lib/std/start.zig b/lib/std/start.zig
index 14903b0bc9..7ba24ad78c 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -281,7 +281,15 @@ fn _start() callconv(.Naked) noreturn {
                     \\ andl $-16, %%esp
                     \\ jmp _posixCallMainAndExit
                 ),
-                .aarch64, .aarch64_be, .arm, .armeb, .thumb => asm volatile (
+                .aarch64, .aarch64_be => asm volatile (
+                    \\ mov fp, #0
+                    \\ mov lr, #0
+                    \\ mov x0, sp
+                    \\ adrp x1, argc_argv_ptr
+                    \\ str x0, [x1, :lo12:argc_argv_ptr]
+                    \\ b _posixCallMainAndExit
+                ),
+                .arm, .armeb, .thumb => asm volatile (
                     \\ mov fp, #0
                     \\ mov lr, #0
                     \\ str sp, argc_argv_ptr
diff --git a/lib/test_runner.zig b/lib/test_runner.zig
index 079d9c813a..83ac378daf 100644
--- a/lib/test_runner.zig
+++ b/lib/test_runner.zig
@@ -130,7 +130,8 @@ pub fn main2() anyerror!void {
     }
     if (builtin.zig_backend == .stage2_wasm or
         builtin.zig_backend == .stage2_x86_64 or
-        builtin.zig_backend == .stage2_llvm)
+        builtin.zig_backend == .stage2_llvm or
+        builtin.zig_backend == .stage2_c)
     {
         const passed = builtin.test_functions.len - skipped - failed;
         const stderr = std.io.getStdErr();