* [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests
@ 2023-02-20 20:20 Vincent Dagonneau
2023-02-20 20:20 ` [PATCH v5 1/4] tools/nolibc: add stdint.h Vincent Dagonneau
` (3 more replies)
0 siblings, 4 replies; 18+ messages in thread
From: Vincent Dagonneau @ 2023-02-20 20:20 UTC (permalink / raw)
To: linux-kernel; +Cc: w, Vincent Dagonneau
Hi,
This is version 5 of the patch to add stdint.h to nolibc. Previous
versions of this patch are available here:
* v4: https://lore.kernel.org/all/20230209024044.13127-1-v@vda.io/
* v3: https://lore.kernel.org/all/20230206013248.471664-1-v@vda.io/
* v2: https://lore.kernel.org/all/20230202201101.43160-1-v@vda.io/
* v1: https://lore.kernel.org/all/20230202160236.25342-1-v@vda.io/
This version includes the work done by Willy (see
https://lore.kernel.org/all/20230219185133.14576-1-w@1wt.eu/) on using
__LONG_MAX__ to calculate the max size of ssize_t, size_t, intptr_t,
uintptr_t and ptrdiff_t.
It also includes the '*fast*' types, although I have never seen them used
in the wild.
Thank you Willy for the review and the guidance!
Vincent.
Vincent Dagonneau (4):
tools/nolibc: Adding stdint.h
tools/nolibc: Adding integer types and integer limit macros
tools/nolibc: Enlarging column width of tests
tools/nolibc: Adds tests for the integer limits in stdint.h
tools/include/nolibc/Makefile | 4 +-
tools/include/nolibc/std.h | 15 +-
tools/include/nolibc/stdint.h | 84 +++++++++++
tools/testing/selftests/nolibc/nolibc-test.c | 139 ++++++++++++-------
4 files changed, 177 insertions(+), 65 deletions(-)
create mode 100644 tools/include/nolibc/stdint.h
--
2.39.1
^ permalink raw reply [flat|nested] 18+ messages in thread* [PATCH v5 1/4] tools/nolibc: add stdint.h 2023-02-20 20:20 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau @ 2023-02-20 20:20 ` Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros Vincent Dagonneau ` (2 subsequent siblings) 3 siblings, 0 replies; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-20 20:20 UTC (permalink / raw) To: linux-kernel; +Cc: w, Vincent Dagonneau 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> 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.39.2 ^ permalink raw reply related [flat|nested] 18+ messages in thread
* [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros 2023-02-20 20:20 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 1/4] tools/nolibc: add stdint.h Vincent Dagonneau @ 2023-02-20 20:20 ` Vincent Dagonneau 2023-02-21 17:40 ` Thomas Weißschuh 2023-02-20 20:20 ` [PATCH v5 3/4] tools/nolibc: enlarge column width of tests Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h Vincent Dagonneau 3 siblings, 1 reply; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-20 20:20 UTC (permalink / raw) To: linux-kernel; +Cc: w, Vincent Dagonneau 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 ssize_t, 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. size_t/ssize_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> Signed-off-by: Willy Tarreau <w@1wt.eu> --- tools/include/nolibc/stdint.h | 77 +++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h index 4ba264031df9..f7179a583f61 100644 --- a/tools/include/nolibc/stdint.h +++ b/tools/include/nolibc/stdint.h @@ -21,4 +21,81 @@ 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 SSIZE_MIN (-__LONG_MAX__ - 1) +#define SSIZE_MAX __LONG_MAX__ +#define INTPTR_MIN SSIZE_MIN +#define INTPTR_MAX SSIZE_MAX +#define PTRDIFF_MIN SSIZE_MIN +#define PTRDIFF_MAX SSIZE_MAX +#define UINTPTR_MAX SIZE_MAX + +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST16_MIN SSIZE_MIN +#define INT_FAST32_MIN SSIZE_MIN +#define INT_FAST64_MIN SSIZE_MIN + +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MAX SSIZE_MAX +#define INT_FAST32_MAX SSIZE_MAX +#define INT_FAST64_MAX SSIZE_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.39.2 ^ permalink raw reply related [flat|nested] 18+ messages in thread
* Re: [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros 2023-02-20 20:20 ` [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros Vincent Dagonneau @ 2023-02-21 17:40 ` Thomas Weißschuh 2023-02-23 0:35 ` Vincent Dagonneau 0 siblings, 1 reply; 18+ messages in thread From: Thomas Weißschuh @ 2023-02-21 17:40 UTC (permalink / raw) To: Vincent Dagonneau; +Cc: linux-kernel, w On Mon, Feb 20, 2023 at 03:20:08PM -0500, Vincent Dagonneau wrote: > 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 > ssize_t, 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. size_t/ssize_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> > Signed-off-by: Willy Tarreau <w@1wt.eu> > --- > tools/include/nolibc/stdint.h | 77 +++++++++++++++++++++++++++++++++++ > 1 file changed, 77 insertions(+) > > diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h > index 4ba264031df9..f7179a583f61 100644 > --- a/tools/include/nolibc/stdint.h > +++ b/tools/include/nolibc/stdint.h > @@ -21,4 +21,81 @@ 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 SSIZE_MIN (-__LONG_MAX__ - 1) SSIZE_MIN is not defined by a standard. It also doesn't really make sense to have, as ssize_t is only supposed to store [-1,SSIZE_MAX]. > +#define SSIZE_MAX __LONG_MAX__ Apparently SSIZE_MAX can also defined via the compilers <limits.h> as used by nolibc-test.c leading to a warning. Maybe wrap it in #ifndef SSIZE_MAX. In file included from sysroot/x86/include/std.h:21, from sysroot/x86/include/stdio.h:12, from nolibc-test.c:15: sysroot/x86/include/stdint.h:79: warning: "SSIZE_MAX" redefined 79 | #define SSIZE_MAX __LONG_MAX__ | In file included from /usr/include/limits.h:195, from /usr/lib/gcc/x86_64-pc-linux-gnu/12.2.1/include-fixed/limits.h:203, from /usr/lib/gcc/x86_64-pc-linux-gnu/12.2.1/include-fixed/syslimits.h:7, from /usr/lib/gcc/x86_64-pc-linux-gnu/12.2.1/include-fixed/limits.h:34, from nolibc-test.c:6: /usr/include/bits/posix1_lim.h:169: note: this is the location of the previous definition 169 | # define SSIZE_MAX LONG_MAX | > +#define INTPTR_MIN SSIZE_MIN > +#define INTPTR_MAX SSIZE_MAX > +#define PTRDIFF_MIN SSIZE_MIN > +#define PTRDIFF_MAX SSIZE_MAX > +#define UINTPTR_MAX SIZE_MAX > + > +#define INT_FAST8_MIN INT8_MIN > +#define INT_FAST16_MIN SSIZE_MIN > +#define INT_FAST32_MIN SSIZE_MIN > +#define INT_FAST64_MIN SSIZE_MIN > + > +#define INT_FAST8_MAX INT8_MAX > +#define INT_FAST16_MAX SSIZE_MAX > +#define INT_FAST32_MAX SSIZE_MAX > +#define INT_FAST64_MAX SSIZE_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 Alignment of values within lines is inconsistent. > + > #endif /* _NOLIBC_STDINT_H */ > -- > 2.39.2 > ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros 2023-02-21 17:40 ` Thomas Weißschuh @ 2023-02-23 0:35 ` Vincent Dagonneau 0 siblings, 0 replies; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-23 0:35 UTC (permalink / raw) To: Thomas Weißschuh; +Cc: linux-kernel, Willy Tarreau Hi Thomas, On Tue, Feb 21, 2023, at 12:40, Thomas Weißschuh wrote: > On Mon, Feb 20, 2023 at 03:20:08PM -0500, Vincent Dagonneau wrote: >> 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 >> ssize_t, 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. size_t/ssize_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> >> Signed-off-by: Willy Tarreau <w@1wt.eu> >> --- >> tools/include/nolibc/stdint.h | 77 +++++++++++++++++++++++++++++++++++ >> 1 file changed, 77 insertions(+) >> >> diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h >> index 4ba264031df9..f7179a583f61 100644 >> --- a/tools/include/nolibc/stdint.h >> +++ b/tools/include/nolibc/stdint.h >> @@ -21,4 +21,81 @@ 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 SSIZE_MIN (-__LONG_MAX__ - 1) > > SSIZE_MIN is not defined by a standard. > It also doesn't really make sense to have, as ssize_t is only supposed > to store [-1,SSIZE_MAX]. > >> +#define SSIZE_MAX __LONG_MAX__ > > Apparently SSIZE_MAX can also defined via the compilers <limits.h> as > used by nolibc-test.c leading to a warning. > Maybe wrap it in #ifndef SSIZE_MAX. > > In file included from sysroot/x86/include/std.h:21, > from sysroot/x86/include/stdio.h:12, > from nolibc-test.c:15: > sysroot/x86/include/stdint.h:79: warning: "SSIZE_MAX" redefined > 79 | #define SSIZE_MAX __LONG_MAX__ > | > In file included from /usr/include/limits.h:195, > from > /usr/lib/gcc/x86_64-pc-linux-gnu/12.2.1/include-fixed/limits.h:203, > from > /usr/lib/gcc/x86_64-pc-linux-gnu/12.2.1/include-fixed/syslimits.h:7, > from > /usr/lib/gcc/x86_64-pc-linux-gnu/12.2.1/include-fixed/limits.h:34, > from nolibc-test.c:6: > /usr/include/bits/posix1_lim.h:169: note: this is the location of > the previous definition > 169 | # define SSIZE_MAX LONG_MAX > | > Ok, I'll remove the SSIZE_MIN and SSIZE_MAX since neither seem to be in the standards page anyway. Note that ssize_t is still defined in this file. It pre-dates my patch. >> +#define INTPTR_MIN SSIZE_MIN >> +#define INTPTR_MAX SSIZE_MAX >> +#define PTRDIFF_MIN SSIZE_MIN >> +#define PTRDIFF_MAX SSIZE_MAX >> +#define UINTPTR_MAX SIZE_MAX >> + >> +#define INT_FAST8_MIN INT8_MIN >> +#define INT_FAST16_MIN SSIZE_MIN >> +#define INT_FAST32_MIN SSIZE_MIN >> +#define INT_FAST64_MIN SSIZE_MIN >> + >> +#define INT_FAST8_MAX INT8_MAX >> +#define INT_FAST16_MAX SSIZE_MAX >> +#define INT_FAST32_MAX SSIZE_MAX >> +#define INT_FAST64_MAX SSIZE_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 > > Alignment of values within lines is inconsistent. > Thanks, I did a whole lot of alignment in the latest version, hopefully it should be ok now. >> + >> #endif /* _NOLIBC_STDINT_H */ >> -- >> 2.39.2 >> Thanks for the review, Vincent. ^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v5 3/4] tools/nolibc: enlarge column width of tests 2023-02-20 20:20 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 1/4] tools/nolibc: add stdint.h Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros Vincent Dagonneau @ 2023-02-20 20:20 ` Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h Vincent Dagonneau 3 siblings, 0 replies; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-20 20:20 UTC (permalink / raw) To: linux-kernel; +Cc: w, Vincent Dagonneau 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> 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.39.2 ^ permalink raw reply related [flat|nested] 18+ messages in thread
* [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h 2023-02-20 20:20 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau ` (2 preceding siblings ...) 2023-02-20 20:20 ` [PATCH v5 3/4] tools/nolibc: enlarge column width of tests Vincent Dagonneau @ 2023-02-20 20:20 ` Vincent Dagonneau 2023-02-21 17:34 ` Thomas Weißschuh 3 siblings, 1 reply; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-20 20:20 UTC (permalink / raw) To: linux-kernel; +Cc: w, Vincent Dagonneau 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> Signed-off-by: Willy Tarreau <w@1wt.eu> --- tools/testing/selftests/nolibc/nolibc-test.c | 62 +++++++++++++++++++- 1 file changed, 61 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c index 882140508d56..ceaf60075331 100644 --- a/tools/testing/selftests/nolibc/nolibc-test.c +++ b/tools/testing/selftests/nolibc/nolibc-test.c @@ -561,7 +561,67 @@ int run_syscall(int min, int max) CASE_TEST(waitpid_child); EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break; CASE_TEST(write_badf); EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break; CASE_TEST(write_zero); EXPECT_SYSZR(1, write(1, &tmp, 0)); break; - case __LINE__: + 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_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; +#if __SIZEOF_LONG__ == 8 + 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_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) 0x7fffffffffffffffLL); break; + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) 0x8000000000000000LL); break; + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) 0xffffffffffffffffULL); break; + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) 0x7fffffffffffffffLL); break; + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) 0x8000000000000000LL); break; + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) 0xffffffffffffffffULL); break; + 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_ssize_min); EXPECT_EQ(1, SSIZE_MIN, (ssize_t) 0x8000000000000000LL); break; + CASE_TEST(limit_ssize_max); EXPECT_EQ(1, SSIZE_MAX, (ssize_t) 0x7fffffffffffffffLL); break; + CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break; +#elif __SIZEOF_LONG__ == 4 + CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) 0x7fffffff); break; + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) 0x80000000); break; + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) 0xffffffffU); break; + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) 0x7fffffff); break; + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) 0x80000000); break; + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) 0xffffffffU); break; + 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_ssize_min); EXPECT_EQ(1, SSIZE_MIN, (ssize_t) 0x80000000); break; + CASE_TEST(limit_ssize_max); EXPECT_EQ(1, SSIZE_MAX, (ssize_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.39.2 ^ permalink raw reply related [flat|nested] 18+ messages in thread
* Re: [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h 2023-02-20 20:20 ` [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h Vincent Dagonneau @ 2023-02-21 17:34 ` Thomas Weißschuh 2023-02-21 17:44 ` Willy Tarreau 2023-02-23 0:58 ` Vincent Dagonneau 0 siblings, 2 replies; 18+ messages in thread From: Thomas Weißschuh @ 2023-02-21 17:34 UTC (permalink / raw) To: Vincent Dagonneau; +Cc: linux-kernel, w I think some comments from my last review got lost; see inline. On Mon, Feb 20, 2023 at 03:20:10PM -0500, Vincent Dagonneau wrote: > 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> > Signed-off-by: Willy Tarreau <w@1wt.eu> > --- > tools/testing/selftests/nolibc/nolibc-test.c | 62 +++++++++++++++++++- > 1 file changed, 61 insertions(+), 1 deletion(-) > > diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c > index 882140508d56..ceaf60075331 100644 > --- a/tools/testing/selftests/nolibc/nolibc-test.c > +++ b/tools/testing/selftests/nolibc/nolibc-test.c > @@ -561,7 +561,67 @@ int run_syscall(int min, int max) > CASE_TEST(waitpid_child); EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break; > CASE_TEST(write_badf); EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break; > CASE_TEST(write_zero); EXPECT_SYSZR(1, write(1, &tmp, 0)); break; > - case __LINE__: > + 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_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; > +#if __SIZEOF_LONG__ == 8 > + 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; The _least64 tests should also apply to 32bit, no? And moved before the _fast8 tests. > + CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) 0x7fffffffffffffffLL); break; > + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) 0x8000000000000000LL); break; > + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) 0xffffffffffffffffULL); break; > + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) 0x7fffffffffffffffLL); break; > + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) 0x8000000000000000LL); break; > + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) 0xffffffffffffffffULL); break; > + 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_ssize_min); EXPECT_EQ(1, SSIZE_MIN, (ssize_t) 0x8000000000000000LL); break; > + CASE_TEST(limit_ssize_max); EXPECT_EQ(1, SSIZE_MAX, (ssize_t) 0x7fffffffffffffffLL); break; > + CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break; > +#elif __SIZEOF_LONG__ == 4 > + CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) 0x7fffffff); break; > + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) 0x80000000); break; > + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) 0xffffffffU); break; > + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) 0x7fffffff); break; > + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) 0x80000000); break; > + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) 0xffffffffU); break; > + 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_ssize_min); EXPECT_EQ(1, SSIZE_MIN, (ssize_t) 0x80000000); break; > + CASE_TEST(limit_ssize_max); EXPECT_EQ(1, SSIZE_MAX, (ssize_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__: The case __LINE__ still seems to be misindented, at least different than before. > return ret; /* must be last */ > /* note: do not set any defaults so as to permit holes above */ > } > -- > 2.39.2 ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h 2023-02-21 17:34 ` Thomas Weißschuh @ 2023-02-21 17:44 ` Willy Tarreau 2023-02-23 0:38 ` Vincent Dagonneau 2023-02-23 0:58 ` Vincent Dagonneau 1 sibling, 1 reply; 18+ messages in thread From: Willy Tarreau @ 2023-02-21 17:44 UTC (permalink / raw) To: Thomas Weißschuh; +Cc: Vincent Dagonneau, linux-kernel On Tue, Feb 21, 2023 at 05:34:01PM +0000, Thomas Weißschuh wrote: > > diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c > > index 882140508d56..ceaf60075331 100644 > > --- a/tools/testing/selftests/nolibc/nolibc-test.c > > +++ b/tools/testing/selftests/nolibc/nolibc-test.c > > @@ -561,7 +561,67 @@ int run_syscall(int min, int max) > > CASE_TEST(waitpid_child); EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break; > > CASE_TEST(write_badf); EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break; > > CASE_TEST(write_zero); EXPECT_SYSZR(1, write(1, &tmp, 0)); break; > > - case __LINE__: > > + 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_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; > > +#if __SIZEOF_LONG__ == 8 > > + 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; > > The _least64 tests should also apply to 32bit, no? > And moved before the _fast8 tests. Just thinking loud, it seems to me that all of these _least/_fast ones can in fact be reliably checked against INT_*, LONG_* and SIZE_MAX. Given that these ones are already tested, maybe we can just get rid of the ifdef around all the least/fast and map them to the ones we already test ? That would possibly remove duplication and make it more readable. Willy ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h 2023-02-21 17:44 ` Willy Tarreau @ 2023-02-23 0:38 ` Vincent Dagonneau 0 siblings, 0 replies; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-23 0:38 UTC (permalink / raw) To: Willy Tarreau, Thomas Weißschuh; +Cc: linux-kernel On Tue, Feb 21, 2023, at 12:44, Willy Tarreau wrote: > On Tue, Feb 21, 2023 at 05:34:01PM +0000, Thomas Weißschuh wrote: >> > diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c >> > index 882140508d56..ceaf60075331 100644 >> > --- a/tools/testing/selftests/nolibc/nolibc-test.c >> > +++ b/tools/testing/selftests/nolibc/nolibc-test.c >> > @@ -561,7 +561,67 @@ int run_syscall(int min, int max) >> > CASE_TEST(waitpid_child); EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break; >> > CASE_TEST(write_badf); EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break; >> > CASE_TEST(write_zero); EXPECT_SYSZR(1, write(1, &tmp, 0)); break; >> > - case __LINE__: >> > + 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_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; >> > +#if __SIZEOF_LONG__ == 8 >> > + 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; >> >> The _least64 tests should also apply to 32bit, no? >> And moved before the _fast8 tests. > > Just thinking loud, it seems to me that all of these _least/_fast ones > can in fact be reliably checked against INT_*, LONG_* and SIZE_MAX. Given > that these ones are already tested, maybe we can just get rid of the ifdef > around all the least/fast and map them to the ones we already test ? That > would possibly remove duplication and make it more readable. > Ok, just did something similar in the newest version. It does make it more readable. > Willy ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h 2023-02-21 17:34 ` Thomas Weißschuh 2023-02-21 17:44 ` Willy Tarreau @ 2023-02-23 0:58 ` Vincent Dagonneau 1 sibling, 0 replies; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-23 0:58 UTC (permalink / raw) To: Thomas Weißschuh; +Cc: linux-kernel, Willy Tarreau On Tue, Feb 21, 2023, at 12:34, Thomas Weißschuh wrote: > I think some comments from my last review got lost; see inline. > Yes, sorry, I hope the new version addresses them. > On Mon, Feb 20, 2023 at 03:20:10PM -0500, Vincent Dagonneau wrote: >> 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> >> Signed-off-by: Willy Tarreau <w@1wt.eu> >> --- >> tools/testing/selftests/nolibc/nolibc-test.c | 62 +++++++++++++++++++- >> 1 file changed, 61 insertions(+), 1 deletion(-) >> >> diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c >> index 882140508d56..ceaf60075331 100644 >> --- a/tools/testing/selftests/nolibc/nolibc-test.c >> +++ b/tools/testing/selftests/nolibc/nolibc-test.c >> @@ -561,7 +561,67 @@ int run_syscall(int min, int max) >> CASE_TEST(waitpid_child); EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break; >> CASE_TEST(write_badf); EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break; >> CASE_TEST(write_zero); EXPECT_SYSZR(1, write(1, &tmp, 0)); break; >> - case __LINE__: >> + 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_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; >> +#if __SIZEOF_LONG__ == 8 >> + 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; > > The _least64 tests should also apply to 32bit, no? > And moved before the _fast8 tests. > You are right. I got confused. I added the fast64/least64 tests to 32 bits as well. >> + CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) 0x7fffffffffffffffLL); break; >> + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) 0x8000000000000000LL); break; >> + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) 0xffffffffffffffffULL); break; >> + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) 0x7fffffffffffffffLL); break; >> + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) 0x8000000000000000LL); break; >> + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) 0xffffffffffffffffULL); break; >> + 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_ssize_min); EXPECT_EQ(1, SSIZE_MIN, (ssize_t) 0x8000000000000000LL); break; >> + CASE_TEST(limit_ssize_max); EXPECT_EQ(1, SSIZE_MAX, (ssize_t) 0x7fffffffffffffffLL); break; >> + CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break; >> +#elif __SIZEOF_LONG__ == 4 >> + CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) 0x7fffffff); break; >> + CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) 0x80000000); break; >> + CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) 0xffffffffU); break; >> + CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) 0x7fffffff); break; >> + CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) 0x80000000); break; >> + CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) 0xffffffffU); break; >> + 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_ssize_min); EXPECT_EQ(1, SSIZE_MIN, (ssize_t) 0x80000000); break; >> + CASE_TEST(limit_ssize_max); EXPECT_EQ(1, SSIZE_MAX, (ssize_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__: > > The case __LINE__ still seems to be misindented, at least different > than before. > Should be fixed in the new version. >> return ret; /* must be last */ >> /* note: do not set any defaults so as to permit holes above */ >> } >> -- >> 2.39.2 ^ permalink raw reply [flat|nested] 18+ messages in thread
* [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests @ 2023-02-09 2:40 Vincent Dagonneau 2023-02-09 3:43 ` Willy Tarreau 0 siblings, 1 reply; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-09 2:40 UTC (permalink / raw) To: linux-kernel; +Cc: w, Vincent Dagonneau Hi, This is version 4 of my patch to add stdint.h to nolibc. Previous versions of this patch are available here: * v3: https://lore.kernel.org/all/20230206013248.471664-1-v@vda.io/ * v2: https://lore.kernel.org/all/20230202201101.43160-1-v@vda.io/ * v1: https://lore.kernel.org/all/20230202160236.25342-1-v@vda.io/ I tested it successfully on x86_64, as well as i386 and arm on qemu. Thank you Willy for the review and the guidance! Vincent. Vincent Dagonneau (4): tools/nolibc: Adding stdint.h tools/nolibc: Adding integer types and integer limit macros tools/nolibc: Enlarging column width of tests tools/nolibc: Adds tests for the integer limits in stdint.h tools/include/nolibc/Makefile | 4 +- tools/include/nolibc/std.h | 15 +- tools/include/nolibc/stdint.h | 84 +++++++++++ tools/testing/selftests/nolibc/nolibc-test.c | 139 ++++++++++++------- 4 files changed, 177 insertions(+), 65 deletions(-) create mode 100644 tools/include/nolibc/stdint.h -- 2.39.1 ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests 2023-02-09 2:40 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau @ 2023-02-09 3:43 ` Willy Tarreau 2023-02-10 13:03 ` Vincent Dagonneau 0 siblings, 1 reply; 18+ messages in thread From: Willy Tarreau @ 2023-02-09 3:43 UTC (permalink / raw) To: Vincent Dagonneau; +Cc: linux-kernel On Wed, Feb 08, 2023 at 09:40:40PM -0500, Vincent Dagonneau wrote: > Hi, > > This is version 4 of my patch to add stdint.h to nolibc. Previous > versions of this patch are available here: > > * v3: https://lore.kernel.org/all/20230206013248.471664-1-v@vda.io/ > * v2: https://lore.kernel.org/all/20230202201101.43160-1-v@vda.io/ > * v1: https://lore.kernel.org/all/20230202160236.25342-1-v@vda.io/ > > I tested it successfully on x86_64, as well as i386 and arm on qemu. > > Thank you Willy for the review and the guidance! > Vincent. Thanks Vincent. At first glance it looks good. I'll give it a try on all supported archs to make sure we didn't overlook anything and we'll merge it. One tiny comment though, look below: > Vincent Dagonneau (4): > tools/nolibc: Adding stdint.h > tools/nolibc: Adding integer types and integer limit macros > tools/nolibc: Enlarging column width of tests > tools/nolibc: Adds tests for the integer limits in stdint.h I mentioned in the first review that it's generally preferred to use the imperative form rather than present participle on subject lines. This would give: 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 I can perform this trivial change locally before merging without asking you to respin a series just for this if that's OK for you. Just let me know. Thanks! Willy ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests 2023-02-09 3:43 ` Willy Tarreau @ 2023-02-10 13:03 ` Vincent Dagonneau 2023-02-12 10:41 ` Willy Tarreau 0 siblings, 1 reply; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-10 13:03 UTC (permalink / raw) To: Willy Tarreau; +Cc: linux-kernel On Wed, Feb 8, 2023, at 22:43, Willy Tarreau wrote: > On Wed, Feb 08, 2023 at 09:40:40PM -0500, Vincent Dagonneau wrote: >> Hi, >> >> This is version 4 of my patch to add stdint.h to nolibc. Previous >> versions of this patch are available here: >> >> * v3: https://lore.kernel.org/all/20230206013248.471664-1-v@vda.io/ >> * v2: https://lore.kernel.org/all/20230202201101.43160-1-v@vda.io/ >> * v1: https://lore.kernel.org/all/20230202160236.25342-1-v@vda.io/ >> >> I tested it successfully on x86_64, as well as i386 and arm on qemu. >> >> Thank you Willy for the review and the guidance! >> Vincent. > > Thanks Vincent. At first glance it looks good. I'll give it a try on > all supported archs to make sure we didn't overlook anything and we'll > merge it. One tiny comment though, look below: > >> Vincent Dagonneau (4): >> tools/nolibc: Adding stdint.h >> tools/nolibc: Adding integer types and integer limit macros >> tools/nolibc: Enlarging column width of tests >> tools/nolibc: Adds tests for the integer limits in stdint.h > > I mentioned in the first review that it's generally preferred to use > the imperative form rather than present participle on subject lines. > This would give: > > 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 > > I can perform this trivial change locally before merging without asking > you to respin a series just for this if that's OK for you. Just let me > know. > > Thanks! > Willy Yep, go ahead! Thank you again for the guidance, Vincent. ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests 2023-02-10 13:03 ` Vincent Dagonneau @ 2023-02-12 10:41 ` Willy Tarreau 2023-02-12 18:27 ` Willy Tarreau 0 siblings, 1 reply; 18+ messages in thread From: Willy Tarreau @ 2023-02-12 10:41 UTC (permalink / raw) To: Vincent Dagonneau; +Cc: linux-kernel Hi Vincent, On Fri, Feb 10, 2023 at 08:03:02AM -0500, Vincent Dagonneau wrote: > > Thanks Vincent. At first glance it looks good. I'll give it a try on > > all supported archs to make sure we didn't overlook anything and we'll > > merge it. One tiny comment though, look below: > > > >> Vincent Dagonneau (4): > >> tools/nolibc: Adding stdint.h > >> tools/nolibc: Adding integer types and integer limit macros > >> tools/nolibc: Enlarging column width of tests > >> tools/nolibc: Adds tests for the integer limits in stdint.h > > > > I mentioned in the first review that it's generally preferred to use > > the imperative form rather than present participle on subject lines. > > This would give: > > > > 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 > > > > I can perform this trivial change locally before merging without asking > > you to respin a series just for this if that's OK for you. Just let me > > know. > > > > Thanks! > > Willy > > Yep, go ahead! Done, however I'm seeing the following failures on aarch64/riscv64/s390x: $ grep -B 200 limit.*FAIL stdint.out | grep '\(limit.*FAIL\|gcc-11.3.0-nolibc.*-O0\)' /f/tc/nolibc/gcc-11.3.0-nolibc/aarch64*/bin/aarch64*-gcc -g -O0 -g -o nolibc-test \ 100 limit_intptr_min = -2147483648 [FAIL] 103 limit_ptrdiff_min = -2147483648 [FAIL] 105 limit_ptrdiff_min = -2147483648 [FAIL] /f/tc/nolibc/gcc-11.3.0-nolibc/riscv64*/bin/riscv64*-gcc -g -O0 -g -o nolibc-test \ 100 limit_intptr_min = -2147483648 [FAIL] 103 limit_ptrdiff_min = -2147483648 [FAIL] 105 limit_ptrdiff_min = -2147483648 [FAIL] /f/tc/nolibc/gcc-11.3.0-nolibc/s390*/bin/s390*-gcc -g -march=z10 -m64 -O0 -g -o nolibc-test \ 100 limit_intptr_min = -2147483648 [FAIL] 103 limit_ptrdiff_min = -2147483648 [FAIL] 105 limit_ptrdiff_min = -2147483648 [FAIL] It makes me think that the __WORDSIZE==64 condition didn't match there, I'm investigating. However while looking at this I noticed a mistake in your patch: in the 32-bit part, limit_ptrdiff_{min,max} were repeated, and no least64_{min,max} tests were placed, so I sense a copy-paste mistake though I'm uncertain about the initial intent. If you just want me to drop the duplicate lines I can easily do it, just let me know. I'll be back with more info once I figure the reason for these archs not using __WORDSIZE==64. #if __WORDSIZE == 64 CASE_TEST(limit_int_least64_max); EXPECT_EQ(1, INT_LEAST64_MAX, (int_least64_t) 0x7fffffffffffffffLL); break; CASE_TEST(limit_int_least64_min); EXPECT_EQ(1, INT_LEAST64_MIN, (int_least64_t) 0x8000000000000000LL); break; CASE_TEST(limit_uint_least64_max); EXPECT_EQ(1, UINT_LEAST64_MAX, (uint_least64_t) 0xffffffffffffffffULL); break; 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; #else 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_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; #endif /* __WORDSIZE == 64 */ Regards, Willy ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests 2023-02-12 10:41 ` Willy Tarreau @ 2023-02-12 18:27 ` Willy Tarreau 2023-02-16 0:11 ` Vincent Dagonneau 0 siblings, 1 reply; 18+ messages in thread From: Willy Tarreau @ 2023-02-12 18:27 UTC (permalink / raw) To: Vincent Dagonneau; +Cc: linux-kernel Hi again Vincent, On Sun, Feb 12, 2023 at 11:41:15AM +0100, Willy Tarreau wrote: > Hi Vincent, > > On Fri, Feb 10, 2023 at 08:03:02AM -0500, Vincent Dagonneau wrote: > > > Thanks Vincent. At first glance it looks good. I'll give it a try on > > > all supported archs to make sure we didn't overlook anything and we'll > > > merge it. One tiny comment though, look below: > > > > > >> Vincent Dagonneau (4): > > >> tools/nolibc: Adding stdint.h > > >> tools/nolibc: Adding integer types and integer limit macros > > >> tools/nolibc: Enlarging column width of tests > > >> tools/nolibc: Adds tests for the integer limits in stdint.h > > > > > > I mentioned in the first review that it's generally preferred to use > > > the imperative form rather than present participle on subject lines. > > > This would give: > > > > > > 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 > > > > > > I can perform this trivial change locally before merging without asking > > > you to respin a series just for this if that's OK for you. Just let me > > > know. > > > > > > Thanks! > > > Willy > > > > Yep, go ahead! > > Done, however I'm seeing the following failures on aarch64/riscv64/s390x: > > $ grep -B 200 limit.*FAIL stdint.out | grep '\(limit.*FAIL\|gcc-11.3.0-nolibc.*-O0\)' > /f/tc/nolibc/gcc-11.3.0-nolibc/aarch64*/bin/aarch64*-gcc -g -O0 -g -o nolibc-test \ > 100 limit_intptr_min = -2147483648 [FAIL] > 103 limit_ptrdiff_min = -2147483648 [FAIL] > 105 limit_ptrdiff_min = -2147483648 [FAIL] > /f/tc/nolibc/gcc-11.3.0-nolibc/riscv64*/bin/riscv64*-gcc -g -O0 -g -o nolibc-test \ > 100 limit_intptr_min = -2147483648 [FAIL] > 103 limit_ptrdiff_min = -2147483648 [FAIL] > 105 limit_ptrdiff_min = -2147483648 [FAIL] > /f/tc/nolibc/gcc-11.3.0-nolibc/s390*/bin/s390*-gcc -g -march=z10 -m64 -O0 -g -o nolibc-test \ > 100 limit_intptr_min = -2147483648 [FAIL] > 103 limit_ptrdiff_min = -2147483648 [FAIL] > 105 limit_ptrdiff_min = -2147483648 [FAIL] > > It makes me think that the __WORDSIZE==64 condition didn't match there, > I'm investigating. However while looking at this I noticed a mistake in > your patch: in the 32-bit part, limit_ptrdiff_{min,max} were repeated, > and no least64_{min,max} tests were placed, so I sense a copy-paste > mistake though I'm uncertain about the initial intent. If you just want > me to drop the duplicate lines I can easily do it, just let me know. I'll > be back with more info once I figure the reason for these archs not using > __WORDSIZE==64. > > #if __WORDSIZE == 64 > CASE_TEST(limit_int_least64_max); EXPECT_EQ(1, INT_LEAST64_MAX, (int_least64_t) 0x7fffffffffffffffLL); break; > CASE_TEST(limit_int_least64_min); EXPECT_EQ(1, INT_LEAST64_MIN, (int_least64_t) 0x8000000000000000LL); break; > CASE_TEST(limit_uint_least64_max); EXPECT_EQ(1, UINT_LEAST64_MAX, (uint_least64_t) 0xffffffffffffffffULL); break; > 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; > #else > 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_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; > #endif /* __WORDSIZE == 64 */ So after investigation, __WORDSIZE is not defined, hence the failures! It proves the importance of the tests you've added ;-) However we have the size of these types defined by the compiler itself at least since gcc-4.4 and clang-3.8 which are the oldest I could test: $ mips-gcc44_glibc214-linux-gnu-gcc -xc -dM -E - </dev/null |grep SIZE #define __SIZEOF_POINTER__ 4 #define __SIZEOF_LONG__ 4 #define __SIZEOF_LONG_DOUBLE__ 8 #define __SIZEOF_SIZE_T__ 4 #define __SIZEOF_WINT_T__ 4 #define __SIZE_TYPE__ unsigned int #define __SIZEOF_PTRDIFF_T__ 4 #define __SIZEOF_INT__ 4 #define __SIZEOF_FLOAT__ 4 #define __SIZEOF_SHORT__ 2 #define __SIZEOF_WCHAR_T__ 4 #define __SIZEOF_DOUBLE__ 8 #define __SIZEOF_LONG_LONG__ 8 In addition both provide __SIZE_TYPE__ which is defined either as unsigned int or long unsigned int, so that can simplify quite some parts (and other types are defined for other types in more recent versions). Both also define __LONG_MAX__ that you could possibly use to conveniently create INTPTR_MAX, INTPTR_MIN, UINTPTR_MAX and so on. And finally we should set the __WORDSIZE ourselves as 8*__SIZEOF_LONG__ and that would do the job. I tested the following patch which passes all the tests successfully on all supported archs. Let me know if you agree with such a change and how you want us to proceed. It would require a small change in the commit message though, to explain that our pointers are the size of a long on supported platforms. Regards, Willy --- diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h index 6a7683de09ec..7da0d35c481c 100644 --- a/tools/include/nolibc/stdint.h +++ b/tools/include/nolibc/stdint.h @@ -65,20 +65,12 @@ typedef uint64_t uintmax_t; #define UINT_LEAST32_MAX UINT32_MAX #define UINT_LEAST64_MAX UINT64_MAX -#if __WORDSIZE == 64 - #define SIZE_MAX UINT64_MAX - #define INTPTR_MIN INT64_MIN - #define INTPTR_MAX INT64_MAX - #define UINTPTR_MAX UINT64_MAX - #define PTRDIFF_MIN INT64_MIN - #define PTRDIFF_MAX INT64_MAX -#else - #define SIZE_MAX UINT32_MAX - #define INTPTR_MIN INT32_MIN - #define INTPTR_MAX INT32_MAX - #define UINTPTR_MAX UINT32_MAX - #define PTRDIFF_MIN INT32_MIN - #define PTRDIFF_MAX INT32_MAX -#endif /* __WORDSIZE == 64 */ +#define SIZE_MAX ((__SIZE_TYPE__)(__LONG_MAX__) * 2 + 1) +#define INTPTR_MIN (-__LONG_MAX__ - 1) +#define INTPTR_MAX __LONG_MAX__ +#define UINTPTR_MAX (SIZE_MAX) +#define PTRDIFF_MIN INTPTR_MIN +#define PTRDIFF_MAX INTPTR_MAX +#define __WORDSIZE (__SIZEOF_LONG__ * 8) #endif /* _NOLIBC_STDINT_H */ ^ permalink raw reply related [flat|nested] 18+ messages in thread
* Re: [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests 2023-02-12 18:27 ` Willy Tarreau @ 2023-02-16 0:11 ` Vincent Dagonneau 2023-02-16 3:29 ` Willy Tarreau 0 siblings, 1 reply; 18+ messages in thread From: Vincent Dagonneau @ 2023-02-16 0:11 UTC (permalink / raw) To: Willy Tarreau; +Cc: linux-kernel On Sun, Feb 12, 2023, at 13:27, Willy Tarreau wrote: > Hi again Vincent, > > On Sun, Feb 12, 2023 at 11:41:15AM +0100, Willy Tarreau wrote: >> Hi Vincent, >> >> On Fri, Feb 10, 2023 at 08:03:02AM -0500, Vincent Dagonneau wrote: >> > > Thanks Vincent. At first glance it looks good. I'll give it a try on >> > > all supported archs to make sure we didn't overlook anything and we'll >> > > merge it. One tiny comment though, look below: >> > > >> > >> Vincent Dagonneau (4): >> > >> tools/nolibc: Adding stdint.h >> > >> tools/nolibc: Adding integer types and integer limit macros >> > >> tools/nolibc: Enlarging column width of tests >> > >> tools/nolibc: Adds tests for the integer limits in stdint.h >> > > >> > > I mentioned in the first review that it's generally preferred to use >> > > the imperative form rather than present participle on subject lines. >> > > This would give: >> > > >> > > 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 >> > > >> > > I can perform this trivial change locally before merging without asking >> > > you to respin a series just for this if that's OK for you. Just let me >> > > know. >> > > >> > > Thanks! >> > > Willy >> > >> > Yep, go ahead! >> >> Done, however I'm seeing the following failures on aarch64/riscv64/s390x: >> >> $ grep -B 200 limit.*FAIL stdint.out | grep '\(limit.*FAIL\|gcc-11.3.0-nolibc.*-O0\)' >> /f/tc/nolibc/gcc-11.3.0-nolibc/aarch64*/bin/aarch64*-gcc -g -O0 -g -o nolibc-test \ >> 100 limit_intptr_min = -2147483648 [FAIL] >> 103 limit_ptrdiff_min = -2147483648 [FAIL] >> 105 limit_ptrdiff_min = -2147483648 [FAIL] >> /f/tc/nolibc/gcc-11.3.0-nolibc/riscv64*/bin/riscv64*-gcc -g -O0 -g -o nolibc-test \ >> 100 limit_intptr_min = -2147483648 [FAIL] >> 103 limit_ptrdiff_min = -2147483648 [FAIL] >> 105 limit_ptrdiff_min = -2147483648 [FAIL] >> /f/tc/nolibc/gcc-11.3.0-nolibc/s390*/bin/s390*-gcc -g -march=z10 -m64 -O0 -g -o nolibc-test \ >> 100 limit_intptr_min = -2147483648 [FAIL] >> 103 limit_ptrdiff_min = -2147483648 [FAIL] >> 105 limit_ptrdiff_min = -2147483648 [FAIL] >> >> It makes me think that the __WORDSIZE==64 condition didn't match there, >> I'm investigating. However while looking at this I noticed a mistake in >> your patch: in the 32-bit part, limit_ptrdiff_{min,max} were repeated, >> and no least64_{min,max} tests were placed, so I sense a copy-paste >> mistake though I'm uncertain about the initial intent. If you just want >> me to drop the duplicate lines I can easily do it, just let me know. I'll >> be back with more info once I figure the reason for these archs not using >> __WORDSIZE==64. >> >> #if __WORDSIZE == 64 >> CASE_TEST(limit_int_least64_max); EXPECT_EQ(1, INT_LEAST64_MAX, (int_least64_t) 0x7fffffffffffffffLL); break; >> CASE_TEST(limit_int_least64_min); EXPECT_EQ(1, INT_LEAST64_MIN, (int_least64_t) 0x8000000000000000LL); break; >> CASE_TEST(limit_uint_least64_max); EXPECT_EQ(1, UINT_LEAST64_MAX, (uint_least64_t) 0xffffffffffffffffULL); break; >> 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; >> #else >> 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_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; >> #endif /* __WORDSIZE == 64 */ > > So after investigation, __WORDSIZE is not defined, hence the failures! > It proves the importance of the tests you've added ;-) > > However we have the size of these types defined by the compiler itself > at least since gcc-4.4 and clang-3.8 which are the oldest I could test: > > $ mips-gcc44_glibc214-linux-gnu-gcc -xc -dM -E - </dev/null |grep SIZE > #define __SIZEOF_POINTER__ 4 > #define __SIZEOF_LONG__ 4 > #define __SIZEOF_LONG_DOUBLE__ 8 > #define __SIZEOF_SIZE_T__ 4 > #define __SIZEOF_WINT_T__ 4 > #define __SIZE_TYPE__ unsigned int > #define __SIZEOF_PTRDIFF_T__ 4 > #define __SIZEOF_INT__ 4 > #define __SIZEOF_FLOAT__ 4 > #define __SIZEOF_SHORT__ 2 > #define __SIZEOF_WCHAR_T__ 4 > #define __SIZEOF_DOUBLE__ 8 > #define __SIZEOF_LONG_LONG__ 8 > > In addition both provide __SIZE_TYPE__ which is defined either as > unsigned int or long unsigned int, so that can simplify quite some > parts (and other types are defined for other types in more recent > versions). Both also define __LONG_MAX__ that you could possibly > use to conveniently create INTPTR_MAX, INTPTR_MIN, UINTPTR_MAX and > so on. > Mmmh, interesting, I hadn't thought about verifying what defined the __WORDSIZE. I assumed wrongly that it was set by standard but it seems not. I replicated your example on my machine to see the intersection of what is defined by both GCC and clang. Do you know if we would need to check any other compilers? > And finally we should set the __WORDSIZE ourselves as 8*__SIZEOF_LONG__ > and that would do the job. > > I tested the following patch which passes all the tests successfully > on all supported archs. Let me know if you agree with such a change > and how you want us to proceed. It would require a small change in the > commit message though, to explain that our pointers are the size of a > long on supported platforms. > I can integrate the changes and write an explanation as a commit message and submit a new version tomorrow, would that work for you? > Regards, > Willy > > --- > > diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h > index 6a7683de09ec..7da0d35c481c 100644 > --- a/tools/include/nolibc/stdint.h > +++ b/tools/include/nolibc/stdint.h > @@ -65,20 +65,12 @@ typedef uint64_t uintmax_t; > #define UINT_LEAST32_MAX UINT32_MAX > #define UINT_LEAST64_MAX UINT64_MAX > > -#if __WORDSIZE == 64 > - #define SIZE_MAX UINT64_MAX > - #define INTPTR_MIN INT64_MIN > - #define INTPTR_MAX INT64_MAX > - #define UINTPTR_MAX UINT64_MAX > - #define PTRDIFF_MIN INT64_MIN > - #define PTRDIFF_MAX INT64_MAX > -#else > - #define SIZE_MAX UINT32_MAX > - #define INTPTR_MIN INT32_MIN > - #define INTPTR_MAX INT32_MAX > - #define UINTPTR_MAX UINT32_MAX > - #define PTRDIFF_MIN INT32_MIN > - #define PTRDIFF_MAX INT32_MAX > -#endif /* __WORDSIZE == 64 */ > +#define SIZE_MAX ((__SIZE_TYPE__)(__LONG_MAX__) * 2 + 1) > +#define INTPTR_MIN (-__LONG_MAX__ - 1) > +#define INTPTR_MAX __LONG_MAX__ > +#define UINTPTR_MAX (SIZE_MAX) > +#define PTRDIFF_MIN INTPTR_MIN > +#define PTRDIFF_MAX INTPTR_MAX > +#define __WORDSIZE (__SIZEOF_LONG__ * 8) > > #endif /* _NOLIBC_STDINT_H */ ^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests 2023-02-16 0:11 ` Vincent Dagonneau @ 2023-02-16 3:29 ` Willy Tarreau 0 siblings, 0 replies; 18+ messages in thread From: Willy Tarreau @ 2023-02-16 3:29 UTC (permalink / raw) To: Vincent Dagonneau; +Cc: linux-kernel Hi Vincent, On Wed, Feb 15, 2023 at 07:11:09PM -0500, Vincent Dagonneau wrote: > > So after investigation, __WORDSIZE is not defined, hence the failures! > > It proves the importance of the tests you've added ;-) > > > > However we have the size of these types defined by the compiler itself > > at least since gcc-4.4 and clang-3.8 which are the oldest I could test: > > > > $ mips-gcc44_glibc214-linux-gnu-gcc -xc -dM -E - </dev/null |grep SIZE > > #define __SIZEOF_POINTER__ 4 > > #define __SIZEOF_LONG__ 4 > > #define __SIZEOF_LONG_DOUBLE__ 8 > > #define __SIZEOF_SIZE_T__ 4 > > #define __SIZEOF_WINT_T__ 4 > > #define __SIZE_TYPE__ unsigned int > > #define __SIZEOF_PTRDIFF_T__ 4 > > #define __SIZEOF_INT__ 4 > > #define __SIZEOF_FLOAT__ 4 > > #define __SIZEOF_SHORT__ 2 > > #define __SIZEOF_WCHAR_T__ 4 > > #define __SIZEOF_DOUBLE__ 8 > > #define __SIZEOF_LONG_LONG__ 8 > > > > In addition both provide __SIZE_TYPE__ which is defined either as > > unsigned int or long unsigned int, so that can simplify quite some > > parts (and other types are defined for other types in more recent > > versions). Both also define __LONG_MAX__ that you could possibly > > use to conveniently create INTPTR_MAX, INTPTR_MIN, UINTPTR_MAX and > > so on. > > > > Mmmh, interesting, I hadn't thought about verifying what defined the > __WORDSIZE. I assumed wrongly that it was set by standard but it seems not. No problem, that's exactly why I wanted to retry every combination. > I replicated your example on my machine to see the intersection of what is > defined by both GCC and clang. Do you know if we would need to check any > other compilers? I don't think it's particularly needed to go further for now. For example I know that tcc doesn't support some of the asm constraints that we use in register alllocation. Supporting the most commonly encountered compilers is sufficient for our use case. > > And finally we should set the __WORDSIZE ourselves as 8*__SIZEOF_LONG__ > > and that would do the job. > > > > I tested the following patch which passes all the tests successfully > > on all supported archs. Let me know if you agree with such a change > > and how you want us to proceed. It would require a small change in the > > commit message though, to explain that our pointers are the size of a > > long on supported platforms. > > > > I can integrate the changes and write an explanation as a commit message and > submit a new version tomorrow, would that work for you? Sure that would be great! I'll look at it this week-end anyway. Thank you! Willy ^ permalink raw reply [flat|nested] 18+ messages in thread
end of thread, other threads:[~2023-02-23 1:00 UTC | newest] Thread overview: 18+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2023-02-20 20:20 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 1/4] tools/nolibc: add stdint.h Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 2/4] tools/nolibc: add integer types and integer limit macros Vincent Dagonneau 2023-02-21 17:40 ` Thomas Weißschuh 2023-02-23 0:35 ` Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 3/4] tools/nolibc: enlarge column width of tests Vincent Dagonneau 2023-02-20 20:20 ` [PATCH v5 4/4] tools/nolibc: add tests for the integer limits in stdint.h Vincent Dagonneau 2023-02-21 17:34 ` Thomas Weißschuh 2023-02-21 17:44 ` Willy Tarreau 2023-02-23 0:38 ` Vincent Dagonneau 2023-02-23 0:58 ` Vincent Dagonneau -- strict thread matches above, loose matches on Subject: below -- 2023-02-09 2:40 [PATCH v4 0/4] tools/nolibc: Adding stdint.h, more integer types and tests Vincent Dagonneau 2023-02-09 3:43 ` Willy Tarreau 2023-02-10 13:03 ` Vincent Dagonneau 2023-02-12 10:41 ` Willy Tarreau 2023-02-12 18:27 ` Willy Tarreau 2023-02-16 0:11 ` Vincent Dagonneau 2023-02-16 3:29 ` Willy Tarreau
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox