Hot/cold attributes for labels.

gcc/
        * doc/extend.texi (attribute): Document hot/cold for labels.
        * predict.c (tree_estimate_probability_bb): Handle hot/cold
        attributes on user labels.
        * predict.def (PRED_HOT_LABEL, PRED_COLD_LABEL): New.
gcc/c-family/
        * c-common.c (handle_hot_attribute): Allow labels.
        (handle_cold_attribute): Likewise.
gcc/testsuite/
        * gcc.dg/attr-hotcold-1.c: New.
        * gcc.dg/tree-ssa/attr-hotcold-2.c: New.

From-SVN: r189898

gcc/ChangeLog

@@ -1,3 +1,10 @@
+2012-07-26  Richard Henderson  <rth@redhat.com>
+
+	* doc/extend.texi (attribute): Document hot/cold for labels.
+	* predict.c (tree_estimate_probability_bb): Handle hot/cold
+	attributes on user labels.
+	* predict.def (PRED_HOT_LABEL, PRED_COLD_LABEL): New.
+
 2012-07-26  Andrew Jenner  <andrew@codesourcery.com>
 	    Sandra Loosemore  <sandra@codesourcery.com>
 

gcc/c-family/ChangeLog

@@ -1,3 +1,8 @@
+2012-07-26  Richard Henderson  <rth@redhat.com>
+
+	* c-common.c (handle_hot_attribute): Allow labels.
+	(handle_cold_attribute): Likewise.
+
 2012-07-20  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c++/28656

gcc/c-family/c-common.c

