c-common.h (add_decl_stmt): Move to cp-tree.h.

        * c-common.h (add_decl_stmt): Move to cp-tree.h.
        * c-decl.c (finish_decl): Don't use add_decl_stmt.
        * c-parse.in: Likewise.
        * c-gimplify.c (gimplify_expr_stmt): Don't build CLEANUP_POINT_EXPR.
        (gimplify_c_loop, gimplify_return_stmt, gimplify_decl_stmt): Likewise.
        * c-semantics.c (add_decl_stmt): Move to cp/semantics.c.
cp/
        * cp-tree.h (add_decl_stmt): Declare.
        * pt.c (tsubst_copy): Abort for CLEANUP_POINT_EXPR.
        * semantics.c (maybe_cleanup_point_expr): New.
        (add_decl_stmt, finish_expr_stmt, finish_return_stmt,
        finish_for_expr, finish_switch_cond): Use it.
        (finalize_nrv_r): Don't build an EXPR_STMT.  Don't frob TREE_CHAIN.

From-SVN: r83409

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index fd9f0ac0ee1e823b3ad3b0a4e07da8e809cf4828..b6e81ff99e89cebb7718fb433faed8f7becdb48e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2004-06-20  Richard Henderson  <rth@redhat.com>
+
+       * c-common.h (add_decl_stmt): Move to cp-tree.h.
+       * c-decl.c (finish_decl): Don't use add_decl_stmt.
+       * c-parse.in: Likewise.
+       * c-gimplify.c (gimplify_expr_stmt): Don't build CLEANUP_POINT_EXPR.
+       (gimplify_c_loop, gimplify_return_stmt, gimplify_decl_stmt): Likewise.
+       * c-semantics.c (add_decl_stmt): Move to cp/semantics.c.
+
 2004-06-20  Richard Henderson  <rth@redhat.com>
 
        * c-common.def (IF_STMT, CLEANUP_STMT): Move to cp-tree.def.

diff --git a/gcc/c-common.h b/gcc/c-common.h
index 073ff70e4ec9e303614c6b91f88c45536501db2d..f8d087b8dbd8f334dc42e2abb58ec214e8ef1bfd 100644 (file)
--- a/gcc/c-common.h
+++ b/gcc/c-common.h
@@ -294,7 +294,6 @@ extern tree push_stmt_list (void);
 extern tree re_push_stmt_list (tree);
 extern tree pop_stmt_list (tree);
 extern tree add_stmt (tree);
-extern void add_decl_stmt (tree);
 extern void push_cleanup (tree, tree, bool);
 
 extern tree walk_stmt_tree (tree *, walk_tree_fn, void *);

diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index cbf5795b83d9bbb602c1571d1b711ff21dcb8edb..aa23a9fa1670b7a2c64665da519ec4782d947d95 100644 (file)
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -2940,7 +2940,7 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
            }
 
          if (TREE_CODE (decl) != FUNCTION_DECL)
-           add_decl_stmt (decl);
+           add_stmt (build_stmt (DECL_STMT, decl));
        }
 
       if (!DECL_FILE_SCOPE_P (decl))
@@ -2967,7 +2967,7 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
     {
       if (!DECL_FILE_SCOPE_P (decl)
          && variably_modified_type_p (TREE_TYPE (decl)))
-       add_decl_stmt (decl);
+       add_stmt (build_stmt (DECL_STMT, decl));
 
       rest_of_decl_compilation (decl, NULL, DECL_FILE_SCOPE_P (decl), 0);
     }

diff --git a/gcc/c-gimplify.c b/gcc/c-gimplify.c
index fa3ea299cc47c8fd2c4425e4ded115f864c55f7f..57208e4c03f27b6ceda5c716aa3fa60cb18c9ff3 100644 (file)
--- a/gcc/c-gimplify.c
+++ b/gcc/c-gimplify.c
@@ -249,8 +249,6 @@ gimplify_expr_stmt (tree *stmt_p)
 
   if (stmt == NULL_TREE)
     stmt = build_empty_stmt ();
-  else if (stmts_are_full_exprs_p ())
-    stmt = build1 (CLEANUP_POINT_EXPR, void_type_node, stmt);
 
   *stmt_p = stmt;
 
@@ -383,8 +381,6 @@ gimplify_c_loop (tree cond, tree body, tree incr, bool cond_is_first)
   cont_block = begin_bc_block (bc_continue);
 
   gimplify_stmt (&body);
-  if (incr && stmts_are_full_exprs_p ())
-    incr = fold (build1 (CLEANUP_POINT_EXPR, void_type_node, incr));
   gimplify_stmt (&incr);
 
   body = finish_bc_block (cont_block, body);
