re PR target/65697 (__atomic memory barriers not strong enough for __sync builtins)

[gcc.git] / gcc / predict.c

diff --git a/gcc/predict.c b/gcc/predict.c
index 779af115b2ab1553dcf87bd1cb7647b05431a293..9a69c6f4e39a7017320cfe4cae4e36b95bf0c77a 100644 (file)
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -1,5 +1,5 @@
 /* Branch prediction routines for the GNU compiler.
-   Copyright (C) 2000-2014 Free Software Foundation, Inc.
+   Copyright (C) 2000-2015 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -31,17 +31,15 @@ along with GCC; see the file COPYING3.  If not see
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
+#include "alias.h"
+#include "symtab.h"
 #include "tree.h"
+#include "fold-const.h"
 #include "calls.h"
 #include "rtl.h"
 #include "tm_p.h"
 #include "hard-reg-set.h"
 #include "predict.h"
-#include "vec.h"
-#include "hashtab.h"
-#include "hash-set.h"
-#include "machmode.h"
-#include "input.h"
 #include "function.h"
 #include "dominance.h"
 #include "cfg.h"
@@ -54,22 +52,24 @@ along with GCC; see the file COPYING3.  If not see
 #include "except.h"
 #include "diagnostic-core.h"
 #include "recog.h"
+#include "expmed.h"
+#include "dojump.h"
+#include "explow.h"
+#include "emit-rtl.h"
+#include "varasm.h"
+#include "stmt.h"
 #include "expr.h"
 #include "coverage.h"
 #include "sreal.h"
 #include "params.h"
 #include "target.h"
 #include "cfgloop.h"
-#include "hash-map.h"
 #include "tree-ssa-alias.h"
 #include "internal-fn.h"
 #include "gimple-expr.h"
-#include "is-a.h"
 #include "gimple.h"
 #include "gimple-iterator.h"
 #include "gimple-ssa.h"
-#include "plugin-api.h"
-#include "ipa-ref.h"
 #include "cgraph.h"
 #include "tree-cfg.h"
 #include "tree-phinodes.h"
@@ -78,11 +78,10 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-ssa-loop.h"
 #include "tree-pass.h"
 #include "tree-scalar-evolution.h"
-#include "cfgloop.h"
 
 /* real constants: 0, 1, 1-1/REG_BR_PROB_BASE, REG_BR_PROB_BASE,
                   1/REG_BR_PROB_BASE, 0.5, BB_FREQ_MAX.  */
-static sreal real_zero, real_one, real_almost_one, real_br_prob_base,
+static sreal real_almost_one, real_br_prob_base,
             real_inv_br_prob_base, real_one_half, real_bb_freq_max;
 
 static void combine_predictions_for_insn (rtx_insn *, basic_block);
@@ -700,10 +699,10 @@ dump_prediction (FILE *file, enum br_predictor predictor, int probability,
 
   if (bb->count)
     {
-      fprintf (file, "  exec %"PRId64, bb->count);
+      fprintf (file, "  exec %" PRId64, bb->count);
       if (e)
        {
-         fprintf (file, " hit %"PRId64, e->count);
+         fprintf (file, " hit %" PRId64, e->count);
          fprintf (file, " (%.1f%%)", e->count * 100.0 / bb->count);
        }
     }
@@ -2541,13 +2540,13 @@ propagate_freq (basic_block head, bitmap tovisit)
        bb->count = bb->frequency = 0;
     }
 
-  BLOCK_INFO (head)->frequency = real_one;
+  BLOCK_INFO (head)->frequency = 1;
   last = head;
   for (bb = head; bb; bb = nextbb)
     {
       edge_iterator ei;
-      sreal cyclic_probability = real_zero;
-      sreal frequency = real_zero;
+      sreal cyclic_probability = 0;
+      sreal frequency = 0;
 
       nextbb = BLOCK_INFO (bb)->next;
       BLOCK_INFO (bb)->next = NULL;
@@ -2572,13 +2571,13 @@ propagate_freq (basic_block head, bitmap tovisit)
                                  * BLOCK_INFO (e->src)->frequency /
                                  REG_BR_PROB_BASE);  */
 
-               sreal tmp (e->probability, 0);
+               sreal tmp = e->probability;
                tmp *= BLOCK_INFO (e->src)->frequency;
                tmp *= real_inv_br_prob_base;
                frequency += tmp;
              }
 
-         if (cyclic_probability == real_zero)
+         if (cyclic_probability == 0)
            {
              BLOCK_INFO (bb)->frequency = frequency;
            }
@@ -2590,7 +2589,7 @@ propagate_freq (basic_block head, bitmap tovisit)
              /* BLOCK_INFO (bb)->frequency = frequency
                                              / (1 - cyclic_probability) */
 
-             cyclic_probability = real_one - cyclic_probability;
+             cyclic_probability = sreal (1) - cyclic_probability;
              BLOCK_INFO (bb)->frequency = frequency / cyclic_probability;
            }
        }
@@ -2604,7 +2603,7 @@ propagate_freq (basic_block head, bitmap tovisit)
             = ((e->probability * BLOCK_INFO (bb)->frequency)
             / REG_BR_PROB_BASE); */
 
-         sreal tmp (e->probability, 0);
+         sreal tmp = e->probability;
          tmp *= BLOCK_INFO (bb)->frequency;
          EDGE_INFO (e)->back_edge_prob = tmp * real_inv_br_prob_base;
        }
@@ -2886,13 +2885,11 @@ estimate_bb_frequencies (bool force)
       if (!real_values_initialized)
         {
          real_values_initialized = 1;
-         real_zero = sreal (0, 0);
-         real_one = sreal (1, 0);
-         real_br_prob_base = sreal (REG_BR_PROB_BASE, 0);
-         real_bb_freq_max = sreal (BB_FREQ_MAX, 0);
+         real_br_prob_base = REG_BR_PROB_BASE;
+         real_bb_freq_max = BB_FREQ_MAX;
          real_one_half = sreal (1, -1);
-         real_inv_br_prob_base = real_one / real_br_prob_base;
-         real_almost_one = real_one - real_inv_br_prob_base;
+         real_inv_br_prob_base = sreal (1) / real_br_prob_base;
+         real_almost_one = sreal (1) - real_inv_br_prob_base;
        }
 
       mark_dfs_back_edges ();
@@ -2910,7 +2907,7 @@ estimate_bb_frequencies (bool force)
 
          FOR_EACH_EDGE (e, ei, bb->succs)
            {
-             EDGE_INFO (e)->back_edge_prob = sreal (e->probability, 0);
+             EDGE_INFO (e)->back_edge_prob = e->probability;
              EDGE_INFO (e)->back_edge_prob *= real_inv_br_prob_base;
            }
        }
@@ -2919,7 +2916,7 @@ estimate_bb_frequencies (bool force)
          to outermost to examine frequencies for back edges.  */
       estimate_loops ();
 
-      freq_max = real_zero;
+      freq_max = 0;
       FOR_EACH_BB_FN (bb, cfun)
        if (freq_max < BLOCK_INFO (bb)->frequency)
          freq_max = BLOCK_INFO (bb)->frequency;
@@ -3038,6 +3035,9 @@ pass_profile::execute (function *fun)
 {
   unsigned nb_loops;
 
+  if (profile_status_for_fn (cfun) == PROFILE_GUESSED)
+    return 0;
+
   loop_optimizer_init (LOOPS_NORMAL);
   if (dump_file && (dump_flags & TDF_DETAILS))
     flow_loops_dump (dump_file, NULL, 0);