On Fri, Mar 16, 2018 at 10:55 AM, Al Viro <v...@zeniv.linux.org.uk> wrote:
>
> That's not them, that's C standard regarding ICE.
Yes. The C standard talks about "integer constant expression". I know.
It's come up in this very thread before.
The C standard at no point talks about - or forbids - "variable length
arrays". That never comes up in the whole standard, I checked.
So we are right now hindered by a _syntactic_ check, without any way
to have a _semantic_ check.
That's my problem. The warnings are misleading and imply semantics.
And apparently there is no way to actually check semantics.
> 1,100 is *not* a constant expression as far as the standard is concerned,
I very much know.
But it sure isn't "variable" either as far as the standard is
concerned, because the standard doesn't even have that concept (it
uses "variable" for argument numbers and for variables).
So being pedantic doesn't really change anything.
> Would you argue that in
> void foo(char c)
> {
> int a[(c<<1) + 10 - c + 2 - c];
Yeah, I don't think that even counts as a constant value, even if it
can be optimized to one. I would not at all be unhppy to see
__builtin_constant_p() to return zero.
But that is very much different from the syntax issue.
So I would like to get some way to get both type-checking and constant
checking without the annoying syntax issue.
> expr, constant_expression is not a constant_expression. And in
> this particular case the standard is not insane - the only reason
> for using that is typechecking and _that_ can be achieved without
> violating 6.6p6:
> sizeof(expr,0) * 0 + ICE
> *is* an integer constant expression, and it gives you exact same
> typechecking. So if somebody wants to play odd games, they can
> do that just fine, without complicating the logics for compilers...
Now that actually looks like a good trick. Maybe we can use that
instead of the comma expression that causes problems.
And using sizeof() to make sure that __builtin_choose_expression()
really gets an integer constant expression and that there should be no
ambiguity looks good.
Hmm.
This works for me, and I'm being *very* careful (those casts to
pointer types are inside that sizeof, because it's not an integral
type, and non-integral casts are not valid in an ICE either) but
somebody needs to check gcc-4.4:
#define __typecheck(a,b) \
(!!(sizeof((typeof(a)*)1==(typeof(b)*)1)))
#define __no_side_effects(a,b) \
(__builtin_constant_p(a)&&__builtin_constant_p(b))
#define __safe_cmp(a,b) \
(__typecheck(a,b) && __no_side_effects(a,b))
#define __cmp(a,b,op) ((a)op(b)?(a):(b))
#define __cmp_once(a,b,op) ({ \
typeof(a) __a = (a); \
typeof(b) __b = (b); \
__cmp(__a,__b,op); })
#define __careful_cmp(a,b,op) \
__builtin_choose_expr(__safe_cmp(a,b), __cmp(a,b,op),
__cmp_once(a,b,op))
#define min(a,b) __careful_cmp(a,b,<)
#define max(a,b) __careful_cmp(a,b,>)
#define min_t(t,a,b) __careful_cmp((t)(a),(t)(b),<)
#define max_t(t,a,b) __careful_cmp((t)(a),(t)(b),>)
and yes, it does cause new warnings for that
comparison between ‘enum tis_defaults’ and ‘enum tpm2_const’
in drivers/char/tpm/tpm_tis_core.h due to
#define TIS_TIMEOUT_A_MAX max(TIS_SHORT_TIMEOUT, TPM2_TIMEOUT_A)
but technically that warning is actually correct, I'm just confused
why gcc cares about the cast placement or something.
That warning is easy to fix by turning it into a "max_t(int, enum1,
enum2)' and that is technically the right thing to do, it's just not
warned about for some odd reason with the current code.
Kees - is there some online "gcc-4.4 checker" somewhere? This does
seem to work with my gcc. I actually tested some of those files you
pointed at now.
Linus
include/linux/kernel.h | 77 +++++++++++++-------------------------------------
1 file changed, 20 insertions(+), 57 deletions(-)
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 3fd291503576..23c31bf1d7fb 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -787,37 +787,29 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
* strict type-checking.. See the
* "unnecessary" pointer comparison.
*/
-#define __min(t1, t2, min1, min2, x, y) ({ \
- t1 min1 = (x); \
- t2 min2 = (y); \
- (void) (&min1 == &min2); \
- min1 < min2 ? min1 : min2; })
+#define __typecheck(a,b) \
+ (!!(sizeof((typeof(a)*)1==(typeof(b)*)1)))
-/**
- * min - return minimum of two values of the same or compatible types
- * @x: first value
- * @y: second value
- */
-#define min(x, y) \
- __min(typeof(x), typeof(y), \
- __UNIQUE_ID(min1_), __UNIQUE_ID(min2_), \
- x, y)
+#define __no_side_effects(a,b) \
+ (__builtin_constant_p(a)&&__builtin_constant_p(b))
-#define __max(t1, t2, max1, max2, x, y) ({ \
- t1 max1 = (x); \
- t2 max2 = (y); \
- (void) (&max1 == &max2); \
- max1 > max2 ? max1 : max2; })
+#define __safe_cmp(a,b) \
+ (__typecheck(a,b) && __no_side_effects(a,b))
-/**
- * max - return maximum of two values of the same or compatible types
- * @x: first value
- * @y: second value
- */
-#define max(x, y) \
- __max(typeof(x), typeof(y), \
- __UNIQUE_ID(max1_), __UNIQUE_ID(max2_), \
- x, y)
+#define __cmp(a,b,op) ((a)op(b)?(a):(b))
+
+#define __cmp_once(a,b,op) ({ \
+ typeof(a) __a = (a); \
+ typeof(b) __b = (b); \
+ __cmp(__a,__b,op); })
+
+#define __careful_cmp(a,b,op) \
+ __builtin_choose_expr(__safe_cmp(a,b), __cmp(a,b,op), __cmp_once(a,b,op))
+
+#define min(a,b) __careful_cmp(a,b,<)
+#define max(a,b) __careful_cmp(a,b,>)
+#define min_t(t,a,b) __careful_cmp((t)(a),(t)(b),<)
+#define max_t(t,a,b) __careful_cmp((t)(a),(t)(b),>)
/**
* min3 - return minimum of three values
@@ -856,35 +848,6 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
*/
#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)
-/*
- * ..and if you can't take the strict
- * types, you can specify one yourself.
- *
- * Or not use min/max/clamp at all, of course.
- */
-
-/**
- * min_t - return minimum of two values, using the specified type
- * @type: data type to use
- * @x: first value
- * @y: second value
- */
-#define min_t(type, x, y) \
- __min(type, type, \
- __UNIQUE_ID(min1_), __UNIQUE_ID(min2_), \
- x, y)
-
-/**
- * max_t - return maximum of two values, using the specified type
- * @type: data type to use
- * @x: first value
- * @y: second value
- */
-#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
* @type: the type of variable to use
