authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2022-10-31 20:18:15-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2022-10-31 20:18:15-04:00
logb945d3eb902113317ff66a6e830316c4d7ce10f5
tree969eca72f0b7daf7c54c69839ff6ffb9a3289872
parent0bbb000359107e25dccf2411ea7bea7f5cf52684

cbe: improve support for non-native float types

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

5 files changed, 511 insertions(+), 232 deletions(-)

lib/include/zig.h+312-135
...@@ -20,7 +20,7 @@...@@ -20,7 +20,7 @@
2020
21#if __STDC_VERSION__ >= 201112L21#if __STDC_VERSION__ >= 201112L
22#define zig_threadlocal thread_local22#define zig_threadlocal thread_local
23#elif __GNUC__23#elif defined(__GNUC__)
24#define zig_threadlocal __thread24#define zig_threadlocal __thread
25#elif _MSC_VER25#elif _MSC_VER
26#define zig_threadlocal __declspec(thread)26#define zig_threadlocal __declspec(thread)
...@@ -28,7 +28,7 @@...@@ -28,7 +28,7 @@
28#define zig_threadlocal zig_threadlocal_unavailable28#define zig_threadlocal zig_threadlocal_unavailable
29#endif29#endif
3030
31#if zig_has_attribute(naked)31#if zig_has_attribute(naked) || defined(__GNUC__)
32#define zig_naked __attribute__((naked))32#define zig_naked __attribute__((naked))
33#elif defined(_MSC_VER)33#elif defined(_MSC_VER)
34#define zig_naked __declspec(naked)34#define zig_naked __declspec(naked)
...@@ -128,7 +128,7 @@...@@ -128,7 +128,7 @@
128#define zig_atomic_store(obj, arg, order) atomic_store_explicit (obj, arg, order)128#define zig_atomic_store(obj, arg, order) atomic_store_explicit (obj, arg, order)
129#define zig_atomic_load(obj, order) atomic_load_explicit (obj, order)129#define zig_atomic_load(obj, order) atomic_load_explicit (obj, order)
130#define zig_fence(order) atomic_thread_fence(order)130#define zig_fence(order) atomic_thread_fence(order)
131#elif __GNUC__131#elif defined(__GNUC__)
132#define memory_order_relaxed __ATOMIC_RELAXED132#define memory_order_relaxed __ATOMIC_RELAXED
133#define memory_order_consume __ATOMIC_CONSUME133#define memory_order_consume __ATOMIC_CONSUME
134#define memory_order_acquire __ATOMIC_ACQUIRE134#define memory_order_acquire __ATOMIC_ACQUIRE
...@@ -176,7 +176,7 @@...@@ -176,7 +176,7 @@
176176
177#if __STDC_VERSION__ >= 201112L177#if __STDC_VERSION__ >= 201112L
178#define zig_noreturn _Noreturn void178#define zig_noreturn _Noreturn void
179#elif zig_has_attribute(noreturn)179#elif zig_has_attribute(noreturn) || defined(__GNUC__)
180#define zig_noreturn __attribute__((noreturn)) void180#define zig_noreturn __attribute__((noreturn)) void
181#elif _MSC_VER181#elif _MSC_VER
182#define zig_noreturn __declspec(noreturn) void182#define zig_noreturn __declspec(noreturn) void
...@@ -184,6 +184,9 @@...@@ -184,6 +184,9 @@
184#define zig_noreturn void184#define zig_noreturn void
185#endif185#endif
186186
187#define zig_concat(lhs, rhs) lhs##rhs
188#define zig_expand_concat(lhs, rhs) zig_concat(lhs, rhs)
189
187#define zig_bitSizeOf(T) (CHAR_BIT * sizeof(T))190#define zig_bitSizeOf(T) (CHAR_BIT * sizeof(T))
188191
189typedef void zig_void;192typedef void zig_void;
...@@ -250,110 +253,17 @@ typedef int64_t zig_i64;...@@ -250,110 +253,17 @@ typedef int64_t zig_i64;
250#define zig_minInt_i64 INT64_MIN253#define zig_minInt_i64 INT64_MIN
251#define zig_maxInt_i64 INT64_MAX254#define zig_maxInt_i64 INT64_MAX
252255
253#define zig_builtin_f16(name) __##name##h256#define zig_compiler_rt_abbrev_u32 si
254#define zig_builtin_constant_f16(name) zig_suffix_f16(__builtin_##name)257#define zig_compiler_rt_abbrev_i32 si
255#if FLT_MANT_DIG == 11258#define zig_compiler_rt_abbrev_u64 di
256typedef float zig_f16;259#define zig_compiler_rt_abbrev_i64 di
257#define zig_suffix_f16(x) x##f260#define zig_compiler_rt_abbrev_u128 ti
258#elif DBL_MANT_DIG == 11261#define zig_compiler_rt_abbrev_i128 ti
259typedef double zig_f16;262#define zig_compiler_rt_abbrev_f16 hf
260#define zig_suffix_f16(x) x263#define zig_compiler_rt_abbrev_f32 sf
261#elif LDBL_MANT_DIG == 11264#define zig_compiler_rt_abbrev_f64 df
262typedef long double zig_f16;265#define zig_compiler_rt_abbrev_f80 xf
263#define zig_suffix_f16(x) x##l266#define zig_compiler_rt_abbrev_f128 tf
264#elif FLT16_MANT_DIG == 11
265typedef _Float16 zig_f16;
266#define zig_suffix_f16(x) x##f16
267#elif defined(__SIZEOF_FP16__)
268typedef __fp16 zig_f16;
269#define zig_suffix_f16(x) x##f16
270#endif
271
272#define zig_builtin_f32(name) name##f
273#define zig_builtin_constant_f32(name) zig_suffix_f32(__builtin_##name)
274#if FLT_MANT_DIG == 24
275typedef float zig_f32;
276#define zig_suffix_f32(x) x##f
277#elif DBL_MANT_DIG == 24
278typedef double zig_f32;
279#define zig_suffix_f32(x) x
280#elif LDBL_MANT_DIG == 24
281typedef long double zig_f32;
282#define zig_suffix_f32(x) x##l
283#elif FLT32_MANT_DIG == 24
284typedef _Float32 zig_f32;
285#define zig_suffix_f32(x) x##f32
286#endif
287
288#define zig_builtin_f64(name) name
289#define zig_builtin_constant_f64(name) zig_suffix_f64(__builtin_##name)
290#if FLT_MANT_DIG == 53
291typedef float zig_f64;
292#define zig_suffix_f64(x) x##f
293#elif DBL_MANT_DIG == 53
294typedef double zig_f64;
295#define zig_suffix_f64(x) x
296#elif LDBL_MANT_DIG == 53
297typedef long double zig_f64;
298#define zig_suffix_f64(x) x##l
299#elif FLT64_MANT_DIG == 53
300typedef _Float64 zig_f64;
301#define zig_suffix_f64(x) x##f64
302#elif FLT32X_MANT_DIG == 53
303typedef _Float32x zig_f64;
304#define zig_suffix_f64(x) x##f32x
305#endif
306
307#define zig_builtin_f80(name) __##name##x
308#define zig_builtin_constant_f80(name) zig_suffix_f80(__builtin_##name)
309#if FLT_MANT_DIG == 64
310typedef float zig_f80;
311#define zig_suffix_f80(x) x##f
312#elif DBL_MANT_DIG == 64
313typedef double zig_f80;
314#define zig_suffix_f80(x) x
315#elif LDBL_MANT_DIG == 64
316typedef long double zig_f80;
317#define zig_suffix_f80(x) x##l
318#elif FLT80_MANT_DIG == 64
319typedef _Float80 zig_f80;
320#define zig_suffix_f80(x) x##f80
321#elif FLT64X_MANT_DIG == 64
322typedef _Float64x zig_f80;
323#define zig_suffix_f80(x) x##f64x
324#elif defined(__SIZEOF_FLOAT80__)
325typedef __float80 zig_f80;
326#define zig_suffix_f80(x) x##l
327#endif
328
329#define zig_builtin_f128(name) name##q
330#define zig_builtin_constant_f128(name) zig_suffix_f80(__builtin_##name)
331#if FLT_MANT_DIG == 113
332typedef float zig_f128;
333#define zig_suffix_f128(x) x##f
334#elif DBL_MANT_DIG == 113
335typedef double zig_f128;
336#define zig_suffix_f128(x) x
337#elif LDBL_MANT_DIG == 113
338typedef long double zig_f128;
339#define zig_suffix_f128(x) x##l
340#elif FLT128_MANT_DIG == 113
341typedef _Float128 zig_f128;
342#define zig_suffix_f128(x) x##f128
343#elif FLT64X_MANT_DIG == 113
344typedef _Float64x zig_f128;
345#define zig_suffix_f128(x) x##f64x
346#elif defined(__SIZEOF_FLOAT128__)
347typedef __float128 zig_f128;
348#define zig_suffix_f128(x) x##q
349#undef zig_builtin_constant_f128
350#define zig_builtin_constant_f128(name) __builtin_##name##f128
351#endif
352
353typedef long double zig_c_longdouble;
354#define zig_suffix_c_longdouble(x) x##l
355#define zig_builtin_c_longdouble(name) zig_suffix_c_longdouble(name)
356#define zig_builtin_constant_c_longdouble(name) zig_suffix_c_longdouble(__builtin_##name)
357267
358zig_extern_c void *memcpy (void *zig_restrict, void const *zig_restrict, zig_usize);268zig_extern_c void *memcpy (void *zig_restrict, void const *zig_restrict, zig_usize);
359zig_extern_c void *memset (void *, int, zig_usize);269zig_extern_c void *memset (void *, int, zig_usize);
...@@ -361,7 +271,9 @@ zig_extern_c void *memset (void *, int, zig_usize);...@@ -361,7 +271,9 @@ zig_extern_c void *memset (void *, int, zig_usize);
361/* ==================== 8/16/32/64-bit Integer Routines ===================== */271/* ==================== 8/16/32/64-bit Integer Routines ===================== */
362272
363#define zig_maxInt(Type, bits) zig_shr_##Type(zig_maxInt_##Type, (zig_bitSizeOf(zig_##Type) - bits))273#define zig_maxInt(Type, bits) zig_shr_##Type(zig_maxInt_##Type, (zig_bitSizeOf(zig_##Type) - bits))
274#define zig_expand_maxInt(Type, bits) zig_maxInt(Type, bits)
364#define zig_minInt(Type, bits) zig_not_##Type(zig_maxInt(Type, bits), bits)275#define zig_minInt(Type, bits) zig_not_##Type(zig_maxInt(Type, bits), bits)
276#define zig_expand_minInt(Type, bits) zig_minInt(Type, bits)
365277
366#define zig_int_operator(Type, RhsType, operation, operator) \278#define zig_int_operator(Type, RhsType, operation, operator) \
367 static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##RhsType rhs) { \279 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) {...@@ -954,8 +866,8 @@ static inline zig_u16 zig_bit_reverse_u16(zig_u16 val, zig_u8 bits) {
954#if zig_has_builtin(bitreverse16)866#if zig_has_builtin(bitreverse16)
955 full_res = __builtin_bitreverse16(val);867 full_res = __builtin_bitreverse16(val);
956#else868#else
957 full_res = (zig_u16)zig_bit_reverse_u8((zig_u8)(val >> 0)) << 8 |869 full_res = (zig_u16)zig_bit_reverse_u8((zig_u8)(val >> 0), 8) << 8 |
958 (zig_u16)zig_bit_reverse_u8((zig_u8)(val >> 8)) >> 0;870 (zig_u16)zig_bit_reverse_u8((zig_u8)(val >> 8), 8) >> 0;
959#endif871#endif
960 return zig_wrap_u16(full_res >> (16 - bits), bits);872 return zig_wrap_u16(full_res >> (16 - bits), bits);
961}873}
...@@ -969,8 +881,8 @@ static inline zig_u32 zig_bit_reverse_u32(zig_u32 val, zig_u8 bits) {...@@ -969,8 +881,8 @@ static inline zig_u32 zig_bit_reverse_u32(zig_u32 val, zig_u8 bits) {
969#if zig_has_builtin(bitreverse32)881#if zig_has_builtin(bitreverse32)
970 full_res = __builtin_bitreverse32(val);882 full_res = __builtin_bitreverse32(val);
971#else883#else
972 full_res = (zig_u32)zig_bit_reverse_u16((zig_u16)(val >> 0)) << 16 |884 full_res = (zig_u32)zig_bit_reverse_u16((zig_u16)(val >> 0), 16) << 16 |
973 (zig_u32)zig_bit_reverse_u16((zig_u16)(val >> 16)) >> 0;885 (zig_u32)zig_bit_reverse_u16((zig_u16)(val >> 16), 16) >> 0;
974#endif886#endif
975 return zig_wrap_u32(full_res >> (32 - bits), bits);887 return zig_wrap_u32(full_res >> (32 - bits), bits);
976}888}
...@@ -984,8 +896,8 @@ static inline zig_u64 zig_bit_reverse_u64(zig_u64 val, zig_u8 bits) {...@@ -984,8 +896,8 @@ static inline zig_u64 zig_bit_reverse_u64(zig_u64 val, zig_u8 bits) {
984#if zig_has_builtin(bitreverse64)896#if zig_has_builtin(bitreverse64)
985 full_res = __builtin_bitreverse64(val);897 full_res = __builtin_bitreverse64(val);
986#else898#else
987 full_res = (zig_u64)zig_bit_reverse_u32((zig_u32)(val >> 0)) << 32 |899 full_res = (zig_u64)zig_bit_reverse_u32((zig_u32)(val >> 0), 32) << 32 |
988 (zig_u64)zig_bit_reverse_u32((zig_u32)(val >> 32)) >> 0;900 (zig_u64)zig_bit_reverse_u32((zig_u32)(val >> 32), 32) >> 0;
989#endif901#endif
990 return zig_wrap_u64(full_res >> (64 - bits), bits);902 return zig_wrap_u64(full_res >> (64 - bits), bits);
991}903}
...@@ -1019,7 +931,7 @@ typedef signed __int128 zig_i128;...@@ -1019,7 +931,7 @@ typedef signed __int128 zig_i128;
1019#define zig_bitcast_i128(val) ((zig_i128)(val))931#define zig_bitcast_i128(val) ((zig_i128)(val))
1020#define zig_cmp_int128(Type) \932#define zig_cmp_int128(Type) \
1021 static inline zig_i8 zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \933 static inline zig_i8 zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \
1022 return (lhs > rhs) - (lhs < rhs); \934 return (zig_i8)((lhs > rhs) - (lhs < rhs)); \
1023 }935 }
1024#define zig_bit_int128(Type, operation, operator) \936#define zig_bit_int128(Type, operation, operator) \
1025 static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \937 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) {...@@ -1211,6 +1123,22 @@ static inline zig_i128 zig_mod_i128(zig_i128 lhs, zig_i128 rhs) {
1211#define zig_div_floor_u128 zig_div_trunc_u1281123#define zig_div_floor_u128 zig_div_trunc_u128
1212#define zig_mod_u128 zig_rem_u1281124#define zig_mod_u128 zig_rem_u128
12131125
1126static inline zig_u128 zig_min_u128(zig_u128 lhs, zig_u128 rhs) {
1127 return zig_cmp_u128(lhs, rhs) < 0 ? lhs : rhs;
1128}
1129
1130static inline zig_i128 zig_min_i128(zig_i128 lhs, zig_i128 rhs) {
1131 return zig_cmp_i128(lhs, rhs) < 0 ? lhs : rhs;
1132}
1133
1134static inline zig_u128 zig_max_u128(zig_u128 lhs, zig_u128 rhs) {
1135 return zig_cmp_u128(lhs, rhs) > 0 ? lhs : rhs;
1136}
1137
1138static inline zig_i128 zig_max_i128(zig_i128 lhs, zig_i128 rhs) {
1139 return zig_cmp_i128(lhs, rhs) > 0 ? lhs : rhs;
1140}
1141
1214static inline zig_i128 zig_shr_i128(zig_i128 lhs, zig_u8 rhs) {1142static inline zig_i128 zig_shr_i128(zig_i128 lhs, zig_u8 rhs) {
1215 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);1143 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);
1216 return zig_xor_i128(zig_bitcast_i128(zig_shr_u128(zig_bitcast_u128(zig_xor_i128(lhs, sign_mask)), rhs)), sign_mask);1144 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) {...@@ -1460,36 +1388,285 @@ static inline zig_i128 zig_bit_reverse_i128(zig_i128 val, zig_u8 bits) {
1460 return zig_bit_reverse_u128(zig_bitcast_u128(val), bits);1388 return zig_bit_reverse_u128(zig_bitcast_u128(val), bits);
1461}1389}
14621390
1463/* ========================== Float Point Routines ========================== */1391/* ========================= Floating Point Support ========================= */
1392
1393#define zig_has_f16 1
1394#define zig_bitSizeOf_f16 16
1395#define zig_libc_name_f16(name) __##name##h
1396#define zig_as_special_f16(sign, name, arg, repr) sign zig_as_f16(__builtin_##name, )(arg)
1397#if FLT_MANT_DIG == 11
1398typedef float zig_f16;
1399#define zig_as_f16(fp, repr) fp##f
1400#elif DBL_MANT_DIG == 11
1401typedef double zig_f16;
1402#define zig_as_f16(fp, repr) fp
1403#elif LDBL_MANT_DIG == 11
1404#define zig_bitSizeOf_c_longdouble 16
1405typedef long double zig_f16;
1406#define zig_as_f16(fp, repr) fp##l
1407#elif FLT16_MANT_DIG == 11
1408typedef _Float16 zig_f16;
1409#define zig_as_f16(fp, repr) fp##f16
1410#elif defined(__SIZEOF_FP16__)
1411typedef __fp16 zig_f16;
1412#define zig_as_f16(fp, repr) fp##f16
1413#else
1414#undef zig_has_f16
1415#define zig_has_f16 0
1416#define zig_repr_f16 i16
1417typedef zig_i16 zig_f16;
1418#define zig_as_f16(fp, repr) repr
1419#undef zig_as_special_f16
1420#define zig_as_special_f16(sign, name, arg, repr) repr
1421#endif
1422
1423#define zig_has_f32 1
1424#define zig_bitSizeOf_f32 32
1425#define zig_libc_name_f32(name) name##f
1426#define zig_as_special_f32(sign, name, arg, repr) sign zig_as_f32(__builtin_##name, )(arg)
1427#if FLT_MANT_DIG == 24
1428typedef float zig_f32;
1429#define zig_as_f32(fp, repr) fp##f
1430#elif DBL_MANT_DIG == 24
1431typedef double zig_f32;
1432#define zig_as_f32(fp, repr) fp
1433#elif LDBL_MANT_DIG == 24
1434#define zig_bitSizeOf_c_longdouble 32
1435typedef long double zig_f32;
1436#define zig_as_f32(fp, repr) fp##l
1437#elif FLT32_MANT_DIG == 24
1438typedef _Float32 zig_f32;
1439#define zig_as_f32(fp, repr) fp##f32
1440#else
1441#undef zig_has_f32
1442#define zig_has_f32 0
1443#define zig_repr_f32 i32
1444typedef zig_i32 zig_f32;
1445#define zig_as_f32(fp, repr) repr
1446#undef zig_as_special_f32
1447#define zig_as_special_f32(sign, name, arg, repr) repr
1448#endif
1449
1450#define zig_has_f64 1
1451#define zig_bitSizeOf_f64 64
1452#define zig_libc_name_f64(name) name
1453#define zig_as_special_f64(sign, name, arg, repr) sign zig_as_f64(__builtin_##name, )(arg)
1454#if FLT_MANT_DIG == 53
1455typedef float zig_f64;
1456#define zig_as_f64(fp, repr) fp##f
1457#elif DBL_MANT_DIG == 53
1458typedef double zig_f64;
1459#define zig_as_f64(fp, repr) fp
1460#elif LDBL_MANT_DIG == 53
1461#define zig_bitSizeOf_c_longdouble 64
1462typedef long double zig_f64;
1463#define zig_as_f64(fp, repr) fp##l
1464#elif FLT64_MANT_DIG == 53
1465typedef _Float64 zig_f64;
1466#define zig_as_f64(fp, repr) fp##f64
1467#elif FLT32X_MANT_DIG == 53
1468typedef _Float32x zig_f64;
1469#define zig_as_f64(fp, repr) fp##f32x
1470#else
1471#undef zig_has_f64
1472#define zig_has_f64 0
1473#define zig_repr_f64 i64
1474typedef zig_i64 zig_f64;
1475#define zig_as_f64(fp, repr) repr
1476#undef zig_as_special_f64
1477#define zig_as_special_f64(sign, name, arg, repr) repr
1478#endif
1479
1480#define zig_has_f80 1
1481#define zig_bitSizeOf_f80 80
1482#define zig_libc_name_f80(name) __##name##x
1483#define zig_as_special_f80(sign, name, arg, repr) sign zig_as_f80(__builtin_##name, )(arg)
1484#if FLT_MANT_DIG == 64
1485typedef float zig_f80;
1486#define zig_as_f80(fp, repr) fp##f
1487#elif DBL_MANT_DIG == 64
1488typedef double zig_f80;
1489#define zig_as_f80(fp, repr) fp
1490#elif LDBL_MANT_DIG == 64
1491#define zig_bitSizeOf_c_longdouble 80
1492typedef long double zig_f80;
1493#define zig_as_f80(fp, repr) fp##l
1494#elif FLT80_MANT_DIG == 64
1495typedef _Float80 zig_f80;
1496#define zig_as_f80(fp, repr) fp##f80
1497#elif FLT64X_MANT_DIG == 64
1498typedef _Float64x zig_f80;
1499#define zig_as_f80(fp, repr) fp##f64x
1500#elif defined(__SIZEOF_FLOAT80__)
1501typedef __float80 zig_f80;
1502#define zig_as_f80(fp, repr) fp##l
1503#else
1504#undef zig_has_f80
1505#define zig_has_f80 0
1506#define zig_repr_f80 i128
1507typedef zig_i128 zig_f80;
1508#define zig_as_f80(fp, repr) repr
1509#undef zig_as_special_f80
1510#define zig_as_special_f80(sign, name, arg, repr) repr
1511#endif
1512
1513#define zig_has_f128 1
1514#define zig_bitSizeOf_f128 128
1515#define zig_libc_name_f128(name) name##q
1516#define zig_as_special_f128(sign, name, arg, repr) sign zig_as_f128(__builtin_##name, )(arg)
1517#if FLT_MANT_DIG == 113
1518typedef float zig_f128;
1519#define zig_as_f128(fp, repr) fp##f
1520#elif DBL_MANT_DIG == 113
1521typedef double zig_f128;
1522#define zig_as_f128(fp, repr) fp
1523#elif LDBL_MANT_DIG == 113
1524#define zig_bitSizeOf_c_longdouble 128
1525typedef long double zig_f128;
1526#define zig_as_f128(fp, repr) fp##l
1527#elif FLT128_MANT_DIG == 113
1528typedef _Float128 zig_f128;
1529#define zig_as_f128(fp, repr) fp##f128
1530#elif FLT64X_MANT_DIG == 113
1531typedef _Float64x zig_f128;
1532#define zig_as_f128(fp, repr) fp##f64x
1533#elif defined(__SIZEOF_FLOAT128__)
1534typedef __float128 zig_f128;
1535#define zig_as_f128(fp, repr) fp##q
1536#undef zig_as_special_f128
1537#define zig_as_special_f128(sign, name, arg, repr) sign __builtin_##name##f128(arg)
1538#else
1539#undef zig_has_f128
1540#define zig_has_f128 0
1541#define zig_repr_f128 i128
1542typedef zig_i128 zig_f128;
1543#define zig_as_f128(fp, repr) repr
1544#undef zig_as_special_f128
1545#define zig_as_special_f128(sign, name, arg, repr) repr
1546#endif
1547
1548#define zig_has_c_longdouble 1
1549typedef long double zig_c_longdouble;
1550#define zig_as_c_longdouble(fp, repr) fp##l
1551#define zig_libc_name_c_longdouble(name) name##l
1552#define zig_as_special_c_longdouble(sign, name, arg, repr) sign __builtin_##name##l(arg)
1553
1554#define zig_convert_builtin(ResType, operation, ArgType, version) \
1555 zig_extern_c zig_##ResType zig_expand_concat(zig_expand_concat(zig_expand_concat(__##operation, \
1556 zig_compiler_rt_abbrev_##ArgType), zig_compiler_rt_abbrev_##ResType), version)(zig_##ArgType);
1557zig_convert_builtin(f16, trunc, f32, 2)
1558zig_convert_builtin(f16, trunc, f64, 2)
1559zig_convert_builtin(f16, trunc, f80, 2)
1560zig_convert_builtin(f16, trunc, f128, 2)
1561zig_convert_builtin(f32, extend, f16, 2)
1562zig_convert_builtin(f32, trunc, f64, 2)
1563zig_convert_builtin(f32, trunc, f80, 2)
1564zig_convert_builtin(f32, trunc, f128, 2)
1565zig_convert_builtin(f64, extend, f16, 2)
1566zig_convert_builtin(f64, extend, f32, 2)
1567zig_convert_builtin(f64, trunc, f80, 2)
1568zig_convert_builtin(f64, trunc, f128, 2)
1569zig_convert_builtin(f80, extend, f16, 2)
1570zig_convert_builtin(f80, extend, f32, 2)
1571zig_convert_builtin(f80, extend, f64, 2)
1572zig_convert_builtin(f80, trunc, f128, 2)
1573zig_convert_builtin(f128, extend, f16, 2)
1574zig_convert_builtin(f128, extend, f32, 2)
1575zig_convert_builtin(f128, extend, f64, 2)
1576zig_convert_builtin(f128, extend, f80, 2)
1577
1578#define zig_float_negate_builtin_0(Type) \
1579 static inline zig_##Type zig_neg_##Type(zig_##Type arg) { \
1580 return zig_expand_concat(zig_xor_, zig_repr_##Type)(arg, zig_expand_minInt(zig_repr_##Type, zig_bitSizeOf_##Type)); \
1581 }
1582#define zig_float_negate_builtin_1(Type) \
1583 static inline zig_##Type zig_neg_##Type(zig_##Type arg) { \
1584 return -arg; \
1585 }
1586
1587#define zig_float_less_builtin_0(Type, operation) \
1588 zig_extern_c zig_i8 zig_expand_concat(zig_expand_concat(__##operation, \
1589 zig_compiler_rt_abbrev_##Type), 2)(zig_##Type, zig_##Type); \
1590 static inline zig_i8 zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
1591 return (zig_i8)zig_expand_concat(zig_expand_concat(__##operation, zig_compiler_rt_abbrev_##Type), 2)(lhs, rhs); \
1592 }
1593#define zig_float_less_builtin_1(Type, operation) \
1594 static inline zig_i8 zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
1595 return (zig_i8)(!(lhs <= rhs) - (lhs < rhs)); \
1596 }
1597
1598#define zig_float_greater_builtin_0(Type, operation) \
1599 zig_float_less_builtin_0(Type, operation)
1600#define zig_float_greater_builtin_1(Type, operation) \
1601 static inline zig_i8 zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
1602 return (zig_i8)((lhs > rhs) - !(lhs >= rhs)); \
1603 }
1604
1605#define zig_float_binary_builtin_0(Type, operation, operator) \
1606 zig_extern_c zig_##Type zig_expand_concat(zig_expand_concat(__##operation, \
1607 zig_compiler_rt_abbrev_##Type), 3)(zig_##Type, zig_##Type); \
1608 static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
1609 return zig_expand_concat(zig_expand_concat(__##operation, zig_compiler_rt_abbrev_##Type), 3)(lhs, rhs); \
1610 }
1611#define zig_float_binary_builtin_1(Type, operation, operator) \
1612 static inline zig_##Type zig_##operation##_##Type(zig_##Type lhs, zig_##Type rhs) { \
1613 return lhs operator rhs; \
1614 }
14641615
1465#define zig_float_builtins(Type) \1616#define zig_float_builtins(Type) \
1466 zig_extern_c zig_##Type zig_builtin_##Type(sqrt)(zig_##Type); \1617 zig_convert_builtin(i32, fix, Type, ) \
1467 zig_extern_c zig_##Type zig_builtin_##Type(sin)(zig_##Type); \1618 zig_convert_builtin(u32, fixuns, Type, ) \
1468 zig_extern_c zig_##Type zig_builtin_##Type(cos)(zig_##Type); \1619 zig_convert_builtin(i64, fix, Type, ) \
1469 zig_extern_c zig_##Type zig_builtin_##Type(tan)(zig_##Type); \1620 zig_convert_builtin(u64, fixuns, Type, ) \
1470 zig_extern_c zig_##Type zig_builtin_##Type(exp)(zig_##Type); \1621 zig_convert_builtin(i128, fix, Type, ) \
1471 zig_extern_c zig_##Type zig_builtin_##Type(exp2)(zig_##Type); \1622 zig_convert_builtin(u128, fixuns, Type, ) \
1472 zig_extern_c zig_##Type zig_builtin_##Type(log)(zig_##Type); \1623 zig_convert_builtin(Type, float, i32, ) \
1473 zig_extern_c zig_##Type zig_builtin_##Type(log2)(zig_##Type); \1624 zig_convert_builtin(Type, floatun, u32, ) \
1474 zig_extern_c zig_##Type zig_builtin_##Type(log10)(zig_##Type); \1625 zig_convert_builtin(Type, float, i64, ) \
1475 zig_extern_c zig_##Type zig_builtin_##Type(fabs)(zig_##Type); \1626 zig_convert_builtin(Type, floatun, u64, ) \
1476 zig_extern_c zig_##Type zig_builtin_##Type(floor)(zig_##Type); \1627 zig_convert_builtin(Type, float, i128, ) \
1477 zig_extern_c zig_##Type zig_builtin_##Type(ceil)(zig_##Type); \1628 zig_convert_builtin(Type, floatun, u128, ) \
1478 zig_extern_c zig_##Type zig_builtin_##Type(round)(zig_##Type); \1629 zig_expand_concat(zig_float_negate_builtin_, zig_has_##Type)(Type) \
1479 zig_extern_c zig_##Type zig_builtin_##Type(trunc)(zig_##Type); \1630 zig_expand_concat(zig_float_less_builtin_, zig_has_##Type)(Type, cmp) \
1480 zig_extern_c zig_##Type zig_builtin_##Type(fmod)(zig_##Type, zig_##Type); \1631 zig_expand_concat(zig_float_less_builtin_, zig_has_##Type)(Type, ne) \
1481 zig_extern_c zig_##Type zig_builtin_##Type(fma)(zig_##Type, zig_##Type, zig_##Type); \1632 zig_expand_concat(zig_float_less_builtin_, zig_has_##Type)(Type, eq) \
1633 zig_expand_concat(zig_float_less_builtin_, zig_has_##Type)(Type, lt) \
1634 zig_expand_concat(zig_float_less_builtin_, zig_has_##Type)(Type, le) \
1635 zig_expand_concat(zig_float_greater_builtin_, zig_has_##Type)(Type, gt) \
1636 zig_expand_concat(zig_float_greater_builtin_, zig_has_##Type)(Type, ge) \
1637 zig_expand_concat(zig_float_binary_builtin_, zig_has_##Type)(Type, add, +) \
1638 zig_expand_concat(zig_float_binary_builtin_, zig_has_##Type)(Type, sub, -) \
1639 zig_expand_concat(zig_float_binary_builtin_, zig_has_##Type)(Type, mul, *) \
1640 zig_expand_concat(zig_float_binary_builtin_, zig_has_##Type)(Type, div, /) \
1641 zig_extern_c zig_##Type zig_libc_name_##Type(sqrt)(zig_##Type); \
1642 zig_extern_c zig_##Type zig_libc_name_##Type(sin)(zig_##Type); \
1643 zig_extern_c zig_##Type zig_libc_name_##Type(cos)(zig_##Type); \
1644 zig_extern_c zig_##Type zig_libc_name_##Type(tan)(zig_##Type); \
1645 zig_extern_c zig_##Type zig_libc_name_##Type(exp)(zig_##Type); \
1646 zig_extern_c zig_##Type zig_libc_name_##Type(exp2)(zig_##Type); \
1647 zig_extern_c zig_##Type zig_libc_name_##Type(log)(zig_##Type); \
1648 zig_extern_c zig_##Type zig_libc_name_##Type(log2)(zig_##Type); \
1649 zig_extern_c zig_##Type zig_libc_name_##Type(log10)(zig_##Type); \
1650 zig_extern_c zig_##Type zig_libc_name_##Type(fabs)(zig_##Type); \
1651 zig_extern_c zig_##Type zig_libc_name_##Type(floor)(zig_##Type); \
1652 zig_extern_c zig_##Type zig_libc_name_##Type(ceil)(zig_##Type); \
1653 zig_extern_c zig_##Type zig_libc_name_##Type(round)(zig_##Type); \
1654 zig_extern_c zig_##Type zig_libc_name_##Type(trunc)(zig_##Type); \
1655 zig_extern_c zig_##Type zig_libc_name_##Type(fmod)(zig_##Type, zig_##Type); \
1656 zig_extern_c zig_##Type zig_libc_name_##Type(fmin)(zig_##Type, zig_##Type); \
1657 zig_extern_c zig_##Type zig_libc_name_##Type(fmax)(zig_##Type, zig_##Type); \
1658 zig_extern_c zig_##Type zig_libc_name_##Type(fma)(zig_##Type, zig_##Type, zig_##Type); \
1482\1659\
1483 static inline zig_##Type zig_div_trunc_##Type(zig_##Type lhs, zig_##Type rhs) { \1660 static inline zig_##Type zig_div_trunc_##Type(zig_##Type lhs, zig_##Type rhs) { \
1484 return zig_builtin_##Type(trunc)(lhs / rhs); \1661 return zig_libc_name_##Type(trunc)(zig_div_##Type(lhs, rhs)); \
1485 } \1662 } \
1486\1663\
1487 static inline zig_##Type zig_div_floor_##Type(zig_##Type lhs, zig_##Type rhs) { \1664 static inline zig_##Type zig_div_floor_##Type(zig_##Type lhs, zig_##Type rhs) { \
1488 return zig_builtin_##Type(floor)(lhs / rhs); \1665 return zig_libc_name_##Type(floor)(zig_div_##Type(lhs, rhs)); \
1489 } \1666 } \
1490\1667\
1491 static inline zig_##Type zig_mod_##Type(zig_##Type lhs, zig_##Type rhs) { \1668 static inline zig_##Type zig_mod_##Type(zig_##Type lhs, zig_##Type rhs) { \
1492 return lhs - zig_div_floor_##Type(lhs, rhs) * rhs; \1669 return zig_sub_##Type(lhs, zig_mul_##Type(zig_div_floor_##Type(lhs, rhs), rhs)); \
1493 }1670 }
1494zig_float_builtins(f16)1671zig_float_builtins(f16)
1495zig_float_builtins(f32)1672zig_float_builtins(f32)
lib/std/start.zig+9-1
...@@ -281,7 +281,15 @@ fn _start() callconv(.Naked) noreturn {...@@ -281,7 +281,15 @@ fn _start() callconv(.Naked) noreturn {
281 \\ andl $-16, %%esp281 \\ andl $-16, %%esp
282 \\ jmp _posixCallMainAndExit282 \\ jmp _posixCallMainAndExit
283 ),283 ),
284 .aarch64, .aarch64_be, .arm, .armeb, .thumb => asm volatile (284 .aarch64, .aarch64_be => asm volatile (
285 \\ mov fp, #0
286 \\ mov lr, #0
287 \\ mov x0, sp
288 \\ adrp x1, argc_argv_ptr
289 \\ str x0, [x1, :lo12:argc_argv_ptr]
290 \\ b _posixCallMainAndExit
291 ),
292 .arm, .armeb, .thumb => asm volatile (
285 \\ mov fp, #0293 \\ mov fp, #0
286 \\ mov lr, #0294 \\ mov lr, #0
287 \\ str sp, argc_argv_ptr295 \\ str sp, argc_argv_ptr
lib/test_runner.zig+2-1
...@@ -130,7 +130,8 @@ pub fn main2() anyerror!void {...@@ -130,7 +130,8 @@ pub fn main2() anyerror!void {
130 }130 }
131 if (builtin.zig_backend == .stage2_wasm or131 if (builtin.zig_backend == .stage2_wasm or
132 builtin.zig_backend == .stage2_x86_64 or132 builtin.zig_backend == .stage2_x86_64 or
133 builtin.zig_backend == .stage2_llvm)133 builtin.zig_backend == .stage2_llvm or
134 builtin.zig_backend == .stage2_c)
134 {135 {
135 const passed = builtin.test_functions.len - skipped - failed;136 const passed = builtin.test_functions.len - skipped - failed;
136 const stderr = std.io.getStdErr();137 const stderr = std.io.getStdErr();
src/codegen/c.zig+188-91
...@@ -19,6 +19,7 @@ const Liveness = @import("../Liveness.zig");...@@ -19,6 +19,7 @@ const Liveness = @import("../Liveness.zig");
19const CType = @import("../type.zig").CType;19const CType = @import("../type.zig").CType;
2020
21const Mutability = enum { Const, ConstArgument, Mut };21const Mutability = enum { Const, ConstArgument, Mut };
22const BigIntLimb = std.math.big.Limb;
22const BigInt = std.math.big.int;23const BigInt = std.math.big.int;
2324
24pub const CValue = union(enum) {25pub const CValue = union(enum) {
...@@ -608,19 +609,25 @@ pub const DeclGen = struct {...@@ -608,19 +609,25 @@ pub const DeclGen = struct {
608 .Bool => return dg.renderValue(writer, ty, Value.@"false", location),609 .Bool => return dg.renderValue(writer, ty, Value.@"false", location),
609 .Int, .Enum, .ErrorSet => return writer.print("{x}", .{try dg.fmtIntLiteral(ty, val)}),610 .Int, .Enum, .ErrorSet => return writer.print("{x}", .{try dg.fmtIntLiteral(ty, val)}),
610 .Float => {611 .Float => {
612 const bits = ty.floatBits(target);
613 var int_pl = Type.Payload.Bits{ .base = .{ .tag = .int_signed }, .data = bits };
614 const int_ty = Type.initPayload(&int_pl.base);
615
611 try writer.writeByte('(');616 try writer.writeByte('(');
612 try dg.renderTypecast(writer, ty);617 try dg.renderTypecast(writer, ty);
613 try writer.writeAll(")zig_suffix_");618 try writer.writeAll(")zig_as_");
614 try dg.renderTypeForBuiltinFnName(writer, ty);619 try dg.renderTypeForBuiltinFnName(writer, ty);
615 try writer.writeByte('(');620 try writer.writeByte('(');
616 switch (ty.floatBits(target)) {621 switch (bits) {
617 16 => try writer.print("{x}", .{@bitCast(f16, undefPattern(u16))}),622 16 => try writer.print("{x}", .{@bitCast(f16, undefPattern(i16))}),
618 32 => try writer.print("{x}", .{@bitCast(f32, undefPattern(u32))}),623 32 => try writer.print("{x}", .{@bitCast(f32, undefPattern(i32))}),
619 64 => try writer.print("{x}", .{@bitCast(f64, undefPattern(u64))}),624 64 => try writer.print("{x}", .{@bitCast(f64, undefPattern(i64))}),
620 80 => try writer.print("{x}", .{@bitCast(f80, undefPattern(u80))}),625 80 => try writer.print("{x}", .{@bitCast(f80, undefPattern(i80))}),
621 128 => try writer.print("{x}", .{@bitCast(f128, undefPattern(u128))}),626 128 => try writer.print("{x}", .{@bitCast(f128, undefPattern(i128))}),
622 else => unreachable,627 else => unreachable,
623 }628 }
629 try writer.writeAll(", ");
630 try dg.renderValue(writer, int_ty, Value.undef, .FunctionArgument);
624 return writer.writeByte(')');631 return writer.writeByte(')');
625 },632 },
626 .Pointer => if (ty.isSlice()) {633 .Pointer => if (ty.isSlice()) {
...@@ -770,21 +777,48 @@ pub const DeclGen = struct {...@@ -770,21 +777,48 @@ pub const DeclGen = struct {
770 else => try writer.print("{}", .{try dg.fmtIntLiteral(ty, val)}),777 else => try writer.print("{}", .{try dg.fmtIntLiteral(ty, val)}),
771 },778 },
772 .Float => {779 .Float => {
780 const bits = ty.floatBits(target);
781 const f128_val = val.toFloat(f128);
782
783 var int_ty_pl = Type.Payload.Bits{ .base = .{ .tag = .int_signed }, .data = bits };
784 const int_ty = Type.initPayload(&int_ty_pl.base);
785
786 assert(bits <= 128);
787 var int_val_limbs: [BigInt.calcTwosCompLimbCount(128)]BigIntLimb = undefined;
788 var int_val_big = BigInt.Mutable{
789 .limbs = &int_val_limbs,
790 .len = undefined,
791 .positive = undefined,
792 };
793
794 switch (bits) {
795 16 => int_val_big.set(@bitCast(i16, val.toFloat(f16))),
796 32 => int_val_big.set(@bitCast(i32, val.toFloat(f32))),
797 64 => int_val_big.set(@bitCast(i64, val.toFloat(f64))),
798 80 => int_val_big.set(@bitCast(i80, val.toFloat(f80))),
799 128 => int_val_big.set(@bitCast(i128, f128_val)),
800 else => unreachable,
801 }
802
803 var int_val_pl = Value.Payload.BigInt{
804 .base = .{ .tag = if (int_val_big.positive) .int_big_positive else .int_big_negative },
805 .data = int_val_big.limbs[0..int_val_big.len],
806 };
807 const int_val = Value.initPayload(&int_val_pl.base);
808
773 try writer.writeByte('(');809 try writer.writeByte('(');
774 try dg.renderTypecast(writer, ty);810 try dg.renderTypecast(writer, ty);
775 try writer.writeByte(')');811 try writer.writeByte(')');
776 const f128_val = val.toFloat(f128);
777 if (std.math.signbit(f128_val)) try writer.writeByte('-');
778 if (std.math.isFinite(f128_val)) {812 if (std.math.isFinite(f128_val)) {
779 try writer.writeAll("zig_suffix_");813 try writer.writeAll("zig_as_");
780 try dg.renderTypeForBuiltinFnName(writer, ty);814 try dg.renderTypeForBuiltinFnName(writer, ty);
781 try writer.writeByte('(');815 try writer.writeByte('(');
782 switch (ty.floatBits(target)) {816 switch (bits) {
783 16 => try writer.print("{x}", .{@fabs(val.toFloat(f16))}),817 16 => try writer.print("{x}", .{val.toFloat(f16)}),
784 32 => try writer.print("{x}", .{@fabs(val.toFloat(f32))}),818 32 => try writer.print("{x}", .{val.toFloat(f32)}),
785 64 => try writer.print("{x}", .{@fabs(val.toFloat(f64))}),819 64 => try writer.print("{x}", .{val.toFloat(f64)}),
786 80 => try writer.print("{x}", .{@fabs(val.toFloat(f80))}),820 80 => try writer.print("{x}", .{val.toFloat(f80)}),
787 128 => try writer.print("{x}", .{@fabs(f128_val)}),821 128 => try writer.print("{x}", .{f128_val}),
788 else => unreachable,822 else => unreachable,
789 }823 }
790 } else {824 } else {
...@@ -796,23 +830,26 @@ pub const DeclGen = struct {...@@ -796,23 +830,26 @@ pub const DeclGen = struct {
796 "inf"830 "inf"
797 else831 else
798 unreachable;832 unreachable;
799 try writer.writeAll("zig_builtin_constant_");833
834 try writer.writeAll("zig_as_special_");
800 try dg.renderTypeForBuiltinFnName(writer, ty);835 try dg.renderTypeForBuiltinFnName(writer, ty);
801 try writer.writeByte('(');836 try writer.writeByte('(');
837 if (std.math.signbit(f128_val)) try writer.writeByte('-');
838 try writer.writeAll(", ");
802 try writer.writeAll(operation);839 try writer.writeAll(operation);
803 try writer.writeAll(")(");840 try writer.writeAll(", ");
804 if (std.math.isNan(f128_val)) switch (ty.floatBits(target)) {841 if (std.math.isNan(f128_val)) switch (bits) {
805 // We only actually need to pass the significand, but it will get842 // We only actually need to pass the significand, but it will get
806 // properly masked anyway, so just pass the whole value.843 // properly masked anyway, so just pass the whole value.
807 16 => try writer.print("\"0x{x}\"", .{@bitCast(u16, @fabs(val.toFloat(f16)))}),844 16 => try writer.print("\"0x{x}\"", .{@bitCast(u16, val.toFloat(f16))}),
808 32 => try writer.print("\"0x{x}\"", .{@bitCast(u32, @fabs(val.toFloat(f32)))}),845 32 => try writer.print("\"0x{x}\"", .{@bitCast(u32, val.toFloat(f32))}),
809 64 => try writer.print("\"0x{x}\"", .{@bitCast(u64, @fabs(val.toFloat(f64)))}),846 64 => try writer.print("\"0x{x}\"", .{@bitCast(u64, val.toFloat(f64))}),
810 80 => try writer.print("\"0x{x}\"", .{@bitCast(u80, @fabs(val.toFloat(f80)))}),847 80 => try writer.print("\"0x{x}\"", .{@bitCast(u80, val.toFloat(f80))}),
811 128 => try writer.print("\"0x{x}\"", .{@bitCast(u128, @fabs(f128_val))}),848 128 => try writer.print("\"0x{x}\"", .{@bitCast(u128, f128_val)}),
812 else => unreachable,849 else => unreachable,
813 };850 };
814 }851 }
815 return writer.writeByte(')');852 return writer.print(", {x})", .{try dg.fmtIntLiteral(int_ty, int_val)});
816 },853 },
817 .Pointer => switch (val.tag()) {854 .Pointer => switch (val.tag()) {
818 .null_value, .zero => if (ty.isSlice()) {855 .null_value, .zero => if (ty.isSlice()) {
...@@ -2299,11 +2336,14 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO...@@ -2299,11 +2336,14 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
22992336
2300 // TODO use a different strategy for add, sub, mul, div2337 // TODO use a different strategy for add, sub, mul, div
2301 // that communicates to the optimizer that wrapping is UB.2338 // that communicates to the optimizer that wrapping is UB.
2302 .add => try airBinOp(f, inst, "+", "add", .None),2339 .add => try airBinOp(f, inst, "+", "add", .None),
2303 .sub => try airBinOp(f, inst, "-", "sub", .None),2340 .sub => try airBinOp(f, inst, "-", "sub", .None),
2304 .mul => try airBinOp(f, inst, "*", "mul", .None),2341 .mul => try airBinOp(f, inst, "*", "mul", .None),
2305 .div_float, .div_exact => try airBinOp(f, inst, "/", "div_trunc", .None),2342
2343 .neg => try airFloatNeg(f, inst),
2344 .div_float => try airBinBuiltinCall(f, inst, "div", .None),
23062345
2346 .div_trunc, .div_exact => try airBinOp(f, inst, "/", "div_trunc", .None),
2307 .rem => blk: {2347 .rem => blk: {
2308 const bin_op = f.air.instructions.items(.data)[inst].bin_op;2348 const bin_op = f.air.instructions.items(.data)[inst].bin_op;
2309 const lhs_ty = f.air.typeOf(bin_op.lhs);2349 const lhs_ty = f.air.typeOf(bin_op.lhs);
...@@ -2314,16 +2354,6 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO...@@ -2314,16 +2354,6 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
2314 else2354 else
2315 try airBinFloatOp(f, inst, "fmod");2355 try airBinFloatOp(f, inst, "fmod");
2316 },2356 },
2317 .div_trunc => blk: {
2318 const bin_op = f.air.instructions.items(.data)[inst].bin_op;
2319 const lhs_ty = f.air.typeOf(bin_op.lhs);
2320 // For binary operations @TypeOf(lhs)==@TypeOf(rhs),
2321 // so we only check one.
2322 break :blk if (lhs_ty.isInt())
2323 try airBinOp(f, inst, "/", "div_trunc", .None)
2324 else
2325 try airBinBuiltinCall(f, inst, "div_trunc", .None);
2326 },
2327 .div_floor => try airBinBuiltinCall(f, inst, "div_floor", .None),2357 .div_floor => try airBinBuiltinCall(f, inst, "div_floor", .None),
2328 .mod => try airBinBuiltinCall(f, inst, "mod", .None),2358 .mod => try airBinBuiltinCall(f, inst, "mod", .None),
23292359
...@@ -2336,8 +2366,6 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO...@@ -2336,8 +2366,6 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
2336 .mul_sat => try airBinBuiltinCall(f, inst, "muls", .Bits),2366 .mul_sat => try airBinBuiltinCall(f, inst, "muls", .Bits),
2337 .shl_sat => try airBinBuiltinCall(f, inst, "shls", .Bits),2367 .shl_sat => try airBinBuiltinCall(f, inst, "shls", .Bits),
23382368
2339 .neg => try airNeg(f, inst),
2340
2341 .sqrt,2369 .sqrt,
2342 .sin,2370 .sin,
2343 .cos,2371 .cos,
...@@ -2361,18 +2389,18 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO...@@ -2361,18 +2389,18 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
2361 .mul_with_overflow => try airOverflow(f, inst, "mul", .Bits),2389 .mul_with_overflow => try airOverflow(f, inst, "mul", .Bits),
2362 .shl_with_overflow => try airOverflow(f, inst, "shl", .Bits),2390 .shl_with_overflow => try airOverflow(f, inst, "shl", .Bits),
23632391
2364 .min => try airMinMax(f, inst, '<'),2392 .min => try airMinMax(f, inst, '<', "fmin"),
2365 .max => try airMinMax(f, inst, '>'),2393 .max => try airMinMax(f, inst, '>', "fmax"),
23662394
2367 .slice => try airSlice(f, inst),2395 .slice => try airSlice(f, inst),
23682396
2369 .cmp_gt => try airCmpOp(f, inst, ">"),2397 .cmp_gt => try airCmpOp(f, inst, ">", "gt"),
2370 .cmp_gte => try airCmpOp(f, inst, ">="),2398 .cmp_gte => try airCmpOp(f, inst, ">=", "ge"),
2371 .cmp_lt => try airCmpOp(f, inst, "<"),2399 .cmp_lt => try airCmpOp(f, inst, "<", "lt"),
2372 .cmp_lte => try airCmpOp(f, inst, "<="),2400 .cmp_lte => try airCmpOp(f, inst, "<=", "le"),
23732401
2374 .cmp_eq => try airEquality(f, inst, "((", "=="),2402 .cmp_eq => try airEquality(f, inst, "((", "==", "eq"),
2375 .cmp_neq => try airEquality(f, inst, "!((", "!="),2403 .cmp_neq => try airEquality(f, inst, "!((", "!=", "ne"),
23762404
2377 .cmp_vector => return f.fail("TODO: C backend: implement cmp_vector", .{}),2405 .cmp_vector => return f.fail("TODO: C backend: implement cmp_vector", .{}),
2378 .cmp_lt_errors_len => try airCmpLtErrorsLen(f, inst),2406 .cmp_lt_errors_len => try airCmpLtErrorsLen(f, inst),
...@@ -2468,7 +2496,7 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO...@@ -2468,7 +2496,7 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
2468 .float_to_int,2496 .float_to_int,
2469 .fptrunc,2497 .fptrunc,
2470 .fpext,2498 .fpext,
2471 => try airSimpleCast(f, inst),2499 => try airFloatCast(f, inst),
24722500
2473 .ptrtoint => try airPtrToInt(f, inst),2501 .ptrtoint => try airPtrToInt(f, inst),
24742502
...@@ -2973,8 +3001,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index) !CValue {...@@ -2973,8 +3001,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index) !CValue {
29733001
2974 const src_bits = src_ty.bitSize(target);3002 const src_bits = src_ty.bitSize(target);
29753003
2976 const Limb = std.math.big.Limb;3004 const ExpectedContents = [BigInt.Managed.default_capacity]BigIntLimb;
2977 const ExpectedContents = [BigInt.Managed.default_capacity]Limb;
2978 var stack align(@alignOf(ExpectedContents)) =3005 var stack align(@alignOf(ExpectedContents)) =
2979 std.heap.stackFallback(@sizeOf(ExpectedContents), f.object.dg.gpa);3006 std.heap.stackFallback(@sizeOf(ExpectedContents), f.object.dg.gpa);
29803007
...@@ -3081,7 +3108,7 @@ fn airBinOp(...@@ -3081,7 +3108,7 @@ fn airBinOp(
30813108
3082 const operand_ty = f.air.typeOf(bin_op.lhs);3109 const operand_ty = f.air.typeOf(bin_op.lhs);
3083 const target = f.object.dg.module.getTarget();3110 const target = f.object.dg.module.getTarget();
3084 if (operand_ty.isInt() and operand_ty.bitSize(target) > 64)3111 if ((operand_ty.isInt() and operand_ty.bitSize(target) > 64) or operand_ty.isRuntimeFloat())
3085 return try airBinBuiltinCall(f, inst, operation, info);3112 return try airBinBuiltinCall(f, inst, operation, info);
30863113
3087 const inst_ty = f.air.typeOfIndex(inst);3114 const inst_ty = f.air.typeOfIndex(inst);
...@@ -3102,7 +3129,7 @@ fn airBinOp(...@@ -3102,7 +3129,7 @@ fn airBinOp(
3102 return local;3129 return local;
3103}3130}
31043131
3105fn airCmpOp(f: *Function, inst: Air.Inst.Index, operator: []const u8) !CValue {3132fn airCmpOp(f: *Function, inst: Air.Inst.Index, operator: []const u8, operation: []const u8) !CValue {
3106 if (f.liveness.isUnused(inst)) return CValue.none;3133 if (f.liveness.isUnused(inst)) return CValue.none;
31073134
3108 const bin_op = f.air.instructions.items(.data)[inst].bin_op;3135 const bin_op = f.air.instructions.items(.data)[inst].bin_op;
...@@ -3110,7 +3137,9 @@ fn airCmpOp(f: *Function, inst: Air.Inst.Index, operator: []const u8) !CValue {...@@ -3110,7 +3137,9 @@ fn airCmpOp(f: *Function, inst: Air.Inst.Index, operator: []const u8) !CValue {
3110 const operand_ty = f.air.typeOf(bin_op.lhs);3137 const operand_ty = f.air.typeOf(bin_op.lhs);
3111 const target = f.object.dg.module.getTarget();3138 const target = f.object.dg.module.getTarget();
3112 if (operand_ty.isInt() and operand_ty.bitSize(target) > 64)3139 if (operand_ty.isInt() and operand_ty.bitSize(target) > 64)
3113 return try airCmpBuiltinCall(f, inst, operator);3140 return try airCmpBuiltinCall(f, inst, operator, "cmp");
3141 if (operand_ty.isRuntimeFloat())
3142 return try airCmpBuiltinCall(f, inst, operator, operation);
31143143
3115 const inst_ty = f.air.typeOfIndex(inst);3144 const inst_ty = f.air.typeOfIndex(inst);
3116 const lhs = try f.resolveInst(bin_op.lhs);3145 const lhs = try f.resolveInst(bin_op.lhs);
...@@ -3134,11 +3163,20 @@ fn airEquality(...@@ -3134,11 +3163,20 @@ fn airEquality(
3134 f: *Function,3163 f: *Function,
3135 inst: Air.Inst.Index,3164 inst: Air.Inst.Index,
3136 negate_prefix: []const u8,3165 negate_prefix: []const u8,
3137 eq_op_str: []const u8,3166 operator: []const u8,
3167 operation: []const u8,
3138) !CValue {3168) !CValue {
3139 if (f.liveness.isUnused(inst)) return CValue.none;3169 if (f.liveness.isUnused(inst)) return CValue.none;
31403170
3141 const bin_op = f.air.instructions.items(.data)[inst].bin_op;3171 const bin_op = f.air.instructions.items(.data)[inst].bin_op;
3172
3173 const operand_ty = f.air.typeOf(bin_op.lhs);
3174 const target = f.object.dg.module.getTarget();
3175 if (operand_ty.isInt() and operand_ty.bitSize(target) > 64)
3176 return try airCmpBuiltinCall(f, inst, operator, "cmp");
3177 if (operand_ty.isRuntimeFloat())
3178 return try airCmpBuiltinCall(f, inst, operator, operation);
3179
3142 const lhs = try f.resolveInst(bin_op.lhs);3180 const lhs = try f.resolveInst(bin_op.lhs);
3143 const rhs = try f.resolveInst(bin_op.rhs);3181 const rhs = try f.resolveInst(bin_op.rhs);
31443182
...@@ -3148,8 +3186,7 @@ fn airEquality(...@@ -3148,8 +3186,7 @@ fn airEquality(
31483186
3149 try writer.writeAll(" = ");3187 try writer.writeAll(" = ");
31503188
3151 const lhs_ty = f.air.typeOf(bin_op.lhs);3189 if (operand_ty.tag() == .optional) {
3152 if (lhs_ty.tag() == .optional) {
3153 // (A && B) || (C && (A == B))3190 // (A && B) || (C && (A == B))
3154 // A = lhs.is_null ; B = rhs.is_null ; C = rhs.payload == lhs.payload3191 // A = lhs.is_null ; B = rhs.is_null ; C = rhs.payload == lhs.payload
31553192
...@@ -3172,7 +3209,7 @@ fn airEquality(...@@ -3172,7 +3209,7 @@ fn airEquality(
31723209
3173 try f.writeCValue(writer, lhs, .Other);3210 try f.writeCValue(writer, lhs, .Other);
3174 try writer.writeByte(' ');3211 try writer.writeByte(' ');
3175 try writer.writeAll(eq_op_str);3212 try writer.writeAll(operator);
3176 try writer.writeByte(' ');3213 try writer.writeByte(' ');
3177 try f.writeCValue(writer, rhs, .Other);3214 try f.writeCValue(writer, rhs, .Other);
3178 try writer.writeAll(";\n");3215 try writer.writeAll(";\n");
...@@ -3231,15 +3268,22 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {...@@ -3231,15 +3268,22 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
3231 return local;3268 return local;
3232}3269}
32333270
3234fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {3271fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []const u8) !CValue {
3235 if (f.liveness.isUnused(inst)) return CValue.none;3272 if (f.liveness.isUnused(inst)) return CValue.none;
32363273
3237 const bin_op = f.air.instructions.items(.data)[inst].bin_op;3274 const bin_op = f.air.instructions.items(.data)[inst].bin_op;
3275
3276 const inst_ty = f.air.typeOfIndex(inst);
3277 const target = f.object.dg.module.getTarget();
3278 if (inst_ty.isInt() and inst_ty.bitSize(target) > 64)
3279 return try airBinBuiltinCall(f, inst, operation[1..], .None);
3280 if (inst_ty.isRuntimeFloat())
3281 return try airBinFloatOp(f, inst, operation);
3282
3238 const lhs = try f.resolveInst(bin_op.lhs);3283 const lhs = try f.resolveInst(bin_op.lhs);
3239 const rhs = try f.resolveInst(bin_op.rhs);3284 const rhs = try f.resolveInst(bin_op.rhs);
32403285
3241 const writer = f.object.writer();3286 const writer = f.object.writer();
3242 const inst_ty = f.air.typeOfIndex(inst);
3243 const local = try f.allocLocal(inst_ty, .Const);3287 const local = try f.allocLocal(inst_ty, .Const);
32443288
3245 // (lhs <> rhs) ? lhs : rhs3289 // (lhs <> rhs) ? lhs : rhs
...@@ -4518,19 +4562,44 @@ fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue {...@@ -4518,19 +4562,44 @@ fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue {
4518 return local;4562 return local;
4519}4563}
45204564
4521/// Emits a local variable with the result type and initializes it4565fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue {
4522/// with the operand.
4523fn airSimpleCast(f: *Function, inst: Air.Inst.Index) !CValue {
4524 if (f.liveness.isUnused(inst)) return CValue.none;4566 if (f.liveness.isUnused(inst)) return CValue.none;
45254567
4526 const inst_ty = f.air.typeOfIndex(inst);4568 const inst_ty = f.air.typeOfIndex(inst);
4527 const local = try f.allocLocal(inst_ty, .Const);
4528 const ty_op = f.air.instructions.items(.data)[inst].ty_op;4569 const ty_op = f.air.instructions.items(.data)[inst].ty_op;
4529 const writer = f.object.writer();
4530 const operand = try f.resolveInst(ty_op.operand);4570 const operand = try f.resolveInst(ty_op.operand);
4571 const operand_ty = f.air.typeOf(ty_op.operand);
4572 const target = f.object.dg.module.getTarget();
4573 const operation = if (inst_ty.isRuntimeFloat() and operand_ty.isRuntimeFloat())
4574 if (inst_ty.floatBits(target) < operand_ty.floatBits(target)) "trunc" else "extend"
4575 else if (inst_ty.isInt() and operand_ty.isRuntimeFloat())
4576 if (inst_ty.isSignedInt()) "fix" else "fixuns"
4577 else if (inst_ty.isRuntimeFloat() and operand_ty.isInt())
4578 if (operand_ty.isSignedInt()) "float" else "floatun"
4579 else
4580 unreachable;
4581
4582 const local = try f.allocLocal(inst_ty, .Const);
4583 const writer = f.object.writer();
45314584
4532 try writer.writeAll(" = ");4585 try writer.writeAll(" = ");
4533 try f.writeCValue(writer, operand, .Other);4586 if (inst_ty.isInt() and operand_ty.isRuntimeFloat()) {
4587 try writer.writeAll("zig_wrap_");
4588 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);
4589 try writer.writeByte('(');
4590 }
4591 try writer.writeAll("__");
4592 try writer.writeAll(operation);
4593 try writer.writeAll(compilerRtAbbrev(operand_ty, target));
4594 try writer.writeAll(compilerRtAbbrev(inst_ty, target));
4595 if (inst_ty.isRuntimeFloat() and operand_ty.isRuntimeFloat()) try writer.writeByte('2');
4596 try writer.writeByte('(');
4597 try f.writeCValue(writer, operand, .FunctionArgument);
4598 try writer.writeByte(')');
4599 if (inst_ty.isInt() and operand_ty.isRuntimeFloat()) {
4600 try f.object.dg.renderBuiltinInfo(writer, inst_ty, .Bits);
4601 try writer.writeByte(')');
4602 }
4534 try writer.writeAll(";\n");4603 try writer.writeAll(";\n");
4535 return local;4604 return local;
4536}4605}
...@@ -4604,7 +4673,12 @@ fn airBinBuiltinCall(...@@ -4604,7 +4673,12 @@ fn airBinBuiltinCall(
4604 return local;4673 return local;
4605}4674}
46064675
4607fn airCmpBuiltinCall(f: *Function, inst: Air.Inst.Index, operator: []const u8) !CValue {4676fn airCmpBuiltinCall(
4677 f: *Function,
4678 inst: Air.Inst.Index,
4679 operator: []const u8,
4680 operation: []const u8,
4681) !CValue {
4608 if (f.liveness.isUnused(inst)) return CValue.none;4682 if (f.liveness.isUnused(inst)) return CValue.none;
46094683
4610 const inst_ty = f.air.typeOfIndex(inst);4684 const inst_ty = f.air.typeOfIndex(inst);
...@@ -4613,7 +4687,9 @@ fn airCmpBuiltinCall(f: *Function, inst: Air.Inst.Index, operator: []const u8) !...@@ -4613,7 +4687,9 @@ fn airCmpBuiltinCall(f: *Function, inst: Air.Inst.Index, operator: []const u8) !
46134687
4614 const local = try f.allocLocal(inst_ty, .Const);4688 const local = try f.allocLocal(inst_ty, .Const);
4615 const writer = f.object.writer();4689 const writer = f.object.writer();
4616 try writer.writeAll(" = zig_cmp_");4690 try writer.writeAll(" = zig_");
4691 try writer.writeAll(operation);
4692 try writer.writeByte('_');
4617 try f.object.dg.renderTypeForBuiltinFnName(writer, operand_ty);4693 try f.object.dg.renderTypeForBuiltinFnName(writer, operand_ty);
4618 try writer.writeByte('(');4694 try writer.writeByte('(');
4619 try f.writeCValue(writer, try f.resolveInst(bin_op.lhs), .FunctionArgument);4695 try f.writeCValue(writer, try f.resolveInst(bin_op.lhs), .FunctionArgument);
...@@ -5157,17 +5233,21 @@ fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue {...@@ -5157,17 +5233,21 @@ fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue {
5157 return local;5233 return local;
5158}5234}
51595235
5160fn airNeg(f: *Function, inst: Air.Inst.Index) !CValue {5236fn airFloatNeg(f: *Function, inst: Air.Inst.Index) !CValue {
5161 if (f.liveness.isUnused(inst)) return CValue.none;5237 if (f.liveness.isUnused(inst)) return CValue.none;
51625238
5163 const un_op = f.air.instructions.items(.data)[inst].un_op;
5164 const writer = f.object.writer();
5165 const inst_ty = f.air.typeOfIndex(inst);5239 const inst_ty = f.air.typeOfIndex(inst);
5240 const un_op = f.air.instructions.items(.data)[inst].un_op;
5166 const operand = try f.resolveInst(un_op);5241 const operand = try f.resolveInst(un_op);
5242 const operand_ty = f.air.typeOf(un_op);
5243
5167 const local = try f.allocLocal(inst_ty, .Const);5244 const local = try f.allocLocal(inst_ty, .Const);
5168 try writer.writeAll(" = -");5245 const writer = f.object.writer();
5169 try f.writeCValue(writer, operand, .Other);5246 try writer.writeAll(" = zig_neg_");
5170 try writer.writeAll(";\n");5247 try f.object.dg.renderTypeForBuiltinFnName(writer, operand_ty);
5248 try writer.writeByte('(');
5249 try f.writeCValue(writer, operand, .FunctionArgument);
5250 try writer.writeAll(");\n");
5171 return local;5251 return local;
5172}5252}
51735253
...@@ -5178,7 +5258,7 @@ fn airUnFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CVal...@@ -5178,7 +5258,7 @@ fn airUnFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CVal
5178 const inst_ty = f.air.typeOfIndex(inst);5258 const inst_ty = f.air.typeOfIndex(inst);
5179 const operand = try f.resolveInst(un_op);5259 const operand = try f.resolveInst(un_op);
5180 const local = try f.allocLocal(inst_ty, .Const);5260 const local = try f.allocLocal(inst_ty, .Const);
5181 try writer.writeAll(" = zig_builtin_");5261 try writer.writeAll(" = zig_libc_name_");
5182 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);5262 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);
5183 try writer.writeByte('(');5263 try writer.writeByte('(');
5184 try writer.writeAll(operation);5264 try writer.writeAll(operation);
...@@ -5196,7 +5276,7 @@ fn airBinFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CVa...@@ -5196,7 +5276,7 @@ fn airBinFloatOp(f: *Function, inst: Air.Inst.Index, operation: []const u8) !CVa
5196 const lhs = try f.resolveInst(bin_op.lhs);5276 const lhs = try f.resolveInst(bin_op.lhs);
5197 const rhs = try f.resolveInst(bin_op.rhs);5277 const rhs = try f.resolveInst(bin_op.rhs);
5198 const local = try f.allocLocal(inst_ty, .Const);5278 const local = try f.allocLocal(inst_ty, .Const);
5199 try writer.writeAll(" = zig_builtin_");5279 try writer.writeAll(" = zig_libc_name_");
5200 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);5280 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);
5201 try writer.writeByte('(');5281 try writer.writeByte('(');
5202 try writer.writeAll(operation);5282 try writer.writeAll(operation);
...@@ -5218,7 +5298,7 @@ fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {...@@ -5218,7 +5298,7 @@ fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue {
5218 const addend = try f.resolveInst(pl_op.operand);5298 const addend = try f.resolveInst(pl_op.operand);
5219 const writer = f.object.writer();5299 const writer = f.object.writer();
5220 const local = try f.allocLocal(inst_ty, .Const);5300 const local = try f.allocLocal(inst_ty, .Const);
5221 try writer.writeAll(" = zig_builtin_");5301 try writer.writeAll(" = zig_libc_name_");
5222 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);5302 try f.object.dg.renderTypeForBuiltinFnName(writer, inst_ty);
5223 try writer.writeAll("(fma)(");5303 try writer.writeAll("(fma)(");
5224 try f.writeCValue(writer, mulend1, .FunctionArgument);5304 try f.writeCValue(writer, mulend1, .FunctionArgument);
...@@ -5328,6 +5408,22 @@ fn signAbbrev(signedness: std.builtin.Signedness) u8 {...@@ -5328,6 +5408,22 @@ fn signAbbrev(signedness: std.builtin.Signedness) u8 {
5328 };5408 };
5329}5409}
53305410
5411fn compilerRtAbbrev(ty: Type, target: std.Target) []const u8 {
5412 return if (ty.isInt()) switch (ty.intInfo(target).bits) {
5413 1...32 => "si",
5414 33...64 => "di",
5415 65...128 => "ti",
5416 else => unreachable,
5417 } else if (ty.isRuntimeFloat()) switch (ty.floatBits(target)) {
5418 16 => "hf",
5419 32 => "sf",
5420 64 => "df",
5421 80 => "xf",
5422 128 => "tf",
5423 else => unreachable,
5424 } else unreachable;
5425}
5426
5331fn formatStringLiteral(5427fn formatStringLiteral(
5332 str: []const u8,5428 str: []const u8,
5333 comptime fmt: []const u8,5429 comptime fmt: []const u8,
...@@ -5356,8 +5452,10 @@ fn fmtStringLiteral(str: []const u8) std.fmt.Formatter(formatStringLiteral) {...@@ -5356,8 +5452,10 @@ fn fmtStringLiteral(str: []const u8) std.fmt.Formatter(formatStringLiteral) {
5356 return .{ .data = str };5452 return .{ .data = str };
5357}5453}
53585454
5359fn undefPattern(comptime T: type) T {5455fn undefPattern(comptime IntType: type) IntType {
5360 return (1 << (@bitSizeOf(T) | 1)) / 3;5456 const int_info = @typeInfo(IntType).Int;
5457 const UnsignedType = std.meta.Int(.unsigned, int_info.bits);
5458 return @bitCast(IntType, @as(UnsignedType, (1 << (int_info.bits | 1)) / 3));
5361}5459}
53625460
5363const FormatIntLiteralContext = struct {5461const FormatIntLiteralContext = struct {
...@@ -5374,30 +5472,29 @@ fn formatIntLiteral(...@@ -5374,30 +5472,29 @@ fn formatIntLiteral(
5374 const target = data.mod.getTarget();5472 const target = data.mod.getTarget();
5375 const int_info = data.ty.intInfo(target);5473 const int_info = data.ty.intInfo(target);
53765474
5377 const Limb = std.math.big.Limb;
5378 const ExpectedContents = struct {5475 const ExpectedContents = struct {
5379 const base = 10;5476 const base = 10;
5380 const limbs_count_128 = BigInt.calcTwosCompLimbCount(128);5477 const limbs_count_128 = BigInt.calcTwosCompLimbCount(128);
5381 const expected_needed_limbs_count = BigInt.calcToStringLimbsBufferLen(limbs_count_128, base);5478 const expected_needed_limbs_count = BigInt.calcToStringLimbsBufferLen(limbs_count_128, base);
5382 const worst_case_int = BigInt.Const{5479 const worst_case_int = BigInt.Const{
5383 .limbs = &([1]Limb{std.math.maxInt(Limb)} ** expected_needed_limbs_count),5480 .limbs = &([1]BigIntLimb{std.math.maxInt(BigIntLimb)} ** expected_needed_limbs_count),
5384 .positive = false,5481 .positive = false,
5385 };5482 };
53865483
5387 undef_limbs: [limbs_count_128]Limb,5484 undef_limbs: [limbs_count_128]BigIntLimb,
5388 wrap_limbs: [limbs_count_128]Limb,5485 wrap_limbs: [limbs_count_128]BigIntLimb,
5389 };5486 };
5390 var stack align(@alignOf(ExpectedContents)) =5487 var stack align(@alignOf(ExpectedContents)) =
5391 std.heap.stackFallback(@sizeOf(ExpectedContents), data.mod.gpa);5488 std.heap.stackFallback(@sizeOf(ExpectedContents), data.mod.gpa);
5392 const allocator = stack.get();5489 const allocator = stack.get();
53935490
5394 var undef_limbs: []Limb = &.{};5491 var undef_limbs: []BigIntLimb = &.{};
5395 defer allocator.free(undef_limbs);5492 defer allocator.free(undef_limbs);
53965493
5397 var int_buf: Value.BigIntSpace = undefined;5494 var int_buf: Value.BigIntSpace = undefined;
5398 const int = if (data.val.isUndefDeep()) blk: {5495 const int = if (data.val.isUndefDeep()) blk: {
5399 undef_limbs = try allocator.alloc(Limb, BigInt.calcTwosCompLimbCount(int_info.bits));5496 undef_limbs = try allocator.alloc(BigIntLimb, BigInt.calcTwosCompLimbCount(int_info.bits));
5400 std.mem.set(Limb, undef_limbs, undefPattern(Limb));5497 std.mem.set(BigIntLimb, undef_limbs, undefPattern(BigIntLimb));
54015498
5402 var undef_int = BigInt.Mutable{5499 var undef_int = BigInt.Mutable{
5403 .limbs = undef_limbs,5500 .limbs = undef_limbs,
...@@ -5410,10 +5507,10 @@ fn formatIntLiteral(...@@ -5410,10 +5507,10 @@ fn formatIntLiteral(
5410 assert(int.fitsInTwosComp(int_info.signedness, int_info.bits));5507 assert(int.fitsInTwosComp(int_info.signedness, int_info.bits));
54115508
5412 const c_bits = toCIntBits(int_info.bits) orelse unreachable;5509 const c_bits = toCIntBits(int_info.bits) orelse unreachable;
5413 var one_limbs: [BigInt.calcLimbLen(1)]Limb = undefined;5510 var one_limbs: [BigInt.calcLimbLen(1)]BigIntLimb = undefined;
5414 const one = BigInt.Mutable.init(&one_limbs, 1).toConst();5511 const one = BigInt.Mutable.init(&one_limbs, 1).toConst();
54155512
5416 const wrap_limbs = try allocator.alloc(Limb, BigInt.calcTwosCompLimbCount(c_bits));5513 const wrap_limbs = try allocator.alloc(BigIntLimb, BigInt.calcTwosCompLimbCount(c_bits));
5417 defer allocator.free(wrap_limbs);5514 defer allocator.free(wrap_limbs);
5418 var wrap = BigInt.Mutable{ .limbs = wrap_limbs, .len = undefined, .positive = undefined };5515 var wrap = BigInt.Mutable{ .limbs = wrap_limbs, .len = undefined, .positive = undefined };
5419 if (wrap.addWrap(int, one, int_info.signedness, c_bits) or5516 if (wrap.addWrap(int, one, int_info.signedness, c_bits) or
...@@ -5439,7 +5536,7 @@ fn formatIntLiteral(...@@ -5439,7 +5536,7 @@ fn formatIntLiteral(
5439 else => try writer.print("zig_as_{c}{d}(", .{ signAbbrev(int_info.signedness), c_bits }),5536 else => try writer.print("zig_as_{c}{d}(", .{ signAbbrev(int_info.signedness), c_bits }),
5440 }5537 }
54415538
5442 const limbs_count_64 = @divExact(64, @bitSizeOf(Limb));5539 const limbs_count_64 = @divExact(64, @bitSizeOf(BigIntLimb));
5443 if (c_bits <= 64) {5540 if (c_bits <= 64) {
5444 var base: u8 = undefined;5541 var base: u8 = undefined;
5445 var case: std.fmt.Case = undefined;5542 var case: std.fmt.Case = undefined;
...@@ -5471,7 +5568,7 @@ fn formatIntLiteral(...@@ -5471,7 +5568,7 @@ fn formatIntLiteral(
5471 }5568 }
54725569
5473 var str: [64]u8 = undefined;5570 var str: [64]u8 = undefined;
5474 var limbs_buf: [BigInt.calcToStringLimbsBufferLen(limbs_count_64, 10)]Limb = undefined;5571 var limbs_buf: [BigInt.calcToStringLimbsBufferLen(limbs_count_64, 10)]BigIntLimb = undefined;
5475 try writer.writeAll(str[0..int.abs().toString(&str, base, case, &limbs_buf)]);5572 try writer.writeAll(str[0..int.abs().toString(&str, base, case, &limbs_buf)]);
5476 } else {5573 } else {
5477 assert(c_bits == 128);5574 assert(c_bits == 128);
test/tests.zig-4
...@@ -678,10 +678,6 @@ pub fn addPkgTests(...@@ -678,10 +678,6 @@ pub fn addPkgTests(
678 // https://github.com/ziglang/zig/issues/12415678 // https://github.com/ziglang/zig/issues/12415
679 continue;679 continue;
680 }680 }
681 if (backend == .stage2_c and builtin.cpu.arch == .aarch64) {
682 // https://github.com/ziglang/zig/issues/13357
683 continue;
684 }
685 }681 }
686682
687 const libc_prefix = if (test_target.target.getOs().requiresLibC())683 const libc_prefix = if (test_target.target.getOs().requiresLibC())