minmax: deduplicate __unconst_integer_typeof()

[ Upstream commit 5e57418a2031cd5e1863efdf3d7447a16a368172 ]

It appears that compiler_types.h already have an implementation of the
__unconst_integer_typeof() called __unqual_scalar_typeof().  Use it
instead of the copy.

Link: https://lkml.kernel.org/r/20230911154913.4176033-1-andriy.shevchenko@linux.intel.com
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Acked-by: Herve Codina <herve.codina@bootlin.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Eliav Farber <farbere@amazon.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/include/linux/minmax.h b/include/linux/minmax.h
index aac0b7d237689c8de7e8c5b434762ca039ff4d3b..62b0c0a3cf307201efbd05cac3dda354a77066c0 100644 (file)
--- a/include/linux/minmax.h
+++ b/include/linux/minmax.h
@@ -168,27 +168,6 @@
  */
 #define max_t(type, x, y)      __careful_cmp(max, (type)(x), (type)(y))
 
-/*
- * Remove a const qualifier from integer types
- * _Generic(foo, type-name: association, ..., default: association) performs a
- * comparison against the foo type (not the qualified type).
- * Do not use the const keyword in the type-name as it will not match the
- * unqualified type of foo.
- */
-#define __unconst_integer_type_cases(type)     \
-       unsigned type:  (unsigned type)0,       \
-       signed type:    (signed type)0
-
-#define __unconst_integer_typeof(x) typeof(                    \
-       _Generic((x),                                           \
-               char: (char)0,                                  \
-               __unconst_integer_type_cases(char),             \
-               __unconst_integer_type_cases(short),            \
-               __unconst_integer_type_cases(int),              \
-               __unconst_integer_type_cases(long),             \
-               __unconst_integer_type_cases(long long),        \
-               default: (x)))
-
 /*
  * Do not check the array parameter using __must_be_array().
  * In the following legit use-case where the "array" passed is a simple pointer,
@@ -203,13 +182,13 @@
  * 'int *buff' and 'int buff[N]' types.
  *
  * The array can be an array of const items.
- * typeof() keeps the const qualifier. Use __unconst_integer_typeof() in order
+ * typeof() keeps the const qualifier. Use __unqual_scalar_typeof() in order
  * to discard the const qualifier for the __element variable.
  */
 #define __minmax_array(op, array, len) ({                              \
        typeof(&(array)[0]) __array = (array);                          \
        typeof(len) __len = (len);                                      \
-       __unconst_integer_typeof(__array[0]) __element = __array[--__len]; \
+       __unqual_scalar_typeof(__array[0]) __element = __array[--__len];\
        while (__len--)                                                 \
                __element = op(__element, __array[__len]);              \
        __element; })