OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [hard-reg-set.h] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Sets (bit vectors) of hard registers, and operations on them.
2
   Copyright (C) 1987, 1992, 1994, 2000, 2003, 2004, 2005, 2007, 2008, 2009
3
   Free Software Foundation, Inc.
4
 
5
This file is part of GCC
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#ifndef GCC_HARD_REG_SET_H
22
#define GCC_HARD_REG_SET_H
23
 
24
/* Define the type of a set of hard registers.  */
25
 
26
/* HARD_REG_ELT_TYPE is a typedef of the unsigned integral type which
27
   will be used for hard reg sets, either alone or in an array.
28
 
29
   If HARD_REG_SET is a macro, its definition is HARD_REG_ELT_TYPE,
30
   and it has enough bits to represent all the target machine's hard
31
   registers.  Otherwise, it is a typedef for a suitably sized array
32
   of HARD_REG_ELT_TYPEs.  HARD_REG_SET_LONGS is defined as how many.
33
 
34
   Note that lots of code assumes that the first part of a regset is
35
   the same format as a HARD_REG_SET.  To help make sure this is true,
36
   we only try the widest fast integer mode (HOST_WIDEST_FAST_INT)
37
   instead of all the smaller types.  This approach loses only if
38
   there are very few registers and then only in the few cases where
39
   we have an array of HARD_REG_SETs, so it needn't be as complex as
40
   it used to be.  */
41
 
42
typedef unsigned HOST_WIDEST_FAST_INT HARD_REG_ELT_TYPE;
43
 
44
#if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
45
 
46
#define HARD_REG_SET HARD_REG_ELT_TYPE
47
 
48
#else
49
 
50
#define HARD_REG_SET_LONGS \
51
 ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDEST_FAST_INT - 1)   \
52
  / HOST_BITS_PER_WIDEST_FAST_INT)
53
typedef HARD_REG_ELT_TYPE HARD_REG_SET[HARD_REG_SET_LONGS];
54
 
55
#endif
56
 
57
/* HARD_CONST is used to cast a constant to the appropriate type
58
   for use with a HARD_REG_SET.  */
59
 
60
#define HARD_CONST(X) ((HARD_REG_ELT_TYPE) (X))
61
 
62
/* Define macros SET_HARD_REG_BIT, CLEAR_HARD_REG_BIT and TEST_HARD_REG_BIT
63
   to set, clear or test one bit in a hard reg set of type HARD_REG_SET.
64
   All three take two arguments: the set and the register number.
65
 
66
   In the case where sets are arrays of longs, the first argument
67
   is actually a pointer to a long.
68
 
69
   Define two macros for initializing a set:
70
   CLEAR_HARD_REG_SET and SET_HARD_REG_SET.
71
   These take just one argument.
72
 
73
   Also define macros for copying hard reg sets:
74
   COPY_HARD_REG_SET and COMPL_HARD_REG_SET.
75
   These take two arguments TO and FROM; they read from FROM
76
   and store into TO.  COMPL_HARD_REG_SET complements each bit.
77
 
78
   Also define macros for combining hard reg sets:
79
   IOR_HARD_REG_SET and AND_HARD_REG_SET.
80
   These take two arguments TO and FROM; they read from FROM
81
   and combine bitwise into TO.  Define also two variants
82
   IOR_COMPL_HARD_REG_SET and AND_COMPL_HARD_REG_SET
83
   which use the complement of the set FROM.
84
 
85
   Also define:
86
 
87
   hard_reg_set_subset_p (X, Y), which returns true if X is a subset of Y.
88
   hard_reg_set_equal_p (X, Y), which returns true if X and Y are equal.
89
   hard_reg_set_intersect_p (X, Y), which returns true if X and Y intersect.
90
   hard_reg_set_empty_p (X), which returns true if X is empty.  */
91
 
92
#define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT)
93
 
94
#ifdef HARD_REG_SET
95
 
96
#define SET_HARD_REG_BIT(SET, BIT)  \
97
 ((SET) |= HARD_CONST (1) << (BIT))
98
#define CLEAR_HARD_REG_BIT(SET, BIT)  \
99
 ((SET) &= ~(HARD_CONST (1) << (BIT)))
100
#define TEST_HARD_REG_BIT(SET, BIT)  \
101
 (!!((SET) & (HARD_CONST (1) << (BIT))))
