== Series Details ==

Series: overflow: Introduce overflows_type() and castable_to_type() (rev4)
URL   : https://patchwork.freedesktop.org/series/109076/
State : warning

== Summary ==

Error: dim checkpatch failed
9f9dcc2b4db8 overflow: Introduce overflows_type() and castable_to_type()
-:88: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'x' - possible side-effects?
#88: FILE: include/linux/overflow.h:130:
+#define __overflows_type_constexpr(x, T) (                     \
+       is_unsigned_type(typeof(x)) ?                           \
+               (x) > type_max(typeof(T)) ? 1 : 0               \
+       : is_unsigned_type(typeof(T)) ?                         \
+               (x) < 0 || (x) > type_max(typeof(T)) ? 1 : 0    \
+               : (x) < type_min(typeof(T)) ||                  \
+                 (x) > type_max(typeof(T)) ? 1 : 0)

-:89: CHECK:SPACING: No space is necessary after a cast
#89: FILE: include/linux/overflow.h:131:
+       is_unsigned_type(typeof(x)) ?                           \

-:90: CHECK:SPACING: No space is necessary after a cast
#90: FILE: include/linux/overflow.h:132:
+               (x) > type_max(typeof(T)) ? 1 : 0               \

-:91: CHECK:SPACING: No space is necessary after a cast
#91: FILE: include/linux/overflow.h:133:
+       : is_unsigned_type(typeof(T)) ?                         \

-:92: CHECK:SPACING: No space is necessary after a cast
#92: FILE: include/linux/overflow.h:134:
+               (x) < 0 || (x) > type_max(typeof(T)) ? 1 : 0    \

-:93: CHECK:SPACING: No space is necessary after a cast
#93: FILE: include/linux/overflow.h:135:
+               : (x) < type_min(typeof(T)) ||                  \

-:94: CHECK:SPACING: No space is necessary after a cast
#94: FILE: include/linux/overflow.h:136:
+                 (x) > type_max(typeof(T)) ? 1 : 0)

-:115: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'n' - possible side-effects?
#115: FILE: include/linux/overflow.h:157:
+#define overflows_type(n, T)                                   \
+       __builtin_choose_expr(__is_constexpr(n),                \
+                             __overflows_type_constexpr(n, T), \
+                             __overflows_type(n, T))

-:115: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'T' - possible side-effects?
#115: FILE: include/linux/overflow.h:157:
+#define overflows_type(n, T)                                   \
+       __builtin_choose_expr(__is_constexpr(n),                \
+                             __overflows_type_constexpr(n, T), \
+                             __overflows_type(n, T))

-:131: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'n' - possible side-effects?
#131: FILE: include/linux/overflow.h:173:
+#define castable_to_type(n, T)                                         \
+       __builtin_choose_expr(__is_constexpr(n),                        \
+                             !__overflows_type_constexpr(n, T),        \
+                             __same_type(n, T))

-:131: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'T' - possible side-effects?
#131: FILE: include/linux/overflow.h:173:
+#define castable_to_type(n, T)                                         \
+       __builtin_choose_expr(__is_constexpr(n),                        \
+                             !__overflows_type_constexpr(n, T),        \
+                             __same_type(n, T))

-:176: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'of' - possible side-effects?
#176: FILE: lib/overflow_kunit.c:716:
+#define __TEST_OVERFLOWS_TYPE(func, arg1, arg2, of)    do {            \
+       bool __of = func(arg1, arg2);                                   \
+       KUNIT_EXPECT_EQ_MSG(test, __of, of,                             \
+               "expected " #func "(" #arg1 ", " #arg2 " to%s overflow\n",\
+               of ? "" : " not");                                      \
+       count++;                                                        \
+} while (0)

-:185: CHECK:MACRO_ARG_REUSE: Macro argument reuse '__t2' - possible 
side-effects?
#185: FILE: lib/overflow_kunit.c:725:
+#define TEST_OVERFLOWS_TYPE(__t1, __t2, v, of) do {                    \
+       __t1 t1 = (v);                                                  \
+       __t2 t2;                                                        \
+       __TEST_OVERFLOWS_TYPE(__overflows_type, t1, t2, of);            \
+       __TEST_OVERFLOWS_TYPE(__overflows_type, t1, __t2, of);          \
+       __TEST_OVERFLOWS_TYPE(__overflows_type_constexpr, t1, t2, of);  \
+       __TEST_OVERFLOWS_TYPE(__overflows_type_constexpr, t1, __t2, of);\
+} while (0)

