[PATCH 54/73] c23: Support empty initializer braces {}

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

Support empty initializer braces '{}' for scalar, pointer, nullptr_t,
aggregate, union, and variable-length array objects and compound literals
in C23 mode per ISO C23 6.7.11:
- Synthesize zero/null scalar initializers in handle_scalar() without
  emitting spurious nested scalar-brace warnings, and keep warning under
  -Wpedantic before C23.
- Preserve runtime bounds on VLA empty initializers ('int vla[n] = {}')
  and reject empty initializers for incomplete arrays ('int a[] = {}')
  and incomplete structs or unions.
- Lower empty aggregate and null-pointer static initializers cleanly in
  linearize and sparse-llvm.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 evaluate.c                           |  23 +++++-
 linearize.c                          |   2 +-
 parse.c                              |   5 ++
 sparse-llvm.c                        | 114 +++++++++++++++++++--------
 symbol.c                             |   6 ++
 validation/backend/c23-empty-init.c  |  24 ++++++
 validation/c23-auto-error.c          |   5 +-
 validation/c23-constexpr-error.c     |   2 +-
 validation/c23-empty-init-error.c    |  19 +++++
 validation/c23-empty-init-pedantic.c |  14 ++++
 validation/c23-empty-init.c          |  64 +++++++++++++++
 11 files changed, 239 insertions(+), 39 deletions(-)
 create mode 100644 validation/backend/c23-empty-init.c
 create mode 100644 validation/c23-empty-init-error.c
 create mode 100644 validation/c23-empty-init-pedantic.c
 create mode 100644 validation/c23-empty-init.c

diff --git a/evaluate.c b/evaluate.c
index 43ad5f59b860..f40e35773639 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -2987,7 +2987,8 @@ static int is_string_literal(struct expression **v)
  * an effect of screwup).  In case of anything not legal, we are definitely
  * having an effect of screwup, so just fail and let the caller warn.
  */
-static struct expression *handle_scalar(struct expression *e, int nested)
+static struct expression *handle_scalar(struct expression *e, int nested,
+					int class, struct symbol *ctype)
 {
 	struct expression *v = NULL, *p;
 	int count = 0;
@@ -3001,6 +3002,19 @@ static struct expression *handle_scalar(struct expression *e, int nested)
 			v = p;
 		count++;
 	} END_FOR_EACH_PTR(p);
+	if (count == 0) {
+		if (standard >= STANDARD_C23) {
+			v = alloc_const_expression(e->pos, 0);
+			if (class & TYPE_PTR)
+				v->ctype = &null_ctype;
+			else if (is_nullptr_type(ctype)) {
+				v->ctype = &nullptr_ctype;
+				v->flags = CEF_ADDR;
+			}
+			return v;
+		}
+		return NULL;
+	}
 	if (count != 1)
 		return NULL;
 	switch(v->type) {
@@ -3202,7 +3216,7 @@ static int handle_initializer(struct expression **ep, int nested,
 	if (!(class & TYPE_COMPOUND)) {
 		struct expression orig;
 
-		e = handle_scalar(e, nested);
+		e = handle_scalar(e, nested, class, ctype);
 
 		if (!e)
 			return 0;
@@ -3302,6 +3316,11 @@ static void evaluate_initializer(struct symbol *ctype, struct expression **ep)
 {
 	struct symbol *type;
 	int class = classify_type(ctype, &type);
+	if ((type->type == SYM_STRUCT || type->type == SYM_UNION) &&
+	    (type->bit_size < 0 || !type->endpos.line)) {
+		expression_error(*ep, "initializer for incomplete type");
+		return;
+	}
 	if (!handle_initializer(ep, 0, class, ctype, 0))
 		expression_error(*ep, "invalid initializer");
 }
diff --git a/linearize.c b/linearize.c
index 4179aea03af1..268466f07886 100644
--- a/linearize.c
+++ b/linearize.c
@@ -2003,7 +2003,7 @@ static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym)
 	sym->initialized = 1;
 	ad.address = symbol_pseudo(ep, sym);
 
-	if (sym->initializer && !is_scalar_type(sym)) {
+	if (sym->initializer && !is_scalar_type(sym) && sym->bit_size > 0) {
 		// default zero initialization [6.7.9.21]
 		// FIXME: this init the whole aggregate while
 		// only the existing fields need to be initialized.
diff --git a/parse.c b/parse.c
index 13b8cf5d43c1..f49b3f188c69 100644
--- a/parse.c
+++ b/parse.c
@@ -3456,6 +3456,11 @@ struct token *initializer(struct expression **tree, struct token *token)
 		}
 
 		token = initializer_list(&expr->expr_list, token->next);
+		if (ptr_list_empty((struct ptr_list *)expr->expr_list)) {
+			if (standard < STANDARD_C23 && Wpedantic)
+				warning(expr->pos,
+					"ISO C forbids empty initializer braces before C23");
+		}
 		return expect(token, '}', "at end of initializer");
 	}
 	return assignment_expression(token, tree);
diff --git a/sparse-llvm.c b/sparse-llvm.c
index c7055238ff88..f3f6b7e01171 100644
--- a/sparse-llvm.c
+++ b/sparse-llvm.c
@@ -309,6 +309,8 @@ static const char *pseudo_name(pseudo_t pseudo, char *buf)
 	return buf;
 }
 
+static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym);
+
 static LLVMValueRef get_sym_value(LLVMModuleRef module, struct symbol *sym)
 {
 	const char *name = show_ident(sym->ident);
@@ -1250,6 +1252,83 @@ static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
 	LLVMDisposeBuilder(function.builder);
 }
 
