GCC Middle and Back End API Reference
hard-reg-set.h
Go to the documentation of this file.
1/* Sets (bit vectors) of hard registers, and operations on them.
2 Copyright (C) 1987-2024 Free Software Foundation, Inc.
3
4This file is part of GCC
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#ifndef GCC_HARD_REG_SET_H
21#define GCC_HARD_REG_SET_H
22
23#include "array-traits.h"
24
25/* Define the type of a set of hard registers. */
26
27/* HARD_REG_ELT_TYPE is a typedef of the unsigned integral type which
28 will be used for hard reg sets, either alone or in an array.
29
30 If HARD_REG_SET is a macro, its definition is HARD_REG_ELT_TYPE,
31 and it has enough bits to represent all the target machine's hard
32 registers. Otherwise, it is a typedef for a suitably sized array
33 of HARD_REG_ELT_TYPEs. HARD_REG_SET_LONGS is defined as how many.
34
35 Note that lots of code assumes that the first part of a regset is
36 the same format as a HARD_REG_SET. To help make sure this is true,
37 we only try the widest fast integer mode (HOST_WIDEST_FAST_INT)
38 instead of all the smaller types. This approach loses only if
39 there are very few registers and then only in the few cases where
40 we have an array of HARD_REG_SETs, so it needn't be as complex as
41 it used to be. */
42
44
45#if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
46
49
50#else
51
52#define HARD_REG_SET_LONGS \
53 ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDEST_FAST_INT - 1) \
54 / HOST_BITS_PER_WIDEST_FAST_INT)
55
56struct HARD_REG_SET
57{
59 operator~ () const
60 {
61 HARD_REG_SET res;
62 for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
63 res.elts[i] = ~elts[i];
64 return res;
65 }
66
68 operator& (const HARD_REG_SET &other) const
69 {
70 HARD_REG_SET res;
71 for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
72 res.elts[i] = elts[i] & other.elts[i];
73 return res;
74 }
75
77 operator&= (const HARD_REG_SET &other)
78 {
79 for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
80 elts[i] &= other.elts[i];
81 return *this;
82 }
83
85 operator| (const HARD_REG_SET &other) const
86 {
87 HARD_REG_SET res;
88 for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
89 res.elts[i] = elts[i] | other.elts[i];
90 return res;
91 }
92
94 operator|= (const HARD_REG_SET &other)
95 {
96 for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
97 elts[i] |= other.elts[i];
98 return *this;
99 }
100
101 bool
102 operator== (const HARD_REG_SET &other) const
103 {
104 HARD_REG_ELT_TYPE bad = 0;
105 for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
106 bad |= (elts[i] ^ other.elts[i]);
107 return bad == 0;
108 }
109
110 bool
111 operator!= (const HARD_REG_SET &other) const
112 {
113 return !operator== (other);
114 }
115
116 HARD_REG_ELT_TYPE elts[HARD_REG_SET_LONGS];
117};
118typedef const HARD_REG_SET &const_hard_reg_set;
119
120template<>
122{
124 static const bool has_constant_size = true;
125 static const size_t constant_size = HARD_REG_SET_LONGS;
126 static const element_type *base (const HARD_REG_SET &x) { return x.elts; }
127 static size_t size (const HARD_REG_SET &) { return HARD_REG_SET_LONGS; }
128};
129
130#endif
131
132/* HARD_REG_SET wrapped into a structure, to make it possible to
133 use HARD_REG_SET even in APIs that should not include
134 hard-reg-set.h. */
139
140/* HARD_CONST is used to cast a constant to the appropriate type
141 for use with a HARD_REG_SET. */
142
143#define HARD_CONST(X) ((HARD_REG_ELT_TYPE) (X))
144
145/* Define macros SET_HARD_REG_BIT, CLEAR_HARD_REG_BIT and TEST_HARD_REG_BIT
146 to set, clear or test one bit in a hard reg set of type HARD_REG_SET.
147 All three take two arguments: the set and the register number.
148
149 In the case where sets are arrays of longs, the first argument
150 is actually a pointer to a long.
151
152 Define two macros for initializing a set:
153 CLEAR_HARD_REG_SET and SET_HARD_REG_SET.
154 These take just one argument.
155
156 Also define:
157
158 hard_reg_set_subset_p (X, Y), which returns true if X is a subset of Y.
159 hard_reg_set_intersect_p (X, Y), which returns true if X and Y intersect.
160 hard_reg_set_empty_p (X), which returns true if X is empty. */
161
162#define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT)
163
164#if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
165
166#define SET_HARD_REG_BIT(SET, BIT) \
167 ((SET) |= HARD_CONST (1) << (BIT))
168#define CLEAR_HARD_REG_BIT(SET, BIT) \
169 ((SET) &= ~(HARD_CONST (1) << (BIT)))
170#define TEST_HARD_REG_BIT(SET, BIT) \
171 (!!((SET) & (HARD_CONST (1) << (BIT))))
172
173#define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0))
174#define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0))
175
176inline bool
181
182inline bool
187
188inline bool
190{
191 return x == HARD_CONST (0);
192}
193
194#else
195
196inline void
197SET_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
198{
199 set.elts[bit / UHOST_BITS_PER_WIDE_INT]
200 |= HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT);
201}
202
203inline void
204CLEAR_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
205{
206 set.elts[bit / UHOST_BITS_PER_WIDE_INT]
207 &= ~(HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT));
208}
209
210inline bool
211TEST_HARD_REG_BIT (const_hard_reg_set set, unsigned int bit)
212{
213 return (set.elts[bit / UHOST_BITS_PER_WIDE_INT]
214 & (HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT)));
215}
216
217inline void
219{
220 for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
221 set.elts[i] = 0;
222}
223
224inline void
226{
227 for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
228 set.elts[i] = -1;
229}
230
231inline bool
233{
234 HARD_REG_ELT_TYPE bad = 0;
235 for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
236 bad |= (x.elts[i] & ~y.elts[i]);
237 return bad == 0;
238}
239
240inline bool
242{
243 HARD_REG_ELT_TYPE good = 0;
244 for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
245 good |= (x.elts[i] & y.elts[i]);
246 return good != 0;
247}
248
249inline bool
251{
252 HARD_REG_ELT_TYPE bad = 0;
253 for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
254 bad |= x.elts[i];
255 return bad == 0;
256}
257#endif
258
259/* Iterator for hard register sets. */
260
262{
263 /* Pointer to the current element. */
265
266 /* The length of the set. */
267 unsigned short length;
268
269 /* Word within the current element. */
270 unsigned short word_no;
271
272 /* Contents of the actually processed word. When finding next bit
273 it is shifted right, so that the actual bit is always the least
274 significant bit of ACTUAL. */
276};
277
278#define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT
279
280/* The implementation of the iterator functions is fully analogous to
281 the bitmap iterators. */
282inline void
284 unsigned min, unsigned *regno)
285{
286#ifdef HARD_REG_SET_LONGS
287 iter->pelt = set.elts;
288 iter->length = HARD_REG_SET_LONGS;
289#else
290 iter->pelt = &set;
291 iter->length = 1;
292#endif
293 iter->word_no = min / HARD_REG_ELT_BITS;
294 if (iter->word_no < iter->length)
295 {
296 iter->bits = iter->pelt[iter->word_no];
297 iter->bits >>= min % HARD_REG_ELT_BITS;
298
299 /* This is required for correct search of the next bit. */
300 min += !iter->bits;
301 }
302 *regno = min;
303}
304
305inline bool
307{
308 while (1)
309 {
310 /* Return false when we're advanced past the end of the set. */
311 if (iter->word_no >= iter->length)
312 return false;
313
314 if (iter->bits)
315 {
316 /* Find the correct bit and return it. */
317 while (!(iter->bits & 1))
318 {
319 iter->bits >>= 1;
320 *regno += 1;
321 }
322 return (*regno < FIRST_PSEUDO_REGISTER);
323 }
324
325 /* Round to the beginning of the next word. */
326 *regno = (*regno + HARD_REG_ELT_BITS - 1);
327 *regno -= *regno % HARD_REG_ELT_BITS;
328
329 /* Find the next non-zero word. */
330 while (++iter->word_no < iter->length)
331 {
332 iter->bits = iter->pelt[iter->word_no];
333 if (iter->bits)
334 break;
335 *regno += HARD_REG_ELT_BITS;
336 }
337 }
338}
339
340inline void
342{
343 iter->bits >>= 1;
344 *regno += 1;
345}
346
347#define EXECUTE_IF_SET_IN_HARD_REG_SET(SET, MIN, REGNUM, ITER) \
348 for (hard_reg_set_iter_init (&(ITER), (SET), (MIN), &(REGNUM)); \
349 hard_reg_set_iter_set (&(ITER), &(REGNUM)); \
350 hard_reg_set_iter_next (&(ITER), &(REGNUM)))
351
352
353/* Define some standard sets of registers. */
354
355/* Indexed by hard register number, contains 1 for registers
356 that are being used for global register decls.
357 These must be exempt from ordinary flow analysis
358 and are also considered fixed. */
359
360extern char global_regs[FIRST_PSEUDO_REGISTER];
361
363
365class subreg_shape;
366
367struct simplifiable_subregs_hasher : nofree_ptr_hash <simplifiable_subreg>
368{
370
371 static inline hashval_t hash (const simplifiable_subreg *);
372 static inline bool equal (const simplifiable_subreg *, const subreg_shape *);
373};
374
376 void finalize ();
377
378 /* The set of registers that actually exist on the current target. */
380
381 /* The set of registers that should be considered to be register
382 operands. It is a subset of x_accessible_reg_set. */
384
385 /* Indexed by hard register number, contains 1 for registers
386 that are fixed use (stack pointer, pc, frame pointer, etc.;.
387 These are the registers that cannot be used to allocate
388 a pseudo reg whose life does not cross calls. */
389 char x_fixed_regs[FIRST_PSEUDO_REGISTER];
390
391 /* The same info as a HARD_REG_SET. */
393
394 /* Indexed by hard register number, contains 1 for registers
395 that are fixed use or are clobbered by function calls.
396 These are the registers that cannot be used to allocate
397 a pseudo reg whose life crosses calls. */
398 char x_call_used_regs[FIRST_PSEUDO_REGISTER];
399
400 /* For targets that use reload rather than LRA, this is the set
401 of registers that we are able to save and restore around calls
402 (i.e. those for which we know a suitable mode and set of
403 load/store instructions exist). For LRA targets it contains
404 all registers.
405
406 This is legacy information and should be removed if all targets
407 switch to LRA. */
409
410 /* Contains registers that are fixed use -- i.e. in fixed_reg_set -- but
411 only if they are not merely part of that set because they are global
412 regs. Global regs that are not otherwise fixed can still take part
413 in register allocation. */
415
416 /* Contains 1 for registers that are set or clobbered by calls. */
417 /* ??? Ideally, this would be just call_used_regs plus global_regs, but
418 for someone's bright idea to have call_used_regs strictly include
419 fixed_regs. Which leaves us guessing as to the set of fixed_regs
420 that are actually preserved. We know for sure that those associated
421 with the local stack frame are safe, but scant others. */
423
424 /* The set of registers that are used by EH_RETURN_DATA_REGNO. */
426
427 /* Table of register numbers in the order in which to try to use them. */
428 int x_reg_alloc_order[FIRST_PSEUDO_REGISTER];
429
430 /* The inverse of reg_alloc_order. */
431 int x_inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
432
433 /* For each reg class, a HARD_REG_SET saying which registers are in it. */
435
436 /* For each reg class, a boolean saying whether the class contains only
437 fixed registers. */
438 bool x_class_only_fixed_regs[N_REG_CLASSES];
439
440 /* For each reg class, number of regs it contains. */
441 unsigned int x_reg_class_size[N_REG_CLASSES];
442
443 /* For each reg class, table listing all the classes contained in it. */
444 enum reg_class x_reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
445
446 /* For each pair of reg classes,
447 a largest reg class contained in their union. */
448 enum reg_class x_reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
449
450 /* For each pair of reg classes,
451 the smallest reg class that contains their union. */
452 enum reg_class x_reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
453
454 /* Vector indexed by hardware reg giving its name. */
455 const char *x_reg_names[FIRST_PSEUDO_REGISTER];
456
457 /* Records which registers can form a particular subreg, with the subreg
458 being identified by its outer mode, inner mode and offset. */
459 hash_table <simplifiable_subregs_hasher> *x_simplifiable_subregs;
460};
461
463#if SWITCHABLE_TARGET
465#else
466#define this_target_hard_regs (&default_target_hard_regs)
467#endif
468
469#define accessible_reg_set \
470 (this_target_hard_regs->x_accessible_reg_set)
471#define operand_reg_set \
472 (this_target_hard_regs->x_operand_reg_set)
473#define fixed_regs \
474 (this_target_hard_regs->x_fixed_regs)
475#define fixed_reg_set \
476 (this_target_hard_regs->x_fixed_reg_set)
477#define fixed_nonglobal_reg_set \
478 (this_target_hard_regs->x_fixed_nonglobal_reg_set)
479#ifdef IN_TARGET_CODE
480#define call_used_regs \
481 (this_target_hard_regs->x_call_used_regs)
482#endif
483#define savable_regs \
484 (this_target_hard_regs->x_savable_regs)
485#ifdef IN_TARGET_CODE
486#define regs_invalidated_by_call \
487 (this_target_hard_regs->x_regs_invalidated_by_call)
488#define call_used_or_fixed_regs \
489 (regs_invalidated_by_call | fixed_reg_set)
490#endif
491#define eh_return_data_regs \
492 (this_target_hard_regs->x_eh_return_data_regs)
493#define reg_alloc_order \
494 (this_target_hard_regs->x_reg_alloc_order)
495#define inv_reg_alloc_order \
496 (this_target_hard_regs->x_inv_reg_alloc_order)
497#define reg_class_contents \
498 (this_target_hard_regs->x_reg_class_contents)
499#define class_only_fixed_regs \
500 (this_target_hard_regs->x_class_only_fixed_regs)
501#define reg_class_size \
502 (this_target_hard_regs->x_reg_class_size)
503#define reg_class_subclasses \
504 (this_target_hard_regs->x_reg_class_subclasses)
505#define reg_class_subunion \
506 (this_target_hard_regs->x_reg_class_subunion)
507#define reg_class_superunion \
508 (this_target_hard_regs->x_reg_class_superunion)
509#define reg_names \
510 (this_target_hard_regs->x_reg_names)
511
512/* Vector indexed by reg class giving its name. */
513
514extern const char * reg_class_names[];
515
516/* Given a hard REGN a FROM mode and a TO mode, return true if
517 REGN can change from mode FROM to mode TO. */
518#define REG_CAN_CHANGE_MODE_P(REGN, FROM, TO) \
519 (targetm.can_change_mode_class (FROM, TO, REGNO_REG_CLASS (REGN)))
520
521#ifdef IN_TARGET_CODE
522/* Return true if register REGNO is either fixed or call-used
523 (aka call-clobbered). */
524
525inline bool
526call_used_or_fixed_reg_p (unsigned int regno)
527{
528 return fixed_regs[regno] || this_target_hard_regs->x_call_used_regs[regno];
529}
530#endif
531
532#endif /* ! GCC_HARD_REG_SET_H */
Definition reginfo.cc:55
Definition rtl.h:2126
bool operator==(const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
Definition diagnostic-spec.h:131
bool operator!=(const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
Definition diagnostic-spec.h:139
nowarn_spec_t operator|(const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
Definition diagnostic-spec.h:115
nowarn_spec_t operator&(const nowarn_spec_t &lhs, const nowarn_spec_t &rhs)
Definition diagnostic-spec.h:123
dump_flags_t & operator&=(dump_flags_t &lhs, dump_flags_t rhs)
Definition dumpfile.h:240
dump_flags_t & operator|=(dump_flags_t &lhs, dump_flags_t rhs)
Definition dumpfile.h:232
dump_flags_t operator~(dump_flags_t flags)
Definition dumpfile.h:226
#define SET_HARD_REG_SET(TO)
Definition hard-reg-set.h:174
bool hard_reg_set_subset_p(const_hard_reg_set x, const_hard_reg_set y)
Definition hard-reg-set.h:177
#define HARD_REG_ELT_BITS
Definition hard-reg-set.h:278
#define this_target_hard_regs
Definition hard-reg-set.h:466
unsigned HOST_WIDEST_FAST_INT HARD_REG_ELT_TYPE
Definition hard-reg-set.h:43
bool hard_reg_set_iter_set(hard_reg_set_iterator *iter, unsigned *regno)
Definition hard-reg-set.h:306
#define TEST_HARD_REG_BIT(SET, BIT)
Definition hard-reg-set.h:170
#define CLEAR_HARD_REG_BIT(SET, BIT)
Definition hard-reg-set.h:168
char global_regs[FIRST_PSEUDO_REGISTER]
Definition reginfo.cc:92
HARD_REG_ELT_TYPE HARD_REG_SET
Definition hard-reg-set.h:47
bool hard_reg_set_intersect_p(const_hard_reg_set x, const_hard_reg_set y)
Definition hard-reg-set.h:183
#define HARD_CONST(X)
Definition hard-reg-set.h:143
#define fixed_regs
Definition hard-reg-set.h:473
void hard_reg_set_iter_next(hard_reg_set_iterator *iter, unsigned *regno)
Definition hard-reg-set.h:341
#define CLEAR_HARD_REG_SET(TO)
Definition hard-reg-set.h:173
void hard_reg_set_iter_init(hard_reg_set_iterator *iter, const_hard_reg_set set, unsigned min, unsigned *regno)
Definition hard-reg-set.h:283
const char * reg_class_names[]
Definition reginfo.cc:119
bool hard_reg_set_empty_p(const_hard_reg_set x)
Definition hard-reg-set.h:189
#define UHOST_BITS_PER_WIDE_INT
Definition hard-reg-set.h:162
HARD_REG_SET global_reg_set
Definition reginfo.cc:95
#define SET_HARD_REG_BIT(SET, BIT)
Definition hard-reg-set.h:166
struct target_hard_regs default_target_hard_regs
Definition reginfo.cc:63
const HARD_REG_SET const_hard_reg_set
Definition hard-reg-set.h:48
#define HOST_WIDEST_FAST_INT
Definition hwint.h:154
i
Definition poly-int.h:776
Definition array-traits.h:35
Definition hard-reg-set.h:136
HARD_REG_SET set
Definition hard-reg-set.h:137
Definition hard-reg-set.h:262
unsigned short length
Definition hard-reg-set.h:267
const HARD_REG_ELT_TYPE * pelt
Definition hard-reg-set.h:264
unsigned short word_no
Definition hard-reg-set.h:270
HARD_REG_ELT_TYPE bits
Definition hard-reg-set.h:275
Definition hash-traits.h:303
static const size_t constant_size
Definition array-traits.h:29
T element_type
Definition array-traits.h:27
static const bool has_constant_size
Definition array-traits.h:28
static const T * base(const T &x)
Definition array-traits.h:30
static size_t size(const T &)
Definition array-traits.h:31
Definition cse.cc:4118
Definition hard-reg-set.h:368
static hashval_t hash(const simplifiable_subreg *)
Definition reginfo.cc:1176
static bool equal(const simplifiable_subreg *, const subreg_shape *)
Definition reginfo.cc:1184
const subreg_shape * compare_type
Definition hard-reg-set.h:369
Definition hard-reg-set.h:375
int x_reg_alloc_order[FIRST_PSEUDO_REGISTER]
Definition hard-reg-set.h:428
HARD_REG_SET x_fixed_nonglobal_reg_set
Definition hard-reg-set.h:414
char x_call_used_regs[FIRST_PSEUDO_REGISTER]
Definition hard-reg-set.h:398
char x_fixed_regs[FIRST_PSEUDO_REGISTER]
Definition hard-reg-set.h:389
int x_inv_reg_alloc_order[FIRST_PSEUDO_REGISTER]
Definition hard-reg-set.h:431
enum reg_class x_reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES]
Definition hard-reg-set.h:448
bool x_class_only_fixed_regs[N_REG_CLASSES]
Definition hard-reg-set.h:438
unsigned int x_reg_class_size[N_REG_CLASSES]
Definition hard-reg-set.h:441
HARD_REG_SET x_reg_class_contents[N_REG_CLASSES]
Definition hard-reg-set.h:434
const char * x_reg_names[FIRST_PSEUDO_REGISTER]
Definition hard-reg-set.h:455
HARD_REG_SET x_accessible_reg_set
Definition hard-reg-set.h:379
hash_table< simplifiable_subregs_hasher > * x_simplifiable_subregs
Definition hard-reg-set.h:459
HARD_REG_SET x_savable_regs
Definition hard-reg-set.h:408
HARD_REG_SET x_eh_return_data_regs
Definition hard-reg-set.h:425
enum reg_class x_reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES]
Definition hard-reg-set.h:444
HARD_REG_SET x_operand_reg_set
Definition hard-reg-set.h:383
enum reg_class x_reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES]
Definition hard-reg-set.h:452
void finalize()
Definition reginfo.cc:1354
HARD_REG_SET x_fixed_reg_set
Definition hard-reg-set.h:392
HARD_REG_SET x_regs_invalidated_by_call
Definition hard-reg-set.h:422
const T2 & y
Definition wide-int.h:3870