Simplify the implementation of HARD_REG_SET

We have two styles of HARD_REG_SET: a single integer based on
HOST_WIDEST_FAST_INT (used when FIRST_PSEUDO_REGISTER is small enough)
or an array of integers.  One of the nice properties of this arrangement
is that:

  void foo (const HARD_REG_SET);

is passed by value as an integer when the set is small enough and
by reference otherwise.

(This is in constrast to "const HARD_REG_SET &", which would always
be passed by reference, and in contrast to passing a structure wrapper
like "struct s { T elts[1]; }" by value, where the structure might be
passed like a T or by reference, depending on the ABI.)

However, one of the disadvantages of using an array is that simple
assignment doesn't work.  We need to use COPY_HARD_REG_SET instead.

This patch uses a structure wrapper around the array, and preserves
the above "nice property" using a new const_hard_reg_set typedef.
The patch also removes the manual unrolling for small array sizes;
I think these days we can rely on the compiler to do that for us.

This meant fixing two port-specific quirks:

- epiphany passed NULL as a HARD_REG_SET whose value doesn't matter.
  The patch passes the NO_REGS set instead.

- ia64 reused TEST_HARD_REG_BIT and SET_HARD_REG_BIT for arrays that
  are bigger than HARD_REG_SET.  The patch just open-codes them.

The patch is probably being too conservative.  Very few places actually
take advantage of the "nice property" above, and we could have a
cleaner interface if we used a structure wrapper for all cases.

2019-09-09  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* hard-reg-set.h (HARD_REG_SET): Define using a typedef rather
	than a #define.  Use a structure rather than an array as the
	fallback definition.  Remove special cases for low array sizes.
	(const_hard_reg_set): New typedef.
	(hard_reg_set_subset_p): Use it instead of "const HARD_REG_SET".
	(hard_reg_set_equal_p, hard_reg_set_intersect_p): Likewise.
	(hard_reg_set_empty_p): Likewise.
	(SET_HARD_REG_BIT): Use a function rather than a macro to
	handle the case in which HARD_REG_SET is a structure.
	(CLEAR_HARD_REG_BIT, TEST_HARD_REG_BIT, CLEAR_HARD_REG_SET)
	(SET_HARD_REG_SET, COPY_HARD_REG_SET, COMPL_HARD_REG_SET)
	(AND_HARD_REG_SET, AND_COMPL_HARD_REG_SET, IOR_HARD_REG_SET)
	(IOR_COMPL_HARD_REG_SET): Likewise.
	(hard_reg_set_iterator::pset): Constify the pointer target.
	(hard_reg_set_iter_init): Take a const_hard_reg_set instead
	of a "const HARD_REG_SET".  Update the handling of non-integer
	HARD_REG_SETs.
	* recog.h: Test HARD_CONST instead of CLEAR_HARD_REG_SET.
	* reload.h: Likewise.
	* rtl.h (choose_hard_reg_mode): Remove unnecessary line break.
	* regs.h (in_hard_reg_set_p): Take a const_hard_reg_set instead
	of a "const HARD_REG_SET".
	(overlaps_hard_reg_set_p, range_overlaps_hard_reg_set_p): Likewise.
	(range_in_hard_reg_set_p): Likewise.
	* ira-costs.c (restrict_cost_classes): Likewise.
	* shrink-wrap.c (move_insn_for_shrink_wrap): Likewise.
	* config/epiphany/resolve-sw-modes.c (pass_resolve_sw_modes::execute):
	Pass a NO_REGS HARD_REG_SET rather than NULL to emit_set_fp_mode.
	* config/ia64/ia64.c (rws_insn): In the CHECKING_P version,
	use unsigned HOST_WIDEST_FAST_INT rather than HARD_REG_ELT_TYPE.
	(rws_insn_set, rws_insn_test): In the CHECKING_P version,
	take an unsigned int and open-code the HARD_REG_SET operations.

