OSDN Git Service

(root) / pf3gnuchains / gcc-fork.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* sh.md (cbranch define_delay) Use cond_delay_slot for
[pf3gnuchains/gcc-fork.git] / gcc / sched-rgn.c
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index c7e7f80..62d2f23 100644 (file)
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -1,6 +1,6 @@
 /* Instruction scheduling pass.
    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
 /* Instruction scheduling pass.
    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
    and currently maintained by, Jim Wilson (wilson@cygnus.com)
 
    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
    and currently maintained by, Jim Wilson (wilson@cygnus.com)
 
@@ -63,6 +63,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "toplev.h"
 #include "recog.h"
 #include "cfglayout.h"
 #include "toplev.h"
 #include "recog.h"
 #include "cfglayout.h"
+#include "params.h"
 #include "sched-int.h"
 #include "target.h"
 
 #include "sched-int.h"
 #include "target.h"
 
@@ -83,9 +84,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #define FED_BY_SPEC_LOAD(insn) (h_i_d[INSN_UID (insn)].fed_by_spec_load)
 #define IS_LOAD_INSN(insn)     (h_i_d[INSN_UID (insn)].is_load_insn)
 
 #define FED_BY_SPEC_LOAD(insn) (h_i_d[INSN_UID (insn)].fed_by_spec_load)
 #define IS_LOAD_INSN(insn)     (h_i_d[INSN_UID (insn)].is_load_insn)
 
-#define MAX_RGN_BLOCKS 10
-#define MAX_RGN_INSNS 100
-
 /* nr_inter/spec counts interblock/speculative motion for the function.  */
 static int nr_inter, nr_spec;
 
 /* nr_inter/spec counts interblock/speculative motion for the function.  */
 static int nr_inter, nr_spec;
 
@@ -116,9 +114,10 @@ static int *out_edges;
 #define IN_EDGES(block) (in_edges[block])
 #define OUT_EDGES(block) (out_edges[block])
 
 #define IN_EDGES(block) (in_edges[block])
 #define OUT_EDGES(block) (out_edges[block])
 
-static int is_cfg_nonregular PARAMS ((void));
-static int build_control_flow PARAMS ((struct edge_list *));
-static void new_edge PARAMS ((int, int));
+static int is_cfg_nonregular (void);
+static int build_control_flow (struct edge_list *);
+static void new_edge (int, int);
+static bool sched_is_disabled_for_current_region_p (void);
 
 /* A region is the main entity for interblock scheduling: insns
    are allowed to move between blocks in the same region, along
 
 /* A region is the main entity for interblock scheduling: insns
    are allowed to move between blocks in the same region, along
@@ -142,7 +141,7 @@ static int *rgn_bb_table;
 /* Topological order of blocks in the region (if b2 is reachable from
    b1, block_to_bb[b2] > block_to_bb[b1]).  Note: A basic block is
    always referred to by either block or b, while its topological
 /* Topological order of blocks in the region (if b2 is reachable from
    b1, block_to_bb[b2] > block_to_bb[b1]).  Note: A basic block is
    always referred to by either block or b, while its topological
-   order name (in the region) is refered to by bb.  */
+   order name (in the region) is referred to by bb.  */
 static int *block_to_bb;
 
 /* The number of the region containing a block.  */
 static int *block_to_bb;
 
 /* The number of the region containing a block.  */
@@ -153,12 +152,12 @@ static int *containing_rgn;
 #define BLOCK_TO_BB(block) (block_to_bb[block])
 #define CONTAINING_RGN(block) (containing_rgn[block])
 
 #define BLOCK_TO_BB(block) (block_to_bb[block])
 #define CONTAINING_RGN(block) (containing_rgn[block])
 
-void debug_regions PARAMS ((void));
-static void find_single_block_region PARAMS ((void));
-static void find_rgns PARAMS ((struct edge_list *, dominance_info));
-static int too_large PARAMS ((int, int *, int *));
+void debug_regions (void);
+static void find_single_block_region (void);
+static void find_rgns (struct edge_list *);
+static bool too_large (int, int *, int *);
 
 
-extern void debug_live PARAMS ((int, int));
+extern void debug_live (int, int);
 
 /* Blocks of the current region being scheduled.  */
 static int current_nr_blocks;
 
 /* Blocks of the current region being scheduled.  */
 static int current_nr_blocks;
@@ -177,7 +176,7 @@ bitlst;
 static int bitlst_table_last;
 static int *bitlst_table;
 
 static int bitlst_table_last;
 static int *bitlst_table;
 
-static void extract_bitlst PARAMS ((sbitmap, bitlst *));
+static void extract_bitlst (sbitmap, bitlst *);
 
 /* Target info declarations.
 
 
 /* Target info declarations.
 
@@ -218,10 +217,10 @@ static int target_bb;
 typedef bitlst edgelst;
 
 /* Target info functions.  */
 typedef bitlst edgelst;
 
 /* Target info functions.  */
-static void split_edges PARAMS ((int, int, edgelst *));
-static void compute_trg_info PARAMS ((int));
-void debug_candidate PARAMS ((int));
-void debug_candidates PARAMS ((int));
+static void split_edges (int, int, edgelst *);
+static void compute_trg_info (int);
+void debug_candidate (int);
+void debug_candidates (int);
 
 /* Dominators array: dom[i] contains the sbitmap of dominators of
    bb i in the region.  */
 
 /* Dominators array: dom[i] contains the sbitmap of dominators of
    bb i in the region.  */
@@ -269,7 +268,7 @@ static edgeset *pot_split;
 /* For every bb, a set of its ancestor edges.  */
 static edgeset *ancestor_edges;
 
 /* For every bb, a set of its ancestor edges.  */
 static edgeset *ancestor_edges;
 
-static void compute_dom_prob_ps PARAMS ((int));
+static void compute_dom_prob_ps (int);
 
 #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_PROBABILITY(INSN) (SRC_PROB (BLOCK_TO_BB (BLOCK_NUM (INSN))))
 #define IS_SPECULATIVE_INSN(INSN) (IS_SPECULATIVE (BLOCK_TO_BB (BLOCK_NUM (INSN))))
@@ -280,29 +279,29 @@ static void compute_dom_prob_ps PARAMS ((int));
 #define MIN_PROBABILITY 40
 
 /* Speculative scheduling functions.  */
 #define MIN_PROBABILITY 40
 
 /* Speculative scheduling functions.  */
-static int check_live_1 PARAMS ((int, rtx));
-static void update_live_1 PARAMS ((int, rtx));
-static int check_live PARAMS ((rtx, int));
-static void update_live PARAMS ((rtx, int));
-static void set_spec_fed PARAMS ((rtx));
-static int is_pfree PARAMS ((rtx, int, int));
-static int find_conditional_protection PARAMS ((rtx, int));
-static int is_conditionally_protected PARAMS ((rtx, int, int));
-static int is_prisky PARAMS ((rtx, int, int));
-static int is_exception_free PARAMS ((rtx, int, int));
-
-static bool sets_likely_spilled PARAMS ((rtx));
-static void sets_likely_spilled_1 PARAMS ((rtx, rtx, void *));
-static void add_branch_dependences PARAMS ((rtx, rtx));
-static void compute_block_backward_dependences PARAMS ((int));
-void debug_dependencies PARAMS ((void));
-
-static void init_regions PARAMS ((void));
-static void schedule_region PARAMS ((int));
-static rtx concat_INSN_LIST PARAMS ((rtx, rtx));
-static void concat_insn_mem_list PARAMS ((rtx, rtx, rtx *, rtx *));
-static void propagate_deps PARAMS ((int, struct deps *));
-static void free_pending_lists PARAMS ((void));
+static int check_live_1 (int, rtx);
+static void update_live_1 (int, rtx);
+static int check_live (rtx, int);
+static void update_live (rtx, int);
+static void set_spec_fed (rtx);
+static int is_pfree (rtx, int, int);
+static int find_conditional_protection (rtx, int);
+static int is_conditionally_protected (rtx, int, int);
+static int is_prisky (rtx, int, int);
+static int is_exception_free (rtx, int, int);
+
+static bool sets_likely_spilled (rtx);
+static void sets_likely_spilled_1 (rtx, rtx, void *);
+static void add_branch_dependences (rtx, rtx);
+static void compute_block_backward_dependences (int);
+void debug_dependencies (void);
+
+static void init_regions (void);
+static void schedule_region (int);
+static rtx concat_INSN_LIST (rtx, rtx);
+static void concat_insn_mem_list (rtx, rtx, rtx *, rtx *);
+static void propagate_deps (int, struct deps *);
+static void free_pending_lists (void);
 
 /* Functions for construction of the control flow graph.  */
 
 
 /* Functions for construction of the control flow graph.  */
 
