mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 13:54:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

zig.h: fix float negation

Browse source
This commit is contained in:
Jacob Young 2023-04-21 19:08:43 -04:00
parent d56c6c7791
commit 5feb27c126
2 changed files with 78 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

173
lib/zig.h
View file

@ -434,24 +434,24 @@ typedef ptrdiff_t intptr_t;
#define zig_minInt_u(w, bits) zig_intLimit(u, w, min, bits) #define zig_minInt_u(w, bits) zig_intLimit(u, w, min, bits)
#define zig_maxInt_u(w, bits) zig_intLimit(u, w, max, bits) #define zig_maxInt_u(w, bits) zig_intLimit(u, w, max, bits)
#define zig_int_operator(Type, RhsType, operation, operator) \ #define zig_operator(Type, RhsType, operation, operator) \
static inline Type zig_##operation(Type lhs, RhsType rhs) { \ static inline Type zig_##operation(Type lhs, RhsType rhs) { \
return lhs operator rhs; \ return lhs operator rhs; \
} }
#define zig_int_basic_operator(Type, operation, operator) \ #define zig_basic_operator(Type, operation, operator) \
zig_int_operator(Type, Type, operation, operator) zig_operator(Type, Type, operation, operator)
#define zig_int_shift_operator(Type, operation, operator) \ #define zig_shift_operator(Type, operation, operator) \
zig_int_operator(Type, uint8_t, operation, operator) zig_operator(Type, uint8_t, operation, operator)
#define zig_int_helpers(w) \ #define zig_int_helpers(w) \
zig_int_basic_operator(uint##w##_t, and_u##w, &) \ zig_basic_operator(uint##w##_t, and_u##w, &) \
zig_int_basic_operator( int##w##_t, and_i##w, &) \ zig_basic_operator( int##w##_t, and_i##w, &) \
zig_int_basic_operator(uint##w##_t, or_u##w, |) \ zig_basic_operator(uint##w##_t, or_u##w, |) \
zig_int_basic_operator( int##w##_t, or_i##w, |) \ zig_basic_operator( int##w##_t, or_i##w, |) \
zig_int_basic_operator(uint##w##_t, xor_u##w, ^) \ zig_basic_operator(uint##w##_t, xor_u##w, ^) \
zig_int_basic_operator( int##w##_t, xor_i##w, ^) \ zig_basic_operator( int##w##_t, xor_i##w, ^) \
zig_int_shift_operator(uint##w##_t, shl_u##w, <<) \ zig_shift_operator(uint##w##_t, shl_u##w, <<) \
zig_int_shift_operator( int##w##_t, shl_i##w, <<) \ zig_shift_operator( int##w##_t, shl_i##w, <<) \
zig_int_shift_operator(uint##w##_t, shr_u##w, >>) \ zig_shift_operator(uint##w##_t, shr_u##w, >>) \
\ \
static inline int##w##_t zig_shr_i##w(int##w##_t lhs, uint8_t rhs) { \ static inline int##w##_t zig_shr_i##w(int##w##_t lhs, uint8_t rhs) { \
int##w##_t sign_mask = lhs < INT##w##_C(0) ? -INT##w##_C(1) : INT##w##_C(0); \ int##w##_t sign_mask = lhs < INT##w##_C(0) ? -INT##w##_C(1) : INT##w##_C(0); \
@ -476,13 +476,13 @@ typedef ptrdiff_t intptr_t;
? val | zig_minInt_i(w, bits) : val & zig_maxInt_i(w, bits); \ ? val | zig_minInt_i(w, bits) : val & zig_maxInt_i(w, bits); \
} \ } \
\ \
zig_int_basic_operator(uint##w##_t, div_floor_u##w, /) \ zig_basic_operator(uint##w##_t, div_floor_u##w, /) \
\ \
static inline int##w##_t zig_div_floor_i##w(int##w##_t lhs, int##w##_t rhs) { \ static inline int##w##_t zig_div_floor_i##w(int##w##_t lhs, int##w##_t rhs) { \
return lhs / rhs - (((lhs ^ rhs) & (lhs % rhs)) < INT##w##_C(0)); \ return lhs / rhs - (((lhs ^ rhs) & (lhs % rhs)) < INT##w##_C(0)); \
} \ } \
\ \
zig_int_basic_operator(uint##w##_t, mod_u##w, %) \ zig_basic_operator(uint##w##_t, mod_u##w, %) \
\ \
static inline int##w##_t zig_mod_i##w(int##w##_t lhs, int##w##_t rhs) { \ static inline int##w##_t zig_mod_i##w(int##w##_t lhs, int##w##_t rhs) { \
int##w##_t rem = lhs % rhs; \ int##w##_t rem = lhs % rhs; \
@ -1153,8 +1153,8 @@ typedef signed __int128 zig_i128;
#define zig_lo_u128(val) ((uint64_t)((val) >> 0)) #define zig_lo_u128(val) ((uint64_t)((val) >> 0))
#define zig_hi_i128(val) (( int64_t)((val) >> 64)) #define zig_hi_i128(val) (( int64_t)((val) >> 64))
#define zig_lo_i128(val) ((uint64_t)((val) >> 0)) #define zig_lo_i128(val) ((uint64_t)((val) >> 0))
#define zig_bitcast_u128(val) ((zig_u128)(val)) #define zig_bitCast_u128(val) ((zig_u128)(val))
#define zig_bitcast_i128(val) ((zig_i128)(val)) #define zig_bitCast_i128(val) ((zig_i128)(val))
#define zig_cmp_int128(Type) \ #define zig_cmp_int128(Type) \
static inline int32_t zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \ static inline int32_t zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \
return (lhs > rhs) - (lhs < rhs); \ return (lhs > rhs) - (lhs < rhs); \
@ -1188,8 +1188,8 @@ typedef struct { zig_align(16) int64_t hi; uint64_t lo; } zig_i128;
#define zig_lo_u128(val) ((val).lo) #define zig_lo_u128(val) ((val).lo)
#define zig_hi_i128(val) ((val).hi) #define zig_hi_i128(val) ((val).hi)
#define zig_lo_i128(val) ((val).lo) #define zig_lo_i128(val) ((val).lo)
#define zig_bitcast_u128(val) zig_make_u128((uint64_t)(val).hi, (val).lo) #define zig_bitCast_u128(val) zig_make_u128((uint64_t)(val).hi, (val).lo)
#define zig_bitcast_i128(val) zig_make_i128(( int64_t)(val).hi, (val).lo) #define zig_bitCast_i128(val) zig_make_i128(( int64_t)(val).hi, (val).lo)
#define zig_cmp_int128(Type) \ #define zig_cmp_int128(Type) \
static inline int32_t zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \ static inline int32_t zig_cmp_##Type(zig_##Type lhs, zig_##Type rhs) { \
return (lhs.hi == rhs.hi) \ return (lhs.hi == rhs.hi) \
@ -1363,7 +1363,7 @@ static zig_i128 zig_mul_i128(zig_i128 lhs, zig_i128 rhs) {
} }
static zig_u128 zig_mul_u128(zig_u128 lhs, zig_u128 rhs) { static zig_u128 zig_mul_u128(zig_u128 lhs, zig_u128 rhs) {
return zig_bitcast_u128(zig_mul_i128(zig_bitcast_i128(lhs), zig_bitcast_i128(rhs))); return zig_bitCast_u128(zig_mul_i128(zig_bitCast_i128(lhs), zig_bitCast_i128(rhs)));
} }
zig_extern zig_u128 __udivti3(zig_u128 lhs, zig_u128 rhs); zig_extern zig_u128 __udivti3(zig_u128 lhs, zig_u128 rhs);
@ -1431,7 +1431,7 @@ static inline zig_u128 zig_shlw_u128(zig_u128 lhs, uint8_t rhs, uint8_t bits) {
} }
static inline zig_i128 zig_shlw_i128(zig_i128 lhs, uint8_t rhs, uint8_t bits) { static inline zig_i128 zig_shlw_i128(zig_i128 lhs, uint8_t rhs, uint8_t bits) {
return zig_wrap_i128(zig_bitcast_i128(zig_shl_u128(zig_bitcast_u128(lhs), rhs)), bits); return zig_wrap_i128(zig_bitCast_i128(zig_shl_u128(zig_bitCast_u128(lhs), rhs)), bits);
} }
static inline zig_u128 zig_addw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) { static inline zig_u128 zig_addw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
@ -1439,7 +1439,7 @@ static inline zig_u128 zig_addw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
} }
static inline zig_i128 zig_addw_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) { static inline zig_i128 zig_addw_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) {
return zig_wrap_i128(zig_bitcast_i128(zig_add_u128(zig_bitcast_u128(lhs), zig_bitcast_u128(rhs))), bits); return zig_wrap_i128(zig_bitCast_i128(zig_add_u128(zig_bitCast_u128(lhs), zig_bitCast_u128(rhs))), bits);
} }
static inline zig_u128 zig_subw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) { static inline zig_u128 zig_subw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
@ -1447,7 +1447,7 @@ static inline zig_u128 zig_subw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
} }
static inline zig_i128 zig_subw_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) { static inline zig_i128 zig_subw_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) {
return zig_wrap_i128(zig_bitcast_i128(zig_sub_u128(zig_bitcast_u128(lhs), zig_bitcast_u128(rhs))), bits); return zig_wrap_i128(zig_bitCast_i128(zig_sub_u128(zig_bitCast_u128(lhs), zig_bitCast_u128(rhs))), bits);
} }
static inline zig_u128 zig_mulw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) { static inline zig_u128 zig_mulw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
@ -1455,7 +1455,7 @@ static inline zig_u128 zig_mulw_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
} }
static inline zig_i128 zig_mulw_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) { static inline zig_i128 zig_mulw_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) {
return zig_wrap_i128(zig_bitcast_i128(zig_mul_u128(zig_bitcast_u128(lhs), zig_bitcast_u128(rhs))), bits); return zig_wrap_i128(zig_bitCast_i128(zig_mul_u128(zig_bitCast_u128(lhs), zig_bitCast_u128(rhs))), bits);
} }
#if zig_has_int128 #if zig_has_int128
@ -1590,7 +1590,7 @@ static inline bool zig_shlo_u128(zig_u128 *res, zig_u128 lhs, uint8_t rhs, uint8
static inline bool zig_shlo_i128(zig_i128 *res, zig_i128 lhs, uint8_t rhs, uint8_t bits) { static inline bool zig_shlo_i128(zig_i128 *res, zig_i128 lhs, uint8_t rhs, uint8_t bits) {
*res = zig_shlw_i128(lhs, rhs, bits); *res = zig_shlw_i128(lhs, rhs, bits);
zig_i128 mask = zig_bitcast_i128(zig_shl_u128(zig_maxInt_u128, bits - rhs - UINT8_C(1))); zig_i128 mask = zig_bitCast_i128(zig_shl_u128(zig_maxInt_u128, bits - rhs - UINT8_C(1)));
return zig_cmp_i128(zig_and_i128(lhs, mask), zig_make_i128(0, 0)) != INT32_C(0) && return zig_cmp_i128(zig_and_i128(lhs, mask), zig_make_i128(0, 0)) != INT32_C(0) &&
zig_cmp_i128(zig_and_i128(lhs, mask), mask) != INT32_C(0); zig_cmp_i128(zig_and_i128(lhs, mask), mask) != INT32_C(0);
} }
@ -1604,7 +1604,7 @@ static inline zig_u128 zig_shls_u128(zig_u128 lhs, zig_u128 rhs, uint8_t bits) {
static inline zig_i128 zig_shls_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) { static inline zig_i128 zig_shls_i128(zig_i128 lhs, zig_i128 rhs, uint8_t bits) {
zig_i128 res; zig_i128 res;
if (zig_cmp_u128(zig_bitcast_u128(rhs), zig_make_u128(0, bits)) < INT32_C(0) && !zig_shlo_i128(&res, lhs, (uint8_t)zig_lo_i128(rhs), bits)) return res; if (zig_cmp_u128(zig_bitCast_u128(rhs), zig_make_u128(0, bits)) < INT32_C(0) && !zig_shlo_i128(&res, lhs, (uint8_t)zig_lo_i128(rhs), bits)) return res;
return zig_cmp_i128(lhs, zig_make_i128(0, 0)) < INT32_C(0) ? zig_minInt_i(128, bits) : zig_maxInt_i(128, bits); return zig_cmp_i128(lhs, zig_make_i128(0, 0)) < INT32_C(0) ? zig_minInt_i(128, bits) : zig_maxInt_i(128, bits);
} }
@ -1648,7 +1648,7 @@ static inline uint8_t zig_clz_u128(zig_u128 val, uint8_t bits) {
} }
static inline uint8_t zig_clz_i128(zig_i128 val, uint8_t bits) { static inline uint8_t zig_clz_i128(zig_i128 val, uint8_t bits) {
return zig_clz_u128(zig_bitcast_u128(val), bits); return zig_clz_u128(zig_bitCast_u128(val), bits);
} }
static inline uint8_t zig_ctz_u128(zig_u128 val, uint8_t bits) { static inline uint8_t zig_ctz_u128(zig_u128 val, uint8_t bits) {
@ -1657,7 +1657,7 @@ static inline uint8_t zig_ctz_u128(zig_u128 val, uint8_t bits) {
} }
static inline uint8_t zig_ctz_i128(zig_i128 val, uint8_t bits) { static inline uint8_t zig_ctz_i128(zig_i128 val, uint8_t bits) {
return zig_ctz_u128(zig_bitcast_u128(val), bits); return zig_ctz_u128(zig_bitCast_u128(val), bits);
} }
static inline uint8_t zig_popcount_u128(zig_u128 val, uint8_t bits) { static inline uint8_t zig_popcount_u128(zig_u128 val, uint8_t bits) {
@ -1666,7 +1666,7 @@ static inline uint8_t zig_popcount_u128(zig_u128 val, uint8_t bits) {
} }
static inline uint8_t zig_popcount_i128(zig_i128 val, uint8_t bits) { static inline uint8_t zig_popcount_i128(zig_i128 val, uint8_t bits) {
return zig_popcount_u128(zig_bitcast_u128(val), bits); return zig_popcount_u128(zig_bitCast_u128(val), bits);
} }
static inline zig_u128 zig_byte_swap_u128(zig_u128 val, uint8_t bits) { static inline zig_u128 zig_byte_swap_u128(zig_u128 val, uint8_t bits) {
@ -1681,7 +1681,7 @@ static inline zig_u128 zig_byte_swap_u128(zig_u128 val, uint8_t bits) {
} }
static inline zig_i128 zig_byte_swap_i128(zig_i128 val, uint8_t bits) { static inline zig_i128 zig_byte_swap_i128(zig_i128 val, uint8_t bits) {
return zig_bitcast_i128(zig_byte_swap_u128(zig_bitcast_u128(val), bits)); return zig_bitCast_i128(zig_byte_swap_u128(zig_bitCast_u128(val), bits));
} }
static inline zig_u128 zig_bit_reverse_u128(zig_u128 val, uint8_t bits) { static inline zig_u128 zig_bit_reverse_u128(zig_u128 val, uint8_t bits) {
@ -1691,7 +1691,7 @@ static inline zig_u128 zig_bit_reverse_u128(zig_u128 val, uint8_t bits) {
} }
static inline zig_i128 zig_bit_reverse_i128(zig_i128 val, uint8_t bits) { static inline zig_i128 zig_bit_reverse_i128(zig_i128 val, uint8_t bits) {
return zig_bitcast_i128(zig_bit_reverse_u128(zig_bitcast_u128(val), bits)); return zig_bitCast_i128(zig_bit_reverse_u128(zig_bitCast_u128(val), bits));
} }
/* ========================== Big Integer Support =========================== */ /* ========================== Big Integer Support =========================== */
@ -2957,24 +2957,20 @@ long double __cdecl nanl(char const* input);
#endif #endif
#if (zig_has_builtin(nan) && zig_has_builtin(nans) && zig_has_builtin(inf)) || defined(zig_gnuc) #if (zig_has_builtin(nan) && zig_has_builtin(nans) && zig_has_builtin(inf)) || defined(zig_gnuc)
#define zig_has_float_builtins 1 #define zig_make_special_f16(sign, name, arg, repr) sign zig_make_f16 (__builtin_##name, )(arg)
#define zig_make_special_f16(sign, name, arg, repr) sign zig_make_f16(__builtin_##name, )(arg) #define zig_make_special_f32(sign, name, arg, repr) sign zig_make_f32 (__builtin_##name, )(arg)
#define zig_make_special_f32(sign, name, arg, repr) sign zig_make_f32(__builtin_##name, )(arg) #define zig_make_special_f64(sign, name, arg, repr) sign zig_make_f64 (__builtin_##name, )(arg)
#define zig_make_special_f64(sign, name, arg, repr) sign zig_make_f64(__builtin_##name, )(arg) #define zig_make_special_f80(sign, name, arg, repr) sign zig_make_f80 (__builtin_##name, )(arg)
#define zig_make_special_f80(sign, name, arg, repr) sign zig_make_f80(__builtin_##name, )(arg)
#define zig_make_special_f128(sign, name, arg, repr) sign zig_make_f128(__builtin_##name, )(arg) #define zig_make_special_f128(sign, name, arg, repr) sign zig_make_f128(__builtin_##name, )(arg)
#else #else
#define zig_has_float_builtins 0 #define zig_make_special_f16(sign, name, arg, repr) zig_bitCast_f16 (repr)
#define zig_make_special_f16(sign, name, arg, repr) zig_float_from_repr_f16(repr) #define zig_make_special_f32(sign, name, arg, repr) zig_bitCast_f32 (repr)
#define zig_make_special_f32(sign, name, arg, repr) zig_float_from_repr_f32(repr) #define zig_make_special_f64(sign, name, arg, repr) zig_bitCast_f64 (repr)
#define zig_make_special_f64(sign, name, arg, repr) zig_float_from_repr_f64(repr) #define zig_make_special_f80(sign, name, arg, repr) zig_bitCast_f80 (repr)
#define zig_make_special_f80(sign, name, arg, repr) zig_float_from_repr_f80(repr) #define zig_make_special_f128(sign, name, arg, repr) zig_bitCast_f128(repr)
#define zig_make_special_f128(sign, name, arg, repr) zig_float_from_repr_f128(repr)
#endif #endif
#define zig_has_f16 1 #define zig_has_f16 1
#define zig_bitSizeOf_f16 16
typedef uint16_t zig_repr_f16;
#define zig_libc_name_f16(name) __##name##h #define zig_libc_name_f16(name) __##name##h
#define zig_init_special_f16(sign, name, arg, repr) zig_make_special_f16(sign, name, arg, repr) #define zig_init_special_f16(sign, name, arg, repr) zig_make_special_f16(sign, name, arg, repr)
#if FLT_MANT_DIG == 11 #if FLT_MANT_DIG == 11
@ -2995,7 +2991,8 @@ typedef __fp16 zig_f16;
#else #else
#undef zig_has_f16 #undef zig_has_f16
#define zig_has_f16 0 #define zig_has_f16 0
typedef zig_repr_f16 zig_f16; #define zig_repr_f16 u16
typedef uint16_t zig_f16;
#define zig_make_f16(fp, repr) repr #define zig_make_f16(fp, repr) repr
#undef zig_make_special_f16 #undef zig_make_special_f16
#define zig_make_special_f16(sign, name, arg, repr) repr #define zig_make_special_f16(sign, name, arg, repr) repr
@ -3003,14 +3000,12 @@ typedef zig_repr_f16 zig_f16;
#define zig_init_special_f16(sign, name, arg, repr) repr #define zig_init_special_f16(sign, name, arg, repr) repr
#endif #endif
#if __APPLE__ && (defined(__i386__) || defined(__x86_64__)) #if __APPLE__ && (defined(__i386__) || defined(__x86_64__))
typedef zig_repr_f16 zig_compiler_rt_f16; typedef uint16_t zig_compiler_rt_f16;
#else #else
typedef zig_f16 zig_compiler_rt_f16; typedef zig_f16 zig_compiler_rt_f16;
#endif #endif
#define zig_has_f32 1 #define zig_has_f32 1
#define zig_bitSizeOf_f32 32
typedef uint32_t zig_repr_f32;
#define zig_libc_name_f32(name) name##f #define zig_libc_name_f32(name) name##f
#if _MSC_VER #if _MSC_VER
#define zig_init_special_f32(sign, name, arg, repr) sign zig_make_f32(zig_msvc_flt_##name, ) #define zig_init_special_f32(sign, name, arg, repr) sign zig_make_f32(zig_msvc_flt_##name, )
@ -3032,7 +3027,8 @@ typedef _Float32 zig_f32;
#else #else
#undef zig_has_f32 #undef zig_has_f32
#define zig_has_f32 0 #define zig_has_f32 0
typedef zig_repr_f32 zig_f32; #define zig_repr_f32 u32
ypedef uint32_t zig_f32;
#define zig_make_f32(fp, repr) repr #define zig_make_f32(fp, repr) repr
#undef zig_make_special_f32 #undef zig_make_special_f32
#define zig_make_special_f32(sign, name, arg, repr) repr #define zig_make_special_f32(sign, name, arg, repr) repr
@ -3041,8 +3037,6 @@ typedef zig_repr_f32 zig_f32;
#endif #endif
#define zig_has_f64 1 #define zig_has_f64 1
#define zig_bitSizeOf_f64 64
typedef uint64_t zig_repr_f64;
#define zig_libc_name_f64(name) name #define zig_libc_name_f64(name) name
#if _MSC_VER #if _MSC_VER
#define zig_init_special_f64(sign, name, arg, repr) sign zig_make_f64(zig_msvc_flt_##name, ) #define zig_init_special_f64(sign, name, arg, repr) sign zig_make_f64(zig_msvc_flt_##name, )
@ -3067,7 +3061,8 @@ typedef _Float32x zig_f64;
#else #else
#undef zig_has_f64 #undef zig_has_f64
#define zig_has_f64 0 #define zig_has_f64 0
typedef zig_repr_f64 zig_f64; #define zig_repr_f64 u64
typedef uint64_t zig_f64;
#define zig_make_f64(fp, repr) repr #define zig_make_f64(fp, repr) repr
#undef zig_make_special_f64 #undef zig_make_special_f64
#define zig_make_special_f64(sign, name, arg, repr) repr #define zig_make_special_f64(sign, name, arg, repr) repr
@ -3076,8 +3071,6 @@ typedef zig_repr_f64 zig_f64;
#endif #endif
#define zig_has_f80 1 #define zig_has_f80 1
#define zig_bitSizeOf_f80 80
typedef zig_u128 zig_repr_f80;
#define zig_libc_name_f80(name) __##name##x #define zig_libc_name_f80(name) __##name##x
#define zig_init_special_f80(sign, name, arg, repr) zig_make_special_f80(sign, name, arg, repr) #define zig_init_special_f80(sign, name, arg, repr) zig_make_special_f80(sign, name, arg, repr)
#if FLT_MANT_DIG == 64 #if FLT_MANT_DIG == 64
@ -3101,7 +3094,8 @@ typedef __float80 zig_f80;
#else #else
#undef zig_has_f80 #undef zig_has_f80
#define zig_has_f80 0 #define zig_has_f80 0
typedef zig_repr_f80 zig_f80; #define zig_repr_f80 u128
typedef zig_u128 zig_f80;
#define zig_make_f80(fp, repr) repr #define zig_make_f80(fp, repr) repr
#undef zig_make_special_f80 #undef zig_make_special_f80
#define zig_make_special_f80(sign, name, arg, repr) repr #define zig_make_special_f80(sign, name, arg, repr) repr
@ -3110,8 +3104,6 @@ typedef zig_repr_f80 zig_f80;
#endif #endif
#define zig_has_f128 1 #define zig_has_f128 1
#define zig_bitSizeOf_f128 128
typedef zig_u128 zig_repr_f128;
#define zig_libc_name_f128(name) name##q #define zig_libc_name_f128(name) name##q
#define zig_init_special_f128(sign, name, arg, repr) zig_make_special_f128(sign, name, arg, repr) #define zig_init_special_f128(sign, name, arg, repr) zig_make_special_f128(sign, name, arg, repr)
#if FLT_MANT_DIG == 113 #if FLT_MANT_DIG == 113
@ -3140,14 +3132,18 @@ typedef __float128 zig_f128;
#undef zig_make_special_f128 #undef zig_make_special_f128
#undef zig_init_special_f128 #undef zig_init_special_f128
#if __APPLE__ || defined(__aarch64__) #if __APPLE__ || defined(__aarch64__)
typedef __attribute__((__vector_size__(16))) uint64_t zig_f128; typedef __attribute__((__vector_size__(2 * sizeof(uint64_t)))) uint64_t zig_v2u64;
zig_basic_operator(zig_v2u64, xor_v2u64, ^)
#define zig_repr_f128 v2u64
typedef zig_v2u64 zig_f128;
#define zig_make_f128_zig_make_u128(hi, lo) (zig_f128){ lo, hi } #define zig_make_f128_zig_make_u128(hi, lo) (zig_f128){ lo, hi }
#define zig_make_f128_zig_init_u128 zig_make_f128_zig_make_u128 #define zig_make_f128_zig_init_u128 zig_make_f128_zig_make_u128
#define zig_make_f128(fp, repr) zig_make_f128_##repr #define zig_make_f128(fp, repr) zig_make_f128_##repr
#define zig_make_special_f128(sign, name, arg, repr) zig_make_f128_##repr #define zig_make_special_f128(sign, name, arg, repr) zig_make_f128_##repr
#define zig_init_special_f128(sign, name, arg, repr) zig_make_f128_##repr #define zig_init_special_f128(sign, name, arg, repr) zig_make_f128_##repr
#else #else
typedef zig_repr_f128 zig_f128; #define zig_repr_f128 u128
typedef zig_u128 zig_f128;
#define zig_make_f128(fp, repr) repr #define zig_make_f128(fp, repr) repr
#define zig_make_special_f128(sign, name, arg, repr) repr #define zig_make_special_f128(sign, name, arg, repr) repr
#define zig_init_special_f128(sign, name, arg, repr) repr #define zig_init_special_f128(sign, name, arg, repr) repr
@ -3156,48 +3152,26 @@ typedef zig_repr_f128 zig_f128;
#if !_MSC_VER && defined(ZIG_TARGET_ABI_MSVC) #if !_MSC_VER && defined(ZIG_TARGET_ABI_MSVC)
/* Emulate msvc abi on a gnu compiler */ /* Emulate msvc abi on a gnu compiler */
#define zig_bitSizeOf_c_longdouble 64
typedef zig_repr_f64 zig_repr_c_longdouble;
typedef zig_f64 zig_c_longdouble; typedef zig_f64 zig_c_longdouble;
#elif _MSC_VER && !defined(ZIG_TARGET_ABI_MSVC) #elif _MSC_VER && !defined(ZIG_TARGET_ABI_MSVC)
/* Emulate gnu abi on an msvc compiler */ /* Emulate gnu abi on an msvc compiler */
#define zig_bitSizeOf_c_longdouble 128
typedef zig_repr_f128 zig_repr_c_longdouble;
typedef zig_f128 zig_c_longdouble; typedef zig_f128 zig_c_longdouble;
#else #else
#if LDBL_MANT_DIG == 11 /* Target and compiler abi match */
#define zig_bitSizeOf_c_longdouble 16
typedef zig_repr_f16 zig_repr_c_longdouble;
#elif LDBL_MANT_DIG == 24
#define zig_bitSizeOf_c_longdouble 32
typedef zig_repr_f32 zig_repr_c_longdouble;
#elif LDBL_MANT_DIG == 53
#define zig_bitSizeOf_c_longdouble 64
typedef zig_repr_f64 zig_repr_c_longdouble;
#elif LDBL_MANT_DIG == 64
#define zig_bitSizeOf_c_longdouble 80
typedef zig_repr_f80 zig_repr_c_longdouble;
#elif LDBL_MANT_DIG == 113
#define zig_bitSizeOf_c_longdouble 128
typedef zig_repr_f128 zig_repr_c_longdouble;
#endif
typedef long double zig_c_longdouble; typedef long double zig_c_longdouble;
#endif #endif
#if !zig_has_float_builtins #define zig_bitCast_float(Type, ReprType) \
#define zig_float_from_repr(Type) \ static inline zig_##Type zig_bitCast_##Type(ReprType repr) { \
static inline zig_##Type zig_float_from_repr_##Type(zig_repr_##Type repr) { \
zig_##Type result; \ zig_##Type result; \
memcpy(&result, &repr, sizeof(result)); \ memcpy(&result, &repr, sizeof(result)); \
return result; \ return result; \
} }
zig_bitCast_float(f16, uint16_t)
zig_float_from_repr(f16) zig_bitCast_float(f32, uint32_t)
zig_float_from_repr(f32) zig_bitCast_float(f64, uint64_t)
zig_float_from_repr(f64) zig_bitCast_float(f80, zig_u128)
zig_float_from_repr(f80) zig_bitCast_float(f128, zig_u128)
zig_float_from_repr(f128)
#endif
#define zig_cast_f16 (zig_f16) #define zig_cast_f16 (zig_f16)
#define zig_cast_f32 (zig_f32) #define zig_cast_f32 (zig_f32)
@ -3246,17 +3220,18 @@ zig_convert_builtin(zig_f128, zig_f128, extend, zig_f32,
zig_convert_builtin(zig_f128, zig_f128, extend, zig_f64, zig_f64, 2) zig_convert_builtin(zig_f128, zig_f128, extend, zig_f64, zig_f64, 2)
zig_convert_builtin(zig_f128, zig_f128, extend, zig_f80, zig_f80, 2) zig_convert_builtin(zig_f128, zig_f128, extend, zig_f80, zig_f80, 2)
#define zig_float_negate_builtin_0(w, r, c, sb) zig_xor_u##r(arg, zig_make_f##w(-0x0.0p0, c sb)) #define zig_float_negate_builtin_0(w, c, sb) \
#define zig_float_negate_builtin_1(w, r, c, sb) -arg zig_expand_concat(zig_xor_, zig_repr_f##w)(arg, zig_make_f##w(-0x0.0p0, c sb))
#define zig_float_negate_builtin(w, r, c, sb) \ #define zig_float_negate_builtin_1(w, c, sb) -arg
#define zig_float_negate_builtin(w, c, sb) \
static inline zig_f##w zig_neg_f##w(zig_f##w arg) { \ static inline zig_f##w zig_neg_f##w(zig_f##w arg) { \
return zig_expand_concat(zig_float_negate_builtin_, zig_has_f##w)(w, r, c, sb); \ return zig_expand_concat(zig_float_negate_builtin_, zig_has_f##w)(w, c, sb); \
} }
zig_float_negate_builtin(16, 16, , UINT16_C(1) << 15 ) zig_float_negate_builtin(16, , UINT16_C(1) << 15 )
zig_float_negate_builtin(32, 32, , UINT32_C(1) << 31 ) zig_float_negate_builtin(32, , UINT32_C(1) << 31 )
zig_float_negate_builtin(64, 64, , UINT64_C(1) << 63 ) zig_float_negate_builtin(64, , UINT64_C(1) << 63 )
zig_float_negate_builtin(80, 128, zig_make_u128, (UINT64_C(1) << 15, UINT64_C(0))) zig_float_negate_builtin(80, zig_make_u128, (UINT64_C(1) << 15, UINT64_C(0)))
zig_float_negate_builtin(128, 128, zig_make_u128, (UINT64_C(1) << 63, UINT64_C(0))) zig_float_negate_builtin(128, zig_make_u128, (UINT64_C(1) << 63, UINT64_C(0)))
#define zig_float_less_builtin_0(Type, operation) \ #define zig_float_less_builtin_0(Type, operation) \
zig_extern int32_t zig_expand_concat(zig_expand_concat(__##operation, \ zig_extern int32_t zig_expand_concat(zig_expand_concat(__##operation, \

8
src/codegen/c.zig
View file

@ -3523,13 +3523,13 @@ fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue {
try writer.writeAll("zig_shr_"); try writer.writeAll("zig_shr_");
try f.object.dg.renderTypeForBuiltinFnName(writer, scalar_ty); try f.object.dg.renderTypeForBuiltinFnName(writer, scalar_ty);
if (c_bits == 128) { if (c_bits == 128) {
try writer.print("(zig_bitcast_i{d}(", .{c_bits}); try writer.print("(zig_bitCast_i{d}(", .{c_bits});
} else { } else {
try writer.print("((int{d}_t)", .{c_bits}); try writer.print("((int{d}_t)", .{c_bits});
} }
try writer.print("zig_shl_u{d}(", .{c_bits}); try writer.print("zig_shl_u{d}(", .{c_bits});
if (c_bits == 128) { if (c_bits == 128) {
try writer.print("zig_bitcast_u{d}(", .{c_bits}); try writer.print("zig_bitCast_u{d}(", .{c_bits});
} else { } else {
try writer.print("(uint{d}_t)", .{c_bits}); try writer.print("(uint{d}_t)", .{c_bits});
} }
@ -4484,7 +4484,7 @@ fn airBitcast(f: *Function, inst: Air.Inst.Index) !CValue {
} }
try writer.writeAll(" = "); try writer.writeAll(" = ");
if (need_bitcasts) { if (need_bitcasts) {
try writer.writeAll("zig_bitcast_"); try writer.writeAll("zig_bitCast_");
try f.object.dg.renderCTypeForBuiltinFnName(writer, wrap_cty.?.toUnsigned()); try f.object.dg.renderCTypeForBuiltinFnName(writer, wrap_cty.?.toUnsigned());
try writer.writeByte('('); try writer.writeByte('(');
} }
@ -4496,7 +4496,7 @@ fn airBitcast(f: *Function, inst: Air.Inst.Index) !CValue {
try f.object.dg.renderTypeForBuiltinFnName(writer, info_ty); try f.object.dg.renderTypeForBuiltinFnName(writer, info_ty);
try writer.writeByte('('); try writer.writeByte('(');
if (need_bitcasts) { if (need_bitcasts) {
try writer.writeAll("zig_bitcast_"); try writer.writeAll("zig_bitCast_");
try f.object.dg.renderCTypeForBuiltinFnName(writer, wrap_cty.?); try f.object.dg.renderCTypeForBuiltinFnName(writer, wrap_cty.?);
try writer.writeByte('('); try writer.writeByte('(');
} }