Skip to contentSkip to conversation

Print an error if typeof() lacks an argument

PATCH In review Martin Nagy 3 participants 4 messages Apr 25, 2009 – Apr 27, 2009 Sparse checker

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Print an error if typeof() lacks an argument

We weren't checking if the initializer isn't NULL, which caused sparse to segfault later on when performing lazy evaluation in classify_type().

---
 parse.c |   17 +++++++++++------
 1 files changed, 11 insertions(+), 6 deletions(-)
parse.c +0 -2
index 9662122..18cfaef 100644
@@ -924,12 +924,17 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
 		ctx->ctype.base_type = sym->ctype.base_type;
 		apply_ctype(token->pos, &sym->ctype, &ctx->ctype);
 	} else {
-		struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
-		token = parse_expression(token->next, &typeof_sym->initializer);
#1 lore raw
Quoted 5 lines · Martin Nagy

We weren't checking if the initializer isn't NULL, which caused sparse to segfault later on when performing lazy evaluation in classify_type().

I accidentally sent this from my work email address, which is different than the sign-off address, sorry. I'm not sure if that's an issue, but just to make sure, I'm sending the patch again.

Martin

From 962e4b1ad3b3cb13c7427d07dfa44cd15af11693 Mon Sep 17 00:00:00 2001
From: Martin Nagy <[email protected]>
Date: Sat, 25 Apr 2009 12:56:33 +0200
Subject: [PATCH] Print an error if typeof() lacks an argument

We weren't checking if the initializer isn't NULL, which caused sparse to segfault later on when performing lazy evaluation in classify_type().

---
 parse.c |   17 +++++++++++------
 1 files changed, 11 insertions(+), 6 deletions(-)
parse.c +0 -2
index 9662122..18cfaef 100644
@@ -924,12 +924,17 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
 		ctx->ctype.base_type = sym->ctype.base_type;
 		apply_ctype(token->pos, &sym->ctype, &ctx->ctype);
 	} else {
-		struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
-		token = parse_expression(token->next, &typeof_sym->initializer);
maintainer
#2 lore raw
In reply to Martin Nagy
Quoted 14 lines · Martin Nagy

We weren't checking if the initializer isn't NULL, which caused sparse to segfault later on when performing lazy evaluation in classify_type().

---
 parse.c |   17 +++++++++++------

 1 files changed, 11 insertions(+), 6 deletions(-)
parse.c +0 -0
index 9662122..18cfaef 100644

parse.c static struct token *typeof_specifier(struct token *token, struct decl_state *ct · line 927

Quoted 10 lines
parse.c +1 -6
@@ -924,12 +924,17 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
                ctx->ctype.base_type = sym->ctype.base_type;
                apply_ctype(token->pos, &sym->ctype, &ctx->ctype);
        } else {
-               struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
-               token = parse_expression(token->next, &typeof_sym->initializer);
-
-               typeof_sym->endpos = token->pos;
-               ctx->ctype.base_type = typeof_sym;
-       }
+               struct expression *expr;

I think you want expr = NULL here. Otherwise if(expr) will pick up crap.

I would just add two lines after "token = parse_expression(token->next, &typeof_sym->initializer);"

if (!type->initializer)

        sparse_error(token->pos, "expected expression after the '(' token");

If there is compile error, the sparse should not continue the later stage any way.

BTW, can you add a validation test case which will trigger the bug?

Thanks

Chris
--
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#3 lore raw
Quoted 4 lines · Christopher Li
Quoted 1 line · Martin Nagy

+               struct expression *expr;

I think you want expr = NULL here. Otherwise if(expr) will pick up crap.

Right. I somehow assumed that parse_expression() will set it to NULL in case there is not any expression. I attached a new patch which fixes this.

Quoted 8 lines

I would just add two lines after "token = parse_expression(token->next, &typeof_sym->initializer);"

if (!type->initializer)

        sparse_error(token->pos, "expected expression after the '(' token");

If there is compile error, the sparse should not continue the later stage any way.

That won't work. sparse_error() will not exit, and sparse will still segfault later, so we have to return from the function. You could instead do something like this:

if (!typeof_sym->initializer) {
	sparse_error(token->pos, "expected ...");
	return expect(token, ')', "after typeof");
}

Or use a goto to jump to the return statement. In any case, I didn't want to repeat the code and cause a memory leak. And I didn't want to use a goto. I guess that it's ultimately a matter of style. If you think the memory leak would be acceptable I can rework the patch again. The leak would only occur in this specific case, so I guess maybe it would be acceptable, but I wasn't sure so I rather went with this approach.

Quoted 1 line

BTW, can you add a validation test case which will trigger the bug?

Yup, it's in the new patch.

Martin

From bbd2e88cdd9d36d47ce50204d18547e08f2e2bea Mon Sep 17 00:00:00 2001
From: Martin Nagy <[email protected]>
Date: Mon, 27 Apr 2009 10:48:50 +0200
Subject: [PATCH] Print an error if typeof() lacks an argument

We weren't checking if the initializer isn't NULL, which caused sparse to segfault later on when performing lazy evaluation in classify_type().

---
 parse.c                 |   17 +++++++++++------
 validation/bad-typeof.c |   15 +++++++++++++++
 2 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100644 validation/bad-typeof.c
parse.c +11 -6
index 9662122..604e528 100644
@@ -924,12 +924,17 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
 		ctx->ctype.base_type = sym->ctype.base_type;
 		apply_ctype(token->pos, &sym->ctype, &ctx->ctype);
 	} else {
-		struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
-		token = parse_expression(token->next, &typeof_sym->initializer);
-
-		typeof_sym->endpos = token->pos;
-		ctx->ctype.base_type = typeof_sym;
-	}		
+		struct expression *expr = NULL;
+		token = parse_expression(token->next, &expr);
+		if (expr) {
+			struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
+			typeof_sym->endpos = token->pos;
+			typeof_sym->initializer = expr;
+			ctx->ctype.base_type = typeof_sym;
+		} else {
+			sparse_error(token->pos, "expected expression after the '(' token");
+		}
+	}
 	return expect(token, ')', "after typeof");
 }
 
validation/bad-typeof.c new file +15 -0
new file mode 100644
index 0000000..5c27de4
@@ -0,0 +1,15 @@
+static int fun(void)
+{
+	typeof() a;
+	int b;
+
+	a = b;
+}
+/*
+ * check-name: Bad typeof syntax segfault
+ *
+ * check-error-start
+bad-typeof.c:3:16: error: expected expression after the '(' token
+bad-typeof.c:6:9: error: identifier 'a' has no type
+ * check-error-end
+ */
Signature · 1 line
1.6.0.6