Skip to contentSkip to conversation

integer limit macro consolidation

PATCH In review Rasmus Villemoes 2 participants 5 messages Jul 7, 2025 – Jul 14, 2025

lore
Share & tools
lore
#0 lore raw

v2 cover integer limit macro consolidation

I was bitten by our limit macros not being usable in #if conditionals when building a standalone app. It turns out that the work to fix that had already been started by the inclusion of the mbedtls library, so it's something that people do hit.

Let's finish the job by providing suitable limit macros for all three families:

- Standard C types, char, short, ...
- Kernel-style fixed-width types s8, u64, ...
- POSIX/C99 fixed-width types int16_t, uint32_t, ...

Please note that a naive approach like spelling out the full decimal value for the constants doesn't really work, as there is no such thing as a "negative integer constant". That is, doing

#define LLONG_MIN -9223372036854775808LL

would lead to the compiler complaining

warning: integer constant is so large that it is unsigned

and the type of that LLONG_MIN would actually be "unsigned long long", so e.g.

#if LLONG_MIN >= 0
#warning "LLONG_MIN is not negative?"
#endif

would fire.

v2: Fix typo in 1/3 caught by CI.
CI is now happy: https://github.com/u-boot/u-boot/pull/796

Rasmus Villemoes (3):
move more limits from kernel.h to limits.h and standardize their
definitions
move limits for sNN/uNN types from kernel.h to limits.h limits.h: provide all limit macros for standard [u]intNN_t types

 include/limits.h       | 58 +++++++++++++++++++++++++++++++++++++++---
 include/linux/kernel.h | 26 -------------------
 include/stdint.h       |  2 +-
 3 files changed, 55 insertions(+), 31 deletions(-)
Signature · 1 line
2.50.0
#1 lore raw

PATCH v2 1/3 move more limits from kernel.h to limits.h and standardize their definitions

In a customer project that was building a stand-alone application, I hit a problem related to the fact that our LONG_MAX and friends are not standards-compliant, in that they are not "suitable for use in #if preprocessing directives"

... /toolchain_none/arm-cortexa8-eabi/sys-include/machine/_default_types.h:25:31: error: missing binary operator before token "long"
25 | || ( defined(LLONG_MAX) && (LLONG_MAX > 0x7fffffff) )
| ^~~~~~~~~

So following up on commit 13de8483388 ("mbedtls: add mbedtls into the build system"), move the rest of the macros associated to the standard C types {signed,unsigned} {char, short, int, long, long long} (and of course bare 'char') to limits.h.

Make use of the fact that both gcc and clang provide suitable predefined __FOO_MAX__ macros for the signed types, and use a standard scheme for defining the FOO_MIN and UFOO_MAX macros in terms of FOO_MAX.

Note that suffixes like L and ULL are allowed for preprocessor integers; it is (casts) which are not. And using appropriate suffixes, we can arrange for the type of e.g. UINT_MAX to be "unsigned int" due to integer promotion rules.

---
 include/limits.h       | 30 ++++++++++++++++++++++++++++--
 include/linux/kernel.h | 11 -----------
 2 files changed, 28 insertions(+), 13 deletions(-)
include/limits.h +28 -2
index 1d0bbf69be7..4dcfbe9b156 100644
@@ -3,8 +3,34 @@
 #ifndef _LIMITS_H
 #define _LIMITS_H
 
-#define INT_MAX     0x7fffffff
-#define UINT_MAX    0xffffffffU
+#define SCHAR_MAX   __SCHAR_MAX__
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
+#define UCHAR_MAX   (SCHAR_MAX * 2 + 1)
+
+#ifdef __CHAR_UNSIGNED__
+#define CHAR_MAX    UCHAR_MAX
+#define CHAR_MIN    0
+#else
+#define CHAR_MAX    SCHAR_MAX
+#define CHAR_MIN    SCHAR_MIN
+#endif
+
+#define SHRT_MAX    __SHRT_MAX__
+#define SHRT_MIN    (-SHRT_MAX - 1)
+#define USHRT_MAX   (SHRT_MAX * 2 + 1)
+
+#define INT_MAX     __INT_MAX__
+#define INT_MIN     (-INT_MAX - 1)
+#define UINT_MAX    (INT_MAX * 2U + 1U)
+
+#define LONG_MAX    __LONG_MAX__
+#define LONG_MIN    (-LONG_MAX - 1L)
+#define ULONG_MAX   (LONG_MAX * 2UL + 1UL)
+
+#define LLONG_MAX   __LONG_LONG_MAX__
+#define LLONG_MIN   (-LLONG_MAX - 1LL)
+#define ULLONG_MAX  (LLONG_MAX * 2ULL + 1ULL)
+
 #define CHAR_BIT    8
 #define UINT32_MAX  0xffffffffU
 #define UINT64_MAX  0xffffffffffffffffULL