102
 
103
#define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0))
104
#define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0))
105
 
106
#define COPY_HARD_REG_SET(TO, FROM) ((TO) = (FROM))
107
#define COMPL_HARD_REG_SET(TO, FROM) ((TO) = ~(FROM))
108
 
109
#define IOR_HARD_REG_SET(TO, FROM) ((TO) |= (FROM))
110
#define IOR_COMPL_HARD_REG_SET(TO, FROM) ((TO) |= ~ (FROM))
111
#define AND_HARD_REG_SET(TO, FROM) ((TO) &= (FROM))
112
#define AND_COMPL_HARD_REG_SET(TO, FROM) ((TO) &= ~ (FROM))
113
 
114
static inline bool
115
hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
116
{
117
  return (x & ~y) == HARD_CONST (0);
118
}
119
 
120
static inline bool
121
hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
122
{
123
  return x == y;
124
}
125
 
126
static inline bool
127
hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
128
{
129
  return (x & y) != HARD_CONST (0);
130
}
131
 
132
static inline bool
133
hard_reg_set_empty_p (const HARD_REG_SET x)
134
{
135
  return x == HARD_CONST (0);
136
}
137
 
138
#else
139
 
140
#define SET_HARD_REG_BIT(SET, BIT)              \
141
  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]       \
142
   |= HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))
143
 
144
#define CLEAR_HARD_REG_BIT(SET, BIT)            \
145
  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]       \
146
   &= ~(HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)))
147
 
148
#define TEST_HARD_REG_BIT(SET, BIT)             \
149
  (!!((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]    \
150
      & (HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))))
151
 
152
#if FIRST_PSEUDO_REGISTER <= 2*HOST_BITS_PER_WIDEST_FAST_INT
153
#define CLEAR_HARD_REG_SET(TO)  \
154
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
155
     scan_tp_[0] = 0;                                             \
156
     scan_tp_[1] = 0; } while (0)
157
 
158
#define SET_HARD_REG_SET(TO)  \
159
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
160
     scan_tp_[0] = -1;                                           \
161
     scan_tp_[1] = -1; } while (0)
162
 
163
#define COPY_HARD_REG_SET(TO, FROM)  \
164
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
165
     scan_tp_[0] = scan_fp_[0];                                   \
166
     scan_tp_[1] = scan_fp_[1]; } while (0)
167
 
168
#define COMPL_HARD_REG_SET(TO, FROM)  \
169
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
170
     scan_tp_[0] = ~ scan_fp_[0];                         \
171
     scan_tp_[1] = ~ scan_fp_[1]; } while (0)
172
 
173
#define AND_HARD_REG_SET(TO, FROM)  \
174
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
175
     scan_tp_[0] &= scan_fp_[0];                          \
176
     scan_tp_[1] &= scan_fp_[1]; } while (0)
177
 
178
#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
179
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
180
     scan_tp_[0] &= ~ scan_fp_[0];                                \
181
     scan_tp_[1] &= ~ scan_fp_[1]; } while (0)
182
 
183
#define IOR_HARD_REG_SET(TO, FROM)  \
184
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
185
     scan_tp_[0] |= scan_fp_[0];                          \
186
     scan_tp_[1] |= scan_fp_[1]; } while (0)
187
 
188
#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
189
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
190
     scan_tp_[0] |= ~ scan_fp_[0];                                \
191
     scan_tp_[1] |= ~ scan_fp_[1]; } while (0)
192
 
193
static inline bool
194
hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
195
{
196
  return (x[0] & ~y[0]) == 0 && (x[1] & ~y[1]) == 0;
197
}
198
 
199
static inline bool
200
hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
201
{
202
  return x[0] == y[0] && x[1] == y[1];
203
}
204
 
205
static inline bool
206
hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
207
{
208
  return (x[0] & y[0]) != 0 || (x[1] & y[1]) != 0;
209
}
210
 
211
static inline bool
212
hard_reg_set_empty_p (const HARD_REG_SET x)
213
{
214
  return x[0] == 0 && x[1] == 0;
215
}
216
 
217
#else
218
#if FIRST_PSEUDO_REGISTER <= 3*HOST_BITS_PER_WIDEST_FAST_INT
219
#define CLEAR_HARD_REG_SET(TO)  \
220
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
221
     scan_tp_[0] = 0;                                             \
