authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-12-02 22:19:12-05:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-12-02 22:19:12-05:00
logc43ac67f82cb5a022df67729aa1e6bebc22cfff2
treee8781d33e0a2a1d6510c19d31cdc5ee15ff71f3a
parentaf4361f57af388238a075b0c8ef5b34e75b73787
parent29e8e67a7ec767aed0b9b689bdcad7355c032751
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #13746 from ziglang/cbe-bools

CBE: use bool, true, false, instead of `zig_` prefixes

3 files changed, 115 insertions(+), 101 deletions(-)

lib/zig.h+87-91
...@@ -6,6 +6,16 @@...@@ -6,6 +6,16 @@
6#include <stddef.h>6#include <stddef.h>
7#include <stdint.h>7#include <stdint.h>
88
9#if !defined(__cplusplus) && __STDC_VERSION__ <= 201710L
10#if __STDC_VERSION__ >= 199901L
11#include <stdbool.h>
12#else
13typedef char bool;
14#define false 0
15#define true 1
16#endif
17#endif
18
9#if defined(__has_builtin)19#if defined(__has_builtin)
10#define zig_has_builtin(builtin) __has_builtin(__builtin_##builtin)20#define zig_has_builtin(builtin) __has_builtin(__builtin_##builtin)
11#else21#else
...@@ -136,8 +146,8 @@...@@ -136,8 +146,8 @@
136#define memory_order_acq_rel __ATOMIC_ACQ_REL146#define memory_order_acq_rel __ATOMIC_ACQ_REL
137#define memory_order_seq_cst __ATOMIC_SEQ_CST147#define memory_order_seq_cst __ATOMIC_SEQ_CST
138#define zig_atomic(type) type148#define zig_atomic(type) type
139#define zig_cmpxchg_strong(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, zig_false, succ, fail)149#define zig_cmpxchg_strong(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, false, succ, fail)
140#define zig_cmpxchg_weak(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, zig_true , succ, fail)150#define zig_cmpxchg_weak(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, true , succ, fail)
141#define zig_atomicrmw_xchg(obj, arg, order) __atomic_exchange_n(obj, arg, order)151#define zig_atomicrmw_xchg(obj, arg, order) __atomic_exchange_n(obj, arg, order)
142#define zig_atomicrmw_add(obj, arg, order) __atomic_fetch_add (obj, arg, order)152#define zig_atomicrmw_add(obj, arg, order) __atomic_fetch_add (obj, arg, order)
143#define zig_atomicrmw_sub(obj, arg, order) __atomic_fetch_sub (obj, arg, order)153#define zig_atomicrmw_sub(obj, arg, order) __atomic_fetch_sub (obj, arg, order)
...@@ -189,20 +199,6 @@...@@ -189,20 +199,6 @@
189199
190#define zig_bitSizeOf(T) (CHAR_BIT * sizeof(T))200#define zig_bitSizeOf(T) (CHAR_BIT * sizeof(T))
191201
192#if defined(__cplusplus)
193typedef bool zig_bool;
194#define zig_false false
195#define zig_true true
196#else
197#if __STDC_VERSION__ >= 199901L
198typedef _Bool zig_bool;
199#else
200typedef char zig_bool;
201#endif
202#define zig_false ((zig_bool)0)
203#define zig_true ((zig_bool)1)
204#endif
205
206typedef uintptr_t zig_usize;202typedef uintptr_t zig_usize;
207typedef intptr_t zig_isize;203typedef intptr_t zig_isize;
208typedef signed short int zig_c_short;204typedef signed short int zig_c_short;
...@@ -330,10 +326,10 @@ zig_int_helpers(16)...@@ -330,10 +326,10 @@ zig_int_helpers(16)
330zig_int_helpers(32)326zig_int_helpers(32)
331zig_int_helpers(64)327zig_int_helpers(64)
332328
333static inline zig_bool zig_addo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {329static inline bool zig_addo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {
334#if zig_has_builtin(add_overflow)330#if zig_has_builtin(add_overflow)
335 zig_u32 full_res;331 zig_u32 full_res;
336 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);332 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
337 *res = zig_wrap_u32(full_res, bits);333 *res = zig_wrap_u32(full_res, bits);
338 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);334 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);
339#else335#else
...@@ -349,14 +345,14 @@ static inline void zig_vaddo_u32(zig_u8 *ov, zig_u32 *res, int n,...@@ -349,14 +345,14 @@ static inline void zig_vaddo_u32(zig_u8 *ov, zig_u32 *res, int n,
349}345}
350346
351zig_extern zig_i32 __addosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);347zig_extern zig_i32 __addosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);
352static inline zig_bool zig_addo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {348static inline bool zig_addo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {
353#if zig_has_builtin(add_overflow)349#if zig_has_builtin(add_overflow)
354 zig_i32 full_res;350 zig_i32 full_res;
355 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);351 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
356#else352#else
357 zig_c_int overflow_int;353 zig_c_int overflow_int;
358 zig_u32 full_res = __addosi4(lhs, rhs, &overflow_int);354 zig_u32 full_res = __addosi4(lhs, rhs, &overflow_int);
359 zig_bool overflow = overflow_int != 0;355 bool overflow = overflow_int != 0;
360#endif356#endif
361 *res = zig_wrap_i32(full_res, bits);357 *res = zig_wrap_i32(full_res, bits);
362 return overflow || full_res < zig_minInt(i32, bits) || full_res > zig_maxInt(i32, bits);358 return overflow || full_res < zig_minInt(i32, bits) || full_res > zig_maxInt(i32, bits);
...@@ -368,10 +364,10 @@ static inline void zig_vaddo_i32(zig_u8 *ov, zig_i32 *res, int n,...@@ -368,10 +364,10 @@ static inline void zig_vaddo_i32(zig_u8 *ov, zig_i32 *res, int n,
368 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i32(&res[i], lhs[i], rhs[i], bits);364 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i32(&res[i], lhs[i], rhs[i], bits);
369}365}
370366
371static inline zig_bool zig_addo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {367static inline bool zig_addo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {
372#if zig_has_builtin(add_overflow)368#if zig_has_builtin(add_overflow)
373 zig_u64 full_res;369 zig_u64 full_res;
374 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);370 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
375 *res = zig_wrap_u64(full_res, bits);371 *res = zig_wrap_u64(full_res, bits);
376 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);372 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);
377#else373#else
...@@ -387,14 +383,14 @@ static inline void zig_vaddo_u64(zig_u8 *ov, zig_u64 *res, int n,...@@ -387,14 +383,14 @@ static inline void zig_vaddo_u64(zig_u8 *ov, zig_u64 *res, int n,
387}383}
388384
389zig_extern zig_i64 __addodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);385zig_extern zig_i64 __addodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);
390static inline zig_bool zig_addo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {386static inline bool zig_addo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {
391#if zig_has_builtin(add_overflow)387#if zig_has_builtin(add_overflow)
392 zig_i64 full_res;388 zig_i64 full_res;
393 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);389 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
394#else390#else
395 zig_c_int overflow_int;391 zig_c_int overflow_int;
396 zig_u64 full_res = __addodi4(lhs, rhs, &overflow_int);392 zig_u64 full_res = __addodi4(lhs, rhs, &overflow_int);
397 zig_bool overflow = overflow_int != 0;393 bool overflow = overflow_int != 0;
398#endif394#endif
399 *res = zig_wrap_i64(full_res, bits);395 *res = zig_wrap_i64(full_res, bits);
400 return overflow || full_res < zig_minInt(i64, bits) || full_res > zig_maxInt(i64, bits);396 return overflow || full_res < zig_minInt(i64, bits) || full_res > zig_maxInt(i64, bits);
...@@ -406,10 +402,10 @@ static inline void zig_vaddo_i64(zig_u8 *ov, zig_i64 *res, int n,...@@ -406,10 +402,10 @@ static inline void zig_vaddo_i64(zig_u8 *ov, zig_i64 *res, int n,
406 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i64(&res[i], lhs[i], rhs[i], bits);402 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i64(&res[i], lhs[i], rhs[i], bits);
407}403}
408404
409static inline zig_bool zig_addo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {405static inline bool zig_addo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {
410#if zig_has_builtin(add_overflow)406#if zig_has_builtin(add_overflow)
411 zig_u8 full_res;407 zig_u8 full_res;
412 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);408 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
413 *res = zig_wrap_u8(full_res, bits);409 *res = zig_wrap_u8(full_res, bits);
414 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);410 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);
415#else411#else
...@@ -423,10 +419,10 @@ static inline void zig_vaddo_u8(zig_u8 *ov, zig_u8 *res, int n,...@@ -423,10 +419,10 @@ static inline void zig_vaddo_u8(zig_u8 *ov, zig_u8 *res, int n,
423 for (int i = 0; i < n; ++i) ov[i] = zig_addo_u8(&res[i], lhs[i], rhs[i], bits);419 for (int i = 0; i < n; ++i) ov[i] = zig_addo_u8(&res[i], lhs[i], rhs[i], bits);
424}420}
425421
426static inline zig_bool zig_addo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {422static inline bool zig_addo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {
427#if zig_has_builtin(add_overflow)423#if zig_has_builtin(add_overflow)
428 zig_i8 full_res;424 zig_i8 full_res;
429 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);425 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
430 *res = zig_wrap_i8(full_res, bits);426 *res = zig_wrap_i8(full_res, bits);
431 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);427 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);
432#else428#else
...@@ -440,10 +436,10 @@ static inline void zig_vaddo_i8(zig_u8 *ov, zig_i8 *res, int n,...@@ -440,10 +436,10 @@ static inline void zig_vaddo_i8(zig_u8 *ov, zig_i8 *res, int n,
440 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i8(&res[i], lhs[i], rhs[i], bits);436 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i8(&res[i], lhs[i], rhs[i], bits);
441}437}
442438
443static inline zig_bool zig_addo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {439static inline bool zig_addo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {
444#if zig_has_builtin(add_overflow)440#if zig_has_builtin(add_overflow)
445 zig_u16 full_res;441 zig_u16 full_res;
446 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);442 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
447 *res = zig_wrap_u16(full_res, bits);443 *res = zig_wrap_u16(full_res, bits);
448 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);444 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);
449#else445#else
...@@ -457,10 +453,10 @@ static inline void zig_vaddo_u16(zig_u8 *ov, zig_u16 *res, int n,...@@ -457,10 +453,10 @@ static inline void zig_vaddo_u16(zig_u8 *ov, zig_u16 *res, int n,
457 for (int i = 0; i < n; ++i) ov[i] = zig_addo_u16(&res[i], lhs[i], rhs[i], bits);453 for (int i = 0; i < n; ++i) ov[i] = zig_addo_u16(&res[i], lhs[i], rhs[i], bits);
458}454}
459455
460static inline zig_bool zig_addo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {456static inline bool zig_addo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {
461#if zig_has_builtin(add_overflow)457#if zig_has_builtin(add_overflow)
462 zig_i16 full_res;458 zig_i16 full_res;
463 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);459 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
464 *res = zig_wrap_i16(full_res, bits);460 *res = zig_wrap_i16(full_res, bits);
465 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);461 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);
466#else462#else
...@@ -474,10 +470,10 @@ static inline void zig_vaddo_i16(zig_u8 *ov, zig_i16 *res, int n,...@@ -474,10 +470,10 @@ static inline void zig_vaddo_i16(zig_u8 *ov, zig_i16 *res, int n,
474 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i16(&res[i], lhs[i], rhs[i], bits);470 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i16(&res[i], lhs[i], rhs[i], bits);
475}471}
476472
477static inline zig_bool zig_subo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {473static inline bool zig_subo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {
478#if zig_has_builtin(sub_overflow)474#if zig_has_builtin(sub_overflow)
479 zig_u32 full_res;475 zig_u32 full_res;
480 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);476 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
481 *res = zig_wrap_u32(full_res, bits);477 *res = zig_wrap_u32(full_res, bits);
482 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);478 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);
483#else479#else
...@@ -493,14 +489,14 @@ static inline void zig_vsubo_u32(zig_u8 *ov, zig_u32 *res, int n,...@@ -493,14 +489,14 @@ static inline void zig_vsubo_u32(zig_u8 *ov, zig_u32 *res, int n,
493}489}
494490
495zig_extern zig_i32 __subosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);491zig_extern zig_i32 __subosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);
496static inline zig_bool zig_subo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {492static inline bool zig_subo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {
497#if zig_has_builtin(sub_overflow)493#if zig_has_builtin(sub_overflow)
498 zig_i32 full_res;494 zig_i32 full_res;
499 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);495 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
500#else496#else
501 zig_c_int overflow_int;497 zig_c_int overflow_int;
502 zig_u32 full_res = __subosi4(lhs, rhs, &overflow_int);498 zig_u32 full_res = __subosi4(lhs, rhs, &overflow_int);
503 zig_bool overflow = overflow_int != 0;499 bool overflow = overflow_int != 0;
504#endif500#endif
505 *res = zig_wrap_i32(full_res, bits);501 *res = zig_wrap_i32(full_res, bits);
506 return overflow || full_res < zig_minInt(i32, bits) || full_res > zig_maxInt(i32, bits);502 return overflow || full_res < zig_minInt(i32, bits) || full_res > zig_maxInt(i32, bits);
...@@ -512,10 +508,10 @@ static inline void zig_vsubo_i32(zig_u8 *ov, zig_i32 *res, int n,...@@ -512,10 +508,10 @@ static inline void zig_vsubo_i32(zig_u8 *ov, zig_i32 *res, int n,
512 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i32(&res[i], lhs[i], rhs[i], bits);508 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i32(&res[i], lhs[i], rhs[i], bits);
513}509}
514510
515static inline zig_bool zig_subo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {511static inline bool zig_subo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {
516#if zig_has_builtin(sub_overflow)512#if zig_has_builtin(sub_overflow)
517 zig_u64 full_res;513 zig_u64 full_res;
518 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);514 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
519 *res = zig_wrap_u64(full_res, bits);515 *res = zig_wrap_u64(full_res, bits);
520 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);516 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);
521#else517#else
...@@ -531,14 +527,14 @@ static inline void zig_vsubo_u64(zig_u8 *ov, zig_u64 *res, int n,...@@ -531,14 +527,14 @@ static inline void zig_vsubo_u64(zig_u8 *ov, zig_u64 *res, int n,
531}527}
532528
533zig_extern zig_i64 __subodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);529zig_extern zig_i64 __subodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);
534static inline zig_bool zig_subo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {530static inline bool zig_subo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {
535#if zig_has_builtin(sub_overflow)531#if zig_has_builtin(sub_overflow)
536 zig_i64 full_res;532 zig_i64 full_res;
537 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);533 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
538#else534#else
539 zig_c_int overflow_int;535 zig_c_int overflow_int;
540 zig_u64 full_res = __subodi4(lhs, rhs, &overflow_int);536 zig_u64 full_res = __subodi4(lhs, rhs, &overflow_int);
541 zig_bool overflow = overflow_int != 0;537 bool overflow = overflow_int != 0;
542#endif538#endif
543 *res = zig_wrap_i64(full_res, bits);539 *res = zig_wrap_i64(full_res, bits);
544 return overflow || full_res < zig_minInt(i64, bits) || full_res > zig_maxInt(i64, bits);540 return overflow || full_res < zig_minInt(i64, bits) || full_res > zig_maxInt(i64, bits);
...@@ -550,10 +546,10 @@ static inline void zig_vsubo_i64(zig_u8 *ov, zig_i64 *res, int n,...@@ -550,10 +546,10 @@ static inline void zig_vsubo_i64(zig_u8 *ov, zig_i64 *res, int n,
550 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i64(&res[i], lhs[i], rhs[i], bits);546 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i64(&res[i], lhs[i], rhs[i], bits);
551}547}
552548
553static inline zig_bool zig_subo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {549static inline bool zig_subo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {
554#if zig_has_builtin(sub_overflow)550#if zig_has_builtin(sub_overflow)
555 zig_u8 full_res;551 zig_u8 full_res;
556 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);552 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
557 *res = zig_wrap_u8(full_res, bits);553 *res = zig_wrap_u8(full_res, bits);
558 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);554 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);
559#else555#else
...@@ -567,10 +563,10 @@ static inline void zig_vsubo_u8(zig_u8 *ov, zig_u8 *res, int n,...@@ -567,10 +563,10 @@ static inline void zig_vsubo_u8(zig_u8 *ov, zig_u8 *res, int n,
567 for (int i = 0; i < n; ++i) ov[i] = zig_subo_u8(&res[i], lhs[i], rhs[i], bits);563 for (int i = 0; i < n; ++i) ov[i] = zig_subo_u8(&res[i], lhs[i], rhs[i], bits);
568}564}
569565
570static inline zig_bool zig_subo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {566static inline bool zig_subo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {
571#if zig_has_builtin(sub_overflow)567#if zig_has_builtin(sub_overflow)
572 zig_i8 full_res;568 zig_i8 full_res;
573 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);569 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
574 *res = zig_wrap_i8(full_res, bits);570 *res = zig_wrap_i8(full_res, bits);
575 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);571 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);
576#else572#else
...@@ -585,10 +581,10 @@ static inline void zig_vsubo_i8(zig_u8 *ov, zig_i8 *res, int n,...@@ -585,10 +581,10 @@ static inline void zig_vsubo_i8(zig_u8 *ov, zig_i8 *res, int n,
585}581}
586582
587583
588static inline zig_bool zig_subo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {584static inline bool zig_subo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {
589#if zig_has_builtin(sub_overflow)585#if zig_has_builtin(sub_overflow)
590 zig_u16 full_res;586 zig_u16 full_res;
591 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);587 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
592 *res = zig_wrap_u16(full_res, bits);588 *res = zig_wrap_u16(full_res, bits);
593 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);589 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);
594#else590#else
...@@ -603,10 +599,10 @@ static inline void zig_vsubo_u16(zig_u8 *ov, zig_u16 *res, int n,...@@ -603,10 +599,10 @@ static inline void zig_vsubo_u16(zig_u8 *ov, zig_u16 *res, int n,
603}599}
604600
605601
606static inline zig_bool zig_subo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {602static inline bool zig_subo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {
607#if zig_has_builtin(sub_overflow)603#if zig_has_builtin(sub_overflow)
608 zig_i16 full_res;604 zig_i16 full_res;
609 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);605 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
610 *res = zig_wrap_i16(full_res, bits);606 *res = zig_wrap_i16(full_res, bits);
611 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);607 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);
612#else608#else
...@@ -620,10 +616,10 @@ static inline void zig_vsubo_i16(zig_u8 *ov, zig_i16 *res, int n,...@@ -620,10 +616,10 @@ static inline void zig_vsubo_i16(zig_u8 *ov, zig_i16 *res, int n,
620 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i16(&res[i], lhs[i], rhs[i], bits);616 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i16(&res[i], lhs[i], rhs[i], bits);
621}617}
622618
623static inline zig_bool zig_mulo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {619static inline bool zig_mulo_u32(zig_u32 *res, zig_u32 lhs, zig_u32 rhs, zig_u8 bits) {
624#if zig_has_builtin(mul_overflow)620#if zig_has_builtin(mul_overflow)
625 zig_u32 full_res;621 zig_u32 full_res;
626 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);622 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
627 *res = zig_wrap_u32(full_res, bits);623 *res = zig_wrap_u32(full_res, bits);
628 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);624 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);
629#else625#else
...@@ -639,14 +635,14 @@ static inline void zig_vmulo_u32(zig_u8 *ov, zig_u32 *res, int n,...@@ -639,14 +635,14 @@ static inline void zig_vmulo_u32(zig_u8 *ov, zig_u32 *res, int n,
639}635}
640636
641zig_extern zig_i32 __mulosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);637zig_extern zig_i32 __mulosi4(zig_i32 lhs, zig_i32 rhs, zig_c_int *overflow);
642static inline zig_bool zig_mulo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {638static inline bool zig_mulo_i32(zig_i32 *res, zig_i32 lhs, zig_i32 rhs, zig_u8 bits) {
643#if zig_has_builtin(mul_overflow)639#if zig_has_builtin(mul_overflow)
644 zig_i32 full_res;640 zig_i32 full_res;
645 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);641 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
646#else642#else
647 zig_c_int overflow_int;643 zig_c_int overflow_int;
648 zig_u32 full_res = __mulosi4(lhs, rhs, &overflow_int);644 zig_u32 full_res = __mulosi4(lhs, rhs, &overflow_int);
649 zig_bool overflow = overflow_int != 0;645 bool overflow = overflow_int != 0;
650#endif646#endif
651 *res = zig_wrap_i32(full_res, bits);647 *res = zig_wrap_i32(full_res, bits);
652 return overflow || full_res < zig_minInt(i32, bits) || full_res > zig_maxInt(i32, bits);648 return overflow || full_res < zig_minInt(i32, bits) || full_res > zig_maxInt(i32, bits);
...@@ -658,10 +654,10 @@ static inline void zig_vmulo_i32(zig_u8 *ov, zig_i32 *res, int n,...@@ -658,10 +654,10 @@ static inline void zig_vmulo_i32(zig_u8 *ov, zig_i32 *res, int n,
658 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i32(&res[i], lhs[i], rhs[i], bits);654 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i32(&res[i], lhs[i], rhs[i], bits);
659}655}
660656
661static inline zig_bool zig_mulo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {657static inline bool zig_mulo_u64(zig_u64 *res, zig_u64 lhs, zig_u64 rhs, zig_u8 bits) {
662#if zig_has_builtin(mul_overflow)658#if zig_has_builtin(mul_overflow)
663 zig_u64 full_res;659 zig_u64 full_res;
664 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);660 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
665 *res = zig_wrap_u64(full_res, bits);661 *res = zig_wrap_u64(full_res, bits);
666 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);662 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);
667#else663#else
...@@ -677,14 +673,14 @@ static inline void zig_vmulo_u64(zig_u8 *ov, zig_u64 *res, int n,...@@ -677,14 +673,14 @@ static inline void zig_vmulo_u64(zig_u8 *ov, zig_u64 *res, int n,
677}673}
678674
679zig_extern zig_i64 __mulodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);675zig_extern zig_i64 __mulodi4(zig_i64 lhs, zig_i64 rhs, zig_c_int *overflow);
680static inline zig_bool zig_mulo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {676static inline bool zig_mulo_i64(zig_i64 *res, zig_i64 lhs, zig_i64 rhs, zig_u8 bits) {
681#if zig_has_builtin(mul_overflow)677#if zig_has_builtin(mul_overflow)
682 zig_i64 full_res;678 zig_i64 full_res;
683 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);679 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
684#else680#else
685 zig_c_int overflow_int;681 zig_c_int overflow_int;
686 zig_u64 full_res = __mulodi4(lhs, rhs, &overflow_int);682 zig_u64 full_res = __mulodi4(lhs, rhs, &overflow_int);
687 zig_bool overflow = overflow_int != 0;683 bool overflow = overflow_int != 0;
688#endif684#endif
689 *res = zig_wrap_i64(full_res, bits);685 *res = zig_wrap_i64(full_res, bits);
690 return overflow || full_res < zig_minInt(i64, bits) || full_res > zig_maxInt(i64, bits);686 return overflow || full_res < zig_minInt(i64, bits) || full_res > zig_maxInt(i64, bits);
...@@ -696,10 +692,10 @@ static inline void zig_vmulo_i64(zig_u8 *ov, zig_i64 *res, int n,...@@ -696,10 +692,10 @@ static inline void zig_vmulo_i64(zig_u8 *ov, zig_i64 *res, int n,
696 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i64(&res[i], lhs[i], rhs[i], bits);692 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i64(&res[i], lhs[i], rhs[i], bits);
697}693}
698694
699static inline zig_bool zig_mulo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {695static inline bool zig_mulo_u8(zig_u8 *res, zig_u8 lhs, zig_u8 rhs, zig_u8 bits) {
700#if zig_has_builtin(mul_overflow)696#if zig_has_builtin(mul_overflow)
701 zig_u8 full_res;697 zig_u8 full_res;
702 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);698 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
703 *res = zig_wrap_u8(full_res, bits);699 *res = zig_wrap_u8(full_res, bits);
704 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);700 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);
705#else701#else
...@@ -713,10 +709,10 @@ static inline void zig_vmulo_u8(zig_u8 *ov, zig_u8 *res, int n,...@@ -713,10 +709,10 @@ static inline void zig_vmulo_u8(zig_u8 *ov, zig_u8 *res, int n,
713 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u8(&res[i], lhs[i], rhs[i], bits);709 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u8(&res[i], lhs[i], rhs[i], bits);
714}710}
715711
716static inline zig_bool zig_mulo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {712static inline bool zig_mulo_i8(zig_i8 *res, zig_i8 lhs, zig_i8 rhs, zig_u8 bits) {
717#if zig_has_builtin(mul_overflow)713#if zig_has_builtin(mul_overflow)
718 zig_i8 full_res;714 zig_i8 full_res;
719 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);715 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
720 *res = zig_wrap_i8(full_res, bits);716 *res = zig_wrap_i8(full_res, bits);
721 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);717 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);
722#else718#else
...@@ -730,10 +726,10 @@ static inline void zig_vmulo_i8(zig_u8 *ov, zig_i8 *res, int n,...@@ -730,10 +726,10 @@ static inline void zig_vmulo_i8(zig_u8 *ov, zig_i8 *res, int n,
730 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i8(&res[i], lhs[i], rhs[i], bits);726 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i8(&res[i], lhs[i], rhs[i], bits);
731}727}
732728
733static inline zig_bool zig_mulo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {729static inline bool zig_mulo_u16(zig_u16 *res, zig_u16 lhs, zig_u16 rhs, zig_u8 bits) {
734#if zig_has_builtin(mul_overflow)730#if zig_has_builtin(mul_overflow)
735 zig_u16 full_res;731 zig_u16 full_res;
736 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);732 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
737 *res = zig_wrap_u16(full_res, bits);733 *res = zig_wrap_u16(full_res, bits);
738 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);734 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);
739#else735#else
...@@ -747,10 +743,10 @@ static inline void zig_vmulo_u16(zig_u8 *ov, zig_u16 *res, int n,...@@ -747,10 +743,10 @@ static inline void zig_vmulo_u16(zig_u8 *ov, zig_u16 *res, int n,
747 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u16(&res[i], lhs[i], rhs[i], bits);743 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u16(&res[i], lhs[i], rhs[i], bits);
748}744}
749745
750static inline zig_bool zig_mulo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {746static inline bool zig_mulo_i16(zig_i16 *res, zig_i16 lhs, zig_i16 rhs, zig_u8 bits) {
751#if zig_has_builtin(mul_overflow)747#if zig_has_builtin(mul_overflow)
752 zig_i16 full_res;748 zig_i16 full_res;
753 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);749 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
754 *res = zig_wrap_i16(full_res, bits);750 *res = zig_wrap_i16(full_res, bits);
755 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);751 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);
756#else752#else
...@@ -797,12 +793,12 @@ static inline void zig_vmulo_i16(zig_u8 *ov, zig_i16 *res, int n,...@@ -797,12 +793,12 @@ static inline void zig_vmulo_i16(zig_u8 *ov, zig_i16 *res, int n,
797 return zig_wrap_i##w((zig_i##w)((zig_u##w)lhs * (zig_u##w)rhs), bits); \793 return zig_wrap_i##w((zig_i##w)((zig_u##w)lhs * (zig_u##w)rhs), bits); \
798 } \794 } \
799\795\
800 static inline zig_bool zig_shlo_u##w(zig_u##w *res, zig_u##w lhs, zig_u8 rhs, zig_u8 bits) { \796 static inline bool zig_shlo_u##w(zig_u##w *res, zig_u##w lhs, zig_u8 rhs, zig_u8 bits) { \
801 *res = zig_shlw_u##w(lhs, rhs, bits); \797 *res = zig_shlw_u##w(lhs, rhs, bits); \
802 return (lhs & zig_maxInt_u##w << (bits - rhs)) != zig_as_u##w(0); \798 return (lhs & zig_maxInt_u##w << (bits - rhs)) != zig_as_u##w(0); \
803 } \799 } \
804\800\
805 static inline zig_bool zig_shlo_i##w(zig_i##w *res, zig_i##w lhs, zig_u8 rhs, zig_u8 bits) { \801 static inline bool zig_shlo_i##w(zig_i##w *res, zig_i##w lhs, zig_u8 rhs, zig_u8 bits) { \
806 *res = zig_shlw_i##w(lhs, rhs, bits); \802 *res = zig_shlw_i##w(lhs, rhs, bits); \
807 zig_i##w mask = (zig_i##w)(zig_maxInt_u##w << (bits - rhs - 1)); \803 zig_i##w mask = (zig_i##w)(zig_maxInt_u##w << (bits - rhs - 1)); \
808 return (lhs & mask) != zig_as_i##w(0) && (lhs & mask) != mask; \804 return (lhs & mask) != zig_as_i##w(0) && (lhs & mask) != mask; \
...@@ -1327,22 +1323,22 @@ static inline zig_i128 zig_mulw_i128(zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {...@@ -1327,22 +1323,22 @@ static inline zig_i128 zig_mulw_i128(zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {
13271323
1328#if zig_has_int1281324#if zig_has_int128
13291325
1330static inline zig_bool zig_shlo_u128(zig_u128 *res, zig_u128 lhs, zig_u8 rhs, zig_u8 bits) {1326static inline bool zig_shlo_u128(zig_u128 *res, zig_u128 lhs, zig_u8 rhs, zig_u8 bits) {
1331 *res = zig_shlw_u128(lhs, rhs, bits);1327 *res = zig_shlw_u128(lhs, rhs, bits);
1332 return zig_and_u128(lhs, zig_shl_u128(zig_maxInt_u128, bits - rhs)) != zig_as_u128(0, 0);1328 return zig_and_u128(lhs, zig_shl_u128(zig_maxInt_u128, bits - rhs)) != zig_as_u128(0, 0);
1333}1329}
13341330
1335static inline zig_bool zig_shlo_i128(zig_i128 *res, zig_i128 lhs, zig_u8 rhs, zig_u8 bits) {1331static inline bool zig_shlo_i128(zig_i128 *res, zig_i128 lhs, zig_u8 rhs, zig_u8 bits) {
1336 *res = zig_shlw_i128(lhs, rhs, bits);1332 *res = zig_shlw_i128(lhs, rhs, bits);
1337 zig_i128 mask = zig_bitcast_i128(zig_shl_u128(zig_maxInt_u128, bits - rhs - zig_as_u8(1)));1333 zig_i128 mask = zig_bitcast_i128(zig_shl_u128(zig_maxInt_u128, bits - rhs - zig_as_u8(1)));
1338 return zig_cmp_i128(zig_and_i128(lhs, mask), zig_as_i128(0, 0)) != zig_as_i32(0) &&1334 return zig_cmp_i128(zig_and_i128(lhs, mask), zig_as_i128(0, 0)) != zig_as_i32(0) &&
1339 zig_cmp_i128(zig_and_i128(lhs, mask), mask) != zig_as_i32(0);1335 zig_cmp_i128(zig_and_i128(lhs, mask), mask) != zig_as_i32(0);
1340}1336}
13411337
1342static inline zig_bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs, zig_u8 bits) {1338static inline bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs, zig_u8 bits) {
1343#if zig_has_builtin(add_overflow)1339#if zig_has_builtin(add_overflow)
1344 zig_u128 full_res;1340 zig_u128 full_res;
1345 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);1341 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
1346 *res = zig_wrap_u128(full_res, bits);1342 *res = zig_wrap_u128(full_res, bits);
1347 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);1343 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);
1348#else1344#else
...@@ -1352,23 +1348,23 @@ static inline zig_bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,...@@ -1352,23 +1348,23 @@ static inline zig_bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,
1352}1348}
13531349
1354zig_extern zig_i128 __addoti4(zig_i128 lhs, zig_i128 rhs, zig_c_int *overflow);1350zig_extern zig_i128 __addoti4(zig_i128 lhs, zig_i128 rhs, zig_c_int *overflow);
1355static inline zig_bool zig_addo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {1351static inline bool zig_addo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {
1356#if zig_has_builtin(add_overflow)1352#if zig_has_builtin(add_overflow)
1357 zig_i128 full_res;1353 zig_i128 full_res;
1358 zig_bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);1354 bool overflow = __builtin_add_overflow(lhs, rhs, &full_res);
1359#else1355#else
1360 zig_c_int overflow_int;1356 zig_c_int overflow_int;
1361 zig_i128 full_res = __addoti4(lhs, rhs, &overflow_int);1357 zig_i128 full_res = __addoti4(lhs, rhs, &overflow_int);
1362 zig_bool overflow = overflow_int != 0;1358 bool overflow = overflow_int != 0;
1363#endif1359#endif
1364 *res = zig_wrap_i128(full_res, bits);1360 *res = zig_wrap_i128(full_res, bits);
1365 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);1361 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);
1366}1362}
13671363
1368static inline zig_bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs, zig_u8 bits) {1364static inline bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs, zig_u8 bits) {
1369#if zig_has_builtin(sub_overflow)1365#if zig_has_builtin(sub_overflow)
1370 zig_u128 full_res;1366 zig_u128 full_res;
1371 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);1367 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
1372 *res = zig_wrap_u128(full_res, bits);1368 *res = zig_wrap_u128(full_res, bits);
1373 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);1369 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);
1374#else1370#else
...@@ -1378,23 +1374,23 @@ static inline zig_bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,...@@ -1378,23 +1374,23 @@ static inline zig_bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,
1378}1374}
13791375
1380zig_extern zig_i128 __suboti4(zig_i128 lhs, zig_i128 rhs, zig_c_int *overflow);1376zig_extern zig_i128 __suboti4(zig_i128 lhs, zig_i128 rhs, zig_c_int *overflow);
1381static inline zig_bool zig_subo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {1377static inline bool zig_subo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {
1382#if zig_has_builtin(sub_overflow)1378#if zig_has_builtin(sub_overflow)
1383 zig_i128 full_res;1379 zig_i128 full_res;
1384 zig_bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);1380 bool overflow = __builtin_sub_overflow(lhs, rhs, &full_res);
1385#else1381#else
1386 zig_c_int overflow_int;1382 zig_c_int overflow_int;
1387 zig_i128 full_res = __suboti4(lhs, rhs, &overflow_int);1383 zig_i128 full_res = __suboti4(lhs, rhs, &overflow_int);
1388 zig_bool overflow = overflow_int != 0;1384 bool overflow = overflow_int != 0;
1389#endif1385#endif
1390 *res = zig_wrap_i128(full_res, bits);1386 *res = zig_wrap_i128(full_res, bits);
1391 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);1387 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);
1392}1388}
13931389
1394static inline zig_bool zig_mulo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs, zig_u8 bits) {1390static inline bool zig_mulo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs, zig_u8 bits) {
1395#if zig_has_builtin(mul_overflow)1391#if zig_has_builtin(mul_overflow)
1396 zig_u128 full_res;1392 zig_u128 full_res;
1397 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);1393 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
1398 *res = zig_wrap_u128(full_res, bits);1394 *res = zig_wrap_u128(full_res, bits);
1399 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);1395 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);
1400#else1396#else
...@@ -1404,14 +1400,14 @@ static inline zig_bool zig_mulo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,...@@ -1404,14 +1400,14 @@ static inline zig_bool zig_mulo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,
1404}1400}
14051401
1406zig_extern zig_i128 __muloti4(zig_i128 lhs, zig_i128 rhs, zig_c_int *overflow);1402zig_extern zig_i128 __muloti4(zig_i128 lhs, zig_i128 rhs, zig_c_int *overflow);
1407static inline zig_bool zig_mulo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {1403static inline bool zig_mulo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs, zig_u8 bits) {
1408#if zig_has_builtin(mul_overflow)1404#if zig_has_builtin(mul_overflow)
1409 zig_i128 full_res;1405 zig_i128 full_res;
1410 zig_bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);1406 bool overflow = __builtin_mul_overflow(lhs, rhs, &full_res);
1411#else1407#else
1412 zig_c_int overflow_int;1408 zig_c_int overflow_int;
1413 zig_i128 full_res = __muloti4(lhs, rhs, &overflow);1409 zig_i128 full_res = __muloti4(lhs, rhs, &overflow);
1414 zig_bool overflow = overflow_int != 0;1410 bool overflow = overflow_int != 0;
1415#endif1411#endif
1416 *res = zig_wrap_i128(full_res, bits);1412 *res = zig_wrap_i128(full_res, bits);
1417 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);1413 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);
...@@ -1419,12 +1415,12 @@ static inline zig_bool zig_mulo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs,...@@ -1419,12 +1415,12 @@ static inline zig_bool zig_mulo_i128(zig_i128 *res, zig_i128 lhs, zig_i128 rhs,
14191415
1420#else /* zig_has_int128 */1416#else /* zig_has_int128 */
14211417
1422static inline zig_bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs) {1418static inline bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs) {
1423 return zig_addo_u64(&res->hi, lhs.hi, rhs.hi, UINT64_MAX) |1419 return zig_addo_u64(&res->hi, lhs.hi, rhs.hi, UINT64_MAX) |
1424 zig_addo_u64(&res->hi, res->hi, zig_addo_u64(&res->lo, lhs.lo, rhs.lo, UINT64_MAX));1420 zig_addo_u64(&res->hi, res->hi, zig_addo_u64(&res->lo, lhs.lo, rhs.lo, UINT64_MAX));
1425}1421}
14261422
1427static inline zig_bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs) {1423static inline bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs) {
1428 return zig_subo_u64(&res->hi, lhs.hi, rhs.hi, UINT64_MAX) |1424 return zig_subo_u64(&res->hi, lhs.hi, rhs.hi, UINT64_MAX) |
1429 zig_subo_u64(&res->hi, res->hi, zig_subo_u64(&res->lo, lhs.lo, rhs.lo, UINT64_MAX));1425 zig_subo_u64(&res->hi, res->hi, zig_subo_u64(&res->lo, lhs.lo, rhs.lo, UINT64_MAX));
1430}1426}
src/codegen/c.zig+27-9
...@@ -717,10 +717,21 @@ pub const DeclGen = struct {...@@ -717,10 +717,21 @@ pub const DeclGen = struct {
717 val = rt.data;717 val = rt.data;
718 }718 }
719 const target = dg.module.getTarget();719 const target = dg.module.getTarget();
720
721 const safety_on = switch (dg.module.optimizeMode()) {
722 .Debug, .ReleaseSafe => true,
723 .ReleaseFast, .ReleaseSmall => false,
724 };
725
720 if (val.isUndefDeep()) {726 if (val.isUndefDeep()) {
721 switch (ty.zigTypeTag()) {727 switch (ty.zigTypeTag()) {
722 // bool b = 0xaa; evals to true, but memcpy(&b, 0xaa, 1); evals to false.728 .Bool => {
723 .Bool => return dg.renderValue(writer, ty, Value.false, location),729 if (safety_on) {
730 return writer.writeAll("0xaa");
731 } else {
732 return writer.writeAll("false");
733 }
734 },
724 .Int, .Enum, .ErrorSet => return writer.print("{x}", .{try dg.fmtIntLiteral(ty, val)}),735 .Int, .Enum, .ErrorSet => return writer.print("{x}", .{try dg.fmtIntLiteral(ty, val)}),
725 .Float => {736 .Float => {
726 const bits = ty.floatBits(target);737 const bits = ty.floatBits(target);
...@@ -1099,7 +1110,13 @@ pub const DeclGen = struct {...@@ -1099,7 +1110,13 @@ pub const DeclGen = struct {
1099 },1110 },
1100 }1111 }
1101 },1112 },
1102 .Bool => return writer.print("zig_{}", .{val.toBool()}),1113 .Bool => {
1114 if (val.toBool()) {
1115 return writer.writeAll("true");
1116 } else {
1117 return writer.writeAll("false");
1118 }
1119 },
1103 .Optional => {1120 .Optional => {
1104 var opt_buf: Type.Payload.ElemType = undefined;1121 var opt_buf: Type.Payload.ElemType = undefined;
1105 const payload_ty = ty.optionalChild(&opt_buf);1122 const payload_ty = ty.optionalChild(&opt_buf);
...@@ -1141,8 +1158,10 @@ pub const DeclGen = struct {...@@ -1141,8 +1158,10 @@ pub const DeclGen = struct {
11411158
1142 if (!payload_ty.hasRuntimeBits()) {1159 if (!payload_ty.hasRuntimeBits()) {
1143 // We use the error type directly as the type.1160 // We use the error type directly as the type.
1144 const err_val = if (val.errorUnionIsPayload()) Value.initTag(.zero) else val;1161 if (val.errorUnionIsPayload()) {
1145 return dg.renderValue(writer, error_ty, err_val, location);1162 return try writer.writeByte('0');
1163 }
1164 return dg.renderValue(writer, error_ty, val, location);
1146 }1165 }
11471166
1148 if (location != .Initializer) {1167 if (location != .Initializer) {
...@@ -1802,10 +1821,9 @@ pub const DeclGen = struct {...@@ -1802,10 +1821,9 @@ pub const DeclGen = struct {
1802 const target = dg.module.getTarget();1821 const target = dg.module.getTarget();
18031822
1804 switch (t.zigTypeTag()) {1823 switch (t.zigTypeTag()) {
1805 .Void => {1824 .Void => try w.writeAll("void"),
1806 try w.writeAll("void");1825 .Bool => try w.writeAll("bool"),
1807 },1826 .NoReturn, .Float => {
1808 .NoReturn, .Bool, .Float => {
1809 try w.writeAll("zig_");1827 try w.writeAll("zig_");
1810 try t.print(w, dg.module);1828 try t.print(w, dg.module);
1811 },1829 },
test/stage2/cbe.zig+1-1
...@@ -985,7 +985,7 @@ pub fn addCases(ctx: *TestContext) !void {...@@ -985,7 +985,7 @@ pub fn addCases(ctx: *TestContext) !void {
985 ctx.h("header with bool param function", linux_x64,985 ctx.h("header with bool param function", linux_x64,
986 \\export fn start(a: bool) void{_ = a;}986 \\export fn start(a: bool) void{_ = a;}
987 ,987 ,
988 \\zig_extern void start(zig_bool const a0);988 \\zig_extern void start(bool const a0);
989 \\989 \\
990 );990 );
991 ctx.h("header with noreturn function", linux_x64,991 ctx.h("header with noreturn function", linux_x64,