From-SVN: r275526

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f640d89ac3e6dd9c8ed9d543331b29e422233830..482a50ffc0816205f2b928a0679ea5bb95cf726a 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,38 @@
+2019-09-09  Richard Sandiford  <richard.sandiford@arm.com>
+
+       * hard-reg-set.h (HARD_REG_SET): Define using a typedef rather
+       than a #define.  Use a structure rather than an array as the
+       fallback definition.  Remove special cases for low array sizes.
+       (const_hard_reg_set): New typedef.
+       (hard_reg_set_subset_p): Use it instead of "const HARD_REG_SET".
+       (hard_reg_set_equal_p, hard_reg_set_intersect_p): Likewise.
+       (hard_reg_set_empty_p): Likewise.
+       (SET_HARD_REG_BIT): Use a function rather than a macro to
+       handle the case in which HARD_REG_SET is a structure.
+       (CLEAR_HARD_REG_BIT, TEST_HARD_REG_BIT, CLEAR_HARD_REG_SET)
+       (SET_HARD_REG_SET, COPY_HARD_REG_SET, COMPL_HARD_REG_SET)
+       (AND_HARD_REG_SET, AND_COMPL_HARD_REG_SET, IOR_HARD_REG_SET)
+       (IOR_COMPL_HARD_REG_SET): Likewise.
+       (hard_reg_set_iterator::pset): Constify the pointer target.
+       (hard_reg_set_iter_init): Take a const_hard_reg_set instead
+       of a "const HARD_REG_SET".  Update the handling of non-integer
+       HARD_REG_SETs.
+       * recog.h: Test HARD_CONST instead of CLEAR_HARD_REG_SET.
+       * reload.h: Likewise.
+       * rtl.h (choose_hard_reg_mode): Remove unnecessary line break.
+       * regs.h (in_hard_reg_set_p): Take a const_hard_reg_set instead
+       of a "const HARD_REG_SET".
+       (overlaps_hard_reg_set_p, range_overlaps_hard_reg_set_p): Likewise.
+       (range_in_hard_reg_set_p): Likewise.
+       * ira-costs.c (restrict_cost_classes): Likewise.
+       * shrink-wrap.c (move_insn_for_shrink_wrap): Likewise.
+       * config/epiphany/resolve-sw-modes.c (pass_resolve_sw_modes::execute):
+       Pass a NO_REGS HARD_REG_SET rather than NULL to emit_set_fp_mode.
+       * config/ia64/ia64.c (rws_insn): In the CHECKING_P version,
+       use unsigned HOST_WIDEST_FAST_INT rather than HARD_REG_ELT_TYPE.
+       (rws_insn_set, rws_insn_test): In the CHECKING_P version,
+       take an unsigned int and open-code the HARD_REG_SET operations.
+
 2019-09-09  Richard Sandiford  <richard.sandiford@arm.com>
 
        * Makefile.in (OBJS): Remove bt-load.o.

diff --git a/gcc/config/epiphany/resolve-sw-modes.c b/gcc/config/epiphany/resolve-sw-modes.c
index c1d343bf01259fc8c9ed65de2d27ad225d46ccdd..9ecdf6301bc3aafc03db55d074887e7ecb47c3ec 100644 (file)
--- a/gcc/config/epiphany/resolve-sw-modes.c
+++ b/gcc/config/epiphany/resolve-sw-modes.c
@@ -167,7 +167,8 @@ pass_resolve_sw_modes::execute (function *fun)
            }
          start_sequence ();
          emit_set_fp_mode (EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN,
-                           jilted_mode, FP_MODE_NONE, NULL);
+                           jilted_mode, FP_MODE_NONE,
+                           reg_class_contents[NO_REGS]);
          seq = get_insns ();
          end_sequence ();
          need_commit = true;

diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c
index bfec69b7446efc91b61a17452769cc3c31ea7cc0..3768c8b5e5470a074784f0e3d4b5e52f34735cda 100644 (file)
--- a/gcc/config/ia64/ia64.c
+++ b/gcc/config/ia64/ia64.c
@@ -6230,20 +6230,25 @@ struct reg_write_state
 struct reg_write_state rws_sum[NUM_REGS];
 #if CHECKING_P
 /* Bitmap whether a register has been written in the current insn.  */
-HARD_REG_ELT_TYPE rws_insn[(NUM_REGS + HOST_BITS_PER_WIDEST_FAST_INT - 1)
-                          / HOST_BITS_PER_WIDEST_FAST_INT];
+unsigned HOST_WIDEST_FAST_INT rws_insn
+  [(NUM_REGS + HOST_BITS_PER_WIDEST_FAST_INT - 1)
+   / HOST_BITS_PER_WIDEST_FAST_INT];
 
 static inline void
-rws_insn_set (int regno)
+rws_insn_set (unsigned int regno)
 {
-  gcc_assert (!TEST_HARD_REG_BIT (rws_insn, regno));
-  SET_HARD_REG_BIT (rws_insn, regno);
+  unsigned int elt = regno / HOST_BITS_PER_WIDEST_FAST_INT;
+  unsigned int bit = regno % HOST_BITS_PER_WIDEST_FAST_INT;
+  gcc_assert (!((rws_insn[elt] >> bit) & 1));
+  rws_insn[elt] |= (unsigned HOST_WIDEST_FAST_INT) 1 << bit;
 }
 
 static inline int
-rws_insn_test (int regno)
+rws_insn_test (unsigned int regno)
 {
-  return TEST_HARD_REG_BIT (rws_insn, regno);
+  unsigned int elt = regno / HOST_BITS_PER_WIDEST_FAST_INT;
+  unsigned int bit = regno % HOST_BITS_PER_WIDEST_FAST_INT;
+  return (rws_insn[elt] >> bit) & 1;
 }
 #else
 /* When not checking, track just REG_AR_CFM and REG_VOLATILE.  */

diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h
index bd4249b5a1765b607a1efc6c125778863f5ba6ce..32626bab379a6e7670178fd506bd88f3867fef74 100644 (file)
--- a/gcc/hard-reg-set.h
+++ b/gcc/hard-reg-set.h
@@ -42,14 +42,20 @@ typedef unsigned HOST_WIDEST_FAST_INT HARD_REG_ELT_TYPE;
 
 #if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
 
-#define HARD_REG_SET HARD_REG_ELT_TYPE
+typedef HARD_REG_ELT_TYPE HARD_REG_SET;
+typedef const HARD_REG_SET const_hard_reg_set;
 
 #else
 
 #define HARD_REG_SET_LONGS \
  ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDEST_FAST_INT - 1)  \
   / HOST_BITS_PER_WIDEST_FAST_INT)
-typedef HARD_REG_ELT_TYPE HARD_REG_SET[HARD_REG_SET_LONGS];
+
+struct HARD_REG_SET
+{
+  HARD_REG_ELT_TYPE elts[HARD_REG_SET_LONGS];
+};
+typedef const HARD_REG_SET &const_hard_reg_set;
 
 #endif
 
@@ -98,7 +104,7 @@ struct hard_reg_set_container
 
 #define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT)
 
-#ifdef HARD_REG_SET
+#if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
 
 #define SET_HARD_REG_BIT(SET, BIT)  \
  ((SET) |= HARD_CONST (1) << (BIT))
@@ -119,395 +125,142 @@ struct hard_reg_set_container
 #define AND_COMPL_HARD_REG_SET(TO, FROM) ((TO) &= ~ (FROM))
 
 static inline bool
-hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
+hard_reg_set_subset_p (const_hard_reg_set x, const_hard_reg_set y)
 {
   return (x & ~y) == HARD_CONST (0);
 }
 
 static inline bool
-hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
+hard_reg_set_equal_p (const_hard_reg_set x, const_hard_reg_set y)
 {
   return x == y;
 }
 
 static inline bool
-hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
+hard_reg_set_intersect_p (const_hard_reg_set x, const_hard_reg_set y)
 {
   return (x & y) != HARD_CONST (0);
 }
 
 static inline bool
-hard_reg_set_empty_p (const HARD_REG_SET x)
+hard_reg_set_empty_p (const_hard_reg_set x)
 {
   return x == HARD_CONST (0);
 }
 
 #else
 
-#define SET_HARD_REG_BIT(SET, BIT)             \
-  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]      \
-   |= HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))
-
-#define CLEAR_HARD_REG_BIT(SET, BIT)           \
-  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]      \
-   &= ~(HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)))
-
-#define TEST_HARD_REG_BIT(SET, BIT)            \
-  (!!((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]   \
-      & (HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))))
-
-#if FIRST_PSEUDO_REGISTER <= 2*HOST_BITS_PER_WIDEST_FAST_INT
-#define CLEAR_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     scan_tp_[0] = 0;                                          \
-     scan_tp_[1] = 0; } while (0)
-
-#define SET_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     scan_tp_[0] = -1;                                         \
-     scan_tp_[1] = -1; } while (0)
-
-#define COPY_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] = scan_fp_[0];                                        \
-     scan_tp_[1] = scan_fp_[1]; } while (0)
-
-#define COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] = ~ scan_fp_[0];                              \
-     scan_tp_[1] = ~ scan_fp_[1]; } while (0)
-
-#define AND_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] &= scan_fp_[0];                               \
-     scan_tp_[1] &= scan_fp_[1]; } while (0)
-
-#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] &= ~ scan_fp_[0];                             \
-     scan_tp_[1] &= ~ scan_fp_[1]; } while (0)
-
-#define IOR_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] |= scan_fp_[0];                               \
-     scan_tp_[1] |= scan_fp_[1]; } while (0)
-
-#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] |= ~ scan_fp_[0];                             \
-     scan_tp_[1] |= ~ scan_fp_[1]; } while (0)
-
-static inline bool
-hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+SET_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
 {
-  return (x[0] & ~y[0]) == 0 && (x[1] & ~y[1]) == 0;
+  set.elts[bit / UHOST_BITS_PER_WIDE_INT]
+    |= HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT);
 }
 
-static inline bool
-hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+CLEAR_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
 {
-  return x[0] == y[0] && x[1] == y[1];
+  set.elts[bit / UHOST_BITS_PER_WIDE_INT]
+    &= ~(HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT));
 }
 
-static inline bool
-hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline bool
+TEST_HARD_REG_BIT (const_hard_reg_set set, unsigned int bit)
 {
-  return (x[0] & y[0]) != 0 || (x[1] & y[1]) != 0;
+  return (set.elts[bit / UHOST_BITS_PER_WIDE_INT]
+         & (HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT)));
 }
 
-static inline bool
-hard_reg_set_empty_p (const HARD_REG_SET x)
+inline void
+CLEAR_HARD_REG_SET (HARD_REG_SET &set)
 {
-  return x[0] == 0 && x[1] == 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
+    set.elts[i] = 0;
 }
 