include/linux/kernel.h +0 -11
index 9467edd65ab..f26274fbe1d 100644
@@ -5,17 +5,6 @@
 #include <linux/printk.h> /* for printf/pr_* utilities */
 #include <limits.h>
 
-#define USHRT_MAX	((u16)(~0U))
-#define SHRT_MAX	((s16)(USHRT_MAX>>1))
-#define SHRT_MIN	((s16)(-SHRT_MAX - 1))
-#define INT_MIN		(-INT_MAX - 1)
-#define LONG_MAX	((long)(~0UL>>1))
-#define LONG_MIN	(-LONG_MAX - 1)
-#define ULONG_MAX	(~0UL)
-#define LLONG_MAX	((long long)(~0ULL>>1))
-#define LLONG_MIN	(-LLONG_MAX - 1)
-#define ULLONG_MAX	(~0ULL)
-
 #define U8_MAX		((u8)~0U)
 #define S8_MAX		((s8)(U8_MAX>>1))
 #define S8_MIN		((s8)(-S8_MAX - 1))
Signature · 1 line
2.50.0
#2 lore raw

PATCH v2 2/3 move limits for sNN/uNN types from kernel.h to limits.h

In reply to Rasmus Villemoes

Since we define the {s,u}{8,16,32,64} types the same way on all architectures, i.e. everybody uses asm-generic/int-ll64.h, we can just define the associated limit macros in terms of those for the corresponding types. This eliminates another set of limit macros that are not usable in #if conditionals.

These type names and macros are not C or POSIX, so there's no language violation, but certainly a violation of developers' reasonable expectations.

---
 include/limits.h       | 13 +++++++++++++
 include/linux/kernel.h | 13 -------------
 2 files changed, 13 insertions(+), 13 deletions(-)
include/limits.h +13 -0
index 4dcfbe9b156..c2e3d0302b7 100644
@@ -31,6 +31,19 @@
 #define LLONG_MIN   (-LLONG_MAX - 1LL)
 #define ULLONG_MAX  (LLONG_MAX * 2ULL + 1ULL)
 
+#define U8_MAX      UCHAR_MAX
+#define S8_MAX      SCHAR_MAX
+#define S8_MIN      SCHAR_MIN
+#define U16_MAX     USHRT_MAX
+#define S16_MAX     SHRT_MAX
+#define S16_MIN     SHRT_MIN
+#define U32_MAX     UINT_MAX
+#define S32_MAX     INT_MAX
+#define S32_MIN     INT_MIN
+#define U64_MAX     ULLONG_MAX
+#define S64_MAX     LLONG_MAX
+#define S64_MIN     LLONG_MIN
+
 #define CHAR_BIT    8
 #define UINT32_MAX  0xffffffffU
 #define UINT64_MAX  0xffffffffffffffffULL
include/linux/kernel.h +0 -13
index f26274fbe1d..d3d979834ae 100644
@@ -5,19 +5,6 @@
 #include <linux/printk.h> /* for printf/pr_* utilities */
 #include <limits.h>
 
