/* Perform optimizations on tree structure.
- Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004
+ Free Software Foundation, Inc.
Written by Mark Michell (mark@codesourcery.com).
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify it
+GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful, but
+GCC is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to the Free
+along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "tree.h"
#include "cp-tree.h"
#include "rtl.h"
#include "integrate.h"
#include "toplev.h"
#include "varray.h"
-#include "ggc.h"
#include "params.h"
#include "hashtab.h"
+#include "target.h"
#include "debug.h"
#include "tree-inline.h"
+#include "flags.h"
+#include "langhooks.h"
+#include "diagnostic.h"
+#include "tree-dump.h"
+#include "tree-gimple.h"
/* Prototypes. */
-static tree calls_setjmp_r PARAMS ((tree *, int *, void *));
-static void update_cloned_parm PARAMS ((tree, tree));
-static void dump_function PARAMS ((enum tree_dump_index, tree));
-
-/* Optimize the body of FN. */
-
-void
-optimize_function (fn)
- tree fn;
-{
- dump_function (TDI_original, fn);
-
- /* While in this function, we may choose to go off and compile
- another function. For example, we might instantiate a function
- in the hopes of inlining it. Normally, that wouldn't trigger any
- actual RTL code-generation -- but it will if the template is
- actually needed. (For example, if it's address is taken, or if
- some other function already refers to the template.) If
- code-generation occurs, then garbage collection will occur, so we
- must protect ourselves, just as we do while building up the body
- of the function. */
- ++function_depth;
-
- if (flag_inline_trees
- /* We do not inline thunks, as (a) the backend tries to optimize
- the call to the thunkee, (b) tree based inlining breaks that
- optimization, (c) virtual functions are rarely inlineable,
- and (d) ASM_OUTPUT_MI_THUNK is there to DTRT anyway. */
- && !DECL_THUNK_P (fn))
- {
- optimize_inline_calls (fn);
-
- dump_function (TDI_inlined, fn);
- }
-
- /* Undo the call to ggc_push_context above. */
- --function_depth;
-
- dump_function (TDI_optimized, fn);
-}
-
-/* Called from calls_setjmp_p via walk_tree. */
-
-static tree
-calls_setjmp_r (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
-{
- /* We're only interested in FUNCTION_DECLS. */
- if (TREE_CODE (*tp) != FUNCTION_DECL)
- return NULL_TREE;
-
- return setjmp_call_p (*tp) ? *tp : NULL_TREE;
-}
-
-/* Returns non-zero if FN calls `setjmp' or some other function that
- can return more than once. This function is conservative; it may
- occasionally return a non-zero value even when FN does not actually
- call `setjmp'. */
-
-int
-calls_setjmp_p (fn)
- tree fn;
-{
- return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
- calls_setjmp_r,
- NULL) != NULL_TREE;
-}
+static void update_cloned_parm (tree, tree);
/* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
or destructor. Update it to ensure that the source-position for
debugging generation code will be able to find the original PARM. */
static void
-update_cloned_parm (parm, cloned_parm)
- tree parm;
- tree cloned_parm;
+update_cloned_parm (tree parm, tree cloned_parm)
{
DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
- /* We may have taken its address. */
+ /* We may have taken its address. */
TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
- /* The definition might have different constness. */
+ /* The definition might have different constness. */
TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
TREE_USED (cloned_parm) = TREE_USED (parm);
- /* The name may have changed from the declaration. */
+ /* The name may have changed from the declaration. */
DECL_NAME (cloned_parm) = DECL_NAME (parm);
DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
}
/* FN is a function that has a complete body. Clone the body as
- necessary. Returns non-zero if there's no longer any need to
+ necessary. Returns nonzero if there's no longer any need to
process the main body. */
-int
-maybe_clone_body (fn)
- tree fn;
+bool
+maybe_clone_body (tree fn)
{
tree clone;
- int first = 1;
/* We only clone constructors and destructors. */
if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
/* We know that any clones immediately follow FN in the TYPE_METHODS
list. */
- for (clone = TREE_CHAIN (fn);
- clone && DECL_CLONED_FUNCTION_P (clone);
- clone = TREE_CHAIN (clone), first = 0)
+ push_to_top_level ();
+ FOR_EACH_CLONE (clone, fn)
{
tree parm;
tree clone_parm;
DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
+ DECL_VISIBILITY (clone) = DECL_VISIBILITY (fn);
+ DECL_VISIBILITY_SPECIFIED (clone) = DECL_VISIBILITY_SPECIFIED (fn);
- /* Adjust the parameter names and locations. */
+ /* Adjust the parameter names and locations. */
parm = DECL_ARGUMENTS (fn);
clone_parm = DECL_ARGUMENTS (clone);
/* Update the `this' parameter, which is always first. */
clone_parm = TREE_CHAIN (clone_parm);
for (; parm;
parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
- {
- /* Update this parameter. */
- update_cloned_parm (parm, clone_parm);
- /* We should only give unused information for one clone. */
- if (!first)
- TREE_USED (clone_parm) = 1;
- }
+ /* Update this parameter. */
+ update_cloned_parm (parm, clone_parm);
/* Start processing the function. */
- push_to_top_level ();
- start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
+ start_preparsed_function (clone, NULL_TREE, SF_PRE_PARSED);
/* Remap the parameters. */
decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
}
}
+ if (targetm.cxx.cdtor_returns_this ())
+ {
+ parm = DECL_RESULT (fn);
+ clone_parm = DECL_RESULT (clone);
+ splay_tree_insert (decl_map, (splay_tree_key) parm,
+ (splay_tree_value) clone_parm);
+ }
/* Clone the body. */
clone_body (clone, fn, decl_map);
- /* There are as many statements in the clone as in the
- original. */
- DECL_NUM_STMTS (clone) = DECL_NUM_STMTS (fn);
-
/* Clean up. */
splay_tree_delete (decl_map);
+ /* The clone can throw iff the original function can throw. */
+ cp_function_chain->can_throw = !TREE_NOTHROW (fn);
+
/* Now, expand this function into RTL, if appropriate. */
finish_function (0);
BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
- expand_body (clone);
- pop_from_top_level ();
+ expand_or_defer_fn (clone);
}
+ pop_from_top_level ();
/* We don't need to process the original function any further. */
return 1;
}
-
-/* Dump FUNCTION_DECL FN as tree dump PHASE. */
-
-static void
-dump_function (phase, fn)
- enum tree_dump_index phase;
- tree fn;
-{
- FILE *stream;
- int flags;
-
- stream = dump_begin (phase, &flags);
- if (stream)
- {
- fprintf (stream, "\n;; Function %s",
- decl_as_string (fn, TFF_DECL_SPECIFIERS));
- fprintf (stream, " (%s)\n",
- decl_as_string (DECL_ASSEMBLER_NAME (fn), 0));
- fprintf (stream, ";; enabled by -%s\n", dump_flag_name (phase));
- fprintf (stream, "\n");
-
- dump_node (fn, TDF_SLIM | flags, stream);
- dump_end (phase, stream);
- }
-}