Fix _Generic selection for pointer-to-array types

Use type compatibility matching instead of exact equality in _Generic.
Also fix array type compatibility check to follow C11 6.2.7 standard:
Arrays with unspecified size are compatible with specified sizes.

Fixes: #8690

Author: tautschnig

regression/ansi-c/_Generic_pointer_to_array/main.c

@@ -0,0 +1,34 @@
+#include <assert.h>
+#include <stdbool.h>
+
+int main(void)
+{
+  // Test case from issue #8690
+  // A generic selection on a value of type int(*)[5] should match an arm for int(*)[]
+  int arr[5];
+  assert(_Generic(&arr, int(*)[] : true));
+
+  // Additional test cases to ensure compatibility matching works correctly
+
+  // Test with different array sizes - should all match int(*)[]
+  int arr2[10];
+  assert(_Generic(&arr2, int(*)[] : true));
+
+  int arr3[1];
+  assert(_Generic(&arr3, int(*)[] : true));
+
+  // Test with character arrays
+  char carr[20];
+  assert(_Generic(&carr, char(*)[] : true, default : false));
+
+  // Test with default case as fallback
+  int *ptr;
+  int result = _Generic(ptr, int(*)[] : 1, default : 2);
+  assert(result == 2);
+
+  // Test pointer to array of specific size should also work
+  int(*ptr_to_arr)[5] = &arr;
+  assert(_Generic(ptr_to_arr, int(*)[] : true));
+
+  return 0;
+}

regression/ansi-c/_Generic_pointer_to_array/test.desc

@@ -0,0 +1,11 @@
+CORE
+main.c
+
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+^CONVERSION ERROR$
+--
+Test _Generic selection with pointer-to-array types (issue #8690).
+Pointer to array with specified size should match pointer to array with unspecified size.

src/ansi-c/c_typecheck_expr.cpp

@@ -130,9 +130,23 @@ bool c_typecheck_baset::gcc_types_compatible_p(
   else if(type1.id()==ID_array &&
           type2.id()==ID_array)
   {
-    return gcc_types_compatible_p(
-      to_array_type(type1).element_type(),
-      to_array_type(type2).element_type()); // ignore size
+    // For C11 6.2.7: array types are compatible if element types are
+    // compatible and both size specifiers are present and equal, OR
+    // one or both size specifiers are absent.
+    if(!gcc_types_compatible_p(
+         to_array_type(type1).element_type(),
+         to_array_type(type2).element_type()))
+      return false;
+
+    const array_typet &a_type1 = to_array_type(type1);
+    const array_typet &a_type2 = to_array_type(type2);
+
+    // If either size is absent (incomplete), arrays are compatible
+    if(!a_type1.is_complete() || !a_type2.is_complete())
+      return true;
+
+    // Both sizes are present - they must be equal
+    return a_type1.size() == a_type2.size();
   }
   else if(type1.id()==ID_code &&
           type2.id()==ID_code)
@@ -463,9 +477,18 @@ void c_typecheck_baset::typecheck_expr_main(exprt &expr)
     {
       if(irep.get(ID_type_arg) == ID_default)
         default_match = static_cast<const exprt &>(irep.find(ID_value));
-      else if(op_type == static_cast<const typet &>(irep.find(ID_type_arg)))
+      else
       {
-        assoc_match = static_cast<const exprt &>(irep.find(ID_value));
+        const typet &assoc_type =
+          static_cast<const typet &>(irep.find(ID_type_arg));
+        // Use type compatibility matching instead of exact equality.
+        // This allows pointer-to-array types with specified dimensions
+        // to match pointer-to-array types with unspecified dimensions,
+        // which is required by C11 6.5.1.1 Generic selection.
+        if(gcc_types_compatible_p(op_type, assoc_type))
+        {
+          assoc_match = static_cast<const exprt &>(irep.find(ID_value));
+        }
       }
     }