@@ -313,7 +312,7 @@ static void free_pending_lists PARAMS ((void));
    have nonlocal gotos.  */
 
 static int
    have nonlocal gotos.  */
 
 static int
-is_cfg_nonregular ()
+is_cfg_nonregular (void)
 {
   basic_block b;
   rtx insn;
 {
   basic_block b;
   rtx insn;
@@ -343,21 +342,21 @@ is_cfg_nonregular ()
      the cfg not well structured.  */
   /* Check for labels referred to other thn by jumps.  */
   FOR_EACH_BB (b)
      the cfg not well structured.  */
   /* Check for labels referred to other thn by jumps.  */
   FOR_EACH_BB (b)
-    for (insn = b->head;; insn = NEXT_INSN (insn))
+    for (insn = BB_HEAD (b); ; insn = NEXT_INSN (insn))
       {
        code = GET_CODE (insn);
       {
        code = GET_CODE (insn);
-       if (GET_RTX_CLASS (code) == 'i' && code != JUMP_INSN)
+       if (INSN_P (insn) && code != JUMP_INSN)
          {
            rtx note = find_reg_note (insn, REG_LABEL, NULL_RTX);
 
            if (note
          {
            rtx note = find_reg_note (insn, REG_LABEL, NULL_RTX);
 
            if (note
-               && ! (GET_CODE (NEXT_INSN (insn)) == JUMP_INSN
+               && ! (JUMP_P (NEXT_INSN (insn))
                      && find_reg_note (NEXT_INSN (insn), REG_LABEL,
                                        XEXP (note, 0))))
              return 1;
          }
 
                      && find_reg_note (NEXT_INSN (insn), REG_LABEL,
                                        XEXP (note, 0))))
              return 1;
          }
 
-       if (insn == b->end)
+       if (insn == BB_END (b))
          break;
       }
 
          break;
       }
 
@@ -374,8 +373,7 @@ is_cfg_nonregular ()
    prevent cross block scheduling.  */
 
 static int
    prevent cross block scheduling.  */
 
 static int
-build_control_flow (edge_list)
-     struct edge_list *edge_list;
+build_control_flow (struct edge_list *edge_list)
 {
   int i, unreachable, num_edges;
   basic_block b;
 {
   int i, unreachable, num_edges;
   basic_block b;
@@ -399,9 +397,9 @@ build_control_flow (edge_list)
     }
 
   /* ??? We can kill these soon.  */
     }
 
   /* ??? We can kill these soon.  */
-  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));
+  in_edges = xcalloc (last_basic_block, sizeof (int));
+  out_edges = xcalloc (last_basic_block, sizeof (int));
+  edge_table = xcalloc (num_edges, sizeof (haifa_edge));
 
   nr_edges = 0;
   for (i = 0; i < num_edges; i++)
 
   nr_edges = 0;
   for (i = 0; i < num_edges; i++)
@@ -426,8 +424,7 @@ build_control_flow (edge_list)
    integer lists.  */
 
 static void
    integer lists.  */
 
 static void
