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 <andrew.pinski@oss.qualcomm.com>

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"} } */

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"} } */

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