tree-pretty-print.c: Include predict.h.

	* tree-pretty-print.c: Include predict.h.
	(dump_generic_node): Dump predictor.
	* tree.h (PREDICT_EXPR_OUTCOME, PREDICT_EXPR_PREDICTION): Update.
	* tree-gimple.c (is_gimple_stmt): Add PREDICT_EXPR.
	* gimple-low.c (lower_stmt): Likewise.
	* expr.c (expand_expr_real): Likewise.
	* predict.c (tree_bb_level_predictions): Use PREDICT_EXPRs and remove
	them.
	(build_predict_expr, build_predict_expr): New.
	* predict.h (predictor_name, build_predict_expr): Update.
	* c-typeck.c (c_finish_bc_stmt): Add prediction.
	* gimplify.c (gimplify_expr): Add PREDICT_EXPR.
	* predict.def (PRED_CONTINUE): Update hitrate.
	* tree.def (PREDICT_EXPR): Define.
	* tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Mark PREDICT_EXPR;
	do not handle BIND_EXPR.
	* tree-inline.c (estimate_num_insns_1): PREDICT_EXPR is free.
	* tree-cfg.c (verify_gimple_stmt): PREDICT_EXPR is valid.
	* tree-ssa-operands.c (get_expr_operands): PREDICT_EXPR takes no
	operands.

From-SVN: r133313

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 615cf5735cdc31c113a0fa4618ab9ee6ccdd7102..823742584112a4b0c0f79b78240fe4f36cc4dadf 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,26 @@
+2008-03-18  Jan Hubicka  <jh@suse.cz>
+
+       * tree-pretty-print.c: Include predict.h.
+       (dump_generic_node): Dump predictor.
+       * tree.h (PREDICT_EXPR_OUTCOME, PREDICT_EXPR_PREDICTION): Update.
+       * tree-gimple.c (is_gimple_stmt): Add PREDICT_EXPR.
+       * gimple-low.c (lower_stmt): Likewise.
+       * expr.c (expand_expr_real): Likewise.
+       * predict.c (tree_bb_level_predictions): Use PREDICT_EXPRs and remove
+       them.
+       (build_predict_expr, build_predict_expr): New.
+       * predict.h (predictor_name, build_predict_expr): Update.
+       * c-typeck.c (c_finish_bc_stmt): Add prediction.
+       * gimplify.c (gimplify_expr): Add PREDICT_EXPR.
+       * predict.def (PRED_CONTINUE): Update hitrate.
+       * tree.def (PREDICT_EXPR): Define.
+       * tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Mark PREDICT_EXPR;
+       do not handle BIND_EXPR.
+       * tree-inline.c (estimate_num_insns_1): PREDICT_EXPR is free.
+       * tree-cfg.c (verify_gimple_stmt): PREDICT_EXPR is valid.
+       * tree-ssa-operands.c (get_expr_operands): PREDICT_EXPR takes no
+       operands.
+
 2008-03-18  Michael Matz  <matz@suse.de>
 
        * gcov-io.h (__gcov_merge_ior, __gcov_fork): Mark hidden.
@@ -21,6 +44,29 @@
        * gimplify.c (gimplify_expr): Gimplify second operand of
        OMP_ATOMIC_LOAD.
 
+2008-03-17  Richard Guenther  <rguenther@suse.de>
+
+       * tree-pretty-print.c: Include predict.h.
+       (dump_generic_node): Dump predictor.
+       * tree.h (PREDICT_EXPR_OUTCOME, PREDICT_EXPR_PREDICTION): Update.
+       * tree-gimple.c (is_gimple_stmt): Add PREDICT_EXPR.
+       * gimple-low.c (lower_stmt): Likewise.
+       * expr.c (expand_expr_real): Likewise.
+       * predict.c (tree_bb_level_predictions): Use PREDICT_EXPRs and remove
+       them.
+       (build_predict_expr, build_predict_expr): New.
+       * predict.h (predictor_name, build_predict_expr): Update.
+       * c-typeck.c (c_finish_bc_stmt): Add prediction.
+       * gimplify.c (gimplify_expr): Add PREDICT_EXPR.
+       * predict.def (PRED_CONTINUE): Update hitrate.
+       * tree.def (PREDICT_EXPR): Define.
+       * tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Mark PREDICT_EXPR;
+       do not handle BIND_EXPR.
+       * tree-inline.c (estimate_num_insns_1): PREDICT_EXPR is free.
+       * tree-cfg.c (verify_gimple_stmt): PREDICT_EXPR is valid.
+       * tree-ssa-operands.c (get_expr_operands): PREDICT_EXPR takes no
+       operands.
+
 2008-03-17  Richard Guenther  <rguenther@suse.de>
 
        PR tree-optimization/19637

diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 94d4eea8dc32d3232e5629847688ea36dbbf7210..4d476c5d4dd5f7397e46ecb67d04f45aa8218aed 100644 (file)
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -7503,6 +7503,9 @@ c_finish_bc_stmt (tree *label_p, bool is_break)
   if (skip)
     return NULL_TREE;
 
+  if (!is_break)
+    add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
+
   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
 }
 

diff --git a/gcc/expr.c b/gcc/expr.c
index 3294f1a23e02bf29122880ad67480e2117c14f71..83e8e442a8a0977144e7b2a08728b1dfb18e84f1 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -7055,6 +7055,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
 
   /* Handle ERROR_MARK before anybody tries to access its type.  */
   if (TREE_CODE (exp) == ERROR_MARK
+      || TREE_CODE (exp) == PREDICT_EXPR
       || (!GIMPLE_TUPLE_P (exp) && TREE_CODE (TREE_TYPE (exp)) == ERROR_MARK))
     {
       ret = CONST0_RTX (tmode);

diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c
index a860dd1caf10770a6affc4b4d0724fc82ef41cd5..7330464ebf1422fa02aaedb2654405d19e65012d 100644 (file)
--- a/gcc/gimple-low.c
+++ b/gcc/gimple-low.c
@@ -235,6 +235,7 @@ lower_stmt (tree_stmt_iterator *tsi, struct lower_data *data)
     case NOP_EXPR:
     case ASM_EXPR:
     case GOTO_EXPR:
+    case PREDICT_EXPR:
     case LABEL_EXPR:
     case SWITCH_EXPR:
     case CHANGE_DYNAMIC_TYPE_EXPR:

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 102ce3e7354cb34e3d1516d52d00528dbd3c5d0c..acdfb994960f5f7aa8d05b8361701a614e57cf4f 100644 (file)
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -5837,6 +5837,10 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
                                 NULL, is_gimple_val, fb_rvalue);
          break;
 
+         /* Predictions are always gimplified.  */
+       case PREDICT_EXPR:
+         goto out;
+
        case LABEL_EXPR:
          ret = GS_ALL_DONE;
          gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))

diff --git a/gcc/predict.c b/gcc/predict.c
index cedb3d548184f3435618984db7e519569005dcd1..a20b3526ce385c46fd680ac6621e2649988e70fd 100644 (file)
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -1293,10 +1293,11 @@ tree_bb_level_predictions (void)
     {
       block_stmt_iterator bsi = bsi_last (bb);
 
-      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+      for (bsi = bsi_start (bb); !bsi_end_p (bsi);)
        {
          tree stmt = bsi_stmt (bsi);
          tree decl;
+         bool next = false;
 
          switch (TREE_CODE (stmt))
            {
@@ -1319,9 +1320,17 @@ call_expr:;
                  predict_paths_leading_to (bb, PRED_COLD_FUNCTION,
                                            NOT_TAKEN);
                break;
+             case PREDICT_EXPR:
+               predict_paths_leading_to (bb, PREDICT_EXPR_PREDICTOR (stmt),
+                                         PREDICT_EXPR_OUTCOME (stmt));
+               bsi_remove (&bsi, true);
+               next = true;
+               break;
              default:
                break;
            }
+         if (!next)
+           bsi_next (&bsi);
        }
     }
 }
