c: minor fixes related to arrays of unspecified size

The patch for PR117145 and PR117245 also fixed PR100420 and PR116284 which
are bugs related to arrays of unspecified size.  Those are now represented
as variable size arrays with size (0, 0).  There are still some loose ends,
which are resolved here by

1. adding a testcase for PR116284,
2. moving code related to creation and detection of arrays of unspecified
sizes in their own functions,
3. preferring a specified size over an unspecified size when forming
a composite type as required by C99 (PR118391)
4. removing useless code in comptypes_internal and composite_type_internal.

	PR c/116284
	PR c/117391

gcc/c/ChangeLog:
	* c-tree.h (c_type_unspecified_p): New inline function.
	* c-typeck.cc (c_build_array_type_unspecified): New function.
	(comptypes_interal): Remove useless code.
	(composite_type_internal): Update.
	* c-decl.cc (grokdeclarator): Revise.

gcc/testsuite/ChangeLog:
	* gcc.dg/pr116284.c: New test.
	* gcc.dg/pr117391.c: New test.

(cherry picked from commit 114abf075c1e28358173756042049c9992ae6572)

diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index ab21ee3e5bd17e5d8759ed61229c7dc54e438fb8..70f3faf6d6883a2c528e7dacfe74dc0b120e0a4c 100644 (file)
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -7434,10 +7434,6 @@ grokdeclarator (const struct c_declarator *declarator,
                /* C99 6.7.5.2p4 */
                if (decl_context == TYPENAME)
                  warning (0, "%<[*]%> not in a declaration");
-               /* Array of unspecified size.  */
-               tree upper = build2 (COMPOUND_EXPR, TREE_TYPE (size_zero_node),
-                                    integer_zero_node, size_zero_node);
-               itype = build_index_type (upper);
                size_varies = true;
              }
 
@@ -7473,7 +7469,10 @@ grokdeclarator (const struct c_declarator *declarator,
                if (!ADDR_SPACE_GENERIC_P (as) && as != TYPE_ADDR_SPACE (type))
                  type = c_build_qualified_type (type,
                                                 ENCODE_QUAL_ADDR_SPACE (as));
-               type = c_build_array_type (type, itype);
+               if (array_parm_vla_unspec_p)
+                 type = c_build_array_type_unspecified (type);
+               else
+                 type = c_build_array_type (type, itype);
              }
 
            if (type != error_mark_node)

diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 0f5b4246d0fe723780906b591947c01965da6a75..8b9a4610877b3b397d5aeb665ad75974bf288d83 100644 (file)
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -748,12 +748,22 @@ extern struct c_switch *c_switch_stack;
 extern bool null_pointer_constant_p (const_tree);
 
 
-inline
-bool c_type_variably_modified_p (tree t)
+inline bool
+c_type_variably_modified_p (tree t)
 {
   return error_mark_node != t && C_TYPE_VARIABLY_MODIFIED (t);
 }
 
+inline bool
+c_type_unspecified_p (tree t)
+{
+  return error_mark_node != t
+        && C_TYPE_VARIABLE_SIZE (t) && TREE_CODE (t) == ARRAY_TYPE
+        && TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t))
+        && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == COMPOUND_EXPR
+        && integer_zerop (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0))
+        && integer_zerop (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 1));
+}
 
 extern bool char_type_p (tree);
 extern tree c_objc_common_truthvalue_conversion (location_t, tree,
@@ -852,10 +862,10 @@ extern tree c_reconstruct_complex_type (tree, tree);
 extern tree c_build_type_attribute_variant (tree ntype, tree attrs);
 extern tree c_build_pointer_type (tree type);
 extern tree c_build_array_type (tree type, tree domain);
+extern tree c_build_array_type_unspecified (tree type);
 extern tree c_build_function_type (tree type, tree args, bool no = false);
 extern tree c_build_pointer_type_for_mode (tree type, machine_mode mode, bool m);
 
-
 /* Set to 0 at beginning of a function definition, set to 1 if
    a return statement that specifies a return value is seen.  */
 

diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 401a55932787887b865e29935f53abfa533d5c23..24cc4faa55fae22ee40fcf026761470e56716b21 100644 (file)
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -357,7 +357,7 @@ qualify_type (tree type, tree like)
 }
 
 \f
