https://gcc.gnu.org/g:fdf84733a30b32e201334092f56efe10451c6147
commit r16-7752-gfdf84733a30b32e201334092f56efe10451c6147 Author: Andrew Pinski <[email protected]> Date: Thu Feb 26 12:06:51 2026 -0800 phiopt: Reject hot/cold predictors for early phiopt [PR117935] In this case, early phiopt would get rid of the user provided predicator for hot/cold as it would remove the basic blocks. The easiest and best option is for early phi-opt don't do phi-opt if the middle basic-block(s) have either a hot or cold predict statement. Then after inlining, jump threading will most likely happen and that will keep around the predictor. Note this only needs to be done for match_simplify_replacement and not the other phi-opt functions because currently only match_simplify_replacement is able to skip middle bb with predicator statements in it. This allows for MIN/MAX/ABS/NEG still even with the predicators there as those will less likely be jump threaded later on. The main thing that is rejected is ssa names that are alone where one of the comparisons operands is that one or if we produce a comparison from the phiopt. Changes since v1: * v2: Only reject if the result was the comparison. Bootstrapped and tested on x86_64-linux-gnu. PR tree-optimization/117935 gcc/ChangeLog: * tree-ssa-phiopt.cc (contains_hot_cold_predict): New function. (match_simplify_replacement): Return early if early_p and one of the middle bb(s) have a hot/cold predict statement. gcc/testsuite/ChangeLog: * gcc.dg/predict-24.c: New test. * gcc.dg/predict-25.c: New test. Signed-off-by: Andrew Pinski <[email protected]> Diff: --- gcc/testsuite/gcc.dg/predict-24.c | 24 ++++++++++++++++++ gcc/testsuite/gcc.dg/predict-25.c | 24 ++++++++++++++++++ gcc/tree-ssa-phiopt.cc | 52 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 100 insertions(+) diff --git a/gcc/testsuite/gcc.dg/predict-24.c b/gcc/testsuite/gcc.dg/predict-24.c new file mode 100644 index 000000000000..b2c8a77c323f --- /dev/null +++ b/gcc/testsuite/gcc.dg/predict-24.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-profile_estimate" } */ +/* PR tree-optimization/117935 */ + +static inline bool has_value(bool b) +{ + if (b) + { + [[gnu::hot, gnu::unused]] label1: + return true; + } + else + return false; +} +/* The hot label should last until it gets inlined into value_or and jump_threaded. */ +int value_or(bool b, int def0, int def1) +{ + if (has_value(b)) + return def0; + else + return def1; +} +/* { dg-final { scan-tree-dump-times "first match heuristics: 90.00%" 2 "profile_estimate"} } */ +/* { dg-final { scan-tree-dump-times "hot label heuristics of edge \[0-9\]+->\[0-9]+: 90.00%" 2 "profile_estimate"} } */ diff --git a/gcc/testsuite/gcc.dg/predict-25.c b/gcc/testsuite/gcc.dg/predict-25.c new file mode 100644 index 000000000000..027774ca7466 --- /dev/null +++ b/gcc/testsuite/gcc.dg/predict-25.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-profile_estimate" } */ +/* PR tree-optimization/117935 */ + +static inline bool has_value(int b) +{ + if (b) + { + [[gnu::hot, gnu::unused]] label1: + return true; + } + else + return false; +} +/* The hot label should last until it gets inlined into value_or and jump_threaded. */ +int value_or(int b, int def0, int def1) +{ + if (has_value(b)) + return def0; + else + return def1; +} +/* { dg-final { scan-tree-dump-times "first match heuristics: 90.00%" 2 "profile_estimate"} } */ +/* { dg-final { scan-tree-dump-times "hot label heuristics of edge \[0-9\]+->\[0-9]+: 90.00%" 2 "profile_estimate"} } */ diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index fcf44136d0a4..0bf7e58b8f03 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -55,6 +55,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-ssa-propagate.h" #include "tree-ssa-dce.h" #include "tree-ssa-loop-niter.h" +#include "gimple-predict.h" /* Return the singleton PHI in the SEQ of PHIs for edges E0 and E1. */ @@ -913,6 +914,27 @@ auto_flow_sensitive::~auto_flow_sensitive () p.second.restore (p.first); } +/* Returns true if BB contains an user provided predictor + (PRED_HOT_LABEL/PRED_COLD_LABEL). */ + +static bool +contains_hot_cold_predict (basic_block bb) +{ + gimple_stmt_iterator gsi; + gsi = gsi_start_nondebug_after_labels_bb (bb); + for (; !gsi_end_p (gsi); gsi_next_nondebug (&gsi)) + { + gimple *s = gsi_stmt (gsi); + if (gimple_code (s) != GIMPLE_PREDICT) + continue; + auto predict = gimple_predict_predictor (s); + if (predict == PRED_HOT_LABEL + || predict == PRED_COLD_LABEL) + return true; + } + return false; +} + /* The function match_simplify_replacement does the main work of doing the replacement using match and simplify. Return true if the replacement is done. Otherwise return false. @@ -1006,6 +1028,36 @@ match_simplify_replacement (basic_block cond_bb, basic_block middle_bb, &seq); } + /* For early phiopt, we don't want to lose user generated predictors + if the phiopt is converting `if (a)` into `a` as that might + be jump threaded later on so we want to keep around the + predictors. */ + if (early_p && result && TREE_CODE (result) == SSA_NAME) + { + bool check_it = false; + tree cmp0 = gimple_cond_lhs (stmt); + tree cmp1 = gimple_cond_rhs (stmt); + if (result == cmp0 || result == cmp1) + check_it = true; + else if (gimple_seq_singleton_p (seq)) + { + gimple *stmt = gimple_seq_first_stmt (seq); + if (is_gimple_assign (stmt) + && result == gimple_assign_lhs (stmt) + && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) + == tcc_comparison) + check_it = true; + } + if (!check_it) + ; + else if (contains_hot_cold_predict (middle_bb)) + return false; + else if (threeway_p + && middle_bb != middle_bb_alt + && contains_hot_cold_predict (middle_bb_alt)) + return false; + } + if (!result) { /* If we don't get back a MIN/MAX_EXPR still make sure the expression