+static LLVMValueRef expr_to_const_val(LLVMModuleRef module, struct symbol *sym,
+				      struct expression *initializer)
+{
+	LLVMTypeRef dtype = symbol_type(sym);
+
+	if (!initializer)
+		return LLVMConstNull(dtype);
+
+	switch (initializer->type) {
+	case EXPR_VALUE:
+		return constant_value(initializer->value, dtype);
+	case EXPR_FVALUE:
+		return LLVMConstReal(dtype, initializer->fvalue);
+	case EXPR_SYMBOL: {
+		struct symbol *isym = initializer->symbol;
+
+		if (!isym->ident) {
+			if (!isym->aux) {
+				expand_symbol(isym);
+				isym->aux = output_data(module, isym);
+			}
+			return isym->aux;
+		}
+		LLVMValueRef gv = LLVMGetNamedGlobal(module, show_ident(isym->ident));
+		if (!gv)
+			gv = output_data(module, isym);
+		return gv;
+	}
+	case EXPR_STRING: {
+		const char *s = initializer->string->data;
+		size_t len = initializer->string->length;
+
+		return const_string(s, len);
+	}
+	case EXPR_INITIALIZER: {
+		if (ptr_list_empty((struct ptr_list *)initializer->expr_list))
+			return LLVMConstNull(dtype);
+		if (is_array_type(sym)) {
+			struct symbol *arr = sym->type == SYM_NODE ? sym->ctype.base_type : sym;
+			struct symbol *elem_sym = arr->ctype.base_type;
+			LLVMTypeRef elem_type = symbol_type(elem_sym);
+			unsigned int elem_bytes = bits_to_bytes(elem_sym->bit_size);
+			unsigned int nr = elem_bytes ? bits_to_bytes(sym->bit_size) / elem_bytes : 0;
+			struct expression *entry;
+			LLVMValueRef *vals;
+			LLVMValueRef res;
+			unsigned int i;
+
+			if (!nr)
+				return LLVMConstNull(dtype);
+			vals = calloc(nr, sizeof(*vals));
+			for (i = 0; i < nr; i++)
+				vals[i] = LLVMConstNull(elem_type);
+			FOR_EACH_PTR(initializer->expr_list, entry) {
+				if (entry->type == EXPR_POS) {
+					unsigned int idx = entry->init_offset / elem_bytes;
+					if (idx < nr) {
+						LLVMValueRef v = expr_to_const_val(module, elem_sym,
+										   entry->init_expr);
+						if (v)
+							vals[idx] = v;
+					}
+				}
+			} END_FOR_EACH_PTR(entry);
+			res = LLVMConstArray(elem_type, vals, nr);
+			free(vals);
+			return res;
+		}
+		warning(initializer->pos, "can't initialize type: %s", show_typename(sym));
+		return NULL;
+	}
+	default:
+		warning(initializer->pos, "can't initialize type: %s", show_typename(sym));
+		return NULL;
+	}
+}
+
 static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
 {
 	struct expression *initializer = sym->initializer;
@@ -1257,40 +1336,7 @@ static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
 	LLVMValueRef data;
 	const char *name;
 
-	if (initializer) {
-		switch (initializer->type) {
-		case EXPR_VALUE:
-			initial_value = constant_value(initializer->value, symbol_type(sym));
-			break;
-		case EXPR_FVALUE:
-			initial_value = LLVMConstReal(symbol_type(sym), initializer->fvalue);
-			break;
-		case EXPR_SYMBOL: {
-			struct symbol *sym = initializer->symbol;
-
-			initial_value = LLVMGetNamedGlobal(module, show_ident(sym->ident));
-			if (!initial_value)
-				initial_value = output_data(module, sym);
-			break;
-		}
-		case EXPR_STRING: {
-			const char *s = initializer->string->data;
-			size_t len = initializer->string->length;
-
-			initial_value = const_string(s, len);
-			break;
-		}
-		default:
-			warning(initializer->pos, "can't initialize type: %s", show_typename(sym));
-			initial_value = NULL;
-			break;
-		}
-	} else {
-		LLVMTypeRef type = symbol_type(sym);
-
-		initial_value = LLVMConstNull(type);
-	}
-
+	initial_value = expr_to_const_val(module, sym, initializer);
 	if (!initial_value)
 		return NULL;
 
diff --git a/symbol.c b/symbol.c
index 28fa12352569..270e91d9c480 100644
--- a/symbol.c
+++ b/symbol.c
@@ -569,6 +569,12 @@ static struct symbol * examine_node_type(struct symbol *sym)
 			struct symbol *node_type = base_type->ctype.base_type;
 			int count = count_array_initializer(node_type, initializer);
 
+			if (standard >= STANDARD_C23 &&
+			    initializer->type == EXPR_INITIALIZER &&
+			    ptr_list_empty((struct ptr_list *)initializer->expr_list))
+				sparse_error(sym->pos,
+					     "empty initializer for incomplete array");
+
 			if (node_type && node_type->bit_size >= 0)
 				bit_size = implicit_array_size(sym, count);
 		}
diff --git a/validation/backend/c23-empty-init.c b/validation/backend/c23-empty-init.c
new file mode 100644
index 000000000000..e8741bd5d79a
--- /dev/null
+++ b/validation/backend/c23-empty-init.c
@@ -0,0 +1,24 @@
+typedef typeof(nullptr) nullptr_t;
+
+struct s {
+	int a;
+	void *p;
+};
+
+static nullptr_t g_np = {};
+static void *g_ptr = {};
+static struct s g_s = {};
+
+int test_vla_empty(int n);
+int test_vla_empty(int n)
+{
+	int vla[n] = {};
+	return vla[0] + g_s.a + (g_np != nullptr) + (g_ptr != nullptr);
+}
+
+/*
+ * check-name: backend-c23-empty-init
+ * check-command: sparse-llvm-dis -m64 -std=c23 -Wno-vla $file
+ * check-output-ignore
+ * check-output-contains: define i32 @test_vla_empty(
+ */
diff --git a/validation/c23-auto-error.c b/validation/c23-auto-error.c
index b88ebd37d2d9..16d9c85beb40 100644
--- a/validation/c23-auto-error.c
+++ b/validation/c23-auto-error.c
@@ -28,10 +28,12 @@ void block_errors(void)
 	int bad_cast = (auto)1;
 	_Atomic(auto) bad_atomic = 1;
 	auto braced = { 1 };
+	auto empty = {};
 	(void)bad_sz;
 	(void)bad_cast;
 	(void)bad_atomic;
 	(void)braced;
+	(void)empty;
 }
 
 /*
@@ -56,6 +58,7 @@ c23-auto-error.c:29:16: error: Trying to use reserved word 'auto' as identifier
 c23-auto-error.c:29:23: error: Expected ; at end of declaration
 c23-auto-error.c:29:23: error: got bad_atomic
 c23-auto-error.c:30:14: error: auto requires a scalar initializer expression
+c23-auto-error.c:31:14: error: auto requires a scalar initializer expression
 c23-auto-error.c:2:15: error: invalid initializer
 c23-auto-error.c:7:13: error: underspecified symbol 'self' used in its own initializer
 c23-auto-error.c:9:18: error: underspecified symbol 'self_expr' used in its own initializer
@@ -63,6 +66,6 @@ c23-auto-error.c:10:23: error: underspecified symbol 'self_sz' used in its own i
 c23-auto-error.c:10:16: error: cannot size expression
 c23-auto-error.c:25:31: error: underspecified symbol 'shadow' used in its own initializer
 c23-auto-error.c:27:22: error: cannot size expression
-c23-auto-error.c:33:15: error: undefined identifier 'bad_atomic'
+c23-auto-error.c:34:15: error: undefined identifier 'bad_atomic'
  * check-error-end
  */
