60th Cygnus<->FSF merge

From-SVN: r9230

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 331e139..dc5ee69 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,44 @@
+Fri Mar 24 12:11:24 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+       * decl.c (duplicate_decls): Propagate DECL_ABSTRACT_VIRTUAL_P.
+
+       * pt.c (push_tinst_level): Complain if template instantiation depth
+       is greater than max_tinst_depth.
+
+       * typeck.c (common_type): Assume that we can call common_type to
+       unify the target type of a pointer.
+
+Thu Mar 23 00:48:44 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+       * decl2.c (finish_file): Don't synthesize methods at
+       finish_vtable_prevardecl time.  Do synthesize methods that are not
+       used, but are public and not external.
+
+       * cvt.c (build_type_conversion): Only give an error if for_sure.
+
+       * typeck.c (comp_target_types): Only support pointer conversions if
+       nptrs > 0.
+
+Wed Mar 22 19:30:15 1995  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+       * init.c (build_new): Catch use of an initializer list where it
+       shouldn't be.
+
+Wed Mar 22 16:21:07 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+       * init.c (build_new): Wrap alloc_expr in an RTL_EXPR if nelts is
+       non-constant.
+
+       * decl2.c: temp_name_counter is now public.
+
+       * decl.c (struct cp_function): Add temp_name_counter field.
+       (push_cp_function_context): Save it.
+       (pop_cp_function_context): Restore it.
+
+       * typeck.c (common_type): Handle unifying function types, and unify
+       unmatched things to void* with a compiler_error, rather than
+       silently like before.
+
 Wed Mar 22 15:10:34 1995  Mike Stump  <mrs@cygnus.com>
 
        * decl2.c (finish_prevtable_vardecl, finish_vtable_vardecl): Revert

diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 7e880b4..89f5914 100644 (file)
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -1560,10 +1560,13 @@ build_type_conversion (code, xtype, expr, for_sure)
        {
          if (winner)
            {
-             cp_error ("ambiguous conversion from `%T' to `%T'", basetype,
-                       xtype);
-             cp_error ("  candidate conversions include `%T' and `%T'",
-                       TREE_VALUE (winner), TREE_VALUE (conv));
+             if (for_sure)
+               {
+                 cp_error ("ambiguous conversion from `%T' to `%T'", basetype,
+                           xtype);
+                 cp_error ("  candidate conversions include `%T' and `%T'",
+                           TREE_VALUE (winner), TREE_VALUE (conv));
+               }
              return NULL_TREE;
            }
          else

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index c9865e3..15bb2e0 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -2356,6 +2356,7 @@ duplicate_decls (newdecl, olddecl)
        DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
+      DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
     }
 
   /* Deal with C++: must preserve virtual function table size.  */
@@ -12216,6 +12217,7 @@ struct cp_function
   int assigns_this;
   int just_assigned_this;
   int parms_stored;
+  int temp_name_counter;
   tree named_labels;
   tree shadowed_labels;
   tree ctor_label;
@@ -12229,6 +12231,8 @@ struct cp_function
 
 struct cp_function *cp_function_chain;
 
+extern int temp_name_counter;
+
 /* Save and reinitialize the variables
    used during compilation of a C++ function.  */
 
@@ -12259,6 +12263,7 @@ push_cp_function_context (context)
   p->result_rtx = original_result_rtx;
   p->base_init_insns = base_init_insns;
   p->protect_list = protect_list;
+  p->temp_name_counter = temp_name_counter;
 }
 
 /* Restore the variables used during compilation of a C++ function.  */
@@ -12306,6 +12311,7 @@ pop_cp_function_context (context)
   current_function_parms_stored = p->parms_stored;
   original_result_rtx = p->result_rtx;
   base_init_insns = p->base_init_insns;
+  temp_name_counter = p->temp_name_counter;
 
   free (p);
 }

diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 633fc8b..55ad97e 100644 (file)
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -55,7 +55,7 @@ static tree saved_inlines;
 /* Used to help generate temporary names which are unique within
    a function.  Reset to 0 by start_function.  */
 
