[patch] Add block debug info to phi_arg_d
Dehao Chen
dehao@google.com
Thu Jul 5 09:09:00 GMT 2012
Hi,
This patch added block field to phi_arg_d to make sure the associated
source locus is consistent with its block info.
Bootstrapped and passed gcc regression tests.
OK for trunk?
Thanks,
Dehao
http://codereview.appspot.com/6349075
gcc/ChangeLog
2012-07-05 Dehao Chen <dehao@google.com>
* tree.h (phi_arg_d): New field.
* tree-flow-inline.h (gimple_phi_arg_block): New function.
(gimple_phi_arg_block_from_edge): New function.
(gimple_phi_arg_set_block): New function.
(gimple_phi_arg_has_block): New function.
(redirect_edge_var_map_block): New function.
* tree-flow.h (_edge_var_map): New field.
* tree-ssa-live.c (remove_unused_locals): Mark phi_arg's block
as used.
* tree-eh.c (cleanup_empty_eh_merge_phis): Add block debug info for
redirect_edge_var_map_add.
* tree-outof-ssa.c (_elim_graph): New field.
(insert_partition_copy_on_edge): New parameter.
(insert_value_copy_on_edge): New parameter.
(insert_rtx_to_part_on_edge): New parameter.
(insert_part_to_rtx_on_edge): New parameter.
(elim_graph_add_edge): New parameter.
(elim_graph_remove_succ_edge): New parameter.
(FOR_EACH_ELIM_GRAPH_SUCC): New parameter.
(FOR_EACH_ELIM_GRAPH_PRED): New parameter.
(new_elim_graph): Add block debug info.
(clear_elim_graph): Likewise.
(delete_elim_graph): Likewise.
(elim_graph_add_node): Likewise.
(elim_graph_add_edge): Likewise.
(elim_graph_remove_succ_edge): Likewise.
(eliminate_build): Likewise.
(elim_forward): Likewise.
(elim_unvisited_predecessor): Likewise.
(elim_backward): Likewise.
(elim_create): Likewise.
(eliminate_phi): Likewise.
(insert_backedge_copies): Likewise.
* tree-into-ssa.c (insert_phi_nodes_for): Add block debug info for
add_phi_arg.
(rewrite_add_phi_arguments): Likewise.
* tree-ssa-loop-im.c (execute_sm_if_changed): Likewise.
* tree-ssa-tail-merge.c (replace_block_by): Likewise.
* tree-ssa-threadupdate.c (copy_phi_args): Likewise.
* tree-loop-distribution.c (update_phis_for_loop_copy): Likewise.
* tree-ssa-loop-manip.c (create_iv): Likewise.
(add_exit_phis_edge): Likewise.
(split_loop_exit_edge): Likewise.
(copy_phi_node_args): Likewise.
(tree_transform_and_unroll_loop): Likewise.
* value-prof.c (gimple_ic): Likewise.
(gimple_stringop_fixed_value): Likewise.
* tree-tailcall.c (add_successor_phi_arg): Likewise.
(eliminate_tail_call): Likewise.
(create_tailcall_accumulator): Likewise.
(tree_optimize_tail_calls_1): Likewise.
* tree-phinodes.c (add_phi_arg): Likewise.
(make_phi_node): Likewise.
(resize_phi_node): Likewise.
(remove_phi_arg_num): Likewise.
* omp-low.c (expand_parallel_call): Likewise.
(expand_omp_for_static_chunk): Likewise.
* tree-vect-loop-manip.c (slpeel_update_phis_for_duplicate_loop):
Likewise.
(slpeel_update_phi_nodes_for_guard1): Likewise.
(slpeel_update_phi_nodes_for_guard2): Likewise.
(slpeel_tree_duplicate_loop_to_edge_cfg): Likewise.
(set_prologue_iterations): Likewise.
(slpeel_tree_peel_loop_to_edge): Likewise.
(vect_loop_versioning): Likewise.
* tree-parloops.c (create_phi_for_local_result): Likewise.
(transform_to_exit_first_loop): Likewise.
(create_parallel_loop): Likewise.
* ipa-split.c (split_function): Likewise.
* tree-vect-loop.c (get_initial_def_for_induction): Likewise.
(vect_create_epilog_for_reduction): Likewise.
* tree-vect-data-refs.c (vect_setup_realignment): Likewise.
* graphite-scop-detection.c (canonicalize_loop_closed_ssa): Likewise.
* tree-ssa-phiopt.c (cond_store_replacement): Likewise.
(cond_if_else_store_replacement_1): Likewise.
* tree-cfgcleanup.c (remove_forwarder_block): Likewise.
(remove_forwarder_block_with_phi): Likewise.
* tree-ssa-pre.c (insert_into_preds_of_block): Likewise.
* tree-predcom.c (initialize_root_vars): Likewise.
(initialize_root_vars_lm): Likewise.
* sese.c (sese_add_exit_phis_edge): Likewise.
* tree-ssa-dce.c (forward_edge_to_pdom): Likewise.
* tree-ssa.c (flush_pending_stmts): Likewise.
(redirect_edge_var_map_add): Likewise.
(ssa_redirect_edge): Likewise.
* gimple-streamer-in.c (input_phi): Likewise.
* tree-vect-stmts.c (vectorizable_load): Likewise.
* tree-inline.c (copy_phis_for_bb): Likewise.
* tree-ssa-phiprop.c (phiprop_insert_phi): Likewise.
* tree-switch-conversion.c (fix_phi_nodes): Likewise.
* tree-cfg.c (reinstall_phi_args): Likewise.
(gimple_make_forwarder_block): Likewise.
(add_phi_args_after_copy_edge): Likewise.
(gimple_duplicate_sese_tail): Likewise.
Index: gcc/tree-into-ssa.c
===================================================================
--- gcc/tree-into-ssa.c (revision 189246)
+++ gcc/tree-into-ssa.c (working copy)
@@ -1119,7 +1119,7 @@
renamer will use the symbol on the LHS to get its
reaching definition. */
FOR_EACH_EDGE (e, ei, bb->preds)
- add_phi_arg (phi, var, e, UNKNOWN_LOCATION);
+ add_phi_arg (phi, var, e, UNKNOWN_LOCATION, NULL);
}
else
{
@@ -1474,7 +1474,8 @@
phi = gsi_stmt (gsi);
currdef = get_reaching_def (SSA_NAME_VAR (gimple_phi_result (phi)));
stmt = SSA_NAME_DEF_STMT (currdef);
- add_phi_arg (phi, currdef, e, gimple_location (stmt));
+ add_phi_arg (phi, currdef, e, gimple_location (stmt),
+ gimple_block (stmt));
}
}
}
Index: gcc/tree-ssa-loop-im.c
===================================================================
--- gcc/tree-ssa-loop-im.c (revision 189246)
+++ gcc/tree-ssa-loop-im.c (working copy)
@@ -2086,7 +2086,7 @@
if (gimple_phi_arg_edge (phi, i)->src == new_bb)
{
tree arg = gimple_phi_arg_def (phi, i);
- add_phi_arg (phi, arg, then_old_edge, UNKNOWN_LOCATION);
+ add_phi_arg (phi, arg, then_old_edge, UNKNOWN_LOCATION, NULL);
update_stmt (phi);
}
}
Index: gcc/tree-ssa-tail-merge.c
===================================================================
--- gcc/tree-ssa-tail-merge.c (revision 189246)
+++ gcc/tree-ssa-tail-merge.c (working copy)
@@ -1458,7 +1458,7 @@
bb2_phi = vop_phi (bb2);
add_phi_arg (bb2_phi, SSA_NAME_VAR (gimple_phi_result (bb2_phi)),
- pred_edge, UNKNOWN_LOCATION);
+ pred_edge, UNKNOWN_LOCATION, NULL);
}
bb2->frequency += bb1->frequency;
Index: gcc/tree-ssa-threadupdate.c
===================================================================
--- gcc/tree-ssa-threadupdate.c (revision 189246)
+++ gcc/tree-ssa-threadupdate.c (working copy)
@@ -316,7 +316,9 @@
{
gimple phi = gsi_stmt (gsi);
source_location locus = gimple_phi_arg_location (phi, src_indx);
- add_phi_arg (phi, gimple_phi_arg_def (phi, src_indx), tgt_e, locus);
+ tree block = gimple_phi_arg_block (phi, src_indx);
+ add_phi_arg (phi, gimple_phi_arg_def (phi, src_indx), tgt_e, locus,
+ block);
}
}
Index: gcc/tree-loop-distribution.c
===================================================================
--- gcc/tree-loop-distribution.c (revision 189246)
+++ gcc/tree-loop-distribution.c (working copy)
@@ -171,6 +171,7 @@
{
tree def;
source_location locus;
+ tree block;
gimple phi_new = gsi_stmt (si_new);
gimple phi_orig = gsi_stmt (si_orig);
@@ -178,12 +179,14 @@
associated with the entry of NEW_LOOP) */
def = PHI_ARG_DEF_FROM_EDGE (phi_orig, orig_entry_e);
locus = gimple_phi_arg_location_from_edge (phi_orig, orig_entry_e);
- add_phi_arg (phi_new, def, new_loop_entry_e, locus);
+ block = gimple_phi_arg_block_from_edge (phi_orig, orig_entry_e);
+ add_phi_arg (phi_new, def, new_loop_entry_e, locus, block);
/* Add the second phi argument for the phi in NEW_LOOP (the one
associated with the latch of NEW_LOOP) */
def = PHI_ARG_DEF_FROM_EDGE (phi_orig, orig_loop_latch);
locus = gimple_phi_arg_location_from_edge (phi_orig, orig_loop_latch);
+ block = gimple_phi_arg_block_from_edge (phi_orig, orig_loop_latch);
if (TREE_CODE (def) == SSA_NAME)
{
@@ -198,7 +201,8 @@
/* Could be an integer. */
new_ssa_name = def;
- add_phi_arg (phi_new, new_ssa_name, loop_latch_edge (new_loop), locus);
+ add_phi_arg (phi_new, new_ssa_name, loop_latch_edge (new_loop), locus,
+ block);
}
}
Index: gcc/tree-ssa-loop-manip.c
===================================================================
--- gcc/tree-ssa-loop-manip.c (revision 189246)
+++ gcc/tree-ssa-loop-manip.c (working copy)
@@ -121,8 +121,9 @@
stmt = create_phi_node (vb, loop->header);
SSA_NAME_DEF_STMT (vb) = stmt;
- add_phi_arg (stmt, initial, loop_preheader_edge (loop), UNKNOWN_LOCATION);
- add_phi_arg (stmt, va, loop_latch_edge (loop), UNKNOWN_LOCATION);
+ add_phi_arg (stmt, initial, loop_preheader_edge (loop), UNKNOWN_LOCATION,
+ NULL);
+ add_phi_arg (stmt, va, loop_latch_edge (loop), UNKNOWN_LOCATION, NULL);
}
/* Add exit phis for the USE on EXIT. */
@@ -152,7 +153,7 @@
create_new_def_for (gimple_phi_result (phi), phi,
gimple_phi_result_ptr (phi));
FOR_EACH_EDGE (e, ei, exit->preds)
- add_phi_arg (phi, use, e, UNKNOWN_LOCATION);
+ add_phi_arg (phi, use, e, UNKNOWN_LOCATION, NULL);
}
/* Add exit phis for VAR that is used in LIVEIN.
@@ -485,12 +486,14 @@
use_operand_p op_p;
gimple_stmt_iterator psi;
source_location locus;
+ tree block;
for (psi = gsi_start_phis (dest); !gsi_end_p (psi); gsi_next (&psi))
{
phi = gsi_stmt (psi);
op_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, single_succ_edge (bb));
locus = gimple_phi_arg_location_from_edge (phi, single_succ_edge (bb));
+ block = gimple_phi_arg_block_from_edge (phi, single_succ_edge (bb));
name = USE_FROM_PTR (op_p);
@@ -504,7 +507,7 @@
new_name = duplicate_ssa_name (name, NULL);
new_phi = create_phi_node (new_name, bb);
SSA_NAME_DEF_STMT (new_name) = new_phi;
- add_phi_arg (new_phi, name, exit, locus);
+ add_phi_arg (new_phi, name, exit, locus, block);
SET_USE (op_p, new_name);
}
@@ -1024,8 +1027,8 @@
phi_rest = create_phi_node (new_init, rest);
SSA_NAME_DEF_STMT (new_init) = phi_rest;
- add_phi_arg (phi_rest, init, precond_edge, UNKNOWN_LOCATION);
- add_phi_arg (phi_rest, next, new_exit, UNKNOWN_LOCATION);
+ add_phi_arg (phi_rest, init, precond_edge, UNKNOWN_LOCATION, NULL);
+ add_phi_arg (phi_rest, next, new_exit, UNKNOWN_LOCATION, NULL);
SET_USE (op, new_init);
}
Index: gcc/value-prof.c
===================================================================
--- gcc/value-prof.c (revision 189246)
+++ gcc/value-prof.c (working copy)
@@ -1245,10 +1245,12 @@
SSA_NAME_DEF_STMT (result) = phi;
gimple_call_set_lhs (icall_stmt,
make_ssa_name (SSA_NAME_VAR (result), icall_stmt));
- add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
+ add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION,
+ NULL);
gimple_call_set_lhs (dcall_stmt,
make_ssa_name (SSA_NAME_VAR (result), dcall_stmt));
- add_phi_arg (phi, gimple_call_lhs (dcall_stmt), e_dj, UNKNOWN_LOCATION);
+ add_phi_arg (phi, gimple_call_lhs (dcall_stmt), e_dj, UNKNOWN_LOCATION,
+ NULL);
}
/* Build an EH edge for the direct call if necessary. */
@@ -1476,10 +1478,12 @@
SSA_NAME_DEF_STMT (result) = phi;
gimple_call_set_lhs (vcall_stmt,
make_ssa_name (SSA_NAME_VAR (result), vcall_stmt));
- add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION);
+ add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION,
+ NULL);
gimple_call_set_lhs (icall_stmt,
make_ssa_name (SSA_NAME_VAR (result), icall_stmt));
- add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
+ add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION,
+ NULL);
}
/* Because these are all string op builtins, they're all nothrow. */
Index: gcc/tree-tailcall.c
===================================================================
--- gcc/tree-tailcall.c (revision 189246)
+++ gcc/tree-tailcall.c (working copy)
@@ -597,7 +597,7 @@
break;
gcc_assert (!gsi_end_p (gsi));
- add_phi_arg (gsi_stmt (gsi), phi_arg, e, UNKNOWN_LOCATION);
+ add_phi_arg (gsi_stmt (gsi), phi_arg, e, UNKNOWN_LOCATION, NULL);
}
/* Creates a GIMPLE statement which computes the operation specified by
@@ -853,7 +853,7 @@
phi = gsi_stmt (gsi);
gcc_assert (param == SSA_NAME_VAR (PHI_RESULT (phi)));
- add_phi_arg (phi, arg, e, gimple_location (stmt));
+ add_phi_arg (phi, arg, e, gimple_location (stmt), gimple_block (stmt));
gsi_next (&gsi);
}
@@ -948,7 +948,7 @@
phi = create_phi_node (tmp, bb);
/* RET_TYPE can be a float when -ffast-maths is enabled. */
add_phi_arg (phi, fold_convert (ret_type, init), single_pred_edge (bb),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
return PHI_RESULT (phi);
}
@@ -1012,7 +1012,7 @@
phi = create_phi_node (name, first);
SSA_NAME_DEF_STMT (name) = phi;
add_phi_arg (phi, new_name, single_pred_edge (first),
- EXPR_LOCATION (param));
+ EXPR_LOCATION (param), NULL);
}
phis_constructed = true;
}
Index: gcc/tree.h
===================================================================
--- gcc/tree.h (revision 189246)
+++ gcc/tree.h (working copy)
@@ -2036,6 +2036,7 @@
struct ssa_use_operand_d imm_use;
tree def;
location_t locus;
+ tree block;
};
Index: gcc/tree-phinodes.c
===================================================================
--- gcc/tree-phinodes.c (revision 189246)
+++ gcc/tree-phinodes.c (working copy)
@@ -205,6 +205,7 @@
use_operand_p imm;
gimple_phi_arg_set_location (phi, i, UNKNOWN_LOCATION);
+ gimple_phi_arg_set_block (phi, i ,NULL);
imm = gimple_phi_arg_imm_use_ptr (phi, i);
imm->use = gimple_phi_arg_def_ptr (phi, i);
imm->prev = NULL;
@@ -275,6 +276,7 @@
use_operand_p imm;
gimple_phi_arg_set_location (new_phi, i, UNKNOWN_LOCATION);
+ gimple_phi_arg_set_block (new_phi, i, NULL);
imm = gimple_phi_arg_imm_use_ptr (new_phi, i);
imm->use = gimple_phi_arg_def_ptr (new_phi, i);
imm->prev = NULL;
@@ -362,7 +364,7 @@
PHI points to the reallocated phi node when we return. */
void
-add_phi_arg (gimple phi, tree def, edge e, source_location locus)
+add_phi_arg (gimple phi, tree def, edge e, source_location locus, tree block)
{
basic_block bb = e->dest;
@@ -386,6 +388,7 @@
SET_PHI_ARG_DEF (phi, e->dest_idx, def);
gimple_phi_arg_set_location (phi, e->dest_idx, locus);
+ gimple_phi_arg_set_block (phi, e->dest_idx, block);
}
@@ -417,6 +420,8 @@
/* Move the location as well. */
gimple_phi_arg_set_location (phi, i,
gimple_phi_arg_location (phi, num_elem - 1));
+ gimple_phi_arg_set_block (phi, i,
+ gimple_phi_arg_block (phi, num_elem - 1));
}
/* Shrink the vector and return. Note that we do not have to clear
Index: gcc/omp-low.c
===================================================================
--- gcc/omp-low.c (revision 189246)
+++ gcc/omp-low.c (working copy)
@@ -3061,8 +3061,8 @@
{
gimple phi = create_phi_node (tmp_join, bb);
SSA_NAME_DEF_STMT (tmp_join) = phi;
- add_phi_arg (phi, tmp_then, e_then, UNKNOWN_LOCATION);
- add_phi_arg (phi, tmp_else, e_else, UNKNOWN_LOCATION);
+ add_phi_arg (phi, tmp_then, e_then, UNKNOWN_LOCATION, NULL);
+ add_phi_arg (phi, tmp_else, e_else, UNKNOWN_LOCATION, NULL);
}
val = tmp_join;
@@ -4597,6 +4597,7 @@
{
gimple nphi;
source_location locus;
+ tree block;
phi = gsi_stmt (psi);
t = gimple_phi_result (phi);
@@ -4606,14 +4607,16 @@
t = PHI_ARG_DEF_FROM_EDGE (phi, se);
locus = gimple_phi_arg_location_from_edge (phi, se);
+ block = gimple_phi_arg_block_from_edge (phi, se);
/* A special case -- fd->loop.v is not yet computed in
iter_part_bb, we need to use v_extra instead. */
if (t == fd->loop.v)
t = v_extra;
- add_phi_arg (nphi, t, ene, locus);
+ add_phi_arg (nphi, t, ene, locus, block);
locus = redirect_edge_var_map_location (vm);
- add_phi_arg (nphi, redirect_edge_var_map_def (vm), re, locus);
+ block = redirect_edge_var_map_block (vm);
+ add_phi_arg (nphi, redirect_edge_var_map_def (vm), re, locus, block);
}
gcc_assert (!gsi_end_p (psi) && i == VEC_length (edge_var_map, head));
redirect_edge_var_map_clear (re);
@@ -4629,9 +4632,9 @@
phi = create_phi_node (trip_main, iter_part_bb);
SSA_NAME_DEF_STMT (trip_main) = phi;
add_phi_arg (phi, trip_back, single_succ_edge (trip_update_bb),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
add_phi_arg (phi, trip_init, single_succ_edge (entry_bb),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
}
set_immediate_dominator (CDI_DOMINATORS, trip_update_bb, cont_bb);
Index: gcc/tree-vect-loop-manip.c
===================================================================
--- gcc/tree-vect-loop-manip.c (revision 189246)
+++ gcc/tree-vect-loop-manip.c (working copy)
@@ -294,13 +294,15 @@
gsi_next (&gsi_new), gsi_next (&gsi_orig))
{
source_location locus;
+ tree block;
phi_new = gsi_stmt (gsi_new);
phi_orig = gsi_stmt (gsi_orig);
/* step 1. */
def = PHI_ARG_DEF_FROM_EDGE (phi_orig, entry_arg_e);
locus = gimple_phi_arg_location_from_edge (phi_orig, entry_arg_e);
- add_phi_arg (phi_new, def, new_loop_entry_e, locus);
+ block = gimple_phi_arg_block_from_edge (phi_orig, entry_arg_e);
+ add_phi_arg (phi_new, def, new_loop_entry_e, locus, block);
/* step 2. */
def = PHI_ARG_DEF_FROM_EDGE (phi_orig, orig_loop_latch);
@@ -317,7 +319,8 @@
}
/* An ordinary ssa name defined in the loop. */
- add_phi_arg (phi_new, new_ssa_name, loop_latch_edge (new_loop), locus);
+ add_phi_arg (phi_new, new_ssa_name, loop_latch_edge (new_loop), locus,
+ block);
/* Drop any debug references outside the loop, if they would
become ill-formed SSA. */
@@ -512,6 +515,7 @@
gsi_next (&gsi_orig), gsi_next (&gsi_update))
{
source_location loop_locus, guard_locus;
+ tree loop_block, guard_block;
orig_phi = gsi_stmt (gsi_orig);
update_phi = gsi_stmt (gsi_update);
@@ -527,13 +531,19 @@
loop_locus = gimple_phi_arg_location_from_edge (orig_phi,
EDGE_SUCC (loop->latch,
0));
+ loop_block = gimple_phi_arg_block_from_edge (orig_phi,
+ EDGE_SUCC (loop->latch,
+ 0));
+
guard_arg = PHI_ARG_DEF_FROM_EDGE (orig_phi, loop_preheader_edge (loop));
guard_locus
= gimple_phi_arg_location_from_edge (orig_phi,
loop_preheader_edge (loop));
+ guard_block = gimple_phi_arg_block_from_edge (orig_phi,
+ loop_preheader_edge (loop));
- add_phi_arg (new_phi, loop_arg, new_exit_e, loop_locus);
- add_phi_arg (new_phi, guard_arg, guard_edge, guard_locus);
+ add_phi_arg (new_phi, loop_arg, new_exit_e, loop_locus, loop_block);
+ add_phi_arg (new_phi, guard_arg, guard_edge, guard_locus, guard_block);
/* 1.3. Update phi in successor block. */
gcc_assert (PHI_ARG_DEF_FROM_EDGE (update_phi, e) == loop_arg
@@ -552,7 +562,7 @@
*new_exit_bb);
/* 2.2. NEW_EXIT_BB has one incoming edge: the exit-edge of the loop. */
- add_phi_arg (new_phi, loop_arg, single_exit (loop), loop_locus);
+ add_phi_arg (new_phi, loop_arg, single_exit (loop), loop_locus,
loop_block);
/* 2.3. Update phi in successor of NEW_EXIT_BB: */
gcc_assert (PHI_ARG_DEF_FROM_EDGE (update_phi2, new_exit_e) == loop_arg);
@@ -680,8 +690,8 @@
if (new_name2)
guard_arg = new_name2;
- add_phi_arg (new_phi, loop_arg, new_exit_e, UNKNOWN_LOCATION);
- add_phi_arg (new_phi, guard_arg, guard_edge, UNKNOWN_LOCATION);
+ add_phi_arg (new_phi, loop_arg, new_exit_e, UNKNOWN_LOCATION, NULL);
+ add_phi_arg (new_phi, guard_arg, guard_edge, UNKNOWN_LOCATION, NULL);
/* 1.3. Update phi in successor block. */
gcc_assert (PHI_ARG_DEF_FROM_EDGE (update_phi, e) == orig_def);
@@ -696,7 +706,8 @@
*new_exit_bb);
/* 2.2. NEW_EXIT_BB has one incoming edge: the exit-edge of the loop. */
- add_phi_arg (new_phi, loop_arg, single_exit (loop), UNKNOWN_LOCATION);
+ add_phi_arg (new_phi, loop_arg, single_exit (loop), UNKNOWN_LOCATION,
+ NULL);
/* 2.3. Update phi in successor of NEW_EXIT_BB: */
gcc_assert (PHI_ARG_DEF_FROM_EDGE (update_phi2, new_exit_e) == loop_arg);
@@ -733,7 +744,7 @@
/* 3.3. GUARD_BB has one incoming edge: */
gcc_assert (EDGE_COUNT (guard_edge->src->preds) == 1);
add_phi_arg (new_phi, arg, EDGE_PRED (guard_edge->src, 0),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
/* 3.4. Update phi in successor of GUARD_BB: */
gcc_assert (PHI_ARG_DEF_FROM_EDGE (update_phi2, guard_edge)
@@ -859,14 +870,16 @@
{
edge new_loop_exit_edge;
source_location locus;
+ tree block;
locus = gimple_phi_arg_location_from_edge (phi, single_exit (loop));
+ block = gimple_phi_arg_block_from_edge (phi, single_exit (loop));
if (EDGE_SUCC (new_loop->header, 0)->dest == new_loop->latch)
new_loop_exit_edge = EDGE_SUCC (new_loop->header, 1);
else
new_loop_exit_edge = EDGE_SUCC (new_loop->header, 0);
- add_phi_arg (phi, phi_arg, new_loop_exit_edge, locus);
+ add_phi_arg (phi, phi_arg, new_loop_exit_edge, locus, block);
}
}
@@ -905,7 +918,8 @@
phi_arg = PHI_ARG_DEF_FROM_EDGE (phi, entry_e);
if (phi_arg)
add_phi_arg (phi, phi_arg, new_exit_e,
- gimple_phi_arg_location_from_edge (phi, entry_e));
+ gimple_phi_arg_location_from_edge (phi, entry_e),
+ gimple_phi_arg_block_from_edge (phi, entry_e));
}
redirect_edge_and_branch_force (entry_e, new_loop->header);
@@ -1089,8 +1103,8 @@
newphi = create_phi_node (var, bb_before_first_loop);
add_phi_arg (newphi, prologue_after_cost_adjust_name, e_fallthru,
- UNKNOWN_LOCATION);
- add_phi_arg (newphi, *first_niters, e_false, UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
+ add_phi_arg (newphi, *first_niters, e_false, UNKNOWN_LOCATION, NULL);
*first_niters = PHI_RESULT (newphi);
}
@@ -1193,7 +1207,7 @@
new_phi);
use_operand_p use_p;
- add_phi_arg (new_phi, vop, exit_e, UNKNOWN_LOCATION);
+ add_phi_arg (new_phi, vop, exit_e, UNKNOWN_LOCATION, NULL);
gimple_phi_set_result (new_phi, new_vop);
FOR_EACH_IMM_USE_STMT (stmt, imm_iter, vop)
if (stmt != new_phi && gimple_bb (stmt) != loop->header)
@@ -2551,7 +2565,8 @@
new_exit_bb);
arg = PHI_ARG_DEF_FROM_EDGE (orig_phi, e);
add_phi_arg (new_phi, arg, new_exit_e,
- gimple_phi_arg_location_from_edge (orig_phi, e));
+ gimple_phi_arg_location_from_edge (orig_phi, e),
+ gimple_phi_arg_block_from_edge (orig_phi, e));
adjust_phi_and_debug_stmts (orig_phi, e, PHI_RESULT (new_phi));
}
Index: gcc/tree-parloops.c
===================================================================
--- gcc/tree-parloops.c (revision 189246)
+++ gcc/tree-parloops.c (working copy)
@@ -998,6 +998,7 @@
basic_block store_bb;
tree local_res;
source_location locus;
+ tree block;
/* STORE_BB is the block where the phi
should be stored. It is the destination of the loop exit.
@@ -1017,11 +1018,12 @@
= make_ssa_name (SSA_NAME_VAR (gimple_assign_lhs (reduc->reduc_stmt)),
NULL);
locus = gimple_location (reduc->reduc_stmt);
+ block = gimple_block (reduc->reduc_stmt);
new_phi = create_phi_node (local_res, store_bb);
SSA_NAME_DEF_STMT (local_res) = new_phi;
- add_phi_arg (new_phi, reduc->init, e, locus);
+ add_phi_arg (new_phi, reduc->init, e, locus, block);
add_phi_arg (new_phi, gimple_assign_lhs (reduc->reduc_stmt),
- FALLTHRU_EDGE (loop->latch), locus);
+ FALLTHRU_EDGE (loop->latch), locus, block);
reduc->new_phi = new_phi;
return 1;
@@ -1500,7 +1502,7 @@
SET_PHI_RESULT (phi, t);
nphi = create_phi_node (res, orig_header);
SSA_NAME_DEF_STMT (res) = nphi;
- add_phi_arg (nphi, t, hpred, UNKNOWN_LOCATION);
+ add_phi_arg (nphi, t, hpred, UNKNOWN_LOCATION, NULL);
if (res == control)
{
@@ -1656,6 +1658,7 @@
for (gsi = gsi_start_phis (ex_bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
source_location locus;
+ tree block;
tree def;
phi = gsi_stmt (gsi);
stmt = SSA_NAME_DEF_STMT (PHI_ARG_DEF_FROM_EDGE (phi, exit));
@@ -1663,11 +1666,14 @@
def = PHI_ARG_DEF_FROM_EDGE (stmt, loop_preheader_edge (loop));
locus = gimple_phi_arg_location_from_edge (stmt,
loop_preheader_edge (loop));
- add_phi_arg (phi, def, guard, locus);
+ block = gimple_phi_arg_block_from_edge (stmt,
+ loop_preheader_edge (loop));
+ add_phi_arg (phi, def, guard, locus, block);
def = PHI_ARG_DEF_FROM_EDGE (stmt, loop_latch_edge (loop));
locus = gimple_phi_arg_location_from_edge (stmt, loop_latch_edge (loop));
- add_phi_arg (phi, def, end, locus);
+ block = gimple_phi_arg_block_from_edge (stmt, loop_latch_edge (loop));
+ add_phi_arg (phi, def, end, locus, block);
}
e = redirect_edge_and_branch (exit, nexit->dest);
PENDING_STMT (e) = NULL;
Index: gcc/tree-eh.c
===================================================================
--- gcc/tree-eh.c (revision 189246)
+++ gcc/tree-eh.c (working copy)
@@ -3853,13 +3853,15 @@
FOR_EACH_EDGE (e, ei, old_bb->preds)
{
location_t oloc;
+ tree oblock;
tree oop;
if ((e->flags & EDGE_EH) == 0)
continue;
oop = gimple_phi_arg_def (ophi, e->dest_idx);
oloc = gimple_phi_arg_location (ophi, e->dest_idx);
- redirect_edge_var_map_add (e, nresult, oop, oloc);
+ oblock = gimple_phi_arg_block (ophi, e->dest_idx);
+ redirect_edge_var_map_add (e, nresult, oop, oloc, oblock);
}
}
/* If we didn't find the PHI, but it's a VOP, remember to rename
@@ -3874,8 +3876,9 @@
{
location_t nloc
= gimple_phi_arg_location (nphi, old_bb_out->dest_idx);
+ tree nblock = gimple_phi_arg_block (nphi, old_bb_out->dest_idx);
FOR_EACH_EDGE (e, ei, old_bb->preds)
- redirect_edge_var_map_add (e, nresult, nop, nloc);
+ redirect_edge_var_map_add (e, nresult, nop, nloc, nblock);
}
}
Index: gcc/ipa-split.c
===================================================================
--- gcc/ipa-split.c (revision 189246)
+++ gcc/ipa-split.c (working copy)
@@ -1286,7 +1286,8 @@
/* When there is PHI, just update its value. */
if (TREE_CODE (retval) == SSA_NAME
&& !gsi_end_p (psi))
- add_phi_arg (gsi_stmt (psi), retval, e, UNKNOWN_LOCATION);
+ add_phi_arg (gsi_stmt (psi), retval, e, UNKNOWN_LOCATION,
+ NULL);
/* Otherwise update the return BB itself.
find_return_bb allows at most one assignment to return value,
so update first statement. */
Index: gcc/tree-vect-loop.c
===================================================================
--- gcc/tree-vect-loop.c (revision 189246)
+++ gcc/tree-vect-loop.c (working copy)
@@ -3131,9 +3131,9 @@
NULL));
/* Set the arguments of the phi node: */
- add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION);
+ add_phi_arg (induction_phi, vec_init, pe, UNKNOWN_LOCATION, NULL);
add_phi_arg (induction_phi, vec_def, loop_latch_edge (iv_loop),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
/* In case that vectorization factor (VF) is bigger than the number
@@ -3617,13 +3617,13 @@
{
/* Set the loop-entry arg of the reduction-phi. */
add_phi_arg (phi, vec_init_def, loop_preheader_edge (loop),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
/* Set the loop-latch arg for the reduction-phi. */
if (j > 0)
def = vect_get_vec_def_for_stmt_copy (vect_unknown_def_type, def);
- add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
+ add_phi_arg (phi, def, loop_latch_edge (loop),
UNKNOWN_LOCATION, NULL);
if (vect_print_dump_info (REPORT_DETAILS))
{
@@ -4241,9 +4241,10 @@
/* Update phi node arguments with vs0 and vs2. */
add_phi_arg (vect_phi, vect_phi_init,
loop_preheader_edge (outer_loop),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
add_phi_arg (vect_phi, PHI_RESULT (inner_phi),
- loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
+ loop_latch_edge (outer_loop), UNKNOWN_LOCATION,
+ NULL);
if (vect_print_dump_info (REPORT_DETAILS))
{
fprintf (vect_dump, "created double reduction phi "
Index: gcc/tree-flow-inline.h
===================================================================
--- gcc/tree-flow-inline.h (revision 189246)
+++ gcc/tree-flow-inline.h (working copy)
@@ -483,6 +483,22 @@
return gimple_phi_arg (gs, e->dest_idx)->locus;
}
+/* Return the block location of gimple argument I of phi node GS. */
+
+static inline tree
+gimple_phi_arg_block (gimple gs, size_t i)
+{
+ return gimple_phi_arg (gs, i)->block;
+}
+
+/* Return the block location of the argument on edge E of phi node GS. */
+
+static inline tree
+gimple_phi_arg_block_from_edge (gimple gs, edge e)
+{
+ return gimple_phi_arg (gs, e->dest_idx)->block;
+}
+
/* Set the source location of gimple argument I of phi node GS to LOC. */
static inline void
@@ -491,6 +507,14 @@
gimple_phi_arg (gs, i)->locus = loc;
}
+/* Set the block location of gimple argument I of phi node GS to BLOCK. */
+
+static inline void
+gimple_phi_arg_set_block (gimple gs, size_t i, tree block)
+{
+ gimple_phi_arg (gs, i)->block = block;
+}
+
/* Return TRUE if argument I of phi node GS has a location record. */
static inline bool
@@ -499,6 +523,13 @@
return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION;
}
+/* Return TRUE if argument I of phi node GS has a location record. */
+
+static inline bool
+gimple_phi_arg_has_block (gimple gs, size_t i)
+{
+ return gimple_phi_arg_block (gs, i) != NULL;
+}
/* Return the PHI nodes for basic block BB, or NULL if there are no
PHI nodes. */
@@ -1217,6 +1248,13 @@
return v->locus;
}
+/* Given an edge_var_map V, return the PHI arg location. */
+
+static inline tree
+redirect_edge_var_map_block (edge_var_map *v)
+{
+ return v->block;
+}
/* Return an SSA_NAME node for variable VAR defined in statement STMT
in function cfun. */
Index: gcc/tree-vect-data-refs.c
===================================================================
--- gcc/tree-vect-data-refs.c (revision 189246)
+++ gcc/tree-vect-data-refs.c (working copy)
@@ -4407,7 +4407,7 @@
msq = make_ssa_name (vec_dest, NULL);
phi_stmt = create_phi_node (msq, containing_loop->header);
SSA_NAME_DEF_STMT (msq) = phi_stmt;
- add_phi_arg (phi_stmt, msq_init, pe, UNKNOWN_LOCATION);
+ add_phi_arg (phi_stmt, msq_init, pe, UNKNOWN_LOCATION, NULL);
return msq;
}
Index: gcc/graphite-scop-detection.c
===================================================================
--- gcc/graphite-scop-detection.c (revision 189246)
+++ gcc/graphite-scop-detection.c (working copy)
@@ -1331,7 +1331,7 @@
gimple_phi_result_ptr (close_phi));
add_phi_arg (close_phi, arg,
gimple_phi_arg_edge (close_phi, 0),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
use_p = gimple_phi_arg_imm_use_ptr (phi, i);
replace_exp (use_p, res);
update_stmt (phi);
Index: gcc/tree-ssa-phiopt.c
===================================================================
--- gcc/tree-ssa-phiopt.c (revision 189246)
+++ gcc/tree-ssa-phiopt.c (working copy)
@@ -1454,6 +1454,7 @@
gimple newphi, new_stmt;
gimple_stmt_iterator gsi;
source_location locus;
+ tree block;
/* Check if middle_bb contains of only one store. */
if (!assign
@@ -1461,6 +1462,7 @@
return false;
locus = gimple_location (assign);
+ block = gimple_block (assign);
lhs = gimple_assign_lhs (assign);
rhs = gimple_assign_rhs1 (assign);
if (TREE_CODE (lhs) != MEM_REF
@@ -1494,14 +1496,15 @@
name = make_ssa_name (condstoretemp, new_stmt);
gimple_assign_set_lhs (new_stmt, name);
gimple_set_location (new_stmt, locus);
+ gimple_set_block (new_stmt, block);
gsi_insert_on_edge (e1, new_stmt);
/* 4) Create a PHI node at the join block, with one argument
holding the old RHS, and the other holding the temporary
where we stored the old memory contents. */
newphi = create_phi_node (condstoretemp, join_bb);
- add_phi_arg (newphi, rhs, e0, locus);
- add_phi_arg (newphi, name, e1, locus);
+ add_phi_arg (newphi, rhs, e0, locus, block);
+ add_phi_arg (newphi, name, e1, locus, block);
lhs = unshare_expr (lhs);
new_stmt = gimple_build_assign (lhs, PHI_RESULT (newphi));
@@ -1528,6 +1531,7 @@
{
tree lhs_base, lhs, then_rhs, else_rhs;
source_location then_locus, else_locus;
+ tree then_block, else_block;
gimple_stmt_iterator gsi;
gimple newphi, new_stmt;
@@ -1553,6 +1557,8 @@
else_rhs = gimple_assign_rhs1 (else_assign);
then_locus = gimple_location (then_assign);
else_locus = gimple_location (else_assign);
+ then_block = gimple_block (then_assign);
+ else_block = gimple_block (else_assign);
/* Now we've checked the constraints, so do the transformation:
1) Remove the stores. */
@@ -1576,8 +1582,10 @@
holding the old RHS, and the other holding the temporary
where we stored the old memory contents. */
newphi = create_phi_node (condstoretemp, join_bb);
- add_phi_arg (newphi, then_rhs, EDGE_SUCC (then_bb, 0), then_locus);
- add_phi_arg (newphi, else_rhs, EDGE_SUCC (else_bb, 0), else_locus);
+ add_phi_arg (newphi, then_rhs, EDGE_SUCC (then_bb, 0), then_locus,
+ then_block);
+ add_phi_arg (newphi, else_rhs, EDGE_SUCC (else_bb, 0), else_locus,
+ else_block);
new_stmt = gimple_build_assign (lhs, PHI_RESULT (newphi));
Index: gcc/tree-cfgcleanup.c
===================================================================
--- gcc/tree-cfgcleanup.c (revision 189246)
+++ gcc/tree-cfgcleanup.c (working copy)
@@ -444,7 +444,9 @@
{
gimple phi = gsi_stmt (gsi);
source_location l = gimple_phi_arg_location_from_edge (phi, succ);
- add_phi_arg (phi, gimple_phi_arg_def (phi, succ->dest_idx), s, l);
+ tree b = gimple_phi_arg_block_from_edge (phi, succ);
+ add_phi_arg (phi, gimple_phi_arg_def (phi, succ->dest_idx), s, l,
+ b);
}
}
}
@@ -871,6 +873,7 @@
gimple phi = gsi_stmt (gsi);
tree def = gimple_phi_arg_def (phi, succ->dest_idx);
source_location locus = gimple_phi_arg_location_from_edge (phi, succ);
+ tree block = gimple_phi_arg_block_from_edge (phi, succ);
if (TREE_CODE (def) == SSA_NAME)
{
@@ -891,12 +894,13 @@
{
def = new_arg;
locus = redirect_edge_var_map_location (vm);
+ block = redirect_edge_var_map_block (vm);
break;
}
}
}
- add_phi_arg (phi, def, s, locus);
+ add_phi_arg (phi, def, s, locus, block);
}
redirect_edge_var_map_clear (e);
Index: gcc/tree-ssa-pre.c
===================================================================
--- gcc/tree-ssa-pre.c (revision 189246)
+++ gcc/tree-ssa-pre.c (working copy)
@@ -3403,10 +3403,10 @@
gcc_assert (get_expr_type (ae) == type
|| useless_type_conversion_p (type, get_expr_type (ae)));
if (ae->kind == CONSTANT)
- add_phi_arg (phi, PRE_EXPR_CONSTANT (ae), pred, UNKNOWN_LOCATION);
+ add_phi_arg (phi, PRE_EXPR_CONSTANT (ae), pred, UNKNOWN_LOCATION, NULL);
else
add_phi_arg (phi, PRE_EXPR_NAME (avail[pred->src->index]), pred,
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
}
newphi = get_or_alloc_expr_for_name (gimple_phi_result (phi));
Index: gcc/tree-ssa-live.c
===================================================================
--- gcc/tree-ssa-live.c (revision 189246)
+++ gcc/tree-ssa-live.c (working copy)
@@ -765,6 +765,10 @@
FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES)
{
tree arg = USE_FROM_PTR (arg_p);
+ int index = PHI_ARG_INDEX_FROM_USE (arg_p);
+ tree block = gimple_phi_arg_block (phi, index);
+ if (block != NULL)
+ TREE_USED (block) = true;
mark_all_vars_used (&arg, global_unused_vars);
}
}
Index: gcc/tree-predcom.c
===================================================================
--- gcc/tree-predcom.c (revision 189246)
+++ gcc/tree-predcom.c (working copy)
@@ -1531,8 +1531,8 @@
phi = create_phi_node (var, loop->header);
SSA_NAME_DEF_STMT (var) = phi;
- add_phi_arg (phi, init, entry, UNKNOWN_LOCATION);
- add_phi_arg (phi, next, latch, UNKNOWN_LOCATION);
+ add_phi_arg (phi, init, entry, UNKNOWN_LOCATION, NULL);
+ add_phi_arg (phi, next, latch, UNKNOWN_LOCATION, NULL);
}
}
@@ -1595,8 +1595,8 @@
next = VEC_index (tree, *vars, 1);
phi = create_phi_node (var, loop->header);
SSA_NAME_DEF_STMT (var) = phi;
- add_phi_arg (phi, init, entry, UNKNOWN_LOCATION);
- add_phi_arg (phi, next, latch, UNKNOWN_LOCATION);
+ add_phi_arg (phi, init, entry, UNKNOWN_LOCATION, NULL);
+ add_phi_arg (phi, next, latch, UNKNOWN_LOCATION, NULL);
}
else
{
Index: gcc/sese.c
===================================================================
--- gcc/sese.c (revision 189246)
+++ gcc/sese.c (working copy)
@@ -349,8 +349,8 @@
create_new_def_for (gimple_phi_result (phi), phi,
gimple_phi_result_ptr (phi));
- add_phi_arg (phi, use, false_e, UNKNOWN_LOCATION);
- add_phi_arg (phi, use, true_e, UNKNOWN_LOCATION);
+ add_phi_arg (phi, use, false_e, UNKNOWN_LOCATION, NULL);
+ add_phi_arg (phi, use, true_e, UNKNOWN_LOCATION, NULL);
}
/* Insert in the block BB phi nodes for variables defined in REGION
Index: gcc/tree-ssa-dce.c
===================================================================
--- gcc/tree-ssa-dce.c (revision 189246)
+++ gcc/tree-ssa-dce.c (working copy)
@@ -1129,6 +1129,7 @@
gimple phi = gsi_stmt (gsi);
tree op;
source_location locus;
+ tree block;
/* PHIs for virtuals have no control dependency relation on them.
We are lost here and must force renaming of the symbol. */
@@ -1148,7 +1149,8 @@
op = gimple_phi_arg_def (phi, e2->dest_idx);
locus = gimple_phi_arg_location (phi, e2->dest_idx);
- add_phi_arg (phi, op, e, locus);
+ block = gimple_phi_arg_block (phi, e2->dest_idx);
+ add_phi_arg (phi, op, e, locus, block);
/* The resulting PHI if not dead can only be degenerate. */
gcc_assert (degenerate_phi_p (phi));
gsi_next (&gsi);
Index: gcc/tree-ssa.c
===================================================================
--- gcc/tree-ssa.c (revision 189246)
+++ gcc/tree-ssa.c (working copy)
@@ -51,7 +51,8 @@
/* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
void
-redirect_edge_var_map_add (edge e, tree result, tree def,
source_location locus)
+redirect_edge_var_map_add (edge e, tree result, tree def,
source_location locus,
+ tree block)
{
void **slot;
edge_var_map_vector old_head, head;
@@ -70,6 +71,7 @@
new_node.def = def;
new_node.result = result;
new_node.locus = locus;
+ new_node.block = block;
VEC_safe_push (edge_var_map, heap, head, &new_node);
if (old_head != head)
@@ -193,15 +195,17 @@
{
tree def;
source_location locus ;
+ tree block;
phi = gsi_stmt (gsi);
def = gimple_phi_arg_def (phi, e->dest_idx);
locus = gimple_phi_arg_location (phi, e->dest_idx);
+ block = gimple_phi_arg_block (phi, e->dest_idx);
if (def == NULL_TREE)
continue;
- redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus);
+ redirect_edge_var_map_add (e, gimple_phi_result (phi), def,
locus, block);
}
e = redirect_edge_succ_nodup (e, dest);
@@ -234,7 +238,8 @@
phi = gsi_stmt (gsi);
def = redirect_edge_var_map_def (vm);
- add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
+ add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm),
+ redirect_edge_var_map_block (vm));
}
redirect_edge_var_map_clear (e);
Index: gcc/gimple-streamer-in.c
===================================================================
--- gcc/gimple-streamer-in.c (revision 189246)
+++ gcc/gimple-streamer-in.c (working copy)
@@ -67,7 +67,7 @@
break;
}
- add_phi_arg (result, def, e, arg_loc);
+ add_phi_arg (result, def, e, arg_loc, NULL);
}
return result;
Index: gcc/tree-vect-stmts.c
===================================================================
--- gcc/tree-vect-stmts.c (revision 189246)
+++ gcc/tree-vect-stmts.c (working copy)
@@ -5117,7 +5117,7 @@
if (i == vec_num - 1 && j == ncopies - 1)
add_phi_arg (phi, lsq,
loop_latch_edge (containing_loop),
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
msq = lsq;
}
}
Index: gcc/tree-inline.c
===================================================================
--- gcc/tree-inline.c (revision 189246)
+++ gcc/tree-inline.c (working copy)
@@ -2019,6 +2019,7 @@
tree arg;
tree new_arg;
tree block = id->block;
+ tree arg_block, *n;
edge_iterator ei2;
/* When doing partial cloning, we allow PHIs on the entry block
@@ -2046,8 +2047,15 @@
gsi_insert_seq_on_edge (new_edge, stmts);
inserted = true;
}
+ n = (tree *) pointer_map_contains (id->decl_map,
+ gimple_phi_arg_block_from_edge (phi, old_edge));
+ if (n)
+ arg_block = *n;
+ else
+ arg_block = NULL;
add_phi_arg (new_phi, new_arg, new_edge,
- gimple_phi_arg_location_from_edge (phi, old_edge));
+ gimple_phi_arg_location_from_edge (phi, old_edge),
+ arg_block);
}
}
}
Index: gcc/tree-ssa-phiprop.c
===================================================================
--- gcc/tree-ssa-phiprop.c (revision 189246)
+++ gcc/tree-ssa-phiprop.c (working copy)
@@ -159,9 +159,11 @@
tree old_arg, new_var;
gimple tmp;
source_location locus;
+ tree block;
old_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
locus = gimple_phi_arg_location_from_edge (phi, e);
+ block = gimple_phi_arg_block_from_edge (phi, e);
while (TREE_CODE (old_arg) == SSA_NAME
&& (SSA_NAME_VERSION (old_arg) >= n
|| phivn[SSA_NAME_VERSION (old_arg)].value == NULL_TREE))
@@ -169,6 +171,7 @@
gimple def_stmt = SSA_NAME_DEF_STMT (old_arg);
old_arg = gimple_assign_rhs1 (def_stmt);
locus = gimple_location (def_stmt);
+ block = gimple_block (def_stmt);
}
if (TREE_CODE (old_arg) == SSA_NAME)
@@ -203,6 +206,7 @@
new_var = make_ssa_name (new_var, tmp);
gimple_assign_set_lhs (tmp, new_var);
gimple_set_location (tmp, locus);
+ gimple_set_block (tmp, block);
gsi_insert_on_edge (e, tmp);
update_stmt (tmp);
@@ -216,7 +220,7 @@
}
}
- add_phi_arg (new_phi, new_var, e, locus);
+ add_phi_arg (new_phi, new_var, e, locus, block);
}
update_stmt (new_phi);
Index: gcc/tree-outof-ssa.c
===================================================================
--- gcc/tree-outof-ssa.c (revision 189246)
+++ gcc/tree-outof-ssa.c (working copy)
@@ -78,6 +78,9 @@
/* Source locus on each edge */
VEC(source_location,heap) *edge_locus;
+ /* Block location on each edge. */
+ VEC(tree,heap) *edge_block;
+
/* Visited vector. */
sbitmap visited;
@@ -96,6 +99,9 @@
/* Source locations for any constant copies. */
VEC(source_location,heap) *copy_locus;
+
+ /* Block locations for any constant copies. */
+ VEC(tree,heap) *copy_block;
} *elim_graph;
@@ -174,7 +180,8 @@
/* Insert a copy instruction from partition SRC to DEST onto edge E. */
static void
-insert_partition_copy_on_edge (edge e, int dest, int src,
source_location locus)
+insert_partition_copy_on_edge (edge e, int dest, int src,
source_location locus,
+ tree block)
{
tree var;
rtx seq;
@@ -194,7 +201,10 @@
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ {
+ set_curr_insn_source_location (locus);
+ set_curr_insn_block (block);
+ }
var = partition_to_var (SA.map, src);
seq = emit_partition_copy (SA.partition_to_pseudo[dest],
@@ -209,7 +219,8 @@
onto edge E. */
static void
-insert_value_copy_on_edge (edge e, int dest, tree src, source_location locus)
+insert_value_copy_on_edge (edge e, int dest, tree src, source_location locus,
+ tree block)
{
rtx seq, x;
enum machine_mode dest_mode, src_mode;
@@ -231,7 +242,10 @@
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ {
+ set_curr_insn_source_location (locus);
+ set_curr_insn_block (block);
+ }
start_sequence ();
@@ -269,7 +283,7 @@
static void
insert_rtx_to_part_on_edge (edge e, int dest, rtx src, int unsignedsrcp,
- source_location locus)
+ source_location locus, tree block)
{
rtx seq;
if (dump_file && (dump_flags & TDF_DETAILS))
@@ -287,7 +301,10 @@
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ {
+ set_curr_insn_source_location (locus);
+ set_curr_insn_block (block);
+ }
/* We give the destination as sizeexp in case src/dest are BLKmode
mems. Usually we give the source. As we result from SSA names
@@ -304,7 +321,8 @@
onto edge E. */
static void
-insert_part_to_rtx_on_edge (edge e, rtx dest, int src, source_location locus)
+insert_part_to_rtx_on_edge (edge e, rtx dest, int src, source_location locus,
+ tree block)
{
tree var;
rtx seq;
@@ -323,7 +341,10 @@
set_location_for_edge (e);
/* If a locus is provided, override the default. */
if (locus)
- set_curr_insn_source_location (locus);
+ {
+ set_curr_insn_source_location (locus);
+ set_curr_insn_block (block);
+ }
var = partition_to_var (SA.map, src);
seq = emit_partition_copy (dest,
@@ -347,8 +368,10 @@
g->const_dests = VEC_alloc (int, heap, 20);
g->const_copies = VEC_alloc (tree, heap, 20);
g->copy_locus = VEC_alloc (source_location, heap, 10);
+ g->copy_block = VEC_alloc (tree, heap, 10);
g->edge_list = VEC_alloc (int, heap, 20);
g->edge_locus = VEC_alloc (source_location, heap, 10);
+ g->edge_block = VEC_alloc (tree, heap, 10);
g->stack = VEC_alloc (int, heap, 30);
g->visited = sbitmap_alloc (size);
@@ -365,6 +388,7 @@
VEC_truncate (int, g->nodes, 0);
VEC_truncate (int, g->edge_list, 0);
VEC_truncate (source_location, g->edge_locus, 0);
+ VEC_truncate (tree, g->edge_block, 0);
}
@@ -380,7 +404,9 @@
VEC_free (int, heap, g->const_dests);
VEC_free (int, heap, g->nodes);
VEC_free (source_location, heap, g->copy_locus);
+ VEC_free (tree, heap, g->copy_block);
VEC_free (source_location, heap, g->edge_locus);
+ VEC_free (tree, heap, g->edge_block);
free (g);
}
@@ -413,11 +439,13 @@
/* Add the edge PRED->SUCC to graph G. */
static inline void
-elim_graph_add_edge (elim_graph g, int pred, int succ, source_location locus)
+elim_graph_add_edge (elim_graph g, int pred, int succ, source_location locus,
+ tree block)
{
VEC_safe_push (int, heap, g->edge_list, pred);
VEC_safe_push (int, heap, g->edge_list, succ);
VEC_safe_push (source_location, heap, g->edge_locus, locus);
+ VEC_safe_push (tree, heap, g->edge_block, block);
}
@@ -425,7 +453,8 @@
return the successor node. -1 is returned if there is no such edge. */
static inline int
-elim_graph_remove_succ_edge (elim_graph g, int node, source_location *locus)
+elim_graph_remove_succ_edge (elim_graph g, int node, source_location *locus,
+ tree *block)
{
int y;
unsigned x;
@@ -437,9 +466,12 @@
VEC_replace (int, g->edge_list, x + 1, -1);
*locus = VEC_index (source_location, g->edge_locus, x / 2);
VEC_replace (source_location, g->edge_locus, x / 2, UNKNOWN_LOCATION);
+ *block = VEC_index (tree, g->edge_block, x / 2);
+ VEC_replace (tree, g->edge_block, x / 2, NULL);
return y;
}
*locus = UNKNOWN_LOCATION;
+ *block = NULL;
return -1;
}
@@ -448,7 +480,7 @@
edge list. VAR will hold the partition number found. CODE is the
code fragment executed for every node found. */
-#define FOR_EACH_ELIM_GRAPH_SUCC(GRAPH, NODE, VAR, LOCUS, CODE) \
+#define FOR_EACH_ELIM_GRAPH_SUCC(GRAPH, NODE, VAR, LOCUS, BLOCK, CODE) \
do { \
unsigned x_; \
int y_; \
@@ -460,6 +492,8 @@
(void) ((VAR) = VEC_index (int, (GRAPH)->edge_list, x_ + 1)); \
(void) ((LOCUS) = VEC_index (source_location, \
(GRAPH)->edge_locus, x_ / 2)); \
+ (void) ((BLOCK) = VEC_index (tree, \
+ (GRAPH)->edge_block, x_ / 2)); \
CODE; \
} \
} while (0)
@@ -469,7 +503,7 @@
GRAPH. VAR will hold the partition number found. CODE is the
code fragment executed for every node found. */
-#define FOR_EACH_ELIM_GRAPH_PRED(GRAPH, NODE, VAR, LOCUS, CODE) \
+#define FOR_EACH_ELIM_GRAPH_PRED(GRAPH, NODE, VAR, LOCUS, BLOCK, CODE) \
do { \
unsigned x_; \
int y_; \
@@ -481,6 +515,8 @@
(void) ((VAR) = VEC_index (int, (GRAPH)->edge_list, x_)); \
(void) ((LOCUS) = VEC_index (source_location, \
(GRAPH)->edge_locus, x_ / 2)); \
+ (void) ((BLOCK) = VEC_index (tree, \
+ (GRAPH)->edge_block, x_ / 2)); \
CODE; \
} \
} while (0)
@@ -511,6 +547,7 @@
{
gimple phi = gsi_stmt (gsi);
source_location locus;
+ tree block;
p0 = var_to_partition (g->map, gimple_phi_result (phi));
/* Ignore results which are not in partitions. */
@@ -519,6 +556,7 @@
Ti = PHI_ARG_DEF (phi, g->e->dest_idx);
locus = gimple_phi_arg_location_from_edge (phi, g->e);
+ block = gimple_phi_arg_block_from_edge (phi, g->e);
/* If this argument is a constant, or a SSA_NAME which is being
left in SSA form, just queue a copy to be emitted on this
@@ -532,6 +570,7 @@
VEC_safe_push (int, heap, g->const_dests, p0);
VEC_safe_push (tree, heap, g->const_copies, Ti);
VEC_safe_push (source_location, heap, g->copy_locus, locus);
+ VEC_safe_push (tree, heap, g->copy_block, block);
}
else
{
@@ -540,7 +579,7 @@
{
eliminate_name (g, p0);
eliminate_name (g, pi);
- elim_graph_add_edge (g, p0, pi, locus);
+ elim_graph_add_edge (g, p0, pi, locus, block);
}
}
}
@@ -554,9 +593,10 @@
{
int S;
source_location locus;
+ tree block;
SET_BIT (g->visited, T);
- FOR_EACH_ELIM_GRAPH_SUCC (g, T, S, locus,
+ FOR_EACH_ELIM_GRAPH_SUCC (g, T, S, locus, block,
{
if (!TEST_BIT (g->visited, S))
elim_forward (g, S);
@@ -572,8 +612,9 @@
{
int P;
source_location locus;
+ tree block;
- FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
+ FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus, block,
{
if (!TEST_BIT (g->visited, P))
return 1;
@@ -588,14 +629,15 @@
{
int P;
source_location locus;
+ tree block;
SET_BIT (g->visited, T);
- FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
+ FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus, block,
{
if (!TEST_BIT (g->visited, P))
{
elim_backward (g, P);
- insert_partition_copy_on_edge (g->e, P, T, locus);
+ insert_partition_copy_on_edge (g->e, P, T, locus, block);
}
});
}
@@ -624,6 +666,7 @@
{
int P, S;
source_location locus;
+ tree block;
if (elim_unvisited_predecessor (g, T))
{
@@ -631,23 +674,24 @@
rtx U = get_temp_reg (var);
int unsignedsrcp = TYPE_UNSIGNED (TREE_TYPE (var));
- insert_part_to_rtx_on_edge (g->e, U, T, UNKNOWN_LOCATION);
- FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
+ insert_part_to_rtx_on_edge (g->e, U, T, UNKNOWN_LOCATION, NULL);
+ FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus, block,
{
if (!TEST_BIT (g->visited, P))
{
elim_backward (g, P);
- insert_rtx_to_part_on_edge (g->e, P, U, unsignedsrcp, locus);
+ insert_rtx_to_part_on_edge (g->e, P, U, unsignedsrcp, locus,
+ block);
}
});
}
else
{
- S = elim_graph_remove_succ_edge (g, T, &locus);
+ S = elim_graph_remove_succ_edge (g, T, &locus, &block);
if (S != -1)
{
SET_BIT (g->visited, T);
- insert_partition_copy_on_edge (g->e, T, S, locus);
+ insert_partition_copy_on_edge (g->e, T, S, locus, block);
}
}
}
@@ -662,6 +706,7 @@
gcc_assert (VEC_length (tree, g->const_copies) == 0);
gcc_assert (VEC_length (source_location, g->copy_locus) == 0);
+ gcc_assert (VEC_length (tree, g->copy_block) == 0);
/* Abnormal edges already have everything coalesced. */
if (e->flags & EDGE_ABNORMAL)
@@ -699,11 +744,13 @@
int dest;
tree src;
source_location locus;
+ tree block;
src = VEC_pop (tree, g->const_copies);
dest = VEC_pop (int, g->const_dests);
locus = VEC_pop (source_location, g->copy_locus);
- insert_value_copy_on_edge (e, dest, src, locus);
+ block = VEC_pop (tree, g->copy_block);
+ insert_value_copy_on_edge (e, dest, src, locus, block);
}
}
@@ -1088,8 +1135,12 @@
/* copy location if present. */
if (gimple_phi_arg_has_location (phi, i))
- gimple_set_location (stmt,
- gimple_phi_arg_location (phi, i));
+ {
+ gimple_set_location (stmt,
+ gimple_phi_arg_location (phi, i));
+ gimple_set_block (stmt,
+ gimple_phi_arg_block (phi, i));
+ }
/* Insert the new statement into the block and update
the PHI node. */
Index: gcc/tree-flow.h
===================================================================
--- gcc/tree-flow.h (revision 189246)
+++ gcc/tree-flow.h (working copy)
@@ -506,7 +506,7 @@
extern void reserve_phi_args_for_new_edge (basic_block);
extern void add_phi_node_to_bb (gimple phi, basic_block bb);
extern gimple create_phi_node (tree, basic_block);
-extern void add_phi_arg (gimple, tree, edge, source_location);
+extern void add_phi_arg (gimple, tree, edge, source_location, tree);
extern void remove_phi_args (edge);
extern void remove_phi_node (gimple_stmt_iterator *, bool);
extern void remove_phi_nodes (basic_block);
@@ -530,6 +530,7 @@
tree result; /* PHI result. */
tree def; /* PHI arg definition. */
source_location locus; /* PHI arg location. */
+ tree block; /* PHI arg block. */
};
typedef struct _edge_var_map edge_var_map;
@@ -540,7 +541,7 @@
typedef VEC(edge_var_map, heap) *edge_var_map_vector;
extern void init_tree_ssa (struct function *);
-extern void redirect_edge_var_map_add (edge, tree, tree, source_location);
+extern void redirect_edge_var_map_add (edge, tree, tree,
source_location, tree);
extern void redirect_edge_var_map_clear (edge);
extern void redirect_edge_var_map_dup (edge, edge);
extern edge_var_map_vector redirect_edge_var_map_vector (edge);
Index: gcc/tree-switch-conversion.c
===================================================================
--- gcc/tree-switch-conversion.c (revision 189246)
+++ gcc/tree-switch-conversion.c (working copy)
@@ -1189,8 +1189,10 @@
!gsi_end_p (gsi); gsi_next (&gsi), i++)
{
gimple phi = gsi_stmt (gsi);
- add_phi_arg (phi, info->target_inbound_names[i], e1f, UNKNOWN_LOCATION);
- add_phi_arg (phi, info->target_outbound_names[i], e2f, UNKNOWN_LOCATION);
+ add_phi_arg (phi, info->target_inbound_names[i], e1f, UNKNOWN_LOCATION,
+ NULL);
+ add_phi_arg (phi, info->target_outbound_names[i], e2f, UNKNOWN_LOCATION,
+ NULL);
}
}
Index: gcc/tree-cfg.c
===================================================================
--- gcc/tree-cfg.c (revision 189246)
+++ gcc/tree-cfg.c (working copy)
@@ -2554,7 +2554,8 @@
gcc_assert (result == gimple_phi_result (phi));
- add_phi_arg (phi, arg, new_edge, redirect_edge_var_map_location (vm));
+ add_phi_arg (phi, arg, new_edge, redirect_edge_var_map_location (vm),
+ redirect_edge_var_map_block (vm));
}
redirect_edge_var_map_clear (old_edge);
@@ -5014,7 +5015,7 @@
SSA_NAME_DEF_STMT (var) = new_phi;
gimple_phi_set_result (phi, make_ssa_name (SSA_NAME_VAR (var), phi));
add_phi_arg (new_phi, gimple_phi_result (phi), fallthru,
- UNKNOWN_LOCATION);
+ UNKNOWN_LOCATION, NULL);
}
/* Add the arguments we have stored on edges. */
@@ -5475,7 +5476,8 @@
phi_copy = gsi_stmt (psi_copy);
def = PHI_ARG_DEF_FROM_EDGE (phi, e);
add_phi_arg (phi_copy, def, e_copy,
- gimple_phi_arg_location_from_edge (phi, e));
+ gimple_phi_arg_location_from_edge (phi, e),
+ gimple_phi_arg_block_from_edge (phi, e));
}
}
@@ -5850,7 +5852,8 @@
{
phi = gsi_stmt (psi);
def = PHI_ARG_DEF (phi, nexits[0]->dest_idx);
- add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e));
+ add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e),
+ gimple_phi_arg_block_from_edge (phi, e));
}
}
e = redirect_edge_and_branch (nexits[1], nexits[0]->dest);
@@ -7426,7 +7429,8 @@
phi1 = gsi_stmt (psi1);
phi2 = gsi_stmt (psi2);
def = PHI_ARG_DEF (phi2, e2->dest_idx);
- add_phi_arg (phi1, def, e, gimple_phi_arg_location_from_edge (phi2, e2));
+ add_phi_arg (phi1, def, e, gimple_phi_arg_location_from_edge (phi2, e2),
+ gimple_phi_arg_block_from_edge (phi2, e2));
}
}
More information about the Gcc-patches
mailing list