+2012-08-01 Richard Guenther <rguenther@suse.de>
+
+ * tree-flow.h (struct gimple_df): Remove syms_to_rename member,
+ add ssa_renaming_needed and rename_vops flags.
+ (SYMS_TO_RENAME): Remove.
+ (symbol_marked_for_renaming): Likewise.
+ (mark_virtual_ops_for_renaming): Likewise.
+ * tree-into-ssa.c (symbols_to_rename_set, symbols_to_rename):
+ New globals.
+ (mark_for_renaming, marked_for_renaming): New functions.
+ (symbol_marked_for_renaming): Remove.
+ (dump_currdefs): Adjust.
+ (maybe_replace_use): Likewise.
+ (maybe_replace_use_in_debug_stmt): Likewise.
+ (maybe_register_def): Likewise.
+ (rewrite_update_phi_arguments): Likewise.
+ (rewrite_update_enter_block): Likewise.
+ (fini_ssa_renamer): Clear update SSA status here ...
+ (delete_update_ssa): ... not here. Free rename set.
+ (prepare_block_for_update): Compute which decls need renaming.
+ (dump_update_ssa): Adjust.
+ (mark_sym_for_renaming): Adjust update SSA status for virtuals.
+ (need_ssa_update_p): Adjust.
+ (insert_updated_phi_nodes_for): Likewise.
+ (update_ssa): Likewise.
+ * tree-ssa-operands.c (finalize_ssa_defs): Adjust update SSA status
+ for virtual and real operands.
+ (finalize_ssa_uses): Likewise.
+ * tree-ssanames.c (init_ssanames): Adjust.
+ * tree-ssa.c (maybe_rewrite_mem_ref_base, maybe_optimize_var,
+ execute_update_addresses_taken): Add bitmap to keep track of which
+ candidates are suitable for rewriting and later renaming by SSA
+ update.
+ * matrix-reorg.c (transform_access_sites): Do not rename all defs.
+ * tree-dfa.c (make_rename_temp): Do not mark real operands for renaming.
+ * cgraphunit.c (assemble_thunk): Likewise.
+ * gimplify.c (gimple_regimplify_operands): Likewise.
+ (force_gimple_operand_1): Likewise.
+ * ipa-prop.c (ipa_modify_formal_parameters): Likewise.
+ * tree-inline.c (declare_return_variable): Likewise.
+ * tree-parloops.c (separate_decls_in_region_stmt): Do not call
+ mark_virtual_ops_for_renaming.
+ (create_stores_for_reduction): Likewise.
+ (create_loads_and_stores_for_name): Likewise.
+ * tree-predcom.c (mark_virtual_ops_for_renaming): Remove.
+ (initialize_root_vars_lm): Do not call mark_virtual_ops_for_renaming.
+ (execute_load_motion): Likewise.
+ (remove_stmt): Likewise.
+ (execute_pred_commoning_chain): Likewise.
+ * tree-sra.c (create_access_replacement): Do not rename real
+ operands.
+ (get_unrenamed_access_replacement): Unify with ...
+ (get_access_replacement): ... this.
+ (get_repl_default_def_ssa_name): Adjust.
+ * tree-ssa-loop-im.c (move_computations_stmt): Manually update
+ virtual SSA form.
+ (rewrite_mem_ref_loc): Do not call mark_virtual_ops_for_renaming.
+ * tree-ssa-loop-prefetch.c (emit_mfence_after_loop): Likewise.
+
2012-07-31 DJ Delorie <dj@redhat.com>
* config/s390/s390.c (s390_option_override): Disable DWARF 3/4
else
VEC_quick_push (tree, vargs, a);
add_referenced_var (a);
- if (is_gimple_reg (a))
- mark_sym_for_renaming (a);
for (i = 1, arg = DECL_CHAIN (a); i < nargs; i++, arg = DECL_CHAIN (arg))
{
add_referenced_var (arg);
- if (is_gimple_reg (arg))
- mark_sym_for_renaming (arg);
VEC_quick_push (tree, vargs, arg);
}
call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
add_referenced_var (t);
if (!gimple_seq_empty_p (pre))
- {
- if (gimple_in_ssa_p (cfun))
- {
- gimple_stmt_iterator i;
-
- for (i = gsi_start (pre); !gsi_end_p (i); gsi_next (&i))
- {
- tree lhs = gimple_get_lhs (gsi_stmt (i));
- if (lhs
- && TREE_CODE (lhs) != SSA_NAME
- && is_gimple_reg (lhs))
- mark_sym_for_renaming (lhs);
- }
- }
- gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
- }
+ gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
if (post_stmt)
gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
for (t = gimplify_ctxp->temps; t ; t = DECL_CHAIN (t))
add_referenced_var (t);
- if (!gimple_seq_empty_p (*stmts)
- && gimplify_ctxp->into_ssa)
- {
- gimple_stmt_iterator i;
-
- for (i = gsi_start (*stmts); !gsi_end_p (i); gsi_next (&i))
- {
- tree lhs = gimple_get_lhs (gsi_stmt (i));
- if (lhs
- && TREE_CODE (lhs) != SSA_NAME
- && is_gimple_reg (lhs))
- mark_sym_for_renaming (lhs);
- }
- }
-
pop_gimplify_context (NULL);
return expr;
layout_decl (new_parm, 0);
add_referenced_var (new_parm);
- mark_sym_for_renaming (new_parm);
adj->base = parm;
adj->reduction = new_parm;
{
if (acc_info->level >= 0 && gimple_bb (acc_info->stmt))
{
- ssa_op_iter iter;
- tree def;
gimple stmt = acc_info->stmt;
tree lhs;
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
- mark_sym_for_renaming (SSA_NAME_VAR (def));
gsi = gsi_for_stmt (stmt);
gcc_assert (is_gimple_assign (acc_info->stmt));
lhs = gimple_assign_lhs (acc_info->stmt);
if (gimple_referenced_vars (cfun))
add_referenced_var (t);
- if (gimple_in_ssa_p (cfun))
- mark_sym_for_renaming (t);
return t;
}
for this variable with an empty defining statement. */
htab_t GTY((param_is (union tree_node))) default_defs;
- /* Symbols whose SSA form needs to be updated or created for the first
- time. */
- bitmap syms_to_rename;
+ /* True if there are any symbols that need to be renamed. */
+ unsigned int ssa_renaming_needed : 1;
+
+ /* True if all virtual operands need to be renamed. */
+ unsigned int rename_vops : 1;
/* True if the code is in ssa form. */
unsigned int in_ssa_p : 1;
#define SSANAMES(fun) (fun)->gimple_df->ssa_names
#define MODIFIED_NORETURN_CALLS(fun) (fun)->gimple_df->modified_noreturn_calls
#define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs
-#define SYMS_TO_RENAME(fun) (fun)->gimple_df->syms_to_rename
typedef struct
{
void release_ssa_name_after_update_ssa (tree);
void compute_global_livein (bitmap, bitmap);
void mark_sym_for_renaming (tree);
-bool symbol_marked_for_renaming (tree);
tree get_current_def (tree);
void set_current_def (tree, tree);
transform_callback, void *);
bool contains_abnormal_ssa_name_p (tree);
bool stmt_dominates_stmt_p (gimple, gimple);
-void mark_virtual_ops_for_renaming (gimple);
/* In tree-ssa-dce.c */
void mark_virtual_operand_for_renaming (tree);
TREE_ADDRESSABLE (var) = 1;
var = build_fold_addr_expr (var);
}
- else if (gimple_in_ssa_p (cfun)
- && is_gimple_reg (var))
- /* ??? Re-org id->retval and its special handling so that we can
- record an SSA name directly and not need to invoke the SSA renamer. */
- mark_sym_for_renaming (var);
done:
/* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
extern void dump_currdefs (FILE *);
extern void debug_currdefs (void);
+
+/* The set of symbols we ought to re-write into SSA form in update_ssa. */
+static bitmap symbols_to_rename_set;
+static VEC(tree,heap) *symbols_to_rename;
+
+/* Mark SYM for renaming. */
+
+static void
+mark_for_renaming (tree sym)
+{
+ if (!symbols_to_rename_set)
+ symbols_to_rename_set = BITMAP_ALLOC (NULL);
+ if (bitmap_set_bit (symbols_to_rename_set, DECL_UID (sym)))
+ VEC_safe_push (tree, heap, symbols_to_rename, sym);
+}
+
+/* Return true if SYM is marked for renaming. */
+
+static bool
+marked_for_renaming (tree sym)
+{
+ if (!symbols_to_rename_set)
+ return false;
+ return bitmap_bit_p (symbols_to_rename_set, DECL_UID (sym));
+}
+
+
/* Return true if STMT needs to be rewritten. When renaming a subset
of the variables, not all statements will be processed. This is
decided in mark_def_sites. */
}
-/* Return true if symbol SYM is marked for renaming. */
-
-bool
-symbol_marked_for_renaming (tree sym)
-{
- return bitmap_bit_p (SYMS_TO_RENAME (cfun), DECL_UID (sym));
-}
-
-
/* Return true if NAME is in OLD_SSA_NAMES. */
static inline bool
void
dump_currdefs (FILE *file)
{
- referenced_var_iterator i;
+ unsigned i;
tree var;
+ if (VEC_empty (tree, symbols_to_rename))
+ return;
+
fprintf (file, "\n\nCurrent reaching definitions\n\n");
- FOR_EACH_REFERENCED_VAR (cfun, var, i)
- if (SYMS_TO_RENAME (cfun) == NULL
- || bitmap_bit_p (SYMS_TO_RENAME (cfun), DECL_UID (var)))
- {
- fprintf (file, "CURRDEF (");
- print_generic_expr (file, var, 0);
- fprintf (file, ") = ");
- if (get_current_def (var))
- print_generic_expr (file, get_current_def (var), 0);
- else
- fprintf (file, "<NIL>");
- fprintf (file, "\n");
- }
+ FOR_EACH_VEC_ELT (tree, symbols_to_rename, i, var)
+ {
+ fprintf (file, "CURRDEF (");
+ print_generic_expr (file, var, 0);
+ fprintf (file, ") = ");
+ if (get_current_def (var))
+ print_generic_expr (file, get_current_def (var), 0);
+ else
+ fprintf (file, "<NIL>");
+ fprintf (file, "\n");
+ }
}
tree use = USE_FROM_PTR (use_p);
tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
- if (symbol_marked_for_renaming (sym))
+ if (marked_for_renaming (sym))
rdef = get_reaching_def (sym);
else if (is_old_name (use))
rdef = get_reaching_def (use);
tree use = USE_FROM_PTR (use_p);
tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
- if (symbol_marked_for_renaming (sym))
+ if (marked_for_renaming (sym))
rdef = get_current_def (sym);
else if (is_old_name (use))
{
/* If DEF is a naked symbol that needs renaming, create a new
name for it. */
- if (symbol_marked_for_renaming (sym))
+ if (marked_for_renaming (sym))
{
if (DECL_P (def))
{
{
tree sym = DECL_P (arg) ? arg : SSA_NAME_VAR (arg);
- if (symbol_marked_for_renaming (sym))
+ if (marked_for_renaming (sym))
reaching_def = get_reaching_def (sym);
else if (is_old_name (arg))
reaching_def = get_reaching_def (arg);
lhs = gimple_phi_result (phi);
lhs_sym = SSA_NAME_VAR (lhs);
- if (symbol_marked_for_renaming (lhs_sym))
+ if (marked_for_renaming (lhs_sym))
register_new_update_single (lhs, lhs_sym);
else
{
bitmap_obstack_release (&update_ssa_obstack);
+ cfun->gimple_df->ssa_renaming_needed = 0;
+ cfun->gimple_df->rename_vops = 0;
cfun->gimple_df->in_ssa_p = true;
}
/* Do a dominator walk starting at BB processing statements that
- reference symbols in SYMS_TO_RENAME. This is very similar to
+ reference symbols in SSA operands. This is very similar to
mark_def_sites, but the scan handles statements whose operands may
already be SSA names.
lhs_sym = DECL_P (lhs) ? lhs : SSA_NAME_VAR (lhs);
- if (!symbol_marked_for_renaming (lhs_sym))
+ if (TREE_CODE (lhs) == SSA_NAME
+ && (TREE_CODE (lhs_sym) != VAR_DECL
+ || !VAR_DECL_IS_VIRTUAL_OPERAND (lhs_sym)
+ || !cfun->gimple_df->rename_vops))
continue;
+ mark_for_renaming (lhs_sym);
mark_def_interesting (lhs_sym, phi, bb, insert_phi_p);
/* Mark the uses in phi nodes as interesting. It would be more correct
stmt = gsi_stmt (si);
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, i, SSA_OP_ALL_USES)
+ if (cfun->gimple_df->rename_vops
+ && gimple_vuse (stmt))
{
- tree use = USE_FROM_PTR (use_p);
+ tree use = gimple_vuse (stmt);
tree sym = DECL_P (use) ? use : SSA_NAME_VAR (use);
- if (symbol_marked_for_renaming (sym))
- mark_use_interesting (sym, stmt, bb, insert_phi_p);
+ mark_for_renaming (sym);
+ mark_use_interesting (sym, stmt, bb, insert_phi_p);
}
- FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, i, SSA_OP_ALL_DEFS)
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, i, SSA_OP_USE)
{
- tree def = DEF_FROM_PTR (def_p);
+ tree use = USE_FROM_PTR (use_p);
+ if (!DECL_P (use))
+ continue;
+ mark_for_renaming (use);
+ mark_use_interesting (use, stmt, bb, insert_phi_p);
+ }
+
+ if (cfun->gimple_df->rename_vops
+ && gimple_vdef (stmt))
+ {
+ tree def = gimple_vdef (stmt);
tree sym = DECL_P (def) ? def : SSA_NAME_VAR (def);
- if (symbol_marked_for_renaming (sym))
- mark_def_interesting (sym, stmt, bb, insert_phi_p);
+ mark_for_renaming (sym);
+ mark_def_interesting (sym, stmt, bb, insert_phi_p);
+ }
+
+ FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, i, SSA_OP_DEF)
+ {
+ tree def = DEF_FROM_PTR (def_p);
+ if (!DECL_P (def))
+ continue;
+ mark_for_renaming (def);
+ mark_def_interesting (def, stmt, bb, insert_phi_p);
}
}
dump_names_replaced_by (file, ssa_name (i));
}
- if (!bitmap_empty_p (SYMS_TO_RENAME (cfun)))
+ if (symbols_to_rename_set && !bitmap_empty_p (symbols_to_rename_set))
{
fprintf (file, "\nSymbols to be put in SSA form\n");
- dump_decl_set (file, SYMS_TO_RENAME (cfun));
+ dump_decl_set (file, symbols_to_rename_set);
fprintf (file, "\n");
}
sbitmap_free (new_ssa_names);
new_ssa_names = NULL;
- bitmap_clear (SYMS_TO_RENAME (update_ssa_initialized_fn));
+ BITMAP_FREE (symbols_to_rename_set);
+ symbols_to_rename_set = NULL;
+ VEC_free (tree, heap, symbols_to_rename);
if (names_to_release)
{
void
mark_sym_for_renaming (tree sym)
{
- if (cfun->gimple_df->in_ssa_p)
- bitmap_set_bit (SYMS_TO_RENAME (cfun), DECL_UID (sym));
+ if (TREE_CODE (sym) == VAR_DECL
+ && VAR_DECL_IS_VIRTUAL_OPERAND (sym))
+ {
+ cfun->gimple_df->ssa_renaming_needed = 1;
+ cfun->gimple_df->rename_vops = 1;
+ }
}
{
gcc_assert (fn != NULL);
return (update_ssa_initialized_fn == fn
- || (fn->gimple_df
- && !bitmap_empty_p (SYMS_TO_RENAME (fn))));
+ || (fn->gimple_df && fn->gimple_df->ssa_renaming_needed));
}
/* Return true if name N has been registered in the replacement table. */
if (TREE_CODE (var) == SSA_NAME)
gcc_checking_assert (is_old_name (var));
else
- gcc_checking_assert (symbol_marked_for_renaming (var));
+ gcc_checking_assert (marked_for_renaming (var));
/* Get all the definition sites for VAR. */
db = find_def_blocks_for (var);
unsigned i = 0;
bool insert_phi_p;
sbitmap_iterator sbi;
+ tree sym;
if (!need_ssa_update_p (cfun))
return;
removal, and there are no symbols to rename, then there's
nothing else to do. */
if (sbitmap_first_set_bit (new_ssa_names) < 0
- && bitmap_empty_p (SYMS_TO_RENAME (cfun)))
+ && !cfun->gimple_df->ssa_renaming_needed)
goto done;
}
/* Next, determine the block at which to start the renaming process. */
- if (!bitmap_empty_p (SYMS_TO_RENAME (cfun)))
+ if (cfun->gimple_df->ssa_renaming_needed)
{
/* If we rename bare symbols initialize the mapping to
auxiliar info we need to keep track of. */
start_bb = ENTRY_BLOCK_PTR;
/* Traverse the CFG looking for existing definitions and uses of
- symbols in SYMS_TO_RENAME. Mark interesting blocks and
+ symbols in SSA operands. Mark interesting blocks and
statements and set local live-in information for the PHI
placement heuristics. */
prepare_block_for_update (start_bb, insert_phi_p);
/* If requested, insert PHI nodes at the iterated dominance frontier
of every block, creating new definitions for names in OLD_SSA_NAMES
- and for symbols in SYMS_TO_RENAME. */
+ and for symbols found. */
if (insert_phi_p)
{
bitmap_head *dfs;
sbitmap_free (tmp);
}
- EXECUTE_IF_SET_IN_BITMAP (SYMS_TO_RENAME (cfun), 0, i, bi)
- insert_updated_phi_nodes_for (referenced_var (i), dfs, blocks_to_update,
+ FOR_EACH_VEC_ELT (tree, symbols_to_rename, i, sym)
+ insert_updated_phi_nodes_for (sym, dfs, blocks_to_update,
update_flags);
FOR_EACH_BB (bb)
EXECUTE_IF_SET_IN_SBITMAP (old_ssa_names, 0, i, sbi)
set_current_def (ssa_name (i), NULL_TREE);
- EXECUTE_IF_SET_IN_BITMAP (SYMS_TO_RENAME (cfun), 0, i, bi)
- set_current_def (referenced_var (i), NULL_TREE);
+ FOR_EACH_VEC_ELT (tree, symbols_to_rename, i, sym)
+ set_current_def (sym, NULL_TREE);
/* Now start the renaming process at START_BB. */
interesting_blocks = sbitmap_alloc (last_basic_block);
tree name, copy;
bool copy_name_p;
- mark_virtual_ops_for_renaming (stmt);
-
FOR_EACH_PHI_OR_STMT_DEF (def, stmt, oi, SSA_OP_DEF)
{
name = DEF_FROM_PTR (def);
gsi = gsi_last_bb (clsn_data->store_bb);
t = build3 (COMPONENT_REF, type, clsn_data->store, red->field, NULL_TREE);
stmt = gimple_build_assign (t, red->initial_value);
- mark_virtual_ops_for_renaming (stmt);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
return 1;
gsi = gsi_last_bb (clsn_data->store_bb);
t = build3 (COMPONENT_REF, type, clsn_data->store, elt->field, NULL_TREE);
stmt = gimple_build_assign (t, ssa_name (elt->version));
- mark_virtual_ops_for_renaming (stmt);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
gsi = gsi_last_bb (clsn_data->load_bb);
return VEC_index (tree, chain->inits, index);
}
-/* Marks all virtual operands of statement STMT for renaming. */
-
-void
-mark_virtual_ops_for_renaming (gimple stmt)
-{
- tree var;
-
- if (gimple_code (stmt) == GIMPLE_PHI)
- {
- var = PHI_RESULT (stmt);
- if (is_gimple_reg (var))
- return;
-
- if (TREE_CODE (var) == SSA_NAME)
- var = SSA_NAME_VAR (var);
- mark_sym_for_renaming (var);
- return;
- }
-
- update_stmt (stmt);
- if (gimple_vuse (stmt))
- mark_sym_for_renaming (gimple_vop (cfun));
-}
-
/* Returns a new temporary variable used for the I-th variable carrying
value of REF. The variable's uid is marked in TMP_VARS. */
else
{
gimple init_stmt = gimple_build_assign (var, init);
- mark_virtual_ops_for_renaming (init_stmt);
gsi_insert_on_edge_immediate (entry, init_stmt);
}
}
FOR_EACH_VEC_ELT (dref, chain->refs, i, a)
{
bool is_read = DR_IS_READ (a->ref);
- mark_virtual_ops_for_renaming (a->stmt);
if (DR_IS_WRITE (a->ref))
{
next = single_nonlooparound_use (name);
reset_debug_uses (stmt);
- mark_virtual_ops_for_renaming (stmt);
+ unlink_stmt_vdef (stmt);
gsi_remove (&bsi, true);
release_defs (stmt);
bitmap tmp_vars)
{
unsigned i;
- dref a, root;
+ dref a;
tree var;
if (chain->combined)
/* For non-combined chains, set up the variables that hold its value,
and replace the uses of the original references by these
variables. */
- root = get_chain_root (chain);
- mark_virtual_ops_for_renaming (root->stmt);
-
initialize_root (loop, chain, tmp_vars);
for (i = 1; VEC_iterate (dref, chain->refs, i, a); i++)
{
- mark_virtual_ops_for_renaming (a->stmt);
var = VEC_index (tree, chain->vars, chain->length - a->distance);
replace_ref_with (a->stmt, var, false, false);
}
ACCESS->replacement. */
static tree
-create_access_replacement (struct access *access, bool rename)
+create_access_replacement (struct access *access)
{
tree repl;
repl = create_tmp_var (access->type, "SR");
add_referenced_var (repl);
- if (!access->grp_partial_lhs
- && rename)
- mark_sym_for_renaming (repl);
if (TREE_CODE (access->type) == COMPLEX_TYPE
|| TREE_CODE (access->type) == VECTOR_TYPE)
static inline tree
get_access_replacement (struct access *access)
{
- gcc_assert (access->grp_to_be_replaced);
-
- if (!access->replacement_decl)
- access->replacement_decl = create_access_replacement (access, true);
- return access->replacement_decl;
-}
-
-/* Return ACCESS scalar replacement, create it if it does not exist yet but do
- not mark it for renaming. */
-
-static inline tree
-get_unrenamed_access_replacement (struct access *access)
-{
- gcc_assert (!access->grp_to_be_replaced);
-
if (!access->replacement_decl)
- access->replacement_decl = create_access_replacement (access, false);
+ access->replacement_decl = create_access_replacement (access);
return access->replacement_decl;
}
{
tree repl, decl;
- decl = get_unrenamed_access_replacement (racc);
+ decl = get_access_replacement (racc);
repl = gimple_default_def (cfun, decl);
if (!repl)
for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); )
{
+ edge e;
+
stmt = gsi_stmt (bsi);
lim_data = get_lim_data (stmt);
cost, level->num);
}
- mark_virtual_ops_for_renaming (stmt);
+ e = loop_preheader_edge (level);
+ gcc_assert (!gimple_vdef (stmt));
+ if (gimple_vuse (stmt))
+ {
+ /* The new VUSE is the one from the virtual PHI in the loop
+ header or the one already present. */
+ gimple_stmt_iterator gsi2;
+ for (gsi2 = gsi_start_phis (e->dest);
+ !gsi_end_p (gsi2); gsi_next (&gsi2))
+ {
+ gimple phi = gsi_stmt (gsi2);
+ if (!is_gimple_reg (gimple_phi_result (phi)))
+ {
+ gimple_set_vuse (stmt, PHI_ARG_DEF_FROM_EDGE (phi, e));
+ break;
+ }
+ }
+ }
gsi_remove (&bsi, false);
- gsi_insert_on_edge (loop_preheader_edge (level), stmt);
+ gsi_insert_on_edge (e, stmt);
}
}
static void
rewrite_mem_ref_loc (mem_ref_loc_p loc, tree tmp_var)
{
- mark_virtual_ops_for_renaming (loc->stmt);
*loc->ref = tmp_var;
update_stmt (loc->stmt);
}
bsi = gsi_after_labels (exit->dest);
gsi_insert_before (&bsi, call, GSI_NEW_STMT);
- mark_virtual_ops_for_renaming (call);
}
VEC_free (edge, heap, exits);
/* If we have a non-SSA_NAME VDEF, mark it for renaming. */
if (gimple_vdef (stmt)
&& TREE_CODE (gimple_vdef (stmt)) != SSA_NAME)
- mark_sym_for_renaming (gimple_vdef (stmt));
+ {
+ cfun->gimple_df->rename_vops = 1;
+ cfun->gimple_df->ssa_renaming_needed = 1;
+ }
/* Check for the common case of 1 def that hasn't changed. */
if (old_ops && old_ops->next == NULL && num == 1
/* If there is anything remaining in the build_defs list, simply emit it. */
for ( ; new_i < num; new_i++)
- last = add_def_op ((tree *) VEC_index (tree, build_defs, new_i), last);
+ {
+ tree *op = (tree *) VEC_index (tree, build_defs, new_i);
+ if (DECL_P (*op))
+ cfun->gimple_df->ssa_renaming_needed = 1;
+ last = add_def_op (op, last);
+ }
/* Now set the stmt's operands. */
gimple_set_def_ops (stmt, new_list.next);
&& gimple_vuse (stmt) == NULL_TREE)
{
gimple_set_vuse (stmt, gimple_vop (cfun));
- mark_sym_for_renaming (gimple_vop (cfun));
+ cfun->gimple_df->rename_vops = 1;
+ cfun->gimple_df->ssa_renaming_needed = 1;
}
/* Now create nodes for all the new nodes. */
for (new_i = 0; new_i < VEC_length (tree, build_uses); new_i++)
- last = add_use_op (stmt,
- (tree *) VEC_index (tree, build_uses, new_i),
- last);
+ {
+ tree *op = (tree *) VEC_index (tree, build_uses, new_i);
+ if (DECL_P (*op))
+ cfun->gimple_df->ssa_renaming_needed = 1;
+ last = add_use_op (stmt, op, last);
+ }
/* Now set the stmt's operands. */
gimple_set_use_ops (stmt, new_list.next);
a MEM_REF to a plain or converted symbol. */
static void
-maybe_rewrite_mem_ref_base (tree *tp)
+maybe_rewrite_mem_ref_base (tree *tp, bitmap suitable_for_renaming)
{
tree sym;
&& (sym = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0))
&& DECL_P (sym)
&& !TREE_ADDRESSABLE (sym)
- && symbol_marked_for_renaming (sym))
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
{
if (TREE_CODE (TREE_TYPE (sym)) == VECTOR_TYPE
&& useless_type_conversion_p (TREE_TYPE (*tp),
mark the variable VAR for conversion into SSA. Return true when updating
stmts is required. */
-static bool
-maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs)
+static void
+maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs,
+ bitmap suitable_for_renaming)
{
- bool update_vops = false;
-
/* Global Variables, result decls cannot be changed. */
if (is_global_var (var)
|| TREE_CODE (var) == RESULT_DECL
|| bitmap_bit_p (addresses_taken, DECL_UID (var)))
- return false;
-
- /* If the variable is not in the list of referenced vars then we
- do not need to touch it nor can we rename it. */
- if (!referenced_var_lookup (cfun, DECL_UID (var)))
- return false;
+ return;
if (TREE_ADDRESSABLE (var)
/* Do not change TREE_ADDRESSABLE if we need to preserve var as
{
TREE_ADDRESSABLE (var) = 0;
if (is_gimple_reg (var))
- mark_sym_for_renaming (var);
- update_vops = true;
+ bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
if (dump_file)
{
fprintf (dump_file, "No longer having address taken: ");
&& (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var)))
{
DECL_GIMPLE_REG_P (var) = 1;
- mark_sym_for_renaming (var);
- update_vops = true;
+ bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
if (dump_file)
{
fprintf (dump_file, "Now a gimple register: ");
fprintf (dump_file, "\n");
}
}
-
- return update_vops;
}
/* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
basic_block bb;
bitmap addresses_taken = BITMAP_ALLOC (NULL);
bitmap not_reg_needs = BITMAP_ALLOC (NULL);
- bool update_vops = false;
+ bitmap suitable_for_renaming = BITMAP_ALLOC (NULL);
tree var;
unsigned i;
unused vars from BLOCK trees, which causes code generation differences
for -g vs. -g0. */
for (var = DECL_ARGUMENTS (cfun->decl); var; var = DECL_CHAIN (var))
- update_vops |= maybe_optimize_var (var, addresses_taken, not_reg_needs);
+ maybe_optimize_var (var, addresses_taken, not_reg_needs,
+ suitable_for_renaming);
FOR_EACH_VEC_ELT (tree, cfun->local_decls, i, var)
- update_vops |= maybe_optimize_var (var, addresses_taken, not_reg_needs);
+ maybe_optimize_var (var, addresses_taken, not_reg_needs,
+ suitable_for_renaming);
/* Operand caches need to be recomputed for operands referencing the updated
- variables. */
- if (update_vops)
+ variables and operands need to be rewritten to expose bare symbols. */
+ if (!bitmap_empty_p (suitable_for_renaming))
{
FOR_EACH_BB (bb)
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
&& (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
&& DECL_P (sym)
&& !TREE_ADDRESSABLE (sym)
- && symbol_marked_for_renaming (sym))
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
lhs = sym;
else
lhs = gimple_assign_lhs (stmt);
/* Rewrite the RHS and make sure the resulting assignment
is validly typed. */
- maybe_rewrite_mem_ref_base (rhsp);
+ maybe_rewrite_mem_ref_base (rhsp, suitable_for_renaming);
rhs = gimple_assign_rhs1 (stmt);
if (gimple_assign_lhs (stmt) != lhs
&& !useless_type_conversion_p (TREE_TYPE (lhs),
TREE_ADDRESSABLE just remove the stmt. */
if (DECL_P (lhs)
&& TREE_CLOBBER_P (rhs)
- && symbol_marked_for_renaming (lhs))
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (lhs)))
{
unlink_stmt_vdef (stmt);
gsi_remove (&gsi, true);
for (i = 0; i < gimple_call_num_args (stmt); ++i)
{
tree *argp = gimple_call_arg_ptr (stmt, i);
- maybe_rewrite_mem_ref_base (argp);
+ maybe_rewrite_mem_ref_base (argp, suitable_for_renaming);
}
}
for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
{
tree link = gimple_asm_output_op (stmt, i);
- maybe_rewrite_mem_ref_base (&TREE_VALUE (link));
+ maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
+ suitable_for_renaming);
}
for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
{
tree link = gimple_asm_input_op (stmt, i);
- maybe_rewrite_mem_ref_base (&TREE_VALUE (link));
+ maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
+ suitable_for_renaming);
}
}
{
tree *valuep = gimple_debug_bind_get_value_ptr (stmt);
tree decl;
- maybe_rewrite_mem_ref_base (valuep);
+ maybe_rewrite_mem_ref_base (valuep, suitable_for_renaming);
decl = non_rewritable_mem_ref_base (*valuep);
- if (decl && symbol_marked_for_renaming (decl))
+ if (decl
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (decl)))
gimple_debug_bind_reset_value (stmt);
}
BITMAP_FREE (not_reg_needs);
BITMAP_FREE (addresses_taken);
+ BITMAP_FREE (suitable_for_renaming);
timevar_pop (TV_ADDRESS_TAKEN);
}
VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
FREE_SSANAMES (fn) = NULL;
- SYMS_TO_RENAME (fn) = BITMAP_GGC_ALLOC ();
+ fn->gimple_df->ssa_renaming_needed = 0;
+ fn->gimple_df->rename_vops = 0;
}
/* Finalize management of SSA_NAMEs. */
projects / platform / upstream / linaro-gcc.git / commitdiff