[PATCH 47/73] c23: Support variadic functions without named parameters

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

Allow variadic function prototypes and definitions of the form 'f(...)'
without a preceding named parameter and support single-argument va_start
in C23 mode per ISO C23 6.7.6.3 and 7.16.1.4:
- Replace the predefined 2-argument __builtin_va_start macro in lib.c
  with builtin handlers for __builtin_va_start and
  __builtin_c23_va_start in builtin.c so <stdarg.h> works with both
  va_start(ap) and va_start(ap, ...).
- Validate that va_start appears inside a variadic function on a
  modifiable va_list lvalue, leave extra C23 va_start arguments
  unevaluated, and lower va_start to initialize ap.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 builtin.c                          | 77 ++++++++++++++++++++++++++++++
 lib.c                              |  1 -
 parse.c                            |  5 +-
 validation/c11-va-start-error.c    | 20 ++++++++
 validation/c23-variadic-error.c    | 41 ++++++++++++++++
 validation/c23-variadic-no-named.c | 47 ++++++++++++++++++
 validation/linear/c23-va-start.c   | 22 +++++++++
 7 files changed, 210 insertions(+), 3 deletions(-)
 create mode 100644 validation/c11-va-start-error.c
 create mode 100644 validation/c23-variadic-error.c
 create mode 100644 validation/c23-variadic-no-named.c
 create mode 100644 validation/linear/c23-va-start.c

diff --git a/builtin.c b/builtin.c
index 78a971ce4bb5..0be03c51aedd 100644
--- a/builtin.c
+++ b/builtin.c
@@ -638,6 +638,81 @@ static struct symbol_op object_size_op = {
 	.expand = expand_object_size,
 };
 
