* [PATCH 0/4] tools/nolibc: add stdint and more integer types
@ 2023-03-04 14:26 Willy Tarreau
2023-03-04 14:26 ` [PATCH 1/4] tools/nolibc: add stdint.h Willy Tarreau
` (3 more replies)
0 siblings, 4 replies; 7+ messages in thread
From: Willy Tarreau @ 2023-03-04 14:26 UTC (permalink / raw)
To: paulmck; +Cc: linux, linux-kernel, Willy Tarreau
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain; charset=UTF-8, Size: 4663 bytes --]
Hello Paul,
This first series of patches against nolibc is Vincent Dagonneau's final
work with the kind help from Thomas Weißschuh who reviewed it.
It adds stdint, the accompanying types (uint64_t etc) and their limits.
Vincent wrote extensive tests for these limits that were added at the
end of the stdlib test series. What's nice is that the definitions are
mostly based on calculations from the compiler's provided limits while
the tests are made against hard-coded hex values, so this may possibly
help spot unexpected surprises with some uncommon compiler settings (or
even bugs in the printf implementation). And given that it required
several round trips to get to work on all archs, I tend to think that
it's quite sensitive to misconfigurations, which is a nice feature.
Running it on x86_64 gives me this:
19 limit_int8_max = 127 [OK]
20 limit_int8_min = -128 [OK]
21 limit_uint8_max = 255 [OK]
22 limit_int16_max = 32767 [OK]
23 limit_int16_min = -32768 [OK]
24 limit_uint16_max = 65535 [OK]
25 limit_int32_max = 2147483647 [OK]
26 limit_int32_min = -2147483648 [OK]
27 limit_uint32_max = 4294967295 [OK]
28 limit_int64_max = 9223372036854775807 [OK]
29 limit_int64_min = -9223372036854775808 [OK]
30 limit_uint64_max = -1 [OK]
31 limit_int_least8_max = 127 [OK]
32 limit_int_least8_min = -128 [OK]
33 limit_uint_least8_max = 255 [OK]
34 limit_int_least16_max = 32767 [OK]
35 limit_int_least16_min = -32768 [OK]
36 limit_uint_least16_max = 65535 [OK]
37 limit_int_least32_max = 2147483647 [OK]
38 limit_int_least32_min = -2147483648 [OK]
39 limit_uint_least32_max = 4294967295 [OK]
40 limit_int_least64_min = -9223372036854775808 [OK]
41 limit_int_least64_max = 9223372036854775807 [OK]
42 limit_uint_least64_max = -1 [OK]
43 limit_int_fast8_max = 127 [OK]
44 limit_int_fast8_min = -128 [OK]
45 limit_uint_fast8_max = 255 [OK]
46 limit_int_fast16_min = -9223372036854775808 [OK]
47 limit_int_fast16_max = 9223372036854775807 [OK]
48 limit_uint_fast16_max = -1 [OK]
49 limit_int_fast32_min = -9223372036854775808 [OK]
50 limit_int_fast32_max = 9223372036854775807 [OK]
51 limit_uint_fast32_max = -1 [OK]
52 limit_int_fast64_min = -9223372036854775808 [OK]
53 limit_int_fast64_max = 9223372036854775807 [OK]
54 limit_uint_fast64_max = -1 [OK]
56 limit_intptr_min = -9223372036854775808 [OK]
57 limit_intptr_max = 9223372036854775807 [OK]
58 limit_uintptr_max = -1 [OK]
59 limit_ptrdiff_min = -9223372036854775808 [OK]
60 limit_ptrdiff_max = 9223372036854775807 [OK]
61 limit_size_max = -1 [OK]
This series was rebased on top of your dev.2023.02.22a branch that was
recently merged into rcu/next. If you want me to rebase it on any other
branch, just let me know. If it could make it for 6.4, it would be great.
Thank you!
Willy
Vincent Dagonneau (4):
tools/nolibc: add stdint.h
tools/nolibc: add integer types and integer limit macros
tools/nolibc: enlarge column width of tests
tools/nolibc: add tests for the integer limits in stdint.h
tools/include/nolibc/Makefile | 4 +-
tools/include/nolibc/std.h | 15 +-
tools/include/nolibc/stdint.h | 99 ++++++++++++
tools/testing/selftests/nolibc/nolibc-test.c | 149 +++++++++++++------
4 files changed, 203 insertions(+), 64 deletions(-)
create mode 100644 tools/include/nolibc/stdint.h
--
2.17.5
^ permalink raw reply [flat|nested] 7+ messages in thread* [PATCH 1/4] tools/nolibc: add stdint.h 2023-03-04 14:26 [PATCH 0/4] tools/nolibc: add stdint and more integer types Willy Tarreau @ 2023-03-04 14:26 ` Willy Tarreau 2023-03-05 0:47 ` Paul E. McKenney 2023-03-04 14:26 ` [PATCH 2/4] tools/nolibc: add integer types and integer limit macros Willy Tarreau ` (2 subsequent siblings) 3 siblings, 1 reply; 7+ messages in thread From: Willy Tarreau @ 2023-03-04 14:26 UTC (permalink / raw) To: paulmck; +Cc: linux, linux-kernel, Vincent Dagonneau, Willy Tarreau From: Vincent Dagonneau <v@vda.io> Nolibc works fine for small and limited program however most program expect integer types to be defined in stdint.h rather than std.h. This is a quick fix that moves the existing integer definitions in std.h to stdint.h. Signed-off-by: Vincent Dagonneau <v@vda.io> Reviewed-by: Thomas Weißschuh <linux@weissschuh.net> Signed-off-by: Willy Tarreau <w@1wt.eu> --- tools/include/nolibc/Makefile | 4 ++-- tools/include/nolibc/std.h | 15 +-------------- tools/include/nolibc/stdint.h | 24 ++++++++++++++++++++++++ 3 files changed, 27 insertions(+), 16 deletions(-) create mode 100644 tools/include/nolibc/stdint.h diff --git a/tools/include/nolibc/Makefile b/tools/include/nolibc/Makefile index cfd06764b5ae..ec57d3932506 100644 --- a/tools/include/nolibc/Makefile +++ b/tools/include/nolibc/Makefile @@ -25,8 +25,8 @@ endif nolibc_arch := $(patsubst arm64,aarch64,$(ARCH)) arch_file := arch-$(nolibc_arch).h -all_files := ctype.h errno.h nolibc.h signal.h std.h stdio.h stdlib.h string.h \ - sys.h time.h types.h unistd.h +all_files := ctype.h errno.h nolibc.h signal.h std.h stdint.h stdio.h stdlib.h \ + string.h sys.h time.h types.h unistd.h # install all headers needed to support a bare-metal compiler all: headers diff --git a/tools/include/nolibc/std.h b/tools/include/nolibc/std.h index 1747ae125392..933bc0be7e1c 100644 --- a/tools/include/nolibc/std.h +++ b/tools/include/nolibc/std.h @@ -18,20 +18,7 @@ #define NULL ((void *)0) #endif -/* stdint types */ -typedef unsigned char uint8_t; -typedef signed char int8_t; -typedef unsigned short uint16_t; -typedef signed short int16_t; -typedef unsigned int uint32_t; -typedef signed int int32_t; -typedef unsigned long long uint64_t; -typedef signed long long int64_t; -typedef unsigned long size_t; -typedef signed long ssize_t; -typedef unsigned long uintptr_t; -typedef signed long intptr_t; -typedef signed long ptrdiff_t; +#include "stdint.h" /* those are commonly provided by sys/types.h */ typedef unsigned int dev_t; diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h new file mode 100644 index 000000000000..4ba264031df9 --- /dev/null +++ b/tools/include/nolibc/stdint.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: LGPL-2.1 OR MIT */ +/* + * Standard definitions and types for NOLIBC + * Copyright (C) 2023 Vincent Dagonneau <v@vda.io> + */ + +#ifndef _NOLIBC_STDINT_H +#define _NOLIBC_STDINT_H + +typedef unsigned char uint8_t; +typedef signed char int8_t; +typedef unsigned short uint16_t; +typedef signed short int16_t; +typedef unsigned int uint32_t; +typedef signed int int32_t; +typedef unsigned long long uint64_t; +typedef signed long long int64_t; +typedef unsigned long size_t; +typedef signed long ssize_t; +typedef unsigned long uintptr_t; +typedef signed long intptr_t; +typedef signed long ptrdiff_t; + +#endif /* _NOLIBC_STDINT_H */ -- 2.17.5 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH 1/4] tools/nolibc: add stdint.h 2023-03-04 14:26 ` [PATCH 1/4] tools/nolibc: add stdint.h Willy Tarreau @ 2023-03-05 0:47 ` Paul E. McKenney 2023-03-05 4:27 ` Willy Tarreau 0 siblings, 1 reply; 7+ messages in thread From: Paul E. McKenney @ 2023-03-05 0:47 UTC (permalink / raw) To: Willy Tarreau; +Cc: linux, linux-kernel, Vincent Dagonneau On Sat, Mar 04, 2023 at 03:26:03PM +0100, Willy Tarreau wrote: > From: Vincent Dagonneau <v@vda.io> > > Nolibc works fine for small and limited program however most program > expect integer types to be defined in stdint.h rather than std.h. > > This is a quick fix that moves the existing integer definitions in std.h > to stdint.h. > > Signed-off-by: Vincent Dagonneau <v@vda.io> > Reviewed-by: Thomas Weißschuh <linux@weissschuh.net> > Signed-off-by: Willy Tarreau <w@1wt.eu> I queued all three serieses, and it does look good, thank you! make[1]: Leaving directory '/home/git/linux-rcu' 125 test(s) passed. I am figuring on pushing these into the v6.4 merge window, that is, the one after the current just-now-closing merge window. Thanx, Paul > --- > tools/include/nolibc/Makefile | 4 ++-- > tools/include/nolibc/std.h | 15 +-------------- > tools/include/nolibc/stdint.h | 24 ++++++++++++++++++++++++ > 3 files changed, 27 insertions(+), 16 deletions(-) > create mode 100644 tools/include/nolibc/stdint.h > > diff --git a/tools/include/nolibc/Makefile b/tools/include/nolibc/Makefile > index cfd06764b5ae..ec57d3932506 100644 > --- a/tools/include/nolibc/Makefile > +++ b/tools/include/nolibc/Makefile > @@ -25,8 +25,8 @@ endif > > nolibc_arch := $(patsubst arm64,aarch64,$(ARCH)) > arch_file := arch-$(nolibc_arch).h > -all_files := ctype.h errno.h nolibc.h signal.h std.h stdio.h stdlib.h string.h \ > - sys.h time.h types.h unistd.h > +all_files := ctype.h errno.h nolibc.h signal.h std.h stdint.h stdio.h stdlib.h \ > + string.h sys.h time.h types.h unistd.h > > # install all headers needed to support a bare-metal compiler > all: headers > diff --git a/tools/include/nolibc/std.h b/tools/include/nolibc/std.h > index 1747ae125392..933bc0be7e1c 100644 > --- a/tools/include/nolibc/std.h > +++ b/tools/include/nolibc/std.h > @@ -18,20 +18,7 @@ > #define NULL ((void *)0) > #endif > > -/* stdint types */ > -typedef unsigned char uint8_t; > -typedef signed char int8_t; > -typedef unsigned short uint16_t; > -typedef signed short int16_t; > -typedef unsigned int uint32_t; > -typedef signed int int32_t; > -typedef unsigned long long uint64_t; > -typedef signed long long int64_t; > -typedef unsigned long size_t; > -typedef signed long ssize_t; > -typedef unsigned long uintptr_t; > -typedef signed long intptr_t; > -typedef signed long ptrdiff_t; > +#include "stdint.h" > > /* those are commonly provided by sys/types.h */ > typedef unsigned int dev_t; > diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h > new file mode 100644 > index 000000000000..4ba264031df9 > --- /dev/null > +++ b/tools/include/nolibc/stdint.h > @@ -0,0 +1,24 @@ > +/* SPDX-License-Identifier: LGPL-2.1 OR MIT */ > +/* > + * Standard definitions and types for NOLIBC > + * Copyright (C) 2023 Vincent Dagonneau <v@vda.io> > + */ > + > +#ifndef _NOLIBC_STDINT_H > +#define _NOLIBC_STDINT_H > + > +typedef unsigned char uint8_t; > +typedef signed char int8_t; > +typedef unsigned short uint16_t; > +typedef signed short int16_t; > +typedef unsigned int uint32_t; > +typedef signed int int32_t; > +typedef unsigned long long uint64_t; > +typedef signed long long int64_t; > +typedef unsigned long size_t; > +typedef signed long ssize_t; > +typedef unsigned long uintptr_t; > +typedef signed long intptr_t; > +typedef signed long ptrdiff_t; > + > +#endif /* _NOLIBC_STDINT_H */ > -- > 2.17.5 > ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 1/4] tools/nolibc: add stdint.h 2023-03-05 0:47 ` Paul E. McKenney @ 2023-03-05 4:27 ` Willy Tarreau 0 siblings, 0 replies; 7+ messages in thread From: Willy Tarreau @ 2023-03-05 4:27 UTC (permalink / raw) To: Paul E. McKenney; +Cc: linux, linux-kernel, Vincent Dagonneau Hello Paul, On Sat, Mar 04, 2023 at 04:47:34PM -0800, Paul E. McKenney wrote: > On Sat, Mar 04, 2023 at 03:26:03PM +0100, Willy Tarreau wrote: > > From: Vincent Dagonneau <v@vda.io> > > > > Nolibc works fine for small and limited program however most program > > expect integer types to be defined in stdint.h rather than std.h. > > > > This is a quick fix that moves the existing integer definitions in std.h > > to stdint.h. > > > > Signed-off-by: Vincent Dagonneau <v@vda.io> > > Reviewed-by: Thomas Weißschuh <linux@weissschuh.net> > > Signed-off-by: Willy Tarreau <w@1wt.eu> > > I queued all three serieses, and it does look good, thank you! > > make[1]: Leaving directory '/home/git/linux-rcu' > 125 test(s) passed. > > I am figuring on pushing these into the v6.4 merge window, that is, > the one after the current just-now-closing merge window. Yes that was the intent, so that we still have time to make some adjustments if any would be needed. Many thanks! Willy ^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH 2/4] tools/nolibc: add integer types and integer limit macros 2023-03-04 14:26 [PATCH 0/4] tools/nolibc: add stdint and more integer types Willy Tarreau 2023-03-04 14:26 ` [PATCH 1/4] tools/nolibc: add stdint.h Willy Tarreau @ 2023-03-04 14:26 ` Willy Tarreau 2023-03-04 14:26 ` [PATCH 3/4] tools/nolibc: enlarge column width of tests Willy Tarreau 2023-03-04 14:26 ` [PATCH 4/4] tools/nolibc: add tests for the integer limits in stdint.h Willy Tarreau 3 siblings, 0 replies; 7+ messages in thread From: Willy Tarreau @ 2023-03-04 14:26 UTC (permalink / raw) To: paulmck; +Cc: linux, linux-kernel, Vincent Dagonneau, Willy Tarreau From: Vincent Dagonneau <v@vda.io> This commit adds some of the missing integer types to stdint.h and adds limit macros (e.g. INTN_{MIN,MAX}). The reference used for adding these types is https://pubs.opengroup.org/onlinepubs/009695399/basedefs/stdint.h.html. We rely on the compiler-defined __LONG_MAX__ to get the right limits for size_t, intptr_t, uintptr_t and ptrdiff_t. This compiler constant seem to have been defined at least since GCC 4.1.2 and clang 3.0.0 on x86_64. It is also defined on ARM (32&64), mips and RISC-V. Note that the maximum size of size_t is implementation-defined (>65535), in this case I chose to go with unsigned long on all platforms since unsigned long == unsigned int on all the platforms we care about. Note that the kernel uses either unsigned int or unsigned long in linux/include/uapi/asm-generic/posix_types.h. These should be equivalent for the plaforms we are targeting. Also note that the 'fast*' flavor of the types have been chosen to be always 1 byte for '*fast8*' and always long (a.k.a. intptr_t/uintptr_t) for the other variants. I have never seen the 'fast*' types in use in the wild but that seems to be what glibc does. Signed-off-by: Vincent Dagonneau <v@vda.io> Reviewed-by: Thomas Weißschuh <linux@weissschuh.net> Signed-off-by: Willy Tarreau <w@1wt.eu> --- tools/include/nolibc/stdint.h | 75 +++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h index 4ba264031df9..c1ce4f5e0603 100644 --- a/tools/include/nolibc/stdint.h +++ b/tools/include/nolibc/stdint.h @@ -21,4 +21,79 @@ typedef unsigned long uintptr_t; typedef signed long intptr_t; typedef signed long ptrdiff_t; +typedef int8_t int_least8_t; +typedef uint8_t uint_least8_t; +typedef int16_t int_least16_t; +typedef uint16_t uint_least16_t; +typedef int32_t int_least32_t; +typedef uint32_t uint_least32_t; +typedef int64_t int_least64_t; +typedef uint64_t uint_least64_t; + +typedef int8_t int_fast8_t; +typedef uint8_t uint_fast8_t; +typedef ssize_t int_fast16_t; +typedef size_t uint_fast16_t; +typedef ssize_t int_fast32_t; +typedef size_t uint_fast32_t; +typedef ssize_t int_fast64_t; +typedef size_t uint_fast64_t; + +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + +/* limits of integral types */ + +#define INT8_MIN (-128) +#define INT16_MIN (-32767-1) +#define INT32_MIN (-2147483647-1) +#define INT64_MIN (-9223372036854775807LL-1) + +#define INT8_MAX (127) +#define INT16_MAX (32767) +#define INT32_MAX (2147483647) +#define INT64_MAX (9223372036854775807LL) + +#define UINT8_MAX (255) +#define UINT16_MAX (65535) +#define UINT32_MAX (4294967295U) +#define UINT64_MAX (18446744073709551615ULL) + +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST64_MIN INT64_MIN + +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MAX INT64_MAX + +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +#define SIZE_MAX ((size_t)(__LONG_MAX__) * 2 + 1) +#define INTPTR_MIN (-__LONG_MAX__ - 1) +#define INTPTR_MAX __LONG_MAX__ +#define PTRDIFF_MIN INTPTR_MIN +#define PTRDIFF_MAX INTPTR_MAX +#define UINTPTR_MAX SIZE_MAX + +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST16_MIN INTPTR_MIN +#define INT_FAST32_MIN INTPTR_MIN +#define INT_FAST64_MIN INTPTR_MIN + +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MAX INTPTR_MAX +#define INT_FAST32_MAX INTPTR_MAX +#define INT_FAST64_MAX INTPTR_MAX + +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX SIZE_MAX +#define UINT_FAST32_MAX SIZE_MAX +#define UINT_FAST64_MAX SIZE_MAX + #endif /* _NOLIBC_STDINT_H */ -- 2.17.5 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH 3/4] tools/nolibc: enlarge column width of tests 2023-03-04 14:26 [PATCH 0/4] tools/nolibc: add stdint and more integer types Willy Tarreau 2023-03-04 14:26 ` [PATCH 1/4] tools/nolibc: add stdint.h Willy Tarreau 2023-03-04 14:26 ` [PATCH 2/4] tools/nolibc: add integer types and integer limit macros Willy Tarreau @ 2023-03-04 14:26 ` Willy Tarreau 2023-03-04 14:26 ` [PATCH 4/4] tools/nolibc: add tests for the integer limits in stdint.h Willy Tarreau 3 siblings, 0 replies; 7+ messages in thread From: Willy Tarreau @ 2023-03-04 14:26 UTC (permalink / raw) To: paulmck; +Cc: linux, linux-kernel, Vincent Dagonneau, Willy Tarreau From: Vincent Dagonneau <v@vda.io> This commit enlarges the column width from 40 to 64 characters to make room for longer tests Signed-off-by: Vincent Dagonneau <v@vda.io> Reviewed-by: Thomas Weißschuh <linux@weissschuh.net> Signed-off-by: Willy Tarreau <w@1wt.eu> --- tools/testing/selftests/nolibc/nolibc-test.c | 96 ++++++++++---------- 1 file changed, 48 insertions(+), 48 deletions(-) diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c index c4a0c915139c..882140508d56 100644 --- a/tools/testing/selftests/nolibc/nolibc-test.c +++ b/tools/testing/selftests/nolibc/nolibc-test.c @@ -130,111 +130,111 @@ static int pad_spc(int llen, int cnt, const char *fmt, ...) */ #define EXPECT_ZR(cond, expr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_zr(expr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_zr(expr, llen); } while (0) static int expect_zr(int expr, int llen) { int ret = !(expr == 0); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_NZ(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_nz(expr, llen; } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_nz(expr, llen; } while (0) static int expect_nz(int expr, int llen) { int ret = !(expr != 0); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_EQ(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_eq(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_eq(expr, llen, val); } while (0) -static int expect_eq(int expr, int llen, int val) +static int expect_eq(uint64_t expr, int llen, uint64_t val) { int ret = !(expr == val); - llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + llen += printf(" = %lld ", expr); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_NE(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_ne(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ne(expr, llen, val); } while (0) static int expect_ne(int expr, int llen, int val) { int ret = !(expr != val); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_GE(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_ge(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ge(expr, llen, val); } while (0) static int expect_ge(int expr, int llen, int val) { int ret = !(expr >= val); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_GT(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_gt(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_gt(expr, llen, val); } while (0) static int expect_gt(int expr, int llen, int val) { int ret = !(expr > val); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_LE(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_le(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_le(expr, llen, val); } while (0) static int expect_le(int expr, int llen, int val) { int ret = !(expr <= val); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_LT(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_lt(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_lt(expr, llen, val); } while (0) static int expect_lt(int expr, int llen, int val) { int ret = !(expr < val); llen += printf(" = %d ", expr); - pad_spc(llen, 40, ret ? "[FAIL]\n" : " [OK]\n"); + pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n"); return ret; } #define EXPECT_SYSZR(cond, expr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_syszr(expr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syszr(expr, llen); } while (0) static int expect_syszr(int expr, int llen) { @@ -243,17 +243,17 @@ static int expect_syszr(int expr, int llen) if (expr) { ret = 1; llen += printf(" = %d %s ", expr, errorname(errno)); - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { llen += printf(" = %d ", expr); - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_SYSEQ(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_syseq(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syseq(expr, llen, val); } while (0) static int expect_syseq(int expr, int llen, int val) { @@ -262,17 +262,17 @@ static int expect_syseq(int expr, int llen, int val) if (expr != val) { ret = 1; llen += printf(" = %d %s ", expr, errorname(errno)); - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { llen += printf(" = %d ", expr); - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_SYSNE(cond, expr, val) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_sysne(expr, llen, val); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_sysne(expr, llen, val); } while (0) static int expect_sysne(int expr, int llen, int val) { @@ -281,17 +281,17 @@ static int expect_sysne(int expr, int llen, int val) if (expr == val) { ret = 1; llen += printf(" = %d %s ", expr, errorname(errno)); - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { llen += printf(" = %d ", expr); - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_SYSER(cond, expr, expret, experr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_syserr(expr, expret, experr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syserr(expr, expret, experr, llen); } while (0) static int expect_syserr(int expr, int expret, int experr, int llen) { @@ -302,16 +302,16 @@ static int expect_syserr(int expr, int expret, int experr, int llen) if (expr != expret || _errno != experr) { ret = 1; llen += printf(" != (%d %s) ", expret, errorname(experr)); - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_PTRZR(cond, expr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_ptrzr(expr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrzr(expr, llen); } while (0) static int expect_ptrzr(const void *expr, int llen) { @@ -320,16 +320,16 @@ static int expect_ptrzr(const void *expr, int llen) llen += printf(" = <%p> ", expr); if (expr) { ret = 1; - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_PTRNZ(cond, expr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_ptrnz(expr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrnz(expr, llen); } while (0) static int expect_ptrnz(const void *expr, int llen) { @@ -338,16 +338,16 @@ static int expect_ptrnz(const void *expr, int llen) llen += printf(" = <%p> ", expr); if (!expr) { ret = 1; - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_STRZR(cond, expr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_strzr(expr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strzr(expr, llen); } while (0) static int expect_strzr(const char *expr, int llen) { @@ -356,16 +356,16 @@ static int expect_strzr(const char *expr, int llen) llen += printf(" = <%s> ", expr); if (expr) { ret = 1; - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_STRNZ(cond, expr) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_strnz(expr, llen); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strnz(expr, llen); } while (0) static int expect_strnz(const char *expr, int llen) { @@ -374,16 +374,16 @@ static int expect_strnz(const char *expr, int llen) llen += printf(" = <%s> ", expr); if (!expr) { ret = 1; - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_STREQ(cond, expr, cmp) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_streq(expr, llen, cmp); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_streq(expr, llen, cmp); } while (0) static int expect_streq(const char *expr, int llen, const char *cmp) { @@ -392,16 +392,16 @@ static int expect_streq(const char *expr, int llen, const char *cmp) llen += printf(" = <%s> ", expr); if (strcmp(expr, cmp) != 0) { ret = 1; - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } #define EXPECT_STRNE(cond, expr, cmp) \ - do { if (!cond) pad_spc(llen, 40, "[SKIPPED]\n"); else ret += expect_strne(expr, llen, cmp); } while (0) + do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strne(expr, llen, cmp); } while (0) static int expect_strne(const char *expr, int llen, const char *cmp) { @@ -410,9 +410,9 @@ static int expect_strne(const char *expr, int llen, const char *cmp) llen += printf(" = <%s> ", expr); if (strcmp(expr, cmp) == 0) { ret = 1; - llen += pad_spc(llen, 40, "[FAIL]\n"); + llen += pad_spc(llen, 64, "[FAIL]\n"); } else { - llen += pad_spc(llen, 40, " [OK]\n"); + llen += pad_spc(llen, 64, " [OK]\n"); } return ret; } -- 2.17.5 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH 4/4] tools/nolibc: add tests for the integer limits in stdint.h 2023-03-04 14:26 [PATCH 0/4] tools/nolibc: add stdint and more integer types Willy Tarreau ` (2 preceding siblings ...) 2023-03-04 14:26 ` [PATCH 3/4] tools/nolibc: enlarge column width of tests Willy Tarreau @ 2023-03-04 14:26 ` Willy Tarreau 3 siblings, 0 replies; 7+ messages in thread From: Willy Tarreau @ 2023-03-04 14:26 UTC (permalink / raw) To: paulmck; +Cc: linux, linux-kernel, Vincent Dagonneau, Willy Tarreau From: Vincent Dagonneau <v@vda.io> This commit adds tests for the limits added in a previous commit. The limits are defined in decimal in stdint.h and as hexadecimal in the tests (e.g. 0x7f = 127 or 0x80 = -128). Hopefully it catches some of the most egregious mistakes. As we rely on the compiler to provide __SIZEOF_LONG__, we also test whether it is defined. Signed-off-by: Vincent Dagonneau <v@vda.io> Reviewed-by: Thomas Weißschuh <linux@weissschuh.net> Signed-off-by: Willy Tarreau <w@1wt.eu> --- tools/testing/selftests/nolibc/nolibc-test.c | 53 ++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c index 882140508d56..772f88bda0f1 100644 --- a/tools/testing/selftests/nolibc/nolibc-test.c +++ b/tools/testing/selftests/nolibc/nolibc-test.c @@ -602,6 +602,59 @@ int run_stdlib(int min, int max) CASE_TEST(memcmp_e0_20); EXPECT_GT(1, memcmp("aaa\xe0", "aaa\x20", 4), 0); break; CASE_TEST(memcmp_80_e0); EXPECT_LT(1, memcmp("aaa\x80", "aaa\xe0", 4), 0); break; CASE_TEST(memcmp_e0_80); EXPECT_GT(1, memcmp("aaa\xe0", "aaa\x80", 4), 0); break; + CASE_TEST(limit_int8_max); EXPECT_EQ(1, INT8_MAX, (int8_t) 0x7f); break; + CASE_TEST(limit_int8_min); EXPECT_EQ(1, INT8_MIN, (int8_t) 0x80); break; + CASE_TEST(limit_uint8_max); EXPECT_EQ(1, UINT8_MAX, (uint8_t) 0xff); break; + CASE_TEST(limit_int16_max); EXPECT_EQ(1, INT16_MAX, (int16_t) 0x7fff); break; + CASE_TEST(limit_int16_min); EXPECT_EQ(1, INT16_MIN, (int16_t) 0x8000); break; + CASE_TEST(limit_uint16_max); EXPECT_EQ(1, UINT16_MAX, (uint16_t) 0xffff); break; + CASE_TEST(limit_int32_max); EXPECT_EQ(1, INT32_MAX, (int32_t) 0x7fffffff); break; + CASE_TEST(limit_int32_min); EXPECT_EQ(1, INT32_MIN, (int32_t) 0x80000000); break; + CASE_TEST(limit_uint32_max); EXPECT_EQ(1, UINT32_MAX, (uint32_t) 0xffffffff); break; + CASE_TEST(limit_int64_max); EXPECT_EQ(1, INT64_MAX, (int64_t) 0x7fffffffffffffff); break; + CASE_TEST(limit_int64_min); EXPECT_EQ(1, INT64_MIN, (int64_t) 0x8000000000000000); break; + CASE_TEST(limit_uint64_max); EXPECT_EQ(1, UINT64_MAX, (uint64_t) 0xffffffffffffffff); break; + CASE_TEST(limit_int_least8_max); EXPECT_EQ(1, INT_LEAST8_MAX, (int_least8_t) 0x7f); break; + CASE_TEST(limit_int_least8_min); EXPECT_EQ(1, INT_LEAST8_MIN, (int_least8_t) 0x80); break; + CASE_TEST(limit_uint_least8_max); EXPECT_EQ(1, UINT_LEAST8_MAX, (uint_least8_t) 0xff); break; + CASE_TEST(limit_int_least16_max); EXPECT_EQ(1, INT_LEAST16_MAX, (int_least16_t) 0x7fff); break; + CASE_TEST(limit_int_least16_min); EXPECT_EQ(1, INT_LEAST16_MIN, (int_least16_t) 0x8000); break; + CASE_TEST(limit_uint_least16_max); EXPECT_EQ(1, UINT_LEAST16_MAX, (uint_least16_t) 0xffff); break; + CASE_TEST(limit_int_least32_max); EXPECT_EQ(1, INT_LEAST32_MAX, (int_least32_t) 0x7fffffff); break; + CASE_TEST(limit_int_least32_min); EXPECT_EQ(1, INT_LEAST32_MIN, (int_least32_t) 0x80000000); break; + CASE_TEST(limit_uint_least32_max); EXPECT_EQ(1, UINT_LEAST32_MAX, (uint_least32_t) 0xffffffffU); break; + CASE_TEST(limit_int_least64_min); EXPECT_EQ(1, INT_LEAST64_MIN, (int_least64_t) 0x8000000000000000LL); break; + CASE_TEST(limit_int_least64_max); EXPECT_EQ(1, INT_LEAST64_MAX, (int_least64_t) 0x7fffffffffffffffLL); break; + CASE_TEST(limit_uint_least64_max); EXPECT_EQ(1, UINT_LEAST64_MAX, (uint_least64_t) 0xffffffffffffffffULL); break; + CASE_TEST(limit_int_fast8_max); EXPECT_EQ(1, INT_FAST8_MAX, (int_fast8_t) 0x7f); break; + CASE_TEST(limit_int_fast8_min); EXPECT_EQ(1, INT_FAST8_MIN, (int_fast8_t) 0x80); break; + CASE_TEST(limit_uint_fast8_max); EXPECT_EQ(1, UINT_FAST8_MAX, (uint_fast8_t) 0xff); break; + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) INTPTR_MIN); break; + CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) INTPTR_MAX); break; + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) UINTPTR_MAX); break; + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) INTPTR_MIN); break; + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) INTPTR_MAX); break; + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) UINTPTR_MAX); break; + CASE_TEST(limit_int_fast64_min); EXPECT_EQ(1, INT_FAST64_MIN, (int_fast64_t) INTPTR_MIN); break; + CASE_TEST(limit_int_fast64_max); EXPECT_EQ(1, INT_FAST64_MAX, (int_fast64_t) INTPTR_MAX); break; + CASE_TEST(limit_uint_fast64_max); EXPECT_EQ(1, UINT_FAST64_MAX, (uint_fast64_t) UINTPTR_MAX); break; +#if __SIZEOF_LONG__ == 8 + CASE_TEST(limit_intptr_min); EXPECT_EQ(1, INTPTR_MIN, (intptr_t) 0x8000000000000000LL); break; + CASE_TEST(limit_intptr_max); EXPECT_EQ(1, INTPTR_MAX, (intptr_t) 0x7fffffffffffffffLL); break; + CASE_TEST(limit_uintptr_max); EXPECT_EQ(1, UINTPTR_MAX, (uintptr_t) 0xffffffffffffffffULL); break; + CASE_TEST(limit_ptrdiff_min); EXPECT_EQ(1, PTRDIFF_MIN, (ptrdiff_t) 0x8000000000000000LL); break; + CASE_TEST(limit_ptrdiff_max); EXPECT_EQ(1, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffffffffffffLL); break; + CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break; +#elif __SIZEOF_LONG__ == 4 + CASE_TEST(limit_intptr_min); EXPECT_EQ(1, INTPTR_MIN, (intptr_t) 0x80000000); break; + CASE_TEST(limit_intptr_max); EXPECT_EQ(1, INTPTR_MAX, (intptr_t) 0x7fffffff); break; + CASE_TEST(limit_uintptr_max); EXPECT_EQ(1, UINTPTR_MAX, (uintptr_t) 0xffffffffU); break; + CASE_TEST(limit_ptrdiff_min); EXPECT_EQ(1, PTRDIFF_MIN, (ptrdiff_t) 0x80000000); break; + CASE_TEST(limit_ptrdiff_max); EXPECT_EQ(1, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffff); break; + CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffU); break; +#else +# warning "__SIZEOF_LONG__ is undefined" +#endif /* __SIZEOF_LONG__ */ case __LINE__: return ret; /* must be last */ /* note: do not set any defaults so as to permit holes above */ -- 2.17.5 ^ permalink raw reply related [flat|nested] 7+ messages in thread
end of thread, other threads:[~2023-03-05 4:27 UTC | newest] Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2023-03-04 14:26 [PATCH 0/4] tools/nolibc: add stdint and more integer types Willy Tarreau 2023-03-04 14:26 ` [PATCH 1/4] tools/nolibc: add stdint.h Willy Tarreau 2023-03-05 0:47 ` Paul E. McKenney 2023-03-05 4:27 ` Willy Tarreau 2023-03-04 14:26 ` [PATCH 2/4] tools/nolibc: add integer types and integer limit macros Willy Tarreau 2023-03-04 14:26 ` [PATCH 3/4] tools/nolibc: enlarge column width of tests Willy Tarreau 2023-03-04 14:26 ` [PATCH 4/4] tools/nolibc: add tests for the integer limits in stdint.h Willy Tarreau
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.