X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=gcc%2Fcp%2Foptimize.c;fp=gcc%2Fcp%2Foptimize.c;h=8c7b9e82ccb5cbcc700dfe3d42651b953a09a11b;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=ac51cda4963cf6872988faa0954616e6b3fb2b32;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git diff --git a/gcc/cp/optimize.c b/gcc/cp/optimize.c index ac51cda4..8c7b9e82 100644 --- a/gcc/cp/optimize.c +++ b/gcc/cp/optimize.c @@ -1,26 +1,28 @@ /* Perform optimizations on tree structure. - Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008 + 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) +the Free Software Foundation; either version 3, 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 -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "tree.h" #include "cp-tree.h" #include "rtl.h" @@ -29,83 +31,20 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #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 "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, bool); /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor or destructor. Update it to ensure that the source-position for @@ -113,36 +52,71 @@ calls_setjmp_p (fn) 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, bool first) { 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. */ + + 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_FILE (cloned_parm) = DECL_SOURCE_FILE (parm); - DECL_SOURCE_LINE (cloned_parm) = DECL_SOURCE_LINE (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 in High GIMPLE form that has a complete body and no + CFG. CLONE is a function whose body is to be set to a copy of FN, + mapping argument declarations according to the ARG_MAP splay_tree. */ + +static void +clone_body (tree clone, tree fn, void *arg_map) +{ + copy_body_data id; + gimple_seq new_body; + + /* FN must already be in GIMPLE form. */ + gcc_assert (gimple_body (fn)); + + /* Clone the body, as if we were making an inline call. But, remap + the parameters in the callee to the parameters of caller. */ + memset (&id, 0, sizeof (id)); + id.src_fn = fn; + id.dst_fn = clone; + id.src_cfun = DECL_STRUCT_FUNCTION (fn); + id.decl_map = (struct pointer_map_t *) arg_map; + + id.copy_decl = copy_decl_no_change; + id.transform_call_graph_edges = CB_CGE_DUPLICATE; + id.transform_new_cfg = true; + id.transform_return_to_modify = false; + id.transform_lang_insert_block = NULL; + + /* We're not inside any EH region. */ + id.eh_region = -1; + + /* Actually copy the body. */ + new_body = remap_gimple_seq (gimple_body (fn), &id); + gimple_set_body (clone, new_body); } /* 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; + bool first = true; /* We only clone constructors and destructors. */ if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn) @@ -154,19 +128,16 @@ maybe_clone_body (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; int parmno; - splay_tree decl_map; + struct pointer_map_t *decl_map; /* Update CLONE's source position information to match FN's. */ - DECL_SOURCE_FILE (clone) = DECL_SOURCE_FILE (fn); - DECL_SOURCE_LINE (clone) = DECL_SOURCE_LINE (fn); - DECL_INLINE (clone) = DECL_INLINE (fn); + DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn); DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn); DECL_COMDAT (clone) = DECL_COMDAT (fn); DECL_WEAK (clone) = DECL_WEAK (fn); @@ -177,12 +148,15 @@ maybe_clone_body (fn) 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); + DECL_DLLIMPORT_P (clone) = DECL_DLLIMPORT_P (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. */ - 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)) @@ -193,20 +167,14 @@ maybe_clone_body (fn) 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, 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); @@ -219,9 +187,7 @@ maybe_clone_body (fn) { 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) @@ -232,72 +198,46 @@ maybe_clone_body (fn) 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); - /* 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); + pointer_map_destroy (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 (); + DECL_SAVED_TREE (clone) = NULL; + expand_or_defer_fn (clone); + first = false; } + 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); - } -}