[gcc(refs/users/meissner/heads/work072)] Revert patch.

[Michael Meissner <meissner@gcc.gnu.org>]

https://gcc.gnu.org/g:a2de180d446eb80aee5675869fffbc499cc05bc9

commit a2de180d446eb80aee5675869fffbc499cc05bc9
Author: Michael Meissner <meissner@linux.ibm.com>
Date:   Tue Nov 2 22:56:02 2021 -0400

    Revert patch.
    
    2021-11-02  Michael Meissner  <meissner@the-meissners.org>
    
    gcc/
    
            Revert patch.
            * config/rs6000/rs6000-protos.h (VECTOR_128BIT_*): New macros.
            (vec_const_128bit_type): New structure type.
            (vec_const_128bit_to_bytes): New declaration.
            * config/rs6000/rs6000.c (constant_int_to_128bit_vector): New
            helper function.
            (constant_fp_to_128bit_vector): New helper function.
            (vec_const_128bit_to_bytes): New function.

Diff:
---
 gcc/config/rs6000/rs6000-protos.h |  28 -----
 gcc/config/rs6000/rs6000.c        | 254 --------------------------------------
 2 files changed, 282 deletions(-)

diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h
index 87003f14b44..14f6b313105 100644
--- a/gcc/config/rs6000/rs6000-protos.h
+++ b/gcc/config/rs6000/rs6000-protos.h
@@ -222,34 +222,6 @@ address_is_prefixed (rtx addr,
   return (iform == INSN_FORM_PREFIXED_NUMERIC
 	  || iform == INSN_FORM_PCREL_LOCAL);
 }
-
-/* Functions and data structures relating to 128-bit constants that are
-   converted to byte, half-word, word, and double-word values.  All fields are
-   kept in big endian order.  We also convert scalar values to 128-bits if they
-   are going to be loaded into vector registers.  */
-#define VECTOR_128BIT_BITS		128
-#define VECTOR_128BIT_BYTES		(128 / 8)
-#define VECTOR_128BIT_HALF_WORDS	(128 / 16)
-#define VECTOR_128BIT_WORDS		(128 / 32)
-#define VECTOR_128BIT_DOUBLE_WORDS	(128 / 64)
-
-typedef struct {
-  /* Constant as various sized items.  */
-  unsigned HOST_WIDE_INT double_words[VECTOR_128BIT_DOUBLE_WORDS];
-  unsigned int words[VECTOR_128BIT_WORDS];
-  unsigned short half_words[VECTOR_128BIT_HALF_WORDS];
-  unsigned char bytes[VECTOR_128BIT_BYTES];
-
-  unsigned original_size;		/* Constant size before splat.  */
-  bool fp_constant_p;			/* Is the constant floating point?  */
-  bool all_double_words_same;		/* Are the double words all equal?  */
-  bool all_words_same;			/* Are the words all equal?  */
-  bool all_half_words_same;		/* Are the halft words all equal?  */
-  bool all_bytes_same;			/* Are the bytes all equal?  */
-} vec_const_128bit_type;
-
-extern  bool vec_const_128bit_to_bytes (rtx, machine_mode,
-					vec_const_128bit_type *);
 #endif /* RTX_CODE */
 
 #ifdef TREE_CODE
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 0288253d7e9..01affc7a47c 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -28619,260 +28619,6 @@ rs6000_output_addr_vec_elt (FILE *file, int value)
   fprintf (file, "\n");
 }
 
