From: Nicolai Stange <nicstange@xxxxxxxxx>
Move the whole calculation of cast expressions' constness flags to the
evaluation phase such that expressions like
(int)__builtin_choose_expr(0, 0, 0)
can now be recognized as qualifying as integer constant expressions.
Signed-off-by: Nicolai Stange <nicstange@xxxxxxxxx>
Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@xxxxxxxxx>
---
evaluate.c | 37 +++++++++++++++++++++++++++++--------
expression.c | 19 -------------------
expression.h | 7 +++++++
validation/constexpr-cast.c | 25 +++++++++++++++++++++++++
4 files changed, 61 insertions(+), 27 deletions(-)
create mode 100644 validation/constexpr-cast.c
diff --git a/evaluate.c b/evaluate.c
index 18f1da8b3..5725e898f 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -271,6 +271,7 @@ warn_for_different_enum_types (struct position pos,
}
}
+static int cast_flags(struct expression *expr, struct expression *target);
static struct symbol *cast_to_bool(struct expression *expr);
/*
@@ -323,10 +324,10 @@ static struct expression * cast_to(struct expression *old, struct symbol *type)
}
expr = alloc_expression(old->pos, EXPR_IMPLIED_CAST);
- expr->flags = old->flags;
expr->ctype = type;
expr->cast_type = type;
expr->cast_expression = old;
+ expr->flags = cast_flags(expr, old);
if (is_bool_type(type))
cast_to_bool(expr);
@@ -2720,6 +2721,32 @@ static struct symbol *cast_to_bool(struct expression *expr)
return expr->ctype;
}
+static int cast_flags(struct expression *expr, struct expression *old)
+{
+ struct symbol *t;
+ int class;
+ int flags = CEF_NONE;
+
+ class = classify_type(expr->ctype, &t);
+ if (class & TYPE_NUM) {
+ flags = old->flags & ~CEF_CONST_MASK;
+ /*
+ * Cast to float type -> not an integer constant
+ * expression [6.6(6)].
+ */
+ if (class & TYPE_FLOAT)
+ flags &= ~CEF_CLR_ICE;
+ /*
+ * Casts of float literals to integer type results in
+ * a constant integer expression [6.6(6)].
+ */
+ else if (old->flags & CEF_FLOAT)
+ flags = CEF_SET_ICE;
+ }
+
+ return flags;
+}
+
static struct symbol *evaluate_cast(struct expression *expr)
{
struct expression *target = expr->cast_expression;
@@ -2768,13 +2795,7 @@ static struct symbol *evaluate_cast(struct expression *expr)
class1 = classify_type(ctype, &t1);
- /* cast to non-integer type -> not an integer constant expression */
- if (!is_int(class1))
- expr->flags = CEF_NONE;
- /* if argument turns out to be not an integer constant expression *and*
- it was not a floating literal to start with -> too bad */
- else if (expr->flags & CEF_ICE && !(target->flags & CEF_ICE))
- expr->flags = CEF_NONE;
+ expr->flags = cast_flags(expr, target);
/*
* You can always throw a value away by casting to
diff --git a/expression.c b/expression.c
index 4189e5f3a..3262cf22c 100644
--- a/expression.c
+++ b/expression.c
@@ -722,25 +722,6 @@ static struct token *cast_expression(struct token *token, struct expression **tr
if (!v)
return token;
cast->cast_expression = v;
-
- cast->flags = v->flags & ~CEF_CONST_MASK;
- /*
- * Up to now, we missed the (int).0 case here
- * which should really get a
- * CEF_ICE marker. Also,
- * conversion to non-numeric types is not
- * properly reflected up to this point.
- * However, we do not know until evaluation.
- * For the moment, in order to preserve
- * semantics, speculatively set
- * CEF_ICE if
- * CEF_FLOAT is
- * set. evaluate_cast() will unset
- * inappropriate flags again after examining
- * type information.
- */
- if (v->flags & CEF_FLOAT)
- cast->flags |= CEF_SET_ICE;
return token;
}
}
diff --git a/expression.h b/expression.h
index ec94ff4a1..c084783c8 100644
--- a/expression.h
+++ b/expression.h
@@ -120,6 +120,13 @@ enum constexpr_flag {
CEF_CONST_MASK = (CEF_INT | CEF_FLOAT | CEF_CHAR),
};
+/*
+ * not an integer constant expression => neither of integer,
+ * enumeration and character constant
+ */
+#define CEF_CLR_ICE \
+ (CEF_ICE | CEF_INT | CEF_ENUM | CEF_CHAR)
+
enum {
Taint_comma = 1,
}; /* for expr->taint */
diff --git a/validation/constexpr-cast.c b/validation/constexpr-cast.c
new file mode 100644
index 000000000..27069614c
--- /dev/null
+++ b/validation/constexpr-cast.c
@@ -0,0 +1,25 @@
+static int a[] = {
+ [(int)0] = 0, // OK
+ [(int)(int)0] = 0, // OK
+ [(int)0.] = 0, // OK
+ [(int)(int)0.] = 0, // OK
+ [(int)__builtin_choose_expr(0, 0, 0)] = 0, // OK
+ [(int)__builtin_choose_expr(0, 0, 0.)] = 0, // OK
+
+ [(int)(float)0] = 0, // KO
+ [(int)(float)0.] = 0, // KO
+
+ [(int)(void*)0] = 0, // KO
+ [(int)(void*)0.] = 0, // KO
+
+};
+/*
+ * check-name: Expression constness propagation in casts
+ *
+ * check-error-start
+constexpr-cast.c:9:11: error: bad integer constant expression
+constexpr-cast.c:10:11: error: bad integer constant expression
+constexpr-cast.c:12:11: error: bad integer constant expression
+constexpr-cast.c:13:11: error: bad integer constant expression
+ * check-error-end
+ */
--
2.12.0
--
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
