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

10 files changed, 139 insertions, 346 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f640d89..482a50f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,40 @@
 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.
 	* doc/invoke.texi (fbranch-target-load-optimize): Delete.
 	(fbranch-target-load-optimize2, fbtr-bb-exclusive): Likewise.
diff --git a/gcc/config/epiphany/resolve-sw-modes.c b/gcc/config/epiphany/resolve-sw-modes.c
index c1d343b..9ecdf63 100644
--- 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 bfec69b..3768c8b 100644
--- 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 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;
diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c
index c7feaba..3d81c90 100644
--- 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 e09b27c..71d88e3 100644
--- 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 48b2e70..4634abc 100644
--- 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 eb49771..86f0fff 100644
--- 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 efb9b3c..b9e1fe7 100644
--- 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 57124db..257422c 100644
--- 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)
 {