[PATCH 64/73] expand: Ignore top-level non-array address space in compare_types()

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

Clear c1.as and c2.as in compare_types() only when base_type is not
SYM_ARRAY so that __builtin_types_compatible_p() ignores top-level scalar
address spaces while still distinguishing both pointer target address
spaces and array element address spaces.

Add active validation tests in validation/types-compatible-address-space.c
instead of placing assertions in check-known-to-fail typeof-addresspace.c.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 expand.c                                    |  9 +++--
 validation/types-compatible-address-space.c | 39 +++++++++++++++++++++
 2 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 validation/types-compatible-address-space.c

diff --git a/expand.c b/expand.c
index 815ff24ac487..57d3aeba0f4e 100644
--- a/expand.c
+++ b/expand.c
@@ -790,8 +790,13 @@ static int expand_comma(struct expression *expr)
 
 static int compare_types(int op, struct symbol *left, struct symbol *right)
 {
-	struct ctype c1 = {.base_type = left};
-	struct ctype c2 = {.base_type = right};
+	struct ctype c1 = left->type == SYM_NODE ? left->ctype : (struct ctype){.base_type = left};
+	struct ctype c2 = right->type == SYM_NODE ? right->ctype : (struct ctype){.base_type = right};
+
+	if (!c1.base_type || c1.base_type->type != SYM_ARRAY)
+		c1.as = NULL;
+	if (!c2.base_type || c2.base_type->type != SYM_ARRAY)
+		c2.as = NULL;
 	switch (op) {
 	case SPECIAL_EQUAL:
 		return !type_difference(&c1, &c2, MOD_IGN, MOD_IGN);
diff --git a/validation/types-compatible-address-space.c b/validation/types-compatible-address-space.c
new file mode 100644
index 000000000000..38953eca77e2
--- /dev/null
+++ b/validation/types-compatible-address-space.c
@@ -0,0 +1,39 @@
+#define __as1 __attribute__((address_space(1)))
+#define __as2 __attribute__((address_space(2)))
+
+typedef int __as1 as1_int_t;
+typedef int __as1 as1_arr_t[4];
+typedef int __as1 as1_mat_t[2][4];
+
+static void test_types_compatible_as(void)
+{
+	int __as1 obj, *ptr;
+
+	/* Top-level address space on scalar / pointer itself is ignored */
+	_Static_assert(__builtin_types_compatible_p(int __as1, int), "scalar as1 vs int");
+	_Static_assert(__builtin_types_compatible_p(as1_int_t, int), "typedef scalar as1 vs int");
+	_Static_assert(__builtin_types_compatible_p(typeof(obj), int), "typeof(obj) vs int");
+	_Static_assert(__builtin_types_compatible_p(typeof(*ptr), int), "typeof(*ptr) vs int");
+	_Static_assert(__builtin_types_compatible_p(int * __as1, int *), "ptr own as1 vs int *");
+
+	/* Pointee address space must match */
+	_Static_assert(!__builtin_types_compatible_p(int __as1 *, int *), "pointee as1 vs default");
+	_Static_assert(!__builtin_types_compatible_p(typeof(ptr), int *), "typeof(ptr) vs int *");
+	_Static_assert(!__builtin_types_compatible_p(int __as1 *, int __as2 *), "pointee as1 vs as2");
+	_Static_assert(__builtin_types_compatible_p(int __as1 *, int __as1 *), "pointee as1 vs as1");
+
+	/* Array element address space must match */
+	_Static_assert(!__builtin_types_compatible_p(int __as1[4], int[4]), "array elem as1 vs default");
+	_Static_assert(!__builtin_types_compatible_p(as1_arr_t, int[4]), "typedef array as1 vs int[4]");
+	_Static_assert(!__builtin_types_compatible_p(typeof(as1_arr_t), int[4]), "typeof(as1_arr_t) vs int[4]");
+	_Static_assert(!__builtin_types_compatible_p(int __as1[4], int __as2[4]), "array elem as1 vs as2");
+	_Static_assert(__builtin_types_compatible_p(int __as1[4], int __as1[4]), "array elem as1 vs as1");
+	_Static_assert(!__builtin_types_compatible_p(int __as1[2][4], int[2][4]), "2d array elem as1 vs default");
+	_Static_assert(!__builtin_types_compatible_p(as1_mat_t, int[2][4]), "typedef 2d array as1 vs int[2][4]");
+	_Static_assert(__builtin_types_compatible_p(int __as1[2][4], int __as1[2][4]), "2d array elem as1 vs as1");
+}
+
+/*
+ * check-name: types-compatible-address-space
+ * check-command: sparse $file
+ */