-:185: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'of' - possible side-effects?
#185: FILE: lib/overflow_kunit.c:725:
+#define TEST_OVERFLOWS_TYPE(__t1, __t2, v, of) do {                    \
+       __t1 t1 = (v);                                                  \
+       __t2 t2;                                                        \
+       __TEST_OVERFLOWS_TYPE(__overflows_type, t1, t2, of);            \
+       __TEST_OVERFLOWS_TYPE(__overflows_type, t1, __t2, of);          \
+       __TEST_OVERFLOWS_TYPE(__overflows_type_constexpr, t1, t2, of);  \
+       __TEST_OVERFLOWS_TYPE(__overflows_type_constexpr, t1, __t2, of);\
+} while (0)

-:388: CHECK:MACRO_ARG_REUSE: Macro argument reuse 't1' - possible side-effects?
#388: FILE: lib/overflow_kunit.c:928:
+#define TEST_SAME_TYPE(t1, t2, same)                   do {    \
+       typeof(t1) __t1h = type_max(t1);                        \
+       typeof(t1) __t1l = type_min(t1);                        \
+       typeof(t2) __t2h = type_max(t2);                        \
+       typeof(t2) __t2l = type_min(t2);                        \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1h));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1l));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t1h, t1));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t1l, t1));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2h));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2l));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t2h, t2));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t2l, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, t2));       \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1h));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1l));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t1h, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t1l, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2h));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2l));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t2h, t1));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t2l, t1));    \
+} while (0)

-:388: CHECK:MACRO_ARG_REUSE: Macro argument reuse 't2' - possible side-effects?
#388: FILE: lib/overflow_kunit.c:928:
+#define TEST_SAME_TYPE(t1, t2, same)                   do {    \
+       typeof(t1) __t1h = type_max(t1);                        \
+       typeof(t1) __t1l = type_min(t1);                        \
+       typeof(t2) __t2h = type_max(t2);                        \
+       typeof(t2) __t2l = type_min(t2);                        \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1h));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1l));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t1h, t1));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t1l, t1));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2h));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2l));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t2h, t2));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t2l, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, t2));       \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1h));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1l));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t1h, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t1l, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2h));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2l));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t2h, t1));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t2l, t1));    \
+} while (0)

-:388: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'same' - possible 
side-effects?
#388: FILE: lib/overflow_kunit.c:928:
+#define TEST_SAME_TYPE(t1, t2, same)                   do {    \
+       typeof(t1) __t1h = type_max(t1);                        \
+       typeof(t1) __t1l = type_min(t1);                        \
+       typeof(t2) __t2h = type_max(t2);                        \
+       typeof(t2) __t2l = type_min(t2);                        \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1h));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t1, __t1l));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t1h, t1));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t1l, t1));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2h));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(t2, __t2l));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t2h, t2));    \
+       KUNIT_EXPECT_EQ(test, true, __same_type(__t2l, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, t2));       \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1h));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t2, __t1l));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t1h, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t1l, t2));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2h));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(t1, __t2l));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t2h, t1));    \
+       KUNIT_EXPECT_EQ(test, same, __same_type(__t2l, t1));    \
+} while (0)

-:418: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'base' - possible 
side-effects?
#418: FILE: lib/overflow_kunit.c:958:
+#define TEST_TYPE_SETS(base, mu8, mu16, mu32, ms8, ms16, ms32, mu64, ms64) \
+do {                                                                   \
+       TEST_SAME_TYPE(base,  u8,  mu8);                                \
+       TEST_SAME_TYPE(base, u16, mu16);                                \
+       TEST_SAME_TYPE(base, u32, mu32);                                \
+       TEST_SAME_TYPE(base,  s8,  ms8);                                \
+       TEST_SAME_TYPE(base, s16, ms16);                                \
+       TEST_SAME_TYPE(base, s32, ms32);                                \
+       TEST_SAME_TYPE64(base, u64, mu64);                              \
+       TEST_SAME_TYPE64(base, s64, ms64);                              \
+} while (0)

-:462: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'pass' - possible 
side-effects?
#462: FILE: lib/overflow_kunit.c:1002:
+#define TEST_CASTABLE_TO_TYPE(arg1, arg2, pass)        do {    \
+       bool __pass = castable_to_type(arg1, arg2);             \
+       KUNIT_EXPECT_EQ_MSG(test, __pass, pass,                 \
+               "expected castable_to_type(" #arg1 ", " #arg2 ") to%s pass\n",\
+               pass ? "" : " not");                            \
+       count++;                                                \
+} while (0)

total: 0 errors, 0 warnings, 19 checks, 490 lines checked


Reply via email to