From 10653a171bc0ca145236d2c75e5c5422caeb8b55 Mon Sep 17 00:00:00 2001

From: Vishal Verma <vishal.l.verma@intel.com>

Date: Wed, 23 Feb 2022 22:28:05 -0700

Subject: [PATCH 140/217] util/size.h: fix build for older compilers

Add a fallback for older compilers that lack __builtin_add_overflow()

and friends. Commit 7aa7c7be6e80 ("util: add the struct_size() helper from the

kernel") which added these helpers from the kernel neglected to copy

over the fallback code.

Link: https://lore.kernel.org/r/20220224052805.2462449-1-vishal.l.verma@intel.com

Fixes: 7aa7c7be6e80 ("util: add the struct_size() helper from the kernel")

Reported-by: Joao Martins <joao.m.martins@oracle.com>

Reviewed-by: Joao Martins <joao.m.martins@oracle.com>

Signed-off-by: Vishal Verma <vishal.l.verma@intel.com>

---

 util/size.h | 163 ++++++++++++++++++++++++++++++++++++++++++++++++++--

 1 file changed, 159 insertions(+), 4 deletions(-)

diff --git a/util/size.h b/util/size.h

index e72467f..1cb0669 100644

--- a/util/size.h

+++ b/util/size.h

@@ -6,6 +6,7 @@

 #include <stdbool.h>

 #include <stdint.h>

 #include <util/util.h>

+#include <ccan/short_types/short_types.h>

 #define SZ_1K     0x00000400

 #define SZ_4K     0x00001000

@@ -43,23 +44,177 @@ static inline bool is_power_of_2(unsigned long long v)

  * alias for __builtin_add_overflow, but add type checks similar to

  * below.

  */

-#define check_add_overflow(a, b, d) (({	\

+#define is_signed_type(type)       (((type)(-1)) < (type)1)

+#define __type_half_max(type) ((type)1 << (8*sizeof(type) - 1 - is_signed_type(type)))

+#define type_max(T) ((T)((__type_half_max(T) - 1) + __type_half_max(T)))

+#define type_min(T) ((T)((T)-type_max(T)-(T)1))

+

+#if GCC_VERSION >= 50100

+#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1

+#endif

+

+#if __clang__ && \

+    __has_builtin(__builtin_mul_overflow) && \

+    __has_builtin(__builtin_add_overflow)

+#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1

+#endif

+

+#if COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW

+

+#define check_add_overflow(a, b, d) ({		\

 	typeof(a) __a = (a);			\

 	typeof(b) __b = (b);			\

 	typeof(d) __d = (d);			\

 	(void) (&__a == &__b);			\

 	(void) (&__a == __d);			\

 	__builtin_add_overflow(__a, __b, __d);	\

-}))

+})

+

+#define check_sub_overflow(a, b, d) ({		\

+	typeof(a) __a = (a);			\

+	typeof(b) __b = (b);			\

+	typeof(d) __d = (d);			\

+	(void) (&__a == &__b);			\

+	(void) (&__a == __d);			\

+	__builtin_sub_overflow(__a, __b, __d);	\

+})

-#define check_mul_overflow(a, b, d) (({	\

+#define check_mul_overflow(a, b, d) ({		\

 	typeof(a) __a = (a);			\

 	typeof(b) __b = (b);			\

 	typeof(d) __d = (d);			\

 	(void) (&__a == &__b);			\

 	(void) (&__a == __d);			\

 	__builtin_mul_overflow(__a, __b, __d);	\

-}))

+})

+

+

+#else /* !COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW */

+

+/* Checking for unsigned overflow is relatively easy without causing UB. */

+#define __unsigned_add_overflow(a, b, d) ({	\

+	typeof(a) __a = (a);			\

+	typeof(b) __b = (b);			\

+	typeof(d) __d = (d);			\

+	(void) (&__a == &__b);			\

+	(void) (&__a == __d);			\

+	*__d = __a + __b;			\

+	*__d < __a;				\

+})

+#define __unsigned_sub_overflow(a, b, d) ({	\

+	typeof(a) __a = (a);			\

+	typeof(b) __b = (b);			\

+	typeof(d) __d = (d);			\

+	(void) (&__a == &__b);			\

+	(void) (&__a == __d);			\

+	*__d = __a - __b;			\

+	__a < __b;				\

+})

+/*

+ * If one of a or b is a compile-time constant, this avoids a division.

+ */

+#define __unsigned_mul_overflow(a, b, d) ({		\

+	typeof(a) __a = (a);				\