+static int args_va_start(struct expression *expr)
+{
+	struct symbol *sym = expr->fn->ctype;
+	bool is_c23 = !strcmp(show_ident(sym->ident), "__builtin_c23_va_start");
+	int n = expression_list_size(expr->args);
+	struct expression *arg;
+	int i = 0;
+
+	if (n < 1 || (!is_c23 && standard < STANDARD_C23 && n < 2)) {
+		expression_error(expr, "not enough arguments for %s",
+				 show_ident(sym->ident));
+		return 0;
+	}
+	if (!is_c23 && n > 2) {
+		expression_error(expr, "too many arguments for %s",
+				 show_ident(sym->ident));
+		return 0;
+	}
+	FOR_EACH_PTR(expr->args, arg) {
+		if (i == 1 && !is_c23) {
+			if (!evaluate_expression(arg))
+				return 0;
+		}
+		i++;
+	} END_FOR_EACH_PTR(arg);
+	return 1;
+}
+
+static int evaluate_va_start(struct expression *expr)
+{
+	struct expression *ap = first_expression(expr->args);
+	struct symbol *fntype = current_fn ? current_fn->ctype.base_type : NULL;
+	struct expression *assign, *rhs;
+
+	if (current_fn && current_fn->type == SYM_FN)
+		fntype = current_fn;
+	if (!fntype || !fntype->variadic) {
+		expression_error(expr, "'va_start' used in function with fixed args");
+		return 1;
+	}
+
+	if (!evaluate_expression(ap) || !valid_type(ap->ctype))
+		return 1;
+	{
+		struct symbol *atype = ap->ctype;
+		while (atype && atype->type == SYM_NODE)
+			atype = atype->ctype.base_type;
+		if (atype != &ptr_ctype) {
+			expression_error(expr, "incorrect type in 'va_start'");
+			return 1;
+		}
+	}
+
+	rhs = alloc_expression(expr->pos, EXPR_VALUE);
+	rhs->ctype = &ptr_ctype;
+	rhs->value = 0;
+
+	assign = alloc_expression(expr->pos, EXPR_ASSIGNMENT);
+	assign->op = '=';
+	assign->left = ap;
+	assign->right = rhs;
+	evaluate_expression(assign);
+
+	expr->type = EXPR_CAST;
+	expr->cast_type = &void_ctype;
+	expr->cast_expression = assign;
+	expr->ctype = &void_ctype;
+	return 1;
+}
+
+static struct symbol_op va_start_op = {
+	.args = args_va_start,
+	.evaluate = evaluate_va_start,
+};
+
 static int evaluate_strlen(struct expression *expr)
 {
 	struct expression *arg = first_expression(expr->args);
@@ -876,7 +951,9 @@ static const struct builtin_fn builtins_common[] = {
 	{ "__builtin_usub_overflow", &bool_ctype, 0, { &uint_ctype, &uint_ctype, &uint_ptr_ctype }},
 	{ "__builtin_usubl_overflow", &bool_ctype, 0, { &ulong_ctype, &ulong_ctype, &ulong_ptr_ctype }},
 	{ "__builtin_usubll_overflow", &bool_ctype, 0, { &ullong_ctype, &ullong_ctype, &ullong_ptr_ctype }},
+	{ "__builtin_c23_va_start", &void_ctype, 1, .op = &va_start_op },
 	{ "__builtin_va_arg_pack_len", size_t_ctype, 0 },
+	{ "__builtin_va_start", &void_ctype, 1, .op = &va_start_op },
 	{ "__builtin_vprintf", &int_ctype, 0, { &const_string_ctype, va_list_ctype }},
 	{ "__builtin_vsnprintf", &int_ctype, 0, { &string_ctype, size_t_ctype, &const_string_ctype, va_list_ctype }},
 	{ "__builtin_vsprintf", &int_ctype, 0, { &string_ctype, &const_string_ctype, va_list_ctype }},
diff --git a/lib.c b/lib.c
index 6670e3b46657..3c41c41855c4 100644
--- a/lib.c
+++ b/lib.c
@@ -299,7 +299,6 @@ static void create_builtin_stream(void)
 	add_pre_buffer("#add_system \"%s/include-fixed\"\n", gcc_base_dir);
 
 	add_pre_buffer("#define __builtin_stdarg_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
-	add_pre_buffer("#define __builtin_va_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
 	add_pre_buffer("#define __builtin_ms_va_start(a,b) ((a) = (__builtin_ms_va_list)(&(b)))\n");
 	add_pre_buffer("#define __builtin_va_arg(arg,type)  ({ type __va_arg_ret = *(type *)(arg); arg += sizeof(type); __va_arg_ret; })\n");
 	add_pre_buffer("#define __builtin_va_alist (*(void *)0)\n");
diff --git a/parse.c b/parse.c
index 6af5bfba2392..78ad5f09e2ad 100644
--- a/parse.c
+++ b/parse.c
@@ -1926,8 +1926,9 @@ static enum kind which_func(struct token *token,
 	}
 
 	if (next->special == SPECIAL_ELLIPSIS) {
-		warning(next->pos,
-			"variadic functions must have one named argument");
+		if (standard < STANDARD_C23)
+			warning(next->pos,
+				"variadic functions must have one named argument");
 		return Proto;
 	}
 
diff --git a/validation/c11-va-start-error.c b/validation/c11-va-start-error.c
new file mode 100644
index 000000000000..334ad0cd48ad
--- /dev/null
+++ b/validation/c11-va-start-error.c
@@ -0,0 +1,20 @@
+#include <stdarg.h>
+
+static void f(int n, ...)
+{
+	va_list ap;
+	(void)n;
+	va_start(ap);
+	__builtin_va_start(ap);
+}
+
+/*
+ * check-name: c11-va-start-error
+ * check-command: sparse -std=c11 $file
+ *
+ * check-error-start
+c11-va-start-error.c:7:9: error: macro "va_start" requires 2 arguments, but only 1 given
+c11-va-start-error.c:7:9: error: undefined identifier 'va_start'
+c11-va-start-error.c:8:27: error: not enough arguments for __builtin_va_start
+ * check-error-end
+ */
diff --git a/validation/c23-variadic-error.c b/validation/c23-variadic-error.c
new file mode 100644
index 000000000000..85032625fff3
--- /dev/null
+++ b/validation/c23-variadic-error.c
@@ -0,0 +1,41 @@
+#include <stdarg.h>
+
+static const va_list const_ap;
+
+static void fixed_fn(int x)
+{
+	va_list ap;
+	(void)x;
+	va_start(ap);
+}
+
+static void variadic_errors(...)
+{
+	int not_ap = 0;
+	void *void_ptr = nullptr;
+	va_list ap;
+
+	__builtin_va_start();
+	__builtin_va_start(ap, 1, 2);
+	va_start(not_ap);
+	va_start(void_ptr);
+	va_start(const_ap);
+	(void)(va_start(ap) + 1);
+}
+
+/*
+ * check-name: c23-variadic-error
+ * check-command: sparse -std=c23 $file
+ *
+ * check-error-start
+c23-variadic-error.c:9:9: error: 'va_start' used in function with fixed args
+c23-variadic-error.c:18:27: error: not enough arguments for __builtin_va_start
+c23-variadic-error.c:19:27: error: too many arguments for __builtin_va_start
+c23-variadic-error.c:20:9: error: incorrect type in 'va_start'
+c23-variadic-error.c:21:9: error: incorrect type in 'va_start'
+c23-variadic-error.c:22:9: error: assignment to const expression
+c23-variadic-error.c:23:29: error: incompatible types for operation (+):
+c23-variadic-error.c:23:29:    void
+c23-variadic-error.c:23:29:    int
+ * check-error-end
+ */
diff --git a/validation/c23-variadic-no-named.c b/validation/c23-variadic-no-named.c
new file mode 100644
index 000000000000..35e38f7ae177
--- /dev/null
+++ b/validation/c23-variadic-no-named.c
@@ -0,0 +1,47 @@
+#include <stdarg.h>
+
+static void v1(...)
+{
+}
+
+static int sum_two(...)
+{
+	va_list ap, copy;
+	int a, b;
+
+	va_start(ap);
+	va_copy(copy, ap);
+	a = va_arg(ap, int);
+	b = va_arg(ap, int);
+	va_end(copy);
+	va_end(ap);
+	return a + b;
+}
+
+static int sum_after_n(int n, ...)
+{
+	va_list ap;
+	int a;
+
+	va_start(ap, n);
+	va_end(ap);
+	va_start(ap, undeclared_ignored_token, 1, 2);
+	a = va_arg(ap, int);
+	va_end(ap);
+	return n + a;
+}
+
+static int test(void)
+{
+	int (*fp)(...) = sum_two;
+
+	v1();
+	v1(1);
+	v1(1, 2, "three");
+	return fp(10, 20) + sum_after_n(5, 7);
+}
+
+/*
+ * check-name: c23-variadic-no-named
+ * check-command: sparse -std=c23 -pedantic $file
+ */
diff --git a/validation/linear/c23-va-start.c b/validation/linear/c23-va-start.c
new file mode 100644
index 000000000000..2d5b11d58aa4
--- /dev/null
+++ b/validation/linear/c23-va-start.c
@@ -0,0 +1,22 @@
+#include <stdarg.h>
+
+int first_arg(...);
+int first_arg(...)
+{
+	va_list ap;
+	int v;
+
+	va_start(ap);
+	v = va_arg(ap, int);
+	va_end(ap);
+	return v;
+}
+
+/*
+ * check-name: linear-c23-va-start
+ * check-command: test-linearize -m64 -std=c23 -Wuninitialized $file
+ *
+ * check-output-ignore
+ * check-output-excludes: __builtin_va_start
+ * check-output-excludes: __builtin_c23_va_start
+ */