[gcc r12-3218] Make sure we're playing with integral modes before call extract_integral_bit_field.

[gcc r12-3218] Make sure we're playing with integral modes before call extract_integral_bit_field.

[hongtao Liu]

https://gcc.gnu.org/g:7218c2ec365ce95f5a1012a6eb425b0a36aec6bf

commit r12-3218-g7218c2ec365ce95f5a1012a6eb425b0a36aec6bf
Author: liuhongt <hongtao.liu@intel.com>
Date:   Fri Aug 6 10:18:43 2021 +0800

    Make sure we're playing with integral modes before call extract_integral_bit_field.
    
    gcc/ChangeLog:
    
            * expmed.c (extract_bit_field_1): Make sure we're playing with
            integral modes before call extract_integral_bit_field.
            (extract_integral_bit_field): Add a parameter of type
            scalar_int_mode which corresponds to of tmode.
            And call extract_and_convert_fixed_bit_field instead of
            extract_fixed_bit_field and convert_extracted_bit_field.
            (extract_and_convert_fixed_bit_field): New function, it's a
            combination of extract_fixed_bit_field and
            convert_extracted_bit_field.

Diff:
---
 gcc/expmed.c | 103 ++++++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 78 insertions(+), 25 deletions(-)

diff --git a/gcc/expmed.c b/gcc/expmed.c
index 3143f38e057..f083d6e86d0 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -71,7 +71,14 @@ static void store_split_bit_field (rtx, opt_scalar_int_mode,
 static rtx extract_integral_bit_field (rtx, opt_scalar_int_mode,
 				       unsigned HOST_WIDE_INT,
 				       unsigned HOST_WIDE_INT, int, rtx,
-				       machine_mode, machine_mode, bool, bool);
+				       machine_mode, machine_mode,
+				       scalar_int_mode, bool, bool);
+static rtx extract_and_convert_fixed_bit_field (scalar_int_mode,
+						machine_mode, machine_mode,
+						rtx, opt_scalar_int_mode,
+						unsigned HOST_WIDE_INT,
+						unsigned HOST_WIDE_INT, rtx,
+						int, bool);
 static rtx extract_fixed_bit_field (machine_mode, rtx, opt_scalar_int_mode,
 				    unsigned HOST_WIDE_INT,
 				    unsigned HOST_WIDE_INT, rtx, int, bool);
@@ -1632,6 +1639,7 @@ extract_bit_field_1 (rtx str_rtx, poly_uint64 bitsize, poly_uint64 bitnum,
 {
   rtx op0 = str_rtx;
   machine_mode mode1;
+  scalar_int_mode int_tmode;
 
   if (tmode == VOIDmode)
     tmode = mode;
@@ -1853,10 +1861,46 @@ extract_bit_field_1 (rtx str_rtx, poly_uint64 bitsize, poly_uint64 bitnum,
   /* It's possible we'll need to handle other cases here for
      polynomial bitnum and bitsize.  */
 
+  /* Make sure we are playing with integral modes.  Pun with subregs
+     if we aren't. When tmode is HFmode, op0 is SImode, there will be ICE
+     in extract_integral_bit_field.  */
+  opt_scalar_int_mode target_imode = int_mode_for_mode (tmode);
+  if (!target_imode.exists (&int_tmode) || int_tmode != tmode)
+    {
+      if (target_imode.exists (&int_tmode))
+	{
+	  rtx ret = extract_integral_bit_field (op0, op0_mode,
+						bitsize.to_constant (),
+						bitnum.to_constant (),
+						unsignedp, NULL, int_tmode,
+						int_tmode, int_tmode,
+						reverse, fallback_p);
+	  gcc_assert (ret);
+
+	  if (!REG_P (ret))
+	    ret = force_reg (int_tmode, ret);
+	  return gen_lowpart_SUBREG (tmode, ret);
+	}
+      else
+	{
+	  if (!fallback_p)
+	    return NULL;
+
+	  int_tmode = int_mode_for_mode (mode).require ();
+	  return extract_and_convert_fixed_bit_field (int_tmode, tmode, mode,
+						      op0, op0_mode,
+						      bitsize.to_constant (),
+						      bitnum.to_constant (),
+						      target, unsignedp,
+						      reverse);
+	}
+    }
+
   /* From here on we need to be looking at a fixed-size insertion.  */
   return extract_integral_bit_field (op0, op0_mode, bitsize.to_constant (),
 				     bitnum.to_constant (), unsignedp,
-				     target, mode, tmode, reverse, fallback_p);
+				     target, mode, tmode,
+				     int_tmode, reverse, fallback_p);
 }
 
 /* Subroutine of extract_bit_field_1, with the same arguments, except
@@ -1869,6 +1913,7 @@ extract_integral_bit_field (rtx op0, opt_scalar_int_mode op0_mode,
 			    unsigned HOST_WIDE_INT bitsize,
 			    unsigned HOST_WIDE_INT bitnum, int unsignedp,
 			    rtx target, machine_mode mode, machine_mode tmode,
+			    scalar_int_mode int_tmode,
 			    bool reverse, bool fallback_p)
 {
   /* Handle fields bigger than a word.  */
@@ -2035,29 +2080,10 @@ extract_integral_bit_field (rtx op0, opt_scalar_int_mode op0_mode,
   if (!fallback_p)
     return NULL;
 
-  /* Find a correspondingly-sized integer field, so we can apply
-     shifts and masks to it.  */
-  scalar_int_mode int_mode;
-  if (!int_mode_for_mode (tmode).exists (&int_mode))
-    /* If this fails, we should probably push op0 out to memory and then
-       do a load.  */
-    int_mode = int_mode_for_mode (mode).require ();
-
-  target = extract_fixed_bit_field (int_mode, op0, op0_mode, bitsize,
-				    bitnum, target, unsignedp, reverse);
-
-  /* Complex values must be reversed piecewise, so we need to undo the global
-     reversal, convert to the complex mode and reverse again.  */
-  if (reverse && COMPLEX_MODE_P (tmode))
-    {
-      target = flip_storage_order (int_mode, target);
-      target = convert_extracted_bit_field (target, mode, tmode, unsignedp);
-      target = flip_storage_order (tmode, target);
-    }
-  else
-    target = convert_extracted_bit_field (target, mode, tmode, unsignedp);
-
-  return target;
+  return extract_and_convert_fixed_bit_field (int_tmode, tmode, mode,
+					      op0, op0_mode, bitsize,
+					      bitnum, target, unsignedp,
+					      reverse);
 }
 
 /* Generate code to extract a byte-field from STR_RTX
@@ -2129,6 +2155,33 @@ extract_bit_field (rtx str_rtx, poly_uint64 bitsize, poly_uint64 bitnum,
   return extract_bit_field_1 (str_rtx, bitsize, bitnum, unsignedp,
 			      target, mode, tmode, reverse, true, alt_rtl);
 }
+
+/* Combination of extract_fixed_bit_field and convert_extracted_bit_field.  */
+static rtx
+extract_and_convert_fixed_bit_field (scalar_int_mode int_tmode,
+				     machine_mode tmode, machine_mode mode,
+				     rtx op0, opt_scalar_int_mode op0_mode,
+				     unsigned HOST_WIDE_INT bitsize,
+				     unsigned HOST_WIDE_INT bitnum,
+				     rtx target, int unsignedp, bool reverse)
+{
+  target = extract_fixed_bit_field (int_tmode, op0, op0_mode, bitsize,
+				    bitnum, target, unsignedp, reverse);
+
+  /* Complex values must be reversed piecewise, so we need to undo the global
+     reversal, convert to the complex mode and reverse again.  */
+  if (reverse && COMPLEX_MODE_P (tmode))
+    {
+      target = flip_storage_order (int_tmode, target);
+      target = convert_extracted_bit_field (target, mode, tmode, unsignedp);
+      target = flip_storage_order (tmode, target);
+    }
+  else
+    target = convert_extracted_bit_field (target, mode, tmode, unsignedp);
+
+  return target;
+}
+
 \f
 /* Use shifts and boolean operations to extract a field of BITSIZE bits
    from bit BITNUM of OP0.  If OP0_MODE is defined, it is the mode of OP0,