1 files changed, 89 insertions, 128 deletions

diff --git a/contrib/gcc/lcm.c b/contrib/gcc/lcm.c
index bdbae42..c866904 100644
--- a/contrib/gcc/lcm.c
+++ b/contrib/gcc/lcm.c
@@ -1,5 +1,6 @@
 /* Generic partial redundancy elimination with lazy code motion support.
-   Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -51,6 +52,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #include "config.h"
 #include "system.h"
+#include "coretypes.h"
+#include "tm.h"
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"
@@ -61,38 +64,29 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "basic-block.h"
 #include "output.h"
 #include "tm_p.h"
+#include "function.h"
 
 /* We want target macros for the mode switching code to be able to refer
    to instruction attribute values.  */
 #include "insn-attr.h"
 
 /* Edge based LCM routines.  */
-static void compute_antinout_edge	PARAMS ((sbitmap *, sbitmap *,
-						 sbitmap *, sbitmap *));
-static void compute_earliest		PARAMS ((struct edge_list *, int,
-						 sbitmap *, sbitmap *,
-						 sbitmap *, sbitmap *,
-						 sbitmap *));
-static void compute_laterin		PARAMS ((struct edge_list *, sbitmap *,
-						 sbitmap *, sbitmap *,
-						 sbitmap *));
-static void compute_insert_delete	PARAMS ((struct edge_list *edge_list,
-						 sbitmap *, sbitmap *,
-						 sbitmap *, sbitmap *,
-						 sbitmap *));
+static void compute_antinout_edge (sbitmap *, sbitmap *, sbitmap *, sbitmap *);
+static void compute_earliest (struct edge_list *, int, sbitmap *, sbitmap *,
+			      sbitmap *, sbitmap *, sbitmap *);
+static void compute_laterin (struct edge_list *, sbitmap *, sbitmap *,
+			     sbitmap *, sbitmap *);
+static void compute_insert_delete (struct edge_list *edge_list, sbitmap *,
+				   sbitmap *, sbitmap *, sbitmap *, sbitmap *);
 
 /* Edge based LCM routines on a reverse flowgraph.  */
-static void compute_farthest		PARAMS ((struct edge_list *, int,
-						 sbitmap *, sbitmap *,
-						 sbitmap*, sbitmap *,
-						 sbitmap *));
-static void compute_nearerout		PARAMS ((struct edge_list *, sbitmap *,
-						 sbitmap *, sbitmap *,
-						 sbitmap *));
-static void compute_rev_insert_delete	PARAMS ((struct edge_list *edge_list,
-						 sbitmap *, sbitmap *,
-						 sbitmap *, sbitmap *,
-						 sbitmap *));
+static void compute_farthest (struct edge_list *, int, sbitmap *, sbitmap *,
+			      sbitmap*, sbitmap *, sbitmap *);
+static void compute_nearerout (struct edge_list *, sbitmap *, sbitmap *,
+			       sbitmap *, sbitmap *);
+static void compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *,
+				       sbitmap *, sbitmap *, sbitmap *,
+				       sbitmap *);
 
 /* Edge based lcm routines.  */
 
