[PATCH 42/73] c23: Add support for static_assert, alignas, alignof, thread_local

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

Register static_assert, alignas, alignof, and thread_local as reserved
C23 keywords and support single-argument static_assert(expr) without a
message string per ISO C23 6.7.12:
- Mark static_assert and alignof as reserved identifiers in C23 mode
  while keeping them available as ordinary identifiers in pre-C23 modes.
- Warn under -Wpedantic when alignof or _Alignof is applied to an
  expression rather than a type name.
- Enforce ISO C23 constraints on alignas and thread_local declarations,
  and avoid materializing block-scope thread_local symbols as stack
  locals during linearization.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 expression.c                        |  15 ++++-
 ident-list.h                        |   9 ++-
 linearize.c                         |   2 +-
 options.c                           |   2 +
 parse.c                             | 100 ++++++++++++++++++++++++++--
 parse.h                             |   1 +
 symbol.h                            |   2 +
 validation/c11-c23-keywords-ident.c |  19 ++++++
 validation/c23-alignof-pedantic.c   |  20 ++++++
 validation/c23-keywords-error.c     |  48 +++++++++++++
 validation/c23-keywords.c           |  30 +++++++++
 11 files changed, 241 insertions(+), 7 deletions(-)
 create mode 100644 validation/c11-c23-keywords-ident.c
 create mode 100644 validation/c23-alignof-pedantic.c
 create mode 100644 validation/c23-keywords-error.c
 create mode 100644 validation/c23-keywords.c

