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 @@
66#include <stddef.h>
77#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
919#if defined(__has_builtin)
1020#define zig_has_builtin(builtin) __has_builtin(__builtin_##builtin)
1121#else
......@@ -136,8 +146,8 @@
136146#define memory_order_acq_rel __ATOMIC_ACQ_REL
137147#define memory_order_seq_cst __ATOMIC_SEQ_CST
138148#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)
140#define zig_cmpxchg_weak(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, zig_true , succ, fail)
149#define zig_cmpxchg_strong(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, false, succ, fail)
150#define zig_cmpxchg_weak(obj, expected, desired, succ, fail) __atomic_compare_exchange_n(obj, &(expected), desired, true , succ, fail)
141151#define zig_atomicrmw_xchg(obj, arg, order) __atomic_exchange_n(obj, arg, order)
142152#define zig_atomicrmw_add(obj, arg, order) __atomic_fetch_add (obj, arg, order)
143153#define zig_atomicrmw_sub(obj, arg, order) __atomic_fetch_sub (obj, arg, order)
......@@ -189,20 +199,6 @@
189199
190200#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
206202typedef uintptr_t zig_usize;
207203typedef intptr_t zig_isize;
208204typedef signed short int zig_c_short;
......@@ -330,10 +326,10 @@ zig_int_helpers(16)
330326zig_int_helpers(32)
331327zig_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) {
334330#if zig_has_builtin(add_overflow)
335331 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);
337333 *res = zig_wrap_u32(full_res, bits);
338334 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);
339335#else
......@@ -349,14 +345,14 @@ static inline void zig_vaddo_u32(zig_u8 *ov, zig_u32 *res, int n,
349345}
350346
351347zig_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) {
353349#if zig_has_builtin(add_overflow)
354350 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);
356352#else
357353 zig_c_int overflow_int;
358354 zig_u32 full_res = __addosi4(lhs, rhs, &overflow_int);
359 zig_bool overflow = overflow_int != 0;
355 bool overflow = overflow_int != 0;
360356#endif
361357 *res = zig_wrap_i32(full_res, bits);
362358 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,
368364 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i32(&res[i], lhs[i], rhs[i], bits);
369365}
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) {
372368#if zig_has_builtin(add_overflow)
373369 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);
375371 *res = zig_wrap_u64(full_res, bits);
376372 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);
377373#else
......@@ -387,14 +383,14 @@ static inline void zig_vaddo_u64(zig_u8 *ov, zig_u64 *res, int n,
387383}
388384
389385zig_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) {
391387#if zig_has_builtin(add_overflow)
392388 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);
394390#else
395391 zig_c_int overflow_int;
396392 zig_u64 full_res = __addodi4(lhs, rhs, &overflow_int);
397 zig_bool overflow = overflow_int != 0;
393 bool overflow = overflow_int != 0;
398394#endif
399395 *res = zig_wrap_i64(full_res, bits);
400396 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,
406402 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i64(&res[i], lhs[i], rhs[i], bits);
407403}
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) {
410406#if zig_has_builtin(add_overflow)
411407 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);
413409 *res = zig_wrap_u8(full_res, bits);
414410 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);
415411#else
......@@ -423,10 +419,10 @@ static inline void zig_vaddo_u8(zig_u8 *ov, zig_u8 *res, int n,
423419 for (int i = 0; i < n; ++i) ov[i] = zig_addo_u8(&res[i], lhs[i], rhs[i], bits);
424420}
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) {
427423#if zig_has_builtin(add_overflow)
428424 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);
430426 *res = zig_wrap_i8(full_res, bits);
431427 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);
432428#else
......@@ -440,10 +436,10 @@ static inline void zig_vaddo_i8(zig_u8 *ov, zig_i8 *res, int n,
440436 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i8(&res[i], lhs[i], rhs[i], bits);
441437}
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) {
444440#if zig_has_builtin(add_overflow)
445441 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);
447443 *res = zig_wrap_u16(full_res, bits);
448444 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);
449445#else
......@@ -457,10 +453,10 @@ static inline void zig_vaddo_u16(zig_u8 *ov, zig_u16 *res, int n,
457453 for (int i = 0; i < n; ++i) ov[i] = zig_addo_u16(&res[i], lhs[i], rhs[i], bits);
458454}
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) {
461457#if zig_has_builtin(add_overflow)
462458 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);
464460 *res = zig_wrap_i16(full_res, bits);
465461 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);
466462#else
......@@ -474,10 +470,10 @@ static inline void zig_vaddo_i16(zig_u8 *ov, zig_i16 *res, int n,
474470 for (int i = 0; i < n; ++i) ov[i] = zig_addo_i16(&res[i], lhs[i], rhs[i], bits);
475471}
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) {
478474#if zig_has_builtin(sub_overflow)
479475 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);
481477 *res = zig_wrap_u32(full_res, bits);
482478 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);
483479#else
......@@ -493,14 +489,14 @@ static inline void zig_vsubo_u32(zig_u8 *ov, zig_u32 *res, int n,
493489}
494490
495491zig_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) {
497493#if zig_has_builtin(sub_overflow)
498494 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);
500496#else
501497 zig_c_int overflow_int;
502498 zig_u32 full_res = __subosi4(lhs, rhs, &overflow_int);
503 zig_bool overflow = overflow_int != 0;
499 bool overflow = overflow_int != 0;
504500#endif
505501 *res = zig_wrap_i32(full_res, bits);
506502 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,
512508 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i32(&res[i], lhs[i], rhs[i], bits);
513509}
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) {
516512#if zig_has_builtin(sub_overflow)
517513 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);
519515 *res = zig_wrap_u64(full_res, bits);
520516 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);
521517#else
......@@ -531,14 +527,14 @@ static inline void zig_vsubo_u64(zig_u8 *ov, zig_u64 *res, int n,
531527}
532528
533529zig_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) {
535531#if zig_has_builtin(sub_overflow)
536532 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);
538534#else
539535 zig_c_int overflow_int;
540536 zig_u64 full_res = __subodi4(lhs, rhs, &overflow_int);
541 zig_bool overflow = overflow_int != 0;
537 bool overflow = overflow_int != 0;
542538#endif
543539 *res = zig_wrap_i64(full_res, bits);
544540 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,
550546 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i64(&res[i], lhs[i], rhs[i], bits);
551547}
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) {
554550#if zig_has_builtin(sub_overflow)
555551 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);
557553 *res = zig_wrap_u8(full_res, bits);
558554 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);
559555#else
......@@ -567,10 +563,10 @@ static inline void zig_vsubo_u8(zig_u8 *ov, zig_u8 *res, int n,
567563 for (int i = 0; i < n; ++i) ov[i] = zig_subo_u8(&res[i], lhs[i], rhs[i], bits);
568564}
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) {
571567#if zig_has_builtin(sub_overflow)
572568 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);
574570 *res = zig_wrap_i8(full_res, bits);
575571 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);
576572#else
......@@ -585,10 +581,10 @@ static inline void zig_vsubo_i8(zig_u8 *ov, zig_i8 *res, int n,
585581}
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) {
589585#if zig_has_builtin(sub_overflow)
590586 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);
592588 *res = zig_wrap_u16(full_res, bits);
593589 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);
594590#else
......@@ -603,10 +599,10 @@ static inline void zig_vsubo_u16(zig_u8 *ov, zig_u16 *res, int n,
603599}
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) {
607603#if zig_has_builtin(sub_overflow)
608604 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);
610606 *res = zig_wrap_i16(full_res, bits);
611607 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);
612608#else
......@@ -620,10 +616,10 @@ static inline void zig_vsubo_i16(zig_u8 *ov, zig_i16 *res, int n,
620616 for (int i = 0; i < n; ++i) ov[i] = zig_subo_i16(&res[i], lhs[i], rhs[i], bits);
621617}
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) {
624620#if zig_has_builtin(mul_overflow)
625621 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);
627623 *res = zig_wrap_u32(full_res, bits);
628624 return overflow || full_res < zig_minInt(u32, bits) || full_res > zig_maxInt(u32, bits);
629625#else
......@@ -639,14 +635,14 @@ static inline void zig_vmulo_u32(zig_u8 *ov, zig_u32 *res, int n,
639635}
640636
641637zig_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) {
643639#if zig_has_builtin(mul_overflow)
644640 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);
646642#else
647643 zig_c_int overflow_int;
648644 zig_u32 full_res = __mulosi4(lhs, rhs, &overflow_int);
649 zig_bool overflow = overflow_int != 0;
645 bool overflow = overflow_int != 0;
650646#endif
651647 *res = zig_wrap_i32(full_res, bits);
652648 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,
658654 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i32(&res[i], lhs[i], rhs[i], bits);
659655}
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) {
662658#if zig_has_builtin(mul_overflow)
663659 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);
665661 *res = zig_wrap_u64(full_res, bits);
666662 return overflow || full_res < zig_minInt(u64, bits) || full_res > zig_maxInt(u64, bits);
667663#else
......@@ -677,14 +673,14 @@ static inline void zig_vmulo_u64(zig_u8 *ov, zig_u64 *res, int n,
677673}
678674
679675zig_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) {
681677#if zig_has_builtin(mul_overflow)
682678 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);
684680#else
685681 zig_c_int overflow_int;
686682 zig_u64 full_res = __mulodi4(lhs, rhs, &overflow_int);
687 zig_bool overflow = overflow_int != 0;
683 bool overflow = overflow_int != 0;
688684#endif
689685 *res = zig_wrap_i64(full_res, bits);
690686 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,
696692 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i64(&res[i], lhs[i], rhs[i], bits);
697693}
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) {
700696#if zig_has_builtin(mul_overflow)
701697 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);
703699 *res = zig_wrap_u8(full_res, bits);
704700 return overflow || full_res < zig_minInt(u8, bits) || full_res > zig_maxInt(u8, bits);
705701#else
......@@ -713,10 +709,10 @@ static inline void zig_vmulo_u8(zig_u8 *ov, zig_u8 *res, int n,
713709 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u8(&res[i], lhs[i], rhs[i], bits);
714710}
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) {
717713#if zig_has_builtin(mul_overflow)
718714 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);
720716 *res = zig_wrap_i8(full_res, bits);
721717 return overflow || full_res < zig_minInt(i8, bits) || full_res > zig_maxInt(i8, bits);
722718#else
......@@ -730,10 +726,10 @@ static inline void zig_vmulo_i8(zig_u8 *ov, zig_i8 *res, int n,
730726 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_i8(&res[i], lhs[i], rhs[i], bits);
731727}
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) {
734730#if zig_has_builtin(mul_overflow)
735731 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);
737733 *res = zig_wrap_u16(full_res, bits);
738734 return overflow || full_res < zig_minInt(u16, bits) || full_res > zig_maxInt(u16, bits);
739735#else
......@@ -747,10 +743,10 @@ static inline void zig_vmulo_u16(zig_u8 *ov, zig_u16 *res, int n,
747743 for (int i = 0; i < n; ++i) ov[i] = zig_mulo_u16(&res[i], lhs[i], rhs[i], bits);
748744}
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) {
751747#if zig_has_builtin(mul_overflow)
752748 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);
754750 *res = zig_wrap_i16(full_res, bits);
755751 return overflow || full_res < zig_minInt(i16, bits) || full_res > zig_maxInt(i16, bits);
756752#else
......@@ -797,12 +793,12 @@ static inline void zig_vmulo_i16(zig_u8 *ov, zig_i16 *res, int n,
797793 return zig_wrap_i##w((zig_i##w)((zig_u##w)lhs * (zig_u##w)rhs), bits); \
798794 } \
799795\
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) { \
801797 *res = zig_shlw_u##w(lhs, rhs, bits); \
802798 return (lhs & zig_maxInt_u##w << (bits - rhs)) != zig_as_u##w(0); \
803799 } \
804800\
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) { \
806802 *res = zig_shlw_i##w(lhs, rhs, bits); \
807803 zig_i##w mask = (zig_i##w)(zig_maxInt_u##w << (bits - rhs - 1)); \
808804 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) {
13271323
13281324#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) {
13311327 *res = zig_shlw_u128(lhs, rhs, bits);
13321328 return zig_and_u128(lhs, zig_shl_u128(zig_maxInt_u128, bits - rhs)) != zig_as_u128(0, 0);
13331329}
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) {
13361332 *res = zig_shlw_i128(lhs, rhs, bits);
13371333 zig_i128 mask = zig_bitcast_i128(zig_shl_u128(zig_maxInt_u128, bits - rhs - zig_as_u8(1)));
13381334 return zig_cmp_i128(zig_and_i128(lhs, mask), zig_as_i128(0, 0)) != zig_as_i32(0) &&
13391335 zig_cmp_i128(zig_and_i128(lhs, mask), mask) != zig_as_i32(0);
13401336}
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) {
13431339#if zig_has_builtin(add_overflow)
13441340 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);
13461342 *res = zig_wrap_u128(full_res, bits);
13471343 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);
13481344#else
......@@ -1352,23 +1348,23 @@ static inline zig_bool zig_addo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,
13521348}
13531349
13541350zig_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) {
13561352#if zig_has_builtin(add_overflow)
13571353 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);
13591355#else
13601356 zig_c_int overflow_int;
13611357 zig_i128 full_res = __addoti4(lhs, rhs, &overflow_int);
1362 zig_bool overflow = overflow_int != 0;
1358 bool overflow = overflow_int != 0;
13631359#endif
13641360 *res = zig_wrap_i128(full_res, bits);
13651361 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);
13661362}
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) {
13691365#if zig_has_builtin(sub_overflow)
13701366 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);
13721368 *res = zig_wrap_u128(full_res, bits);
13731369 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);
13741370#else
......@@ -1378,23 +1374,23 @@ static inline zig_bool zig_subo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,
13781374}
13791375
13801376zig_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) {
13821378#if zig_has_builtin(sub_overflow)
13831379 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);
13851381#else
13861382 zig_c_int overflow_int;
13871383 zig_i128 full_res = __suboti4(lhs, rhs, &overflow_int);
1388 zig_bool overflow = overflow_int != 0;
1384 bool overflow = overflow_int != 0;
13891385#endif
13901386 *res = zig_wrap_i128(full_res, bits);
13911387 return overflow || full_res < zig_minInt(i128, bits) || full_res > zig_maxInt(i128, bits);
13921388}
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) {
13951391#if zig_has_builtin(mul_overflow)
13961392 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);
13981394 *res = zig_wrap_u128(full_res, bits);
13991395 return overflow || full_res < zig_minInt(u128, bits) || full_res > zig_maxInt(u128, bits);
14001396#else
......@@ -1404,14 +1400,14 @@ static inline zig_bool zig_mulo_u128(zig_u128 *res, zig_u128 lhs, zig_u128 rhs,
14041400}
14051401
14061402zig_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) {
14081404#if zig_has_builtin(mul_overflow)
14091405 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);
14111407#else
14121408 zig_c_int overflow_int;
14131409 zig_i128 full_res = __muloti4(lhs, rhs, &overflow);
1414 zig_bool overflow = overflow_int != 0;
1410 bool overflow = overflow_int != 0;
14151411#endif
14161412 *res = zig_wrap_i128(full_res, bits);
14171413 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,
14191415
14201416#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) {
14231419 return zig_addo_u64(&res->hi, lhs.hi, rhs.hi, UINT64_MAX) |
14241420 zig_addo_u64(&res->hi, res->hi, zig_addo_u64(&res->lo, lhs.lo, rhs.lo, UINT64_MAX));
14251421}
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) {
14281424 return zig_subo_u64(&res->hi, lhs.hi, rhs.hi, UINT64_MAX) |
14291425 zig_subo_u64(&res->hi, res->hi, zig_subo_u64(&res->lo, lhs.lo, rhs.lo, UINT64_MAX));
14301426}
src/codegen/c.zig+27-9
......@@ -717,10 +717,21 @@ pub const DeclGen = struct {
717717 val = rt.data;
718718 }
719719 const target = dg.module.getTarget();
720
721 const safety_on = switch (dg.module.optimizeMode()) {
722 .Debug, .ReleaseSafe => true,
723 .ReleaseFast, .ReleaseSmall => false,
724 };
725
720726 if (val.isUndefDeep()) {
721727 switch (ty.zigTypeTag()) {
722 // bool b = 0xaa; evals to true, but memcpy(&b, 0xaa, 1); evals to false.
723 .Bool => return dg.renderValue(writer, ty, Value.false, location),
728 .Bool => {
729 if (safety_on) {
730 return writer.writeAll("0xaa");
731 } else {
732 return writer.writeAll("false");
733 }
734 },
724735 .Int, .Enum, .ErrorSet => return writer.print("{x}", .{try dg.fmtIntLiteral(ty, val)}),
725736 .Float => {
726737 const bits = ty.floatBits(target);
......@@ -1099,7 +1110,13 @@ pub const DeclGen = struct {
10991110 },
11001111 }
11011112 },
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 },
11031120 .Optional => {
11041121 var opt_buf: Type.Payload.ElemType = undefined;
11051122 const payload_ty = ty.optionalChild(&opt_buf);
......@@ -1141,8 +1158,10 @@ pub const DeclGen = struct {
11411158
11421159 if (!payload_ty.hasRuntimeBits()) {
11431160 // We use the error type directly as the type.
1144 const err_val = if (val.errorUnionIsPayload()) Value.initTag(.zero) else val;
1145 return dg.renderValue(writer, error_ty, err_val, location);
1161 if (val.errorUnionIsPayload()) {
1162 return try writer.writeByte('0');
1163 }
1164 return dg.renderValue(writer, error_ty, val, location);
11461165 }
11471166
11481167 if (location != .Initializer) {
......@@ -1802,10 +1821,9 @@ pub const DeclGen = struct {
18021821 const target = dg.module.getTarget();
18031822
18041823 switch (t.zigTypeTag()) {
1805 .Void => {
1806 try w.writeAll("void");
1807 },
1808 .NoReturn, .Bool, .Float => {
1824 .Void => try w.writeAll("void"),
1825 .Bool => try w.writeAll("bool"),
1826 .NoReturn, .Float => {
18091827 try w.writeAll("zig_");
18101828 try t.print(w, dg.module);
18111829 },
test/stage2/cbe.zig+1-1
......@@ -985,7 +985,7 @@ pub fn addCases(ctx: *TestContext) !void {
985985 ctx.h("header with bool param function", linux_x64,
986986 \\export fn start(a: bool) void{_ = a;}
987987 ,
988 \\zig_extern void start(zig_bool const a0);
988 \\zig_extern void start(bool const a0);
989989 \\
990990 );
991991 ctx.h("header with noreturn function", linux_x64,