/* Information stored for SSA names. */
struct ssa_name_info
{
+ /* The actual definition of the ssa name. */
+ tree current_def;
+
/* This field indicates whether or not the variable may need PHI nodes.
See the enum's definition for more detailed information about the
states. */
ENUM_BITFIELD (need_phi_state) need_phi_state : 2;
- /* The actual definition of the ssa name. */
- tree current_def;
+ /* Age of this record (so that info_for_ssa_name table can be cleared
+ quicky); if AGE < CURRENT_INFO_FOR_SSA_NAME_AGE, then the fields
+ are assumed to be null. */
+ unsigned age;
};
+/* The information associated with names. */
+typedef struct ssa_name_info *ssa_name_info_p;
+DEF_VEC_P (ssa_name_info_p);
+DEF_VEC_ALLOC_P (ssa_name_info_p, heap);
+
+static VEC(ssa_name_info_p, heap) *info_for_ssa_name;
+static unsigned current_info_for_ssa_name_age;
+
+/* The set of blocks affected by update_ssa. */
+
+static bitmap blocks_to_update;
/* The main entry point to the SSA renamer (rewrite_blocks) may be
called several times to do different, but related, tasks.
static inline struct ssa_name_info *
get_ssa_name_ann (tree name)
{
- if (!SSA_NAME_AUX (name))
- SSA_NAME_AUX (name) = xcalloc (1, sizeof (struct ssa_name_info));
+ unsigned ver = SSA_NAME_VERSION (name);
+ unsigned len = VEC_length (ssa_name_info_p, info_for_ssa_name);
+ struct ssa_name_info *info;
+
+ if (ver >= len)
+ {
+ unsigned new_len = num_ssa_names;
+
+ VEC_reserve (ssa_name_info_p, heap, info_for_ssa_name, new_len);
+ while (len++ < new_len)
+ {
+ struct ssa_name_info *info = XCNEW (struct ssa_name_info);
+ info->age = current_info_for_ssa_name_age;
+ VEC_quick_push (ssa_name_info_p, info_for_ssa_name, info);
+ }
+ }
+
+ info = VEC_index (ssa_name_info_p, info_for_ssa_name, ver);
+ if (info->age < current_info_for_ssa_name_age)
+ {
+ info->need_phi_state = 0;
+ info->current_def = NULL_TREE;
+ info->age = current_info_for_ssa_name_age;
+ }
- return (struct ssa_name_info *) SSA_NAME_AUX (name);
+ return info;
}
+/* Clears info for ssa names. */
+
+static void
+clear_ssa_name_info (void)
+{
+ current_info_for_ssa_name_age++;
+}
/* Gets phi_state field for VAR. */
}
+/* Cleans up the REWRITE_THIS_STMT and REGISTER_DEFS_IN_THIS_STMT flags for
+ all statements in basic block BB. */
+
+static void
+initialize_flags_in_bb (basic_block bb)
+{
+ tree phi, stmt;
+ block_stmt_iterator bsi;
+
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ {
+ REWRITE_THIS_STMT (phi) = 0;
+ REGISTER_DEFS_IN_THIS_STMT (phi) = 0;
+ }
+
+ for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+ {
+ stmt = bsi_stmt (bsi);
+ /* We are going to use the operand cache API, such as
+ SET_USE, SET_DEF, and FOR_EACH_IMM_USE_FAST. The operand
+ cache for each statement should be up-to-date. */
+ gcc_assert (!stmt_modified_p (stmt));
+ REWRITE_THIS_STMT (stmt) = 0;
+ REGISTER_DEFS_IN_THIS_STMT (stmt) = 0;
+ }
+}
+
+/* Mark block BB as interesting for update_ssa. */
+
+static void
+mark_block_for_update (basic_block bb)
+{
+ gcc_assert (blocks_to_update != NULL);
+ if (bitmap_bit_p (blocks_to_update, bb->index))
+ return;
+ bitmap_set_bit (blocks_to_update, bb->index);
+ initialize_flags_in_bb (bb);
+}
+
/* Return the set of blocks where variable VAR is defined and the blocks
where VAR is live on entry (livein). If no entry is found in
DEF_BLOCKS, a new one is created and returned. */
stmt = bsi_stmt (bsi);
update_stmt_if_modified (stmt);
+ gcc_assert (blocks_to_update == NULL);
REGISTER_DEFS_IN_THIS_STMT (stmt) = 0;
REWRITE_THIS_STMT (stmt) = 0;
0, bb_index, bi)
{
bb = BASIC_BLOCK (bb_index);
+ if (update_p)
+ mark_block_for_update (bb);
if (update_p && TREE_CODE (var) == SSA_NAME)
{
/* If mark_def_sites decided that we don't need to rewrite this
statement, ignore it. */
+ gcc_assert (blocks_to_update == NULL);
if (!REWRITE_THIS_STMT (stmt) && !REGISTER_DEFS_IN_THIS_STMT (stmt))
return;
/* Mark the unwind point for this block. */
VEC_safe_push (tree, heap, block_defs_stack, NULL_TREE);
+ if (!bitmap_bit_p (blocks_to_update, bb->index))
+ return;
+
/* Mark the LHS if any of the arguments flows through an abnormal
edge. */
is_abnormal_phi = false;
register it as a new definition for its corresponding name. Also
register definitions for names whose underlying symbols are
marked for renaming. */
+
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{
tree lhs, lhs_sym;
stmt = bsi_stmt (si);
ann = stmt_ann (stmt);
+ gcc_assert (bitmap_bit_p (blocks_to_update, bb->index));
+
/* Only update marked statements. */
if (!REWRITE_THIS_STMT (stmt) && !REGISTER_DEFS_IN_THIS_STMT (stmt))
return;
renamer. BLOCKS is the set of blocks that need updating. */
static void
-mark_def_interesting (tree var, tree stmt, basic_block bb, bitmap blocks,
- bool insert_phi_p)
+mark_def_interesting (tree var, tree stmt, basic_block bb, bool insert_phi_p)
{
+ gcc_assert (bitmap_bit_p (blocks_to_update, bb->index));
REGISTER_DEFS_IN_THIS_STMT (stmt) = 1;
- bitmap_set_bit (blocks, bb->index);
if (insert_phi_p)
{
/* Mark the use of VAR at STMT and BB as interesting for the
renamer. INSERT_PHI_P is true if we are going to insert new PHI
- nodes. BLOCKS is the set of blocks that need updating. */
+ nodes. */
static inline void
-mark_use_interesting (tree var, tree stmt, basic_block bb, bitmap blocks,
- bool insert_phi_p)
+mark_use_interesting (tree var, tree stmt, basic_block bb, bool insert_phi_p)
{
basic_block def_bb = bb_for_stmt (stmt);
+ mark_block_for_update (def_bb);
+ mark_block_for_update (bb);
+
if (TREE_CODE (stmt) == PHI_NODE)
mark_phi_for_rewrite (def_bb, stmt);
else
REWRITE_THIS_STMT (stmt) = 1;
- bitmap_set_bit (blocks, bb->index);
/* If VAR has not been defined in BB, then it is live-on-entry
to BB. Note that we cannot just use the block holding VAR's
/* Do a dominator walk starting at BB processing statements that
reference symbols in SYMS_TO_RENAME. This is very similar to
mark_def_sites, but the scan handles statements whose operands may
- already be SSA names. Blocks that contain defs or uses of symbols
- in SYMS_TO_RENAME are added to BLOCKS.
+ already be SSA names.
If INSERT_PHI_P is true, mark those uses as live in the
corresponding block. This is later used by the PHI placement
algorithm to make PHI pruning decisions. */
static void
-prepare_block_for_update (basic_block bb, bitmap blocks, bool insert_phi_p)
+prepare_block_for_update (basic_block bb, bool insert_phi_p)
{
basic_block son;
block_stmt_iterator si;
tree phi;
+ mark_block_for_update (bb);
+
/* Process PHI nodes marking interesting those that define or use
the symbols that we are interested in. */
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
if (symbol_marked_for_renaming (lhs_sym))
{
- mark_use_interesting (lhs_sym, phi, bb, blocks, insert_phi_p);
- mark_def_interesting (lhs_sym, phi, bb, blocks, insert_phi_p);
+ mark_use_interesting (lhs_sym, phi, bb, insert_phi_p);
+ mark_def_interesting (lhs_sym, phi, bb, insert_phi_p);
}
}
tree use = USE_FROM_PTR (use_p);
tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
if (symbol_marked_for_renaming (sym))
- mark_use_interesting (use, stmt, bb, blocks, insert_phi_p);
+ mark_use_interesting (use, stmt, bb, insert_phi_p);
}
FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, i, SSA_OP_DEF)
tree sym = DECL_P (def) ? def : SSA_NAME_VAR (def);
if (symbol_marked_for_renaming (sym))
- mark_def_interesting (def, stmt, bb, blocks, insert_phi_p);
+ mark_def_interesting (def, stmt, bb, insert_phi_p);
}
FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, i, SSA_OP_VIRTUAL_DEFS)
if (symbol_marked_for_renaming (sym))
{
- mark_use_interesting (sym, stmt, bb, blocks, insert_phi_p);
- mark_def_interesting (sym, stmt, bb, blocks, insert_phi_p);
+ mark_use_interesting (sym, stmt, bb, insert_phi_p);
+ mark_def_interesting (sym, stmt, bb, insert_phi_p);
}
}
tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
if (symbol_marked_for_renaming (sym))
- mark_use_interesting (sym, stmt, bb, blocks, insert_phi_p);
+ mark_use_interesting (sym, stmt, bb, insert_phi_p);
}
}
for (son = first_dom_son (CDI_DOMINATORS, bb);
son;
son = next_dom_son (CDI_DOMINATORS, son))
- prepare_block_for_update (son, blocks, insert_phi_p);
+ prepare_block_for_update (son, insert_phi_p);
}
prepare_names_to_update. */
static void
-prepare_use_sites_for (tree name, bitmap blocks, bool insert_phi_p)
+prepare_use_sites_for (tree name, bool insert_phi_p)
{
use_operand_p use_p;
imm_use_iterator iter;
placement algorithm may try to insert PHI nodes in blocks
that are not only unnecessary but also the renamer would
not know how to fill in. */
- mark_use_interesting (name, stmt, bb, blocks, false);
+ mark_use_interesting (name, stmt, bb, false);
/* As discussed above, we only want to mark NAME live-in
through the edge corresponding to its slot inside the PHI
{
/* For regular statements, mark this as an interesting use
for NAME. */
- mark_use_interesting (name, stmt, bb, blocks, insert_phi_p);
+ mark_use_interesting (name, stmt, bb, insert_phi_p);
}
}
}
prepare_names_to_update. */
static void
-prepare_def_site_for (tree name, bitmap blocks, bool insert_phi_p)
+prepare_def_site_for (tree name, bool insert_phi_p)
{
tree stmt;
basic_block bb;
if (bb)
{
gcc_assert (bb->index < last_basic_block);
- mark_def_interesting (name, stmt, bb, blocks, insert_phi_p);
+ mark_block_for_update (bb);
+ mark_def_interesting (name, stmt, bb, insert_phi_p);
}
}
/* Mark definition and use sites of names in NEW_SSA_NAMES and
- OLD_SSA_NAMES. Add each definition block to BLOCKS. INSERT_PHI_P
- is true if the caller wants to insert PHI nodes for newly created
- names. */
+ OLD_SSA_NAMES. INSERT_PHI_P is true if the caller wants to insert
+ PHI nodes for newly created names. */
static void
-prepare_names_to_update (bitmap blocks, bool insert_phi_p)
+prepare_names_to_update (bool insert_phi_p)
{
unsigned i = 0;
bitmap_iterator bi;
names may be considered to be live-in on blocks that contain
definitions for their replacements. */
EXECUTE_IF_SET_IN_SBITMAP (new_ssa_names, 0, i, sbi)
- prepare_def_site_for (ssa_name (i), blocks, insert_phi_p);
+ prepare_def_site_for (ssa_name (i), insert_phi_p);
/* If an old name is in NAMES_TO_RELEASE, we cannot remove it from
OLD_SSA_NAMES, but we have to ignore its definition site. */
EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi)
{
if (names_to_release == NULL || !bitmap_bit_p (names_to_release, i))
- prepare_def_site_for (ssa_name (i), blocks, insert_phi_p);
- prepare_use_sites_for (ssa_name (i), blocks, insert_phi_p);
+ prepare_def_site_for (ssa_name (i), insert_phi_p);
+ prepare_use_sites_for (ssa_name (i), insert_phi_p);
}
}
BITMAP_FREE (names_to_release);
}
- for (i = 1; i < num_ssa_names; i++)
- {
- tree n = ssa_name (i);
-
- if (n)
- {
- free (SSA_NAME_AUX (n));
- SSA_NAME_AUX (n) = NULL;
- }
- }
+ clear_ssa_name_info ();
}
void
update_ssa (unsigned update_flags)
{
- bitmap blocks;
basic_block bb, start_bb;
bitmap_iterator bi;
unsigned i = 0;
blocks_with_phis_to_rewrite = BITMAP_ALLOC (NULL);
if (!phis_to_rewrite)
phis_to_rewrite = VEC_alloc (tree_vec, heap, last_basic_block);
+ blocks_to_update = BITMAP_ALLOC (NULL);
/* Ensure that the dominance information is up-to-date. */
calculate_dominance_info (CDI_DOMINATORS);
def_blocks = NULL;
}
- blocks = BITMAP_ALLOC (NULL);
-
- /* Clear the REWRITE_THIS_STMT and REGISTER_DEFS_IN_THIS_STMT flags
- for every statement and PHI node. */
- FOR_EACH_BB (bb)
- {
- block_stmt_iterator si;
- tree phi;
-
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- REWRITE_THIS_STMT (phi) = 0;
- REGISTER_DEFS_IN_THIS_STMT (phi) = 0;
- }
-
- for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
- {
- tree stmt = bsi_stmt (si);
- /* We are going to use the operand cache API, such as
- SET_USE, SET_DEF, and FOR_EACH_IMM_USE_FAST. The operand
- cache for each statement should be up-to-date. */
- gcc_assert (!stmt_modified_p (stmt));
- REWRITE_THIS_STMT (stmt) = 0;
- REGISTER_DEFS_IN_THIS_STMT (stmt) = 0;
- }
- }
-
/* Heuristic to avoid massive slow downs when the replacement
mappings include lots of virtual names. */
if (insert_phi_p && switch_virtuals_to_full_rewrite_p ())
OLD_SSA_NAMES. */
if (sbitmap_first_set_bit (new_ssa_names) >= 0)
{
- prepare_names_to_update (blocks, insert_phi_p);
+ prepare_names_to_update (insert_phi_p);
/* If all the names in NEW_SSA_NAMES had been marked for
removal, and there are no symbols to rename, then there's
in SYMS_TO_RENAME. Mark interesting blocks and statements
and set local live-in information for the PHI placement
heuristics. */
- prepare_block_for_update (start_bb, blocks, insert_phi_p);
+ prepare_block_for_update (start_bb, insert_phi_p);
}
else
{
/* Otherwise, the entry block to the region is the nearest
common dominator for the blocks in BLOCKS. */
- start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS, blocks);
+ start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS,
+ blocks_to_update);
}
/* If requested, insert PHI nodes at the iterated dominance frontier
sbitmap tmp = sbitmap_alloc (old_ssa_names->n_bits);
sbitmap_copy (tmp, old_ssa_names);
EXECUTE_IF_SET_IN_SBITMAP (tmp, 0, i, sbi)
- insert_updated_phi_nodes_for (ssa_name (i), dfs, blocks,
+ insert_updated_phi_nodes_for (ssa_name (i), dfs, blocks_to_update,
update_flags);
sbitmap_free (tmp);
}
EXECUTE_IF_SET_IN_BITMAP (syms_to_rename, 0, i, bi)
- insert_updated_phi_nodes_for (referenced_var (i), dfs, blocks,
- update_flags);
+ insert_updated_phi_nodes_for (referenced_var (i), dfs,
+ blocks_to_update, update_flags);
FOR_EACH_BB (bb)
BITMAP_FREE (dfs[bb->index]);
We need to re-compute START_BB to include the newly added
blocks. */
if (start_bb != ENTRY_BLOCK_PTR)
- start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS, blocks);
+ start_bb = nearest_common_dominator_for_set (CDI_DOMINATORS,
+ blocks_to_update);
}
/* Reset the current definition for name and symbol before renaming
/* Now start the renaming process at START_BB. */
tmp = sbitmap_alloc (last_basic_block);
sbitmap_zero (tmp);
- EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
+ EXECUTE_IF_SET_IN_BITMAP (blocks_to_update, 0, i, bi)
SET_BIT (tmp, i);
rewrite_blocks (start_bb, REWRITE_UPDATE, tmp);
start_bb->index);
c = 0;
- EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
+ EXECUTE_IF_SET_IN_BITMAP (blocks_to_update, 0, i, bi)
c++;
fprintf (dump_file, "Number of blocks in CFG: %d\n", last_basic_block);
fprintf (dump_file, "Number of blocks to update: %d (%3.0f%%)\n\n",
if (dump_flags & TDF_DETAILS)
{
fprintf (dump_file, "Affected blocks: ");
- EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
+ EXECUTE_IF_SET_IN_BITMAP (blocks_to_update, 0, i, bi)
fprintf (dump_file, "%u ", i);
fprintf (dump_file, "\n");
}
VEC_replace (tree_vec, phis_to_rewrite, i, NULL);
}
BITMAP_FREE (blocks_with_phis_to_rewrite);
- BITMAP_FREE (blocks);
+ BITMAP_FREE (blocks_to_update);
delete_update_ssa ();
timevar_pop (TV_TREE_SSA_INCREMENTAL);
git://gcc.gnu.org / gcc.git / commitdiff