diff --git a/expression.c b/expression.c
index 04b1a242d08a..4545adcf4c02 100644
--- a/expression.c
+++ b/expression.c
@@ -646,13 +646,21 @@ static struct token *type_info_expression(struct token *token,
 	struct expression **tree, int type)
 {
 	struct expression *expr = alloc_expression(token->pos, type);
+	struct ident *op_ident = token->ident;
+	bool std_alignof = (op_ident == &_Alignof_ident ||
+			    op_ident == &alignof_ident);
 	struct token *p;
 
 	*tree = expr;
 	expr->flags = CEF_SET_ICE; /* XXX: VLA support will need that changed */
 	token = token->next;
-	if (!match_op(token, '(') || !lookup_type(token->next))
+	if (!match_op(token, '(') || !lookup_type(token->next)) {
+		if (std_alignof && Wpedantic)
+			warning(expr->pos,
+				"ISO C does not allow '%s' on an expression",
+				show_ident(op_ident));
 		return unary_expression(token, &expr->cast_expression);
+	}
 	p = token;
 	token = typename(token->next, &expr->cast_type, NULL);
 
@@ -672,6 +680,10 @@ static struct token *type_info_expression(struct token *token,
 	 */
 	if (match_op(token, '{')) {
 		struct expression *cast = alloc_expression(p->pos, EXPR_CAST);
+		if (std_alignof && Wpedantic)
+			warning(expr->pos,
+				"ISO C does not allow '%s' on an expression",
+				show_ident(op_ident));
 		cast->cast_type = expr->cast_type;
 		expr->cast_type = NULL;
 		expr->cast_expression = cast;
@@ -691,6 +703,7 @@ static struct token *unary_expression(struct token *token, struct expression **t
 				int type;
 			} type_information[] = {
 				{ &sizeof_ident, EXPR_SIZEOF },
+				{ &alignof_ident, EXPR_ALIGNOF },
 				{ &__alignof___ident, EXPR_ALIGNOF },
 				{ &__alignof_ident, EXPR_ALIGNOF },
 				{ &_Alignof_ident, EXPR_ALIGNOF },
diff --git a/ident-list.h b/ident-list.h
index 5f4d1fef5a81..83031b265388 100644
--- a/ident-list.h
+++ b/ident-list.h
@@ -43,12 +43,19 @@ IDENT(_Noreturn);
 IDENT_RESERVED(_Static_assert);
 IDENT(_Thread_local);
 
+/* C23 keywords */
+IDENT(alignas);
+IDENT(alignof);
+IDENT(static_assert);
+IDENT(thread_local);
+
 /* Special case for L'\t' */
 IDENT(L);
 
 /* Extended gcc identifiers */
 IDENT(asm); IDENT_RESERVED(__asm); IDENT_RESERVED(__asm__);
-IDENT(alignof); IDENT_RESERVED(__alignof); IDENT_RESERVED(__alignof__); 
+IDENT_RESERVED(__alignof);
+IDENT_RESERVED(__alignof__);
 IDENT_RESERVED(__sizeof_ptr__);
 IDENT_RESERVED(__builtin_types_compatible_p);
 IDENT_RESERVED(__builtin_offsetof);
diff --git a/linearize.c b/linearize.c
index 24b402622b83..bb3a5a9ecf16 100644
--- a/linearize.c
+++ b/linearize.c
@@ -1995,7 +1995,7 @@ static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym)
 		return VOID;
 
 	/* We need to output these puppies some day too.. */
-	if (sym->ctype.modifiers & (MOD_STATIC | MOD_TOPLEVEL))
+	if (sym->ctype.modifiers & (MOD_STATIC | MOD_TOPLEVEL | MOD_TLS))
 		return VOID;
 
 	sym->initialized = 1;
diff --git a/options.c b/options.c
index c140a912e8e9..2de74afc5c35 100644
--- a/options.c
+++ b/options.c
@@ -11,6 +11,7 @@
 #include "lib.h"
 #include "machine.h"
 #include "target.h"
+#include "parse.h"
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -1068,4 +1069,5 @@ void handle_switch_finalize(void)
 {
 	handle_switch_v_finalize();
 	handle_switch_W_finalize();
+	init_parser_finalize();
 }
diff --git a/parse.c b/parse.c
index c30a00eafb3e..d6c23fcdfb5d 100644
--- a/parse.c
+++ b/parse.c
@@ -465,6 +465,7 @@ static struct init_keyword {
 	struct symbol_op *op;
 	struct symbol *type;
 	unsigned long mods;
+	int std;
 } typedefs[] = {
 #define N(I, O,...)	{ I, O,##__VA_ARGS__ }
 #define D(I, O,...)	N(I,O,##__VA_ARGS__ ),		\
@@ -481,6 +482,7 @@ static struct init_keyword {
 	N("extern",		&extern_op,	.mods = MOD_EXTERN),
 	N("__thread",		&thread_op),
 	N("_Thread_local",	&thread_op),
+	N("thread_local",	&thread_op,	.std = STANDARD_C23),
 
 	A("inline",		&inline_op,	.mods = MOD_INLINE),
 
@@ -498,6 +500,7 @@ static struct init_keyword {
 	N("_Atomic",		&atomic_op,	.mods = MOD_ATOMIC),
 	N("_Noreturn",		&noreturn_op,	.mods = MOD_NORETURN),
 	N("_Alignas",		&alignas_op),
+	N("alignas",		&alignas_op,	.std = STANDARD_C23),
 
 	U("attribute",		&attribute_op),
 
@@ -546,6 +549,7 @@ static struct init_keyword {
 	N("__context__",	&__context___op),
 	N("__range__",		&range_op),
 	N("_Static_assert",	&static_assert_op),
+	N("static_assert",	&static_assert_op, .std = STANDARD_C23),
 
 	/* Attributes */
 	D("packed",		&packed_op),
@@ -607,14 +611,23 @@ static void init_keyword(int stream, struct init_keyword *kw, enum namespace ns)
 	sym->op = kw->op;
 }
 
+static int parser_stream;
+
 void init_parser(int stream)
 {
 	int i;
 
-	for (i = 0; i < ARRAY_SIZE(typedefs); i++)
+	parser_stream = stream;
+	for (i = 0; i < ARRAY_SIZE(typedefs); i++) {
+		if (typedefs[i].std)
+			continue;
 		init_keyword(stream, &typedefs[i], NS_TYPEDEF);
-	for (i = 0; i < ARRAY_SIZE(keywords); i++)
+	}
+	for (i = 0; i < ARRAY_SIZE(keywords); i++) {
+		if (keywords[i].std)
+			continue;
 		init_keyword(stream, &keywords[i], NS_KEYWORD);
+	}
 
 	for (i = 0; i < ARRAY_SIZE(ignored_attributes); i++) {
 		const char * name = ignored_attributes[i];
@@ -627,6 +640,23 @@ void init_parser(int stream)
 	}
 }
 
+void init_parser_finalize(void)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(typedefs); i++) {
+		if (typedefs[i].std && standard >= typedefs[i].std)
+			init_keyword(parser_stream, &typedefs[i], NS_TYPEDEF);
+	}
+	for (i = 0; i < ARRAY_SIZE(keywords); i++) {
+		if (keywords[i].std && standard >= keywords[i].std)
+			init_keyword(parser_stream, &keywords[i], NS_KEYWORD);
+	}
+	if (standard >= STANDARD_C23) {
+		static_assert_ident.reserved = 1;
+		alignof_ident.reserved = 1;
+	}
+}
 
 static struct token *skip_to(struct token *token, int op)
 {
@@ -1513,6 +1543,7 @@ static struct token *alignas_specifier(struct token *token, struct symbol *sym,
 {
 	int alignment = 0;
 
+	ctx->has_alignas = 1;
 	if (!match_op(token, '(')) {
 		sparse_error(token->pos, "expected '(' after _Alignas");
 		return token;
@@ -1986,6 +2017,9 @@ static struct token *handle_bitfield(struct token *token, struct decl_state *ctx
 	}
 
 	bitfield = alloc_indirect_symbol(token->pos, ctype, SYM_BITFIELD);
+	if (ctx->has_alignas)
+		sparse_error(token->pos, "alignment specified for bitfield '%s'",
+			show_ident(*ctx->ident));
 	token = conditional_expression(token->next, &expr);
 	width = const_expression_value(expr);
 	bitfield->bit_size = width;
@@ -2042,6 +2076,11 @@ static struct token *declaration_list(struct token *token, struct symbol_list **
 		decl->ctype.modifiers |= mod;
 		decl->cleanup = ctx.cleanup;
 		decl->endpos = token->pos;
+		if (decl->ctype.modifiers & MOD_TLS)
+			sparse_error(
+				decl->pos,
+				"struct or union member '%s' cannot be thread-local",
+				show_ident(decl->ident));
 		add_symbol(list, decl);
 		if (!match_op(token, ','))
 			break;
@@ -2054,7 +2093,9 @@ 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_ident(token, &_Static_assert_ident)) {
+		if (match_ident(token, &_Static_assert_ident) ||
+		    (standard >= STANDARD_C23 &&
+		     match_ident(token, &static_assert_ident))) {
 			token = parse_static_assert(token, NULL);
 			continue;
 		}
@@ -2082,6 +2123,14 @@ static struct token *parameter_declaration(struct token *token, struct symbol *s
 	sym->ctype.modifiers |= decl_modifiers(&ctx);
 	sym->endpos = token->pos;
 	sym->forced_arg = ctx.forced;
+	if (ctx.has_alignas)
+		sparse_error(sym->pos,
+			     "alignment specified for parameter '%s'",
+			     show_ident(sym->ident));
+	if (sym->ctype.modifiers & MOD_TLS)
+		sparse_error(sym->pos,
+			     "parameter '%s' cannot be thread-local",
+			     show_ident(sym->ident));
 	return token;
 }
 
@@ -2092,6 +2141,8 @@ struct token *typename(struct token *token, struct symbol **p, int *forced)
 	struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
 	*p = sym;
 	token = declaration_specifiers(token, &ctx);
+	if (ctx.has_alignas)
+		sparse_error(sym->pos, "alignment specified for type name");
 	token = declarator(token, &ctx);
 	apply_modifiers(token->pos, &ctx);
 	sym->ctype = ctx.ctype;
@@ -2654,7 +2705,9 @@ static struct token * statement_list(struct token *token, struct statement_list
 			break;
 		if (match_op(token, '}'))
 			break;
-		if (match_ident(token, &_Static_assert_ident)) {
+		if (match_ident(token, &_Static_assert_ident) ||
+		    (standard >= STANDARD_C23 &&
+		     match_ident(token, &static_assert_ident))) {
 			token = parse_static_assert(token, NULL);
 			continue;
 		}
@@ -3104,6 +3157,16 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
 		decl->ctype.modifiers |= ctx.f_modifiers;
 
 		/* K&R argument declaration? */
+		if (lookup_type(token) || match_op(token, '{')) {
+			if (ctx.has_alignas)
+				sparse_error(decl->pos,
+					     "alignment specified for function '%s'",
+					     show_ident(decl->ident));
+			if (decl->ctype.modifiers & MOD_TLS)
+				sparse_error(decl->pos,
+					     "function '%s' cannot be thread-local",
+					     show_ident(decl->ident));
+		}
 		if (lookup_type(token))
 			return parse_k_r_arguments(token, decl, list);
 		if (match_op(token, '{'))
@@ -3167,6 +3230,35 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
 			}
 		}
 
+		if (ctx.has_alignas) {
+			if (is_typedef)
+				sparse_error(decl->pos,
+					     "alignment specified for typedef '%s'",
+					     show_ident(decl->ident));
+			else if (decl->ctype.base_type &&
+				 decl->ctype.base_type->type == SYM_FN)
+				sparse_error(decl->pos,
+					     "alignment specified for function '%s'",
+					     show_ident(decl->ident));
+			else if (decl->ctype.modifiers & MOD_REGISTER)
+				sparse_error(decl->pos,
+					     "alignment specified for 'register' object '%s'",
+					     show_ident(decl->ident));
+		}
+
+		if (!is_typedef && (decl->ctype.modifiers & MOD_TLS)) {
+			if (decl->ctype.base_type &&
+			    decl->ctype.base_type->type == SYM_FN)
+				sparse_error(decl->pos,
+					     "function '%s' cannot be thread-local",
+					     show_ident(decl->ident));
+			else if (!(decl->ctype.modifiers &
+				   (MOD_TOPLEVEL | MOD_STATIC | MOD_EXTERN)))
+				sparse_error(decl->pos,
+					     "thread-local variable '%s' at block scope must be 'static' or 'extern'",
+					     show_ident(decl->ident));
+		}
+
 		if (!match_op(token, ','))
 			break;
 
diff --git a/parse.h b/parse.h
index e7ea3642b65c..6a528bc8ca4d 100644
--- a/parse.h
+++ b/parse.h
@@ -139,6 +139,7 @@ extern struct symbol *ctype_integer(int size, int want_unsigned);
 extern int inline_function(struct expression *expr, struct symbol *sym);
 extern void uninline(struct symbol *sym);
 extern void init_parser(int);
+extern void init_parser_finalize(void);
 
 struct token *expect(struct token *, int, const char *);
 
diff --git a/symbol.h b/symbol.h
index a14686fe863b..2c6731f88399 100644
--- a/symbol.h
+++ b/symbol.h
@@ -115,6 +115,7 @@ struct decl_state {
 	unsigned char autotype;
 	unsigned char forced;
 	unsigned char packed;
+	unsigned char has_alignas;
 	unsigned char designated_init;
 	unsigned char transparent_union;
 };
@@ -199,6 +200,7 @@ struct symbol {
 					torename:1,
 					packed:1,
 					transparent_union:1;
+			unsigned int has_alignas : 1;
 			int		rank:3;	// arithmetic's rank
 			struct expression *array_size;
 			struct ctype ctype;
diff --git a/validation/c11-c23-keywords-ident.c b/validation/c11-c23-keywords-ident.c
new file mode 100644
index 000000000000..8fdb011268e4
--- /dev/null
+++ b/validation/c11-c23-keywords-ident.c
@@ -0,0 +1,19 @@
+static int test_c11_idents(void)
+{
+	int alignas = 1;
+	int alignof = 2;
+	int static_assert = 3;
+	int thread_local = 4;
+	int bool = 5;
+	int true = 6;
+	int false = 7;
+	int nullptr = 8;
+
+	return alignas + alignof + static_assert + thread_local +
+	       bool + true + false + nullptr;
+}
+
+/*
+ * check-name: c11-c23-keywords-ident
+ * check-command: sparse -std=c11 $file
+ */
diff --git a/validation/c23-alignof-pedantic.c b/validation/c23-alignof-pedantic.c
new file mode 100644
index 000000000000..d17eabb79108
--- /dev/null
+++ b/validation/c23-alignof-pedantic.c
@@ -0,0 +1,20 @@
+static int test(void)
+{
+	alignas(8) int x = 0;
+	int a = alignof(int);
+	int b = alignof(x);
+	int c = _Alignof(x);
+	int d = __alignof__(x);
+	int e = __alignof(x);
+	return a + b + c + d + e;
+}
+
+/*
+ * check-name: c23-alignof-pedantic
+ * check-command: sparse -std=c23 -pedantic $file
+ *
+ * check-error-start
+c23-alignof-pedantic.c:5:17: warning: ISO C does not allow 'alignof' on an expression
+c23-alignof-pedantic.c:6:17: warning: ISO C does not allow '_Alignof' on an expression
+ * check-error-end
+ */
diff --git a/validation/c23-keywords-error.c b/validation/c23-keywords-error.c
new file mode 100644
index 000000000000..25d3adac3ce8
--- /dev/null
+++ b/validation/c23-keywords-error.c
@@ -0,0 +1,48 @@
+static_assert(0);
+static_assert(0, "must fail");
+
+typedef alignas(8) int bad_typedef;
+
+struct bf {
+	alignas(4) unsigned int x : 2;
+};
+
+static void bad_param(alignas(8) int p)
+{
+	(void)p;
+}
+
+static void bad_fn_locals(void)
+{
+	thread_local int local_tl = 0;
+	register alignas(8) int reg_a = 0;
+	int sz = sizeof(alignas(8) int);
+	(void)local_tl;
+	(void)reg_a;
+	(void)sz;
+}
+
+static int (alignas);
+static int (alignof);
+static int (static_assert);
+static int (thread_local);
+
+/*
+ * check-name: c23-keywords-error
+ * check-command: sparse -std=c23 -Wno-decl $file
+ *
+ * check-error-start
+c23-keywords-error.c:1:15: error: static assertion failed
+c23-keywords-error.c:2:15: error: static assertion failed: "must fail"
+c23-keywords-error.c:4:24: error: alignment specified for typedef 'bad_typedef'
+c23-keywords-error.c:7:35: error: alignment specified for bitfield 'x'
+c23-keywords-error.c:10:23: error: alignment specified for parameter 'p'
+c23-keywords-error.c:17:26: error: thread-local variable 'local_tl' at block scope must be 'static' or 'extern'
+c23-keywords-error.c:18:33: error: alignment specified for 'register' object 'reg_a'
+c23-keywords-error.c:19:25: error: alignment specified for type name
+c23-keywords-error.c:25:12: error: Trying to use reserved word 'alignas' as identifier
+c23-keywords-error.c:26:12: error: Trying to use reserved word 'alignof' as identifier
+c23-keywords-error.c:27:12: error: Trying to use reserved word 'static_assert' as identifier
+c23-keywords-error.c:28:12: error: Trying to use reserved word 'thread_local' as identifier
+ * check-error-end
+ */
diff --git a/validation/c23-keywords.c b/validation/c23-keywords.c
new file mode 100644
index 000000000000..a6f44a735c7e
--- /dev/null
+++ b/validation/c23-keywords.c
@@ -0,0 +1,30 @@
+static_assert(1);
+static_assert(1, "file scope");
+
+struct s {
+	static_assert(1);
+	static_assert(1, "struct scope");
+	alignas(16) int a;
+};
+
+static_assert(alignof(struct s) == 16);
+
+thread_local int tl;
+alignas(double) static int aligned_dbl;
+
+static int test(void)
+{
+	static_assert(1);
+	static_assert(1, "func scope");
+	alignas(8) int x = 0;
+	static thread_local int local_tl = 3;
+	extern thread_local int tl;
+	static_assert(alignof(int) <= 8);
+	static_assert(alignof(double) <= 16);
+	return x + tl + local_tl + aligned_dbl;
+}
+
+/*
+ * check-name: c23-keywords
+ * check-command: sparse -std=c23 -pedantic -Wno-decl $file
+ */