@@ -483,8 +479,6 @@ gimplify_return_stmt (tree *stmt_p)
 {
   tree expr = RETURN_STMT_EXPR (*stmt_p);
   expr = build1 (RETURN_EXPR, void_type_node, expr);
-  if (stmts_are_full_exprs_p ())
-    expr = build1 (CLEANUP_POINT_EXPR, void_type_node, expr);
   *stmt_p = expr;
   return GS_OK;
 }
@@ -553,8 +547,6 @@ gimplify_decl_stmt (tree *stmt_p)
               
              DECL_INITIAL (decl) = NULL_TREE;
              init = build (MODIFY_EXPR, void_type_node, decl, init);
-             if (stmts_are_full_exprs_p ())
-               init = build1 (CLEANUP_POINT_EXPR, void_type_node, init);
              append_to_compound_expr (init, &pre);
            }
          else

diff --git a/gcc/c-parse.in b/gcc/c-parse.in
index d3e39af6858583f1a3d2e286f6a69f4b9315bf8e..02625a535bd9eca80cdad788b8de92a2f5306f03 100644 (file)
--- a/gcc/c-parse.in
+++ b/gcc/c-parse.in
@@ -1540,7 +1540,7 @@ nested_function:
                  add_stmt ($6);
                  finish_function ();
                  pop_function_context ();
-                 add_decl_stmt (decl); }
+                 add_stmt (build_stmt (DECL_STMT, decl)); }
        ;
 
 notype_nested_function:
@@ -1570,7 +1570,7 @@ notype_nested_function:
                  add_stmt ($6);
                  finish_function ();
                  pop_function_context ();
-                 add_decl_stmt (decl); }
+                 add_stmt (build_stmt (DECL_STMT, decl)); }
        ;
 
 /* Any kind of declarator (thus, all declarators allowed
@@ -2019,7 +2019,7 @@ label_decl:
                    {
                      tree label = declare_label (TREE_VALUE (link));
                      C_DECLARED_LABEL_FLAG (label) = 1;
-                     add_decl_stmt (label);
+                     add_stmt (build_stmt (DECL_STMT, label));
                    }
                }
        ;

diff --git a/gcc/c-semantics.c b/gcc/c-semantics.c
index ba4e90b491169292bd4aa4831bc115372650cf79..bda5161bbe4dcdbb83fd1bb2bd1d35c94eb64ff7 100644 (file)
--- a/gcc/c-semantics.c
+++ b/gcc/c-semantics.c
@@ -145,19 +145,6 @@ add_stmt (tree t)
   return t;
 }
 
-/* Create a declaration statement for the declaration given by the
-   DECL.  */
-
-void
-add_decl_stmt (tree decl)
-{
-  tree decl_stmt;
-
-  /* We need the type to last until instantiation time.  */
-  decl_stmt = build_stmt (DECL_STMT, decl);
-  add_stmt (decl_stmt);
-}
-
 /* Build a generic statement based on the given type of node and
    arguments. Similar to `build_nt', except that we set
    EXPR_LOCUS to be the current source location.  */

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index b01e1f8b49def8bfa893bd17f901127eadb1e656..4ec0ee6d18c438ece0ab12b65fb1f2b2f1a46a8d 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,12 @@
+2004-06-20  Richard Henderson  <rth@redhat.com>
+
+       * cp-tree.h (add_decl_stmt): Declare.
+       * pt.c (tsubst_copy): Abort for CLEANUP_POINT_EXPR.
+       * semantics.c (maybe_cleanup_point_expr): New.
+       (add_decl_stmt, finish_expr_stmt, finish_return_stmt,
+       finish_for_expr, finish_switch_cond): Use it.
+       (finalize_nrv_r): Don't build an EXPR_STMT.  Don't frob TREE_CHAIN.
+
 2004-06-20  Richard Henderson  <rth@redhat.com>
 
        * cp-tree.def (CLEANUP_STMT, IF_STMT): Move from c-common.def.

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index ae62adc70dd3c538f7d0409d629ed23f6a323165..9d668d398b76aeee812d104010cc2478ad810a27 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4028,6 +4028,7 @@ extern void pop_to_parent_deferring_access_checks (void);
 extern void perform_deferred_access_checks     (void);
 extern void perform_or_defer_access_check      (tree, tree);
 extern void init_cp_semantics                   (void);