222
     scan_tp_[1] = 0;                                            \
223
     scan_tp_[2] = 0; } while (0)
224
 
225
#define SET_HARD_REG_SET(TO)  \
226
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
227
     scan_tp_[0] = -1;                                           \
228
     scan_tp_[1] = -1;                                          \
229
     scan_tp_[2] = -1; } while (0)
230
 
231
#define COPY_HARD_REG_SET(TO, FROM)  \
232
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
233
     scan_tp_[0] = scan_fp_[0];                                   \
234
     scan_tp_[1] = scan_fp_[1];                                 \
235
     scan_tp_[2] = scan_fp_[2]; } while (0)
236
 
237
#define COMPL_HARD_REG_SET(TO, FROM)  \
238
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
239
     scan_tp_[0] = ~ scan_fp_[0];                         \
240
     scan_tp_[1] = ~ scan_fp_[1];                               \
241
     scan_tp_[2] = ~ scan_fp_[2]; } while (0)
242
 
243
#define AND_HARD_REG_SET(TO, FROM)  \
244
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
245
     scan_tp_[0] &= scan_fp_[0];                          \
246
     scan_tp_[1] &= scan_fp_[1];                                \
247
     scan_tp_[2] &= scan_fp_[2]; } while (0)
248
 
249
#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
250
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
251
     scan_tp_[0] &= ~ scan_fp_[0];                                \
252
     scan_tp_[1] &= ~ scan_fp_[1];                              \
253
     scan_tp_[2] &= ~ scan_fp_[2]; } while (0)
254
 
255
#define IOR_HARD_REG_SET(TO, FROM)  \
256
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
257
     scan_tp_[0] |= scan_fp_[0];                          \
258
     scan_tp_[1] |= scan_fp_[1];                                \
259
     scan_tp_[2] |= scan_fp_[2]; } while (0)
260
 
261
#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
262
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
263
     scan_tp_[0] |= ~ scan_fp_[0];                                \
264
     scan_tp_[1] |= ~ scan_fp_[1];                              \
265
     scan_tp_[2] |= ~ scan_fp_[2]; } while (0)
266
 
267
static inline bool
268
hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
269
{
270
  return ((x[0] & ~y[0]) == 0
271
          && (x[1] & ~y[1]) == 0
272
          && (x[2] & ~y[2]) == 0);
273
}
274
 
275
static inline bool
276
hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
277
{
278
  return x[0] == y[0] && x[1] == y[1] && x[2] == y[2];
279
}
280
 
281
static inline bool
282
hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
283
{
284
  return ((x[0] & y[0]) != 0
285
          || (x[1] & y[1]) != 0
286
          || (x[2] & y[2]) != 0);
287
}
288
 
289
static inline bool
290
hard_reg_set_empty_p (const HARD_REG_SET x)
291
{
292
  return x[0] == 0 && x[1] == 0 && x[2] == 0;
293
}
294
 
295
#else
296
#if FIRST_PSEUDO_REGISTER <= 4*HOST_BITS_PER_WIDEST_FAST_INT
297
#define CLEAR_HARD_REG_SET(TO)  \
298
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
299
     scan_tp_[0] = 0;                                             \
300
     scan_tp_[1] = 0;                                            \
301
     scan_tp_[2] = 0;                                            \
302
     scan_tp_[3] = 0; } while (0)
303
 
304
#define SET_HARD_REG_SET(TO)  \
305
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
306
     scan_tp_[0] = -1;                                           \
307
     scan_tp_[1] = -1;                                          \
308
     scan_tp_[2] = -1;                                          \
309
     scan_tp_[3] = -1; } while (0)
310
 
311
#define COPY_HARD_REG_SET(TO, FROM)  \
312
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
313
     scan_tp_[0] = scan_fp_[0];                                   \
314
     scan_tp_[1] = scan_fp_[1];                                 \
315
     scan_tp_[2] = scan_fp_[2];                                 \
316
     scan_tp_[3] = scan_fp_[3]; } while (0)
317
 
318
#define COMPL_HARD_REG_SET(TO, FROM)  \
319
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
320
     scan_tp_[0] = ~ scan_fp_[0];                         \
321
     scan_tp_[1] = ~ scan_fp_[1];                               \
