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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 0cd287a206a19167fa4c230dc9749867afe80cc4..d75809cce407bc6d1eea10956b644d5406350889 100644 (file)
--- a/gcc/ChangeLog
+++ b/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>
 

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index ddea75a00e1b38784492adc1d435f37ca6e5584f..983a93e4949f5e392c354075a5ce1e7fd577fda8 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/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

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index b72506b212f27f25c1145328f9945ad0088f7a3a..a00254167c99583e168d09bc05b86efa65840b88 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/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)
        {

diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index c3faf09effff713d3e7025e386accd90ab81a7d2..5d851a7386b79feb658c5586f06cdee25a615cf2 100644 (file)
--- a/gcc/doc/extend.texi
+++ b/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.
-
-When profile feedback is available, via @option{-fprofile-use}, hot functions
+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}, 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

diff --git a/gcc/predict.c b/gcc/predict.c
index b690bdc2519f32434fac792f6f60008fa44899af..b8acdbaeb6eb1d12d433aa56666bff36712f23ab 100644 (file)
--- a/gcc/predict.c
+++ b/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.

diff --git a/gcc/predict.def b/gcc/predict.def
index 591bb1caf58f3c01421116c4322ebb90934e7d79..7e77f141a4d96f565d209b9c7133e03347968cb1 100644 (file)
--- a/gcc/predict.def
+++ b/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)

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 0773f040fa4813f914ddb511b8461fe25b70d2cb..320d4efd70d6abc75ad15abe000c2804c8ccf88b 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/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>
 

diff --git a/gcc/testsuite/gcc.dg/attr-hotcold-1.c b/gcc/testsuite/gcc.dg/attr-hotcold-1.c
new file mode 100644 (file)
index 0000000..f63a95c
--- /dev/null
+++ b/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;
+}

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/attr-hotcold-2.c b/gcc/testsuite/gcc.dg/tree-ssa/attr-hotcold-2.c
new file mode 100644 (file)
index 0000000..84327fe
--- /dev/null
+++ b/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" } } */