+extern void add_decl_stmt                      (tree);
 extern tree finish_expr_stmt                    (tree);
 extern tree begin_if_stmt                       (void);
 extern void finish_if_stmt_cond                 (tree, tree);

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index a73ef189f62cc3eadbab7dc0a8012c6e86423af4..de4ab281b2537910c7e45b56e9a8305c3acd9c1b 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -7726,6 +7726,12 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
                                          in_decl),
                             tsubst (TREE_TYPE (t), args, complain, in_decl));
 
+    case CLEANUP_POINT_EXPR:
+      /* We shouldn't have built any of these during initial template
+        generation.  Instead, they should be built during instantiation
+        in response to the saved STMT_IS_FULL_EXPR_P setting.  */
+      abort ();
+
     default:
       return t;
     }

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index e53222f48b2b4723a213b264c9daac53e9a4fb69..92efe443a6d514fbff97674397f68f368ab45bee 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -304,6 +304,27 @@ current_stmt_tree (void)
          : &scope_chain->x_stmt_tree);
 }
 
+/* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR.  */
+
+static tree
+maybe_cleanup_point_expr (tree expr)
+{
+  if (!processing_template_decl && stmts_are_full_exprs_p ())
+    expr = fold (build1 (CLEANUP_POINT_EXPR, TREE_TYPE (expr), expr));
+  return expr;
+}
+
+/* Create a declaration statement for the declaration given by the DECL.  */
+
+void
+add_decl_stmt (tree decl)
+{
+  tree r = build_stmt (DECL_STMT, decl);
+  if (DECL_INITIAL (decl))
+    r = maybe_cleanup_point_expr (r);
+  add_stmt (r);
+}
+
 /* Nonzero if TYPE is an anonymous union or struct type.  We have to use a
    flag for this because "A union for which objects or pointers are
    declared is not an anonymous union" [class.union].  */
@@ -478,8 +499,13 @@ finish_expr_stmt (tree expr)
 
       /* Simplification of inner statement expressions, compound exprs,
         etc can result in the us already having an EXPR_STMT.  */
-      if (TREE_CODE (expr) != EXPR_STMT)
-       expr = build_stmt (EXPR_STMT, expr);
+      if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
+       {
+         if (TREE_CODE (expr) != EXPR_STMT)
+           expr = build_stmt (EXPR_STMT, expr);
+         expr = maybe_cleanup_point_expr (expr);
+       }
+
       r = add_stmt (expr);
     }
 
@@ -636,7 +662,10 @@ finish_return_stmt (tree expr)
          return finish_goto_stmt (dtor_label);
        }
     }
-  r = add_stmt (build_stmt (RETURN_STMT, expr));
+
+  r = build_stmt (RETURN_STMT, expr);
+  r = maybe_cleanup_point_expr (r);
+  r = add_stmt (r);
   finish_stmt ();
 
   return r;
@@ -690,13 +719,16 @@ finish_for_cond (tree cond, tree for_stmt)
 void
 finish_for_expr (tree expr, tree for_stmt)
 {
+  if (!expr)
+    return;
   /* If EXPR is an overloaded function, issue an error; there is no
      context available to use to perform overload resolution.  */
-  if (expr && type_unknown_p (expr))
+  if (type_unknown_p (expr))
     {
       cxx_incomplete_type_error (expr, TREE_TYPE (expr));
       expr = error_mark_node;
     }
+  expr = maybe_cleanup_point_expr (expr);
   FOR_EXPR (for_stmt) = expr;
 }
 
@@ -777,7 +809,7 @@ finish_switch_cond (tree cond, tree switch_stmt)
 
             Integral promotions are performed.  */
          cond = perform_integral_promotions (cond);
-         cond = fold (build1 (CLEANUP_POINT_EXPR, TREE_TYPE (cond), cond));
+         cond = maybe_cleanup_point_expr (cond);
        }
 
       if (cond != error_mark_node)
@@ -1499,8 +1531,7 @@ finish_stmt_expr (tree stmt_expr, bool has_no_scope)
       init = TREE_OPERAND (target_expr, 1);
       type = TREE_TYPE (init);
 
-      if (stmts_are_full_exprs_p ())
-       init = fold (build1 (CLEANUP_POINT_EXPR, type, init));
+      init = maybe_cleanup_point_expr (init);
       *result_stmt_p = init;
 
       if (VOID_TYPE_P (type))
@@ -2995,10 +3026,8 @@ finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
          DECL_INITIAL (dp->var) = error_mark_node;
        }
       else
-       init = NULL_TREE;
-      init = build_stmt (EXPR_STMT, init);
+       init = build_empty_stmt ();
       SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
-      TREE_CHAIN (init) = TREE_CHAIN (*tp);
       *tp = init;
     }
   /* And replace all uses of the NRV with the RESULT_DECL.  */