[PATCH 03/73] typeof_unqual: Strip qualifiers and address space from types and arrays

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

Examine the target symbol type and clear MOD_QUALIFIER, non-array
MOD_ATOMIC, and ctype.as in typeof_specifier_helper() and
examine_typeof_helper() when qual is false. Add strip_array_qualifiers()
to recursively clone SYM_ARRAY chains and strip element qualifiers and
address spaces without mutating shared typedef or declaration symbols,
while preserving MOD_ATOMIC on array element types per ISO C23 6.7.2.5p4.

Ensure that typeof_unqual() and __typeof_unqual__() remove qualifiers and
address spaces from type names, expressions, and qualified array types
instead of retaining qualifiers on the resulting type.

Fixes: dc9efe442b89 ("sparse: implement typeof_unqual()")
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 parse.c                        |   8 +++
 symbol.c                       |  32 +++++++++-
 symbol.h                       |   1 +
 validation/c23-typeof-unqual.c | 113 +++++++++++++++++++++++++++++++++
 4 files changed, 151 insertions(+), 3 deletions(-)
 create mode 100644 validation/c23-typeof-unqual.c

diff --git a/parse.c b/parse.c
index 1a889ccb6a90..f349cc75bff4 100644
--- a/parse.c
+++ b/parse.c
@@ -1070,6 +1070,14 @@ static struct token *typeof_specifier_helper(struct token *token, struct symbol
 	if (lookup_type(token->next)) {
 		struct symbol *sym;
 		token = typename(token->next, &sym, NULL);
+		sym = examine_symbol_type(sym);
+		if (!qual) {
+			sym->ctype.modifiers &= ~MOD_QUALIFIER;
+			if (!sym->ctype.base_type || sym->ctype.base_type->type != SYM_ARRAY)
+				sym->ctype.modifiers &= ~MOD_ATOMIC;
+			sym->ctype.as = NULL;
+			sym->ctype.base_type = strip_array_qualifiers(sym->ctype.base_type);
+		}
 		ctx->ctype.base_type = sym->ctype.base_type;
 		apply_ctype(token->pos, &ctx->ctype, &sym->ctype);
 	} else {
diff --git a/symbol.c b/symbol.c
index 7060acb666d9..5470880db271 100644
--- a/symbol.c
+++ b/symbol.c
@@ -541,6 +541,27 @@ static struct symbol *examine_pointer_type(struct symbol *sym)
 	return sym;
 }
 
+struct symbol *strip_array_qualifiers(struct symbol *type)
+{
+	struct symbol *elem, *copy;
+	unsigned long strip;
+
+	if (!type)
+		return NULL;
+	if (type->type != SYM_ARRAY && type->type != SYM_NODE)
+		return type;
+	elem = strip_array_qualifiers(type->ctype.base_type);
+	strip = type->ctype.modifiers & MOD_QUALIFIER;
+	if (elem == type->ctype.base_type && !strip && !type->ctype.as)
+		return type;
+	copy = alloc_symbol(type->pos, type->type);
+	*copy = *type;
+	copy->ctype.base_type = elem;
+	copy->ctype.modifiers &= ~MOD_QUALIFIER;
+	copy->ctype.as = NULL;
+	return copy;
+}
+
 static struct symbol *examine_typeof_helper(struct symbol *sym, bool qual)
 {
 	struct symbol *base = evaluate_expression(sym->initializer);
@@ -548,12 +569,17 @@ static struct symbol *examine_typeof_helper(struct symbol *sym, bool qual)
 
 	if (!base)
 		base = &bad_ctype;
-	if (base->type == SYM_NODE) {
+	while (base->type == SYM_NODE) {
 		mod |= base->ctype.modifiers & MOD_TYPEOF;
-		if (!qual)
-			mod &= ~MOD_QUALIFIER;
 		base = base->ctype.base_type;
 	}
+	if (!qual) {
+		mod &= ~MOD_QUALIFIER;
+		if (base->type != SYM_ARRAY)
+			mod &= ~MOD_ATOMIC;
+		sym->ctype.as = NULL;
+		base = strip_array_qualifiers(base);
+	}
 	if (base->type == SYM_BITFIELD)
 		warning(base->pos, "typeof applied to bitfield type");
 	sym->type = SYM_NODE;
diff --git a/symbol.h b/symbol.h
index 3552d4391621..9ff2733021b8 100644
--- a/symbol.h
+++ b/symbol.h
@@ -351,6 +351,7 @@ extern void add_symbol(struct symbol_list **, struct symbol *);
 extern void bind_symbol(struct symbol *, struct ident *, enum namespace);
 extern void bind_symbol_with_scope(struct symbol *, struct ident *, enum namespace, struct scope *);
 
+extern struct symbol *strip_array_qualifiers(struct symbol *);
 extern struct symbol *examine_symbol_type(struct symbol *);
 extern struct symbol *examine_pointer_target(struct symbol *);
 extern const char *show_as(struct ident *as);
diff --git a/validation/c23-typeof-unqual.c b/validation/c23-typeof-unqual.c
new file mode 100644
index 000000000000..5738fafd2fca
--- /dev/null
+++ b/validation/c23-typeof-unqual.c
@@ -0,0 +1,113 @@
+/* Test typeof_unqual on type names */
+typedef const int const_int;
+typedef typeof_unqual(const_int) unqual_int;
+
+typedef volatile int vol_int;
+typedef typeof_unqual(vol_int) nonvol_int;
+
+typedef int * const const_ptr;
+typedef typeof_unqual(const_ptr) mod_ptr;
+
+typedef _Atomic int atomic_int;
+typedef typeof_unqual(atomic_int) nonatomic_int;
+
+typedef const int ca[3];
+typedef typeof_unqual(ca) unqual_ca;
+
+typedef const int cmatrix[2][3];
+typedef typeof_unqual(cmatrix) unqual_matrix;
+
+typedef const _Atomic int const_atomic_arr[2];
+typedef typeof_unqual(const_atomic_arr) unqual_atomic_arr;
+
+typedef const int *cip_arr_t[2];
+typedef int * const cpi_arr_t[2];
+
+#ifdef __CHECKER__
+typedef int __attribute__((address_space(1))) as1_int;
+typedef typeof_unqual(as1_int) as0_int;
+typedef int __attribute__((address_space(1))) as1_arr[2];
+typedef typeof_unqual(as1_arr) as0_arr;
+#endif
+
+_Static_assert(!__builtin_types_compatible_p(ca *, int (*)[3]), "ca stays const");
+_Static_assert(__builtin_types_compatible_p(ca *, const int (*)[3]), "ca is const int[3]");
+_Static_assert(__builtin_types_compatible_p(unqual_ca *, int (*)[3]), "unqual_ca strips const");
+_Static_assert(!__builtin_types_compatible_p(cmatrix *, int (*)[2][3]), "cmatrix stays const");
+_Static_assert(__builtin_types_compatible_p(unqual_matrix *, int (*)[2][3]), "unqual_matrix strips const");
+_Static_assert(!__builtin_types_compatible_p(const_atomic_arr *, _Atomic int (*)[2]), "const_atomic_arr stays const");
+_Static_assert(__builtin_types_compatible_p(unqual_atomic_arr *, _Atomic int (*)[2]), "unqual_atomic_arr strips const, keeps _Atomic");
+_Static_assert(__builtin_types_compatible_p(typeof_unqual(cip_arr_t) *, const int *(*)[2]), "pointee const kept");
+_Static_assert(!__builtin_types_compatible_p(typeof_unqual(cip_arr_t) *, int *(*)[2]), "pointee const not stripped");
+_Static_assert(__builtin_types_compatible_p(typeof_unqual(cpi_arr_t) *, int *(*)[2]), "element ptr const stripped");
+
+static void test_types(void)
+{
+	unqual_int a = 1;
+	a = 2;
+
+	mod_ptr p = (void *)0;
+	p = (int *)0;
+
+	unqual_ca b;
+	b[0] = 1;
+
+	unqual_matrix u;
+	u[0][0] = 1;
+
+	unqual_atomic_arr na;
+	na[0] = 1;
+
+	typeof_unqual(cpi_arr_t) ucpi;
+	ucpi[0] = (int *)0;
+
+#ifdef __CHECKER__
+	as0_int x = 0;
+	int *px = &x;
+	(void)px;
+
+	as0_arr ax;
+	int *pax = ax;
+	(void)pax;
+#endif
+}
+
+/* Test typeof_unqual on expressions */
+static void test_exprs(const int c, _Atomic int a)
+{
+	typeof_unqual(c) uc = 10;
+	uc = 20;
+
+	typeof_unqual(a) ua = 30;
+	ua = 40;
+
+	const int arr[3] = { 0 };
+	typeof_unqual(arr) uarr;
+	uarr[0] = 1;
+	_Static_assert(!__builtin_types_compatible_p(typeof(&arr), int (*)[3]), "arr stays const");
+	_Static_assert(__builtin_types_compatible_p(typeof(&uarr), int (*)[3]), "uarr is int[3]");
+
+	const int m[2][3] = { { 0 } };
+	typeof_unqual(m) um;
+	um[0][0] = 1;
+	_Static_assert(!__builtin_types_compatible_p(typeof(&m), int (*)[2][3]), "m stays const");
+	_Static_assert(__builtin_types_compatible_p(typeof(&um), int (*)[2][3]), "um is int[2][3]");
+
+	const _Atomic int aa[2] = { 0 };
+	typeof_unqual(aa) uaa;
+	uaa[0] = 1;
+	_Static_assert(!__builtin_types_compatible_p(typeof(&aa), _Atomic int (*)[2]), "aa stays const");
+	_Static_assert(__builtin_types_compatible_p(typeof(&uaa), _Atomic int (*)[2]), "uaa is _Atomic int[2]");
+
+#ifdef __CHECKER__
+	static int __attribute__((address_space(1))) asa[2];
+	typeof_unqual(asa) uasa;
+	int *p = uasa;
+	(void)p;
+#endif
+}
+
+/*
+ * check-name: c23-typeof-unqual
+ * check-command: sparse $file
+ */