From patchwork Thu Jul 5 09:08:58 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dehao Chen X-Patchwork-Id: 169099 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 17E1F2C0089 for ; Thu, 5 Jul 2012 19:09:40 +1000 (EST) Comment: DKIM? See http://www.dkim.org DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d=gcc.gnu.org; s=default; x=1342084182; h=Comment: DomainKey-Signature:Received:Received:Received:Received:Received: MIME-Version:Received:Received:Date:Message-ID:Subject:From:To: Cc:Content-Type:Content-Transfer-Encoding:Mailing-List: Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:Sender:Delivered-To; bh=RnNI+rK21Ac3smlxn51afkz2lH8=; b=JqepnTH5srijiZ5DngRenTd/6L7TtwsbP8ibieGWeZa/v2LUEr63yY3bIiWj84 vLmc50zAJSwjnTLti0HBeOsuCG0Vfa76yTL8Xs14TLNxntoFTLeEp0bfnjEyRmOu yRxQf9GTye0brUpKYrcJHGpPdCqzZDo0o55dctCVnfoIw= Comment: DomainKeys? See http://antispam.yahoo.com/domainkeys DomainKey-Signature: a=rsa-sha1; q=dns; c=nofws; s=default; d=gcc.gnu.org; h=Received:Received:X-SWARE-Spam-Status:X-Spam-Check-By:Received:Received:X-Google-DKIM-Signature:Received:MIME-Version:Received:Received:Date:Message-ID:Subject:From:To:Cc:Content-Type:Content-Transfer-Encoding:X-System-Of-Record:X-Gm-Message-State:X-IsSubscribed:Mailing-List:Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help:Sender:Delivered-To; b=O53anMVtcQuRKsel3qA0FH8Jbp4ZwXb0xmfveKzpZ1PhOc93yq+AixiWQ94o4B Dv6eavRjqWDAxIb/YLVywnJFYTsxhNnvEp/n/fVz+ijbqE61YglH+NEVb2woi1Fc mnHwmbQ2nz/m9VQd/DMSVWGUL4+v/xxJqpWJCHYQmPGK8=; Received: (qmail 5996 invoked by alias); 5 Jul 2012 09:09:33 -0000 Received: (qmail 5952 invoked by uid 22791); 5 Jul 2012 09:09:23 -0000 X-SWARE-Spam-Status: No, hits=-4.7 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, KHOP_RCVD_TRUST, RCVD_IN_DNSWL_LOW, RCVD_IN_HOSTKARMA_YE, TW_TM, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail-pb0-f47.google.com (HELO mail-pb0-f47.google.com) (209.85.160.47) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 05 Jul 2012 09:08:59 +0000 Received: by pbbrq2 with SMTP id rq2so12643147pbb.20 for ; Thu, 05 Jul 2012 02:08:58 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=mime-version:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding:x-system-of-record:x-gm-message-state; bh=ugj5SRwGPoZn+StDSwKKluXNmvxP1dmdiaUJ6wVQGdM=; b=WgkKo91nOllQEpBbWod6Xk37xpPHnMZ0UzY144xzrXxpB/93PjixQ9ViEpOLSsZYJZ baGo2q4j7uhp/hpoEfUx9UquKduadWgvAolzY3ibZhDBxCWgivAl4GZ/DtB4uBptyf37 cDdYcMHRF4gY1iUpfbOfweOXiD++tBU/rhlj6QwnpinKiHGTkpy6nv5THBgTwpEjPbB9 rXZix4ZVs4+UqfVb6urBHMUzXMCqgX0hESpdlIlzO80ydtVo8lKTQqluacFxTLn4QM4t 0vAWZ6d8F2f27uSj5lIwIPJFJBaW+IaWSKX+Ry4TN8InJ2pdE/ykrI/AJXBXMJyz6ym/ FIfQ== Received: by 10.68.221.38 with SMTP id qb6mr26063858pbc.144.1341479338300; Thu, 05 Jul 2012 02:08:58 -0700 (PDT) MIME-Version: 1.0 Received: by 10.68.221.38 with SMTP id qb6mr26063834pbc.144.1341479338139; Thu, 05 Jul 2012 02:08:58 -0700 (PDT) Received: by 10.68.49.231 with HTTP; Thu, 5 Jul 2012 02:08:58 -0700 (PDT) Date: Thu, 5 Jul 2012 17:08:58 +0800 Message-ID: Subject: [patch] Add block debug info to phi_arg_d From: Dehao Chen To: gcc-patches@gcc.gnu.org Cc: Richard Guenther , Cary Coutant X-System-Of-Record: true X-Gm-Message-State: ALoCoQmGrz8V0t0U1iMiSFcQtxC71A8rvQu5H5JAia5P9NwRbxFUKBOn0jyunKPLPKWXFfTsC8z5HUN+/Dc3i7s/8J2UmzKMC+Pyq9RIsKsK5GF+nFY8aDj2h/+4WxMVCic8Luv4MeIFMV0yuf0wKZpiZ/vYCdwJaQvYpEskfaWtYgT3m8xhBixHJ0nSw14KxLb7xifb61PD X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org 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 * 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)); } }