322
     scan_tp_[2] = ~ scan_fp_[2];                               \
323
     scan_tp_[3] = ~ scan_fp_[3]; } while (0)
324
 
325
#define AND_HARD_REG_SET(TO, FROM)  \
326
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
327
     scan_tp_[0] &= scan_fp_[0];                          \
328
     scan_tp_[1] &= scan_fp_[1];                                \
329
     scan_tp_[2] &= scan_fp_[2];                                \
330
     scan_tp_[3] &= scan_fp_[3]; } while (0)
331
 
332
#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
333
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
334
     scan_tp_[0] &= ~ scan_fp_[0];                                \
335
     scan_tp_[1] &= ~ scan_fp_[1];                              \
336
     scan_tp_[2] &= ~ scan_fp_[2];                              \
337
     scan_tp_[3] &= ~ scan_fp_[3]; } while (0)
338
 
339
#define IOR_HARD_REG_SET(TO, FROM)  \
340
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
341
     scan_tp_[0] |= scan_fp_[0];                          \
342
     scan_tp_[1] |= scan_fp_[1];                                \
343
     scan_tp_[2] |= scan_fp_[2];                                \
344
     scan_tp_[3] |= scan_fp_[3]; } while (0)
345
 
346
#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
347
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
348
     scan_tp_[0] |= ~ scan_fp_[0];                                \
349
     scan_tp_[1] |= ~ scan_fp_[1];                              \
350
     scan_tp_[2] |= ~ scan_fp_[2];                              \
351
     scan_tp_[3] |= ~ scan_fp_[3]; } while (0)
352
 
353
static inline bool
354
hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
355
{
356
  return ((x[0] & ~y[0]) == 0
357
          && (x[1] & ~y[1]) == 0
358
          && (x[2] & ~y[2]) == 0
359
          && (x[3] & ~y[3]) == 0);
360
}
361
 
362
static inline bool
363
hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
364
{
365
  return x[0] == y[0] && x[1] == y[1] && x[2] == y[2] && x[3] == y[3];
366
}
367
 
368
static inline bool
369
hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
370
{
371
  return ((x[0] & y[0]) != 0
372
          || (x[1] & y[1]) != 0
373
          || (x[2] & y[2]) != 0
374
          || (x[3] & y[3]) != 0);
375
}
376
 
377
static inline bool
378
hard_reg_set_empty_p (const HARD_REG_SET x)
379
{
380
  return x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 0;
381
}
382
 
383
#else /* FIRST_PSEUDO_REGISTER > 4*HOST_BITS_PER_WIDEST_FAST_INT */
384
 
385
#define CLEAR_HARD_REG_SET(TO)  \
386
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
387
     int i;                                                     \
388
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
389
       *scan_tp_++ = 0; } while (0)
390
 
391
#define SET_HARD_REG_SET(TO)  \
392
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO);                        \
393
     int i;                                                     \
394
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
395
       *scan_tp_++ = -1; } while (0)
396
 
397
#define COPY_HARD_REG_SET(TO, FROM)  \
398
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
399
     int i;                                                     \
400
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
401
       *scan_tp_++ = *scan_fp_++; } while (0)
402
 
403
#define COMPL_HARD_REG_SET(TO, FROM)  \
404
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
405
     int i;                                                     \
406
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
407
       *scan_tp_++ = ~ *scan_fp_++; } while (0)
408
 
409
#define AND_HARD_REG_SET(TO, FROM)  \
410
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
411
     int i;                                                     \
412
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
413
       *scan_tp_++ &= *scan_fp_++; } while (0)
414
 
415
#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
416
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
417
     int i;                                                     \
418
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
419
       *scan_tp_++ &= ~ *scan_fp_++; } while (0)
420
 
421
#define IOR_HARD_REG_SET(TO, FROM)  \
422
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
423
     int i;                                                     \
424
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
425
       *scan_tp_++ |= *scan_fp_++; } while (0)
426
 
427
#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
428
do { HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);    \
429
     int i;                                                     \
430
     for (i = 0; i < HARD_REG_SET_LONGS; i++)                    \
431
       *scan_tp_++ |= ~ *scan_fp_++; } while (0)
432
 