-\f
-/* Copy an integer constant to the vector constant structure.  */
-
-static void
-constant_int_to_128bit_vector (rtx op,
-			       machine_mode mode,
-			       size_t byte_num,
-			       vec_const_128bit_type *info)
-{
-  unsigned HOST_WIDE_INT uvalue = UINTVAL (op);
-  unsigned bitsize = GET_MODE_BITSIZE (mode);
-
-  for (int shift = bitsize - 8; shift >= 0; shift -= 8)
-    info->bytes[byte_num++] = (uvalue >> shift) & 0xff;
-}
-
-/* Copy an floating point constant to the vector constant structure.  */
-
-static void
-constant_fp_to_128bit_vector (rtx op,
-			      machine_mode mode,
-			      size_t byte_num,
-			      vec_const_128bit_type *info)
-{
-  unsigned bitsize = GET_MODE_BITSIZE (mode);
-  unsigned num_words = bitsize / 32;
-  const REAL_VALUE_TYPE *rtype = CONST_DOUBLE_REAL_VALUE (op);
-  long real_words[VECTOR_128BIT_WORDS];
-
-  /* Make sure we don't overflow the real_words array and that it is
-     filled completely.  */
-  gcc_assert (num_words <= VECTOR_128BIT_WORDS && (bitsize % 32) == 0);
-
-  real_to_target (real_words, rtype, mode);
-
-  /* Iterate over each 32-bit word in the floating point constant.  The
-     real_to_target function puts out words in endian fashion.  We need
-     to arrange so the words are written in big endian order.  */
-  for (unsigned num = 0; num < num_words; num++)
-    {
-      unsigned endian_num = (BYTES_BIG_ENDIAN
-			     ? num
-			     : num_words - 1 - num);
-
-      unsigned uvalue = real_words[endian_num];
-      for (int shift = 32 - 8; shift >= 0; shift -= 8)
-	info->bytes[byte_num++] = (uvalue >> shift) & 0xff;
-    }
-
-  /* Mark that this constant involves floating point.  */
-  info->fp_constant_p = true;
-}
-
-/* Convert a vector constant OP with mode MODE to a vector 128-bit constant
-   structure INFO.
-
-   Break out the constant out to bytes, half words, words, and double words.
-   Return true if we have successfully broken out a constant.
-
-   We handle CONST_INT, CONST_DOUBLE, CONST_VECTOR, and VEC_DUPLICATE of
-   constants.  Integer and floating point scalar constants are splatted to fill
-   out the vector.  */
-
-bool
-vec_const_128bit_to_bytes (rtx op,
-			   machine_mode mode,
-			   vec_const_128bit_type *info)
-{
-  /* Initialize the constant structure.  */
-  memset ((void *)info, 0, sizeof (vec_const_128bit_type));
-
-  /* Assume CONST_INTs are DImode.  */
-  if (mode == VOIDmode)
-    mode = CONST_INT_P (op) ? DImode : GET_MODE (op);
-
-  if (mode == VOIDmode)
-    return false;
-
-  unsigned size = GET_MODE_SIZE (mode);
-  bool splat_p = false;
-
-  if (size > VECTOR_128BIT_BYTES)
-    return false;
-
-  /* Set up the bits.  */
-  switch (GET_CODE (op))
-    {
-      /* Integer constants, default to double word.  */
-    case CONST_INT:
-      {
-	constant_int_to_128bit_vector (op, mode, 0, info);
-	splat_p = true;
-	break;
-      }
-
-      /* Floating point constants.  */
-    case CONST_DOUBLE:
-      {
-	/* Fail if the floating point constant is the wrong mode.  */
-	if (GET_MODE (op) != mode)
-	  return false;
-
-	/* SFmode stored as scalars are stored in DFmode format.  */
-	if (mode == SFmode)
-	  {
-	    mode = DFmode;
-	    size = GET_MODE_SIZE (DFmode);
-	  }
-
-	constant_fp_to_128bit_vector (op, mode, 0, info);
-	splat_p = true;
-	break;
-      }
-
-      /* Vector constants, iterate over each element.  On little endian
-	 systems, we have to reverse the element numbers.  */
-    case CONST_VECTOR:
-      {
-	/* Fail if the vector constant is the wrong mode or size.  */
-	if (GET_MODE (op) != mode
-	    || GET_MODE_SIZE (mode) != VECTOR_128BIT_BYTES)
-	  return false;
-
-	machine_mode ele_mode = GET_MODE_INNER (mode);
-	size_t ele_size = GET_MODE_SIZE (ele_mode);
-	size_t nunits = GET_MODE_NUNITS (mode);
-
-	for (size_t num = 0; num < nunits; num++)
-	  {
-	    rtx ele = CONST_VECTOR_ELT (op, num);
-	    size_t byte_num = (BYTES_BIG_ENDIAN
-			       ? num
-			       : nunits - 1 - num) * ele_size;
-
-	    if (CONST_INT_P (ele))
-	      constant_int_to_128bit_vector (ele, ele_mode, byte_num, info);
-	    else if (CONST_DOUBLE_P (ele))
-	      constant_fp_to_128bit_vector (ele, ele_mode, byte_num, info);
-	    else
-	      return false;
-	  }
-
-	break;
-      }
-
-	/* Treat VEC_DUPLICATE of a constant just like a vector constant.
-	   Since we are duplicating the element, we don't have to worry about
-	   endian issues.  */
-    case VEC_DUPLICATE:
-      {
-	/* Fail if the vector duplicate is the wrong mode or size.  */
-	if (GET_MODE (op) != mode
-	    || GET_MODE_SIZE (mode) != VECTOR_128BIT_BYTES)
-	  return false;
-
-	machine_mode ele_mode = GET_MODE_INNER (mode);
-	size_t ele_size = GET_MODE_SIZE (ele_mode);
-	rtx ele = XEXP (op, 0);
-	size_t nunits = GET_MODE_NUNITS (mode);
-
-	if (!CONST_INT_P (ele) && !CONST_DOUBLE_P (ele))
-	  return false;
-
-	for (size_t num = 0; num < nunits; num++)
-	  {
-	    size_t byte_num = num * ele_size;
-
-	    if (CONST_INT_P (ele))
-	      constant_int_to_128bit_vector (ele, ele_mode, byte_num, info);
-	    else
-	      constant_fp_to_128bit_vector (ele, ele_mode, byte_num, info);
-	  }
-
-	break;
-      }
-
-      /* Any thing else, just return failure.  */
-    default:
-      return false;
-    }
-
-  /* Possibly splat the constant to fill a vector size.  */
-  if (splat_p && size < VECTOR_128BIT_BYTES)
-    {
-      if ((VECTOR_128BIT_BYTES % size) != 0)
-	return false;
-
-      for (size_t offset = size;
-	   offset < VECTOR_128BIT_BYTES;
-	   offset += size)
-	memcpy ((void *) &info->bytes[offset],
-		(void *) &info->bytes[0],
-		size);
-    }
-
-  /* Remember original size.  */
-  info->original_size = size;
-
-  /* Determine if the bytes are all the same.  */
-  unsigned char first_byte = info->bytes[0];
-  info->all_bytes_same = true;
-  for (size_t i = 1; i < VECTOR_128BIT_BYTES; i++)
-    if (first_byte != info->bytes[i])
-      {
-	info->all_bytes_same = false;
-	break;
-      }
-
-  /* Pack half words together & determine if all of the half words are the
-     same.  */
-  for (size_t i = 0; i < VECTOR_128BIT_HALF_WORDS; i++)
-    info->half_words[i] = ((info->bytes[i * 2] << 8)
-			   | info->bytes[(i * 2) + 1]);
-
-  unsigned short first_hword = info->half_words[0];
-  info->all_half_words_same = true;
-  for (size_t i = 1; i < VECTOR_128BIT_HALF_WORDS; i++)
-    if (first_hword != info->half_words[i])
-      {
-	info->all_half_words_same = false;
-	break;
-      }
-
-  /* Pack words together & determine if all of the words are the same.  */
-  for (size_t i = 0; i < VECTOR_128BIT_WORDS; i++)
-    info->words[i] = ((info->bytes[i * 4] << 24)
-		      | (info->bytes[(i * 4) + 1] << 16)
-		      | (info->bytes[(i * 4) + 2] << 8)
-		      | info->bytes[(i * 4) + 3]);
-
-  info->all_words_same
-    = (info->words[0] == info->words[1]
-       && info->words[0] == info->words[1]
-       && info->words[0] == info->words[2]
-       && info->words[0] == info->words[3]);
-
-  /* Pack double words together & determine if all of the double words are the
-     same.  */
-  for (size_t i = 0; i < VECTOR_128BIT_DOUBLE_WORDS; i++)
-    {
-      unsigned HOST_WIDE_INT d_word = 0;
-      for (size_t j = 0; j < 8; j++)
-	d_word = (d_word << 8) | info->bytes[(i * 8) + j];
-
-      info->double_words[i] = d_word;
-    }
-
-  info->all_double_words_same
-    = (info->double_words[0] == info->double_words[1]);
-
-  return true;
-}
-
-\f
 struct gcc_target targetm = TARGET_INITIALIZER;
 
 #include "gt-rs6000.h"