-#else
-#if FIRST_PSEUDO_REGISTER <= 3*HOST_BITS_PER_WIDEST_FAST_INT
-#define CLEAR_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     scan_tp_[0] = 0;                                          \
-     scan_tp_[1] = 0;                                          \
-     scan_tp_[2] = 0; } while (0)
-
-#define SET_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     scan_tp_[0] = -1;                                         \
-     scan_tp_[1] = -1;                                         \
-     scan_tp_[2] = -1; } while (0)
-
-#define COPY_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] = scan_fp_[0];                                        \
-     scan_tp_[1] = scan_fp_[1];                                        \
-     scan_tp_[2] = scan_fp_[2]; } while (0)
-
-#define COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] = ~ scan_fp_[0];                              \
-     scan_tp_[1] = ~ scan_fp_[1];                              \
-     scan_tp_[2] = ~ scan_fp_[2]; } while (0)
-
-#define AND_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] &= scan_fp_[0];                               \
-     scan_tp_[1] &= scan_fp_[1];                               \
-     scan_tp_[2] &= scan_fp_[2]; } while (0)
-
-#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] &= ~ scan_fp_[0];                             \
-     scan_tp_[1] &= ~ scan_fp_[1];                             \
-     scan_tp_[2] &= ~ scan_fp_[2]; } while (0)
-
-#define IOR_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] |= scan_fp_[0];                               \
-     scan_tp_[1] |= scan_fp_[1];                               \
-     scan_tp_[2] |= scan_fp_[2]; } while (0)
-
-#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] |= ~ scan_fp_[0];                             \
-     scan_tp_[1] |= ~ scan_fp_[1];                             \
-     scan_tp_[2] |= ~ scan_fp_[2]; } while (0)
-
-static inline bool
-hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+SET_HARD_REG_SET (HARD_REG_SET &set)
 {
-  return ((x[0] & ~y[0]) == 0
-         && (x[1] & ~y[1]) == 0
-         && (x[2] & ~y[2]) == 0);
+  for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
+    set.elts[i] = -1;
 }
 
-static inline bool
-hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+COPY_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
 {
-  return x[0] == y[0] && x[1] == y[1] && x[2] == y[2];
+  to = from;
 }
 
-static inline bool
-hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
 {
-  return ((x[0] & y[0]) != 0
-         || (x[1] & y[1]) != 0
-         || (x[2] & y[2]) != 0);
+  for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
+    to.elts[i] = ~from.elts[i];
 }
 
-static inline bool
-hard_reg_set_empty_p (const HARD_REG_SET x)
+inline void
+AND_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
 {
-  return x[0] == 0 && x[1] == 0 && x[2] == 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
+    to.elts[i] &= from.elts[i];
 }
 
-#else
-#if FIRST_PSEUDO_REGISTER <= 4*HOST_BITS_PER_WIDEST_FAST_INT
-#define CLEAR_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     scan_tp_[0] = 0;                                          \
-     scan_tp_[1] = 0;                                          \
-     scan_tp_[2] = 0;                                          \
-     scan_tp_[3] = 0; } while (0)
-
-#define SET_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     scan_tp_[0] = -1;                                         \
-     scan_tp_[1] = -1;                                         \
-     scan_tp_[2] = -1;                                         \
-     scan_tp_[3] = -1; } while (0)
-
-#define COPY_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] = scan_fp_[0];                                        \
-     scan_tp_[1] = scan_fp_[1];                                        \
-     scan_tp_[2] = scan_fp_[2];                                        \
-     scan_tp_[3] = scan_fp_[3]; } while (0)
-
-#define COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] = ~ scan_fp_[0];                              \
-     scan_tp_[1] = ~ scan_fp_[1];                              \
-     scan_tp_[2] = ~ scan_fp_[2];                              \
-     scan_tp_[3] = ~ scan_fp_[3]; } while (0)
-
-#define AND_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] &= scan_fp_[0];                               \
-     scan_tp_[1] &= scan_fp_[1];                               \
-     scan_tp_[2] &= scan_fp_[2];                               \
-     scan_tp_[3] &= scan_fp_[3]; } while (0)
-
-#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] &= ~ scan_fp_[0];                             \
-     scan_tp_[1] &= ~ scan_fp_[1];                             \
-     scan_tp_[2] &= ~ scan_fp_[2];                             \
-     scan_tp_[3] &= ~ scan_fp_[3]; } while (0)
-
-#define IOR_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] |= scan_fp_[0];                               \
-     scan_tp_[1] |= scan_fp_[1];                               \
-     scan_tp_[2] |= scan_fp_[2];                               \
-     scan_tp_[3] |= scan_fp_[3]; } while (0)
-
-#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     scan_tp_[0] |= ~ scan_fp_[0];                             \
-     scan_tp_[1] |= ~ scan_fp_[1];                             \
-     scan_tp_[2] |= ~ scan_fp_[2];                             \
-     scan_tp_[3] |= ~ scan_fp_[3]; } while (0)
-
-static inline bool
-hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
-{
-  return ((x[0] & ~y[0]) == 0
-         && (x[1] & ~y[1]) == 0
-         && (x[2] & ~y[2]) == 0
-         && (x[3] & ~y[3]) == 0);
-}
-
-static inline bool
-hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+AND_COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
 {
-  return x[0] == y[0] && x[1] == y[1] && x[2] == y[2] && x[3] == y[3];
+  for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
+    to.elts[i] &= ~from.elts[i];
 }
 
