[gentoo-commits] proj/gcc-patches:master commit in: 15.0.0/gentoo/

["Sam James" <sam@gentoo.org>]

commit:     45c3db3dbbdcb7c6a692987a05a40cfb2bdaa034
Author:     Sam James <sam <AT> gentoo <DOT> org>
AuthorDate: Tue Jan 14 08:43:30 2025 +0000
Commit:     Sam James <sam <AT> gentoo <DOT> org>
CommitDate: Tue Jan 14 08:43:30 2025 +0000
URL:        https://gitweb.gentoo.org/proj/gcc-patches.git/commit/?id=45c3db3d

15.0.0: add two more ifcombine patches

Bug: https://gcc.gnu.org/PR118456
Signed-off-by: Sam James <sam <AT> gentoo.org>

 ...xtend-constants-to-compare-with-bitfields.patch | 214 +++++++++++++
 ...PR118456-robustify-decode_field_reference.patch | 354 +++++++++++++++++++++
 15.0.0/gentoo/README.history                       |   2 +
 3 files changed, 570 insertions(+)

diff --git a/15.0.0/gentoo/84_all_PR118456-check-and-extend-constants-to-compare-with-bitfields.patch b/15.0.0/gentoo/84_all_PR118456-check-and-extend-constants-to-compare-with-bitfields.patch
new file mode 100644
index 0000000..e005c02
--- /dev/null
+++ b/15.0.0/gentoo/84_all_PR118456-check-and-extend-constants-to-compare-with-bitfields.patch
@@ -0,0 +1,214 @@
+https://inbox.sourceware.org/gcc-patches/ora5bugmmi.fsf@lxoliva.fsfla.org/
+
+From 4e794a3a5de8e8fa0fcaf98e5ea298d4a3c71192 Mon Sep 17 00:00:00 2001
+Message-ID: <4e794a3a5de8e8fa0fcaf98e5ea298d4a3c71192.1736844127.git.sam@gentoo.org>
+From: Alexandre Oliva <oliva@adacore.com>
+Date: Mon, 13 Jan 2025 23:22:45 -0300
+Subject: [PATCH 1/2] check and extend constants to compare with bitfields
+ [PR118456]
+
+Add logic to check and extend constants compared with bitfields, so
+that fields are only compared with constants they could actually
+equal.  This involves making sure the signedness doesn't change
+between loads and conversions before shifts: we'd need to carry a lot
+more data to deal with all the possibilities.
+
+Regstrapped on x86_64-linux-gnu.  Ok to install?
+
+for  gcc/ChangeLog
+
+	PR tree-optimization/118456
+	* gimple-fold.cc (decode_field_reference): Punt if shifting
+	after changing signedness.
+	(fold_truth_andor_for_ifcombine): Check extension bits in
+	constants before clipping.
+
+for  gcc/testsuite/ChangeLog
+
+PR tree-optimization/118456
+	* gcc.dg/field-merge-21.c: New.
+	* gcc.dg/field-merge-22.c: New.
+---
+ gcc/gimple-fold.cc                    | 40 +++++++++++++++++++-
+ gcc/testsuite/gcc.dg/field-merge-21.c | 53 +++++++++++++++++++++++++++
+ gcc/testsuite/gcc.dg/field-merge-22.c | 31 ++++++++++++++++
+ 3 files changed, 122 insertions(+), 2 deletions(-)
+ create mode 100644 gcc/testsuite/gcc.dg/field-merge-21.c
+ create mode 100644 gcc/testsuite/gcc.dg/field-merge-22.c
+
+diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
+index 93ed8b3abb05..5b1fbe6db1df 100644
+--- a/gcc/gimple-fold.cc
++++ b/gcc/gimple-fold.cc
+@@ -7712,6 +7712,18 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+ 
+   if (shiftrt)
+     {
++      /* Punt if we're shifting by more than the loaded bitfield (after
++	 adjustment), or if there's a shift after a change of signedness, punt.
++	 When comparing this field with a constant, we'll check that the
++	 constant is a proper sign- or zero-extension (depending on signedness)
++	 of a value that would fit in the selected portion of the bitfield.  A
++	 shift after a change of signedness would make the extension
++	 non-uniform, and we can't deal with that (yet ???).  See
++	 gcc.dg/field-merge-22.c for a test that would go wrong.  */
++      if (*pbitsize <= shiftrt
++	  || (convert_before_shift
++	      && outer_type && unsignedp != TYPE_UNSIGNED (outer_type)))
++	return NULL_TREE;
+       if (!*preversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
+ 	*pbitpos += shiftrt;
+       *pbitsize -= shiftrt;
+@@ -8512,13 +8524,25 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+      and bit position.  */
+   if (l_const.get_precision ())
+     {
++      /* Before clipping upper bits of the right-hand operand of the compare,
++	 check that they're sign or zero extensions, depending on how the
++	 left-hand operand would be extended.  */
++      bool l_non_ext_bits = false;
++      if (ll_bitsize < lr_bitsize)
++	{
++	  wide_int zext = wi::zext (l_const, ll_bitsize);
++	  if ((ll_unsignedp ? zext : wi::sext (l_const, ll_bitsize)) == l_const)
++	    l_const = zext;
++	  else
++	    l_non_ext_bits = true;
++	}
+       /* We're doing bitwise equality tests, so don't bother with sign
+ 	 extensions.  */
+       l_const = wide_int::from (l_const, lnprec, UNSIGNED);
+       if (ll_and_mask.get_precision ())
+ 	l_const &= wide_int::from (ll_and_mask, lnprec, UNSIGNED);
+       l_const <<= xll_bitpos;
+-      if ((l_const & ~ll_mask) != 0)
++      if (l_non_ext_bits || (l_const & ~ll_mask) != 0)
+ 	{
+ 	  warning_at (lloc, OPT_Wtautological_compare,
+ 		      "comparison is always %d", wanted_code == NE_EXPR);
+@@ -8530,11 +8554,23 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+ 	 again.  */
+       gcc_checking_assert (r_const.get_precision ());
+ 
++      /* Before clipping upper bits of the right-hand operand of the compare,
++	 check that they're sign or zero extensions, depending on how the
++	 left-hand operand would be extended.  */
++      bool r_non_ext_bits = false;
++      if (rl_bitsize < rr_bitsize)
++	{
++	  wide_int zext = wi::zext (r_const, rl_bitsize);
++	  if ((rl_unsignedp ? zext : wi::sext (r_const, rl_bitsize)) == r_const)
++	    r_const = zext;
++	  else
++	    r_non_ext_bits = true;
++	}
+       r_const = wide_int::from (r_const, lnprec, UNSIGNED);
+       if (rl_and_mask.get_precision ())
+ 	r_const &= wide_int::from (rl_and_mask, lnprec, UNSIGNED);
+       r_const <<= xrl_bitpos;
+-      if ((r_const & ~rl_mask) != 0)
++      if (r_non_ext_bits || (r_const & ~rl_mask) != 0)
+ 	{
+ 	  warning_at (rloc, OPT_Wtautological_compare,
+ 		      "comparison is always %d", wanted_code == NE_EXPR);
+diff --git a/gcc/testsuite/gcc.dg/field-merge-21.c b/gcc/testsuite/gcc.dg/field-merge-21.c
+new file mode 100644
+index 000000000000..042b2123eb63
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/field-merge-21.c
+@@ -0,0 +1,53 @@
++/* { dg-do run } */
++/* { dg-options "-O2" } */
++
++/* PR tree-optimization/118456 */
++/* Check that shifted fields compared with a constants compare correctly even
++   if the constant contains sign-extension bits not present in the bit
++   range.  */
++
++struct S { unsigned long long o; unsigned short a, b; } s;
++
++__attribute__((noipa)) int
++foo (void)
++{
++  return ((unsigned char) s.a) >> 3 == 17 && ((signed char) s.b) >> 2 == -27;
++}
++
++__attribute__((noipa)) int
++bar (void)
++{
++  return ((unsigned char) s.a) >> 3 == 17 && ((signed char) s.b) >> 2 == -91;
++}
++
++__attribute__((noipa)) int
++bars (void)
++{
++  return ((unsigned char) s.a) >> 3 == 17 && ((signed char) s.b) >> 2 == 37;
++}
++
++__attribute__((noipa)) int
++baz (void)
++{
++  return ((unsigned char) s.a) >> 3 == 49 && ((signed char) s.b) >> 2 == -27;
++}
++
++__attribute__((noipa)) int
++bazs (void)
++{
++  return ((unsigned char) s.a) >> 3 == (unsigned char) -15 && ((signed char) s.b) >> 2 == -27;
++}
++
++int
++main ()
++{
++  s.a = 17 << 3;
++  s.b = (unsigned short)(-27u << 2);
++  if (foo () != 1
++      || bar () != 0
++      || bars () != 0
++      || baz () != 0
++      || bazs () != 0)
++    __builtin_abort ();
++  return 0;
++}
+diff --git a/gcc/testsuite/gcc.dg/field-merge-22.c b/gcc/testsuite/gcc.dg/field-merge-22.c
+new file mode 100644
+index 000000000000..45b29c0bccaf
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/field-merge-22.c
+@@ -0,0 +1,31 @@
++/* { dg-do run } */
++/* { dg-options "-O2" } */
++
++/* PR tree-optimization/118456 */
++/* Check that compares with constants take into account sign/zero extension of
++   both the bitfield and of the shifting type.  */
++
++#define shift (__CHAR_BIT__ - 4)
++
++struct S {
++  signed char a : shift + 2;
++  signed char b : shift + 2;
++  short ignore[0];
++} s;
++
++__attribute__((noipa)) int
++foo (void)
++{
++  return ((unsigned char) s.a) >> shift == 15
++    && ((unsigned char) s.b) >> shift == 0;
++}
++
++int
++main ()
++{
++  s.a = -1;
++  s.b = 1;
++  if (foo () != 1)
++    __builtin_abort ();
++  return 0;
++}
+
+base-commit: 31c3c1a83fd885b4687c9f6f7acd68af76d758d3
+-- 
+2.48.0
+

diff --git a/15.0.0/gentoo/85_all_PR118456-robustify-decode_field_reference.patch b/15.0.0/gentoo/85_all_PR118456-robustify-decode_field_reference.patch
new file mode 100644
index 0000000..065c958
--- /dev/null
+++ b/15.0.0/gentoo/85_all_PR118456-robustify-decode_field_reference.patch
@@ -0,0 +1,354 @@
+https://inbox.sourceware.org/gcc-patches/or1px6gf6r.fsf@lxoliva.fsfla.org/
+
+From e3a5a707fd88522a73d05841970fa2465e991eaa Mon Sep 17 00:00:00 2001
+Message-ID: <e3a5a707fd88522a73d05841970fa2465e991eaa.1736844127.git.sam@gentoo.org>
+In-Reply-To: <4e794a3a5de8e8fa0fcaf98e5ea298d4a3c71192.1736844127.git.sam@gentoo.org>
+References: <4e794a3a5de8e8fa0fcaf98e5ea298d4a3c71192.1736844127.git.sam@gentoo.org>
+From: Alexandre Oliva <oliva@adacore.com>
+Date: Tue, 14 Jan 2025 02:03:24 -0300
+Subject: [PATCH 2/2] robustify decode_field_reference
+
+Arrange for decode_field_reference to use local variables throughout,
+to modify the out parms only when we're about to return non-NULL, and
+to drop the unused case of NULL pand_mask, that had a latent failure
+to detect signbit masking.
+
+Regstrapped on x86_64-linux-gnu along with the PR118456 patch.
+Ok to install?
+
+for  gcc/ChangeLog
+
+* gimple-fold.cc (decode_field_reference): Rebustify to set
+	out parms only when returning non-NULL.
+	(fold_truth_andor_for_ifcombine): Bail if
+	decode_field_reference returns NULL.  Add complementary assert
+	on r_const's not being set when l_const isn't.
+---
+ gcc/gimple-fold.cc | 155 +++++++++++++++++++++++----------------------
+ 1 file changed, 80 insertions(+), 75 deletions(-)
+
+diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
+index 5b1fbe6db1df..3c971a29ef04 100644
+--- a/gcc/gimple-fold.cc
++++ b/gcc/gimple-fold.cc
+@@ -7510,18 +7510,17 @@ gimple_binop_def_p (enum tree_code code, tree t, tree op[2])
+    *PREVERSEP is set to the storage order of the field.
+ 
+    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.  If
+-   PAND_MASK *is NULL, BIT_AND_EXPR is not recognized.  If *PAND_MASK
+-   is initially set to a mask with nonzero precision, that mask is
++   *PAND_MASK is initially set to a mask with nonzero precision, that mask is
+    combined with the found mask, or adjusted in precision to match.
+ 
+    *PSIGNBIT is set to TRUE if, before clipping to *PBITSIZE, the mask
+    encompassed bits that corresponded to extensions of the sign bit.
+ 
+-   *XOR_P is to be FALSE if EXP might be a XOR used in a compare, in which
+-   case, if XOR_CMP_OP is a zero constant, it will be overridden with *PEXP,
+-   *XOR_P will be set to TRUE, *XOR_PAND_MASK will be copied from *PAND_MASK,
+-   and the left-hand operand of the XOR will be decoded.  If *XOR_P is TRUE,
+-   XOR_CMP_OP and XOR_PAND_MASK are supposed to be NULL, and then the
++   *PXORP is to be FALSE if EXP might be a XOR used in a compare, in which
++   case, if PXOR_CMP_OP is a zero constant, it will be overridden with *PEXP,
++   *PXORP will be set to TRUE, *PXOR_AND_MASK will be copied from *PAND_MASK,
++   and the left-hand operand of the XOR will be decoded.  If *PXORP is TRUE,
++   PXOR_CMP_OP and PXOR_AND_MASK are supposed to be NULL, and then the
+    right-hand operand of the XOR will be decoded.
+ 
+    *LOAD is set to the load stmt of the innermost reference, if any,
+@@ -7538,8 +7537,8 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+ 			HOST_WIDE_INT *pbitpos,
+ 			bool *punsignedp, bool *preversep, bool *pvolatilep,
+ 			wide_int *pand_mask, bool *psignbit,
+-			bool *xor_p, tree *xor_cmp_op, wide_int *xor_pand_mask,
+-			gimple **load, location_t loc[4])
++			bool *pxorp, tree *pxor_cmp_op, wide_int *pxor_and_mask,
++			gimple **pload, location_t loc[4])
+ {
+   tree exp = *pexp;
+   tree outer_type = 0;
+@@ -7549,9 +7548,11 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+   tree res_ops[2];
+   machine_mode mode;
+   bool convert_before_shift = false;
+-
+-  *load = NULL;
+-  *psignbit = false;
++  bool signbit = false;
++  bool xorp = false;
++  tree xor_cmp_op;
++  wide_int xor_and_mask;
++  gimple *load = NULL;
+ 
+   /* All the optimizations using this function assume integer fields.
+      There are problems with FP fields since the type_for_size call
+@@ -7576,7 +7577,7 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+ 
+   /* Recognize and save a masking operation.  Combine it with an
+      incoming mask.  */
+-  if (pand_mask && gimple_binop_def_p (BIT_AND_EXPR, exp, res_ops)
++  if (gimple_binop_def_p (BIT_AND_EXPR, exp, res_ops)
+       && TREE_CODE (res_ops[1]) == INTEGER_CST)
+     {
+       loc[1] = gimple_location (SSA_NAME_DEF_STMT (exp));
+@@ -7596,29 +7597,29 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+ 	    and_mask &= wide_int::from (*pand_mask, prec_op, UNSIGNED);
+ 	}
+     }
+-  else if (pand_mask)
++  else
+     and_mask = *pand_mask;
+ 
+   /* Turn (a ^ b) [!]= 0 into a [!]= b.  */
+-  if (xor_p && gimple_binop_def_p (BIT_XOR_EXPR, exp, res_ops))
++  if (pxorp && gimple_binop_def_p (BIT_XOR_EXPR, exp, res_ops))
+     {
+       /* No location recorded for this one, it's entirely subsumed by the
+ 	 compare.  */
+-      if (*xor_p)
++      if (*pxorp)
+ 	{
+ 	  exp = res_ops[1];
+-	  gcc_checking_assert (!xor_cmp_op && !xor_pand_mask);
++	  gcc_checking_assert (!pxor_cmp_op && !pxor_and_mask);
+ 	}
+-      else if (!xor_cmp_op)
++      else if (!pxor_cmp_op)
+ 	/* Not much we can do when xor appears in the right-hand compare
+ 	   operand.  */
+ 	return NULL_TREE;
+-      else if (integer_zerop (*xor_cmp_op))
++      else if (integer_zerop (*pxor_cmp_op))
+ 	{
+-	  *xor_p = true;
++	  xorp = true;
+ 	  exp = res_ops[0];
+-	  *xor_cmp_op = *pexp;
+-	  *xor_pand_mask = *pand_mask;
++	  xor_cmp_op = *pexp;
++	  xor_and_mask = *pand_mask;
+ 	}
+     }
+ 
+@@ -7646,12 +7647,12 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+   /* Yet another chance to drop conversions.  This one is allowed to
+      match a converting load, subsuming the load identification block
+      below.  */
+-  if (!outer_type && gimple_convert_def_p (exp, res_ops, load))
++  if (!outer_type && gimple_convert_def_p (exp, res_ops, &load))
+     {
+       outer_type = TREE_TYPE (exp);
+       loc[0] = gimple_location (SSA_NAME_DEF_STMT (exp));
+-      if (*load)
+-	loc[3] = gimple_location (*load);
++      if (load)
++	loc[3] = gimple_location (load);
+       exp = res_ops[0];
+       /* This looks backwards, but we're going back the def chain, so if we
+ 	 find the conversion here, after finding a shift, that's because the
+@@ -7662,14 +7663,13 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+     }
+ 
+   /* Identify the load, if there is one.  */
+-  if (!(*load) && TREE_CODE (exp) == SSA_NAME
+-      && !SSA_NAME_IS_DEFAULT_DEF (exp))
++  if (!load && TREE_CODE (exp) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (exp))
+     {
+       gimple *def = SSA_NAME_DEF_STMT (exp);
+       if (gimple_assign_load_p (def))
+ 	{
+ 	  loc[3] = gimple_location (def);
+-	  *load = def;
++	  load = def;
+ 	  exp = gimple_assign_rhs1 (def);
+ 	}
+     }
+@@ -7694,20 +7694,14 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+ 	  && !type_has_mode_precision_p (TREE_TYPE (inner))))
+     return NULL_TREE;
+ 
+-  *pbitsize = bs;
+-  *pbitpos = bp;
+-  *punsignedp = unsignedp;
+-  *preversep = reversep;
+-  *pvolatilep = volatilep;
+-
+   /* Adjust shifts...  */
+   if (convert_before_shift
+-      && outer_type && *pbitsize > TYPE_PRECISION (outer_type))
++      && outer_type && bs > TYPE_PRECISION (outer_type))
+     {
+-      HOST_WIDE_INT excess = *pbitsize - TYPE_PRECISION (outer_type);
+-      if (*preversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
+-	*pbitpos += excess;
+-      *pbitsize -= excess;
++      HOST_WIDE_INT excess = bs - TYPE_PRECISION (outer_type);
++      if (reversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
++	bp += excess;
++      bs -= excess;
+     }
+ 
+   if (shiftrt)
+@@ -7720,49 +7714,57 @@ decode_field_reference (tree *pexp, HOST_WIDE_INT *pbitsize,
+ 	 shift after a change of signedness would make the extension
+ 	 non-uniform, and we can't deal with that (yet ???).  See
+ 	 gcc.dg/field-merge-22.c for a test that would go wrong.  */
+-      if (*pbitsize <= shiftrt
++      if (bs <= shiftrt
+ 	  || (convert_before_shift
+ 	      && outer_type && unsignedp != TYPE_UNSIGNED (outer_type)))
+ 	return NULL_TREE;
+-      if (!*preversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
+-	*pbitpos += shiftrt;
+-      *pbitsize -= shiftrt;
++      if (!reversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
++	bp += shiftrt;
++      bs -= shiftrt;
+     }
+ 
+   /* ... and bit position.  */
+   if (!convert_before_shift
+-      && outer_type && *pbitsize > TYPE_PRECISION (outer_type))
++      && outer_type && bs > TYPE_PRECISION (outer_type))
+     {
+-      HOST_WIDE_INT excess = *pbitsize - TYPE_PRECISION (outer_type);
+-      if (*preversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
+-	*pbitpos += excess;
+-      *pbitsize -= excess;
++      HOST_WIDE_INT excess = bs - TYPE_PRECISION (outer_type);
++      if (reversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
++	bp += excess;
++      bs -= excess;
+     }
+ 
+-  *pexp = exp;
+-
+   /* If the number of bits in the reference is the same as the bitsize of
+      the outer type, then the outer type gives the signedness. Otherwise
+      (in case of a small bitfield) the signedness is unchanged.  */
+-  if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
+-    *punsignedp = TYPE_UNSIGNED (outer_type);
++  if (outer_type && bs == TYPE_PRECISION (outer_type))
++    unsignedp = TYPE_UNSIGNED (outer_type);
+ 
+-  if (pand_mask)
++  /* Make the mask the expected width.  */
++  if (and_mask.get_precision () != 0)
+     {
+-      /* Make the mask the expected width.  */
+-      if (and_mask.get_precision () != 0)
+-	{
+-	  /* If the AND_MASK encompasses bits that would be extensions of
+-	     the sign bit, set *PSIGNBIT.  */
+-	  if (!unsignedp
+-	      && and_mask.get_precision () > *pbitsize
+-	      && (and_mask
+-		  & wi::mask (*pbitsize, true, and_mask.get_precision ())) != 0)
+-	    *psignbit = true;
+-	  and_mask = wide_int::from (and_mask, *pbitsize, UNSIGNED);
+-	}
++      /* If the AND_MASK encompasses bits that would be extensions of
++	 the sign bit, set SIGNBIT.  */
++      if (!unsignedp
++	  && and_mask.get_precision () > bs
++	  && (and_mask & wi::mask (bs, true, and_mask.get_precision ())) != 0)
++	signbit = true;
++      and_mask = wide_int::from (and_mask, bs, UNSIGNED);
++    }
+ 
+-      *pand_mask = and_mask;
++  *pexp = exp;
++  *pload = load;
++  *pbitsize = bs;
++  *pbitpos = bp;
++  *punsignedp = unsignedp;
++  *preversep = reversep;
++  *pvolatilep = volatilep;
++  *psignbit = signbit;
++  *pand_mask = and_mask;
++  if (xorp)
++    {
++      *pxorp = xorp;
++      *pxor_cmp_op = xor_cmp_op;
++      *pxor_and_mask = xor_and_mask;
+     }
+ 
+   return inner;
+@@ -8168,19 +8170,27 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+ 				     &ll_and_mask, &ll_signbit,
+ 				     &l_xor, &lr_arg, &lr_and_mask,
+ 				     &ll_load, ll_loc);
++  if (!ll_inner)
++    return 0;
+   lr_inner = decode_field_reference (&lr_arg, &lr_bitsize, &lr_bitpos,
+ 				     &lr_unsignedp, &lr_reversep, &volatilep,
+ 				     &lr_and_mask, &lr_signbit, &l_xor, 0, 0,
+ 				     &lr_load, lr_loc);
++  if (!lr_inner)
++    return 0;
+   rl_inner = decode_field_reference (&rl_arg, &rl_bitsize, &rl_bitpos,
+ 				     &rl_unsignedp, &rl_reversep, &volatilep,
+ 				     &rl_and_mask, &rl_signbit,
+ 				     &r_xor, &rr_arg, &rr_and_mask,
+ 				     &rl_load, rl_loc);
++  if (!rl_inner)
++    return 0;
+   rr_inner = decode_field_reference (&rr_arg, &rr_bitsize, &rr_bitpos,
+ 				     &rr_unsignedp, &rr_reversep, &volatilep,
+ 				     &rr_and_mask, &rr_signbit, &r_xor, 0, 0,
+ 				     &rr_load, rr_loc);
++  if (!rr_inner)
++    return 0;
+ 
+   /* It must be true that the inner operation on the lhs of each
+      comparison must be the same if we are to be able to do anything.
+@@ -8188,16 +8198,13 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+      the rhs's.  If one is a load and the other isn't, we have to be
+      conservative and avoid the optimization, otherwise we could get
+      SRAed fields wrong.  */
+-  if (volatilep
+-      || ll_reversep != rl_reversep
+-      || ll_inner == 0 || rl_inner == 0)
++  if (volatilep || ll_reversep != rl_reversep)
+     return 0;
+ 
+   if (! operand_equal_p (ll_inner, rl_inner, 0))
+     {
+       /* Try swapping the operands.  */
+       if (ll_reversep != rr_reversep
+-	  || !rr_inner
+ 	  || !operand_equal_p (ll_inner, rr_inner, 0))
+ 	return 0;
+ 
+@@ -8266,7 +8273,6 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+       lr_reversep = ll_reversep;
+     }
+   else if (lr_reversep != rr_reversep
+-	   || lr_inner == 0 || rr_inner == 0
+ 	   || ! operand_equal_p (lr_inner, rr_inner, 0)
+ 	   || ((lr_load && rr_load)
+ 	       ? gimple_vuse (lr_load) != gimple_vuse (rr_load)
+@@ -8520,6 +8526,9 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+   else
+     rl_mask = wi::shifted_mask (xrl_bitpos, rl_bitsize, false, lnprec);
+ 
++  /* When we set l_const, we also set r_const.  */
++  gcc_checking_assert (!l_const.get_precision () == !r_const.get_precision ());
++
+   /* Adjust right-hand constants in both original comparisons to match width
+      and bit position.  */
+   if (l_const.get_precision ())
+@@ -8550,10 +8559,6 @@ fold_truth_andor_for_ifcombine (enum tree_code code, tree truth_type,
+ 	  return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
+ 	}
+ 
+-      /* When we set l_const, we also set r_const, so we need not test it
+-	 again.  */
+-      gcc_checking_assert (r_const.get_precision ());
+-
+       /* Before clipping upper bits of the right-hand operand of the compare,
+ 	 check that they're sign or zero extensions, depending on how the
+ 	 left-hand operand would be extended.  */
+-- 
+2.48.0
+

diff --git a/15.0.0/gentoo/README.history b/15.0.0/gentoo/README.history
index 5580afb..490735a 100644
--- a/15.0.0/gentoo/README.history
+++ b/15.0.0/gentoo/README.history
@@ -2,6 +2,8 @@
 
 	U 80_all_PR81358-Enable-automatic-linking-of-libatomic.patch
 	- 82_all_PR118409-ifcombine.patch
+	+ 84_all_PR118456-check-and-extend-constants-to-compare-with-bitfields.patch
+	+ 85_all_PR118456-robustify-decode_field_reference.patch
 
 38	13 January 2023