--- a/gcc/regmove.c	Sun Feb 07 18:28:00 2010 +0900
+++ b/gcc/regmove.c	Fri Feb 12 23:39:51 2010 +0900
@@ -44,28 +44,34 @@
 #include "timevar.h"
 #include "tree-pass.h"
 #include "df.h"
+#include "ira.h"
 
-static int perhaps_ends_bb_p (rtx);
 static int optimize_reg_copy_1 (rtx, rtx, rtx);
 static void optimize_reg_copy_2 (rtx, rtx, rtx);
 static void optimize_reg_copy_3 (rtx, rtx, rtx);
 static void copy_src_to_dest (rtx, rtx, rtx);
 
+enum match_use
+{
+  READ,
+  WRITE,
+  READWRITE
+};
+
 struct match {
   int with[MAX_RECOG_OPERANDS];
-  enum { READ, WRITE, READWRITE } use[MAX_RECOG_OPERANDS];
+  enum match_use use[MAX_RECOG_OPERANDS];
   int commutative[MAX_RECOG_OPERANDS];
   int early_clobber[MAX_RECOG_OPERANDS];
 };
 
 static int find_matches (rtx, struct match *);
-static int regclass_compatible_p (int, int);
 static int fixup_match_2 (rtx, rtx, rtx, rtx);
 
 /* Return nonzero if registers with CLASS1 and CLASS2 can be merged without
    causing too much register allocation problems.  */
 static int