-static inline bool
-hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
+inline void
+IOR_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
 {
-  return ((x[0] & y[0]) != 0
-         || (x[1] & y[1]) != 0
-         || (x[2] & y[2]) != 0
-         || (x[3] & y[3]) != 0);
+  for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
+    to.elts[i] |= from.elts[i];
 }
 
-static inline bool
-hard_reg_set_empty_p (const HARD_REG_SET x)
+inline void
+IOR_COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
 {
-  return x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
+    to.elts[i] |= ~from.elts[i];
 }
 
-#else /* FIRST_PSEUDO_REGISTER > 4*HOST_BITS_PER_WIDEST_FAST_INT */
-
-#define CLEAR_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ = 0; } while (0)
-
-#define SET_HARD_REG_SET(TO)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ = -1; } while (0)
-
-#define COPY_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ = *scan_fp_++; } while (0)
-
-#define COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ = ~ *scan_fp_++; } while (0)
-
-#define AND_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ &= *scan_fp_++; } while (0)
-
-#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ &= ~ *scan_fp_++; } while (0)
-
-#define IOR_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ |= *scan_fp_++; } while (0)
-
-#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
-do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                       \
-     const HARD_REG_ELT_TYPE *scan_fp_ = (FROM);               \
-     int i;                                                    \
-     for (i = 0; i < HARD_REG_SET_LONGS; i++)                  \
-       *scan_tp_++ |= ~ *scan_fp_++; } while (0)
-
 static inline bool
-hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
+hard_reg_set_subset_p (const_hard_reg_set x, const_hard_reg_set y)
 {
-  int i;
-
-  for (i = 0; i < HARD_REG_SET_LONGS; i++)
-    if ((x[i] & ~y[i]) != 0)
-      return false;
-  return true;
+  HARD_REG_ELT_TYPE bad = 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
+    bad |= (x.elts[i] & ~y.elts[i]);
+  return bad == 0;
 }
 
 static inline bool
-hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
+hard_reg_set_equal_p (const_hard_reg_set x, const_hard_reg_set y)
 {
-  int i;
-
-  for (i = 0; i < HARD_REG_SET_LONGS; i++)
-    if (x[i] != y[i])
-      return false;
-  return true;
+  HARD_REG_ELT_TYPE bad = 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
+    bad |= (x.elts[i] ^ y.elts[i]);
+  return bad == 0;
 }
 
 static inline bool
-hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
+hard_reg_set_intersect_p (const_hard_reg_set x, const_hard_reg_set y)
 {
-  int i;
-
-  for (i = 0; i < HARD_REG_SET_LONGS; i++)
-    if ((x[i] & y[i]) != 0)
-      return true;
-  return false;
+  HARD_REG_ELT_TYPE good = 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
+    good |= (x.elts[i] & y.elts[i]);
+  return good != 0;
 }
 
 static inline bool
