2c91dc1bcd
This includes support for the CXL commands, and adds the following packages: cxl-cli, cxl-devel, cxl-libs. Resolves: rhbz#2132167
217 lines
6.8 KiB
Diff
217 lines
6.8 KiB
Diff
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
|
|
|