* rtl.h (insn_note): Remove NOTE_INSN_PREDICTION.

	* rtl.c (note_insn_name): Likewise.
	* print-rtl.c (print_rtx): Don't print it.
	* cfgrtl.h (can_delete_note_p): Don't handle it.
	(rtl_delete_block): Likewise.
	* passes.c (rest_of_handle_guess_branch_prob): Remove.
	(rest_of_compilation): Don't call it.
	* predict.c (process_note_predictions, process_note_prediction,
	note_prediction_to_br_prob): Remove.
	* basic-block.c (note_prediction_to_br_prob): Remove prototype.
	* stmt.c (return_prediction): Remove.
	(expand_value_return): Don't call it.  Don't add prediction
	notes for return statements.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@85016 138bc75d-0d04-0410-961f-82ee72b054a4

9 files changed, 20 insertions, 226 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 66415377ced..dcafdeca5d0 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,19 @@
+2004-07-21  Steven Bosscher  <stevenb@suse.de>
+
+	* rtl.h (insn_note): Remove NOTE_INSN_PREDICTION.
+	* rtl.c (note_insn_name): Likewise.
+	* print-rtl.c (print_rtx): Don't print it.
+	* cfgrtl.h (can_delete_note_p): Don't handle it.
+	(rtl_delete_block): Likewise.
+	* passes.c (rest_of_handle_guess_branch_prob): Remove.
+	(rest_of_compilation): Don't call it.
+	* predict.c (process_note_predictions, process_note_prediction,
+	note_prediction_to_br_prob): Remove.
+	* basic-block.c (note_prediction_to_br_prob): Remove prototype.
+	* stmt.c (return_prediction): Remove.
+	(expand_value_return): Don't call it.  Don't add prediction
+	notes for return statements.
+
 2004-07-21  Josef Zlomek  <zlomekj@suse.cz>
 
 	* var-tracking.c (vt_find_locations): Set the in_pending bitmap at
diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index e29b67aa9b9..c7d2c072146 100644
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -595,7 +595,6 @@ extern rtx emit_block_insn_before (rtx, rtx, basic_block);
 
 /* In predict.c */
 extern void estimate_probability (struct loops *);
-extern void note_prediction_to_br_prob (void);
 extern void expected_value_to_br_prob (void);
 extern bool maybe_hot_bb_p (basic_block);
 extern bool probably_cold_bb_p (basic_block);
diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index 8d17d06642a..5a280af4bf8 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -93,8 +93,7 @@ can_delete_note_p (rtx note)
 {
   return (NOTE_LINE_NUMBER (note) == NOTE_INSN_DELETED
 	  || NOTE_LINE_NUMBER (note) == NOTE_INSN_BASIC_BLOCK
-	  || NOTE_LINE_NUMBER (note) == NOTE_INSN_UNLIKELY_EXECUTED_CODE
-	  || NOTE_LINE_NUMBER (note) == NOTE_INSN_PREDICTION);
+	  || NOTE_LINE_NUMBER (note) == NOTE_INSN_UNLIKELY_EXECUTED_CODE);
 }
 
 /* True if a given label can be deleted.  */
@@ -376,15 +375,13 @@ rtl_delete_block (basic_block b)
      and remove the associated NOTE_INSN_EH_REGION_BEG and
      NOTE_INSN_EH_REGION_END notes.  */
 
-  /* Get rid of all NOTE_INSN_PREDICTIONs and NOTE_INSN_LOOP_CONTs
-     hanging before the block.  */
+  /* Get rid of all NOTE_INSN_LOOP_CONTs hanging before the block.  */
 
   for (insn = PREV_INSN (BB_HEAD (b)); insn; insn = PREV_INSN (insn))
     {
       if (!NOTE_P (insn))
 	break;
-      if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION
-	  || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT)
+      if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_CONT)
 	NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
     }
 
diff --git a/gcc/passes.c b/gcc/passes.c
index 108d18583ad..b124b3eafcd 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -1473,18 +1473,6 @@ rest_of_handle_jump (void)
 }
 
 static void
-rest_of_handle_guess_branch_prob (void)
-{
-  /* Turn NOTE_INSN_PREDICTIONs into branch predictions.  */
-  if (flag_guess_branch_prob)
-    {
-      timevar_push (TV_BRANCH_PROB);
-      note_prediction_to_br_prob ();
-      timevar_pop (TV_BRANCH_PROB);
-    }
-}
-
-static void
 rest_of_handle_eh (void)
 {
   insn_locators_initialize ();
@@ -1791,7 +1779,6 @@ rest_of_compilation (void)
     goto exit_rest_of_compilation;
 
   rest_of_handle_jump ();
-  rest_of_handle_guess_branch_prob ();
 
   if (cfun->tail_call_emit)
     fixup_tail_calls ();
diff --git a/gcc/predict.c b/gcc/predict.c
index 49d2c612063..c92b27f8bdf 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -76,8 +76,6 @@ static void estimate_loops_at_level (struct loop *loop);
 static void propagate_freq (struct loop *);
 static void estimate_bb_frequencies (struct loops *);
 static int counts_to_freqs (void);
-static void process_note_predictions (basic_block, int *);
-static void process_note_prediction (basic_block, int *, int, int);
 static bool last_basic_block_p (basic_block);
 static void compute_function_frequency (void);
 static void choose_function_section (void);
@@ -1078,150 +1076,6 @@ last_basic_block_p (basic_block bb)
 	      && bb->succ && !bb->succ->succ_next
 	      && bb->succ->dest->next_bb == EXIT_BLOCK_PTR));
 }