-/* Check consistency of type TYP.E  For derived types, we test that
+/* Check consistency of type TYPE.  For derived types, we test that
    C_TYPE_VARIABLE_SIZE and C_TYPE_VARIABLY_MODIFIED are consistent with
    the requirements of the base type.  We also check that arrays with a
    non-constant length are marked with C_TYPE_VARIABLE_SIZE. If any
@@ -489,6 +489,17 @@ c_build_array_type (tree type, tree domain)
   return c_set_type_bits (ret, type);
 }
 
+
+/* Build an array type of unspecified size.  */
+tree
+c_build_array_type_unspecified (tree type)
+{
+  tree upper = build2 (COMPOUND_EXPR, TREE_TYPE (size_zero_node),
+                      integer_zero_node, size_zero_node);
+  return c_build_array_type (type, build_index_type (upper));
+}
+
+
 tree
 c_build_type_attribute_qual_variant (tree type, tree attrs, int quals)
 {
@@ -659,15 +670,23 @@ composite_type_internal (tree t1, tree t2, struct composite_cache* cache)
        d2_variable = (!d2_zero
                       && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
                           || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
-       d1_variable = d1_variable || (d1_zero && C_TYPE_VARIABLE_SIZE (t1));
-       d2_variable = d2_variable || (d2_zero && C_TYPE_VARIABLE_SIZE (t2));
+
+       bool use1 = TYPE_DOMAIN (t1)
+                   && (d2_variable || d2_zero || !d1_variable);
+       bool use2 = TYPE_DOMAIN (t2)
+                   && (d1_variable || d1_zero || !d2_variable);
+
+       /* If the first is an unspecified size pick the other one.  */
+       if (d2_variable && c_type_unspecified_p (t1))
+         {
+           gcc_assert (use1 && use2);
+           use1 = false;
+         }
 
        /* Save space: see if the result is identical to one of the args.  */
-       if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
-           && (d2_variable || d2_zero || !d1_variable))
+       if (elt == TREE_TYPE (t1) && use1)
          return c_build_type_attribute_variant (t1, attributes);
-       if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
-           && (d1_variable || d1_zero || !d2_variable))
+       if (elt == TREE_TYPE (t2) && use2)
          return c_build_type_attribute_variant (t2, attributes);
 
        if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
@@ -682,13 +701,7 @@ composite_type_internal (tree t1, tree t2, struct composite_cache* cache)
           back at the end.  */
        quals = TYPE_QUALS (strip_array_types (elt));
        unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
-       t1 = c_build_array_type (unqual_elt,
-                                TYPE_DOMAIN ((TYPE_DOMAIN (t1)
-                                             && (d2_variable
-                                                 || d2_zero
-                                                 || !d1_variable))
-                                             ? t1
-                                             : t2));
+       t1 = c_build_array_type (unqual_elt, TYPE_DOMAIN (use1 ? t1 : t2));
 
        /* Check that a type which has a varying outermost dimension
           got marked has having a variable size.  */
@@ -1615,8 +1628,6 @@ comptypes_internal (const_tree type1, const_tree type2,
        d2_variable = (!d2_zero
                       && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
                           || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
-       d1_variable = d1_variable || (d1_zero && C_TYPE_VARIABLE_SIZE (t1));
-       d2_variable = d2_variable || (d2_zero && C_TYPE_VARIABLE_SIZE (t2));
 
        if (d1_variable != d2_variable)
          data->different_types_p = true;

diff --git a/gcc/testsuite/gcc.dg/pr116284.c b/gcc/testsuite/gcc.dg/pr116284.c
new file mode 100644 (file)
index 0000000..c283182
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr116284.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu23" } */
+
+// There should be no warning about variably-modified types
+
+static int a[0];
+static int b[sizeof a];
+
+void foo(int (*x)[*]);
+
+static int c[0];
+static int d[sizeof c];
+
+

diff --git a/gcc/testsuite/gcc.dg/pr117391.c b/gcc/testsuite/gcc.dg/pr117391.c
new file mode 100644 (file)
index 0000000..d3d03ad
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr117391.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c99" } */
+
+int foo(int n, char (*buf)[*]);
+int bar(int n, char (*buf)[n]);
+
+void test()
+{
+       (1 ? foo : bar)(0);     /* { dg-error "too few arguments to function '\\\(int \\\(\\\*\\\)\\\(int,  char \\\(\\\*\\\)\\\[n]\\\)\\\)&foo'" } */
+       (0 ? bar : foo)(0);     /* { dg-error "too few arguments to function '\\\(int \\\(\\\*\\\)\\\(int,  char \\\(\\\*\\\)\\\[n]\\\)\\\)&foo'" } */
+       (0 ? foo : bar)(0);     /* { dg-error "too few arguments to function 'bar'" } */
+       (1 ? bar : foo)(0);     /* { dg-error "too few arguments to function 'bar'" } */
+}
+