433
static inline bool
434
hard_reg_set_subset_p (const HARD_REG_SET x, const HARD_REG_SET y)
435
{
436
  int i;
437
 
438
  for (i = 0; i < HARD_REG_SET_LONGS; i++)
439
    if ((x[i] & ~y[i]) != 0)
440
      return false;
441
  return true;
442
}
443
 
444
static inline bool
445
hard_reg_set_equal_p (const HARD_REG_SET x, const HARD_REG_SET y)
446
{
447
  int i;
448
 
449
  for (i = 0; i < HARD_REG_SET_LONGS; i++)
450
    if (x[i] != y[i])
451
      return false;
452
  return true;
453
}
454
 
455
static inline bool
456
hard_reg_set_intersect_p (const HARD_REG_SET x, const HARD_REG_SET y)
457
{
458
  int i;
459
 
460
  for (i = 0; i < HARD_REG_SET_LONGS; i++)
461
    if ((x[i] & y[i]) != 0)
462
      return true;
463
  return false;
464
}
465
 
466
static inline bool
467
hard_reg_set_empty_p (const HARD_REG_SET x)
468
{
469
  int i;
470
 
471
  for (i = 0; i < HARD_REG_SET_LONGS; i++)
472
    if (x[i] != 0)
473
      return false;
474
  return true;
475
}
476
 
477
#endif
478
#endif
479
#endif
480
#endif
481
 
482
/* Iterator for hard register sets.  */
483
 
484
typedef struct
485
{
486
  /* Pointer to the current element.  */
487
  HARD_REG_ELT_TYPE *pelt;
488
 
489
  /* The length of the set.  */
490
  unsigned short length;
491
 
492
  /* Word within the current element.  */
493
  unsigned short word_no;
494
 
495
  /* Contents of the actually processed word.  When finding next bit
496
     it is shifted right, so that the actual bit is always the least
497
     significant bit of ACTUAL.  */
498
  HARD_REG_ELT_TYPE bits;
499
} hard_reg_set_iterator;
500
 
501
#define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT
502
 
503
/* The implementation of the iterator functions is fully analogous to
504
   the bitmap iterators.  */
505
static inline void
506
hard_reg_set_iter_init (hard_reg_set_iterator *iter, HARD_REG_SET set,
507
                        unsigned min, unsigned *regno)
508
{
509
#ifdef HARD_REG_SET_LONGS
510
  iter->pelt = set;
511
  iter->length = HARD_REG_SET_LONGS;
512
#else
513
  iter->pelt = &set;
514
  iter->length = 1;
515
#endif
516
  iter->word_no = min / HARD_REG_ELT_BITS;
517
  if (iter->word_no < iter->length)
518
    {
519
      iter->bits = iter->pelt[iter->word_no];
520
      iter->bits >>= min % HARD_REG_ELT_BITS;
521
 
522
      /* This is required for correct search of the next bit.  */
523
      min += !iter->bits;
524
    }
525
  *regno = min;
526
}
527
 
528
static inline bool
529
hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno)
530
{
531
  while (1)
532
    {
533
      /* Return false when we're advanced past the end of the set.  */
534
      if (iter->word_no >= iter->length)
535
        return false;
536
 
537
      if (iter->bits)
538
        {
539
          /* Find the correct bit and return it.  */
540
          while (!(iter->bits & 1))
541
            {
542
              iter->bits >>= 1;
543
              *regno += 1;
544
            }
545
          return (*regno < FIRST_PSEUDO_REGISTER);
546
        }
547
 
548
      /* Round to the beginning of the next word.  */
549
      *regno = (*regno + HARD_REG_ELT_BITS - 1);
550
      *regno -= *regno % HARD_REG_ELT_BITS;
551
 
552
      /* Find the next non-zero word.  */
553
      while (++iter->word_no < iter->length)
554
        {
555
          iter->bits = iter->pelt[iter->word_no];
556
          if (iter->bits)
557
            break;
558
          *regno += HARD_REG_ELT_BITS;
559
        }
560
    }
561
}
562
 
563
static inline void
564
hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno)
565
{
566
  iter->bits >>= 1;
567
  *regno += 1;
568
}
569
 
570
#define EXECUTE_IF_SET_IN_HARD_REG_SET(SET, MIN, REGNUM, ITER)          \
571
  for (hard_reg_set_iter_init (&(ITER), (SET), (MIN), &(REGNUM));       \
572
       hard_reg_set_iter_set (&(ITER), &(REGNUM));                      \
573
       hard_reg_set_iter_next (&(ITER), &(REGNUM)))