+	typeof(b) __b = (b);				\

+	typeof(d) __d = (d);				\

+	(void) (&__a == &__b);				\

+	(void) (&__a == __d);				\

+	*__d = __a * __b;				\

+	__builtin_constant_p(__b) ?			\

+	  __b > 0 && __a > type_max(typeof(__a)) / __b : \

+	  __a > 0 && __b > type_max(typeof(__b)) / __a;	 \

+})

+

+/*

+ * For signed types, detecting overflow is much harder, especially if

+ * we want to avoid UB. But the interface of these macros is such that

+ * we must provide a result in *d, and in fact we must produce the

+ * result promised by gcc's builtins, which is simply the possibly

+ * wrapped-around value. Fortunately, we can just formally do the

+ * operations in the widest relevant unsigned type (u64) and then

+ * truncate the result - gcc is smart enough to generate the same code

+ * with and without the (u64) casts.

+ */

+

+/*

+ * Adding two signed integers can overflow only if they have the same

+ * sign, and overflow has happened iff the result has the opposite

+ * sign.

+ */

+#define __signed_add_overflow(a, b, d) ({	\

+	typeof(a) __a = (a);			\

+	typeof(b) __b = (b);			\

+	typeof(d) __d = (d);			\

+	(void) (&__a == &__b);			\

+	(void) (&__a == __d);			\

+	*__d = (u64)__a + (u64)__b;		\

+	(((~(__a ^ __b)) & (*__d ^ __a))	\

+		& type_min(typeof(__a))) != 0;	\

+})

+

+/*

+ * Subtraction is similar, except that overflow can now happen only

+ * when the signs are opposite. In this case, overflow has happened if

+ * the result has the opposite sign of a.

+ */

+#define __signed_sub_overflow(a, b, d) ({	\

+	typeof(a) __a = (a);			\

+	typeof(b) __b = (b);			\

+	typeof(d) __d = (d);			\

+	(void) (&__a == &__b);			\

+	(void) (&__a == __d);			\

+	*__d = (u64)__a - (u64)__b;		\

+	((((__a ^ __b)) & (*__d ^ __a))		\

+		& type_min(typeof(__a))) != 0;	\

+})

+

+/*

+ * Signed multiplication is rather hard. gcc always follows C99, so

+ * division is truncated towards 0. This means that we can write the

+ * overflow check like this:

+ *

+ * (a > 0 && (b > MAX/a || b < MIN/a)) ||

+ * (a < -1 && (b > MIN/a || b < MAX/a) ||

+ * (a == -1 && b == MIN)

+ *

+ * The redundant casts of -1 are to silence an annoying -Wtype-limits

+ * (included in -Wextra) warning: When the type is u8 or u16, the

+ * __b_c_e in check_mul_overflow obviously selects

+ * __unsigned_mul_overflow, but unfortunately gcc still parses this

+ * code and warns about the limited range of __b.

+ */

+

+#define __signed_mul_overflow(a, b, d) ({				\

+	typeof(a) __a = (a);						\

+	typeof(b) __b = (b);						\

+	typeof(d) __d = (d);						\

+	typeof(a) __tmax = type_max(typeof(a));				\

+	typeof(a) __tmin = type_min(typeof(a));				\

+	(void) (&__a == &__b);						\

+	(void) (&__a == __d);						\

+	*__d = (u64)__a * (u64)__b;					\

+	(__b > 0   && (__a > __tmax/__b || __a < __tmin/__b)) ||	\

+	(__b < (typeof(__b))-1  && (__a > __tmin/__b || __a < __tmax/__b)) || \

+	(__b == (typeof(__b))-1 && __a == __tmin);			\

+})

+

+

+#define check_add_overflow(a, b, d)					\

+	__builtin_choose_expr(is_signed_type(typeof(a)),		\

+			__signed_add_overflow(a, b, d),			\

+			__unsigned_add_overflow(a, b, d))

+

+#define check_sub_overflow(a, b, d)					\

+	__builtin_choose_expr(is_signed_type(typeof(a)),		\

+			__signed_sub_overflow(a, b, d),			\

+			__unsigned_sub_overflow(a, b, d))

+

+#define check_mul_overflow(a, b, d)					\

+	__builtin_choose_expr(is_signed_type(typeof(a)),		\

+			__signed_mul_overflow(a, b, d),			\

+			__unsigned_mul_overflow(a, b, d))

+

+#endif

 /*

  * Compute a*b+c, returning SIZE_MAX on overflow. Internal helper for

-- 

2.27.0