-new_edge (source, target)
-     int source, target;
+new_edge (int source, int target)
 {
   int e, next_edge;
   int curr_edge, fst_edge;
 {
   int e, next_edge;
   int curr_edge, fst_edge;
@@ -481,9 +478,7 @@ new_edge (source, target)
 /* Translate a bit-set SET to a list BL of the bit-set members.  */
 
 static void
 /* Translate a bit-set SET to a list BL of the bit-set members.  */
 
 static void
-extract_bitlst (set, bl)
-     sbitmap set;
-     bitlst *bl;
+extract_bitlst (sbitmap set, bitlst *bl)
 {
   int i;
 
 {
   int i;
 
@@ -507,7 +502,7 @@ extract_bitlst (set, bl)
 /* Print the regions, for debugging purposes.  Callable from debugger.  */
 
 void
 /* Print the regions, for debugging purposes.  Callable from debugger.  */
 
 void
-debug_regions ()
+debug_regions (void)
 {
   int rgn, bb;
 
 {
   int rgn, bb;
 
@@ -537,7 +532,7 @@ debug_regions ()
    scheduling.  */
 
 static void
    scheduling.  */
 
 static void
-find_single_block_region ()
+find_single_block_region (void)
 {
   basic_block bb;
 
 {
   basic_block bb;
 
@@ -555,20 +550,18 @@ find_single_block_region ()
 }
 
 /* Update number of blocks and the estimate for number of insns
 }
 
 /* Update number of blocks and the estimate for number of insns
-   in the region.  Return 1 if the region is "too large" for interblock
-   scheduling (compile time considerations), otherwise return 0.  */
+   in the region.  Return true if the region is "too large" for interblock
+   scheduling (compile time considerations).  */
 
 
-static int
-too_large (block, num_bbs, num_insns)
-     int block, *num_bbs, *num_insns;
+static bool
+too_large (int block, int *num_bbs, int *num_insns)
 {
   (*num_bbs)++;
 {
   (*num_bbs)++;
-  (*num_insns) += (INSN_LUID (BLOCK_END (block)) -
-                  INSN_LUID (BLOCK_HEAD (block)));
-  if ((*num_bbs > MAX_RGN_BLOCKS) || (*num_insns > MAX_RGN_INSNS))
-    return 1;
-  else
-    return 0;
+  (*num_insns) += (INSN_LUID (BB_END (BASIC_BLOCK (block)))
+                  - INSN_LUID (BB_HEAD (BASIC_BLOCK (block))));
+
+  return ((*num_bbs > PARAM_VALUE (PARAM_MAX_SCHED_REGION_BLOCKS))
+         || (*num_insns > PARAM_VALUE (PARAM_MAX_SCHED_REGION_INSNS)));
 }
 
 /* Update_loop_relations(blk, hdr): Check if the loop headed by max_hdr[blk]
 }
 
 /* Update_loop_relations(blk, hdr): Check if the loop headed by max_hdr[blk]
@@ -618,14 +611,13 @@ too_large (block, num_bbs, num_insns)
    of edge tables.  That would simplify it somewhat.  */
 
 static void
    of edge tables.  That would simplify it somewhat.  */
 
 static void
-find_rgns (edge_list, dom)
-     struct edge_list *edge_list;
-     dominance_info dom;
+find_rgns (struct edge_list *edge_list)
 {
   int *max_hdr, *dfs_nr, *stack, *degree;
   char no_loops = 1;
   int node, child, loop_head, i, head, tail;
 {
   int *max_hdr, *dfs_nr, *stack, *degree;
   char no_loops = 1;
   int node, child, loop_head, i, head, tail;
-  int count = 0, sp, idx = 0, current_edge = out_edges[0];
+  int count = 0, sp, idx = 0;
+  int current_edge = out_edges[ENTRY_BLOCK_PTR->succ->dest->index];
   int num_bbs, num_insns, unreachable;
   int too_large_failure;
   basic_block bb;
   int num_bbs, num_insns, unreachable;
   int too_large_failure;
   basic_block bb;
@@ -657,9 +649,9 @@ 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.  */
      STACK, SP and DFS_NR are only used during the first traversal.  */
 
   /* Allocate and initialize variables for the first traversal.  */
-  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));
+  max_hdr = xmalloc (last_basic_block * sizeof (int));
+  dfs_nr = xcalloc (last_basic_block, sizeof (int));
+  stack = xmalloc (nr_edges * sizeof (int));
 
   inner = sbitmap_alloc (last_basic_block);
   sbitmap_ones (inner);
 
   inner = sbitmap_alloc (last_basic_block);
   sbitmap_ones (inner);
@@ -803,7 +795,7 @@ find_rgns (edge_list, dom)
       /* Second traversal:find reducible inner loops and topologically sort
         block of each region.  */
 
       /* Second traversal:find reducible inner loops and topologically sort
         block of each region.  */
 
-      queue = (int *) xmalloc (n_basic_blocks * sizeof (int));
+      queue = xmalloc (n_basic_blocks * sizeof (int));
 
       /* Find blocks which are inner loop headers.  We still have non-reducible
         loops to consider at this point.  */
 
       /* Find blocks which are inner loop headers.  We still have non-reducible
         loops to consider at this point.  */
@@ -833,7 +825,7 @@ find_rgns (edge_list, dom)
                    {
                      /* Now verify that the block is dominated by the loop
                         header.  */
                    {
                      /* Now verify that the block is dominated by the loop
                         header.  */
-                     if (!dominated_by_p (dom, jbb, bb))
+                     if (!dominated_by_p (CDI_DOMINATORS, jbb, bb))
                        break;
                    }
                }
                        break;
                    }
                }
@@ -858,8 +850,8 @@ find_rgns (edge_list, dom)
 
              /* Estimate # insns, and count # blocks in the region.  */
              num_bbs = 1;
 
              /* Estimate # insns, and count # blocks in the region.  */
              num_bbs = 1;
-             num_insns = (INSN_LUID (bb->end)
-                          - INSN_LUID (bb->head));
+             num_insns = (INSN_LUID (BB_END (bb))
+                          - INSN_LUID (BB_HEAD (bb)));
 
              /* Find all loop latches (blocks with back edges to the loop
                 header) or all the leaf blocks in the cfg has no loops.
 
              /* Find all loop latches (blocks with back edges to the loop
                 header) or all the leaf blocks in the cfg has no loops.
@@ -1044,8 +1036,7 @@ find_rgns (edge_list, dom)
    Assume that these values were already computed for bb's predecessors.  */
 
 static void
    Assume that these values were already computed for bb's predecessors.  */
 
 static void
-compute_dom_prob_ps (bb)
-     int bb;
+compute_dom_prob_ps (int bb)
 {
   int nxt_in_edge, fst_in_edge, pred;
   int fst_out_edge, nxt_out_edge, nr_out_edges, nr_rgn_out_edges;
 {
   int nxt_in_edge, fst_in_edge, pred;
   int fst_out_edge, nxt_out_edge, nr_out_edges, nr_rgn_out_edges;
@@ -1123,12 +1114,9 @@ compute_dom_prob_ps (bb)
    Note that bb_trg dominates bb_src.  */
 
 static void
    Note that bb_trg dominates bb_src.  */
 
 static void
-split_edges (bb_src, bb_trg, bl)
-     int bb_src;
-     int bb_trg;
-     edgelst *bl;
+split_edges (int bb_src, int bb_trg, edgelst *bl)
 {
 {
-  sbitmap src = (edgeset) sbitmap_alloc (pot_split[bb_src]->n_bits);
+  sbitmap src = sbitmap_alloc (pot_split[bb_src]->n_bits);
   sbitmap_copy (src, pot_split[bb_src]);
 
   sbitmap_difference (src, src, pot_split[bb_trg]);
   sbitmap_copy (src, pot_split[bb_src]);
 
   sbitmap_difference (src, src, pot_split[bb_trg]);
@@ -1141,8 +1129,7 @@ split_edges (bb_src, bb_trg, bl)
    For speculative sources, compute their update-blocks and split-blocks.  */
 
 static void
    For speculative sources, compute their update-blocks and split-blocks.  */
 
 static void
-compute_trg_info (trg)
-     int trg;
+compute_trg_info (int trg)
 {
   candidate *sp;
   edgelst el;
 {
   candidate *sp;
   edgelst el;
@@ -1193,7 +1180,7 @@ 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.  */
             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 (last_basic_block);
+         update_blocks = alloca (last_basic_block);
          memset (update_blocks, 0, last_basic_block);
 
          update_idx = 0;
          memset (update_blocks, 0, last_basic_block);
 
          update_idx = 0;
@@ -1240,8 +1227,7 @@ compute_trg_info (trg)
 /* Print candidates info, for debugging purposes.  Callable from debugger.  */
 
 void
 /* Print candidates info, for debugging purposes.  Callable from debugger.  */
 
 void
-debug_candidate (i)
-     int i;
+debug_candidate (int i)
 {
   if (!candidate_table[i].is_valid)
     return;
 {
   if (!candidate_table[i].is_valid)
     return;
@@ -1278,8 +1264,7 @@ debug_candidate (i)
 /* Print candidates info, for debugging purposes.  Callable from debugger.  */
 
 void
 /* Print candidates info, for debugging purposes.  Callable from debugger.  */
 
 void
-debug_candidates (trg)
-     int trg;
+debug_candidates (int trg)
 {
   int i;
 
 {
   int i;
 
@@ -1295,9 +1280,7 @@ debug_candidates (trg)
    of the split-blocks of src, otherwise return 1.  */
 
 static int
    of the split-blocks of src, otherwise return 1.  */
 
 static int
-check_live_1 (src, x)
-     int src;
-     rtx x;
+check_live_1 (int src, rtx x)
 {
   int i;
   int regno;
 {
   int i;
   int regno;
@@ -1323,7 +1306,7 @@ check_live_1 (src, x)
       return 0;
     }
 
       return 0;
     }
 
-  if (GET_CODE (reg) != REG)
+  if (!REG_P (reg))
     return 1;
 
   regno = REGNO (reg);
     return 1;
 
   regno = REGNO (reg);
@@ -1338,7 +1321,7 @@ check_live_1 (src, x)
       if (regno < FIRST_PSEUDO_REGISTER)
        {
          /* Check for hard registers.  */
       if (regno < FIRST_PSEUDO_REGISTER)
        {
          /* Check for hard registers.  */
-         int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
+         int j = hard_regno_nregs[regno][GET_MODE (reg)];
          while (--j >= 0)
            {
              for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
          while (--j >= 0)
            {
              for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
@@ -1355,7 +1338,7 @@ check_live_1 (src, x)
        }
       else
        {
        }
       else
        {
-         /* Check for psuedo registers.  */
+         /* Check for pseudo registers.  */
          for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
            {
              int b = candidate_table[src].split_bbs.first_member[i];
          for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
            {
              int b = candidate_table[src].split_bbs.first_member[i];
@@ -1375,9 +1358,7 @@ check_live_1 (src, x)
    of every update-block of src.  */
 
 static void
    of every update-block of src.  */
 
 static void
-update_live_1 (src, x)
-     int src;
-     rtx x;
+update_live_1 (int src, rtx x)
 {
   int i;
   int regno;
 {
   int i;
   int regno;
@@ -1402,7 +1383,7 @@ update_live_1 (src, x)
       return;
     }
 
       return;
     }
 
-  if (GET_CODE (reg) != REG)
+  if (!REG_P (reg))
     return;
 
   /* Global registers are always live, so the code below does not apply
     return;
 
   /* Global registers are always live, so the code below does not apply
@@ -1414,7 +1395,7 @@ update_live_1 (src, x)
     {
       if (regno < FIRST_PSEUDO_REGISTER)
        {
     {
       if (regno < FIRST_PSEUDO_REGISTER)
        {
-         int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
+         int j = hard_regno_nregs[regno][GET_MODE (reg)];
          while (--j >= 0)
            {
              for (i = 0; i < candidate_table[src].update_bbs.nr_members; i++)
          while (--j >= 0)
            {
              for (i = 0; i < candidate_table[src].update_bbs.nr_members; i++)
@@ -1443,9 +1424,7 @@ update_live_1 (src, x)
    ready-list or before the scheduling.  */
 
 static int
    ready-list or before the scheduling.  */
 
 static int
-check_live (insn, src)
-     rtx insn;
-     int src;
+check_live (rtx insn, int src)
 {
   /* Find the registers set by instruction.  */
   if (GET_CODE (PATTERN (insn)) == SET
 {
   /* Find the registers set by instruction.  */
   if (GET_CODE (PATTERN (insn)) == SET
@@ -1470,9 +1449,7 @@ check_live (insn, src)
    block src to trg.  */
 
 static void
    block src to trg.  */
 
 static void
-update_live (insn, src)
-     rtx insn;
-     int src;
+update_live (rtx insn, int src)
 {
   /* Find the registers set by instruction.  */
   if (GET_CODE (PATTERN (insn)) == SET
 {
   /* Find the registers set by instruction.  */
   if (GET_CODE (PATTERN (insn)) == SET
@@ -1498,8 +1475,7 @@ update_live (insn, src)
 /* Turns on the fed_by_spec_load flag for insns fed by load_insn.  */
 
 static void
 /* Turns on the fed_by_spec_load flag for insns fed by load_insn.  */
 
 static void
-set_spec_fed (load_insn)
-     rtx load_insn;
+set_spec_fed (rtx load_insn)
 {
   rtx link;
 
 {
   rtx link;
 
@@ -1512,9 +1488,7 @@ set_spec_fed (load_insn)
 branch depending on insn, that guards the speculative load.  */
 
 static int
 branch depending on insn, that guards the speculative load.  */
 
 static int
-find_conditional_protection (insn, load_insn_bb)
-     rtx insn;
-     int load_insn_bb;
+find_conditional_protection (rtx insn, int load_insn_bb)
 {
   rtx link;
 
 {
   rtx link;
 
@@ -1527,7 +1501,7 @@ find_conditional_protection (insn, load_insn_bb)
          && IS_REACHABLE (INSN_BB (next), load_insn_bb)
          && load_insn_bb != INSN_BB (next)
          && GET_MODE (link) == VOIDmode
          && IS_REACHABLE (INSN_BB (next), load_insn_bb)
          && load_insn_bb != INSN_BB (next)
          && GET_MODE (link) == VOIDmode
-         && (GET_CODE (next) == JUMP_INSN
+         && (JUMP_P (next)
              || find_conditional_protection (next, load_insn_bb)))
        return 1;
     }
              || find_conditional_protection (next, load_insn_bb)))
        return 1;
     }
@@ -1549,9 +1523,7 @@ find_conditional_protection (insn, load_insn_bb)
    Locate the branch by following INSN_DEPEND from insn1.  */
 
 static int
    Locate the branch by following INSN_DEPEND from insn1.  */
 
 static int
-is_conditionally_protected (load_insn, bb_src, bb_trg)
-     rtx load_insn;
-     int bb_src, bb_trg;
+is_conditionally_protected (rtx load_insn, int bb_src, int bb_trg)
 {
   rtx link;
 
 {
   rtx link;
 
@@ -1561,7 +1533,7 @@ is_conditionally_protected (load_insn, bb_src, bb_trg)
 
       /* Must be a DEF-USE dependence upon non-branch.  */
       if (GET_MODE (link) != VOIDmode
 
       /* Must be a DEF-USE dependence upon non-branch.  */
       if (GET_MODE (link) != VOIDmode
-         || GET_CODE (insn1) == JUMP_INSN)
+         || JUMP_P (insn1))
        continue;
 
       /* Must exist a path: region-entry -> ... -> bb_trg -> ... load_insn.  */
        continue;
 
       /* Must exist a path: region-entry -> ... -> bb_trg -> ... load_insn.  */
@@ -1601,9 +1573,7 @@ is_conditionally_protected (load_insn, bb_src, bb_trg)
    load2 anyhow.  */
 
 static int
    load2 anyhow.  */
 
 static int
-is_pfree (load_insn, bb_src, bb_trg)
-     rtx load_insn;
-     int bb_src, bb_trg;
+is_pfree (rtx load_insn, int bb_src, int bb_trg)
 {
   rtx back_link;
   candidate *candp = candidate_table + bb_src;
 {
   rtx back_link;
   candidate *candp = candidate_table + bb_src;
@@ -1654,9 +1624,7 @@ is_pfree (load_insn, bb_src, bb_trg)
    a compare on load_insn's address).  */
 
 static int
    a compare on load_insn's address).  */
 
 static int
-is_prisky (load_insn, bb_src, bb_trg)
-     rtx load_insn;
-     int bb_src, bb_trg;
+is_prisky (rtx load_insn, int bb_src, int bb_trg)
 {
   if (FED_BY_SPEC_LOAD (load_insn))
     return 1;
 {
   if (FED_BY_SPEC_LOAD (load_insn))
     return 1;
@@ -1676,9 +1644,7 @@ is_prisky (load_insn, bb_src, bb_trg)
    and 0 otherwise.  */
 
 static int
    and 0 otherwise.  */
 
 static int
-is_exception_free (insn, bb_src, bb_trg)
-     rtx insn;
-     int bb_src, bb_trg;
+is_exception_free (rtx insn, int bb_src, int bb_trg)
 {
   int insn_class = haifa_classify_insn (insn);
 
 {
   int insn_class = haifa_classify_insn (insn);
 
@@ -1727,19 +1693,19 @@ static int sched_n_insns;
 static int last_was_jump;
 
 /* Implementations of the sched_info functions for region scheduling.  */
 static int last_was_jump;
 
 /* Implementations of the sched_info functions for region scheduling.  */
-static void init_ready_list PARAMS ((struct ready_list *));
-static int can_schedule_ready_p PARAMS ((rtx));
-static int new_ready PARAMS ((rtx));
-static int schedule_more_p PARAMS ((void));
-static const char *rgn_print_insn PARAMS ((rtx, int));
-static int rgn_rank PARAMS ((rtx, rtx));
-static int contributes_to_priority PARAMS ((rtx, rtx));
-static void compute_jump_reg_dependencies PARAMS ((rtx, regset));
+static void init_ready_list (struct ready_list *);
+static int can_schedule_ready_p (rtx);
+static int new_ready (rtx);
+static int schedule_more_p (void);
+static const char *rgn_print_insn (rtx, int);
+static int rgn_rank (rtx, rtx);
+static int contributes_to_priority (rtx, rtx);
+static void compute_jump_reg_dependencies (rtx, regset, regset, regset);
 
 /* Return nonzero if there are more insns that should be scheduled.  */
 
 static int
 
 /* Return nonzero if there are more insns that should be scheduled.  */
 
 static int
-schedule_more_p ()
+schedule_more_p (void)
 {
   return ! last_was_jump && sched_target_n_insns < target_n_insns;
 }
 {
   return ! last_was_jump && sched_target_n_insns < target_n_insns;
 }
@@ -1748,8 +1714,7 @@ schedule_more_p ()
    once before scheduling a set of insns.  */
 
 static void
    once before scheduling a set of insns.  */
 
 static void
-init_ready_list (ready)
-     struct ready_list *ready;
+init_ready_list (struct ready_list *ready)
 {
   rtx prev_head = current_sched_info->prev_head;
   rtx next_tail = current_sched_info->next_tail;
 {
   rtx prev_head = current_sched_info->prev_head;
   rtx next_tail = current_sched_info->next_tail;
@@ -1768,8 +1733,7 @@ init_ready_list (ready)
   /* Prepare current target block info.  */
   if (current_nr_blocks > 1)
     {
   /* Prepare current target block info.  */
   if (current_nr_blocks > 1)
     {
-      candidate_table = (candidate *) xmalloc (current_nr_blocks
-                                              * sizeof (candidate));
+      candidate_table = xmalloc (current_nr_blocks * sizeof (candidate));
 
       bblst_last = 0;
       /* bblst_table holds split blocks and update blocks for each block after
 
       bblst_last = 0;
       /* bblst_table holds split blocks and update blocks for each block after
@@ -1777,10 +1741,10 @@ init_ready_list (ready)
         the TO blocks of region edges, so there can be at most rgn_nr_edges
         of them.  */
       bblst_size = (current_nr_blocks - target_bb) * rgn_nr_edges;
         the TO blocks of region edges, so there can be at most rgn_nr_edges
         of them.  */
       bblst_size = (current_nr_blocks - target_bb) * rgn_nr_edges;
-      bblst_table = (int *) xmalloc (bblst_size * sizeof (int));
+      bblst_table = xmalloc (bblst_size * sizeof (int));
 
       bitlst_table_last = 0;
 
       bitlst_table_last = 0;
-      bitlst_table = (int *) xmalloc (rgn_nr_edges * sizeof (int));
+      bitlst_table = xmalloc (rgn_nr_edges * sizeof (int));
 
       compute_trg_info (target_bb);
     }
 
       compute_trg_info (target_bb);
     }
@@ -1790,7 +1754,13 @@ init_ready_list (ready)
   for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
     {
       if (INSN_DEP_COUNT (insn) == 0)
   for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
     {
       if (INSN_DEP_COUNT (insn) == 0)
-       ready_add (ready, insn);
+       {
+         ready_add (ready, insn);
+
+         if (targetm.sched.adjust_priority)
+           INSN_PRIORITY (insn) =
+             targetm.sched.adjust_priority (insn, INSN_PRIORITY (insn));
+       }
       target_n_insns++;
     }
 
       target_n_insns++;
     }
 
@@ -1815,18 +1785,19 @@ init_ready_list (ready)
 
            if (!CANT_MOVE (insn)
                && (!IS_SPECULATIVE_INSN (insn)
 
            if (!CANT_MOVE (insn)
                && (!IS_SPECULATIVE_INSN (insn)
-                   || ((((!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)))
+                   || ((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))))
              if (INSN_DEP_COUNT (insn) == 0)
                        && check_live (insn, bb_src)
                        && is_exception_free (insn, bb_src, target_bb))))
              if (INSN_DEP_COUNT (insn) == 0)
-               ready_add (ready, insn);
+               {
+                 ready_add (ready, insn); 
+
+                 if (targetm.sched.adjust_priority)
+                   INSN_PRIORITY (insn) =
+                     targetm.sched.adjust_priority (insn, INSN_PRIORITY (insn));
+               }
          }
       }
 }
          }
       }
 }
@@ -1835,10 +1806,9 @@ init_ready_list (ready)
    insn can be scheduled, nonzero if we should silently discard it.  */
 
 static int
    insn can be scheduled, nonzero if we should silently discard it.  */
 
 static int
-can_schedule_ready_p (insn)
-     rtx insn;
+can_schedule_ready_p (rtx insn)
 {
 {
-  if (GET_CODE (insn) == JUMP_INSN)
+  if (JUMP_P (insn))
     last_was_jump = 1;
 
   /* An interblock motion?  */
     last_was_jump = 1;
 
   /* An interblock motion?  */
@@ -1862,28 +1832,28 @@ can_schedule_ready_p (insn)
 
       /* Update source block boundaries.  */
       b1 = BLOCK_FOR_INSN (insn);
 
       /* Update source block boundaries.  */
       b1 = BLOCK_FOR_INSN (insn);
-      if (insn == b1->head && insn == b1->end)
+      if (insn == BB_HEAD (b1) && insn == BB_END (b1))
        {
          /* We moved all the insns in the basic block.
             Emit a note after the last insn and update the
             begin/end boundaries to point to the note.  */
          rtx note = emit_note_after (NOTE_INSN_DELETED, insn);
        {
          /* We moved all the insns in the basic block.
             Emit a note after the last insn and update the
             begin/end boundaries to point to the note.  */
          rtx note = emit_note_after (NOTE_INSN_DELETED, insn);
-         b1->head = note;
-         b1->end = note;
+         BB_HEAD (b1) = note;
+         BB_END (b1) = note;
        }
        }
-      else if (insn == b1->end)
+      else if (insn == BB_END (b1))
        {
          /* We took insns from the end of the basic block,
             so update the end of block boundary so that it
             points to the first insn we did not move.  */
        {
          /* We took insns from the end of the basic block,
             so update the end of block boundary so that it
             points to the first insn we did not move.  */
-         b1->end = PREV_INSN (insn);
+         BB_END (b1) = PREV_INSN (insn);
        }
        }
-      else if (insn == b1->head)
+      else if (insn == BB_HEAD (b1))
        {
          /* We took insns from the start of the basic block,
             so update the start of block boundary so that
             it points to the first insn we did not move.  */
        {
          /* We took insns from the start of the basic block,
             so update the start of block boundary so that
             it points to the first insn we did not move.  */
-         b1->head = NEXT_INSN (insn);
+         BB_HEAD (b1) = NEXT_INSN (insn);
        }
     }
   else
        }
     }
   else
@@ -1900,8 +1870,7 @@ can_schedule_ready_p (insn)
    if it should be moved to the ready list or the queue, or zero if we
    should silently discard it.  */
 static int
    if it should be moved to the ready list or the queue, or zero if we
    should silently discard it.  */
 static int
-new_ready (next)
-     rtx next;
+new_ready (rtx next)
 {
   /* For speculative insns, before inserting to ready/queue,
      check live, exception-free, and issue-delay.  */
 {
   /* For speculative insns, before inserting to ready/queue,
      check live, exception-free, and issue-delay.  */
@@ -1909,15 +1878,8 @@ new_ready (next)
       && (!IS_VALID (INSN_BB (next))
          || CANT_MOVE (next)
          || (IS_SPECULATIVE_INSN (next)
       && (!IS_VALID (INSN_BB (next))
          || CANT_MOVE (next)
          || (IS_SPECULATIVE_INSN (next)
-             && (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)
+             && ((recog_memoized (next) >= 0
+                  && min_insn_conflict_delay (curr_state, next, next) > 3)
                  || !check_live (next, INSN_BB (next))
                  || !is_exception_free (next, INSN_BB (next), target_bb)))))
     return 0;
                  || !check_live (next, INSN_BB (next))
                  || !is_exception_free (next, INSN_BB (next), target_bb)))))
     return 0;
@@ -1930,9 +1892,7 @@ new_ready (next)
    to be formatted so that multiple output lines will line up nicely.  */
 
 static const char *
    to be formatted so that multiple output lines will line up nicely.  */
 
 static const char *
-rgn_print_insn (insn, aligned)
-     rtx insn;
-     int aligned;
+rgn_print_insn (rtx insn, int aligned)
 {
   static char tmp[80];
 
 {
   static char tmp[80];
 
@@ -1953,8 +1913,7 @@ rgn_print_insn (insn, aligned)
    is to be preferred.  Zero if they are equally good.  */
 
 static int
    is to be preferred.  Zero if they are equally good.  */
 
 static int
-rgn_rank (insn1, insn2)
-     rtx insn1, insn2;
+rgn_rank (rtx insn1, rtx insn2)
 {
   /* Some comparison make sense in interblock scheduling only.  */
   if (INSN_BB (insn1) != INSN_BB (insn2))
 {
   /* Some comparison make sense in interblock scheduling only.  */
   if (INSN_BB (insn1) != INSN_BB (insn2))
@@ -1985,19 +1944,21 @@ rgn_rank (insn1, insn2)
    calculations.  */
 
 static int
    calculations.  */
 
 static int
-contributes_to_priority (next, insn)
-     rtx next, insn;
+contributes_to_priority (rtx next, rtx insn)
 {
   return BLOCK_NUM (next) == BLOCK_NUM (insn);
 }
 
 {
   return BLOCK_NUM (next) == BLOCK_NUM (insn);
 }
 
-/* INSN is a JUMP_INSN.  Store the set of registers that must be considered
-   to be set by this jump in SET.  */
+/* INSN is a JUMP_INSN, COND_SET is the set of registers that are
+   conditionally set before INSN.  Store the set of registers that
+   must be considered as used by this jump in USED and that of
+   registers that must be considered as set in SET.  */
 
 static void
 
 static void
-compute_jump_reg_dependencies (insn, set)
-     rtx insn ATTRIBUTE_UNUSED;
-     regset set ATTRIBUTE_UNUSED;
+compute_jump_reg_dependencies (rtx insn ATTRIBUTE_UNUSED,
+                              regset cond_exec ATTRIBUTE_UNUSED,
+                              regset used ATTRIBUTE_UNUSED,
+                              regset set ATTRIBUTE_UNUSED)
 {
   /* Nothing to do here, since we postprocess jumps in
      add_branch_dependences.  */
 {
   /* Nothing to do here, since we postprocess jumps in
      add_branch_dependences.  */
@@ -2019,14 +1980,13 @@ static struct sched_info region_sched_info =
 
   NULL, NULL,
   NULL, NULL,
 
   NULL, NULL,
   NULL, NULL,
-  0, 0
+  0, 0, 0
 };
 
 /* Determine if PAT sets a CLASS_LIKELY_SPILLED_P register.  */
 
 static bool
 };
 
 /* Determine if PAT sets a CLASS_LIKELY_SPILLED_P register.  */
 
 static bool
-sets_likely_spilled (pat)
-     rtx pat;
+sets_likely_spilled (rtx pat)
 {
   bool ret = false;
   note_stores (pat, sets_likely_spilled_1, &ret);
 {
   bool ret = false;
   note_stores (pat, sets_likely_spilled_1, &ret);
@@ -2034,9 +1994,7 @@ sets_likely_spilled (pat)
 }
 
 static void
 }
 
 static void
-sets_likely_spilled_1 (x, pat, data)
-     rtx x, pat;
-     void *data;
+sets_likely_spilled_1 (rtx x, rtx pat, void *data)
 {
   bool *ret = (bool *) data;
 
 {
   bool *ret = (bool *) data;
 
@@ -2051,8 +2009,7 @@ sets_likely_spilled_1 (x, pat, data)
    block.  */
 
 static void
    block.  */
 
 static void
-add_branch_dependences (head, tail)
-     rtx head, tail;
+add_branch_dependences (rtx head, rtx tail)
 {
   rtx insn, last;
 
 {
   rtx insn, last;
 
@@ -2065,7 +2022,7 @@ add_branch_dependences (head, tail)
      end since moving them results in worse register allocation.  Uses remain
      at the end to ensure proper register allocation.
 
      end since moving them results in worse register allocation.  Uses remain
      at the end to ensure proper register allocation.
 
-     cc0 setters remaim at the end because they can't be moved away from
+     cc0 setters remain at the end because they can't be moved away from
      their cc0 user.
 
      Insns setting CLASS_LIKELY_SPILLED_P registers (usually return values)
      their cc0 user.
 
      Insns setting CLASS_LIKELY_SPILLED_P registers (usually return values)
@@ -2074,9 +2031,9 @@ add_branch_dependences (head, tail)
 
   insn = tail;
   last = 0;
 
   insn = tail;
   last = 0;
-  while (GET_CODE (insn) == CALL_INSN
-        || GET_CODE (insn) == JUMP_INSN
-        || (GET_CODE (insn) == INSN
+  while (CALL_P (insn)
+        || JUMP_P (insn)
+        || (NONJUMP_INSN_P (insn)
             && (GET_CODE (PATTERN (insn)) == USE
                 || GET_CODE (PATTERN (insn)) == CLOBBER
                 || can_throw_internal (insn)
             && (GET_CODE (PATTERN (insn)) == USE
                 || GET_CODE (PATTERN (insn)) == CLOBBER
                 || can_throw_internal (insn)
@@ -2085,9 +2042,9 @@ add_branch_dependences (head, tail)
 #endif
                 || (!reload_completed
                     && sets_likely_spilled (PATTERN (insn)))))
 #endif
                 || (!reload_completed
                     && sets_likely_spilled (PATTERN (insn)))))
-        || GET_CODE (insn) == NOTE)
+        || NOTE_P (insn))
     {
     {
-      if (GET_CODE (insn) != NOTE)
+      if (!NOTE_P (insn))
        {
          if (last != 0 && !find_insn_list (insn, LOG_LINKS (last)))
            {
        {
          if (last != 0 && !find_insn_list (insn, LOG_LINKS (last)))
            {
@@ -2133,8 +2090,7 @@ static struct deps *bb_deps;
 /* Duplicate the INSN_LIST elements of COPY and prepend them to OLD.  */
 
 static rtx
 /* Duplicate the INSN_LIST elements of COPY and prepend them to OLD.  */
 
 static rtx
-concat_INSN_LIST (copy, old)
-     rtx copy, old;
+concat_INSN_LIST (rtx copy, rtx old)
 {
   rtx new = old;
   for (; copy ; copy = XEXP (copy, 1))
 {
   rtx new = old;
   for (; copy ; copy = XEXP (copy, 1))
@@ -2143,9 +2099,8 @@ concat_INSN_LIST (copy, old)
 }
 
 static void
 }
 
 static void
-concat_insn_mem_list (copy_insns, copy_mems, old_insns_p, old_mems_p)
-     rtx copy_insns, copy_mems;
-     rtx *old_insns_p, *old_mems_p;
+concat_insn_mem_list (rtx copy_insns, rtx copy_mems, rtx *old_insns_p,
+                     rtx *old_mems_p)
 {
   rtx new_insns = *old_insns_p;
   rtx new_mems = *old_mems_p;
 {
   rtx new_insns = *old_insns_p;
   rtx new_mems = *old_mems_p;
@@ -2165,9 +2120,7 @@ concat_insn_mem_list (copy_insns, copy_mems, old_insns_p, old_mems_p)
 /* After computing the dependencies for block BB, propagate the dependencies
    found in TMP_DEPS to the successors of the block.  */
 static void
 /* After computing the dependencies for block BB, propagate the dependencies
    found in TMP_DEPS to the successors of the block.  */
 static void
-propagate_deps (bb, pred_deps)
-     int bb;
-     struct deps *pred_deps;
+propagate_deps (int bb, struct deps *pred_deps)
 {
   int b = BB_TO_BLOCK (bb);
   int e, first_edge;
 {
   int b = BB_TO_BLOCK (bb);
   int e, first_edge;
@@ -2268,8 +2221,7 @@ propagate_deps (bb, pred_deps)
    similar, and the result is interblock dependences in the region.  */
 
 static void
    similar, and the result is interblock dependences in the region.  */
 
 static void
-compute_block_backward_dependences (bb)
-     int bb;
+compute_block_backward_dependences (int bb)
 {
   rtx head, tail;
   struct deps tmp_deps;
 {
   rtx head, tail;
   struct deps tmp_deps;
@@ -2292,7 +2244,7 @@ compute_block_backward_dependences (bb)
    them to the unused_*_list variables, so that they can be reused.  */
 
 static void
    them to the unused_*_list variables, so that they can be reused.  */
 
 static void
-free_pending_lists ()
+free_pending_lists (void)
 {
   int bb;
 
 {
   int bb;
 
@@ -2308,121 +2260,116 @@ free_pending_lists ()
 /* Print dependences for debugging, callable from debugger.  */
 
 void
 /* Print dependences for debugging, callable from debugger.  */
 
 void
-debug_dependencies ()
+debug_dependencies (void)
 {
   int bb;
 
   fprintf (sched_dump, ";;   --------------- forward dependences: ------------ \n");
   for (bb = 0; bb < current_nr_blocks; bb++)
     {
 {
   int bb;
 
   fprintf (sched_dump, ";;   --------------- forward dependences: ------------ \n");
   for (bb = 0; bb < current_nr_blocks; bb++)
     {
-      if (1)
-       {
-         rtx head, tail;
-         rtx next_tail;
-         rtx insn;
-
-         get_block_head_tail (BB_TO_BLOCK (bb), &head, &tail);
-         next_tail = NEXT_INSN (tail);
-         fprintf (sched_dump, "\n;;   --- Region Dependences --- b %d bb %d \n",
-                  BB_TO_BLOCK (bb), bb);
+      rtx head, tail;
+      rtx next_tail;
+      rtx insn;
 
 
-         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",
-             "----", "----", "--", "---", "----", "----", "--------", "-----");
-           }
+      get_block_head_tail (BB_TO_BLOCK (bb), &head, &tail);
+      next_tail = NEXT_INSN (tail);
+      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%14s\n",
+              "insn", "code", "bb", "dep", "prio", "cost",
+              "reservation");
+      fprintf (sched_dump, ";;   %7s%6s%6s%6s%6s%6s%14s\n",
+              "----", "----", "--", "---", "----", "----",
+              "-----------");
+
+      for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
+       {
+         rtx link;
 
 
-         for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
+         if (! INSN_P (insn))
            {
            {
-             rtx link;
-
-             if (! INSN_P (insn))
+             int n;
+             fprintf (sched_dump, ";;   %6d ", INSN_UID (insn));
+             if (NOTE_P (insn))
                {
                {
-                 int n;
-                 fprintf (sched_dump, ";;   %6d ", INSN_UID (insn));
-                 if (GET_CODE (insn) == NOTE)
+                 n = NOTE_LINE_NUMBER (insn);
+                 if (n < 0)
+                   fprintf (sched_dump, "%s\n", GET_NOTE_INSN_NAME (n));
+                 else
                    {
                    {
-                     n = NOTE_LINE_NUMBER (insn);
-                     if (n < 0)
-                       fprintf (sched_dump, "%s\n", GET_NOTE_INSN_NAME (n));
-                     else
-                       fprintf (sched_dump, "line %d, file %s\n", n,
-                                NOTE_SOURCE_FILE (insn));
+                     expanded_location xloc;
+                     NOTE_EXPANDED_LOCATION (xloc, insn);
+                     fprintf (sched_dump, "line %d, file %s\n",
+                              xloc.line, xloc.file);
                    }
                    }
-                 else
-                   fprintf (sched_dump, " {%s}\n", GET_RTX_NAME (GET_CODE (insn)));
-                 continue;
-               }
-
-             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
                }
              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)));
-             fprintf (sched_dump, "\n");
+               fprintf (sched_dump, " {%s}\n", GET_RTX_NAME (GET_CODE (insn)));
+             continue;
            }
            }
+
+         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);
+
+         fprintf (sched_dump, "\t: ");
+         for (link = INSN_DEPEND (insn); link; link = XEXP (link, 1))
+           fprintf (sched_dump, "%d ", INSN_UID (XEXP (link, 0)));
+         fprintf (sched_dump, "\n");
        }
     }
   fprintf (sched_dump, "\n");
 }
 \f
        }
     }
   fprintf (sched_dump, "\n");
 }
 \f
+/* Returns true if all the basic blocks of the current region have
+   NOTE_DISABLE_SCHED_OF_BLOCK which means not to schedule that region.  */
+static bool
+sched_is_disabled_for_current_region_p (void)
+{
+  rtx first_bb_insn, last_bb_insn, insn;
+  int bb;
+
+  for (bb = 0; bb < current_nr_blocks; bb++)
+    {
+      bool disable_sched = false;
+      /* Searching for NOTE_DISABLE_SCHED_OF_BLOCK note between the
+         start and end of the basic block. */
+      get_block_head_tail (BB_TO_BLOCK (bb), &first_bb_insn,
+                          &last_bb_insn);
+      for (insn = last_bb_insn; insn != NULL && insn != first_bb_insn;
+           insn = PREV_INSN (insn))
+       if (GET_CODE (insn) == NOTE
+           && (NOTE_LINE_NUMBER (insn)
+               == NOTE_DISABLE_SCHED_OF_BLOCK))
+          {
+              disable_sched = true;
+             break;
+          }
+      if (! disable_sched)
+       return false;
+    }
+
+  return true;
+}
+
 /* Schedule a region.  A region is either an inner loop, a loop-free
    subroutine, or a single basic block.  Each bb in the region is
    scheduled after its flow predecessors.  */
 
 static void
 /* Schedule a region.  A region is either an inner loop, a loop-free
    subroutine, or a single basic block.  Each bb in the region is
    scheduled after its flow predecessors.  */
 
 static void
-schedule_region (rgn)
-     int rgn;
+schedule_region (int rgn)
 {
   int bb;
   int rgn_n_insns = 0;
 {
   int bb;
   int rgn_n_insns = 0;
@@ -2432,10 +2379,15 @@ schedule_region (rgn)
   current_nr_blocks = RGN_NR_BLOCKS (rgn);
   current_blocks = RGN_BLOCKS (rgn);
 
   current_nr_blocks = RGN_NR_BLOCKS (rgn);
   current_blocks = RGN_BLOCKS (rgn);
 
+  /* Don't schedule region that is marked by
+     NOTE_DISABLE_SCHED_OF_BLOCK.  */
+  if (sched_is_disabled_for_current_region_p ())
+    return;
+
   init_deps_global ();
 
   /* Initializations for region data dependence analysis.  */
   init_deps_global ();
 
   /* Initializations for region data dependence analysis.  */
-  bb_deps = (struct deps *) xmalloc (sizeof (struct deps) * current_nr_blocks);
+  bb_deps = xmalloc (sizeof (struct deps) * current_nr_blocks);
   for (bb = 0; bb < current_nr_blocks; bb++)
     init_deps (bb_deps + bb);
 
   for (bb = 0; bb < current_nr_blocks; bb++)
     init_deps (bb_deps + bb);
 
@@ -2470,17 +2422,17 @@ schedule_region (rgn)
     {
       int i;
 
     {
       int i;
 
-      prob = (float *) xmalloc ((current_nr_blocks) * sizeof (float));
+      prob = xmalloc ((current_nr_blocks) * sizeof (float));
 
       dom = sbitmap_vector_alloc (current_nr_blocks, current_nr_blocks);
       sbitmap_vector_zero (dom, current_nr_blocks);
       /* Edge to bit.  */
       rgn_nr_edges = 0;
 
       dom = sbitmap_vector_alloc (current_nr_blocks, current_nr_blocks);
       sbitmap_vector_zero (dom, current_nr_blocks);
       /* Edge to bit.  */
       rgn_nr_edges = 0;
-      edge_to_bit = (int *) xmalloc (nr_edges * sizeof (int));
+      edge_to_bit = xmalloc (nr_edges * sizeof (int));
       for (i = 1; i < nr_edges; i++)
        if (CONTAINING_RGN (FROM_BLOCK (i)) == rgn)
          EDGE_TO_BIT (i) = rgn_nr_edges++;
       for (i = 1; i < nr_edges; i++)
        if (CONTAINING_RGN (FROM_BLOCK (i)) == rgn)
          EDGE_TO_BIT (i) = rgn_nr_edges++;
-      rgn_edges = (int *) xmalloc (rgn_nr_edges * sizeof (int));
+      rgn_edges = xmalloc (rgn_nr_edges * sizeof (int));
 
       rgn_nr_edges = 0;
       for (i = 1; i < nr_edges; i++)
 
       rgn_nr_edges = 0;
       for (i = 1; i < nr_edges; i++)
@@ -2520,7 +2472,7 @@ schedule_region (rgn)
 
       /* rm_other_notes only removes notes which are _inside_ the
         block---that is, it won't remove notes before the first real insn
 
       /* rm_other_notes only removes notes which are _inside_ the
         block---that is, it won't remove notes before the first real insn
-        or after the last real insn of the block.  So if the first insn
+        or after the last real insn of the block.  So if the first insn
         has a REG_SAVE_NOTE which would otherwise be emitted before the
         insn, it is redundant with the note before the start of the
         block, and so we have to take it out.  */
         has a REG_SAVE_NOTE which would otherwise be emitted before the
         insn, it is redundant with the note before the start of the
         block, and so we have to take it out.  */
@@ -2551,10 +2503,10 @@ schedule_region (rgn)
       sched_rgn_n_insns += sched_n_insns;
 
       /* Update target block boundaries.  */
       sched_rgn_n_insns += sched_n_insns;
 
       /* Update target block boundaries.  */
-      if (head == BLOCK_HEAD (b))
-       BLOCK_HEAD (b) = current_sched_info->head;
-      if (tail == BLOCK_END (b))
-       BLOCK_END (b) = current_sched_info->tail;
+      if (head == BB_HEAD (BASIC_BLOCK (b)))
+       BB_HEAD (BASIC_BLOCK (b)) = current_sched_info->head;
+      if (tail == BB_END (BASIC_BLOCK (b)))
+       BB_END (BASIC_BLOCK (b)) = current_sched_info->tail;
 
       /* Clean up.  */
       if (current_nr_blocks > 1)
 
       /* Clean up.  */
       if (current_nr_blocks > 1)
@@ -2605,16 +2557,16 @@ static int *deaths_in_region;
 /* Initialize data structures for region scheduling.  */
 
 static void
 /* Initialize data structures for region scheduling.  */
 
 static void
-init_regions ()
+init_regions (void)
 {
   sbitmap blocks;
   int rgn;
 
   nr_regions = 0;
 {
   sbitmap blocks;
   int rgn;
 
   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 ((last_basic_block) * sizeof (int));
-  containing_rgn = (int *) xmalloc ((last_basic_block) * sizeof (int));
+  rgn_table = xmalloc ((n_basic_blocks) * sizeof (region));
+  rgn_bb_table = xmalloc ((n_basic_blocks) * sizeof (int));
+  block_to_bb = xmalloc ((last_basic_block) * sizeof (int));
+  containing_rgn = xmalloc ((last_basic_block) * sizeof (int));
 
   /* Compute regions for scheduling.  */
   if (reload_completed
 
   /* Compute regions for scheduling.  */
   if (reload_completed
@@ -2632,7 +2584,6 @@ init_regions ()
        }
       else
        {
        }
       else
        {
-         dominance_info dom;
          struct edge_list *edge_list;
 
          /* The scheduler runs after estimate_probabilities; therefore, we
          struct edge_list *edge_list;
 
          /* The scheduler runs after estimate_probabilities; therefore, we
@@ -2642,7 +2593,7 @@ init_regions ()
          edge_list = create_edge_list ();
 
          /* Compute the dominators and post dominators.  */
          edge_list = create_edge_list ();
 
          /* Compute the dominators and post dominators.  */
-         dom = calculate_dominance_info (CDI_DOMINATORS);
+         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
 
          /* build_control_flow will return nonzero if it detects unreachable
             blocks or any other irregularity with the cfg which prevents
@@ -2650,7 +2601,7 @@ init_regions ()
          if (build_control_flow (edge_list) != 0)
            find_single_block_region ();
          else
          if (build_control_flow (edge_list) != 0)
            find_single_block_region ();
          else
-           find_rgns (edge_list, dom);
+           find_rgns (edge_list);
 
          if (sched_verbose >= 3)
            debug_regions ();
 
          if (sched_verbose >= 3)
            debug_regions ();
@@ -2660,7 +2611,7 @@ init_regions ()
 
          /* For now.  This will move as more and more of haifa is converted
             to using the cfg code in flow.c.  */
 
          /* For now.  This will move as more and more of haifa is converted
             to using the cfg code in flow.c.  */
-         free_dominance_info (dom);
+         free_dominance_info (CDI_DOMINATORS);
        }
     }
 
        }
     }
 
@@ -2668,7 +2619,7 @@ init_regions ()
   if (CHECK_DEAD_NOTES)
     {
       blocks = sbitmap_alloc (last_basic_block);
   if (CHECK_DEAD_NOTES)
     {
       blocks = sbitmap_alloc (last_basic_block);
-      deaths_in_region = (int *) xmalloc (sizeof (int) * nr_regions);
+      deaths_in_region = xmalloc (sizeof (int) * nr_regions);
       /* Remove all death notes from the subroutine.  */
       for (rgn = 0; rgn < nr_regions; rgn++)
        {
       /* Remove all death notes from the subroutine.  */
       for (rgn = 0; rgn < nr_regions; rgn++)
        {
@@ -2690,8 +2641,7 @@ init_regions ()
    this pass.  */
 
 void
    this pass.  */
 
 void
-schedule_insns (dump_file)
-     FILE *dump_file;
+schedule_insns (FILE *dump_file)
 {
   sbitmap large_region_blocks, blocks;
   int rgn;
 {
   sbitmap large_region_blocks, blocks;
   int rgn;
About OSDN
Find Software
Develop Software
Help