min/max: remove sparse warnings when they're nested

Currently, when min/max are nested within themselves, sparse will warn:

    warning: symbol '_min1' shadows an earlier one
    originally declared here
    warning: symbol '_min1' shadows an earlier one
    originally declared here
    warning: symbol '_min2' shadows an earlier one
    originally declared here

This also immediately happens when min3() or max3() are used.

Since sparse implements __COUNTER__, we can use __UNIQUE_ID() to
generate unique variable names, avoiding this.

Link: http://lkml.kernel.org/r/1471519773-29882-1-git-send-email-johannes@sipsolutions.net
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Cc: Jens Axboe <axboe@kernel.dk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 74fd6f05bc5bf5afad4364f6118aebc1a7407913..bc6ed52a39b967898c6e2f2814e23fbd6f2a3332 100644 (file)
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -733,17 +733,25 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
  * strict type-checking.. See the
  * "unnecessary" pointer comparison.
  */
-#define min(x, y) ({                           \
-       typeof(x) _min1 = (x);                  \
-       typeof(y) _min2 = (y);                  \
-       (void) (&_min1 == &_min2);              \
-       _min1 < _min2 ? _min1 : _min2; })
-
-#define max(x, y) ({                           \
-       typeof(x) _max1 = (x);                  \
-       typeof(y) _max2 = (y);                  \
-       (void) (&_max1 == &_max2);              \
-       _max1 > _max2 ? _max1 : _max2; })
+#define __min(t1, t2, min1, min2, x, y) ({             \
+       t1 min1 = (x);                                  \
+       t2 min2 = (y);                                  \
+       (void) (&min1 == &min2);                        \
+       min1 < min2 ? min1 : min2; })
+#define min(x, y)                                      \
+       __min(typeof(x), typeof(y),                     \
+             __UNIQUE_ID(min1_), __UNIQUE_ID(min2_),   \
+             x, y)
+
+#define __max(t1, t2, max1, max2, x, y) ({             \
+       t1 max1 = (x);                                  \
+       t2 max2 = (y);                                  \
+       (void) (&max1 == &max2);                        \
+       max1 > max2 ? max1 : max2; })
+#define max(x, y)                                      \
+       __max(typeof(x), typeof(y),                     \
+             __UNIQUE_ID(max1_), __UNIQUE_ID(max2_),   \
+             x, y)
 
 #define min3(x, y, z) min((typeof(x))min(x, y), z)
 #define max3(x, y, z) max((typeof(x))max(x, y), z)
@@ -775,15 +783,15 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
  *
  * Or not use min/max/clamp at all, of course.
  */
-#define min_t(type, x, y) ({                   \
-       type __min1 = (x);                      \
-       type __min2 = (y);                      \
-       __min1 < __min2 ? __min1: __min2; })
-
-#define max_t(type, x, y) ({                   \
-       type __max1 = (x);                      \
-       type __max2 = (y);                      \
-       __max1 > __max2 ? __max1: __max2; })
+#define min_t(type, x, y)                              \
+       __min(type, type,                               \
+             __UNIQUE_ID(min1_), __UNIQUE_ID(min2_),   \
+             x, y)
+
+#define max_t(type, x, y)                              \
+       __max(type, type,                               \
+             __UNIQUE_ID(min1_), __UNIQUE_ID(min2_),   \
+             x, y)
 
 /**
  * clamp_t - return a value clamped to a given range using a given type