-
-/* Sets branch probabilities according to PREDiction and
-   FLAGS. HEADS[bb->index] should be index of basic block in that we
-   need to alter branch predictions (i.e. the first of our dominators
-   such that we do not post-dominate it) (but we fill this information
-   on demand, so -1 may be there in case this was not needed yet).  */
-
-static void
-process_note_prediction (basic_block bb, int *heads, int pred, int flags)
-{
-  edge e;
-  int y;
-  bool taken;
-
-  taken = flags & IS_TAKEN;
-
-  if (heads[bb->index] < 0)
-    {
-      /* 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).  */
-      basic_block ai = bb;
-      basic_block next_ai = get_immediate_dominator (CDI_DOMINATORS, bb);
-      int head;
-
-      while (heads[next_ai->index] < 0)
-	{
-	  if (!dominated_by_p (CDI_POST_DOMINATORS, next_ai, bb))
-	    break;
-	  heads[next_ai->index] = ai->index;
-	  ai = next_ai;
-	  next_ai = get_immediate_dominator (CDI_DOMINATORS, next_ai);
-	}
-      if (!dominated_by_p (CDI_POST_DOMINATORS, next_ai, bb))
-	head = next_ai->index;
-      else
-	head = heads[next_ai->index];
-      while (next_ai != bb)
-	{
-	  next_ai = ai;
-	  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];
-
-  /* Now find the edge that leads to our branch and aply the prediction.  */
-
-  if (y == last_basic_block || !can_predict_insn_p (BB_END (BASIC_BLOCK (y))))
-    return;
-  for (e = BASIC_BLOCK (y)->succ; e; e = e->succ_next)
-    if (e->dest->index >= 0
-	&& dominated_by_p (CDI_POST_DOMINATORS, e->dest, bb))
-      predict_edge_def (e, pred, taken);
-}
-
-/* Gathers NOTE_INSN_PREDICTIONs in given basic block and turns them
-   into branch probabilities.  For description of heads array, see
-   process_note_prediction.  */
-
-static void
-process_note_predictions (basic_block bb, int *heads)
-{
-  rtx insn;
-  edge e;
-
-  /* Additionally, we check here for blocks with no successors.  */
-  int contained_noreturn_call = 0;
-  int was_bb_head = 0;
-  int noreturn_block = 1;
-
-  for (insn = BB_END (bb); insn;
-       was_bb_head |= (insn == BB_HEAD (bb)), insn = PREV_INSN (insn))
-    {
-      if (!NOTE_P (insn))
-	{
-	  if (was_bb_head)
-	    break;
-	  else
-	    {
-	      /* Noreturn calls cause program to exit, therefore they are
-	         always predicted as not taken.  */
-	      if (CALL_P (insn)
-		  && find_reg_note (insn, REG_NORETURN, NULL))
-		contained_noreturn_call = 1;
-	      continue;
-	    }
-	}
-      if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PREDICTION)
-	{
-	  int alg = (int) NOTE_PREDICTION_ALG (insn);
-	  /* Process single prediction note.  */
-	  process_note_prediction (bb,
-				   heads,
-				   alg, (int) NOTE_PREDICTION_FLAGS (insn));
-	  delete_insn (insn);
-	}
-    }
-  for (e = bb->succ; e; e = e->succ_next)
-    if (!(e->flags & EDGE_FAKE))
-      noreturn_block = 0;
-  if (contained_noreturn_call)
-    {
-      /* This block ended from other reasons than because of return.
-         If it is because of noreturn call, this should certainly not
-         be taken.  Otherwise it is probably some error recovery.  */
-      process_note_prediction (bb, heads, PRED_NORETURN, NOT_TAKEN);
-    }
-}
-
-/* Gathers NOTE_INSN_PREDICTIONs and turns them into
-   branch probabilities.  */
-
-void
-note_prediction_to_br_prob (void)
-{
-  basic_block bb;
-  int *heads;
-
-  /* To enable handling of noreturn blocks.  */
-  add_noreturn_fake_exit_edges ();
-  connect_infinite_loops_to_exit ();
-
-  calculate_dominance_info (CDI_POST_DOMINATORS);
-  calculate_dominance_info (CDI_DOMINATORS);
-
-  heads = xmalloc (sizeof (int) * last_basic_block);
-  memset (heads, -1, sizeof (int) * last_basic_block);
-  heads[ENTRY_BLOCK_PTR->next_bb->index] = last_basic_block;
-
-  /* Process all prediction notes.  */
-
-  FOR_EACH_BB (bb)
-    process_note_predictions (bb, heads);
-
-  free_dominance_info (CDI_POST_DOMINATORS);
-  free_dominance_info (CDI_DOMINATORS);
-  free (heads);
-
-  remove_fake_exit_edges ();
-}
 
 /* This is used to carry information about basic blocks.  It is
    attached to the AUX field of the standard CFG block.  */
diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c
index e2febfa48cc..8b211f076ac 100644
--- a/gcc/print-rtl.c
+++ b/gcc/print-rtl.c
@@ -281,15 +281,6 @@ print_rtx (rtx in_rtx)
 		}
 		break;
 
-	      case NOTE_INSN_PREDICTION:
-		if (NOTE_PREDICTION (in_rtx))
-		  fprintf (outfile, " [ %d %d ] ",
-			   (int)NOTE_PREDICTION_ALG (in_rtx),
-			   (int) NOTE_PREDICTION_FLAGS (in_rtx));
-		else
-		  fprintf (outfile, " [ ERROR ]");
-		break;
-
 	      case NOTE_INSN_UNLIKELY_EXECUTED_CODE:
 		{
 		  basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
diff --git a/gcc/rtl.c b/gcc/rtl.c
index 2c08256478a..3c03ae2924b 100644
--- a/gcc/rtl.c
+++ b/gcc/rtl.c
@@ -122,7 +122,6 @@ const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
   "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
   "NOTE_INSN_REPEATED_LINE_NUMBER",
   "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE",
-  "NOTE_INSN_PREDICTION",
   "NOTE_INSN_UNLIKELY_EXECUTED_CODE",
   "NOTE_INSN_VAR_LOCATION"
 };
diff --git a/gcc/rtl.h b/gcc/rtl.h
index 2a8da5b4971..3fd8bafecba 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -1029,9 +1029,6 @@ enum insn_note
      NOTE_EXPECTED_VALUE; stored as (eq (reg) (const_int)).  */
   NOTE_INSN_EXPECTED_VALUE,
 
-  /* Record a prediction.  Uses NOTE_PREDICTION.  */
-  NOTE_INSN_PREDICTION,
-
   /* Record that the current basic block is unlikely to be executed and
      should be moved to the UNLIKELY_EXECUTED_TEXT_SECTION.  */
   NOTE_INSN_UNLIKELY_EXECUTED_CODE,
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 6d3043b3869..b2ffef690ca 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -264,7 +264,6 @@ static bool check_operand_nalternatives (tree, tree);
 static bool check_unique_operand_names (tree, tree);
 static char *resolve_operand_name_1 (char *, tree, tree);
 static void expand_null_return_1 (void);
-static enum br_predictor return_prediction (rtx);
 static rtx shift_return_value (rtx);
 static void expand_value_return (rtx);
 static void do_jump_if_equal (rtx, rtx, rtx, int);
@@ -1811,35 +1810,6 @@ expand_naked_return (void)
   emit_jump (end_label);
 }
 
-/* Try to guess whether the value of return means error code.  */
-static enum br_predictor
-return_prediction (rtx val)
-{
-  /* Different heuristics for pointers and scalars.  */
-  if (POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl))))
-    {
-      /* NULL is usually not returned.  */
-      if (val == const0_rtx)
-	return PRED_NULL_RETURN;
-    }
-  else
-    {
-      /* Negative return values are often used to indicate
-         errors.  */
-      if (GET_CODE (val) == CONST_INT
-	  && INTVAL (val) < 0)
-	return PRED_NEGATIVE_RETURN;
-      /* Constant return values are also usually erors,
-         zero/one often mean booleans so exclude them from the
-	 heuristics.  */
-      if (CONSTANT_P (val)
-	  && (val != const0_rtx && val != const1_rtx))
-	return PRED_CONST_RETURN;
-    }
-  return PRED_NO_PREDICTION;
-}
-
-
 /* If the current function returns values in the most significant part
    of a register, shift return value VAL appropriately.  The mode of
    the function's return type is known not to be BLKmode.  */
@@ -1872,26 +1842,10 @@ shift_return_value (rtx val)
 static void
 expand_value_return (rtx val)
 {
-  rtx return_reg;
-  enum br_predictor pred;
-
-  if (flag_guess_branch_prob
-      && (pred = return_prediction (val)) != PRED_NO_PREDICTION)
-    {
-      /* Emit information for branch prediction.  */
-      rtx note;
-
-      note = emit_note (NOTE_INSN_PREDICTION);
-
-      NOTE_PREDICTION (note) = NOTE_PREDICT (pred, NOT_TAKEN);
-
-    }
-
-  return_reg = DECL_RTL (DECL_RESULT (current_function_decl));
-
   /* Copy the value to the return location
      unless it's already there.  */
 
+  rtx return_reg = DECL_RTL (DECL_RESULT (current_function_decl));
   if (return_reg != val)
     {
       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));