Mon Jun 10 20:42:34 CEST 2002 Jan Hubicka <jh@suse.cz>

[thirdparty/gcc.git] / gcc / predict.c

diff --git a/gcc/predict.c b/gcc/predict.c
index c00c86409f3147bef98067298b5cd580801055ae..71950ee6766f1b119b2d67f76618c0efce35e537 100644 (file)
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -49,6 +49,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "real.h"
 #include "params.h"
 #include "target.h"
+#include "loop.h"
 
 /* real constants: 0, 1, 1-1/REG_BR_PROB_BASE, REG_BR_PROB_BASE, 0.5,
                    REAL_BB_FREQ_MAX.  */
@@ -73,10 +74,12 @@ static void estimate_loops_at_level  PARAMS ((struct loop *loop));
 static void propagate_freq              PARAMS ((struct loop *));
 static void estimate_bb_frequencies     PARAMS ((struct loops *));
 static void counts_to_freqs             PARAMS ((void));
-static void process_note_predictions    PARAMS ((basic_block, int *, int *,
-                                                 sbitmap *));
-static void process_note_prediction     PARAMS ((basic_block, int *, int *,
-                                                 sbitmap *, int, int));
+static void process_note_predictions    PARAMS ((basic_block, int *,
+                                                 dominance_info,
+                                                 dominance_info));
+static void process_note_prediction     PARAMS ((basic_block, int *, 
+                                                 dominance_info,
+                                                 dominance_info, int, int));
 static bool last_basic_block_p           PARAMS ((basic_block));
 static void compute_function_frequency  PARAMS ((void));
 static void choose_function_section     PARAMS ((void));
@@ -408,14 +411,13 @@ void
 estimate_probability (loops_info)
      struct loops *loops_info;
 {
-  sbitmap *dominators, *post_dominators;
+  dominance_info dominators, post_dominators;
   basic_block bb;
   int i;
 
-  dominators = sbitmap_vector_alloc (last_basic_block, last_basic_block);
-  post_dominators = sbitmap_vector_alloc (last_basic_block, last_basic_block);
-  calculate_dominance_info (NULL, dominators, CDI_DOMINATORS);
-  calculate_dominance_info (NULL, post_dominators, CDI_POST_DOMINATORS);
+  connect_infinite_loops_to_exit ();
+  dominators = calculate_dominance_info (CDI_DOMINATORS);
+  post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
 
   /* Try to predict out blocks in a loop that are not part of a
      natural loop.  */
@@ -495,8 +497,8 @@ estimate_probability (loops_info)
          /* Look for block we are guarding (ie we dominate it,
             but it doesn't postdominate us).  */
          if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
-             && TEST_BIT (dominators[e->dest->index], e->src->index)
-             && !TEST_BIT (post_dominators[e->src->index], e->dest->index))
+             && dominated_by_p (dominators, e->dest, e->src)
+             && !dominated_by_p (post_dominators, e->src, e->dest))
            {
              rtx insn;
 
@@ -613,9 +615,10 @@ estimate_probability (loops_info)
        && bb->succ->succ_next != NULL)
       combine_predictions_for_insn (bb->end, bb);
 
-  sbitmap_vector_free (post_dominators);
-  sbitmap_vector_free (dominators);
+  free_dominance_info (post_dominators);
+  free_dominance_info (dominators);
 
+  remove_fake_edges ();
   estimate_bb_frequencies (loops_info);
 }
 \f
@@ -717,8 +720,8 @@ static void
 process_note_prediction (bb, heads, dominators, post_dominators, pred, flags)
      basic_block bb;
      int *heads;
-     int *dominators;
-     sbitmap *post_dominators;
+     dominance_info dominators;
+     dominance_info post_dominators;
      int pred;
      int flags;
 {
@@ -733,27 +736,30 @@ process_note_prediction (bb, heads, dominators, post_dominators, pred, flags)
       /* This is first time we need this field in heads array; so
          find first dominator that we do not post-dominate (we are
          using already known members of heads array).  */
-      int ai = bb->index;
-      int next_ai = dominators[bb->index];
+      basic_block ai = bb;
+      basic_block next_ai = get_immediate_dominator (dominators, bb);
       int head;
 
-      while (heads[next_ai] < 0)
+      while (heads[next_ai->index] < 0)
        {
-         if (!TEST_BIT (post_dominators[next_ai], bb->index))
+         if (!dominated_by_p (post_dominators, next_ai, bb))
            break;
-         heads[next_ai] = ai;
+         heads[next_ai->index] = ai->index;
          ai = next_ai;
-         next_ai = dominators[next_ai];
+         next_ai = get_immediate_dominator (dominators, next_ai);
        }
-      if (!TEST_BIT (post_dominators[next_ai], bb->index))
-       head = next_ai;
+      if (!dominated_by_p (post_dominators, next_ai, bb))
+       head = next_ai->index;
       else
-       head = heads[next_ai];
-      while (next_ai != bb->index)
+       head = heads[next_ai->index];
+      while (next_ai != bb)
        {
          next_ai = ai;
-         ai = heads[ai];
-         heads[next_ai] = head;
+         if (heads[ai->index] == ENTRY_BLOCK)
+           ai = ENTRY_BLOCK_PTR;
+         else
+           ai = BASIC_BLOCK (heads[ai->index]);
+         heads[next_ai->index] = head;
        }
     }
   y = heads[bb->index];
@@ -764,7 +770,7 @@ process_note_prediction (bb, heads, dominators, post_dominators, pred, flags)
     return;
   for (e = BASIC_BLOCK (y)->succ; e; e = e->succ_next)
     if (e->dest->index >= 0
-       && TEST_BIT (post_dominators[e->dest->index], bb->index))
+       && dominated_by_p (post_dominators, e->dest, bb))
       predict_edge_def (e, pred, taken);
 }
 
@@ -776,8 +782,8 @@ static void
 process_note_predictions (bb, heads, dominators, post_dominators)
      basic_block bb;
      int *heads;
-     int *dominators;
-     sbitmap *post_dominators;
+     dominance_info dominators;
+     dominance_info post_dominators;
 {
   rtx insn;
   edge e;
@@ -838,18 +844,15 @@ void
 note_prediction_to_br_prob ()
 {
   basic_block bb;
-  sbitmap *post_dominators;
-  int *dominators, *heads;
+  dominance_info post_dominators, dominators;
+  int *heads;
 
   /* To enable handling of noreturn blocks.  */
   add_noreturn_fake_exit_edges ();
   connect_infinite_loops_to_exit ();
 
-  dominators = xmalloc (sizeof (int) * last_basic_block);
-  memset (dominators, -1, sizeof (int) * last_basic_block);
-  post_dominators = sbitmap_vector_alloc (last_basic_block, last_basic_block);
-  calculate_dominance_info (NULL, post_dominators, CDI_POST_DOMINATORS);
-  calculate_dominance_info (dominators, NULL, CDI_DOMINATORS);
+  post_dominators = calculate_dominance_info (CDI_POST_DOMINATORS);
+  dominators = calculate_dominance_info (CDI_DOMINATORS);
 
   heads = xmalloc (sizeof (int) * last_basic_block);
   memset (heads, -1, sizeof (int) * last_basic_block);
@@ -860,8 +863,8 @@ note_prediction_to_br_prob ()
   FOR_EACH_BB (bb)
     process_note_predictions (bb, heads, dominators, post_dominators);
 
-  sbitmap_vector_free (post_dominators);
-  free (dominators);
+  free_dominance_info (post_dominators);
+  free_dominance_info (dominators);
   free (heads);
 
   remove_fake_edges ();