diff --git a/validation/c23-constexpr-error.c b/validation/c23-constexpr-error.c
index 41ee86d7ae63..370f2409c99a 100644
--- a/validation/c23-constexpr-error.c
+++ b/validation/c23-constexpr-error.c
@@ -50,7 +50,7 @@ void assign_and_vla_test(int n)
 	constexpr int arr[2] = { 1, 2 };
 	arr[0] = 3;
 
-	constexpr int (*vla)[n] = nullptr;
+	constexpr int vla[n] = {};
 	(void)vla;
 }
 
diff --git a/validation/c23-empty-init-error.c b/validation/c23-empty-init-error.c
new file mode 100644
index 000000000000..b5f39174e1e4
--- /dev/null
+++ b/validation/c23-empty-init-error.c
@@ -0,0 +1,19 @@
+static int inc_arr[] = {};
+
+struct inc_struct;
+
+static void bad_init(void)
+{
+	struct inc_struct x = {};
+	(void)x;
+}
+
+/*
+ * check-name: c23-empty-init-error
+ * check-command: sparse -std=c23 $file
+ *
+ * check-error-start
+c23-empty-init-error.c:1:12: error: empty initializer for incomplete array
+c23-empty-init-error.c:7:31: error: initializer for incomplete type
+ * check-error-end
+ */
diff --git a/validation/c23-empty-init-pedantic.c b/validation/c23-empty-init-pedantic.c
new file mode 100644
index 000000000000..19dfb769f16b
--- /dev/null
+++ b/validation/c23-empty-init-pedantic.c
@@ -0,0 +1,14 @@
+struct s {
+	int a;
+};
+
+static struct s s = {};
+
+/*
+ * check-name: c23 empty initializer pedantic warning
+ * check-command: sparse -std=c11 -Wpedantic $file
+ *
+ * check-error-start
+c23-empty-init-pedantic.c:5:21: warning: ISO C forbids empty initializer braces before C23
+ * check-error-end
+ */
diff --git a/validation/c23-empty-init.c b/validation/c23-empty-init.c
new file mode 100644
index 000000000000..8af4ddf86e42
--- /dev/null
+++ b/validation/c23-empty-init.c
@@ -0,0 +1,64 @@
+struct s {
+	int a;
+	void *ptr;
+};
+
+struct nested {
+	struct s inner;
+	int arr[2];
+};
+
+union u {
+	int a;
+	char *p;
+};
+
+enum e {
+	E0,
+	E1,
+};
+
+typedef typeof(nullptr) nullptr_t;
+
+static int i = {};
+static float f = {};
+static double d = {};
+static void *p = {};
+static bool b = {};
+static nullptr_t np = {};
+static enum e ge = {};
+static struct s s = {};
+static struct s s2 = { {}, {} };
+static struct nested ns = { {}, {} };
+static union u u = {};
+static int arr[3] = {};
+
+static constexpr int ci = {};
+static constexpr bool cb = {};
+static_assert(ci == 0, "ci");
+static_assert(cb == false, "cb");
+
+static int test(int n)
+{
+	int local_i = {};
+	void *local_p = {};
+	struct s local_s = {};
+	int local_arr[2] = {};
+	int vla[n] = {};
+	int cl_i = (int){};
+	struct s cl_s = (struct s){};
+	int *cl_arr = (int [3]){};
+
+	(void)local_p;
+	(void)local_s;
+	(void)cl_s;
+	return local_i + local_arr[0] + vla[0] + cl_i + cl_arr[0] +
+	       i + (int)f + (int)d + (p != nullptr) + b + (np != nullptr) +
+	       ge + s.a + s2.a + (s2.ptr != nullptr) +
+	       ns.inner.a + u.a + arr[0];
+}
+
+/*
+ * check-name: c23 empty initializer braces
+ * check-command: sparse -std=c23 -pedantic -Wno-vla $file
+ */