[PATCH 10/73] parse, show-parse: Fix attribute propagation, enum overflow, and bounds

[Bart Van Assche <bvanassche@acm.org>]

Fix parser attribute handling, enumerator overflow promotion, and type
formatting bounds in expression.c, parse.c, show-parse.c, and symbol.h:
- Reject invalid integer suffixes and missing _Generic association
  expressions in expression.c.
- Propagate designated_init and transparent_union attributes on forward
  and post-brace tag declarations, promote overflowing enumerators while
  diagnosing ULLONG_MAX wraparound, validate alignment and address_space
  bounds, transfer context attributes across pointer return types, and
  guard null current_fn.
- Enlarge show-parse.c formatting buffers, reserve space for the trailing
  NUL byte, and route all type formatting through prepend() and append()
  with pointer-subtraction capacity checks.
- Add regression tests in validation/parser-type-fixes.c and
  validation/parser-enum-overflow.c.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 expression.c                      | 16 +++++-
 parse.c                           | 81 ++++++++++++++++++++++++---
 show-parse.c                      | 61 ++++++++++++--------
 symbol.h                          |  2 +
 validation/parser-enum-overflow.c | 13 +++++
 validation/parser-type-fixes.c    | 93 +++++++++++++++++++++++++++++++
 6 files changed, 233 insertions(+), 33 deletions(-)
 create mode 100644 validation/parser-enum-overflow.c
 create mode 100644 validation/parser-type-fixes.c

diff --git a/expression.c b/expression.c
index 727e7056e460..04b1a242d08a 100644
--- a/expression.c
+++ b/expression.c
@@ -290,8 +290,12 @@ static void get_number_value(struct expression *expr, struct token *token)
 				size = 2;
 				end++;
 			}
-		} else
+		} else if (c == '.' || c == 'e' || c == 'E' || c == 'p' || c == 'P' ||
+			   strchr(end, '.') || strchr(end, 'e') || strchr(end, 'E')) {
 			goto Float;
+		} else {
+			goto Enoint;
+		}
 	}
 	if (overflow)
 		goto Eoverflow;