-regclass_compatible_p (int class0, int class1)
+regclass_compatible_p (enum reg_class class0, enum reg_class class1)
 {
   return (class0 == class1
 	  || (reg_class_subset_p (class0, class1)
@@ -100,7 +106,7 @@
 
   if (code == MEM && GET_CODE (XEXP (x, 0)) == PLUS
       && XEXP (XEXP (x, 0), 0) == reg
-      && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
+      && CONST_INT_P (XEXP (XEXP (x, 0), 1))
       && INTVAL (XEXP (XEXP (x, 0), 1)) == plusconst)
     return x;
 
@@ -179,7 +185,9 @@
 		   &SET_SRC (inc_insn_set),
 		   XEXP (SET_SRC (inc_insn_set), 0), 1);
 	      validate_change (insn, &XEXP (use, 0),
-			       gen_rtx_fmt_e (inc_code, Pmode, reg), 1);
+			       gen_rtx_fmt_e (inc_code,
+					      GET_MODE (XEXP (use, 0)), reg),
+			       1);
 	      if (apply_change_group ())
 		{
 		  /* If there is a REG_DEAD note on this insn, we must
@@ -190,7 +198,7 @@
 		     changed.  */
 		  rtx note = find_reg_note (insn, REG_DEAD, reg);
 		  if (note)
-		    PUT_MODE (note, REG_UNUSED);
+		    PUT_REG_NOTE_KIND (note, REG_UNUSED);
 
 		  add_reg_note (insn, REG_INC, reg);
 
@@ -208,30 +216,6 @@
 
 static int *regno_src_regno;
 
-
-/* Return 1 if INSN might end a basic block.  */
-
-static int perhaps_ends_bb_p (rtx insn)
-{
-  switch (GET_CODE (insn))
-    {
-    case CODE_LABEL:
-    case JUMP_INSN:
-      /* These always end a basic block.  */
-      return 1;
-
-    case CALL_INSN:
-      /* A CALL_INSN might be the last insn of a basic block, if it is inside
-	 an EH region or if there are nonlocal gotos.  Note that this test is
-	 very conservative.  */
-      if (nonlocal_goto_handler_labels)
-	return 1;
-      /* Fall through.  */
-    default:
-      return can_throw_internal (insn);
-    }
-}
-
 /* INSN is a copy from SRC to DEST, both registers, and SRC does not die
    in INSN.
 
@@ -251,6 +235,7 @@
   rtx dest_death = 0;
   int sregno = REGNO (src);
   int dregno = REGNO (dest);
+  basic_block bb = BLOCK_FOR_INSN (insn);
 
   /* We don't want to mess with hard regs if register classes are small.  */
   if (sregno == dregno
@@ -264,12 +249,10 @@
 
   for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
     {
-      /* ??? We can't scan past the end of a basic block without updating
-	 the register lifetime info (REG_DEAD/basic_block_live_at_start).  */
-      if (perhaps_ends_bb_p (p))
+      if (! INSN_P (p))
+	continue;
+      if (BLOCK_FOR_INSN (p) != bb)
 	break;
-      else if (! INSN_P (p))
-	continue;
 
       if (reg_set_p (src, p) || reg_set_p (dest, p)
 	  /* If SRC is an asm-declared register, it must not be replaced
@@ -323,7 +306,7 @@
 		  if (sregno < FIRST_PSEUDO_REGISTER
 		      && reg_mentioned_p (dest, PATTERN (q)))
 		    failed = 1;
-		  
+
 		  /* Attempt to replace all uses.  */
 		  else if (!validate_replace_rtx (src, dest, q))
 		    failed = 1;
@@ -341,9 +324,12 @@
 	      /* For SREGNO, count the total number of insns scanned.
 		 For DREGNO, count the total number of insns scanned after
 		 passing the death note for DREGNO.  */
-	      s_length++;
-	      if (dest_death)
-		d_length++;
+	      if (!DEBUG_INSN_P (p))
+		{
+		  s_length++;
+		  if (dest_death)
+		    d_length++;
+		}
 
 	      /* If the insn in which SRC dies is a CALL_INSN, don't count it
 		 as a call that has been crossed.  Otherwise, count it.  */
@@ -457,15 +443,14 @@
   rtx set;
   int sregno = REGNO (src);
   int dregno = REGNO (dest);
+  basic_block bb = BLOCK_FOR_INSN (insn);
 
   for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
     {
-      /* ??? We can't scan past the end of a basic block without updating
-	 the register lifetime info (REG_DEAD/basic_block_live_at_start).  */
-      if (perhaps_ends_bb_p (p))
+      if (! INSN_P (p))
+	continue;
+      if (BLOCK_FOR_INSN (p) != bb)
 	break;
-      else if (! INSN_P (p))
-	continue;
 
       set = single_set (p);
       if (set && SET_SRC (set) == dest && SET_DEST (set) == src
@@ -530,6 +515,7 @@
   int dst_no = REGNO (dest);
   rtx p, set;
   enum machine_mode old_mode;
+  basic_block bb = BLOCK_FOR_INSN (insn);
 
   if (src_no < FIRST_PSEUDO_REGISTER
       || dst_no < FIRST_PSEUDO_REGISTER
@@ -537,13 +523,12 @@
       || REG_N_DEATHS (src_no) != 1
       || REG_N_SETS (src_no) != 1)
     return;
+
   for (p = PREV_INSN (insn); p && ! reg_set_p (src_reg, p); p = PREV_INSN (p))
-    /* ??? We can't scan past the end of a basic block without updating
-       the register lifetime info (REG_DEAD/basic_block_live_at_start).  */
-    if (perhaps_ends_bb_p (p))
+    if (INSN_P (p) && BLOCK_FOR_INSN (p) != bb)
       break;
 
-  if (! p)
+  if (! p || BLOCK_FOR_INSN (p) != bb)
     return;
 
   if (! (set = single_set (p))
@@ -620,8 +605,6 @@
   rtx *p_move_notes;
   int src_regno;
   int dest_regno;
-  int insn_uid;
-  int move_uid;
 
   /* A REG_LIVE_LENGTH of -1 indicates the register is equivalent to a constant
      or memory location and is used infrequently; a REG_LIVE_LENGTH of -2 is
@@ -677,9 +660,6 @@
       *p_move_notes = NULL_RTX;
       *p_insn_notes = NULL_RTX;
 
-      insn_uid = INSN_UID (insn);
-      move_uid = INSN_UID (move_insn);
-
       /* Update the various register tables.  */
       dest_regno = REGNO (dest);
       INC_REG_N_SETS (dest_regno, 1);
@@ -767,6 +747,7 @@
 {
   rtx p, dst_death = 0;
   int length, num_calls = 0, freq_calls = 0;
+  basic_block bb = BLOCK_FOR_INSN (insn);
 
   /* If SRC dies in INSN, we'd have to move the death note.  This is
      considered to be very unlikely, so we just skip the optimization
@@ -780,23 +761,21 @@
     {
       rtx pset;
 
-      /* ??? We can't scan past the end of a basic block without updating
-	 the register lifetime info (REG_DEAD/basic_block_live_at_start).  */
-      if (perhaps_ends_bb_p (p))
+      if (! INSN_P (p))
+	continue;
+      if (BLOCK_FOR_INSN (p) != bb)
 	break;
-      else if (! INSN_P (p))
-	continue;
 
       if (find_regno_note (p, REG_DEAD, REGNO (dst)))
 	dst_death = p;
-      if (! dst_death)
+      if (! dst_death && !DEBUG_INSN_P (p))
 	length++;
 
       pset = single_set (p);
       if (pset && SET_DEST (pset) == dst
 	  && GET_CODE (SET_SRC (pset)) == PLUS
 	  && XEXP (SET_SRC (pset), 0) == src
-	  && GET_CODE (XEXP (SET_SRC (pset), 1)) == CONST_INT)
+	  && CONST_INT_P (XEXP (SET_SRC (pset), 1)))
 	{
 	  HOST_WIDE_INT newconst
 	    = INTVAL (offset) - INTVAL (XEXP (SET_SRC (pset), 1));
@@ -821,11 +800,10 @@
 #ifdef AUTO_INC_DEC
 	      for (p = PREV_INSN (insn); p; p = PREV_INSN (p))
 		{
-		  if (LABEL_P (p)
-		      || JUMP_P (p))
-		    break;
 		  if (! INSN_P (p))
 		    continue;
+		  if (BLOCK_FOR_INSN (p) != bb)
+		    break;
 		  if (reg_overlap_mentioned_p (dst, PATTERN (p)))
 		    {
 		      if (try_auto_increment (p, insn, 0, dst, newconst, 0))
@@ -835,11 +813,10 @@
 		}
 	      for (p = NEXT_INSN (insn); p; p = NEXT_INSN (p))
 		{
-		  if (LABEL_P (p)
-		      || JUMP_P (p))
-		    break;
 		  if (! INSN_P (p))
 		    continue;
+		  if (BLOCK_FOR_INSN (p) != bb)
+		    break;
 		  if (reg_overlap_mentioned_p (dst, PATTERN (p)))
 		    {
 		      try_auto_increment (p, insn, 0, dst, newconst, 1);
@@ -882,40 +859,23 @@
   return 0;
 }
 
-/* Main entry for the register move optimization.  */
+/* A forward pass.  Replace output operands with input operands.  */
 
-static unsigned int
-regmove_optimize (void)
+static void
+regmove_forward_pass (void)
 {
+  basic_block bb;
   rtx insn;
-  struct match match;
-  int i;
-  rtx copy_src, copy_dst;
-  int nregs = max_reg_num ();
-
-  /* ??? Hack.  Regmove doesn't examine the CFG, and gets mightily
-     confused by non-call exceptions ending blocks.  */
-  if (flag_non_call_exceptions)
-    return 0;
 
-  df_note_add_problem ();
-  df_analyze ();
-
-  regstat_init_n_sets_and_refs ();
-  regstat_compute_ri ();
+  if (! flag_expensive_optimizations)
+    return;
 
-  regno_src_regno = XNEWVEC (int, nregs);
-  for (i = nregs; --i >= 0; )
-    regno_src_regno[i] = -1;
-
-  /* A forward pass.  Replace output operands with input operands.  */
+  if (dump_file)
+    fprintf (dump_file, "Starting forward pass...\n");
 
-  if (flag_expensive_optimizations)
+  FOR_EACH_BB (bb)
     {
-      if (dump_file)
-	fprintf (dump_file, "Starting forward pass...\n");
-
-      for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+      FOR_BB_INSNS (bb, insn)
 	{
 	  rtx set = single_set (insn);
 	  if (! set)
@@ -952,19 +912,33 @@
 	    }
 	}
     }
+}
 
-  /* A backward pass.  Replace input operands with output operands.  */
+/* A backward pass.  Replace input operands with output operands.  */
+
+static void
+regmove_backward_pass (void)
+{
+  basic_block bb;
+  rtx insn, prev;
 
   if (dump_file)
     fprintf (dump_file, "Starting backward pass...\n");
 
-  for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
+  FOR_EACH_BB_REVERSE (bb)
     {
-      if (INSN_P (insn))
+      /* ??? Use the safe iterator because fixup_match_2 can remove
+	     insns via try_auto_increment.  */
+      FOR_BB_INSNS_REVERSE_SAFE (bb, insn, prev)
 	{
+	  struct match match;
+	  rtx copy_src, copy_dst;
 	  int op_no, match_no;
 	  int success = 0;
 
+	  if (! INSN_P (insn))
+	    continue;
+
 	  if (! find_matches (insn, &match))
 	    continue;
 
@@ -1042,7 +1016,7 @@
 	      if (REGNO (src) < FIRST_PSEUDO_REGISTER)
 		{
 		  if (GET_CODE (SET_SRC (set)) == PLUS
-		      && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT
+		      && CONST_INT_P (XEXP (SET_SRC (set), 1))
 		      && XEXP (SET_SRC (set), 0) == src
 		      && fixup_match_2 (insn, dst, src,
 					XEXP (SET_SRC (set), 1)))
@@ -1117,15 +1091,13 @@
 		{
 		  rtx pset;
 
-		  /* ??? We can't scan past the end of a basic block without
-		     updating the register lifetime info
-		     (REG_DEAD/basic_block_live_at_start).  */
-		  if (perhaps_ends_bb_p (p))
+		  if (! INSN_P (p))
+		    continue;
+		  if (BLOCK_FOR_INSN (p) != bb)
 		    break;
-		  else if (! INSN_P (p))
-		    continue;
 
-		  length++;
+		  if (!DEBUG_INSN_P (p))
+		    length++;
 
 		  /* ??? See if all of SRC is set in P.  This test is much
 		     more conservative than it needs to be.  */
@@ -1133,35 +1105,41 @@
 		  if (pset && SET_DEST (pset) == src)
 		    {
 		      /* We use validate_replace_rtx, in case there
-			 are multiple identical source operands.  All of
-			 them have to be changed at the same time.  */
+			 are multiple identical source operands.  All
+			 of them have to be changed at the same time:
+			 when validate_replace_rtx() calls
+			 apply_change_group().  */
+		      validate_change (p, &SET_DEST (pset), dst, 1);
 		      if (validate_replace_rtx (src, dst, insn))
-			{
-			  if (validate_change (p, &SET_DEST (pset),
-					       dst, 0))
-			    success = 1;
-			  else
-			    {
-			      /* Change all source operands back.
-				 This modifies the dst as a side-effect.  */
-			      validate_replace_rtx (dst, src, insn);
-			      /* Now make sure the dst is right.  */
-			      validate_change (insn,
-					       recog_data.operand_loc[match_no],
-					       dst, 0);
-			    }
-			}
+			success = 1;
 		      break;
 		    }
 
-		  /* We can't make this change if SRC is read or
+		  /* We can't make this change if DST is mentioned at
+		     all in P, since we are going to change its value.
+		     We can't make this change if SRC is read or
 		     partially written in P, since we are going to
-		     eliminate SRC. We can't make this change 
-		     if DST is mentioned at all in P,
-		     since we are going to change its value.  */
-		  if (reg_overlap_mentioned_p (src, PATTERN (p))
-		      || reg_mentioned_p (dst, PATTERN (p)))
-		    break;
+		     eliminate SRC.  However, if it's a debug insn, we
+		     can't refrain from making the change, for this
+		     would cause codegen differences, so instead we
+		     invalidate debug expressions that reference DST,
+		     and adjust references to SRC in them so that they
+		     become references to DST.  */
+		  if (reg_mentioned_p (dst, PATTERN (p)))
+		    {
+		      if (DEBUG_INSN_P (p))
+			validate_change (p, &INSN_VAR_LOCATION_LOC (p),
+					 gen_rtx_UNKNOWN_VAR_LOC (), 1);
+		      else
+			break;
+		    }
+		  if (reg_overlap_mentioned_p (src, PATTERN (p)))
+		    {
+		      if (DEBUG_INSN_P (p))
+			validate_replace_rtx_group (src, dst, p);
+		      else
+			break;
+		    }
 
 		  /* If we have passed a call instruction, and the
 		     pseudo-reg DST is not already live across a call,
@@ -1223,6 +1201,8 @@
 
 		  break;
 		}
+	      else if (num_changes_pending () > 0)
+		cancel_changes (0);
 	    }
 
 	  /* If we weren't able to replace any of the alternatives, try an
@@ -1231,6 +1211,34 @@
 	    copy_src_to_dest (insn, copy_src, copy_dst);
 	}
     }
+}
+
+/* Main entry for the register move optimization.  */
+
+static unsigned int
+regmove_optimize (void)
+{
+  int i;
+  int nregs = max_reg_num ();
+
+  df_note_add_problem ();
+  df_analyze ();
+
+  if (flag_ira_loop_pressure)
+    ira_set_pseudo_classes (dump_file);
+
+  regstat_init_n_sets_and_refs ();
+  regstat_compute_ri ();
+
+  regno_src_regno = XNEWVEC (int, nregs);
+  for (i = nregs; --i >= 0; )
+    regno_src_regno[i] = -1;
+
+  /* A forward pass.  Replace output operands with input operands.  */
+  regmove_forward_pass ();
+
+  /* A backward pass.  Replace input operands with output operands.  */
+  regmove_backward_pass ();
 
   /* Clean up.  */
   free (regno_src_regno);
@@ -1241,6 +1249,8 @@
     }
   regstat_free_n_sets_and_refs ();
   regstat_free_ri ();
+  if (flag_ira_loop_pressure)
+    free_reg_info ();
   return 0;
 }
 
@@ -1364,4 +1374,3 @@
   TODO_ggc_collect                      /* todo_flags_finish */
  }
 };
-