1 files changed, 178 insertions, 129 deletions

diff --git a/contrib/gcc/sched-rgn.c b/contrib/gcc/sched-rgn.c
index ab65e2c..88545b2 100644
--- a/contrib/gcc/sched-rgn.c
+++ b/contrib/gcc/sched-rgn.c
@@ -62,6 +62,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "recog.h"
 #include "cfglayout.h"
 #include "sched-int.h"
+#include "target.h"
 
 /* Define when we want to do count REG_DEAD notes before and after scheduling
    for sanity checking.  We can't do that when conditional execution is used,
@@ -152,7 +153,7 @@ static int *containing_rgn;
 
 void debug_regions PARAMS ((void));
 static void find_single_block_region PARAMS ((void));
-static void find_rgns PARAMS ((struct edge_list *, sbitmap *));
+static void find_rgns PARAMS ((struct edge_list *, dominance_info));
 static int too_large PARAMS ((int, int *, int *));
 
 extern void debug_live PARAMS ((int, int));
@@ -269,16 +270,13 @@ static edgeset *ancestor_edges;
 
 static void compute_dom_prob_ps PARAMS ((int));
 
-#define ABS_VALUE(x) (((x)<0)?(-(x)):(x))
 #define INSN_PROBABILITY(INSN) (SRC_PROB (BLOCK_TO_BB (BLOCK_NUM (INSN))))
 #define IS_SPECULATIVE_INSN(INSN) (IS_SPECULATIVE (BLOCK_TO_BB (BLOCK_NUM (INSN))))
 #define INSN_BB(INSN) (BLOCK_TO_BB (BLOCK_NUM (INSN)))
 
 /* Parameters affecting the decision of rank_for_schedule().
    ??? Nope.  But MIN_PROBABILITY is used in copmute_trg_info.  */
-#define MIN_DIFF_PRIORITY 2
 #define MIN_PROBABILITY 40
-#define MIN_PROB_DIFF 10
 
 /* Speculative scheduling functions.  */
 static int check_live_1 PARAMS ((int, rtx));
@@ -318,7 +316,7 @@ static void free_pending_lists PARAMS ((void));
 static int
 is_cfg_nonregular ()
 {
-  int b;
+  basic_block b;
   rtx insn;
   RTX_CODE code;
 
@@ -345,8 +343,8 @@ is_cfg_nonregular ()
   /* If we have non-jumping insns which refer to labels, then we consider
      the cfg not well structured.  */
   /* Check for labels referred to other thn by jumps.  */
-  for (b = 0; b < n_basic_blocks; b++)
-    for (insn = BLOCK_HEAD (b);; insn = NEXT_INSN (insn))
+  FOR_EACH_BB (b)
+    for (insn = b->head;; insn = NEXT_INSN (insn))
       {
 	code = GET_CODE (insn);
 	if (GET_RTX_CLASS (code) == 'i' && code != JUMP_INSN)
@@ -360,7 +358,7 @@ is_cfg_nonregular ()
 	      return 1;
 	  }
 
-	if (insn == BLOCK_END (b))
+	if (insn == b->end)
 	  break;
       }
 
