procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplify the implementation of HARD_REG_SET

Browse source 
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
This commit is contained in:
Richard Sandiford 2019-09-09 17:58:36 +00:00 • committed by Richard Sandiford
parent 812b3c62a7
commit 504279ae0a
10 changed files with 169 additions and 376 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
gcc/ChangeLog
View file

@ -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.

3
gcc/config/epiphany/resolve-sw-modes.c
View file

@ -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;

19
gcc/config/ia64/ia64.c
View file

@ -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. */

465
gcc/hard-reg-set.h
View file

@ -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);
}
inline void
CLEAR_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
{
set.elts[bit / UHOST_BITS_PER_WIDE_INT]
&= ~(HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT));
}
inline bool
TEST_HARD_REG_BIT (const_hard_reg_set set, unsigned int bit)
{
return (set.elts[bit / UHOST_BITS_PER_WIDE_INT]
& (HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT)));
}
inline void
CLEAR_HARD_REG_SET (HARD_REG_SET &set)
{
for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
set.elts[i] = 0;
}
inline void
SET_HARD_REG_SET (HARD_REG_SET &set)
{
for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
set.elts[i] = -1;
}
inline void
COPY_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
{
to = from;
}
inline void
COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
{
for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
to.elts[i] = ~from.elts[i];
}
inline void
AND_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
{
for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
to.elts[i] &= from.elts[i];
}
inline void
AND_COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
{
for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
to.elts[i] &= ~from.elts[i];
}
inline void
IOR_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
{
for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
to.elts[i] |= from.elts[i];
}
inline void
IOR_COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from)
{
for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i)
to.elts[i] |= ~from.elts[i];
}
static inline bool
hard_reg_set_equal_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[0] == y[0] && x[1] == y[1];
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_equal_p (const_hard_reg_set x, const_hard_reg_set y)
{
return (x[0] & y[0]) != 0 || (x[1] & y[1]) != 0;
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_empty_p (const HARD_REG_SET x)
hard_reg_set_intersect_p (const_hard_reg_set x, const_hard_reg_set y)
{
return x[0] == 0 && x[1] == 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)
{
return ((x[0] & ~y[0]) == 0
&& (x[1] & ~y[1]) == 0
&& (x[2] & ~y[2]) == 0);
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_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
hard_reg_set_empty_p (const_hard_reg_set x)
{
return x[0] == y[0] && x[1] == y[1] && x[2] == y[2];
HARD_REG_ELT_TYPE bad = 0;
for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
bad |= x.elts[i];
return bad == 0;
}
static inline bool
hard_reg_set_intersect_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);
}
static inline bool
hard_reg_set_empty_p (const HARD_REG_SET x)
{
return x[0] == 0 && x[1] == 0 && x[2] == 0;
}
#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)
{
return x[0] == y[0] && x[1] == y[1] && x[2] == y[2] && x[3] == y[3];
}
static inline bool
hard_reg_set_intersect_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_empty_p (const HARD_REG_SET x)
{
return x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 0;
}
#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)
{
int i;
for (i = 0; i < HARD_REG_SET_LONGS; i++)
if ((x[i] & ~y[i]) != 0)
return false;
return true;
}
static inline bool
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;
}
static inline bool
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;
}
static inline bool
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;
}
#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;

2
gcc/ira-costs.c
View file

@ -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];

2
gcc/recog.h
View file

@ -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

8
gcc/regs.h
View file

@ -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))

4
gcc/reload.h
View file

@ -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

3
gcc/rtl.h
View file

@ -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 */

4
gcc/shrink-wrap.c
View file

@ -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)
{