c++: Extend build_array_type API

The modules machinery needs to construct array types, and that wanted
to determine type dependency.  That doesn't work during loading, but
the module loader can stream that fact too and tell the array builder.
Thus this extends the API to allow a caller to specify the dependency
explicitly.  The call in cp_build_qualified_type_real is unreachable
during the loading, so that one's ok as is.

	gcc/cp/
	* cp-tree.h (build_cplus_array_type): Add defaulted DEP parm.
	* tree.c (set_array_type_common): Add DEP parm.
	(build_cplus_array_type): Add DEP parm, determine dependency if
	needed.
	(cp_build_qualified_type_real): Adjust array-building call.
	(strip_typedefs): Likewise.

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index b5d4fc0aba16b53f46aad280290342f3ba5d26d1..ae1147d4589b355acc83ff58a27e2ddc5694f371 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -7377,7 +7377,7 @@ extern bool is_local_temp                 (tree);
 extern tree build_aggr_init_expr               (tree, tree);
 extern tree get_target_expr                    (tree);
 extern tree get_target_expr_sfinae             (tree, tsubst_flags_t);
-extern tree build_cplus_array_type             (tree, tree);
+extern tree build_cplus_array_type             (tree, tree, int is_dep = -1);
 extern tree build_array_of_n_type              (tree, int);
 extern bool array_of_runtime_bound_p           (tree);
 extern bool vla_type_p                         (tree);

diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 4113a34b0c1267e552da8c6d3456ee6b1f6844d1..5932777be0449d65dd7c305e05711954acc8822d 100644 (file)
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -998,7 +998,7 @@ build_min_array_type (tree elt_type, tree index_type)
    build_cplus_array_type.  */
 
 static void
-set_array_type_canon (tree t, tree elt_type, tree index_type)
+set_array_type_canon (tree t, tree elt_type, tree index_type, bool dep)
 {
   /* Set the canonical type for this new node.  */
   if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
@@ -1009,30 +1009,33 @@ set_array_type_canon (tree t, tree elt_type, tree index_type)
     TYPE_CANONICAL (t)
       = build_cplus_array_type (TYPE_CANONICAL (elt_type),
                                index_type
-                               ? TYPE_CANONICAL (index_type) : index_type);
+                               ? TYPE_CANONICAL (index_type) : index_type,
+                               dep);
   else
     TYPE_CANONICAL (t) = t;
 }
 
 /* Like build_array_type, but handle special C++ semantics: an array of a
    variant element type is a variant of the array of the main variant of
-   the element type.  */
+   the element type.  IS_DEPENDENT is -ve if we should determine the
+   dependency.  Otherwise its bool value indicates dependency.  */
 
 tree
-build_cplus_array_type (tree elt_type, tree index_type)
+build_cplus_array_type (tree elt_type, tree index_type, int dependent)
 {
   tree t;
 
   if (elt_type == error_mark_node || index_type == error_mark_node)
     return error_mark_node;
 
-  bool dependent = (uses_template_parms (elt_type)
-                   || (index_type && uses_template_parms (index_type)));
+  if (dependent < 0)
+    dependent = (uses_template_parms (elt_type)
+                || (index_type && uses_template_parms (index_type)));
 
   if (elt_type != TYPE_MAIN_VARIANT (elt_type))
     /* Start with an array of the TYPE_MAIN_VARIANT.  */
     t = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
-                               index_type);
+                               index_type, dependent);
   else if (dependent)
     {
       /* Since type_hash_canon calls layout_type, we need to use our own
@@ -1062,7 +1065,11 @@ build_cplus_array_type (tree elt_type, tree index_type)
          *e = t;
 
          /* Set the canonical type for this new node.  */
-         set_array_type_canon (t, elt_type, index_type);
+         set_array_type_canon (t, elt_type, index_type, dependent);
+
+         /* Mark it as dependent now, this saves time later.  */
+         TYPE_DEPENDENT_P_VALID (t) = true;
+         TYPE_DEPENDENT_P (t) = true;
        }
     }
   else
@@ -1083,7 +1090,7 @@ build_cplus_array_type (tree elt_type, tree index_type)
       if (!t)
        {
          t = build_min_array_type (elt_type, index_type);
-         set_array_type_canon (t, elt_type, index_type);
+         set_array_type_canon (t, elt_type, index_type, dependent);
          if (!dependent)
            {
              layout_type (t);
@@ -1319,7 +1326,8 @@ cp_build_qualified_type_real (tree type,
 
       if (!t)
        {
-         t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
+         t = build_cplus_array_type (element_type, TYPE_DOMAIN (type),
+                                     TYPE_DEPENDENT_P (type));
 
          /* Keep the typedef name.  */
          if (TYPE_NAME (t) != TYPE_NAME (type))
@@ -1555,7 +1563,7 @@ strip_typedefs (tree t, bool *remove_attributes, unsigned int flags)
     case ARRAY_TYPE:
       type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
       t0  = strip_typedefs (TYPE_DOMAIN (t), remove_attributes, flags);
-      result = build_cplus_array_type (type, t0);
+      result = build_cplus_array_type (type, t0, TYPE_DEPENDENT_P (t));
       break;
     case FUNCTION_TYPE:
     case METHOD_TYPE: