I play with it a bit.
On Thu, May 4, 2017 at 12:00 PM, Lance Richardson <lrichard@xxxxxxxxxx> wrote:
> +static int match_static_assert(struct token *token)
> +{
> + return token_type(token) == TOKEN_IDENT &&
> + token->ident == &_Static_assert_ident;
> +}
I just find out there is already function match_ident() so use that
instead will make it clear it is compare against "_Static_assert".
Sorry I forget about this function earlier. I only find it when I play
with the code today.
>
> struct statement *alloc_statement(struct position pos, int type)
> {
> @@ -1864,13 +1877,17 @@ static struct token *declaration_list(struct token *token, struct symbol_list **
> static struct token *struct_declaration_list(struct token *token, struct symbol_list **list)
> {
> while (!match_op(token, '}')) {
> - if (!match_op(token, ';'))
> - token = declaration_list(token, list);
> - if (!match_op(token, ';')) {
> - sparse_error(token->pos, "expected ; at end of declaration");
> - break;
> + if (match_static_assert(token))
> + token = parse_static_assert(token, NULL);
> + else {
> + if (!match_op(token, ';'))
> + token = declaration_list(token, list);
> + if (!match_op(token, ';')) {
> + sparse_error(token->pos, "expected ; at end of declaration");
> + break;
> + }
> + token = token->next;
I reshape the code a bit to make it looks compact. Please see my
attachment patch.
> +static struct token *parse_static_assert(struct token *token, struct symbol_list **unused)
> +{
> + struct expression *expr1 = NULL, *expr2 = NULL;
> + int val;
> +
> + token = expect(token->next, '(', "after _Static_assert");
> + token = constant_expression(token, &expr1);
> + token = expect(token, ',', "after first argument of _Static_assert");
> + token = parse_expression(token, &expr2);
> + token = expect(token, ')', "after second argument of _Static_assert");
> +
> + token = expect(token, ';', "after _Static_assert()");
> +
> + if (!expr1 || !expr2)
> + return token;
OK, this parsing does not complain about the following input:
_Static_assert(0, );
_Static_assert(, "");
I fix it in my patch. While I am there, I rename the expr1 to "cond".
> /* Make a statement out of an expression */
> static struct statement *make_statement(struct expression *expr)
> {
> @@ -2389,11 +2436,14 @@ static struct token * statement_list(struct token *token, struct statement_list
> }
> stmt = alloc_statement(token->pos, STMT_DECLARATION);
> token = external_declaration(token, &stmt->declaration);
> + add_statement(list, stmt);
> + } else if (match_static_assert(token)) {
> + token = parse_static_assert(token, NULL);
After take a closer look of the grimmer syntax. Static assert is
actually a declaration rather than a statement. So I merge this
two because external_declaration() can handle _Static_assert
parsing any way. Just need to pay attention it does not generate
resulting symbol node.
I rename the patch as V6. V5 does not apply to master any more.
Luc, can you take a look the V6 patch as well?
Thanks
Chris
From patchwork Thu May 4 16:00:38 2017
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: [v5] sparse: add support for _Static_assert
From: Lance Richardson <lrichard@xxxxxxxxxx>
X-Patchwork-Id: 9712267
Message-Id: <20170504160038.5328-1-lrichard@xxxxxxxxxx>
To: linux-sparse@xxxxxxxxxxxxxxx
Date: Thu, 4 May 2017 12:00:38 -0400
This patch introduces support for the C11 _Static_assert() construct.
Per the N1539 draft standard, the syntax changes for this construct
include:
declaration:
<declaration-specifiers> <init-declarator-list>[opt] ;
<static_assert-declaration>
struct-declaration:
<specifier-qualifier-list> <struct-declarator-list>[opt] ;
<static_assert-declaration>
static_assert-declaration:
_Static_assert ( <constant-expression> , <string-literal> ) ;
Signed-off-by: Lance Richardson <lrichard@xxxxxxxxxx>
Acked-by: Luc Van Oostenryck <luc.vanoostenryck@xxxxxxxxx>
---
v5: Incorporated feedback from Christopher Li and Luc van Oostenryck:
- Made _Static_assert a reserved identifier
- Simplified check for _Static_assert keyword, consolidated into
a common function.
- Improved the "static assert within a function body" test case
by adding a static assertion intermingled with code and adding
a static assertion within a compound statement block.
- Fixed use of initialized stmt variable.
Tested by using sparse on entire kernel tree and a similarly-sized
code tree which makes use of _Static_assert().
v4: Addressed feedback, simplified and restructured to better model
description in draft standard.
v3:
- Removed bogus test case introduced in v2 (static assertion on sizeof
a structure within the definition of the structure).
v2:
- Added additional test cases.
- Added additional validation for parameters to _Static_assert().
- Reworked implementation to avoid impacting struct/union definition
handling ( the v1 implementation, which treated _Static_assert()
as an NS_TYPEDEF term, had the unfortunate side-effect of
leaving an unnamed field with unknown size attached to structure
definitions when a static assert was inside a structure definition).
ident-list.h | 1 +
parse.c | 66 ++++++++++++++++++++++++++++++++++++++++------
validation/static_assert.c | 64 ++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 123 insertions(+), 8 deletions(-)
create mode 100644 validation/static_assert.c
--- sparse.chrisl.orig/parse.c
+++ sparse.chrisl/parse.c
@@ -73,6 +73,7 @@ static struct token *parse_context_state
static struct token *parse_range_statement(struct token *token, struct statement *stmt);
static struct token *parse_asm_statement(struct token *token, struct statement *stmt);
static struct token *toplevel_asm_declaration(struct token *token, struct symbol_list **list);
+static struct token *parse_static_assert(struct token *token, struct symbol_list **unused);
typedef struct token *attr_t(struct token *, struct symbol *,
struct decl_state *);
@@ -328,6 +329,10 @@ static struct symbol_op asm_op = {
.toplevel = toplevel_asm_declaration,
};
+static struct symbol_op static_assert_op = {
+ .toplevel = parse_static_assert,
+};
+
static struct symbol_op packed_op = {
.attribute = attribute_packed,
};
@@ -466,6 +471,9 @@ static struct init_keyword {
{ "__restrict", NS_TYPEDEF, .op = &restrict_op},
{ "__restrict__", NS_TYPEDEF, .op = &restrict_op},
+ /* Static assertion */
+ { "_Static_assert", NS_KEYWORD, .op = &static_assert_op },
+
/* Storage class */
{ "auto", NS_TYPEDEF, .op = &auto_op },
{ "register", NS_TYPEDEF, .op = ®ister_op },
@@ -690,7 +698,6 @@ static int SENTINEL_ATTR match_idents(st
return next && token->ident == next;
}
-
struct statement *alloc_statement(struct position pos, int type)
{
struct statement *stmt = __alloc_statement(0);
@@ -1942,11 +1949,18 @@ static struct token *declaration_list(st
return token;
}
+static struct token *static_assert_or_declaration_list(struct token *token, struct symbol_list **list)
+{
+ if (match_ident(token, &_Static_assert_ident))
+ return parse_static_assert(token, NULL);
+ return declaration_list(token, list);
+}
+
static struct token *struct_declaration_list(struct token *token, struct symbol_list **list)
{
while (!match_op(token, '}')) {
if (!match_op(token, ';'))
- token = declaration_list(token, list);
+ token = static_assert_or_declaration_list(token, list);
if (!match_op(token, ';')) {
sparse_error(token->pos, "expected ; at end of declaration");
break;
@@ -2093,6 +2107,40 @@ static struct token *parse_asm_declarato
return token;
}
+
+static struct token *parse_static_assert(struct token *token, struct symbol_list **unused)
+{
+ struct expression *cond = NULL, *fail_string = NULL;
+ int val;
+
+ token = expect(token->next, '(', "after _Static_assert");
+ token = constant_expression(token, &cond);
+ if (!cond)
+ sparse_error(token->pos, "expect expression before '%s' token", show_token(token));
+ token = expect(token, ',', "after first argument of _Static_assert");
+ token = parse_expression(token, &fail_string);
+ if (!fail_string)
+ sparse_error(token->pos, "expect expression before '%s' token", show_token(token));
+ token = expect(token, ')', "after second argument of _Static_assert");
+
+ expect(token, ';', "after _Static_assert()");
+
+ if (!cond || !fail_string)
+ return token;
+
+ val = const_expression_value(cond);
+
+ if (fail_string->type != EXPR_STRING) {
+ sparse_error(fail_string->pos, "bad string literal");
+ return token;
+ }
+
+ if (cond->type == EXPR_VALUE && !val)
+ sparse_error(cond->pos, "static assertion failed: %s",
+ show_string(fail_string->string));
+ return token;
+}
+
/* Make a statement out of an expression */
static struct statement *make_statement(struct expression *expr)
{
@@ -2474,13 +2522,18 @@ static struct token * statement_list(str
break;
if (match_op(token, '}'))
break;
- if (lookup_type(token)) {
+ if (lookup_type(token) || match_ident(token, &_Static_assert_ident)) {
+ struct symbol_list *declaration = NULL;
+
if (seen_statement) {
warning(token->pos, "mixing declarations and code");
seen_statement = 0;
}
+ token = external_declaration(token, &declaration, NULL);
+ if (!declaration)
+ continue;
stmt = alloc_statement(token->pos, STMT_DECLARATION);
- token = external_declaration(token, &stmt->declaration, NULL);
+ stmt->declaration = declaration;
} else {
seen_statement = Wdeclarationafterstatement;
token = statement(token, &stmt);
@@ -2819,7 +2872,7 @@ struct token *external_declaration(struc
unsigned long mod;
int is_typedef;
- /* Top-level inline asm? */
+ /* Top-level inline asm or static assertion? */
if (token_type(token) == TOKEN_IDENT) {
struct symbol *s = lookup_keyword(token->ident, NS_KEYWORD);
if (s && s->op->toplevel)
--- sparse.chrisl.orig/ident-list.h
+++ sparse.chrisl/ident-list.h
@@ -16,6 +16,7 @@ IDENT_RESERVED(for);
IDENT_RESERVED(while);
IDENT_RESERVED(do);
IDENT_RESERVED(goto);
+IDENT_RESERVED(_Static_assert);
/* C typenames. They get marked as reserved when initialized */
IDENT(struct);
--- sparse.chrisl.orig/validation/static_assert.c
+++ sparse.chrisl/validation/static_assert.c
@@ -0,0 +1,64 @@
+_Static_assert(1, "global ok");
+
+struct foo {
+ _Static_assert(1, "struct ok");
+};
+
+void bar(void)
+{
+ _Static_assert(1, " func1 ok");
+ int i;
+ i = 0;
+ _Static_assert(1, " func2 ok");
+
+ if (1) {
+ _Static_assert(1, " func3 ok");
+ }
+}
+
+_Static_assert(0, "expected assertion failure");
+
+static int f;
+_Static_assert(f, "non-constant expression");
+
+static int *p;
+_Static_assert(p, "non-integer expression");
+
+_Static_assert(0.1, "float expression");
+
+_Static_assert(!0 == 1, "non-trivial expression");
+
+static char array[4];
+_Static_assert(sizeof(array) == 4, "sizeof expression");
+
+static const char non_literal_string[] = "non literal string";
+_Static_assert(0, non_literal_string);
+
+_Static_assert(1 / 0, "invalid expression: should not show up?");
+
+struct s {
+ char arr[16];
+ _Static_assert(1, "inside struct");
+};
+
+union u {
+ char c;
+ int i;
+ _Static_assert(1, "inside union");
+};
+
+_Static_assert(sizeof(struct s) == 16, "sizeof assertion");
+
+/*
+ * check-name: static assertion
+ *
+ * check-error-start
+static_assert.c:19:16: error: static assertion failed: "expected assertion failure"
+static_assert.c:22:16: error: bad constant expression
+static_assert.c:25:16: error: bad constant expression
+static_assert.c:27:16: error: bad constant expression
+static_assert.c:35:19: error: bad string literal
+static_assert.c:37:18: error: bad constant expression
+ * check-error-end
+ */
+