@@ -381,6 +379,7 @@ build_control_flow (edge_list)
      struct edge_list *edge_list;
 {
   int i, unreachable, num_edges;
+  basic_block b;
 
   /* This already accounts for entry/exit edges.  */
   num_edges = NUM_EDGES (edge_list);
@@ -392,10 +391,8 @@ build_control_flow (edge_list)
      test is redundant with the one in find_rgns, but it's much
     cheaper to go ahead and catch the trivial case here.  */
   unreachable = 0;
-  for (i = 0; i < n_basic_blocks; i++)
+  FOR_EACH_BB (b)
     {
-      basic_block b = BASIC_BLOCK (i);
-
       if (b->pred == NULL
 	  || (b->pred->src == b
 	      && b->pred->pred_next == NULL))
@@ -403,8 +400,8 @@ build_control_flow (edge_list)
     }
 
   /* ??? We can kill these soon.  */
-  in_edges = (int *) xcalloc (n_basic_blocks, sizeof (int));
-  out_edges = (int *) xcalloc (n_basic_blocks, sizeof (int));
+  in_edges = (int *) xcalloc (last_basic_block, sizeof (int));
+  out_edges = (int *) xcalloc (last_basic_block, sizeof (int));
   edge_table = (haifa_edge *) xcalloc (num_edges, sizeof (haifa_edge));
 
   nr_edges = 0;
@@ -543,17 +540,19 @@ debug_regions ()
 static void
 find_single_block_region ()
 {
-  int i;
+  basic_block bb;
+
+  nr_regions = 0;
 
-  for (i = 0; i < n_basic_blocks; i++)
+  FOR_EACH_BB (bb)
     {
-      rgn_bb_table[i] = i;
-      RGN_NR_BLOCKS (i) = 1;
-      RGN_BLOCKS (i) = i;
-      CONTAINING_RGN (i) = i;
-      BLOCK_TO_BB (i) = 0;
+      rgn_bb_table[nr_regions] = bb->index;
+      RGN_NR_BLOCKS (nr_regions) = 1;
+      RGN_BLOCKS (nr_regions) = nr_regions;
+      CONTAINING_RGN (bb->index) = nr_regions;
+      BLOCK_TO_BB (bb->index) = 0;
+      nr_regions++;
     }
-  nr_regions = n_basic_blocks;
 }
 
 /* Update number of blocks and the estimate for number of insns
@@ -576,17 +575,17 @@ too_large (block, num_bbs, num_insns)
 /* Update_loop_relations(blk, hdr): Check if the loop headed by max_hdr[blk]
    is still an inner loop.  Put in max_hdr[blk] the header of the most inner
    loop containing blk.  */
-#define UPDATE_LOOP_RELATIONS(blk, hdr)                              \
-{                                                                    \
-  if (max_hdr[blk] == -1)                                            \
-    max_hdr[blk] = hdr;                                              \
-  else if (dfs_nr[max_hdr[blk]] > dfs_nr[hdr])                       \
-         RESET_BIT (inner, hdr);                                     \
-  else if (dfs_nr[max_hdr[blk]] < dfs_nr[hdr])                       \
-         {                                                           \
-            RESET_BIT (inner,max_hdr[blk]);			     \
-            max_hdr[blk] = hdr;                                      \
-         }                                                           \
+#define UPDATE_LOOP_RELATIONS(blk, hdr)		\
+{						\
+  if (max_hdr[blk] == -1)			\
+    max_hdr[blk] = hdr;				\
+  else if (dfs_nr[max_hdr[blk]] > dfs_nr[hdr])	\
+    RESET_BIT (inner, hdr);			\
+  else if (dfs_nr[max_hdr[blk]] < dfs_nr[hdr])	\
+    {						\
+      RESET_BIT (inner,max_hdr[blk]);		\
+      max_hdr[blk] = hdr;			\
+    }						\
 }
 
 /* Find regions for interblock scheduling.
@@ -622,7 +621,7 @@ too_large (block, num_bbs, num_insns)
 static void
 find_rgns (edge_list, dom)
      struct edge_list *edge_list;
-     sbitmap *dom;
+     dominance_info dom;
 {
   int *max_hdr, *dfs_nr, *stack, *degree;
   char no_loops = 1;
@@ -630,6 +629,7 @@ find_rgns (edge_list, dom)
   int count = 0, sp, idx = 0, current_edge = out_edges[0];
   int num_bbs, num_insns, unreachable;
   int too_large_failure;
+  basic_block bb;
 
   /* Note if an edge has been passed.  */
   sbitmap passed;
@@ -637,7 +637,7 @@ find_rgns (edge_list, dom)
   /* Note if a block is a natural loop header.  */
   sbitmap header;
 
-  /* Note if a block is an natural inner loop header.  */
+  /* Note if a block is a natural inner loop header.  */
   sbitmap inner;
 
   /* Note if a block is in the block queue.  */
@@ -658,26 +658,26 @@ find_rgns (edge_list, dom)
      STACK, SP and DFS_NR are only used during the first traversal.  */
 
   /* Allocate and initialize variables for the first traversal.  */
-  max_hdr = (int *) xmalloc (n_basic_blocks * sizeof (int));
-  dfs_nr = (int *) xcalloc (n_basic_blocks, sizeof (int));
+  max_hdr = (int *) xmalloc (last_basic_block * sizeof (int));
+  dfs_nr = (int *) xcalloc (last_basic_block, sizeof (int));
   stack = (int *) xmalloc (nr_edges * sizeof (int));
 
-  inner = sbitmap_alloc (n_basic_blocks);
+  inner = sbitmap_alloc (last_basic_block);
   sbitmap_ones (inner);
 
-  header = sbitmap_alloc (n_basic_blocks);
+  header = sbitmap_alloc (last_basic_block);
   sbitmap_zero (header);
 
   passed = sbitmap_alloc (nr_edges);
   sbitmap_zero (passed);
 
-  in_queue = sbitmap_alloc (n_basic_blocks);
+  in_queue = sbitmap_alloc (last_basic_block);
   sbitmap_zero (in_queue);
 
-  in_stack = sbitmap_alloc (n_basic_blocks);
+  in_stack = sbitmap_alloc (last_basic_block);
   sbitmap_zero (in_stack);
 
-  for (i = 0; i < n_basic_blocks; i++)
+  for (i = 0; i < last_basic_block; i++)
     max_hdr[i] = -1;
 
   /* DFS traversal to find inner loops in the cfg.  */
@@ -771,8 +771,8 @@ find_rgns (edge_list, dom)
      the entry node by placing a nonzero value in dfs_nr.  Thus if
      dfs_nr is zero for any block, then it must be unreachable.  */
   unreachable = 0;
-  for (i = 0; i < n_basic_blocks; i++)
-    if (dfs_nr[i] == 0)
+  FOR_EACH_BB (bb)
+    if (dfs_nr[bb->index] == 0)
       {
 	unreachable = 1;
 	break;
@@ -782,8 +782,8 @@ find_rgns (edge_list, dom)
      to hold degree counts.  */
   degree = dfs_nr;
 
-  for (i = 0; i < n_basic_blocks; i++)
-    degree[i] = 0;
+  FOR_EACH_BB (bb)
+    degree[bb->index] = 0;
   for (i = 0; i < num_edges; i++)
     {
       edge e = INDEX_EDGE (edge_list, i);
@@ -808,12 +808,12 @@ find_rgns (edge_list, dom)
 
       /* Find blocks which are inner loop headers.  We still have non-reducible
 	 loops to consider at this point.  */
-      for (i = 0; i < n_basic_blocks; i++)
+      FOR_EACH_BB (bb)
 	{
-	  if (TEST_BIT (header, i) && TEST_BIT (inner, i))
+	  if (TEST_BIT (header, bb->index) && TEST_BIT (inner, bb->index))
 	    {
 	      edge e;
-	      int j;
+	      basic_block jbb;
 
 	      /* Now check that the loop is reducible.  We do this separate
 		 from finding inner loops so that we do not find a reducible
@@ -826,15 +826,15 @@ find_rgns (edge_list, dom)
 		 If there exists a block that is not dominated by the loop
 		 header, then the block is reachable from outside the loop
 		 and thus the loop is not a natural loop.  */
-	      for (j = 0; j < n_basic_blocks; j++)
+	      FOR_EACH_BB (jbb)
 		{
 		  /* First identify blocks in the loop, except for the loop
 		     entry block.  */
-		  if (i == max_hdr[j] && i != j)
+		  if (bb->index == max_hdr[jbb->index] && bb != jbb)
 		    {
 		      /* Now verify that the block is dominated by the loop
 			 header.  */
-		      if (!TEST_BIT (dom[j], i))
+		      if (!dominated_by_p (dom, jbb, bb))
 			break;
 		    }
 		}
@@ -842,25 +842,25 @@ find_rgns (edge_list, dom)
 	      /* If we exited the loop early, then I is the header of
 		 a non-reducible loop and we should quit processing it
 		 now.  */
-	      if (j != n_basic_blocks)
+	      if (jbb != EXIT_BLOCK_PTR)
 		continue;
 
 	      /* I is a header of an inner loop, or block 0 in a subroutine
 		 with no loops at all.  */
 	      head = tail = -1;
 	      too_large_failure = 0;
-	      loop_head = max_hdr[i];
+	      loop_head = max_hdr[bb->index];
 
 	      /* Decrease degree of all I's successors for topological
 		 ordering.  */
-	      for (e = BASIC_BLOCK (i)->succ; e; e = e->succ_next)
+	      for (e = bb->succ; e; e = e->succ_next)
 		if (e->dest != EXIT_BLOCK_PTR)
 		  --degree[e->dest->index];
 
 	      /* Estimate # insns, and count # blocks in the region.  */
 	      num_bbs = 1;
-	      num_insns = (INSN_LUID (BLOCK_END (i))
-			   - INSN_LUID (BLOCK_HEAD (i)));
+	      num_insns = (INSN_LUID (bb->end)
+			   - INSN_LUID (bb->head));
 
 	      /* Find all loop latches (blocks with back edges to the loop
 		 header) or all the leaf blocks in the cfg has no loops.
@@ -868,17 +868,17 @@ find_rgns (edge_list, dom)
 		 Place those blocks into the queue.  */
 	      if (no_loops)
 		{
-		  for (j = 0; j < n_basic_blocks; j++)
+		  FOR_EACH_BB (jbb)
 		    /* Leaf nodes have only a single successor which must
 		       be EXIT_BLOCK.  */
-		    if (BASIC_BLOCK (j)->succ
-			&& BASIC_BLOCK (j)->succ->dest == EXIT_BLOCK_PTR
-			&& BASIC_BLOCK (j)->succ->succ_next == NULL)
+		    if (jbb->succ
+			&& jbb->succ->dest == EXIT_BLOCK_PTR
+			&& jbb->succ->succ_next == NULL)
 		      {
-			queue[++tail] = j;
-			SET_BIT (in_queue, j);
+			queue[++tail] = jbb->index;
+			SET_BIT (in_queue, jbb->index);
 
-			if (too_large (j, &num_bbs, &num_insns))
+			if (too_large (jbb->index, &num_bbs, &num_insns))
 			  {
 			    too_large_failure = 1;
 			    break;
@@ -889,14 +889,14 @@ find_rgns (edge_list, dom)
 		{
 		  edge e;
 
-		  for (e = BASIC_BLOCK (i)->pred; e; e = e->pred_next)
+		  for (e = bb->pred; e; e = e->pred_next)
 		    {
 		      if (e->src == ENTRY_BLOCK_PTR)
 			continue;
 
 		      node = e->src->index;
 
-		      if (max_hdr[node] == loop_head && node != i)
+		      if (max_hdr[node] == loop_head && node != bb->index)
 			{
 			  /* This is a loop latch.  */
 			  queue[++tail] = node;
@@ -958,7 +958,7 @@ find_rgns (edge_list, dom)
 			  tail = -1;
 			  break;
 			}
-		      else if (!TEST_BIT (in_queue, node) && node != i)
+		      else if (!TEST_BIT (in_queue, node) && node != bb->index)
 			{
 			  queue[++tail] = node;
 			  SET_BIT (in_queue, node);
@@ -975,12 +975,12 @@ find_rgns (edge_list, dom)
 	      if (tail >= 0 && !too_large_failure)
 		{
 		  /* Place the loop header into list of region blocks.  */
-		  degree[i] = -1;
-		  rgn_bb_table[idx] = i;
+		  degree[bb->index] = -1;
+		  rgn_bb_table[idx] = bb->index;
 		  RGN_NR_BLOCKS (nr_regions) = num_bbs;
 		  RGN_BLOCKS (nr_regions) = idx++;
-		  CONTAINING_RGN (i) = nr_regions;
-		  BLOCK_TO_BB (i) = count = 0;
+		  CONTAINING_RGN (bb->index) = nr_regions;
+		  BLOCK_TO_BB (bb->index) = count = 0;
 
 		  /* Remove blocks from queue[] when their in degree
 		     becomes zero.  Repeat until no blocks are left on the
@@ -1019,14 +1019,14 @@ find_rgns (edge_list, dom)
 
   /* Any block that did not end up in a region is placed into a region
      by itself.  */
-  for (i = 0; i < n_basic_blocks; i++)
-    if (degree[i] >= 0)
+  FOR_EACH_BB (bb)
+    if (degree[bb->index] >= 0)
       {
-	rgn_bb_table[idx] = i;
+	rgn_bb_table[idx] = bb->index;
 	RGN_NR_BLOCKS (nr_regions) = 1;
 	RGN_BLOCKS (nr_regions) = idx++;
-	CONTAINING_RGN (i) = nr_regions++;
-	BLOCK_TO_BB (i) = 0;
+	CONTAINING_RGN (bb->index) = nr_regions++;
+	BLOCK_TO_BB (bb->index) = 0;
       }
 
   free (max_hdr);
@@ -1093,7 +1093,7 @@ compute_dom_prob_ps (bb)
 	  if (CONTAINING_RGN (TO_BLOCK (nxt_out_edge)) !=
 	      CONTAINING_RGN (BB_TO_BLOCK (bb)))
 	    ++nr_rgn_out_edges;
-        SET_BIT (pot_split[bb], EDGE_TO_BIT (nxt_out_edge));
+	  SET_BIT (pot_split[bb], EDGE_TO_BIT (nxt_out_edge));
 	  nxt_out_edge = NEXT_OUT (nxt_out_edge);
 
 	}
@@ -1194,8 +1194,8 @@ compute_trg_info (trg)
 	     add the TO block to the update block list.  This list can end
 	     up with a lot of duplicates.  We need to weed them out to avoid
 	     overrunning the end of the bblst_table.  */
-	  update_blocks = (char *) alloca (n_basic_blocks);
-	  memset (update_blocks, 0, n_basic_blocks);
+	  update_blocks = (char *) alloca (last_basic_block);
+	  memset (update_blocks, 0, last_basic_block);
 
 	  update_idx = 0;
 	  for (j = 0; j < el.nr_members; j++)
@@ -1561,17 +1561,17 @@ enum INSN_TRAP_CLASS
 
 /* Non-zero if block bb_to is equal to, or reachable from block bb_from.  */
 #define IS_REACHABLE(bb_from, bb_to)					\
-(bb_from == bb_to                                                       \
+  (bb_from == bb_to							\
    || IS_RGN_ENTRY (bb_from)						\
-   || (TEST_BIT (ancestor_edges[bb_to],                               \
-                    EDGE_TO_BIT (IN_EDGES (BB_TO_BLOCK (bb_from))))))
+   || (TEST_BIT (ancestor_edges[bb_to],					\
+		 EDGE_TO_BIT (IN_EDGES (BB_TO_BLOCK (bb_from))))))
 
 /* Non-zero iff the address is comprised from at most 1 register.  */
 #define CONST_BASED_ADDRESS_P(x)			\
   (GET_CODE (x) == REG					\
-   || ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS   \
-	|| (GET_CODE (x) == LO_SUM))	                \
-       && (CONSTANT_P (XEXP (x, 0))		\
+   || ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS	\
+	|| (GET_CODE (x) == LO_SUM))			\
+       && (CONSTANT_P (XEXP (x, 0))			\
 	   || CONSTANT_P (XEXP (x, 1)))))
 
 /* Turns on the fed_by_spec_load flag for insns fed by load_insn.  */
@@ -2030,7 +2030,7 @@ init_ready_list (ready)
       next = NEXT_INSN (insn);
 
       if (INSN_DEP_COUNT (insn) == 0
-	  && (SCHED_GROUP_P (next) == 0 || ! INSN_P (next)))
+	  && (! INSN_P (next) || SCHED_GROUP_P (next) == 0))
 	ready_add (ready, insn);
       if (!(SCHED_GROUP_P (insn)))
 	target_n_insns++;
@@ -2057,7 +2057,14 @@ init_ready_list (ready)
 
 	    if (!CANT_MOVE (insn)
 		&& (!IS_SPECULATIVE_INSN (insn)
-		    || (insn_issue_delay (insn) <= 3
+		    || ((((!targetm.sched.use_dfa_pipeline_interface
+			   || !(*targetm.sched.use_dfa_pipeline_interface) ())
+			  && insn_issue_delay (insn) <= 3)
+			 || (targetm.sched.use_dfa_pipeline_interface
+			     && (*targetm.sched.use_dfa_pipeline_interface) ()
+			     && (recog_memoized (insn) < 0
+			         || min_insn_conflict_delay (curr_state,
+							     insn, insn) <= 3)))
 			&& check_live (insn, bb_src)
 			&& is_exception_free (insn, bb_src, target_bb))))
 	      {
@@ -2069,8 +2076,8 @@ init_ready_list (ready)
 		next = next_nonnote_insn (insn);
 		if (INSN_DEP_COUNT (insn) == 0
 		    && (! next
-			|| SCHED_GROUP_P (next) == 0
-			|| ! INSN_P (next)))
+			|| ! INSN_P (next)
+			|| SCHED_GROUP_P (next) == 0))
 		  ready_add (ready, insn);
 	      }
 	  }
@@ -2165,7 +2172,15 @@ new_ready (next)
       && (!IS_VALID (INSN_BB (next))
 	  || CANT_MOVE (next)
 	  || (IS_SPECULATIVE_INSN (next)
-	      && (insn_issue_delay (next) > 3
+	      && (0
+		  || (targetm.sched.use_dfa_pipeline_interface
+		      && (*targetm.sched.use_dfa_pipeline_interface) ()
+		      && recog_memoized (next) >= 0
+		      && min_insn_conflict_delay (curr_state, next,
+						  next) > 3)
+		  || ((!targetm.sched.use_dfa_pipeline_interface
+		       || !(*targetm.sched.use_dfa_pipeline_interface) ())
+		      && insn_issue_delay (next) > 3)
 		  || !check_live (next, INSN_BB (next))
 		  || !is_exception_free (next, INSN_BB (next), target_bb)))))
     return 0;
@@ -2481,7 +2496,7 @@ propagate_deps (bb, pred_deps)
 	succ_deps->last_pending_memory_flush
 	  = concat_INSN_LIST (pred_deps->last_pending_memory_flush,
 			      succ_deps->last_pending_memory_flush);
-	
+
 	succ_deps->pending_lists_length += pred_deps->pending_lists_length;
 	succ_deps->pending_flush_length += pred_deps->pending_flush_length;
 
@@ -2589,14 +2604,27 @@ debug_dependencies ()
 	  fprintf (sched_dump, "\n;;   --- Region Dependences --- b %d bb %d \n",
 		   BB_TO_BLOCK (bb), bb);
 
-	  fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%11s%6s\n",
-	  "insn", "code", "bb", "dep", "prio", "cost", "blockage", "units");
-	  fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%11s%6s\n",
-	  "----", "----", "--", "---", "----", "----", "--------", "-----");
+	  if (targetm.sched.use_dfa_pipeline_interface
+	      && (*targetm.sched.use_dfa_pipeline_interface) ())
+	    {
+	      fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%14s\n",
+		       "insn", "code", "bb", "dep", "prio", "cost",
+		       "reservation");
+	      fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%14s\n",
+		       "----", "----", "--", "---", "----", "----",
+		       "-----------");
+	    }
+	  else
+	    {
+	      fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%11s%6s\n",
+	      "insn", "code", "bb", "dep", "prio", "cost", "blockage", "units");
+	      fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%11s%6s\n",
+	      "----", "----", "--", "---", "----", "----", "--------", "-----");
+	    }
+
 	  for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
 	    {
 	      rtx link;
-	      int unit, range;
 
 	      if (! INSN_P (insn))
 		{
@@ -2616,22 +2644,46 @@ debug_dependencies ()
 		  continue;
 		}
 
-	      unit = insn_unit (insn);
-	      range = (unit < 0
-		 || function_units[unit].blockage_range_function == 0) ? 0 :
-		function_units[unit].blockage_range_function (insn);
-	      fprintf (sched_dump,
-		       ";;   %s%5d%6d%6d%6d%6d%6d  %3d -%3d   ",
-		       (SCHED_GROUP_P (insn) ? "+" : " "),
-		       INSN_UID (insn),
-		       INSN_CODE (insn),
-		       INSN_BB (insn),
-		       INSN_DEP_COUNT (insn),
-		       INSN_PRIORITY (insn),
-		       insn_cost (insn, 0, 0),
-		       (int) MIN_BLOCKAGE_COST (range),
-		       (int) MAX_BLOCKAGE_COST (range));
-	      insn_print_units (insn);
+	      if (targetm.sched.use_dfa_pipeline_interface
+		  && (*targetm.sched.use_dfa_pipeline_interface) ())
+		{
+		  fprintf (sched_dump,
+			   ";;   %s%5d%6d%6d%6d%6d%6d   ",
+			   (SCHED_GROUP_P (insn) ? "+" : " "),
+			   INSN_UID (insn),
+			   INSN_CODE (insn),
+			   INSN_BB (insn),
+			   INSN_DEP_COUNT (insn),
+			   INSN_PRIORITY (insn),
+			   insn_cost (insn, 0, 0));
+
+		  if (recog_memoized (insn) < 0)
+		    fprintf (sched_dump, "nothing");
+		  else
+		    print_reservation (sched_dump, insn);
+		}
+	      else
+		{
+		  int unit = insn_unit (insn);
+		  int range
+		    = (unit < 0
+		       || function_units[unit].blockage_range_function == 0
+		       ? 0
+		       : function_units[unit].blockage_range_function (insn));
+		  fprintf (sched_dump,
+			   ";;   %s%5d%6d%6d%6d%6d%6d  %3d -%3d   ",
+			   (SCHED_GROUP_P (insn) ? "+" : " "),
+			   INSN_UID (insn),
+			   INSN_CODE (insn),
+			   INSN_BB (insn),
+			   INSN_DEP_COUNT (insn),
+			   INSN_PRIORITY (insn),
+			   insn_cost (insn, 0, 0),
+			   (int) MIN_BLOCKAGE_COST (range),
+			   (int) MAX_BLOCKAGE_COST (range));
+		  insn_print_units (insn);
+		}
+
 	      fprintf (sched_dump, "\t: ");
 	      for (link = INSN_DEPEND (insn); link; link = XEXP (link, 1))
 		fprintf (sched_dump, "%d ", INSN_UID (XEXP (link, 0)));
@@ -2835,8 +2887,8 @@ init_regions ()
   nr_regions = 0;
   rgn_table = (region *) xmalloc ((n_basic_blocks) * sizeof (region));
   rgn_bb_table = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
-  block_to_bb = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
-  containing_rgn = (int *) xmalloc ((n_basic_blocks) * sizeof (int));
+  block_to_bb = (int *) xmalloc ((last_basic_block) * sizeof (int));
+  containing_rgn = (int *) xmalloc ((last_basic_block) * sizeof (int));
 
   /* Compute regions for scheduling.  */
   if (reload_completed
@@ -2854,11 +2906,9 @@ init_regions ()
 	}
       else
 	{
-	  sbitmap *dom;
+	  dominance_info dom;
 	  struct edge_list *edge_list;
 
-	  dom = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks);
-
 	  /* The scheduler runs after flow; therefore, we can't blindly call
 	     back into find_basic_blocks since doing so could invalidate the
 	     info in global_live_at_start.
@@ -2873,7 +2923,7 @@ init_regions ()
 	  edge_list = create_edge_list ();
 
 	  /* Compute the dominators and post dominators.  */
-	  calculate_dominance_info (NULL, dom, CDI_DOMINATORS);
+	  dom = calculate_dominance_info (CDI_DOMINATORS);
 
 	  /* build_control_flow will return nonzero if it detects unreachable
 	     blocks or any other irregularity with the cfg which prevents
@@ -2891,14 +2941,14 @@ init_regions ()
 
 	  /* For now.  This will move as more and more of haifa is converted
 	     to using the cfg code in flow.c.  */
-	  free (dom);
+	  free_dominance_info (dom);
 	}
     }
 
 
   if (CHECK_DEAD_NOTES)
     {
-      blocks = sbitmap_alloc (n_basic_blocks);
+      blocks = sbitmap_alloc (last_basic_block);
       deaths_in_region = (int *) xmalloc (sizeof (int) * nr_regions);
       /* Remove all death notes from the subroutine.  */
       for (rgn = 0; rgn < nr_regions; rgn++)
@@ -2927,14 +2977,13 @@ schedule_insns (dump_file)
   sbitmap large_region_blocks, blocks;
   int rgn;
   int any_large_regions;
+  basic_block bb;
 
   /* Taking care of this degenerate case makes the rest of
      this code simpler.  */
   if (n_basic_blocks == 0)
     return;
 
-  scope_to_insns_initialize ();
-
   nr_inter = 0;
   nr_spec = 0;
 
@@ -2943,7 +2992,7 @@ schedule_insns (dump_file)
   init_regions ();
 
   current_sched_info = &region_sched_info;
-  
+
   /* Schedule every region in the subroutine.  */
   for (rgn = 0; rgn < nr_regions; rgn++)
     schedule_region (rgn);
@@ -2952,7 +3001,7 @@ schedule_insns (dump_file)
      first so that we can verify that live_at_start didn't change.  Then
      do all other blocks.  */
   /* ??? There is an outside possibility that update_life_info, or more
-     to the point propagate_block, could get called with non-zero flags
+     to the point propagate_block, could get called with nonzero flags
      more than once for one basic block.  This would be kinda bad if it
      were to happen, since REG_INFO would be accumulated twice for the
      block, and we'd have twice the REG_DEAD notes.
@@ -2962,13 +3011,15 @@ schedule_insns (dump_file)
      best way to test for this kind of thing...  */
 
   allocate_reg_life_data ();
-  compute_bb_for_insn (get_max_uid ());
+  compute_bb_for_insn ();
 
   any_large_regions = 0;
-  large_region_blocks = sbitmap_alloc (n_basic_blocks);
-  sbitmap_ones (large_region_blocks);
+  large_region_blocks = sbitmap_alloc (last_basic_block);
+  sbitmap_zero (large_region_blocks);
+  FOR_EACH_BB (bb)
+    SET_BIT (large_region_blocks, bb->index);
 
-  blocks = sbitmap_alloc (n_basic_blocks);
+  blocks = sbitmap_alloc (last_basic_block);
   sbitmap_zero (blocks);
 
   /* Update life information.  For regions consisting of multiple blocks
@@ -3021,8 +3072,6 @@ schedule_insns (dump_file)
   if (write_symbols != NO_DEBUG)
     rm_redundant_line_notes ();
 
-  scope_to_insns_finalize ();
-
   if (sched_verbose)
     {
       if (reload_completed == 0 && flag_schedule_interblock)