diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0cd287a206a1..d75809cce407 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2012-07-26 Richard Henderson + + * 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 Sandra Loosemore diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index ddea75a00e1b..983a93e4949f 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,8 @@ +2012-07-26 Richard Henderson + + * c-common.c (handle_hot_attribute): Allow labels. + (handle_cold_attribute): Likewise. + 2012-07-20 Jakub Jelinek PR c++/28656 diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index b72506b212f2..a00254167c99 100644 --- 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 c3faf09effff..5d851a7386b7 100644 --- 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. +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 diff --git a/gcc/predict.c b/gcc/predict.c index b690bdc2519f..b8acdbaeb6eb 100644 --- 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 591bb1caf58f..7e77f141a4d9 100644 --- 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 0773f040fa48..320d4efd70d6 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2012-07-26 Richard Henderson + + * gcc.dg/attr-hotcold-1.c: New. + * gcc.dg/tree-ssa/attr-hotcold-2.c: New. + 2012-07-26 Andrew Jenner Sandra Loosemore diff --git a/gcc/testsuite/gcc.dg/attr-hotcold-1.c b/gcc/testsuite/gcc.dg/attr-hotcold-1.c new file mode 100644 index 000000000000..f63a95c71c53 --- /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 index 000000000000..84327fe52d57 --- /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" } } */