@@ -1915,6 +1924,21 @@ gate_estimate_probability (void)
   return flag_guess_branch_prob;
 }
 
+/* Build PREDICT_EXPR.  */
+tree
+build_predict_expr (enum br_predictor predictor, enum prediction taken)
+{
+  tree t = build1 (PREDICT_EXPR, NULL_TREE, build_int_cst (NULL, predictor));
+  PREDICT_EXPR_OUTCOME (t) = taken;
+  return t;
+}
+
+const char *
+predictor_name (enum br_predictor predictor)
+{
+  return predictor_info[predictor].name;
+}
+
 struct tree_opt_pass pass_profile = 
 {
   "profile",                           /* name */

diff --git a/gcc/predict.def b/gcc/predict.def
index a858c016aa7df5bc4d50929ceb0af8dbdf3f8a7d..62ae9d9f8d3dee4dc1ae14d442f9baaf1059327e 100644 (file)
--- a/gcc/predict.def
+++ b/gcc/predict.def
@@ -66,7 +66,7 @@ DEF_PREDICTOR (PRED_LOOP_ITERATIONS_GUESSED, "guessed loop iterations",
               PROB_ALWAYS, PRED_FLAG_FIRST_MATCH)
 
 /* Branch containing goto is probably not taken.  */
-DEF_PREDICTOR (PRED_CONTINUE, "continue", HITRATE (56), 0)
+DEF_PREDICTOR (PRED_CONTINUE, "continue", HITRATE (50), 0)
 
 /* Branch to basic block containing call marked by noreturn attribute.  */
 DEF_PREDICTOR (PRED_NORETURN, "noreturn call", HITRATE (99),

diff --git a/gcc/predict.h b/gcc/predict.h
index 6c48c3e1d423c9fc1561f2e5c7ac2db866c9a158..6552c7293fdc00878745e02c35c12bcf55379f9e 100644 (file)
--- a/gcc/predict.h
+++ b/gcc/predict.h
@@ -38,5 +38,7 @@ enum prediction
 extern void predict_insn_def (rtx, enum br_predictor, enum prediction);
 extern int counts_to_freqs (void);
 extern void estimate_bb_frequencies (void);
+extern const char *predictor_name (enum br_predictor);
+extern tree build_predict_expr (enum br_predictor, enum prediction);
 
 #endif  /* GCC_PREDICT_H */

diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 5e551aa4517f3943a8f168db62832bdecba6982d..329566411b05003c645571d699e06d718a599401 100644 (file)
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -4059,6 +4059,7 @@ verify_gimple_stmt (tree stmt)
     case NOP_EXPR:
     case CHANGE_DYNAMIC_TYPE_EXPR:
     case ASM_EXPR:
+    case PREDICT_EXPR:
       return false;
 
     default:

diff --git a/gcc/tree-gimple.c b/gcc/tree-gimple.c
index 93e99e6cbed1dc11cfe588209f1a09e93d83d4bb..bc482983847d2fccd7dd8429a8f4a247264db6e4 100644 (file)
--- a/gcc/tree-gimple.c
+++ b/gcc/tree-gimple.c
@@ -325,6 +325,7 @@ is_gimple_stmt (tree t)
 
     case CALL_EXPR:
     case GIMPLE_MODIFY_STMT:
+    case PREDICT_EXPR:
       /* These are valid regardless of their type.  */
       return true;
 

diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 74895a82c9363a9c6904fafa398807891ca74872..54cacb5a79b892705cf31da56d537505ec11ab02 100644 (file)
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -2265,6 +2265,7 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
     case COMPLEX_CST:
     case VECTOR_CST:
     case STRING_CST:
+    case PREDICT_EXPR:
       *walk_subtrees = 0;
       return NULL;
 

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index b64571dbae2665ec2933750eefe7d7aab51bd21a..8b5f847e476ae4aa3da08e9473aeb65a1d58f2df 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -35,6 +35,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-pass.h"
 #include "fixed-value.h"
 #include "value-prof.h"
+#include "predict.h"
 
 /* Local functions, macros and variables.  */
 static int op_prio (const_tree);
@@ -1592,6 +1593,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       is_expr = false;
       break;
 
+    case PREDICT_EXPR:
+      pp_string (buffer, "// predicted ");
+      if (PREDICT_EXPR_OUTCOME (node))
+        pp_string (buffer, "likely by ");
+      else
+        pp_string (buffer, "unlikely by ");
+      pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
+      pp_string (buffer, " predictor.");
+      break;
+
     case RETURN_EXPR:
       pp_string (buffer, "return");
       op0 = TREE_OPERAND (node, 0);

diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index bc1700338d85329850e4c6b97a9c57435d3ecd1c..640c1f38f5c44dd6b5da113c5f5569d47db3cc3d 100644 (file)
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -277,7 +277,7 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
      can then remove the block and labels.  */
   switch (TREE_CODE (stmt))
     {
-    case BIND_EXPR:
+    case PREDICT_EXPR:
     case LABEL_EXPR:
     case CASE_LABEL_EXPR:
       mark_stmt_necessary (stmt, false);

diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index ceb18ba55a63391d67974281307d8b9f3a733714..8869e6ed95a64db2a5884435e08c8819c04491ca 100644 (file)
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -2376,6 +2376,7 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
     case OMP_RETURN:
     case OMP_SECTION:
     case OMP_SECTIONS_SWITCH:
+    case PREDICT_EXPR:
       /* Expressions that make no memory references.  */
       return;
 

diff --git a/gcc/tree.def b/gcc/tree.def
index 4a55ee0aaf9c0409bbcd8e9b0d3bf6ecd7bd1ca9..89c18dfd16cab36446cf6308543df8bd5ae54d4d 100644 (file)
--- a/gcc/tree.def
+++ b/gcc/tree.def
@@ -1170,6 +1170,12 @@ DEFTREECODE (VEC_EXTRACT_ODD_EXPR, "vec_extractodd_expr", tcc_binary, 2)
 DEFTREECODE (VEC_INTERLEAVE_HIGH_EXPR, "vec_interleavehigh_expr", tcc_binary, 2)
 DEFTREECODE (VEC_INTERLEAVE_LOW_EXPR, "vec_interleavelow_expr", tcc_binary, 2)
 
+/* PREDICT_EXPR.  Specify hint for branch prediction.  The
+   PREDICT_EXPR_PREDICTOR specify predictor and PREDICT_EXPR_OUTCOME the
+   outcome (0 for not taken and 1 for taken).  Once the profile is guessed
+   all conditional branches leading to execution paths executing the
+   PREDICT_EXPR will get predicted by the specified predictor.  */
+DEFTREECODE (PREDICT_EXPR, "predict_expr", tcc_unary, 1)
 /*
 Local variables:
 mode:c

diff --git a/gcc/tree.h b/gcc/tree.h
index de6654de80f722c0c6eca3ae373536e3115263a4..0cb2fadca75e8fb4936849529bfd17e46ed466e8 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -436,6 +436,7 @@ struct gimple_stmt GTY(())
           expression.
        CALL_EXPR_TAILCALL in CALL_EXPR
        CASE_LOW_SEEN in CASE_LABEL_EXPR
+       RETURN_EXPR_OUTCOME in RETURN_EXPR
 
    static_flag:
 
@@ -1158,6 +1159,11 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
 #define CASE_LOW_SEEN(NODE) \
   (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
 
+#define PREDICT_EXPR_OUTCOME(NODE) \
+  (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag)
+#define PREDICT_EXPR_PREDICTOR(NODE) \
+  ((enum br_predictor)tree_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 0))
+
 /* In a VAR_DECL, nonzero means allocate static storage.
    In a FUNCTION_DECL, nonzero if function has been defined.
    In a CONSTRUCTOR, nonzero means allocate static storage.