@@ -101,11 +95,8 @@ static void compute_rev_insert_delete	PARAMS ((struct edge_list *edge_list,
    Other than that, its pretty much identical to compute_antinout.  */
 
 static void
-compute_antinout_edge (antloc, transp, antin, antout)
-     sbitmap *antloc;
-     sbitmap *transp;
-     sbitmap *antin;
-     sbitmap *antout;
+compute_antinout_edge (sbitmap *antloc, sbitmap *transp, sbitmap *antin,
+		       sbitmap *antout)
 {
   basic_block bb;
   edge e;
@@ -115,8 +106,7 @@ compute_antinout_edge (antloc, transp, antin, antout)
   /* Allocate a worklist array/queue.  Entries are only added to the
      list if they were not already on the list.  So the size is
      bounded by the number of basic blocks.  */
-  qin = qout = worklist
-    = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
+  qin = qout = worklist = xmalloc (sizeof (basic_block) * n_basic_blocks);
 
   /* We want a maximal solution, so make an optimistic initialization of
      ANTIN.  */
@@ -126,7 +116,7 @@ compute_antinout_edge (antloc, transp, antin, antout)
      optimistic initialization of ANTIN above.  */
   FOR_EACH_BB_REVERSE (bb)
     {
-      *qin++ =bb;
+      *qin++ = bb;
       bb->aux = bb;
     }
 
@@ -186,10 +176,9 @@ compute_antinout_edge (antloc, transp, antin, antout)
 /* Compute the earliest vector for edge based lcm.  */
 
 static void
-compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest)
-     struct edge_list *edge_list;
-     int n_exprs;
-     sbitmap *antin, *antout, *avout, *kill, *earliest;
+compute_earliest (struct edge_list *edge_list, int n_exprs, sbitmap *antin,
+		  sbitmap *antout, sbitmap *avout, sbitmap *kill,
+		  sbitmap *earliest)
 {
   sbitmap difference, temp_bitmap;
   int x, num_edges;
@@ -255,9 +244,8 @@ compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest)
      to compute it.  */
 
 static void
-compute_laterin (edge_list, earliest, antloc, later, laterin)
-     struct edge_list *edge_list;
-     sbitmap *earliest, *antloc, *later, *laterin;
+compute_laterin (struct edge_list *edge_list, sbitmap *earliest,
+		 sbitmap *antloc, sbitmap *later, sbitmap *laterin)
 {
   int num_edges, i;
   edge e;
@@ -270,7 +258,7 @@ compute_laterin (edge_list, earliest, antloc, later, laterin)
      list if they were not already on the list.  So the size is
      bounded by the number of basic blocks.  */
   qin = qout = worklist
-    = (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
+    = xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
 
   /* Initialize a mapping from each edge to its index.  */
   for (i = 0; i < num_edges; i++)
@@ -305,7 +293,7 @@ compute_laterin (edge_list, earliest, antloc, later, laterin)
   qin = worklist;
   /* Note that we do not use the last allocated element for our queue,
      as EXIT_BLOCK is never inserted into it. In fact the above allocation
-     of n_basic_blocks + 1 elements is not encessary.  */
+     of n_basic_blocks + 1 elements is not necessary.  */
   qend = &worklist[n_basic_blocks];
   qlen = n_basic_blocks;
 
@@ -358,10 +346,9 @@ compute_laterin (edge_list, earliest, antloc, later, laterin)
 /* Compute the insertion and deletion points for edge based LCM.  */
 
 static void
-compute_insert_delete (edge_list, antloc, later, laterin,
-		       insert, delete)
-     struct edge_list *edge_list;
-     sbitmap *antloc, *later, *laterin, *insert, *delete;
+compute_insert_delete (struct edge_list *edge_list, sbitmap *antloc,
+		       sbitmap *later, sbitmap *laterin, sbitmap *insert,
+		       sbitmap *delete)
 {
   int x;
   basic_block bb;
@@ -385,15 +372,9 @@ compute_insert_delete (edge_list, antloc, later, laterin,
    map the insert vector to what edge an expression should be inserted on.  */
 
 struct edge_list *
-pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete)
-     FILE *file ATTRIBUTE_UNUSED;
-     int n_exprs;
-     sbitmap *transp;
-     sbitmap *avloc;
-     sbitmap *antloc;
-     sbitmap *kill;
-     sbitmap **insert;
-     sbitmap **delete;
+pre_edge_lcm (FILE *file ATTRIBUTE_UNUSED, int n_exprs, sbitmap *transp,
+	      sbitmap *avloc, sbitmap *antloc, sbitmap *kill,
+	      sbitmap **insert, sbitmap **delete)
 {
   sbitmap *antin, *antout, *earliest;
   sbitmap *avin, *avout;
@@ -488,8 +469,8 @@ pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete)
    Return the number of passes we performed to iterate to a solution.  */
 
 void
-compute_available (avloc, kill, avout, avin)
-     sbitmap *avloc, *kill, *avout, *avin;
+compute_available (sbitmap *avloc, sbitmap *kill, sbitmap *avout,
+		   sbitmap *avin)
 {
   edge e;
   basic_block *worklist, *qin, *qout, *qend, bb;
@@ -498,8 +479,7 @@ compute_available (avloc, kill, avout, avin)
   /* Allocate a worklist array/queue.  Entries are only added to the
      list if they were not already on the list.  So the size is
      bounded by the number of basic blocks.  */
-  qin = qout = worklist
-    = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
+  qin = qout = worklist = xmalloc (sizeof (basic_block) * n_basic_blocks);
 
   /* We want a maximal solution.  */
   sbitmap_vector_ones (avout, last_basic_block);
@@ -570,11 +550,9 @@ compute_available (avloc, kill, avout, avin)
 /* Compute the farthest vector for edge based lcm.  */
 
 static void
-compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
-		  kill, farthest)
-     struct edge_list *edge_list;
-     int n_exprs;
-     sbitmap *st_avout, *st_avin, *st_antin, *kill, *farthest;
+compute_farthest (struct edge_list *edge_list, int n_exprs,
+		  sbitmap *st_avout, sbitmap *st_avin, sbitmap *st_antin,
+		  sbitmap *kill, sbitmap *farthest)
 {
   sbitmap difference, temp_bitmap;
   int x, num_edges;
@@ -616,9 +594,8 @@ compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
    implementation can be found before compute_laterin.  */
 
 static void
-compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout)
-     struct edge_list *edge_list;
-     sbitmap *farthest, *st_avloc, *nearer, *nearerout;
+compute_nearerout (struct edge_list *edge_list, sbitmap *farthest,
+		   sbitmap *st_avloc, sbitmap *nearer, sbitmap *nearerout)
 {
   int num_edges, i;
   edge e;
@@ -629,8 +606,7 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout)
   /* Allocate a worklist array/queue.  Entries are only added to the
      list if they were not already on the list.  So the size is
      bounded by the number of basic blocks.  */
-  tos = worklist
-    = (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
+  tos = worklist = xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
 
   /* Initialize NEARER for each edge and build a mapping from an edge to
      its index.  */
@@ -699,10 +675,9 @@ compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout)
 /* Compute the insertion and deletion points for edge based LCM.  */
 
 static void
-compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
-			   insert, delete)
-     struct edge_list *edge_list;
-     sbitmap *st_avloc, *nearer, *nearerout, *insert, *delete;
+compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *st_avloc,
+			   sbitmap *nearer, sbitmap *nearerout,
+			   sbitmap *insert, sbitmap *delete)
 {
   int x;
   basic_block bb;
@@ -726,16 +701,9 @@ compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
    an expression should be inserted on.  */
 
 struct edge_list *
-pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill,
-		  insert, delete)
-     FILE *file ATTRIBUTE_UNUSED;
-     int n_exprs;
-     sbitmap *transp;
-     sbitmap *st_avloc;
-     sbitmap *st_antloc;
-     sbitmap *kill;
-     sbitmap **insert;
-     sbitmap **delete;
+pre_edge_rev_lcm (FILE *file ATTRIBUTE_UNUSED, int n_exprs, sbitmap *transp,
+		  sbitmap *st_avloc, sbitmap *st_antloc, sbitmap *kill,
+		  sbitmap **insert, sbitmap **delete)
 {
   sbitmap *st_antin, *st_antout;
   sbitmap *st_avout, *st_avin, *farthest;
@@ -746,8 +714,8 @@ pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill,
   edge_list = create_edge_list ();
   num_edges = NUM_EDGES (edge_list);
 
-  st_antin = (sbitmap *) sbitmap_vector_alloc (last_basic_block, n_exprs);
-  st_antout = (sbitmap *) sbitmap_vector_alloc (last_basic_block, n_exprs);
+  st_antin = sbitmap_vector_alloc (last_basic_block, n_exprs);
+  st_antout = sbitmap_vector_alloc (last_basic_block, n_exprs);
   sbitmap_vector_zero (st_antin, last_basic_block);
   sbitmap_vector_zero (st_antout, last_basic_block);
   compute_antinout_edge (st_antloc, transp, st_antin, st_antout);
@@ -847,9 +815,9 @@ pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill,
 
    The LCM algorithm is then run over the flow graph to determine where to
    place the sets to the highest-priority value in respect of first the first
-   insn in any one block.  Any adjustments required to the transparancy
+   insn in any one block.  Any adjustments required to the transparency
    vectors are made, then the next iteration starts for the next-lower
-   priority mode, till for each entity all modes are exhasted.
+   priority mode, till for each entity all modes are exhausted.
 
    More details are located in the code for optimize_mode_switching().  */
 
@@ -884,11 +852,11 @@ static sbitmap *comp;
 static sbitmap *delete;
 static sbitmap *insert;
 
-static struct seginfo * new_seginfo PARAMS ((int, rtx, int, HARD_REG_SET));
-static void add_seginfo PARAMS ((struct bb_info *, struct seginfo *));
-static void reg_dies PARAMS ((rtx, HARD_REG_SET));
-static void reg_becomes_live PARAMS ((rtx, rtx, void *));
-static void make_preds_opaque PARAMS ((basic_block, int));
+static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET);
+static void add_seginfo (struct bb_info *, struct seginfo *);
+static void reg_dies (rtx, HARD_REG_SET);
+static void reg_becomes_live (rtx, rtx, void *);
+static void make_preds_opaque (basic_block, int);
 #endif
 
 #ifdef OPTIMIZE_MODE_SWITCHING
@@ -897,11 +865,7 @@ static void make_preds_opaque PARAMS ((basic_block, int));
    with the MODE, INSN, and basic block BB parameters.  */
 
 static struct seginfo *
-new_seginfo (mode, insn, bb, regs_live)
-     int mode;
-     rtx insn;
-     int bb;
-     HARD_REG_SET regs_live;
+new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live)
 {
   struct seginfo *ptr;
   ptr = xmalloc (sizeof (struct seginfo));
@@ -918,9 +882,7 @@ new_seginfo (mode, insn, bb, regs_live)
    INFO is the structure to be linked in.  */
 
 static void
-add_seginfo (head, info)
-     struct bb_info *head;
-     struct seginfo *info;
+add_seginfo (struct bb_info *head, struct seginfo *info)
 {
   struct seginfo *ptr;
 
@@ -942,9 +904,7 @@ add_seginfo (head, info)
    we are currently handling mode-switching for.  */
 
 static void
-make_preds_opaque (b, j)
-     basic_block b;
-     int j;
+make_preds_opaque (basic_block b, int j)
 {
   edge e;
 
@@ -963,9 +923,7 @@ make_preds_opaque (b, j)
 /* Record in LIVE that register REG died.  */
 
 static void
-reg_dies (reg, live)
-     rtx reg;
-     HARD_REG_SET live;
+reg_dies (rtx reg, HARD_REG_SET live)
 {
   int regno, nregs;
 
@@ -983,10 +941,7 @@ reg_dies (reg, live)
    This is called via note_stores.  */
 
 static void
-reg_becomes_live (reg, setter, live)
-     rtx reg;
-     rtx setter ATTRIBUTE_UNUSED;
-     void *live;
+reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live)
 {
   int regno, nregs;
 
@@ -1003,12 +958,17 @@ reg_becomes_live (reg, setter, live)
       SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
 }
 
+/* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined
+   and vice versa.  */
+#if defined (MODE_ENTRY) != defined (MODE_EXIT)
+ #error "Both MODE_ENTRY and MODE_EXIT must be defined"
+#endif
+
 /* Find all insns that need a particular mode setting, and insert the
    necessary mode switches.  Return true if we did work.  */
 
 int
-optimize_mode_switching (file)
-     FILE *file;
+optimize_mode_switching (FILE *file)
 {
   rtx insn;
   int e;
@@ -1036,12 +996,11 @@ optimize_mode_switching (file)
 	/* Create the list of segments within each basic block.
 	   If NORMAL_MODE is defined, allow for two extra
 	   blocks split from the entry and exit block.  */
-#ifdef NORMAL_MODE
+#if defined (MODE_ENTRY) && defined (MODE_EXIT)
 	entry_exit_extra = 2;
 #endif
 	bb_info[n_entities]
-	  = (struct bb_info *) xcalloc (last_basic_block + entry_exit_extra,
-					sizeof **bb_info);
+	  = xcalloc (last_basic_block + entry_exit_extra, sizeof **bb_info);
 	entity_map[n_entities++] = e;
 	if (num_modes[e] > max_num_modes)
 	  max_num_modes = num_modes[e];
@@ -1050,7 +1009,7 @@ optimize_mode_switching (file)
   if (! n_entities)
     return 0;
 
-#ifdef NORMAL_MODE
+#if defined (MODE_ENTRY) && defined (MODE_EXIT)
   {
     /* Split the edge from the entry block and the fallthrough edge to the
        exit block, so that we can note that there NORMAL_MODE is supplied /
@@ -1099,8 +1058,8 @@ optimize_mode_switching (file)
 
 	  REG_SET_TO_HARD_REG_SET (live_now,
 				   bb->global_live_at_start);
-	  for (insn = bb->head;
-	       insn != NULL && insn != NEXT_INSN (bb->end);
+	  for (insn = BB_HEAD (bb);
+	       insn != NULL && insn != NEXT_INSN (BB_END (bb));
 	       insn = NEXT_INSN (insn))
 	    {
 	      if (INSN_P (insn))
@@ -1115,7 +1074,9 @@ optimize_mode_switching (file)
 		      add_seginfo (info + bb->index, ptr);
 		      RESET_BIT (transp[bb->index], j);
 		    }
-
+#ifdef MODE_AFTER
+		  last_mode = MODE_AFTER (last_mode, insn);
+#endif
 		  /* Update LIVE_NOW.  */
 		  for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
 		    if (REG_NOTE_KIND (link) == REG_DEAD)
@@ -1132,13 +1093,13 @@ optimize_mode_switching (file)
 	  /* Check for blocks without ANY mode requirements.  */
 	  if (last_mode == no_mode)
 	    {
-	      ptr = new_seginfo (no_mode, bb->end, bb->index, live_now);
+	      ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
 	      add_seginfo (info + bb->index, ptr);
 	    }
 	}
-#ifdef NORMAL_MODE
+#if defined (MODE_ENTRY) && defined (MODE_EXIT)
       {
-	int mode = NORMAL_MODE (e);
+	int mode = MODE_ENTRY (e);
 
 	if (mode != no_mode)
 	  {
@@ -1156,7 +1117,7 @@ optimize_mode_switching (file)
 	    info[bb->index].computing = mode;
 
 	    if (pre_exit)
-	      info[pre_exit->index].seginfo->mode = mode;
+	      info[pre_exit->index].seginfo->mode = MODE_EXIT (e);
 	  }
       }
 #endif /* NORMAL_MODE */
@@ -1240,8 +1201,8 @@ optimize_mode_switching (file)
 	      if (eg->flags & EDGE_ABNORMAL)
 		{
 		  emited = true;
-		  if (GET_CODE (src_bb->end) == JUMP_INSN)
-		    emit_insn_before (mode_set, src_bb->end);
+		  if (GET_CODE (BB_END (src_bb)) == JUMP_INSN)
+		    emit_insn_before (mode_set, BB_END (src_bb));
 		  /* It doesn't make sense to switch to normal mode
 		     after a CALL_INSN, so we're going to abort if we
 		     find one.  The cases in which a CALL_INSN may
@@ -1253,8 +1214,8 @@ optimize_mode_switching (file)
 		     the call (it wouldn't make sense, anyway).  In
 		     the case of EH edges, EH entry points also start
 		     in normal mode, so a similar reasoning applies.  */
-		  else if (GET_CODE (src_bb->end) == INSN)
-		    emit_insn_after (mode_set, src_bb->end);
+		  else if (GET_CODE (BB_END (src_bb)) == INSN)
+		    emit_insn_after (mode_set, BB_END (src_bb));
 		  else
 		    abort ();
 		  bb_info[j][src_bb->index].computing = mode;
@@ -1332,7 +1293,7 @@ optimize_mode_switching (file)
   if (need_commit)
     commit_edge_insertions ();
 
-#ifdef NORMAL_MODE
+#if defined (MODE_ENTRY) && defined (MODE_EXIT)
   cleanup_cfg (CLEANUP_NO_INSN_DEL);
 #else
   if (!need_commit && !emited)