/* Perform optimizations on tree structure.
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007
Free Software Foundation, Inc.
Written by Mark Michell (mark@codesourcery.com).
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)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful, but
General Public License for more details.
You should have received a copy of the GNU General Public License
-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. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "varray.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 (tree *, int *, void *);
-static void update_cloned_parm (tree, tree);
-
-/* Called from calls_setjmp_p via walk_tree. */
-
-static tree
-calls_setjmp_r (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 nonzero if FN calls `setjmp' or some other function that
- can return more than once. This function is conservative; it may
- occasionally return a nonzero value even when FN does not actually
- call `setjmp'. */
-
-bool
-calls_setjmp_p (tree fn)
-{
- return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
- calls_setjmp_r,
- NULL) != NULL_TREE;
-}
+static void update_cloned_parm (tree, tree, bool);
/* 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 (tree parm, tree cloned_parm)
+update_cloned_parm (tree parm, tree cloned_parm, bool first)
{
DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
/* The definition might have different constness. */
TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
-
- TREE_USED (cloned_parm) = TREE_USED (parm);
-
+
+ TREE_USED (cloned_parm) = !first || TREE_USED (parm);
+
/* The name may have changed from the declaration. */
DECL_NAME (cloned_parm) = DECL_NAME (parm);
DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
+ TREE_TYPE (cloned_parm) = TREE_TYPE (parm);
+
+ DECL_GIMPLE_REG_P (cloned_parm) = DECL_GIMPLE_REG_P (parm);
}
/* FN is a function that has a complete body. Clone the body as
maybe_clone_body (tree fn)
{
tree clone;
+ bool first = true;
/* 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))
+ push_to_top_level ();
+ FOR_EACH_CLONE (clone, fn)
{
tree parm;
tree clone_parm;
int parmno;
- splay_tree decl_map;
+ struct pointer_map_t *decl_map;
/* Update CLONE's source position information to match FN's. */
DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (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. */
parm = DECL_ARGUMENTS (fn);
clone_parm = DECL_ARGUMENTS (clone);
/* Update the `this' parameter, which is always first. */
- update_cloned_parm (parm, clone_parm);
+ update_cloned_parm (parm, clone_parm, first);
parm = TREE_CHAIN (parm);
clone_parm = TREE_CHAIN (clone_parm);
if (DECL_HAS_IN_CHARGE_PARM_P (fn))
for (; parm;
parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
/* Update this parameter. */
- update_cloned_parm (parm, clone_parm);
+ update_cloned_parm (parm, clone_parm, first);
/* 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);
+ decl_map = pointer_map_create ();
for (parmno = 0,
parm = DECL_ARGUMENTS (fn),
clone_parm = DECL_ARGUMENTS (clone);
{
tree in_charge;
in_charge = in_charge_arg_for_name (DECL_NAME (clone));
- splay_tree_insert (decl_map,
- (splay_tree_key) parm,
- (splay_tree_value) in_charge);
+ *pointer_map_insert (decl_map, parm) = in_charge;
}
else if (DECL_ARTIFICIAL (parm)
&& DECL_NAME (parm) == vtt_parm_identifier)
if (DECL_HAS_VTT_PARM_P (clone))
{
DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
- splay_tree_insert (decl_map,
- (splay_tree_key) parm,
- (splay_tree_value) clone_parm);
+ *pointer_map_insert (decl_map, parm) = clone_parm;
clone_parm = TREE_CHAIN (clone_parm);
}
/* Otherwise, map the VTT parameter to `NULL'. */
else
- {
- splay_tree_insert (decl_map,
- (splay_tree_key) parm,
- (splay_tree_value) null_pointer_node);
- }
+ *pointer_map_insert (decl_map, parm) = null_pointer_node;
}
/* Map other parameters to their equivalents in the cloned
function. */
else
{
- splay_tree_insert (decl_map,
- (splay_tree_key) parm,
- (splay_tree_value) clone_parm);
+ *pointer_map_insert (decl_map, parm) = clone_parm;
clone_parm = TREE_CHAIN (clone_parm);
}
}
+ if (targetm.cxx.cdtor_returns_this ())
+ {
+ parm = DECL_RESULT (fn);
+ clone_parm = DECL_RESULT (clone);
+ *pointer_map_insert (decl_map, parm) = clone_parm;
+ }
/* Clone the body. */
clone_body (clone, fn, decl_map);
/* Clean up. */
- splay_tree_delete (decl_map);
+ pointer_map_destroy (decl_map);
/* The clone can throw iff the original function can throw. */
cp_function_chain->can_throw = !TREE_NOTHROW (fn);
finish_function (0);
BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
expand_or_defer_fn (clone);
- pop_from_top_level ();
+ first = false;
}
+ pop_from_top_level ();
/* We don't need to process the original function any further. */
return 1;
OSDN Git Service