-#define U8_MAX		((u8)~0U)
-#define S8_MAX		((s8)(U8_MAX>>1))
-#define S8_MIN		((s8)(-S8_MAX - 1))
-#define U16_MAX		((u16)~0U)
-#define S16_MAX		((s16)(U16_MAX>>1))
-#define S16_MIN		((s16)(-S16_MAX - 1))
-#define U32_MAX		((u32)~0U)
-#define S32_MAX		((s32)(U32_MAX>>1))
-#define S32_MIN		((s32)(-S32_MAX - 1))
-#define U64_MAX		((u64)~0ULL)
-#define S64_MAX		((s64)(U64_MAX>>1))
-#define S64_MIN		((s64)(-S64_MAX - 1))
-
 #define INT32_MAX	S32_MAX
 
 #define STACK_MAGIC	0xdeadbeef
Signature · 1 line
2.50.0
#3 lore raw

PATCH v2 3/3 limits.h: provide all limit macros for standard [u]intNN_t types

In reply to Rasmus Villemoes

Currently, we only have UINT32_MAX and UINT64_MAX in limits.h, and then stdint.h and kernel.h somewhat randomly define UINT8_MAX and INT32_MAX, respectively.

Provide a full set of definitions in terms of the min/max macros for the types that [u]intNN_t are defined in terms of, namely the {s,u}NN ones.

Try to avoid breaking whatever depended on getting UINT8_MAX from our compat stdint.h by replacing it with an include of limits.h.

---
 include/limits.h       | 15 +++++++++++++--
 include/linux/kernel.h |  2 --
 include/stdint.h       |  2 +-
 3 files changed, 14 insertions(+), 5 deletions(-)
include/limits.h +13 -2
index c2e3d0302b7..a032bc5b84d 100644
@@ -44,9 +44,20 @@
 #define S64_MAX     LLONG_MAX
 #define S64_MIN     LLONG_MIN
 
+#define UINT8_MAX   U8_MAX
+#define INT8_MAX    S8_MAX
+#define INT8_MIN    S8_MIN
+#define UINT16_MAX  U16_MAX
+#define INT16_MAX   S16_MAX
+#define INT16_MIN   S16_MIN
+#define UINT32_MAX  U32_MAX
+#define INT32_MAX   S32_MAX
+#define INT32_MIN   S32_MIN
+#define UINT64_MAX  U64_MAX
+#define INT64_MAX   S64_MAX
+#define INT64_MIN   S64_MIN
+
 #define CHAR_BIT    8
-#define UINT32_MAX  0xffffffffU
-#define UINT64_MAX  0xffffffffffffffffULL
 
 #if (defined(CONFIG_64BIT) && !defined(CONFIG_SPL_BUILD)) || \
 	(defined(CONFIG_SPL_64BIT) && defined(CONFIG_SPL_BUILD))
include/linux/kernel.h +0 -2
index d3d979834ae..e0443ecac84 100644
@@ -5,8 +5,6 @@
 #include <linux/printk.h> /* for printf/pr_* utilities */
 #include <limits.h>
 
-#define INT32_MAX	S32_MAX
-
 #define STACK_MAGIC	0xdeadbeef
 
 #define REPEAT_BYTE(x)	((~0ul / 0xff) * (x))
include/stdint.h +1 -1
index dea83c8226a..90fd2bdee08 100644
@@ -9,6 +9,6 @@
 #ifndef __UB_STDINT_H
 #define __UB_STDINT_H
 
-#define UINT8_MAX	0xff
+#include <limits.h>
 
 #endif
Signature · 1 line
2.50.0
#4 lore raw
In reply to Rasmus Villemoes
Quoted 8 lines · Rasmus Villemoes

I was bitten by our limit macros not being usable in #if conditionals when building a standalone app. It turns out that the work to fix that had already been started by the inclusion of the mbedtls library, so it's something that people do hit.

Let's finish the job by providing suitable limit macros for all three families:

[...]

Applied to u-boot/master, thanks!

[1/3] move more limits from kernel.h to limits.h and standardize their definitions

      commit: dc323f3bee318514af9d7c6fed1e01c712bc71ae
[2/3] move limits for sNN/uNN types from kernel.h to limits.h
      commit: 0604595c16a6bf3c0aed131b80d1a25d5d74057d
[3/3] limits.h: provide all limit macros for standard [u]intNN_t types
      commit: dd260d95fd26deedc64f076b554759d09420f006
Signature · 1 line
Tom