574
 
575
 
576
/* Define some standard sets of registers.  */
577
 
578
/* Indexed by hard register number, contains 1 for registers
579
   that are fixed use (stack pointer, pc, frame pointer, etc.).
580
   These are the registers that cannot be used to allocate
581
   a pseudo reg whose life does not cross calls.  */
582
 
583
extern char fixed_regs[FIRST_PSEUDO_REGISTER];
584
 
585
/* The same info as a HARD_REG_SET.  */
586
 
587
extern HARD_REG_SET fixed_reg_set;
588
 
589
/* Indexed by hard register number, contains 1 for registers
590
   that are fixed use or are clobbered by function calls.
591
   These are the registers that cannot be used to allocate
592
   a pseudo reg whose life crosses calls.  */
593
 
594
extern char call_used_regs[FIRST_PSEUDO_REGISTER];
595
 
596
#ifdef CALL_REALLY_USED_REGISTERS
597
extern char call_really_used_regs[];
598
#endif
599
 
600
/* The same info as a HARD_REG_SET.  */
601
 
602
extern HARD_REG_SET call_used_reg_set;
603
 
604
/* Contains registers that are fixed use -- i.e. in fixed_reg_set -- or
605
   a function value return register or TARGET_STRUCT_VALUE_RTX or
606
   STATIC_CHAIN_REGNUM.  These are the registers that cannot hold quantities
607
   across calls even if we are willing to save and restore them.  */
608
 
609
extern HARD_REG_SET call_fixed_reg_set;
610
 
611
/* Indexed by hard register number, contains 1 for registers
612
   that are being used for global register decls.
613
   These must be exempt from ordinary flow analysis
614
   and are also considered fixed.  */
615
 
616
extern char global_regs[FIRST_PSEUDO_REGISTER];
617
 
618
/* Contains 1 for registers that are set or clobbered by calls.  */
619
/* ??? Ideally, this would be just call_used_regs plus global_regs, but
620
   for someone's bright idea to have call_used_regs strictly include
621
   fixed_regs.  Which leaves us guessing as to the set of fixed_regs
622
   that are actually preserved.  We know for sure that those associated
623
   with the local stack frame are safe, but scant others.  */
624
 
625
extern HARD_REG_SET regs_invalidated_by_call;
626
 
627
/* Call used hard registers which can not be saved because there is no
628
   insn for this.  */
629
 
630
extern HARD_REG_SET no_caller_save_reg_set;
631
 
632
#ifdef REG_ALLOC_ORDER
633
/* Table of register numbers in the order in which to try to use them.  */
634
 
635
extern int reg_alloc_order[FIRST_PSEUDO_REGISTER];
636
 
637
/* The inverse of reg_alloc_order.  */
638
 
639
extern int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
640
#endif
641
 
642
/* For each reg class, a HARD_REG_SET saying which registers are in it.  */
643
 
644
extern HARD_REG_SET reg_class_contents[N_REG_CLASSES];
645
 
646
/* For each reg class, number of regs it contains.  */
647
 
648
extern unsigned int reg_class_size[N_REG_CLASSES];
649
 
650
/* For each reg class, table listing all the classes contained in it.  */
651
 
652
extern enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
653
 
654
/* For each pair of reg classes,
655
   a largest reg class contained in their union.  */
656
 
657
extern enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
658
 
659
/* For each pair of reg classes,
660
   the smallest reg class that contains their union.  */
661
 
662
extern enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
663
 
664
/* Vector indexed by hardware reg giving its name.  */
665
 
666
extern const char * reg_names[FIRST_PSEUDO_REGISTER];
667
 
668
/* Vector indexed by reg class giving its name.  */
669
 
670
extern const char * reg_class_names[];
671
 
672
/* Given a hard REGN a FROM mode and a TO mode, return nonzero if
673
   REGN cannot change modes between the specified modes.  */
674
#define REG_CANNOT_CHANGE_MODE_P(REGN, FROM, TO)                          \
675
         CANNOT_CHANGE_MODE_CLASS (FROM, TO, REGNO_REG_CLASS (REGN))
676
 
677
#endif /* ! GCC_HARD_REG_SET_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.