-static int temp_name_counter;
+int temp_name_counter;
 
 /* Same, but not reset.  Local temp variables and global temp variables
    can have the same name.  */
@@ -2861,16 +2861,6 @@ finish_file ()
   /* Walk to mark the inline functions we need, then output them so
      that we can pick up any other tdecls that those routines need. */
   walk_vtables ((void (*)())0, finish_prevtable_vardecl);
-  for (vars = saved_inlines; vars; vars = TREE_CHAIN (vars))
-    {
-      tree decl = TREE_VALUE (vars);
-
-      if (DECL_ARTIFICIAL (decl)
-         && ! DECL_INITIAL (decl)
-         && (TREE_USED (decl) || ! DECL_EXTERNAL (decl)))
-       synthesize_method (decl);
-    }
-  walk_vtables ((void (*)())0, finish_prevtable_vardecl);
 
   if (needs_cleaning == 0)
     goto mess_up;
@@ -3103,7 +3093,8 @@ finish_file ()
 
            if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl))
              {
-               if (TREE_USED (decl))
+               if (TREE_USED (decl)
+                   || (TREE_PUBLIC (decl) && ! DECL_EXTERNAL (decl)))
                  synthesize_method (decl);
                else
                  {

diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 3737613..8dfbc31 100644 (file)
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -3091,6 +3091,11 @@ build_new (placement, decl, init, use_global_new)
 
          if (TREE_CHAIN (init) != NULL_TREE)
            pedwarn ("initializer list being treated as compound expression");
+         else if (TREE_CODE (init) == CONSTRUCTOR)
+           {
+             pedwarn ("initializer list appears where operand should be used");
+             init = TREE_OPERAND (init, 1);
+           }
          init = build_compound_expr (init);
 
          init = convert_for_initialization (deref, type, init, LOOKUP_NORMAL,
@@ -3150,6 +3155,29 @@ build_new (placement, decl, init, use_global_new)
             can't easily know the latter, just do it always.  */
          tree xval = make_node (RTL_EXPR);
 
+         /* If we want to check the value of the allocation expression,
+             and the number of elements in the array is not a constant, we
+             *must* expand the SAVE_EXPR for nelts in alloc_expr before we
+             expand it in the actual initalization.  So we need to build up
+             an RTL_EXPR for alloc_expr.  Sigh.  */
+         if (alloc_expr && ! TREE_CONSTANT (nelts))
+           {
+             tree xval = make_node (RTL_EXPR);
+             rtx rtxval;
+             TREE_TYPE (xval) = TREE_TYPE (alloc_expr);
+             do_pending_stack_adjust ();
+             start_sequence_for_rtl_expr (xval);
+             emit_note (0, -1);
+             rtxval = expand_expr (alloc_expr, NULL, VOIDmode, 0);
+             do_pending_stack_adjust ();
+             TREE_SIDE_EFFECTS (xval) = 1;
+             RTL_EXPR_SEQUENCE (xval) = get_insns ();
+             end_sequence ();
+             RTL_EXPR_RTL (xval) = rtxval;
+             TREE_TYPE (xval) = TREE_TYPE (alloc_expr);
+             alloc_expr = xval;
+           }
+
          TREE_TYPE (xval) = TREE_TYPE (rval);
          do_pending_stack_adjust ();
          start_sequence_for_rtl_expr (xval);

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index e05265a..ce5e4f8 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -924,16 +924,26 @@ instantiate_member_templates (classname)
     }
 }
 
-struct tinst_level *current_tinst_level = 0;
-struct tinst_level *free_tinst_level = 0;
+static struct tinst_level *current_tinst_level = 0;
+static struct tinst_level *free_tinst_level = 0;
+static int tinst_depth = 0;
+int max_tinst_depth = 17;
 
-void
+int
 push_tinst_level (name)
      tree name;
 {
   struct tinst_level *new;
   tree global = IDENTIFIER_GLOBAL_VALUE (name);
 
+  if (tinst_depth >= max_tinst_depth)
+    {
+      error ("template instantiation depth exceeds maximum of %d",
+            max_tinst_depth);
+      cp_error ("  instantiating `%D'", name);
+      return 0;
+    }
+
   if (free_tinst_level)
     {
       new = free_tinst_level;
@@ -955,6 +965,8 @@ push_tinst_level (name)
     }
   new->next = current_tinst_level;
   current_tinst_level = new;
+  ++tinst_depth;
+  return 1;
 }
 
 void
@@ -965,6 +977,7 @@ pop_tinst_level ()
   current_tinst_level = old->next;
   old->next = free_tinst_level;
   free_tinst_level = old;
+  --tinst_depth;
 }
 
 struct tinst_level *