@@ -6169,7 +6169,8 @@ static tree
 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
 		      int ARG_UNUSED (flags), bool *no_add_attrs)
 {
-  if (TREE_CODE (*node) == FUNCTION_DECL)
+  if (TREE_CODE (*node) == FUNCTION_DECL
+      || TREE_CODE (*node) == LABEL_DECL)
     {
       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
 	{
@@ -6188,6 +6189,7 @@ handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
 
   return NULL_TREE;
 }
+
 /* Handle a "cold" and attribute; arguments as in
    struct attribute_spec.handler.  */
 
@@ -6195,7 +6197,8 @@ static tree
 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
 		       int ARG_UNUSED (flags), bool *no_add_attrs)
 {
-  if (TREE_CODE (*node) == FUNCTION_DECL)
+  if (TREE_CODE (*node) == FUNCTION_DECL
+      || TREE_CODE (*node) == LABEL_DECL)
     {
       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
 	{

gcc/doc/extend.texi

@@ -3345,33 +3345,53 @@ than 2.96.
 
 @item hot
 @cindex @code{hot} function attribute
-The @code{hot} attribute is used to inform the compiler that a function is a
-hot spot of the compiled program.  The function is optimized more aggressively
-and on many target it is placed into special subsection of the text section so
-all hot functions appears close together improving locality.
+The @code{hot} attribute on a function is used to inform the compiler that
+the function is a hot spot of the compiled program.  The function is
+optimized more aggressively and on many target it is placed into special
+subsection of the text section so all hot functions appears close together
+improving locality.
 
 When profile feedback is available, via @option{-fprofile-use}, hot functions
 are automatically detected and this attribute is ignored.
 
-The @code{hot} attribute is not implemented in GCC versions earlier
-than 4.3.
+The @code{hot} attribute on functions is not implemented in GCC versions
+earlier than 4.3.
+
+@cindex @code{hot} label attribute
+The @code{hot} attribute on a label is used to inform the compiler that
+path following the label are more likely than paths that are not so
+annotated.  This attribute is used in cases where @code{__builtin_expect}
+cannot be used, for instance with computed goto or @code{asm goto}.
+
+The @code{hot} attribute on labels is not implemented in GCC versions
+earlier than 4.8.
 
 @item cold
 @cindex @code{cold} function attribute
-The @code{cold} attribute is used to inform the compiler that a function is
-unlikely executed.  The function is optimized for size rather than speed and on
-many targets it is placed into special subsection of the text section so all
-cold functions appears close together improving code locality of non-cold parts
-of program.  The paths leading to call of cold functions within code are marked
-as unlikely by the branch prediction mechanism. It is thus useful to mark
-functions used to handle unlikely conditions, such as @code{perror}, as cold to
-improve optimization of hot functions that do call marked functions in rare
-occasions.
+The @code{cold} attribute on functions is used to inform the compiler that
+the function is unlikely to be executed.  The function is optimized for
+size rather than speed and on many targets it is placed into special
+subsection of the text section so all cold functions appears close together
+improving code locality of non-cold parts of program.  The paths leading
+to call of cold functions within code are marked as unlikely by the branch
+prediction mechanism.  It is thus useful to mark functions used to handle
+unlikely conditions, such as @code{perror}, as cold to improve optimization
+of hot functions that do call marked functions in rare occasions.
 
-When profile feedback is available, via @option{-fprofile-use}, hot functions
+When profile feedback is available, via @option{-fprofile-use}, cold functions
 are automatically detected and this attribute is ignored.
 
-The @code{cold} attribute is not implemented in GCC versions earlier than 4.3.
+The @code{cold} attribute on functions is not implemented in GCC versions
+earlier than 4.3.
+
+@cindex @code{cold} label attribute
+The @code{cold} attribute on labels is used to inform the compiler that
+the path following the label is unlikely to be executed.  This attribute
+is used in cases where @code{__builtin_expect} cannot be used, for instance
+with computed goto or @code{asm goto}.
+
+The @code{cold} attribute on labels is not implemented in GCC versions
+earlier than 4.8.
 
 @item regparm (@var{number})
 @cindex @code{regparm} attribute

gcc/predict.c

@@ -2059,6 +2059,29 @@ tree_estimate_probability_bb (basic_block bb)
 
   FOR_EACH_EDGE (e, ei, bb->succs)
     {
+      /* Predict edges to user labels with attributes.  */
+      if (e->dest != EXIT_BLOCK_PTR)
+	{
+	  gimple_stmt_iterator gi;
+	  for (gi = gsi_start_bb (e->dest); !gsi_end_p (gi); gsi_next (&gi))
+	    {
+	      gimple stmt = gsi_stmt (gi);
+	      tree decl;
+
+	      if (gimple_code (stmt) != GIMPLE_LABEL)
+		break;
+	      decl = gimple_label_label (stmt);
+	      if (DECL_ARTIFICIAL (decl))
+		continue;
+
+	      /* Finally, we have a user-defined label.  */
+	      if (lookup_attribute ("cold", DECL_ATTRIBUTES (decl)))
+		predict_edge_def (e, PRED_COLD_LABEL, NOT_TAKEN);
+	      else if (lookup_attribute ("hot", DECL_ATTRIBUTES (decl)))
+		predict_edge_def (e, PRED_HOT_LABEL, TAKEN);
+	    }
+	}
+
       /* Predict early returns to be probable, as we've already taken
 	 care for error returns and other cases are often used for
 	 fast paths through function.

gcc/predict.def

@@ -126,3 +126,10 @@ DEF_PREDICTOR (PRED_LOOP_IV_COMPARE_GUESS, "guess loop iv compare",
    to set probability of branches that compares IV to loop bound variable.  */
 DEF_PREDICTOR (PRED_LOOP_IV_COMPARE, "loop iv compare", PROB_VERY_LIKELY,
 	       PRED_FLAG_FIRST_MATCH)
+
+/* Branches to hot labels are likely.  */
+DEF_PREDICTOR (PRED_HOT_LABEL, "hot label", HITRATE (85), 0)
+
+/* Branches to cold labels are extremely unlikely.  */
+DEF_PREDICTOR (PRED_COLD_LABEL, "cold label", PROB_VERY_LIKELY,
+	       PRED_FLAG_FIRST_MATCH)

gcc/testsuite/ChangeLog

@@ -1,3 +1,8 @@
+2012-07-26  Richard Henderson  <rth@redhat.com>
+
+	* gcc.dg/attr-hotcold-1.c: New.
+	* gcc.dg/tree-ssa/attr-hotcold-2.c: New.
+
 2012-07-26  Andrew Jenner  <andrew@codesourcery.com>
 	    Sandra Loosemore  <sandra@codesourcery.com>
 

gcc/testsuite/gcc.dg/attr-hotcold-1.c

@@ -0,0 +1,8 @@
+void f(void)
+{
+  goto A;
+ A: __attribute__((cold))
+  goto B;
+ B: __attribute__((hot))
+  return;
+}

gcc/testsuite/gcc.dg/tree-ssa/attr-hotcold-2.c

@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-ipa-profile_estimate-details" } */
+
+void g(void);
+void h(void);
+void f(int x, int y)
+{
+  if (x) goto A;
+  if (y) goto B;
+  return;
+
+ A: __attribute__((cold))
+  g();
+  return;
+
+ B: __attribute__((hot))
+  h();
+  return;
+}
+
+/* { dg-final { scan-ipa-dump-times "block 4, loop depth 0, count 0, freq 1\[^0-9\]" 1 "profile_estimate" } } */
+
+/* Note: we're attempting to match some number > 6000, i.e. > 60%.
+   The exact number ought to be tweekable without having to juggle
+   the testcase around too much.  */
+/* { dg-final { scan-ipa-dump-times "block 5, loop depth 0, count 0, freq \[6-9\]\[0-9\]\[0-9\]\[0-9\]" 1 "profile_estimate" } } */
+
+/* { dg-final { cleanup-tree-dump "profile_estimate" } } */