-hard_reg_set_empty_p (const HARD_REG_SET x)
+hard_reg_set_empty_p (const_hard_reg_set x)
 {
-  int i;
-
-  for (i = 0; i < HARD_REG_SET_LONGS; i++)
-    if (x[i] != 0)
-      return false;
-  return true;
+  HARD_REG_ELT_TYPE bad = 0;
+  for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
+    bad |= x.elts[i];
+  return bad == 0;
 }
-
-#endif
-#endif
-#endif
 #endif
 
 /* Iterator for hard register sets.  */
@@ -515,7 +268,7 @@ hard_reg_set_empty_p (const HARD_REG_SET x)
 struct hard_reg_set_iterator
 {
   /* Pointer to the current element.  */
-  HARD_REG_ELT_TYPE *pelt;
+  const HARD_REG_ELT_TYPE *pelt;
 
   /* The length of the set.  */
   unsigned short length;
@@ -534,11 +287,11 @@ struct hard_reg_set_iterator
 /* The implementation of the iterator functions is fully analogous to
    the bitmap iterators.  */
 static inline void
-hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set,
+hard_reg_set_iter_init (hard_reg_set_iterator *iter, const_hard_reg_set set,
                         unsigned min, unsigned *regno)
 {
 #ifdef HARD_REG_SET_LONGS
-  iter->pelt = set;
+  iter->pelt = set.elts;
   iter->length = HARD_REG_SET_LONGS;
 #else
   iter->pelt = &set;

diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c
index c7feaba371838ddac64e2cf2d34b0fa9658add6e..3d81c90200525cc0a3cbe7596bfa8ae1f09c0424 100644 (file)
--- a/gcc/ira-costs.c
+++ b/gcc/ira-costs.c
@@ -237,7 +237,7 @@ setup_cost_classes (cost_classes_t from)
    allocated.  */
 static cost_classes_t
 restrict_cost_classes (cost_classes_t full, machine_mode mode,
-                      const HARD_REG_SET &regs)
+                      const_hard_reg_set regs)
 {
   static struct cost_classes narrow;
   int map[N_REG_CLASSES];

diff --git a/gcc/recog.h b/gcc/recog.h
index e09b27c5be1e22fc6e11b365d07101ea6de32832..71d88e3e376de813577e532d8cf727e374dbdace 100644 (file)
--- a/gcc/recog.h
+++ b/gcc/recog.h
@@ -142,7 +142,7 @@ extern void preprocess_constraints (rtx_insn *);
 extern rtx_insn *peep2_next_insn (int);
 extern int peep2_regno_dead_p (int, int);
 extern int peep2_reg_dead_p (int, rtx);
-#ifdef CLEAR_HARD_REG_SET
+#ifdef HARD_CONST
 extern rtx peep2_find_free_register (int, int, const char *,
                                     machine_mode, HARD_REG_SET *);
 #endif

diff --git a/gcc/regs.h b/gcc/regs.h
index 48b2e70816099281c015f2be1f249e8a36b861a8..4634abc7ece12706b9991eda0c257adeda839b56 100644 (file)
--- a/gcc/regs.h
+++ b/gcc/regs.h
@@ -298,7 +298,7 @@ remove_from_hard_reg_set (HARD_REG_SET *regs, machine_mode mode,
 /* Return true if REGS contains the whole of (reg:MODE REGNO).  */
 
 static inline bool
-in_hard_reg_set_p (const HARD_REG_SET regs, machine_mode mode,
+in_hard_reg_set_p (const_hard_reg_set regs, machine_mode mode,
                   unsigned int regno)
 {
   unsigned int end_regno;
@@ -323,7 +323,7 @@ in_hard_reg_set_p (const HARD_REG_SET regs, machine_mode mode,
 /* Return true if (reg:MODE REGNO) includes an element of REGS.  */
 
 static inline bool
-overlaps_hard_reg_set_p (const HARD_REG_SET regs, machine_mode mode,
+overlaps_hard_reg_set_p (const_hard_reg_set regs, machine_mode mode,
                         unsigned int regno)
 {
   unsigned int end_regno;
@@ -363,7 +363,7 @@ remove_range_from_hard_reg_set (HARD_REG_SET *regs, unsigned int regno,
 /* Like overlaps_hard_reg_set_p, but use a REGNO/NREGS range instead of
    REGNO and MODE.  */
 static inline bool
-range_overlaps_hard_reg_set_p (const HARD_REG_SET set, unsigned regno,
+range_overlaps_hard_reg_set_p (const_hard_reg_set set, unsigned regno,
                               int nregs)
 {
   while (nregs-- > 0)
@@ -375,7 +375,7 @@ range_overlaps_hard_reg_set_p (const HARD_REG_SET set, unsigned regno,
 /* Like in_hard_reg_set_p, but use a REGNO/NREGS range instead of
    REGNO and MODE.  */
 static inline bool
-range_in_hard_reg_set_p (const HARD_REG_SET set, unsigned regno, int nregs)
+range_in_hard_reg_set_p (const_hard_reg_set set, unsigned regno, int nregs)
 {
   while (nregs-- > 0)
     if (!TEST_HARD_REG_BIT (set, regno + nregs))

diff --git a/gcc/reload.h b/gcc/reload.h
index eb49771249838cb59b3d4d71f2ed27b0479595f2..86f0fff57f19fe8e145b3c4a03d1d66f1bffc13d 100644 (file)
--- a/gcc/reload.h
+++ b/gcc/reload.h
@@ -274,7 +274,7 @@ extern int reload_first_uid;
 
 extern int num_not_at_initial_offset;
 
-#if defined SET_HARD_REG_BIT && defined CLEAR_REG_SET
+#if defined HARD_CONST && defined CLEAR_REG_SET
 /* This structure describes instructions which are relevant for reload.
    Apart from all regular insns, this also includes CODE_LABELs, since they
    must be examined for register elimination.  */
@@ -326,7 +326,7 @@ extern class insn_chain *reload_insn_chain;
 extern class insn_chain *new_insn_chain (void);
 #endif
 
-#if defined SET_HARD_REG_BIT
+#if defined HARD_CONST
 extern void compute_use_by_pseudos (HARD_REG_SET *, bitmap);
 #endif
 

diff --git a/gcc/rtl.h b/gcc/rtl.h
index efb9b3ce40da66f0d02940e72b53c25e880c33fb..b9e1fe74a01d334922c641d2feb2f19fc1551066 100644 (file)
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -3377,8 +3377,7 @@ extern bool val_signbit_known_clear_p (machine_mode,
                                       unsigned HOST_WIDE_INT);
 
 /* In reginfo.c  */
-extern machine_mode choose_hard_reg_mode (unsigned int, unsigned int,
-                                              bool);
+extern machine_mode choose_hard_reg_mode (unsigned int, unsigned int, bool);
 extern const HARD_REG_SET &simplifiable_subregs (const subreg_shape &);
 
 /* In emit-rtl.c  */

diff --git a/gcc/shrink-wrap.c b/gcc/shrink-wrap.c
index 57124db92c662bf52efc7ea94c274d9b4e234d04..257422cd2a61cf0db59322a1291a6235e391ac8e 100644 (file)
--- a/gcc/shrink-wrap.c
+++ b/gcc/shrink-wrap.c
@@ -151,8 +151,8 @@ live_edge_for_reg (basic_block bb, int regno, int end_regno)
 
 static bool
 move_insn_for_shrink_wrap (basic_block bb, rtx_insn *insn,
-                          const HARD_REG_SET uses,
-                          const HARD_REG_SET defs,
+                          const_hard_reg_set uses,
+                          const_hard_reg_set defs,
                           bool *split_p,
                           struct dead_debug_local *debug)
 {