1 files changed, 91 insertions, 0 deletions
diff --git a/0059-Backport-Add-a-couple-of-A-CST1-CST2-match-and-simpl.patch b/0059-Backport-Add-a-couple-of-A-CST1-CST2-match-and-simpl.patch
new file mode 100644
index 0000000..a16b336
--- /dev/null
+++ b/0059-Backport-Add-a-couple-of-A-CST1-CST2-match-and-simpl.patch
@@ -0,0 +1,91 @@
+From 9f3a8c600abe16f172b36d8113862e8f7aea940c Mon Sep 17 00:00:00 2001
+From: Andrew Pinski <apinski@marvell.com>
+Date: Sun, 16 May 2021 13:07:06 -0700
+Subject: [PATCH 11/35] [Backport] Add a couple of A?CST1:CST2 match and
+ simplify optimizations
+
+Reference: https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=b6bdd7a4cb41ee057f2d064fffcb00f23ce6b497
+
+Instead of some of the more manual optimizations inside phi-opt,
+it would be good idea to do a lot of the heavy lifting inside match
+and simplify instead. In the process, this moves the three simple
+A?CST1:CST2 (where CST1 or CST2 is zero) simplifications.
+
+OK? Boostrapped and tested on x86_64-linux-gnu with no regressions.
+
+Differences from V1:
+* Use bit_xor 1 instead of bit_not to fix the problem with boolean types
+which are not 1 bit precision.
+
+Thanks,
+Andrew Pinski
+
+gcc:
+	* match.pd (A?CST1:CST2): Add simplifcations for A?0:+-1, A?+-1:0,
+	A?POW2:0 and A?0:POW2.
+---
+ gcc/match.pd | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 48 insertions(+)
+
+diff --git a/gcc/match.pd b/gcc/match.pd
+index 660d5c268..032830b0d 100644
+--- a/gcc/match.pd
++++ b/gcc/match.pd
+@@ -3334,6 +3334,54 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
+    (if (cst1 && cst2)
+     (vec_cond @0 { cst1; } { cst2; })))))
+ 
++/* A few simplifications of "a ? CST1 : CST2". */
++/* NOTE: Only do this on gimple as the if-chain-to-switch
++   optimization depends on the gimple to have if statements in it. */
++#if GIMPLE
++(simplify
++ (cond @0 INTEGER_CST@1 INTEGER_CST@2)
++ (switch
++  (if (integer_zerop (@2))
++   (switch
++    /* a ? 1 : 0 -> a if 0 and 1 are integral types. */
++    (if (integer_onep (@1))
++     (convert (convert:boolean_type_node @0)))
++    /* a ? powerof2cst : 0 -> a << (log2(powerof2cst)) */
++    (if (INTEGRAL_TYPE_P (type) && integer_pow2p (@1))
++     (with {
++       tree shift = build_int_cst (integer_type_node, tree_log2 (@1));
++      }
++      (lshift (convert (convert:boolean_type_node @0)) { shift; })))
++    /* a ? -1 : 0 -> -a.  No need to check the TYPE_PRECISION not being 1
++       here as the powerof2cst case above will handle that case correctly.  */
++    (if (INTEGRAL_TYPE_P (type) && integer_all_onesp (@1))
++     (negate (convert (convert:boolean_type_node @0))))))
++  (if (integer_zerop (@1))
++   (with {
++      tree booltrue = constant_boolean_node (true, boolean_type_node);
++    }
++    (switch
++     /* a ? 0 : 1 -> !a. */
++     (if (integer_onep (@2))
++      (convert (bit_xor (convert:boolean_type_node @0) { booltrue; } )))
++     /* a ? powerof2cst : 0 -> (!a) << (log2(powerof2cst)) */
++     (if (INTEGRAL_TYPE_P (type) &&  integer_pow2p (@2))
++      (with {
++	tree shift = build_int_cst (integer_type_node, tree_log2 (@2));
++       }
++       (lshift (convert (bit_xor (convert:boolean_type_node @0) { booltrue; } ))
++        { shift; })))
++     /* a ? -1 : 0 -> -(!a).  No need to check the TYPE_PRECISION not being 1
++       here as the powerof2cst case above will handle that case correctly.  */
++     (if (INTEGRAL_TYPE_P (type) && integer_all_onesp (@2))
++      (negate (convert (bit_xor (convert:boolean_type_node @0) { booltrue; } ))))
++    )
++   )
++  )
++ )
++)
++#endif
++
+ /* Simplification moved from fold_cond_expr_with_comparison.  It may also
+    be extended.  */
+ /* This pattern implements two kinds simplification:
+-- 
+2.27.0.windows.1
+