@@ -402,8 +406,12 @@ static struct token *generic_selection(struct token *token, struct expression **
 			token = typename(token, &map->type, NULL);
 			token = expect(token, ':', "after typename");
 			token = assignment_expression(token, &map->expr);
-			*last = map;
-			last = &map->next;
+			if (!map->expr)
+				sparse_error(token->pos, "expected expression after ':'");
+			else {
+				*last = map;
+				last = &map->next;
+			}
 		} else if (match_ident(token, &default_ident)) {
 			if (expr->def) {
 				warning(token->pos, "multiple default in generic expression");
@@ -412,6 +420,8 @@ static struct token *generic_selection(struct token *token, struct expression **
 			token = token->next;
 			token = expect(token, ':', "after typename");
 			token = assignment_expression(token, &expr->def);
+			if (!expr->def)
+				sparse_error(token->pos, "expected expression after ':'");
 		}
 	}
 end:
diff --git a/parse.c b/parse.c
index f349cc75bff4..ea90d088a244 100644
--- a/parse.c
+++ b/parse.c
@@ -753,8 +753,21 @@ static struct token *struct_union_enum_specifier(enum type type,
 		ctx->ctype.base_type = sym;
 		repos = &token->pos;
 		token = token->next;
-		if (!match_op(token, '{'))
+		if (!match_op(token, '{')) {
+			if (attr.designated_init) {
+				if (sym->type == SYM_STRUCT)
+					sym->designated_init = 1;
+				else
+					warning(token->pos, "attribute designated_init applied to non-structure type");
+			}
+			if (attr.transparent_union) {
+				if (sym->type == SYM_UNION)
+					sym->transparent_union = 1;
+				else
+					warning(token->pos, "attribute __transparent_union__ applied to non-union type");
+			}
 			return token;
+		}
 
 		// The following test is actually wrong for empty
 		// structs, but (1) they are not C99, (2) gcc does
@@ -782,6 +795,18 @@ static struct token *struct_union_enum_specifier(enum type type,
 	token = handle_attributes(token, &attr);
 	apply_ctype(token->pos, &sym->ctype, &attr.ctype);
 	sym->packed = attr.packed;
+	if (attr.designated_init) {
+		if (sym->type == SYM_STRUCT)
+			sym->designated_init = 1;
+		else
+			warning(token->pos, "attribute designated_init applied to non-structure type");
+	}
+	if (attr.transparent_union) {
+		if (sym->type == SYM_UNION)
+			sym->transparent_union = 1;
+		else
+			warning(token->pos, "attribute __transparent_union__ applied to non-union type");
+	}
 
 	sym->endpos = token->pos;
 
@@ -935,6 +960,7 @@ static struct token *parse_enum_declaration(struct token *token, struct symbol *
 		struct token *next = token->next;
 		struct decl_state ctx = { };
 		struct symbol *sym;
+		bool overflow = false;
 
 		// FIXME: only 'deprecated' should be accepted
 		next = handle_attributes(next, &ctx);
@@ -948,14 +974,41 @@ static struct token *parse_enum_declaration(struct token *token, struct symbol *
 		} else if (!ctype) {
 			ctype = &int_ctype;
 		} else if (is_int_type(ctype)) {
-			lastval++;
+			struct range crange = type_range(ctype);
+			if (is_signed_type(ctype) && (long long)lastval == crange.pos) {
+				if (ctype->bit_size < bits_in_int)
+					ctype = &int_ctype;
+				else if (ctype->bit_size < bits_in_long)
+					ctype = &long_ctype;
+				else if (ctype->bit_size < bits_in_longlong)
+					ctype = &llong_ctype;
+				else
+					ctype = &ullong_ctype;
+			} else if (!is_signed_type(ctype) && lastval == crange.pos) {
+				if (ctype->bit_size < bits_in_int - 1)
+					ctype = &int_ctype;
+				else if (ctype->bit_size < bits_in_int)
+					ctype = &uint_ctype;
+				else if (ctype->bit_size < bits_in_long)
+					ctype = &ulong_ctype;
+				else if (ctype->bit_size < bits_in_longlong)
+					ctype = &ullong_ctype;
+				else {
+					sparse_error(token->pos,
+						"enumerator value for '%s' overflows",
+						show_ident(token->ident));
+					overflow = true;
+				}
+			}
+			if (!overflow)
+				lastval++;
 		} else {
 			error_die(token->pos, "can't increment the last enum member");
 		}
 
 		if (!expr) {
 			expr = alloc_expression(token->pos, EXPR_VALUE);
-			expr->value = lastval;
+			expr->value = lastval & bits_mask(ctype->bit_size);
 			expr->ctype = ctype;
 		}
 
@@ -1135,7 +1188,7 @@ static struct token *attribute_packed(struct token *token, struct symbol *attr,
 
 static struct token *attribute_aligned(struct token *token, struct symbol *attr, struct decl_state *ctx)
 {
-	int alignment = max_alignment;
+	long long alignment = max_alignment;
 	struct expression *expr = NULL;
 
 	if (match_op(token, '(')) {
@@ -1143,7 +1196,7 @@ static struct token *attribute_aligned(struct token *token, struct symbol *attr,
 		if (expr)
 			alignment = const_expression_value(expr);
 	}
-	if (alignment & (alignment-1)) {
+	if (alignment <= 0 || alignment > INT_MAX || (alignment & (alignment - 1))) {
 		warning(token->pos, "I don't like non-power-of-2 alignments");
 		return token;
 	} else if (alignment > ctx->ctype.alignment)
@@ -1222,7 +1275,7 @@ static struct token *attribute_address_space(struct token *token, struct symbol
 	switch (token_type(token)) {
 	case TOKEN_NUMBER:
 		next = primary_expression(token, &expr);
-		if (expr->type != EXPR_VALUE)
+		if (expr->type != EXPR_VALUE || expr->value > INT_MAX)
 			goto invalid;
 		as = numerical_address_space(expr->value);
 		break;
@@ -1351,6 +1404,8 @@ static struct token *attribute_designated_init(struct token *token, struct symbo
 {
 	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_STRUCT)
 		ctx->ctype.base_type->designated_init = 1;
+	else if (!ctx->ctype.base_type)
+		ctx->designated_init = 1;
 	else
 		warning(token->pos, "attribute designated_init applied to non-structure type");
 	return token;
@@ -1363,6 +1418,8 @@ static struct token *attribute_transparent_union(struct token *token, struct sym
 
 	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_UNION)
 		ctx->ctype.base_type->transparent_union = 1;
+	else if (!ctx->ctype.base_type)
+		ctx->transparent_union = 1;
 	else
 		warning(token->pos, "attribute __transparent_union__ applied to non-union type");
 	return token;
@@ -1856,9 +1913,16 @@ static struct token *direct_declarator(struct token *token, struct decl_state *c
 
 	if (match_op(token, '(')) {
 		enum kind kind = which_func(token, p, ctx->prefer_abstract);
-		struct symbol *fn;
+		struct symbol *fn, *walk;
 		fn = alloc_indirect_symbol(token->pos, ctype, SYM_FN);
 		ctype->modifiers |= ctx->f_modifiers;
+		for (walk = fn->ctype.base_type; walk && walk->type == SYM_PTR; walk = walk->ctype.base_type) {
+			if (walk->ctype.contexts) {
+				concat_ptr_list((struct ptr_list *)walk->ctype.contexts,
+						(struct ptr_list **)&ctype->contexts);
+				walk->ctype.contexts = NULL;
+			}
+		}
 		token = token->next;
 		if (kind == K_R)
 			token = identifier_list(token, fn);
@@ -2440,7 +2504,8 @@ static void warn_label_usage(struct position def, struct position use, struct id
 	const char *id = show_ident(ident);
 	sparse_error(use, "label '%s' used outside statement expression", id);
 	info(def, "   label '%s' defined here", id);
-	current_fn->bogus_linear = 1;
+	if (current_fn)
+		current_fn->bogus_linear = 1;
 }
 
 void check_label_usage(struct symbol *label, struct position use_pos)
diff --git a/show-parse.c b/show-parse.c
index ceb6b3cb6f82..8ef59b5ee255 100644
--- a/show-parse.c
+++ b/show-parse.c
@@ -204,17 +204,27 @@ const char *show_as(struct ident *as)
 struct type_name {
 	char *start;
 	char *end;
+	char *buf_start;
+	char *buf_end;
 };
 
 static void FORMAT_ATTR(2) prepend(struct type_name *name, const char *fmt, ...)
 {
-	static char buffer[512];
+	static char buffer[4096];
 	int n;
 
 	va_list args;
 	va_start(args, fmt);
-	n = vsprintf(buffer, fmt, args);
+	n = vsnprintf(buffer, sizeof(buffer), fmt, args);
 	va_end(args);
+	if (n <= 0)
+		return;
+	if (n >= sizeof(buffer))
+		n = sizeof(buffer) - 1;
+	if (n > name->start - name->buf_start)
+		n = name->start - name->buf_start;
+	if (n <= 0)
+		return;
 
 	name->start -= n;
 	memcpy(name->start, buffer, n);
@@ -222,13 +232,21 @@ static void FORMAT_ATTR(2) prepend(struct type_name *name, const char *fmt, ...)
 
 static void FORMAT_ATTR(2) append(struct type_name *name, const char *fmt, ...)
 {
-	static char buffer[512];
+	static char buffer[4096];
 	int n;
 
 	va_list args;
 	va_start(args, fmt);
-	n = vsprintf(buffer, fmt, args);
+	n = vsnprintf(buffer, sizeof(buffer), fmt, args);
 	va_end(args);
+	if (n <= 0)
+		return;
+	if (n >= sizeof(buffer))
+		n = sizeof(buffer) - 1;
+	if (n > name->buf_end - name->end)
+		n = name->buf_end - name->end;
+	if (n <= 0)
+		return;
 
 	memcpy(name->end, buffer, n);
 	name->end += n;
@@ -314,17 +332,14 @@ deeper:
 	if (sym && (sym->type != SYM_NODE && sym->type != SYM_ARRAY &&
 		     sym->type != SYM_BITFIELD)) {
 		const char *s;
-		size_t len;
 
 		if (as)
 			prepend(name, "%s ", show_as(as));
 
-		if (sym && (sym->type == SYM_BASETYPE || sym->type == SYM_ENUM))
+		if (sym->type == SYM_BASETYPE || sym->type == SYM_ENUM)
 			mod &= ~MOD_SPECIFIER;
 		s = modifier_string(mod);
-		len = strlen(s);
-		name->start -= len;
-		memcpy(name->start, s, len);
+		prepend(name, "%s", s);
 		mod = 0;
 		as = NULL;
 	}
@@ -333,11 +348,9 @@ deeper:
 		goto out;
 
 	if ((typename = builtin_typename(sym))) {
-		int len = strlen(typename);
 		if (name->start != name->end)
-			*--name->start = ' ';
-		name->start -= len;
-		memcpy(name->start, typename, len);
+			prepend(name, " ");
+		prepend(name, "%s", typename);
 		goto out;
 	}
 
@@ -362,13 +375,13 @@ deeper:
 
 	case SYM_STRUCT:
 		if (name->start != name->end)
-			*--name->start = ' ';
+			prepend(name, " ");
 		prepend(name, "struct %s", show_ident(sym->ident));
 		goto out;
 
 	case SYM_UNION:
 		if (name->start != name->end)
-			*--name->start = ' ';
+			prepend(name, " ");
 		prepend(name, "union %s", show_ident(sym->ident));
 		goto out;
 
@@ -401,7 +414,7 @@ deeper:
 			append(name, " )");
 			was_ptr = 0;
 		}
-		append(name, "[%lld]", get_expression_value(sym->array_size));
+		append(name, "[%lld]", get_expression_value_silent(sym->array_size));
 		break;
 
 	case SYM_RESTRICT:
@@ -410,7 +423,7 @@ deeper:
 			break;
 		}
 		if (name->start != name->end)
-			*--name->start = ' ';
+			prepend(name, " ");
 		prepend(name, "restricted %s", show_ident(sym->ident));
 		goto out;
 
@@ -420,7 +433,7 @@ deeper:
 
 	default:
 		if (name->start != name->end)
-			*--name->start = ' ';
+			prepend(name, " ");
 		prepend(name, "unknown type %d", sym->type);
 		goto out;
 	}
@@ -441,10 +454,12 @@ out:
 
 void show_type(struct symbol *sym)
 {
-	char array[200];
+	char array[8192];
 	struct type_name name;
 
-	name.start = name.end = array+100;
+	name.start = name.end = array + 4096;
+	name.buf_start = array;
+	name.buf_end = array + sizeof(array) - 1;
 	do_show_type(sym, &name);
 	*name.end = 0;
 	printf("%s", name.start);
@@ -452,10 +467,12 @@ void show_type(struct symbol *sym)
 
 const char *show_typename(struct symbol *sym)
 {
-	static char array[200];
+	static char array[8192];
 	struct type_name name;
 
-	name.start = name.end = array+100;
+	name.start = name.end = array + 4096;
+	name.buf_start = array;
+	name.buf_end = array + sizeof(array) - 1;
 	do_show_type(sym, &name);
 	*name.end = 0;
 	return name.start;
diff --git a/symbol.h b/symbol.h
index 9d657fbba260..9a8e58d5da28 100644
--- a/symbol.h
+++ b/symbol.h
@@ -115,6 +115,8 @@ struct decl_state {
 	unsigned char autotype;
 	unsigned char forced;
 	unsigned char packed;
+	unsigned char designated_init;
+	unsigned char transparent_union;
 };
 
 struct pseudo;
diff --git a/validation/parser-enum-overflow.c b/validation/parser-enum-overflow.c
new file mode 100644
index 000000000000..3e72a56b9e50
--- /dev/null
+++ b/validation/parser-enum-overflow.c
@@ -0,0 +1,13 @@
+enum {
+	E_ULLMAX = ~0ULL,
+	E_ULL_OVERFLOW,
+};
+
+/*
+ * check-name: parser-enum-overflow
+ * check-command: sparse $file
+ *
+ * check-error-start
+parser-enum-overflow.c:3:9: error: enumerator value for 'E_ULL_OVERFLOW' overflows
+ * check-error-end
+ */
diff --git a/validation/parser-type-fixes.c b/validation/parser-type-fixes.c
new file mode 100644
index 000000000000..dafcdd4a3f75
--- /dev/null
+++ b/validation/parser-type-fixes.c
@@ -0,0 +1,93 @@
+/* 1. designated_init propagation on forward and post-brace declarations */
+struct __attribute__((designated_init)) s_fwd;
+struct s_fwd {
+	int a;
+	int b;
+};
+static struct s_fwd fwd_pos = { 1, 2 };
+static struct s_fwd fwd_des = { .a = 1, .b = 2 };
+
+struct s_post {
+	int a;
+	int b;
+} __attribute__((designated_init));
+static struct s_post post_pos = { 3, 4 };
+static struct s_post post_des = { .a = 3, .b = 4 };
+
+/* 2. transparent_union propagation on forward and post-brace declarations */
+union __attribute__((__transparent_union__)) u_fwd;
+union u_fwd {
+	int *ip;
+	long *lp;
+};
+void take_u_fwd(union u_fwd u);
+
+union u_post {
+	int *ip;
+	long *lp;
+} __attribute__((__transparent_union__));
+void take_u_post(union u_post u);
+
+void call_transparent(int *ip, long *lp)
+{
+	take_u_fwd(ip);
+	take_u_fwd(lp);
+	take_u_post(ip);
+	take_u_post(lp);
+}
+
+/* 3. Function context attribute transferred through pointer return type */
+int *acquire_ptr(void) __attribute__((context(0, 1)));
+
+void good_context(void)
+{
+	(void)acquire_ptr();
+	__context__(-1);
+}
+
+void bad_context(void)
+{
+	(void)acquire_ptr();
+}
+
+/* 4. typeof on restrict-qualified pointer */
+void typeof_restrict(int * restrict p)
+{
+	typeof(p) q = p;
+	(void)q;
+}
+
+/* 5. Sub-int enum auto-increment promotes to int before long/ulong */
+enum {
+	E_SCHAR = (signed char)127,
+	E_SCHAR_NEXT,
+	E_SHRT = (short)32767,
+	E_SHRT_NEXT,
+	E_UCHAR = (unsigned char)255,
+	E_UCHAR_NEXT,
+};
+_Static_assert(E_SCHAR_NEXT == 128, "schar + 1");
+_Static_assert(__builtin_types_compatible_p(typeof(E_SCHAR_NEXT), int), "schar + 1 is int");
+_Static_assert(E_SHRT_NEXT == 32768, "short + 1");
+_Static_assert(__builtin_types_compatible_p(typeof(E_SHRT_NEXT), int), "short + 1 is int");
+_Static_assert(E_UCHAR_NEXT == 256, "uchar + 1");
+_Static_assert(__builtin_types_compatible_p(typeof(E_UCHAR_NEXT), int), "uchar + 1 is int");
+
+/* 6. Out-of-range address_space and aligned warnings */
+int __attribute__((address_space(0x100000000ULL))) *bad_as;
+int __attribute__((aligned(0x100000000ULL))) bad_align;
+
+/*
+ * check-name: parser-type-fixes
+ * check-command: sparse -Wno-decl $file
+ *
+ * check-error-start
+parser-type-fixes.c:77:34: warning: invalid address space name
+parser-type-fixes.c:78:43: warning: I don't like non-power-of-2 alignments
+parser-type-fixes.c:7:33: warning: in initializer for fwd_pos: positional init of field in struct s_fwd, declared with attribute designated_init
+parser-type-fixes.c:7:36: warning: in initializer for fwd_pos: positional init of field in struct s_fwd, declared with attribute designated_init
+parser-type-fixes.c:14:35: warning: in initializer for post_pos: positional init of field in struct s_post, declared with attribute designated_init
+parser-type-fixes.c:14:38: warning: in initializer for post_pos: positional init of field in struct s_post, declared with attribute designated_init
+parser-type-fixes.c:48:6: warning: context imbalance in 'bad_context' - wrong count at exit
+ * check-error-end
+ */