/* Generic routines for manipulating SSA_NAME expressions
- Copyright (C) 2003, 2004 Free Software Foundation, Inc.
-
+ Copyright (C) 2003, 2004, 2005 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)
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. */
-
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
+
#include "config.h"
#include "system.h"
#include "coretypes.h"
#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
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. */
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. */
-
-void
-unmark_all_for_rewrite (void)
-{
- if (!ssa_names_to_rewrite)
- return;
-
- 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 (cfun) = VEC_alloc (tree, gc, 50);
/* 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 (cfun), NULL_TREE);
+ FREE_SSANAMES (cfun) = NULL;
}
/* Finalize management of SSA_NAMEs. */
void
fini_ssanames (void)
{
- ggc_free (ssa_names);
- ssa_names = NULL;
- 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. */
make_ssa_name (tree var, tree stmt)
{
tree t;
+ use_operand_p imm;
gcc_assert (DECL_P (var)
|| TREE_CODE (var) == INDIRECT_REF);
- gcc_assert (!stmt || EXPR_P (stmt) || TREE_CODE (stmt) == PHI_NODE);
+ gcc_assert (!stmt
+ || EXPR_P (stmt) || GIMPLE_STMT_P (stmt)
+ || TREE_CODE (stmt) == PHI_NODE);
- /* 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 (cfun))
{
- unsigned int save_version;
-
- t = free_ssanames;
- free_ssanames = TREE_CHAIN (free_ssanames);
+ t = FREE_SSANAMES (cfun);
+ FREE_SSANAMES (cfun) = TREE_CHAIN (FREE_SSANAMES (cfun));
#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 (cfun), SSA_NAME_VERSION (t), t);
}
else
{
t = make_node (SSA_NAME);
SSA_NAME_VERSION (t) = num_ssa_names;
- VARRAY_PUSH_TREE (ssa_names, t);
+ VEC_safe_push (tree, gc, SSANAMES (cfun), t);
#ifdef GATHER_STATISTICS
ssa_name_nodes_created++;
#endif
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->stmt = t;
return t;
}
/* 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
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));
+
+#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->stmt = 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;
}
}
{
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));
+
+ if (!ptr_info)
+ return;
new_ptr_info = ggc_alloc (sizeof (struct ptr_info_def));
- *new_ptr_info = *old_ptr_info;
+ *new_ptr_info = *ptr_info;
- if (old_ptr_info->pt_vars)
+ if (ptr_info->pt_vars)
{
new_ptr_info->pt_vars = BITMAP_GGC_ALLOC ();
- bitmap_copy (new_ptr_info->pt_vars, old_ptr_info->pt_vars);
+ bitmap_copy (new_ptr_info->pt_vars, ptr_info->pt_vars);
}
- SSA_NAME_PTR_INFO (new_name) = new_ptr_info;
- return new_name;
+ SSA_NAME_PTR_INFO (name) = new_ptr_info;
}
tree def;
ssa_op_iter iter;
+ /* Make sure that we are in SSA. Otherwise, operand cache may point
+ to garbage. */
+ gcc_assert (gimple_in_ssa_p (cfun));
+
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
if (TREE_CODE (def) == SSA_NAME)
release_ssa_name (def);
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 tree_opt_pass pass_release_ssa_names =
+{
+ "release_ssa", /* name */
+ NULL, /* gate */
+ release_dead_ssa_names, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ 0, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+ 0 /* letter */
+};