public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/users/meissner/heads/work072)] Add new constant data structure.
@ 2021-11-03 1:02 Michael Meissner
0 siblings, 0 replies; 3+ messages in thread
From: Michael Meissner @ 2021-11-03 1:02 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:a71d28bc56456d903926506805b32ea9aff0f37e
commit a71d28bc56456d903926506805b32ea9aff0f37e
Author: Michael Meissner <meissner@linux.ibm.com>
Date: Tue Nov 2 21:02:21 2021 -0400
Add new constant data structure.
This patch provides the data structure and function to convert a
CONST_INT, CONST_DOUBLE, CONST_VECTOR, or VEC_DUPLICATE of a constant) to
an array of bytes, half-words, words, and double words that can be loaded
into a 128-bit vector register.
The next patches will use this data structure to generate code that
generates load of the vector/floating point registers using the XXSPLTIDP,
XXSPLTIW, and LXVKQ instructions that were added in power10.
2021-10-20 Michael Meissner <meissner@the-meissners.org>
gcc/
* config/rs6000/rs6000-protos.h (VECTOR_128BIT_*): New macros.
(constant_splat_type): New enum type.
(vector_128bit_constant_type): New structure type.
(constant_to_128bit_vector): New declaration.
* config/rs6000/rs6000.c (constant_int_to_128bit_vector): New
helper function.
(constant_to_128bit_vector): New helper function.
(constant_to_128bit_vector): New function.
Diff:
---
gcc/config/rs6000/rs6000-protos.h | 36 ++++++
gcc/config/rs6000/rs6000.c | 254 ++++++++++++++++++++++++++++++++++++++
2 files changed, 290 insertions(+)
diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h
index 14f6b313105..ec162c1fb6c 100644
--- a/gcc/config/rs6000/rs6000-protos.h
+++ b/gcc/config/rs6000/rs6000-protos.h
@@ -222,6 +222,42 @@ 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)
+
+/* If the constant is small, whether we will splat the constant to fill a
+ vector. */
+typedef enum {
+ CONSTANT_NO_SPLAT, /* Do not splat the constant. */
+ CONSTANT_SPLAT /* Splat to fill the constant. */
+} constant_splat_type;
+
+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? */
+} vector_128bit_constant_type;
+
+extern bool constant_to_128bit_vector (rtx, machine_mode,
+ vector_128bit_constant_type *,
+ constant_splat_type);
#endif /* RTX_CODE */
#ifdef TREE_CODE
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 01affc7a47c..32b0389fb28 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -28619,6 +28619,260 @@ 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,
+ vector_128bit_constant_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,
+ vector_128bit_constant_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 involes floating point. */
+ info->fp_constant_p = true;
+}
+
+/* Convert an RTL constant OP with mode MODE to a vector 128-bit constant
+ structure INFO. Possibly splat the constant to a larger size (SPLAT).
+
+ 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. */
+
+bool
+constant_to_128bit_vector (rtx op,
+ machine_mode mode,
+ vector_128bit_constant_type *info,
+ constant_splat_type splat)
+{
+ /* Initialize the constant structure. */
+ memset ((void *)info, 0, sizeof (vector_128bit_constant_type));
+
+ /* Assume plain integer constants 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);
+
+ 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);
+ 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);
+ 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 == CONSTANT_SPLAT)
+ {
+ 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);
+ }
+
+ else if (splat != CONSTANT_NO_SPLAT)
+ return false;
+
+ /* 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"
^ permalink raw reply [flat|nested] 3+ messages in thread
* [gcc(refs/users/meissner/heads/work072)] Add new constant data structure.
@ 2021-11-03 3:05 Michael Meissner
0 siblings, 0 replies; 3+ messages in thread
From: Michael Meissner @ 2021-11-03 3:05 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:3a73ac105143f92340e35115ae4aca64d63d5cd6
commit 3a73ac105143f92340e35115ae4aca64d63d5cd6
Author: Michael Meissner <meissner@linux.ibm.com>
Date: Tue Nov 2 23:05:24 2021 -0400
Add new constant data structure.
This patch provides the data structure and function to convert a
CONST_INT, CONST_DOUBLE, CONST_VECTOR, or VEC_DUPLICATE of a constant) to
an array of bytes, half-words, words, and double words that can be loaded
into a 128-bit vector register.
The next patches will use this data structure to generate code that
generates load of the vector/floating point registers using the XXSPLTIDP,
XXSPLTIW, and LXVKQ instructions that were added in power10.
2021-11-03 Michael Meissner <meissner@the-meissners.org>
gcc/
* 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 | 253 ++++++++++++++++++++++++++++++++++++++
2 files changed, 281 insertions(+)
diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h
index 14f6b313105..490d6e33736 100644
--- a/gcc/config/rs6000/rs6000-protos.h
+++ b/gcc/config/rs6000/rs6000-protos.h
@@ -222,6 +222,34 @@ 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 01affc7a47c..f285022294a 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -28619,6 +28619,259 @@ 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;
+}
+
struct gcc_target targetm = TARGET_INITIALIZER;
#include "gt-rs6000.h"
^ permalink raw reply [flat|nested] 3+ messages in thread
* [gcc(refs/users/meissner/heads/work072)] Add new constant data structure.
@ 2021-11-03 2:32 Michael Meissner
0 siblings, 0 replies; 3+ messages in thread
From: Michael Meissner @ 2021-11-03 2:32 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:2b0ac0798ae6b39d7bf42f72c1bfa4f6fe835d98
commit 2b0ac0798ae6b39d7bf42f72c1bfa4f6fe835d98
Author: Michael Meissner <meissner@linux.ibm.com>
Date: Tue Nov 2 22:31:55 2021 -0400
Add new constant data structure.
This patch provides the data structure and function to convert a
CONST_INT, CONST_DOUBLE, CONST_VECTOR, or VEC_DUPLICATE of a constant) to
an array of bytes, half-words, words, and double words that can be loaded
into a 128-bit vector register.
The next patches will use this data structure to generate code that
generates load of the vector/floating point registers using the XXSPLTIDP,
XXSPLTIW, and LXVKQ instructions that were added in power10.
2021-11-02 Michael Meissner <meissner@the-meissners.org>
gcc/
* 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 insertions(+)
diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h
index 14f6b313105..87003f14b44 100644
--- a/gcc/config/rs6000/rs6000-protos.h
+++ b/gcc/config/rs6000/rs6000-protos.h
@@ -222,6 +222,34 @@ 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 01affc7a47c..0288253d7e9 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -28619,6 +28619,260 @@ 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"
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2021-11-03 3:05 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-11-03 1:02 [gcc(refs/users/meissner/heads/work072)] Add new constant data structure Michael Meissner
2021-11-03 2:32 Michael Meissner
2021-11-03 3:05 Michael Meissner
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).