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

1 files changed, 79 insertions, 326 deletions

diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h
index bd4249b..32626ba 100644
--- 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;