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));
     }
 }

