/* SSA Dominator optimizations for trees
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
expressions are removed from AVAIL_EXPRS. Else we may change the
hash code for an expression and be unable to find/remove it from
AVAIL_EXPRS. */
-static VEC(tree,heap) *stmts_to_rescan;
+typedef tree *tree_p;
+DEF_VEC_P(tree_p);
+DEF_VEC_ALLOC_P(tree_p,heap);
+
+static VEC(tree_p,heap) *stmts_to_rescan;
/* Structure for entries in the expression hash table.
restored during finalization of this block. */
static VEC(tree,heap) *const_and_copies_stack;
-/* Bitmap of SSA_NAMEs known to have a nonzero value, even if we do not
- know their exact value. */
-static bitmap nonzero_vars;
-
-/* Stack of SSA_NAMEs which need their NONZERO_VARS property cleared
- when the current block is finalized.
-
- A NULL entry is used to mark the end of names needing their
- entry in NONZERO_VARS cleared during finalization of this block. */
-static VEC(tree,heap) *nonzero_vars_stack;
-
/* Track whether or not we have changed the control flow graph. */
static bool cfg_altered;
static void remove_local_expressions_from_table (void);
static void restore_vars_to_original_value (void);
static edge single_incoming_edge_ignoring_loop_edges (basic_block);
-static void restore_nonzero_vars_to_original_value (void);
-static inline bool unsafe_associative_fp_binop (tree);
/* Allocate an EDGE_INFO for edge E and attach it to E.
every new symbol exposed, its corresponding bit will be set in
VARS_TO_RENAME. */
-static void
+static unsigned int
tree_ssa_dominator_optimize (void)
{
struct dom_walk_data walk_data;
unsigned int i;
- struct loops loops_info;
memset (&opt_stats, 0, sizeof (opt_stats));
avail_exprs = htab_create (1024, real_avail_expr_hash, avail_expr_eq, free);
avail_exprs_stack = VEC_alloc (tree, heap, 20);
const_and_copies_stack = VEC_alloc (tree, heap, 20);
- nonzero_vars_stack = VEC_alloc (tree, heap, 20);
- stmts_to_rescan = VEC_alloc (tree, heap, 20);
- nonzero_vars = BITMAP_ALLOC (NULL);
+ stmts_to_rescan = VEC_alloc (tree_p, heap, 20);
need_eh_cleanup = BITMAP_ALLOC (NULL);
/* Setup callbacks for the generic dominator tree walker. */
init_walk_dominator_tree (&walk_data);
calculate_dominance_info (CDI_DOMINATORS);
+ cfg_altered = false;
- /* We need to know which edges exit loops so that we can
- aggressively thread through loop headers to an exit
- edge. */
- flow_loops_find (&loops_info);
- mark_loop_exit_edges (&loops_info);
- flow_loops_free (&loops_info);
-
- /* Clean up the CFG so that any forwarder blocks created by loop
- canonicalization are removed. */
- cleanup_tree_cfg ();
- calculate_dominance_info (CDI_DOMINATORS);
+ /* We need to know loop structures in order to avoid destroying them
+ in jump threading. Note that we still can e.g. thread through loop
+ headers to an exit edge, or through loop header to the loop body, assuming
+ that we update the loop info. */
+ loop_optimizer_init (LOOPS_HAVE_SIMPLE_LATCHES);
/* We need accurate information regarding back edges in the CFG
- for jump threading. */
+ for jump threading; this may include back edes that are not part of
+ a single loop. */
mark_dfs_back_edges ();
-
+
/* Recursively walk the dominator tree optimizing statements. */
walk_dominator_tree (&walk_data, ENTRY_BLOCK_PTR);
free_all_edge_infos ();
/* Thread jumps, creating duplicate blocks as needed. */
- cfg_altered |= thread_through_all_blocks ();
+ cfg_altered |= thread_through_all_blocks (first_pass_instance);
+
+ if (cfg_altered)
+ free_dominance_info (CDI_DOMINATORS);
/* Removal of statements may make some EH edges dead. Purge
such edges from the CFG as needed. */
if (!bitmap_empty_p (need_eh_cleanup))
{
- cfg_altered |= tree_purge_all_dead_eh_edges (need_eh_cleanup);
+ tree_purge_all_dead_eh_edges (need_eh_cleanup);
bitmap_zero (need_eh_cleanup);
}
- if (cfg_altered)
- free_dominance_info (CDI_DOMINATORS);
-
/* Finally, remove everything except invariants in SSA_NAME_VALUE.
Long term we will be able to let everything in SSA_NAME_VALUE
if (dump_file && (dump_flags & TDF_STATS))
dump_dominator_optimization_stats (dump_file);
+ loop_optimizer_finalize ();
+
/* Delete our main hashtable. */
htab_delete (avail_exprs);
/* And finalize the dominator walker. */
fini_walk_dominator_tree (&walk_data);
- /* Free nonzero_vars. */
- BITMAP_FREE (nonzero_vars);
+ /* Free asserted bitmaps and stacks. */
BITMAP_FREE (need_eh_cleanup);
VEC_free (tree, heap, avail_exprs_stack);
VEC_free (tree, heap, const_and_copies_stack);
- VEC_free (tree, heap, nonzero_vars_stack);
- VEC_free (tree, heap, stmts_to_rescan);
+ VEC_free (tree_p, heap, stmts_to_rescan);
+ return 0;
}
static bool
far to unwind when we finalize this block. */
VEC_safe_push (tree, heap, avail_exprs_stack, NULL_TREE);
VEC_safe_push (tree, heap, const_and_copies_stack, NULL_TREE);
- VEC_safe_push (tree, heap, nonzero_vars_stack, NULL_TREE);
record_equivalences_from_incoming_edge (bb);
else if (TREE_CODE (expr) == RETURN_EXPR && TREE_OPERAND (expr, 0))
{
element->stmt = expr;
- element->rhs = TREE_OPERAND (TREE_OPERAND (expr, 0), 1);
+ element->rhs = GIMPLE_STMT_OPERAND (TREE_OPERAND (expr, 0), 1);
}
else if (TREE_CODE (expr) == GOTO_EXPR)
{
else
{
element->stmt = expr;
- element->rhs = TREE_OPERAND (expr, 1);
+ element->rhs = GENERIC_TREE_OPERAND (expr, 1);
}
element->lhs = lhs;
}
}
-/* Use the SSA_NAMES in LOCALS to restore TABLE to its original
- state, stopping when there are LIMIT entries left in LOCALs. */
-
-static void
-restore_nonzero_vars_to_original_value (void)
-{
- while (VEC_length (tree, nonzero_vars_stack) > 0)
- {
- tree name = VEC_pop (tree, nonzero_vars_stack);
-
- if (name == NULL)
- break;
-
- bitmap_clear_bit (nonzero_vars, SSA_NAME_VERSION (name));
- }
-}
-
/* Use the source/dest pairs in CONST_AND_COPIES_STACK to restore
CONST_AND_COPIES to its original state, stopping when we hit a
NULL marker. */
/* A trivial wrapper so that we can present the generic jump
threading code with a simple API for simplifying statements. */
static tree
-simplify_stmt_for_jump_threading (tree stmt)
+simplify_stmt_for_jump_threading (tree stmt, tree within_stmt ATTRIBUTE_UNUSED)
{
return lookup_avail_expr (stmt, false);
}
/* If we don't already have a dummy condition, build it now. */
if (! walk_data->global_data)
{
- tree dummy_cond = build2 (NE, boolean_type_node,
+ tree dummy_cond = build2 (NE_EXPR, boolean_type_node,
integer_zero_node, integer_zero_node);
dummy_cond = build3 (COND_EXPR, void_type_node, dummy_cond, NULL, NULL);
walk_data->global_data = dummy_cond;
}
- thread_across_edge (walk_data->global_data, e, false,
+ thread_across_edge ((tree) walk_data->global_data, e, false,
&const_and_copies_stack,
simplify_stmt_for_jump_threading);
}
}
remove_local_expressions_from_table ();
- restore_nonzero_vars_to_original_value ();
restore_vars_to_original_value ();
/* If we queued any statements to rescan in this block, then
go ahead and rescan them now. */
- while (VEC_length (tree, stmts_to_rescan) > 0)
+ while (VEC_length (tree_p, stmts_to_rescan) > 0)
{
- tree stmt = VEC_last (tree, stmts_to_rescan);
+ tree *stmt_p = VEC_last (tree_p, stmts_to_rescan);
+ tree stmt = *stmt_p;
basic_block stmt_bb = bb_for_stmt (stmt);
if (stmt_bb != bb)
break;
- VEC_pop (tree, stmts_to_rescan);
- mark_new_vars_to_rename (stmt);
+ VEC_pop (tree_p, stmts_to_rescan);
+ pop_stmt_changes (stmt_p);
}
}
Ignoring any alternatives which are the same as the result, if
all the alternatives are equal, then the PHI node creates an
- equivalence.
-
- Additionally, if all the PHI alternatives are known to have a nonzero
- value, then the result of this PHI is known to have a nonzero value,
- even if we do not know its exact value. */
+ equivalence. */
static void
record_equivalences_from_phis (basic_block bb)
if (i == PHI_NUM_ARGS (phi)
&& may_propagate_copy (lhs, rhs))
SSA_NAME_VALUE (lhs) = rhs;
-
- /* Now see if we know anything about the nonzero property for the
- result of this PHI. */
- for (i = 0; i < PHI_NUM_ARGS (phi); i++)
- {
- if (!PHI_ARG_NONZERO (phi, i))
- break;
- }
-
- if (i == PHI_NUM_ARGS (phi))
- bitmap_set_bit (nonzero_vars, SSA_NAME_VERSION (PHI_RESULT (phi)));
}
}
htab_collisions (htab));
}
-/* Record the fact that VAR has a nonzero value, though we may not know
- its exact value. Note that if VAR is already known to have a nonzero
- value, then we do nothing. */
-
-static void
-record_var_is_nonzero (tree var)
-{
- int indx = SSA_NAME_VERSION (var);
-
- if (bitmap_bit_p (nonzero_vars, indx))
- return;
-
- /* Mark it in the global table. */
- bitmap_set_bit (nonzero_vars, indx);
-
- /* Record this SSA_NAME so that we can reset the global table
- when we leave this block. */
- VEC_safe_push (tree, heap, nonzero_vars_stack, var);
-}
-
/* Enter a statement into the true/false expression hash table indicating
that the condition COND has the value VALUE. */
{
case LT_EXPR:
case GT_EXPR:
- edge_info->max_cond_equivalences = 12;
- edge_info->cond_equivalences = XNEWVEC (tree, 12);
+ if (FLOAT_TYPE_P (TREE_TYPE (op0)))
+ {
+ edge_info->max_cond_equivalences = 12;
+ edge_info->cond_equivalences = XNEWVEC (tree, 12);
+ build_and_record_new_cond (ORDERED_EXPR, op0, op1,
+ &edge_info->cond_equivalences[8]);
+ build_and_record_new_cond (LTGT_EXPR, op0, op1,
+ &edge_info->cond_equivalences[10]);
+ }
+ else
+ {
+ edge_info->max_cond_equivalences = 8;
+ edge_info->cond_equivalences = XNEWVEC (tree, 8);
+ }
+
build_and_record_new_cond ((TREE_CODE (cond) == LT_EXPR
? LE_EXPR : GE_EXPR),
op0, op1, &edge_info->cond_equivalences[4]);
- build_and_record_new_cond (ORDERED_EXPR, op0, op1,
- &edge_info->cond_equivalences[6]);
build_and_record_new_cond (NE_EXPR, op0, op1,
- &edge_info->cond_equivalences[8]);
- build_and_record_new_cond (LTGT_EXPR, op0, op1,
- &edge_info->cond_equivalences[10]);
+ &edge_info->cond_equivalences[6]);
break;
case GE_EXPR:
case LE_EXPR:
- edge_info->max_cond_equivalences = 6;
- edge_info->cond_equivalences = XNEWVEC (tree, 6);
- build_and_record_new_cond (ORDERED_EXPR, op0, op1,
- &edge_info->cond_equivalences[4]);
+ if (FLOAT_TYPE_P (TREE_TYPE (op0)))
+ {
+ edge_info->max_cond_equivalences = 6;
+ edge_info->cond_equivalences = XNEWVEC (tree, 6);
+ build_and_record_new_cond (ORDERED_EXPR, op0, op1,
+ &edge_info->cond_equivalences[4]);
+ }
+ else
+ {
+ edge_info->max_cond_equivalences = 4;
+ edge_info->cond_equivalences = XNEWVEC (tree, 4);
+ }
break;
case EQ_EXPR:
- edge_info->max_cond_equivalences = 10;
- edge_info->cond_equivalences = XNEWVEC (tree, 10);
- build_and_record_new_cond (ORDERED_EXPR, op0, op1,
- &edge_info->cond_equivalences[4]);
+ if (FLOAT_TYPE_P (TREE_TYPE (op0)))
+ {
+ edge_info->max_cond_equivalences = 10;
+ edge_info->cond_equivalences = XNEWVEC (tree, 10);
+ build_and_record_new_cond (ORDERED_EXPR, op0, op1,
+ &edge_info->cond_equivalences[8]);
+ }
+ else
+ {
+ edge_info->max_cond_equivalences = 8;
+ edge_info->cond_equivalences = XNEWVEC (tree, 8);
+ }
build_and_record_new_cond (LE_EXPR, op0, op1,
- &edge_info->cond_equivalences[6]);
+ &edge_info->cond_equivalences[4]);
build_and_record_new_cond (GE_EXPR, op0, op1,
- &edge_info->cond_equivalences[8]);
+ &edge_info->cond_equivalences[6]);
break;
case UNORDERED_EXPR:
record_const_or_copy_1 (x, y, prev_x);
}
-/* Return true, if it is ok to do folding of an associative expression.
- EXP is the tree for the associative expression. */
-
-static inline bool
-unsafe_associative_fp_binop (tree exp)
-{
- enum tree_code code = TREE_CODE (exp);
- return !(!flag_unsafe_math_optimizations
- && (code == MULT_EXPR || code == PLUS_EXPR
- || code == MINUS_EXPR)
- && FLOAT_TYPE_P (TREE_TYPE (exp)));
-}
-
/* Returns true when STMT is a simple iv increment. It detects the
following situation:
tree lhs, rhs, preinc, phi;
unsigned i;
- if (TREE_CODE (stmt) != MODIFY_EXPR)
+ if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
- lhs = TREE_OPERAND (stmt, 0);
+ lhs = GIMPLE_STMT_OPERAND (stmt, 0);
if (TREE_CODE (lhs) != SSA_NAME)
return false;
- rhs = TREE_OPERAND (stmt, 1);
+ rhs = GIMPLE_STMT_OPERAND (stmt, 1);
if (TREE_CODE (rhs) != PLUS_EXPR
&& TREE_CODE (rhs) != MINUS_EXPR)
/* CONST_AND_COPIES is a table which maps an SSA_NAME to the current
known value for that SSA_NAME (or NULL if no value is known).
- NONZERO_VARS is the set SSA_NAMES known to have a nonzero value,
- even if we don't know their precise value.
-
- Propagate values from CONST_AND_COPIES and NONZERO_VARS into the PHI
- nodes of the successors of BB. */
+ Propagate values from CONST_AND_COPIES into the PHI nodes of the
+ successors of BB. */
static void
-cprop_into_successor_phis (basic_block bb, bitmap nonzero_vars)
+cprop_into_successor_phis (basic_block bb)
{
edge e;
edge_iterator ei;
indx = e->dest_idx;
for ( ; phi; phi = PHI_CHAIN (phi))
{
- tree new;
+ tree new_val;
use_operand_p orig_p;
- tree orig;
+ tree orig_val;
/* The alternative may be associated with a constant, so verify
it is an SSA_NAME before doing anything with it. */
orig_p = PHI_ARG_DEF_PTR (phi, indx);
- orig = USE_FROM_PTR (orig_p);
- if (TREE_CODE (orig) != SSA_NAME)
+ orig_val = USE_FROM_PTR (orig_p);
+ if (TREE_CODE (orig_val) != SSA_NAME)
continue;
- /* If the alternative is known to have a nonzero value, record
- that fact in the PHI node itself for future use. */
- if (bitmap_bit_p (nonzero_vars, SSA_NAME_VERSION (orig)))
- PHI_ARG_NONZERO (phi, indx) = true;
-
/* If we have *ORIG_P in our constant/copy table, then replace
ORIG_P with its value in our constant/copy table. */
- new = SSA_NAME_VALUE (orig);
- if (new
- && new != orig
- && (TREE_CODE (new) == SSA_NAME
- || is_gimple_min_invariant (new))
- && may_propagate_copy (orig, new))
- propagate_value (orig_p, new);
+ new_val = SSA_NAME_VALUE (orig_val);
+ if (new_val
+ && new_val != orig_val
+ && (TREE_CODE (new_val) == SSA_NAME
+ || is_gimple_min_invariant (new_val))
+ && may_propagate_copy (orig_val, new_val))
+ propagate_value (orig_p, new_val);
}
}
}
basic_block bb)
{
record_edge_info (bb);
- cprop_into_successor_phis (bb, nonzero_vars);
+ cprop_into_successor_phis (bb);
}
/* Search for redundant computations in STMT. If any are found, then
bool retval = false;
bool modify_expr_p = false;
- if (TREE_CODE (stmt) == MODIFY_EXPR)
- def = TREE_OPERAND (stmt, 0);
+ if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
+ def = GIMPLE_STMT_OPERAND (stmt, 0);
/* Certain expressions on the RHS can be optimized away, but can not
themselves be entered into the hash tables. */
if (! def
|| TREE_CODE (def) != SSA_NAME
|| SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)
- || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYDEF)
+ || !ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF)
/* Do not record equivalences for increments of ivs. This would create
overlapping live ranges for a very questionable gain. */
|| simple_iv_increment_p (stmt))
expr_p = &SWITCH_COND (stmt);
else if (TREE_CODE (stmt) == RETURN_EXPR && TREE_OPERAND (stmt, 0))
{
- expr_p = &TREE_OPERAND (TREE_OPERAND (stmt, 0), 1);
+ expr_p = &GIMPLE_STMT_OPERAND (TREE_OPERAND (stmt, 0), 1);
modify_expr_p = true;
}
else
{
- expr_p = &TREE_OPERAND (stmt, 1);
+ expr_p = &GENERIC_TREE_OPERAND (stmt, 1);
modify_expr_p = true;
}
if (cached_lhs
&& ((TREE_CODE (cached_lhs) != SSA_NAME
&& (modify_expr_p
- || tree_ssa_useless_type_conversion_1 (TREE_TYPE (*expr_p),
- TREE_TYPE (cached_lhs))))
+ || useless_type_conversion_p (TREE_TYPE (*expr_p),
+ TREE_TYPE (cached_lhs))))
|| may_propagate_copy (*expr_p, cached_lhs)))
{
if (dump_file && (dump_flags & TDF_DETAILS))
retval = true;
if (modify_expr_p
- && !tree_ssa_useless_type_conversion_1 (TREE_TYPE (*expr_p),
- TREE_TYPE (cached_lhs)))
+ && !useless_type_conversion_p (TREE_TYPE (*expr_p),
+ TREE_TYPE (cached_lhs)))
cached_lhs = fold_convert (TREE_TYPE (*expr_p), cached_lhs);
propagate_tree_value (expr_p, cached_lhs);
return retval;
}
-/* STMT, a MODIFY_EXPR, may create certain equivalences, in either
+/* STMT, a GIMPLE_MODIFY_STMT, may create certain equivalences, in either
the available expressions table or the const_and_copies table.
Detect and record those equivalences. */
static void
-record_equivalences_from_stmt (tree stmt,
- int may_optimize_p,
- stmt_ann_t ann)
+record_equivalences_from_stmt (tree stmt, int may_optimize_p, stmt_ann_t ann)
{
- tree lhs = TREE_OPERAND (stmt, 0);
+ tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
enum tree_code lhs_code = TREE_CODE (lhs);
- int i;
if (lhs_code == SSA_NAME)
{
- tree rhs = TREE_OPERAND (stmt, 1);
+ tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
/* Strip away any useless type conversions. */
STRIP_USELESS_TYPE_CONVERSION (rhs);
&& (TREE_CODE (rhs) == SSA_NAME
|| is_gimple_min_invariant (rhs)))
SSA_NAME_VALUE (lhs) = rhs;
-
- if (tree_expr_nonzero_p (rhs))
- record_var_is_nonzero (lhs);
}
- /* Look at both sides for pointer dereferences. If we find one, then
- the pointer must be nonnull and we can enter that equivalence into
- the hash tables. */
- if (flag_delete_null_pointer_checks)
- for (i = 0; i < 2; i++)
- {
- tree t = TREE_OPERAND (stmt, i);
-
- /* Strip away any COMPONENT_REFs. */
- while (TREE_CODE (t) == COMPONENT_REF)
- t = TREE_OPERAND (t, 0);
-
- /* Now see if this is a pointer dereference. */
- if (INDIRECT_REF_P (t))
- {
- tree op = TREE_OPERAND (t, 0);
-
- /* If the pointer is a SSA variable, then enter new
- equivalences into the hash table. */
- while (TREE_CODE (op) == SSA_NAME)
- {
- tree def = SSA_NAME_DEF_STMT (op);
-
- record_var_is_nonzero (op);
-
- /* And walk up the USE-DEF chains noting other SSA_NAMEs
- which are known to have a nonzero value. */
- if (def
- && TREE_CODE (def) == MODIFY_EXPR
- && TREE_CODE (TREE_OPERAND (def, 1)) == NOP_EXPR)
- op = TREE_OPERAND (TREE_OPERAND (def, 1), 0);
- else
- break;
- }
- }
- }
-
/* A memory store, even an aliased store, creates a useful
equivalence. By exchanging the LHS and RHS, creating suitable
vops and recording the result in the available expression table,
we may be able to expose more redundant loads. */
if (!ann->has_volatile_ops
- && (TREE_CODE (TREE_OPERAND (stmt, 1)) == SSA_NAME
- || is_gimple_min_invariant (TREE_OPERAND (stmt, 1)))
+ && stmt_references_memory_p (stmt)
+ && (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == SSA_NAME
+ || is_gimple_min_invariant (GIMPLE_STMT_OPERAND (stmt, 1)))
&& !is_gimple_reg (lhs))
{
- tree rhs = TREE_OPERAND (stmt, 1);
- tree new;
+ tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
+ tree new_stmt;
/* FIXME: If the LHS of the assignment is a bitfield and the RHS
is a constant, we need to adjust the constant to fit into the
if (rhs)
{
/* Build a new statement with the RHS and LHS exchanged. */
- new = build2 (MODIFY_EXPR, TREE_TYPE (stmt), rhs, lhs);
+ new_stmt = build_gimple_modify_stmt (rhs, lhs);
- create_ssa_artficial_load_stmt (new, stmt);
+ create_ssa_artificial_load_stmt (new_stmt, stmt);
/* Finally enter the statement into the available expression
table. */
- lookup_avail_expr (new, true);
+ lookup_avail_expr (new_stmt, true);
}
}
}
propagation opportunity. */
if (TREE_CODE (val) != SSA_NAME)
{
- if (!lang_hooks.types_compatible_p (op_type, val_type))
+ if (!useless_type_conversion_p (op_type, val_type))
{
val = fold_convert (TREE_TYPE (op), val);
if (!is_gimple_min_invariant (val))
known value for that SSA_NAME (or NULL if no value is known).
Propagate values from CONST_AND_COPIES into the uses, vuses and
- v_may_def_ops of STMT. */
+ vdef_ops of STMT. */
static bool
cprop_into_stmt (tree stmt)
ann = stmt_ann (stmt);
opt_stats.num_stmts++;
may_have_exposed_new_symbols = false;
+ push_stmt_changes (bsi_stmt_ptr (si));
if (dump_file && (dump_flags & TDF_DETAILS))
{
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
- /* Const/copy propagate into USES, VUSES and the RHS of V_MAY_DEFs. */
+ /* Const/copy propagate into USES, VUSES and the RHS of VDEFs. */
may_have_exposed_new_symbols = cprop_into_stmt (stmt);
/* If the statement has been modified with constant replacements,
may_optimize_p = (!ann->has_volatile_ops
&& ((TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
- && TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR
+ && TREE_CODE (TREE_OPERAND (stmt, 0))
+ == GIMPLE_MODIFY_STMT
&& ! (TREE_SIDE_EFFECTS
- (TREE_OPERAND (TREE_OPERAND (stmt, 0), 1))))
- || (TREE_CODE (stmt) == MODIFY_EXPR
- && ! TREE_SIDE_EFFECTS (TREE_OPERAND (stmt, 1)))
+ (GIMPLE_STMT_OPERAND
+ (TREE_OPERAND (stmt, 0), 1))))
+ || (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+ && ! TREE_SIDE_EFFECTS (GIMPLE_STMT_OPERAND (stmt,
+ 1)))
|| TREE_CODE (stmt) == COND_EXPR
|| TREE_CODE (stmt) == SWITCH_EXPR));
may_have_exposed_new_symbols |= eliminate_redundant_computations (stmt);
/* Record any additional equivalences created by this statement. */
- if (TREE_CODE (stmt) == MODIFY_EXPR)
- record_equivalences_from_stmt (stmt,
- may_optimize_p,
- ann);
+ if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
+ record_equivalences_from_stmt (stmt, may_optimize_p, ann);
/* If STMT is a COND_EXPR and it was modified, then we may know
where it goes. If that is the case, then mark the CFG as altered.
Ultimately I suspect we're going to need to change the interface
into the SSA_NAME manager. */
-
if (ann->modified)
{
tree val = NULL;
}
if (may_have_exposed_new_symbols)
- VEC_safe_push (tree, heap, stmts_to_rescan, bsi_stmt (si));
+ {
+ /* Queue the statement to be re-scanned after all the
+ AVAIL_EXPRS have been processed. The change buffer stack for
+ all the pushed statements will be processed when this queue
+ is emptied. */
+ VEC_safe_push (tree_p, heap, stmts_to_rescan, bsi_stmt_ptr (si));
+ }
+ else
+ {
+ /* Otherwise, just discard the recently pushed change buffer. If
+ not, the STMTS_TO_RESCAN queue will get out of synch with the
+ change buffer stack. */
+ discard_stmt_changes (bsi_stmt_ptr (si));
+ }
}
/* Search for an existing instance of STMT in the AVAIL_EXPRS table. If
is also added to the stack pointed to by BLOCK_AVAIL_EXPRS_P, so that they
can be removed when we finish processing this block and its children.
- NOTE: This function assumes that STMT is a MODIFY_EXPR node that
+ NOTE: This function assumes that STMT is a GIMPLE_MODIFY_STMT node that
contains no CALL_EXPR on its RHS and makes no volatile nor
aliased references. */
tree temp;
struct expr_hash_elt *element = XNEW (struct expr_hash_elt);
- lhs = TREE_CODE (stmt) == MODIFY_EXPR ? TREE_OPERAND (stmt, 0) : NULL;
+ lhs = TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
+ ? GIMPLE_STMT_OPERAND (stmt, 0) : NULL;
initialize_hash_element (stmt, lhs, element);
return NULL_TREE;
}
- /* If this is an equality test against zero, see if we have recorded a
- nonzero value for the variable in question. */
- if ((TREE_CODE (element->rhs) == EQ_EXPR
- || TREE_CODE (element->rhs) == NE_EXPR)
- && TREE_CODE (TREE_OPERAND (element->rhs, 0)) == SSA_NAME
- && integer_zerop (TREE_OPERAND (element->rhs, 1)))
- {
- int indx = SSA_NAME_VERSION (TREE_OPERAND (element->rhs, 0));
-
- if (bitmap_bit_p (nonzero_vars, indx))
- {
- tree t = element->rhs;
- free (element);
- return constant_boolean_node (TREE_CODE (t) != EQ_EXPR,
- TREE_TYPE (t));
- }
- }
-
/* Finally try to find the expression in the main expression hash table. */
slot = htab_find_slot_with_hash (avail_exprs, element, element->hash,
(insert ? INSERT : NO_INSERT));
}
/* Hashing and equality functions for AVAIL_EXPRS. The table stores
- MODIFY_EXPR statements. We compute a value number for expressions using
- the code of the expression and the SSA numbers of its operands. */
+ GIMPLE_MODIFY_STMT statements. We compute a value number for expressions
+ using the code of the expression and the SSA numbers of its operands. */
static hashval_t
avail_expr_hash (const void *p)
/* In case of a collision, both RHS have to be identical and have the
same VUSE operands. */
- if ((TREE_TYPE (rhs1) == TREE_TYPE (rhs2)
- || lang_hooks.types_compatible_p (TREE_TYPE (rhs1), TREE_TYPE (rhs2)))
+ if (types_compatible_p (TREE_TYPE (rhs1), TREE_TYPE (rhs2))
&& operand_equal_p (rhs1, rhs2, OEP_PURE_SAME))
{
bool ret = compare_ssa_operands_equal (stmt1, stmt2, SSA_OP_VUSE);
return false;
}
+
+/* PHI-ONLY copy and constant propagation. This pass is meant to clean
+ up degenerate PHIs created by or exposed by jump threading. */
+
+/* Given PHI, return its RHS if the PHI is a degenerate, otherwise return
+ NULL. */
+
+static tree
+degenerate_phi_result (tree phi)
+{
+ tree lhs = PHI_RESULT (phi);
+ tree val = NULL;
+ int i;
+
+ /* Ignoring arguments which are the same as LHS, if all the remaining
+ arguments are the same, then the PHI is a degenerate and has the
+ value of that common argument. */
+ for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+ {
+ tree arg = PHI_ARG_DEF (phi, i);
+
+ if (arg == lhs)
+ continue;
+ else if (!val)
+ val = arg;
+ else if (!operand_equal_p (arg, val, 0))
+ break;
+ }
+ return (i == PHI_NUM_ARGS (phi) ? val : NULL);
+}
+
+/* Given a tree node T, which is either a PHI_NODE or GIMPLE_MODIFY_STMT,
+ remove it from the IL. */
+
+static void
+remove_stmt_or_phi (tree t)
+{
+ if (TREE_CODE (t) == PHI_NODE)
+ remove_phi_node (t, NULL, true);
+ else
+ {
+ block_stmt_iterator bsi = bsi_for_stmt (t);
+ bsi_remove (&bsi, true);
+ release_defs (t);
+ }
+}
+
+/* Given a tree node T, which is either a PHI_NODE or GIMPLE_MODIFY_STMT,
+ return the "rhs" of the node, in the case of a non-degenerate
+ PHI, NULL is returned. */
+
+static tree
+get_rhs_or_phi_arg (tree t)
+{
+ if (TREE_CODE (t) == PHI_NODE)
+ return degenerate_phi_result (t);
+ else if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
+ return GIMPLE_STMT_OPERAND (t, 1);
+ gcc_unreachable ();
+}
+
+
+/* Given a tree node T, which is either a PHI_NODE or a GIMPLE_MODIFY_STMT,
+ return the "lhs" of the node. */
+
+static tree
+get_lhs_or_phi_result (tree t)
+{
+ if (TREE_CODE (t) == PHI_NODE)
+ return PHI_RESULT (t);
+ else if (TREE_CODE (t) == GIMPLE_MODIFY_STMT)
+ return GIMPLE_STMT_OPERAND (t, 0);
+ gcc_unreachable ();
+}
+
+/* Propagate RHS into all uses of LHS (when possible).
+
+ RHS and LHS are derived from STMT, which is passed in solely so
+ that we can remove it if propagation is successful.
+
+ When propagating into a PHI node or into a statement which turns
+ into a trivial copy or constant initialization, set the
+ appropriate bit in INTERESTING_NAMEs so that we will visit those
+ nodes as well in an effort to pick up secondary optimization
+ opportunities. */
+
+static void
+propagate_rhs_into_lhs (tree stmt, tree lhs, tree rhs, bitmap interesting_names)
+{
+ /* First verify that propagation is valid and isn't going to move a
+ loop variant variable outside its loop. */
+ if (! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs)
+ && (TREE_CODE (rhs) != SSA_NAME
+ || ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs))
+ && may_propagate_copy (lhs, rhs)
+ && loop_depth_of_name (lhs) >= loop_depth_of_name (rhs))
+ {
+ use_operand_p use_p;
+ imm_use_iterator iter;
+ tree use_stmt;
+ bool all = true;
+
+ /* Dump details. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, " Replacing '");
+ print_generic_expr (dump_file, lhs, dump_flags);
+ fprintf (dump_file, "' with %s '",
+ (TREE_CODE (rhs) != SSA_NAME ? "constant" : "variable"));
+ print_generic_expr (dump_file, rhs, dump_flags);
+ fprintf (dump_file, "'\n");
+ }
+
+ /* Walk over every use of LHS and try to replace the use with RHS.
+ At this point the only reason why such a propagation would not
+ be successful would be if the use occurs in an ASM_EXPR. */
+ FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
+ {
+
+ /* It's not always safe to propagate into an ASM_EXPR. */
+ if (TREE_CODE (use_stmt) == ASM_EXPR
+ && ! may_propagate_copy_into_asm (lhs))
+ {
+ all = false;
+ continue;
+ }
+
+ /* Dump details. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, " Original statement:");
+ print_generic_expr (dump_file, use_stmt, dump_flags);
+ fprintf (dump_file, "\n");
+ }
+
+ push_stmt_changes (&use_stmt);
+
+ /* Propagate the RHS into this use of the LHS. */
+ FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
+ propagate_value (use_p, rhs);
+
+ /* Special cases to avoid useless calls into the folding
+ routines, operand scanning, etc.
+
+ First, propagation into a PHI may cause the PHI to become
+ a degenerate, so mark the PHI as interesting. No other
+ actions are necessary.
+
+ Second, if we're propagating a virtual operand and the
+ propagation does not change the underlying _DECL node for
+ the virtual operand, then no further actions are necessary. */
+ if (TREE_CODE (use_stmt) == PHI_NODE
+ || (! is_gimple_reg (lhs)
+ && TREE_CODE (rhs) == SSA_NAME
+ && SSA_NAME_VAR (lhs) == SSA_NAME_VAR (rhs)))
+ {
+ /* Dump details. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, " Updated statement:");
+ print_generic_expr (dump_file, use_stmt, dump_flags);
+ fprintf (dump_file, "\n");
+ }
+
+ /* Propagation into a PHI may expose new degenerate PHIs,
+ so mark the result of the PHI as interesting. */
+ if (TREE_CODE (use_stmt) == PHI_NODE)
+ {
+ tree result = get_lhs_or_phi_result (use_stmt);
+ bitmap_set_bit (interesting_names, SSA_NAME_VERSION (result));
+ }
+
+ discard_stmt_changes (&use_stmt);
+ continue;
+ }
+
+ /* From this point onward we are propagating into a
+ real statement. Folding may (or may not) be possible,
+ we may expose new operands, expose dead EH edges,
+ etc. */
+ fold_stmt_inplace (use_stmt);
+
+ /* Sometimes propagation can expose new operands to the
+ renamer. Note this will call update_stmt at the
+ appropriate time. */
+ pop_stmt_changes (&use_stmt);
+
+ /* Dump details. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, " Updated statement:");
+ print_generic_expr (dump_file, use_stmt, dump_flags);
+ fprintf (dump_file, "\n");
+ }
+
+ /* If we replaced a variable index with a constant, then
+ we would need to update the invariant flag for ADDR_EXPRs. */
+ if (TREE_CODE (use_stmt) == GIMPLE_MODIFY_STMT
+ && TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == ADDR_EXPR)
+ recompute_tree_invariant_for_addr_expr
+ (GIMPLE_STMT_OPERAND (use_stmt, 1));
+
+ /* If we cleaned up EH information from the statement,
+ mark its containing block as needing EH cleanups. */
+ if (maybe_clean_or_replace_eh_stmt (use_stmt, use_stmt))
+ {
+ bitmap_set_bit (need_eh_cleanup, bb_for_stmt (use_stmt)->index);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, " Flagged to clear EH edges.\n");
+ }
+
+ /* Propagation may expose new trivial copy/constant propagation
+ opportunities. */
+ if (TREE_CODE (use_stmt) == GIMPLE_MODIFY_STMT
+ && TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 0)) == SSA_NAME
+ && (TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == SSA_NAME
+ || is_gimple_min_invariant (GIMPLE_STMT_OPERAND (use_stmt,
+ 1))))
+ {
+ tree result = get_lhs_or_phi_result (use_stmt);
+ bitmap_set_bit (interesting_names, SSA_NAME_VERSION (result));
+ }
+
+ /* Propagation into these nodes may make certain edges in
+ the CFG unexecutable. We want to identify them as PHI nodes
+ at the destination of those unexecutable edges may become
+ degenerates. */
+ else if (TREE_CODE (use_stmt) == COND_EXPR
+ || TREE_CODE (use_stmt) == SWITCH_EXPR
+ || TREE_CODE (use_stmt) == GOTO_EXPR)
+ {
+ tree val;
+
+ if (TREE_CODE (use_stmt) == COND_EXPR)
+ val = COND_EXPR_COND (use_stmt);
+ else if (TREE_CODE (use_stmt) == SWITCH_EXPR)
+ val = SWITCH_COND (use_stmt);
+ else
+ val = GOTO_DESTINATION (use_stmt);
+
+ if (is_gimple_min_invariant (val))
+ {
+ basic_block bb = bb_for_stmt (use_stmt);
+ edge te = find_taken_edge (bb, val);
+ edge_iterator ei;
+ edge e;
+ block_stmt_iterator bsi;
+
+ /* Remove all outgoing edges except TE. */
+ for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei));)
+ {
+ if (e != te)
+ {
+ tree phi;
+
+ /* Mark all the PHI nodes at the destination of
+ the unexecutable edge as interesting. */
+ for (phi = phi_nodes (e->dest);
+ phi;
+ phi = PHI_CHAIN (phi))
+ {
+ tree result = PHI_RESULT (phi);
+ int version = SSA_NAME_VERSION (result);
+
+ bitmap_set_bit (interesting_names, version);
+ }
+
+ te->probability += e->probability;
+
+ te->count += e->count;
+ remove_edge (e);
+ cfg_altered = true;
+ }
+ else
+ ei_next (&ei);
+ }
+
+ bsi = bsi_last (bb_for_stmt (use_stmt));
+ bsi_remove (&bsi, true);
+
+ /* And fixup the flags on the single remaining edge. */
+ te->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
+ te->flags &= ~EDGE_ABNORMAL;
+ te->flags |= EDGE_FALLTHRU;
+ if (te->probability > REG_BR_PROB_BASE)
+ te->probability = REG_BR_PROB_BASE;
+ }
+ }
+ }
+
+ /* Ensure there is nothing else to do. */
+ gcc_assert (!all || has_zero_uses (lhs));
+
+ /* If we were able to propagate away all uses of LHS, then
+ we can remove STMT. */
+ if (all)
+ remove_stmt_or_phi (stmt);
+ }
+}
+
+/* T is either a PHI node (potentially a degenerate PHI node) or
+ a statement that is a trivial copy or constant initialization.
+
+ Attempt to eliminate T by propagating its RHS into all uses of
+ its LHS. This may in turn set new bits in INTERESTING_NAMES
+ for nodes we want to revisit later.
+
+ All exit paths should clear INTERESTING_NAMES for the result
+ of T. */
+
+static void
+eliminate_const_or_copy (tree t, bitmap interesting_names)
+{
+ tree lhs = get_lhs_or_phi_result (t);
+ tree rhs;
+ int version = SSA_NAME_VERSION (lhs);
+
+ /* If the LHS of this statement or PHI has no uses, then we can
+ just eliminate it. This can occur if, for example, the PHI
+ was created by block duplication due to threading and its only
+ use was in the conditional at the end of the block which was
+ deleted. */
+ if (has_zero_uses (lhs))
+ {
+ bitmap_clear_bit (interesting_names, version);
+ remove_stmt_or_phi (t);
+ return;
+ }
+
+ /* Get the RHS of the assignment or PHI node if the PHI is a
+ degenerate. */
+ rhs = get_rhs_or_phi_arg (t);
+ if (!rhs)
+ {
+ bitmap_clear_bit (interesting_names, version);
+ return;
+ }
+
+ propagate_rhs_into_lhs (t, lhs, rhs, interesting_names);
+
+ /* Note that T may well have been deleted by now, so do
+ not access it, instead use the saved version # to clear
+ T's entry in the worklist. */
+ bitmap_clear_bit (interesting_names, version);
+}
+
+/* The first phase in degenerate PHI elimination.
+
+ Eliminate the degenerate PHIs in BB, then recurse on the
+ dominator children of BB. */
+
+static void
+eliminate_degenerate_phis_1 (basic_block bb, bitmap interesting_names)
+{
+ tree phi, next;
+ basic_block son;
+
+ for (phi = phi_nodes (bb); phi; phi = next)
+ {
+ next = PHI_CHAIN (phi);
+ eliminate_const_or_copy (phi, interesting_names);
+ }
+
+ /* Recurse into the dominator children of BB. */
+ for (son = first_dom_son (CDI_DOMINATORS, bb);
+ son;
+ son = next_dom_son (CDI_DOMINATORS, son))
+ eliminate_degenerate_phis_1 (son, interesting_names);
+}
+
+
+/* A very simple pass to eliminate degenerate PHI nodes from the
+ IL. This is meant to be fast enough to be able to be run several
+ times in the optimization pipeline.
+
+ Certain optimizations, particularly those which duplicate blocks
+ or remove edges from the CFG can create or expose PHIs which are
+ trivial copies or constant initializations.
+
+ While we could pick up these optimizations in DOM or with the
+ combination of copy-prop and CCP, those solutions are far too
+ heavy-weight for our needs.
+
+ This implementation has two phases so that we can efficiently
+ eliminate the first order degenerate PHIs and second order
+ degenerate PHIs.
+
+ The first phase performs a dominator walk to identify and eliminate
+ the vast majority of the degenerate PHIs. When a degenerate PHI
+ is identified and eliminated any affected statements or PHIs
+ are put on a worklist.
+
+ The second phase eliminates degenerate PHIs and trivial copies
+ or constant initializations using the worklist. This is how we
+ pick up the secondary optimization opportunities with minimal
+ cost. */
+
+static unsigned int
+eliminate_degenerate_phis (void)
+{
+ bitmap interesting_names;
+ bitmap interesting_names1;
+
+ /* Bitmap of blocks which need EH information updated. We can not
+ update it on-the-fly as doing so invalidates the dominator tree. */
+ need_eh_cleanup = BITMAP_ALLOC (NULL);
+
+ /* INTERESTING_NAMES is effectively our worklist, indexed by
+ SSA_NAME_VERSION.
+
+ A set bit indicates that the statement or PHI node which
+ defines the SSA_NAME should be (re)examined to determine if
+ it has become a degenerate PHI or trivial const/copy propagation
+ opportunity.
+
+ Experiments have show we generally get better compilation
+ time behavior with bitmaps rather than sbitmaps. */
+ interesting_names = BITMAP_ALLOC (NULL);
+ interesting_names1 = BITMAP_ALLOC (NULL);
+
+ calculate_dominance_info (CDI_DOMINATORS);
+ cfg_altered = false;
+
+ /* First phase. Eliminate degenerate PHIs via a dominator
+ walk of the CFG.
+
+ Experiments have indicated that we generally get better
+ compile-time behavior by visiting blocks in the first
+ phase in dominator order. Presumably this is because walking
+ in dominator order leaves fewer PHIs for later examination
+ by the worklist phase. */
+ eliminate_degenerate_phis_1 (ENTRY_BLOCK_PTR, interesting_names);
+
+ /* Second phase. Eliminate second order degenerate PHIs as well
+ as trivial copies or constant initializations identified by
+ the first phase or this phase. Basically we keep iterating
+ until our set of INTERESTING_NAMEs is empty. */
+ while (!bitmap_empty_p (interesting_names))
+ {
+ unsigned int i;
+ bitmap_iterator bi;
+
+ /* EXECUTE_IF_SET_IN_BITMAP does not like its bitmap
+ changed during the loop. Copy it to another bitmap and
+ use that. */
+ bitmap_copy (interesting_names1, interesting_names);
+
+ EXECUTE_IF_SET_IN_BITMAP (interesting_names1, 0, i, bi)
+ {
+ tree name = ssa_name (i);
+
+ /* Ignore SSA_NAMEs that have been released because
+ their defining statement was deleted (unreachable). */
+ if (name)
+ eliminate_const_or_copy (SSA_NAME_DEF_STMT (ssa_name (i)),
+ interesting_names);
+ }
+ }
+
+ if (cfg_altered)
+ free_dominance_info (CDI_DOMINATORS);
+
+ /* Propagation of const and copies may make some EH edges dead. Purge
+ such edges from the CFG as needed. */
+ if (!bitmap_empty_p (need_eh_cleanup))
+ {
+ tree_purge_all_dead_eh_edges (need_eh_cleanup);
+ BITMAP_FREE (need_eh_cleanup);
+ }
+
+ BITMAP_FREE (interesting_names);
+ BITMAP_FREE (interesting_names1);
+ return 0;
+}
+
+struct tree_opt_pass pass_phi_only_cprop =
+{
+ "phicprop", /* name */
+ gate_dominator, /* gate */
+ eliminate_degenerate_phis, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_TREE_PHI_CPROP, /* tv_id */
+ PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_cleanup_cfg
+ | TODO_dump_func
+ | TODO_ggc_collect
+ | TODO_verify_ssa
+ | TODO_verify_stmts
+ | TODO_update_ssa, /* todo_flags_finish */
+ 0 /* letter */
+};