X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssanames.c;h=46fa42029ce8b13dee29acf29433311679ee8852;hb=f06d9be53124a28b9aa52388b3738a999ca84b59;hp=f48c4a0de7ae149b1af6f9e2bfdce7d670e93ce6;hpb=bb445479def5c8fcb62ba57aa917feec3228322c;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c index f48c4a0de7a..46fa42029ce 100644 --- a/gcc/tree-ssanames.c +++ b/gcc/tree-ssanames.c @@ -1,23 +1,23 @@ /* Generic routines for manipulating SSA_NAME expressions - Copyright (C) 2003 Free Software Foundation, Inc. - + Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 + Free Software Foundation, Inc. + This file is part of GCC. - + 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 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 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 +. */ + #include "config.h" #include "system.h" #include "coretypes.h" @@ -26,10 +26,11 @@ Boston, MA 02111-1307, USA. */ #include "varray.h" #include "ggc.h" #include "tree-flow.h" +#include "tree-pass.h" /* Rewriting a function into SSA form can create a huge number of SSA_NAMEs, many of which may be thrown away shortly after their creation if jumps - were threaded through PHI nodes. + were threaded through PHI nodes. While our garbage collection mechanisms will handle this situation, it is extremely wasteful to create nodes and throw them away, especially @@ -43,7 +44,7 @@ Boston, MA 02111-1307, USA. */ Right now we maintain our free list on a per-function basis. It may or may not make sense to maintain the free list for the duration of - a compilation unit. + a compilation unit. External code should rely solely upon HIGHEST_SSA_VERSION and the externally defined functions. External code should not know about @@ -57,16 +58,6 @@ Boston, MA 02111-1307, USA. */ We could also use a zone allocator for these objects since they have a very well defined lifetime. If someone wants to experiment with that this is the place to try it. */ - -/* Array of all SSA_NAMEs used in the function. */ -varray_type ssa_names; - -/* Bitmap of ssa names marked for rewriting. */ -bitmap ssa_names_to_rewrite; - -/* Free list of SSA_NAMEs. This list is wiped at the end of each function - after we leave SSA form. */ -static GTY (()) tree free_ssanames; /* Version numbers with special meanings. We start allocating new version numbers after the special ones. */ @@ -77,77 +68,28 @@ unsigned int ssa_name_nodes_reused; unsigned int ssa_name_nodes_created; #endif -/* Returns true if ssa name VAR is marked for rewrite. */ - -bool -marked_for_rewrite_p (tree var) -{ - if (ssa_names_to_rewrite - && bitmap_bit_p (ssa_names_to_rewrite, SSA_NAME_VERSION (var))) - return true; - - return false; -} - -/* Returns true if any ssa name is marked for rewrite. */ - -bool -any_marked_for_rewrite_p (void) -{ - if (!ssa_names_to_rewrite) - return false; - - return bitmap_first_set_bit (ssa_names_to_rewrite) != -1; -} - -/* Mark ssa name VAR for rewriting. */ - -void -mark_for_rewrite (tree var) -{ - if (!ssa_names_to_rewrite) - ssa_names_to_rewrite = BITMAP_XMALLOC (); - - bitmap_set_bit (ssa_names_to_rewrite, SSA_NAME_VERSION (var)); -} - -/* Unmark all ssa names marked for rewrite. */ +/* Initialize management of SSA_NAMEs to default SIZE. If SIZE is + zero use default. */ void -unmark_all_for_rewrite (void) +init_ssanames (struct function *fn, int size) { - if (!ssa_names_to_rewrite) - return; + if (size < 50) + size = 50; - bitmap_clear (ssa_names_to_rewrite); -} - -/* Return the bitmap of ssa names to rewrite. Copy the bitmap, - so that the optimizers cannot access internals directly */ - -bitmap -marked_ssa_names (void) -{ - bitmap ret = BITMAP_XMALLOC (); - if (ssa_names_to_rewrite) - bitmap_copy (ret, ssa_names_to_rewrite); - - return ret; -} - -/* Initialize management of SSA_NAMEs. */ - -void -init_ssanames (void) -{ - VARRAY_TREE_INIT (ssa_names, 50, "ssa_names table"); + SSANAMES (fn) = VEC_alloc (tree, gc, size); /* Version 0 is special, so reserve the first slot in the table. Though currently unused, we may use version 0 in alias analysis as part of the heuristics used to group aliases when the alias sets are too - large. */ - VARRAY_PUSH_TREE (ssa_names, NULL_TREE); - free_ssanames = NULL; + large. + + We use VEC_quick_push here because we know that SSA_NAMES has at + least 50 elements reserved in it. */ + VEC_quick_push (tree, SSANAMES (fn), NULL_TREE); + FREE_SSANAMES (fn) = NULL; + + SYMS_TO_RENAME (fn) = BITMAP_GGC_ALLOC (); } /* Finalize management of SSA_NAMEs. */ @@ -155,7 +97,8 @@ init_ssanames (void) void fini_ssanames (void) { - free_ssanames = NULL; + VEC_free (tree, gc, SSANAMES (cfun)); + FREE_SSANAMES (cfun) = NULL; } /* Dump some simple statistics regarding the re-use of SSA_NAME nodes. */ @@ -169,50 +112,38 @@ ssanames_print_statistics (void) } #endif -/* Return an SSA_NAME node for variable VAR defined in statement STMT. - STMT may be an empty statement for artificial references (e.g., default - definitions created when a variable is used without a preceding - definition). */ +/* Return an SSA_NAME node for variable VAR defined in statement STMT + in function FN. STMT may be an empty statement for artificial + references (e.g., default definitions created when a variable is + used without a preceding definition). */ tree -make_ssa_name (tree var, tree stmt) +make_ssa_name_fn (struct function *fn, tree var, gimple stmt) { tree t; + use_operand_p imm; -#if defined ENABLE_CHECKING - if ((!DECL_P (var) - && TREE_CODE (var) != INDIRECT_REF) - || (stmt - && !IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (stmt))) - && TREE_CODE (stmt) != PHI_NODE)) - abort (); -#endif + gcc_assert (DECL_P (var)); - /* If our free list has an element, then use it. Also reuse the - SSA version number of the element on the free list which helps - keep sbitmaps and arrays sized HIGHEST_SSA_VERSION smaller. */ - if (free_ssanames) + /* If our free list has an element, then use it. */ + if (FREE_SSANAMES (fn)) { - unsigned int save_version; - - t = free_ssanames; - free_ssanames = TREE_CHAIN (free_ssanames); + t = FREE_SSANAMES (fn); + FREE_SSANAMES (fn) = TREE_CHAIN (FREE_SSANAMES (fn)); #ifdef GATHER_STATISTICS ssa_name_nodes_reused++; #endif - /* Clear the node so that it looks just like one we would have - received from make_node. */ - save_version = SSA_NAME_VERSION (t); - memset (t, 0, tree_size (t)); - TREE_SET_CODE (t, SSA_NAME); - SSA_NAME_VERSION (t) = save_version; + /* The node was cleared out when we put it on the free list, so + there is no need to do so again here. */ + gcc_assert (ssa_name (SSA_NAME_VERSION (t)) == NULL); + VEC_replace (tree, SSANAMES (fn), SSA_NAME_VERSION (t), t); } else { t = make_node (SSA_NAME); - SSA_NAME_VERSION (t) = num_ssa_names; - VARRAY_PUSH_TREE (ssa_names, t); + SSA_NAME_VERSION (t) = VEC_length (tree, SSANAMES (fn)); + VEC_safe_push (tree, gc, SSANAMES (fn), t); #ifdef GATHER_STATISTICS ssa_name_nodes_created++; #endif @@ -223,13 +154,19 @@ make_ssa_name (tree var, tree stmt) SSA_NAME_DEF_STMT (t) = stmt; SSA_NAME_PTR_INFO (t) = NULL; SSA_NAME_IN_FREE_LIST (t) = 0; + SSA_NAME_IS_DEFAULT_DEF (t) = 0; + imm = &(SSA_NAME_IMM_USE_NODE (t)); + imm->use = NULL; + imm->prev = imm; + imm->next = imm; + imm->loc.ssa_name = t; return t; } /* We no longer need the SSA_NAME expression VAR, release it so that - it may be reused. + it may be reused. Note it is assumed that no calls to make_ssa_name will be made until all uses of the ssa name are released and that the only @@ -239,82 +176,123 @@ make_ssa_name (tree var, tree stmt) void release_ssa_name (tree var) { + if (!var) + return; + /* Never release the default definition for a symbol. It's a special SSA name that should always exist once it's created. */ - if (var == var_ann (SSA_NAME_VAR (var))->default_def) + if (SSA_NAME_IS_DEFAULT_DEF (var)) return; - /* If the ssa name is marked for rewriting, it may have multiple definitions, - but we may happen to remove just one of them. So do not remove the - ssa name now. */ - if (marked_for_rewrite_p (var)) - return; + /* If VAR has been registered for SSA updating, don't remove it. + After update_ssa has run, the name will be released. */ + if (name_registered_for_update_p (var)) + { + release_ssa_name_after_update_ssa (var); + return; + } /* release_ssa_name can be called multiple times on a single SSA_NAME. However, it should only end up on our free list one time. We keep a status bit in the SSA_NAME node itself to indicate it has - been put on the free list. + been put on the free list. Note that once on the freelist you can not reference the SSA_NAME's defining statement. */ if (! SSA_NAME_IN_FREE_LIST (var)) { + tree saved_ssa_name_var = SSA_NAME_VAR (var); + int saved_ssa_name_version = SSA_NAME_VERSION (var); + use_operand_p imm = &(SSA_NAME_IMM_USE_NODE (var)); + + if (MAY_HAVE_DEBUG_STMTS) + insert_debug_temp_for_var_def (NULL, var); + +#ifdef ENABLE_CHECKING + verify_imm_links (stderr, var); +#endif + while (imm->next != imm) + delink_imm_use (imm->next); + + VEC_replace (tree, SSANAMES (cfun), + SSA_NAME_VERSION (var), NULL_TREE); + memset (var, 0, tree_size (var)); + + imm->prev = imm; + imm->next = imm; + imm->loc.ssa_name = var; + + /* First put back the right tree node so that the tree checking + macros do not complain. */ + TREE_SET_CODE (var, SSA_NAME); + + /* Restore the version number. */ + SSA_NAME_VERSION (var) = saved_ssa_name_version; + + /* Hopefully this can go away once we have the new incremental + SSA updating code installed. */ + SSA_NAME_VAR (var) = saved_ssa_name_var; + + /* Note this SSA_NAME is now in the first list. */ SSA_NAME_IN_FREE_LIST (var) = 1; - TREE_CHAIN (var) = free_ssanames; - free_ssanames = var; + + /* And finally link it into the free list. */ + TREE_CHAIN (var) = FREE_SSANAMES (cfun); + FREE_SSANAMES (cfun) = var; } } /* Creates a duplicate of a ssa name NAME defined in statement STMT. */ tree -duplicate_ssa_name (tree name, tree stmt) +duplicate_ssa_name (tree name, gimple stmt) { tree new_name = make_ssa_name (SSA_NAME_VAR (name), stmt); struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name); + + if (old_ptr_info) + duplicate_ssa_name_ptr_info (new_name, old_ptr_info); + + return new_name; +} + + +/* Creates a duplicate of the ptr_info_def at PTR_INFO for use by + the SSA name NAME. */ + +void +duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info) +{ struct ptr_info_def *new_ptr_info; - if (!old_ptr_info) - return new_name; + gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); + gcc_assert (!SSA_NAME_PTR_INFO (name)); - new_ptr_info = ggc_alloc (sizeof (struct ptr_info_def)); - *new_ptr_info = *old_ptr_info; + if (!ptr_info) + return; - if (old_ptr_info->pt_vars) - { - new_ptr_info->pt_vars = BITMAP_GGC_ALLOC (); - bitmap_copy (new_ptr_info->pt_vars, old_ptr_info->pt_vars); - } + new_ptr_info = GGC_NEW (struct ptr_info_def); + *new_ptr_info = *ptr_info; - SSA_NAME_PTR_INFO (new_name) = new_ptr_info; - return new_name; + SSA_NAME_PTR_INFO (name) = new_ptr_info; } /* Release all the SSA_NAMEs created by STMT. */ void -release_defs (tree stmt) +release_defs (gimple stmt) { - size_t i; - v_may_def_optype v_may_defs; - v_must_def_optype v_must_defs; - def_optype defs; - stmt_ann_t ann; - - ann = stmt_ann (stmt); - defs = DEF_OPS (ann); - v_may_defs = V_MAY_DEF_OPS (ann); - v_must_defs = V_MUST_DEF_OPS (ann); + tree def; + ssa_op_iter iter; - for (i = 0; i < NUM_DEFS (defs); i++) - release_ssa_name (DEF_OP (defs, i)); + /* Make sure that we are in SSA. Otherwise, operand cache may point + to garbage. */ + gcc_assert (gimple_in_ssa_p (cfun)); - for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++) - release_ssa_name (V_MAY_DEF_RESULT (v_may_defs, i)); - - for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++) - release_ssa_name (V_MUST_DEF_OP (v_must_defs, i)); + FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS) + if (TREE_CODE (def) == SSA_NAME) + release_ssa_name (def); } @@ -327,4 +305,59 @@ replace_ssa_name_symbol (tree ssa_name, tree sym) TREE_TYPE (ssa_name) = TREE_TYPE (sym); } -#include "gt-tree-ssanames.h" +/* Return SSA names that are unused to GGC memory. This is used to keep + footprint of compiler during interprocedural optimization. + As a side effect the SSA_NAME_VERSION number reuse is reduced + so this function should not be used too often. */ +static unsigned int +release_dead_ssa_names (void) +{ + tree t, next; + int n = 0; + referenced_var_iterator rvi; + + /* Current defs point to various dead SSA names that in turn points to dead + statements so bunch of dead memory is held from releasing. */ + FOR_EACH_REFERENCED_VAR (t, rvi) + set_current_def (t, NULL); + /* Now release the freelist. */ + for (t = FREE_SSANAMES (cfun); t; t = next) + { + next = TREE_CHAIN (t); + /* Dangling pointers might make GGC to still see dead SSA names, so it is + important to unlink the list and avoid GGC from seeing all subsequent + SSA names. In longer run we want to have all dangling pointers here + removed (since they usually go through dead statements that consume + considerable amounts of memory). */ + TREE_CHAIN (t) = NULL_TREE; + n++; + } + FREE_SSANAMES (cfun) = NULL; + + /* Cgraph edges has been invalidated and point to dead statement. We need to + remove them now and will rebuild it before next IPA pass. */ + cgraph_node_remove_callees (cgraph_node (current_function_decl)); + + if (dump_file) + fprintf (dump_file, "Released %i names, %.2f%%\n", n, n * 100.0 / num_ssa_names); + return 0; +} + +struct gimple_opt_pass pass_release_ssa_names = +{ + { + GIMPLE_PASS, + "release_ssa", /* name */ + NULL, /* gate */ + release_dead_ssa_names, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_NONE, /* tv_id */ + PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +};