unsigned int call_overhead;
edge e;
edge_iterator ei;
+ gimple_stmt_iterator bsi;
+ unsigned int i;
+ int incomming_freq = 0;
+
if (dump_file && (dump_flags & TDF_DETAILS))
dump_split_point (dump_file, current);
+ FOR_EACH_EDGE (e, ei, current->entry_bb->preds)
+ if (!bitmap_bit_p (current->split_bbs, e->src->index))
+ incomming_freq += EDGE_FREQUENCY (e);
+
/* Do not split when we would end up calling function anyway. */
- if (current->entry_bb->frequency
+ if (incomming_freq
>= (ENTRY_BLOCK_PTR->frequency
* PARAM_VALUE (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY) / 100))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
- " Refused: split BB frequency is too large.\n");
+ " Refused: incomming frequency is too large.\n");
return;
}
return;
}
- /* FIXME: We can do better: if the split region start with a loop and there
- is only one entry point from outer wrold, we can update PHI. */
- if (!gsi_end_p (gsi_start_phis (current->entry_bb)))
+ /* Verify that PHI args on entry are either virutal or all their operands
+ incomming from header are the same. */
+ for (bsi = gsi_start_phis (current->entry_bb); !gsi_end_p (bsi); gsi_next (&bsi))
{
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file,
- " Refused: entry BB has PHI\n");
- return;
+ gimple stmt = gsi_stmt (bsi);
+ tree val = NULL;
+
+ if (!is_gimple_reg (gimple_phi_result (stmt)))
+ continue;
+ for (i = 0; i < gimple_phi_num_args (stmt); i++)
+ {
+ edge e = gimple_phi_arg_edge (stmt, i);
+ if (!bitmap_bit_p (current->split_bbs, e->src->index))
+ {
+ tree edge_val = gimple_phi_arg_def (stmt, i);
+ if (val && edge_val != val)
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file,
+ " Refused: entry BB has PHI with multiple variants\n");
+ return;
+ }
+ val = edge_val;
+ }
+ }
}
we can pass more than that. */
if (num_args != bitmap_count_bits (current->ssa_names_to_pass))
{
+
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
" Refused: need to pass non-param values\n");
}
for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
{
- if (is_gimple_debug (gsi_stmt (bsi)))
- continue;
if (walk_stmt_load_store_addr_ops
(gsi_stmt (bsi), non_ssa_vars, test_nonssa_use,
test_nonssa_use, test_nonssa_use))
for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
{
gimple stmt = gsi_stmt (bsi);
- tree op;
- ssa_op_iter iter;
+ unsigned int i;
if (is_gimple_debug (stmt))
continue;
if (!is_gimple_reg (gimple_phi_result (stmt)))
continue;
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
- bitmap_set_bit (set_ssa_names, SSA_NAME_VERSION (op));
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
- bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op));
+ bitmap_set_bit (set_ssa_names,
+ SSA_NAME_VERSION (gimple_phi_result (stmt)));
+ for (i = 0; i < gimple_phi_num_args (stmt); i++)
+ {
+ tree op = gimple_phi_arg_def (stmt, i);
+ if (TREE_CODE (op) == SSA_NAME)
+ bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op));
+ }
can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
mark_nonssa_use,
mark_nonssa_use,
= new_phi = create_phi_node (new_res, new_bb);
FOR_EACH_EDGE (new_edge, ei, new_bb->preds)
{
- edge const old_edge
- = find_edge ((basic_block) new_edge->src->aux, bb);
- tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
- tree new_arg = arg;
+ edge old_edge = find_edge ((basic_block) new_edge->src->aux, bb);
+ tree arg;
+ tree new_arg;
tree block = id->block;
+ edge_iterator ei2;
+
+ /* When doing partial clonning, we allow PHIs on the entry block
+ as long as all the arguments are the same. Find any input
+ edge to see argument to copy. */
+ if (!old_edge)
+ FOR_EACH_EDGE (old_edge, ei2, bb->preds)
+ if (!old_edge->src->aux)
+ break;
+
+ arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge);
+ new_arg = arg;
id->block = NULL_TREE;
walk_tree (&new_arg, copy_tree_body_r, id, NULL);
id->block = block;
|| (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index)))
need_debug_cleanup |= copy_edges_for_bb (bb, count_scale, exit_block_map);
- if (gimple_in_ssa_p (cfun))
- FOR_ALL_BB_FN (bb, cfun_to_copy)
- if (!blocks_to_copy
- || (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index)))
- copy_phis_for_bb (bb, id);
-
if (new_entry)
{
edge e;
e->count = entry_block_map->count;
}
+ if (gimple_in_ssa_p (cfun))
+ FOR_ALL_BB_FN (bb, cfun_to_copy)
+ if (!blocks_to_copy
+ || (bb->index > 0 && bitmap_bit_p (blocks_to_copy, bb->index)))
+ copy_phis_for_bb (bb, id);
+
FOR_ALL_BB_FN (bb, cfun_to_copy)
if (bb->aux)
{