@@ -1040,9 +1053,8 @@ instantiate_class_template (classname, setup_parse)
 
   push_to_top_level ();
   template_info = DECL_TEMPLATE_INFO (t1);
-  if (setup_parse)
+  if (setup_parse && push_tinst_level (classname))
     {
-      push_tinst_level (classname);
       push_template_decls (DECL_TEMPLATE_PARMS (TREE_PURPOSE (template)),
                           TREE_VALUE (template), 0);
       set_current_level_tags_transparency (1);

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 2467882..b8cf968 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -379,13 +379,10 @@ common_type (t1, t2)
 
        if (tt1 == tt2)
          target = tt1;
-       else if ((IS_AGGR_TYPE_CODE (TREE_CODE (tt1))
-                 || TREE_CODE (tt1) == OFFSET_TYPE
-                 || TREE_CODE (tt1) == METHOD_TYPE)
-                && TREE_CODE (tt2) == TREE_CODE (tt1))
-         target = common_type (tt1, tt2);
-       else
+       else if (tt1 == void_type_node || tt2 == void_type_node)
          target = void_type_node;
+       else
+         target = common_type (tt1, tt2);
 
        target = cp_build_type_variant (target, constp, volatilep);
        if (code1 == POINTER_TYPE)
@@ -775,27 +772,32 @@ comp_target_types (ttl, ttr, nptrs)
   if (ttl == ttr)
     return 1;
 
-  if (TREE_CODE (ttl) == VOID_TYPE
-      && TREE_CODE (ttr) != FUNCTION_TYPE
-      && TREE_CODE (ttr) != METHOD_TYPE
-      && TREE_CODE (ttr) != OFFSET_TYPE)
-    return 1;
-  if (TREE_CODE (ttr) == VOID_TYPE
-      && TREE_CODE (ttl) != FUNCTION_TYPE
-      && TREE_CODE (ttl) != METHOD_TYPE
-      && TREE_CODE (ttl) != OFFSET_TYPE)
-    return -1;
-  
   if (TREE_CODE (ttr) != TREE_CODE (ttl))
     return 0;
 
   if (TREE_CODE (ttr) == POINTER_TYPE)
     {
-      if (TREE_CODE (TREE_TYPE (ttl)) == POINTER_TYPE
-         || TREE_CODE (TREE_TYPE (ttl)) == ARRAY_TYPE)
-       return comp_ptr_ttypes (TREE_TYPE (ttl), TREE_TYPE (ttr));
-      else
-       return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs - 1);
+      ttl = TREE_TYPE (ttl);
+      ttr = TREE_TYPE (ttr);
+
+      if (nptrs > 0)
+       {
+         if (TREE_CODE (ttl) == POINTER_TYPE
+             || TREE_CODE (ttl) == ARRAY_TYPE)
+           return comp_ptr_ttypes (ttl, ttr);
+         else if (TREE_CODE (ttl) == VOID_TYPE
+                  && TREE_CODE (ttr) != FUNCTION_TYPE
+                  && TREE_CODE (ttr) != METHOD_TYPE
+                  && TREE_CODE (ttr) != OFFSET_TYPE)
+           return 1;
+         else if (TREE_CODE (ttr) == VOID_TYPE
+                  && TREE_CODE (ttl) != FUNCTION_TYPE
+                  && TREE_CODE (ttl) != METHOD_TYPE
+                  && TREE_CODE (ttl) != OFFSET_TYPE)
+           return -1;
+       }
+
+      return comp_target_types (ttl, ttr, nptrs - 1);
     }
 
   if (TREE_CODE (ttr) == REFERENCE_TYPE)