source: trunk/third/gcc/hard-reg-set.h @ 11288

Revision 11288, 16.6 KB checked in by ghudson, 26 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r11287, which included commits to RCS files with non-trunk default branches.
Line 
1/* Sets (bit vectors) of hard registers, and operations on them.
2   Copyright (C) 1987, 1992, 1994 Free Software Foundation, Inc.
3
4This file is part of GNU CC
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING.  If not, write to
18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA.  */
20
21
22/* Define the type of a set of hard registers.  */
23
24/* HARD_REG_ELT_TYPE is a typedef of the unsigned integral type which
25   will be used for hard reg sets, either alone or in an array.
26
27   If HARD_REG_SET is a macro, its definition is HARD_REG_ELT_TYPE,
28   and it has enough bits to represent all the target machine's hard
29   registers.  Otherwise, it is a typedef for a suitably sized array
30   of HARD_REG_ELT_TYPEs.  HARD_REG_SET_LONGS is defined as how many.
31
32   Note that lots of code assumes that the first part of a regset is
33   the same format as a HARD_REG_SET.  To help make sure this is true,
34   we only try the widest integer mode (HOST_WIDE_INT) instead of all the
35   smaller types.  This approach loses only if there are a very few
36   registers and then only in the few cases where we have an array of
37   HARD_REG_SETs, so it needn't be as complex as it used to be.  */
38
39typedef unsigned HOST_WIDE_INT HARD_REG_ELT_TYPE;
40
41#if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDE_INT
42
43#define HARD_REG_SET HARD_REG_ELT_TYPE
44
45#else
46
47#define HARD_REG_SET_LONGS \
48 ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDE_INT - 1)  \
49  / HOST_BITS_PER_WIDE_INT)
50typedef HARD_REG_ELT_TYPE HARD_REG_SET[HARD_REG_SET_LONGS];
51
52#endif
53
54/* HARD_CONST is used to cast a constant to the appropriate type
55   for use with a HARD_REG_SET.  */
56
57#define HARD_CONST(X) ((HARD_REG_ELT_TYPE) (X))
58
59/* Define macros SET_HARD_REG_BIT, CLEAR_HARD_REG_BIT and TEST_HARD_REG_BIT
60   to set, clear or test one bit in a hard reg set of type HARD_REG_SET.
61   All three take two arguments: the set and the register number.
62
63   In the case where sets are arrays of longs, the first argument
64   is actually a pointer to a long.
65
66   Define two macros for initializing a set:
67   CLEAR_HARD_REG_SET and SET_HARD_REG_SET.
68   These take just one argument.
69
70   Also define macros for copying hard reg sets:
71   COPY_HARD_REG_SET and COMPL_HARD_REG_SET.
72   These take two arguments TO and FROM; they read from FROM
73   and store into TO.  COMPL_HARD_REG_SET complements each bit.
74
75   Also define macros for combining hard reg sets:
76   IOR_HARD_REG_SET and AND_HARD_REG_SET.
77   These take two arguments TO and FROM; they read from FROM
78   and combine bitwise into TO.  Define also two variants
79   IOR_COMPL_HARD_REG_SET and AND_COMPL_HARD_REG_SET
80   which use the complement of the set FROM.
81
82   Also define GO_IF_HARD_REG_SUBSET (X, Y, TO):
83   if X is a subset of Y, go to TO.
84*/
85
86#ifdef HARD_REG_SET
87
88#define SET_HARD_REG_BIT(SET, BIT)  \
89 ((SET) |= HARD_CONST (1) << (BIT))
90#define CLEAR_HARD_REG_BIT(SET, BIT)  \
91 ((SET) &= ~(HARD_CONST (1) << (BIT)))
92#define TEST_HARD_REG_BIT(SET, BIT)  \
93 ((SET) & (HARD_CONST (1) << (BIT)))
94
95#define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0))
96#define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0))
97
98#define COPY_HARD_REG_SET(TO, FROM) ((TO) = (FROM))
99#define COMPL_HARD_REG_SET(TO, FROM) ((TO) = ~(FROM))
100
101#define IOR_HARD_REG_SET(TO, FROM) ((TO) |= (FROM))
102#define IOR_COMPL_HARD_REG_SET(TO, FROM) ((TO) |= ~ (FROM))
103#define AND_HARD_REG_SET(TO, FROM) ((TO) &= (FROM))
104#define AND_COMPL_HARD_REG_SET(TO, FROM) ((TO) &= ~ (FROM))
105
106#define GO_IF_HARD_REG_SUBSET(X,Y,TO) if (HARD_CONST (0) == ((X) & ~(Y))) goto TO
107
108#define GO_IF_HARD_REG_EQUAL(X,Y,TO) if ((X) == (Y)) goto TO
109
110#else
111
112#define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDE_INT)
113
114#define SET_HARD_REG_BIT(SET, BIT)              \
115  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]       \
116   |= HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT))
117
118#define CLEAR_HARD_REG_BIT(SET, BIT)            \
119  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]       \
120   &= ~(HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)))
121
122#define TEST_HARD_REG_BIT(SET, BIT)             \
123  ((SET)[(BIT) / UHOST_BITS_PER_WIDE_INT]       \
124   & (HARD_CONST (1) << ((BIT) % UHOST_BITS_PER_WIDE_INT)))
125
126#if FIRST_PSEUDO_REGISTER <= 2*HOST_BITS_PER_WIDE_INT
127#define CLEAR_HARD_REG_SET(TO)  \
128do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
129     scan_tp_[0] = 0;                                           \
130     scan_tp_[1] = 0; } while (0)
131
132#define SET_HARD_REG_SET(TO)  \
133do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
134     scan_tp_[0] = -1;                                          \
135     scan_tp_[1] = -1; } while (0)
136
137#define COPY_HARD_REG_SET(TO, FROM)  \
138do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);   \
139     scan_tp_[0] = scan_fp_[0];                                 \
140     scan_tp_[1] = scan_fp_[1]; } while (0)
141
142#define COMPL_HARD_REG_SET(TO, FROM)  \
143do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
144     scan_tp_[0] = ~ scan_fp_[0];                               \
145     scan_tp_[1] = ~ scan_fp_[1]; } while (0)
146
147#define AND_HARD_REG_SET(TO, FROM)  \
148do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
149     scan_tp_[0] &= scan_fp_[0];                                        \
150     scan_tp_[1] &= scan_fp_[1]; } while (0)
151
152#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
153do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
154     scan_tp_[0] &= ~ scan_fp_[0];                              \
155     scan_tp_[1] &= ~ scan_fp_[1]; } while (0)
156
157#define IOR_HARD_REG_SET(TO, FROM)  \
158do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
159     scan_tp_[0] |= scan_fp_[0];                                \
160     scan_tp_[1] |= scan_fp_[1]; } while (0)
161
162#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
163do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
164     scan_tp_[0] |= ~ scan_fp_[0];                              \
165     scan_tp_[1] |= ~ scan_fp_[1]; } while (0)
166
167#define GO_IF_HARD_REG_SUBSET(X,Y,TO)  \
168do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
169     if ((0 == (scan_xp_[0] & ~ scan_yp_[0]))                   \
170         && (0 == (scan_xp_[1] & ~ scan_yp_[1])))               \
171        goto TO; } while (0)
172
173#define GO_IF_HARD_REG_EQUAL(X,Y,TO)  \
174do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
175     if ((scan_xp_[0] == scan_yp_[0])                           \
176         && (scan_xp_[1] == scan_yp_[1]))                       \
177        goto TO; } while (0)
178
179#else
180#if FIRST_PSEUDO_REGISTER <= 3*HOST_BITS_PER_WIDE_INT
181#define CLEAR_HARD_REG_SET(TO)  \
182do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
183     scan_tp_[0] = 0;                                           \
184     scan_tp_[1] = 0;                                           \
185     scan_tp_[2] = 0; } while (0)
186
187#define SET_HARD_REG_SET(TO)  \
188do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
189     scan_tp_[0] = -1;                                          \
190     scan_tp_[1] = -1;                                          \
191     scan_tp_[2] = -1; } while (0)
192
193#define COPY_HARD_REG_SET(TO, FROM)  \
194do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);   \
195     scan_tp_[0] = scan_fp_[0];                                 \
196     scan_tp_[1] = scan_fp_[1];                                 \
197     scan_tp_[2] = scan_fp_[2]; } while (0)
198
199#define COMPL_HARD_REG_SET(TO, FROM)  \
200do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
201     scan_tp_[0] = ~ scan_fp_[0];                               \
202     scan_tp_[1] = ~ scan_fp_[1];                               \
203     scan_tp_[2] = ~ scan_fp_[2]; } while (0)
204
205#define AND_HARD_REG_SET(TO, FROM)  \
206do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
207     scan_tp_[0] &= scan_fp_[0];                                        \
208     scan_tp_[1] &= scan_fp_[1];                                        \
209     scan_tp_[2] &= scan_fp_[2]; } while (0)
210
211#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
212do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
213     scan_tp_[0] &= ~ scan_fp_[0];                              \
214     scan_tp_[1] &= ~ scan_fp_[1];                              \
215     scan_tp_[2] &= ~ scan_fp_[2]; } while (0)
216
217#define IOR_HARD_REG_SET(TO, FROM)  \
218do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
219     scan_tp_[0] |= scan_fp_[0];                                \
220     scan_tp_[1] |= scan_fp_[1];                                \
221     scan_tp_[2] |= scan_fp_[2]; } while (0)
222
223#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
224do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
225     scan_tp_[0] |= ~ scan_fp_[0];                              \
226     scan_tp_[1] |= ~ scan_fp_[1];                              \
227     scan_tp_[2] |= ~ scan_fp_[2]; } while (0)
228
229#define GO_IF_HARD_REG_SUBSET(X,Y,TO)  \
230do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
231     if ((0 == (scan_xp_[0] & ~ scan_yp_[0]))                   \
232         && (0 == (scan_xp_[1] & ~ scan_yp_[1]))                \
233         && (0 == (scan_xp_[2] & ~ scan_yp_[2])))               \
234        goto TO; } while (0)
235
236#define GO_IF_HARD_REG_EQUAL(X,Y,TO)  \
237do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
238     if ((scan_xp_[0] == scan_yp_[0])                           \
239         && (scan_xp_[1] == scan_yp_[1])                        \
240         && (scan_xp_[2] == scan_yp_[2]))                       \
241        goto TO; } while (0)
242
243#else
244#if FIRST_PSEUDO_REGISTER <= 4*HOST_BITS_PER_WIDE_INT
245#define CLEAR_HARD_REG_SET(TO)  \
246do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
247     scan_tp_[0] = 0;                                           \
248     scan_tp_[1] = 0;                                           \
249     scan_tp_[2] = 0;                                           \
250     scan_tp_[3] = 0; } while (0)
251
252#define SET_HARD_REG_SET(TO)  \
253do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
254     scan_tp_[0] = -1;                                          \
255     scan_tp_[1] = -1;                                          \
256     scan_tp_[2] = -1;                                          \
257     scan_tp_[3] = -1; } while (0)
258
259#define COPY_HARD_REG_SET(TO, FROM)  \
260do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM);   \
261     scan_tp_[0] = scan_fp_[0];                                 \
262     scan_tp_[1] = scan_fp_[1];                                 \
263     scan_tp_[2] = scan_fp_[2];                                 \
264     scan_tp_[3] = scan_fp_[3]; } while (0)
265
266#define COMPL_HARD_REG_SET(TO, FROM)  \
267do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
268     scan_tp_[0] = ~ scan_fp_[0];                               \
269     scan_tp_[1] = ~ scan_fp_[1];                               \
270     scan_tp_[2] = ~ scan_fp_[2];                               \
271     scan_tp_[3] = ~ scan_fp_[3]; } while (0)
272
273#define AND_HARD_REG_SET(TO, FROM)  \
274do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
275     scan_tp_[0] &= scan_fp_[0];                                        \
276     scan_tp_[1] &= scan_fp_[1];                                        \
277     scan_tp_[2] &= scan_fp_[2];                                        \
278     scan_tp_[3] &= scan_fp_[3]; } while (0)
279
280#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
281do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
282     scan_tp_[0] &= ~ scan_fp_[0];                              \
283     scan_tp_[1] &= ~ scan_fp_[1];                              \
284     scan_tp_[2] &= ~ scan_fp_[2];                              \
285     scan_tp_[3] &= ~ scan_fp_[3]; } while (0)
286
287#define IOR_HARD_REG_SET(TO, FROM)  \
288do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
289     scan_tp_[0] |= scan_fp_[0];                                \
290     scan_tp_[1] |= scan_fp_[1];                                \
291     scan_tp_[2] |= scan_fp_[2];                                \
292     scan_tp_[3] |= scan_fp_[3]; } while (0)
293
294#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
295do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
296     scan_tp_[0] |= ~ scan_fp_[0];                              \
297     scan_tp_[1] |= ~ scan_fp_[1];                              \
298     scan_tp_[2] |= ~ scan_fp_[2];                              \
299     scan_tp_[3] |= ~ scan_fp_[3]; } while (0)
300
301#define GO_IF_HARD_REG_SUBSET(X,Y,TO)  \
302do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
303     if ((0 == (scan_xp_[0] & ~ scan_yp_[0]))                   \
304         && (0 == (scan_xp_[1] & ~ scan_yp_[1]))                \
305         && (0 == (scan_xp_[2] & ~ scan_yp_[2]))                \
306         && (0 == (scan_xp_[3] & ~ scan_yp_[3])))               \
307        goto TO; } while (0)
308
309#define GO_IF_HARD_REG_EQUAL(X,Y,TO)  \
310do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
311     if ((scan_xp_[0] == scan_yp_[0])                           \
312         && (scan_xp_[1] == scan_yp_[1])                        \
313         && (scan_xp_[2] == scan_yp_[2])                        \
314         && (scan_xp_[3] == scan_yp_[3]))                       \
315        goto TO; } while (0)
316
317#else /* FIRST_PSEUDO_REGISTER > 3*HOST_BITS_PER_WIDE_INT */
318
319#define CLEAR_HARD_REG_SET(TO)  \
320do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
321     register int i;                                            \
322     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
323       *scan_tp_++ = 0; } while (0)
324
325#define SET_HARD_REG_SET(TO)  \
326do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO);               \
327     register int i;                                            \
328     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
329       *scan_tp_++ = -1; } while (0)
330
331#define COPY_HARD_REG_SET(TO, FROM)  \
332do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
333     register int i;                                            \
334     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
335       *scan_tp_++ = *scan_fp_++; } while (0)
336
337#define COMPL_HARD_REG_SET(TO, FROM)  \
338do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
339     register int i;                                            \
340     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
341       *scan_tp_++ = ~ *scan_fp_++; } while (0)
342
343#define AND_HARD_REG_SET(TO, FROM)  \
344do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
345     register int i;                                            \
346     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
347       *scan_tp_++ &= *scan_fp_++; } while (0)
348
349#define AND_COMPL_HARD_REG_SET(TO, FROM)  \
350do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
351     register int i;                                            \
352     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
353       *scan_tp_++ &= ~ *scan_fp_++; } while (0)
354
355#define IOR_HARD_REG_SET(TO, FROM)  \
356do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
357     register int i;                                            \
358     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
359       *scan_tp_++ |= *scan_fp_++; } while (0)
360
361#define IOR_COMPL_HARD_REG_SET(TO, FROM)  \
362do { register HARD_REG_ELT_TYPE *scan_tp_ = (TO), *scan_fp_ = (FROM); \
363     register int i;                                            \
364     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
365       *scan_tp_++ |= ~ *scan_fp_++; } while (0)
366
367#define GO_IF_HARD_REG_SUBSET(X,Y,TO)  \
368do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
369     register int i;                                            \
370     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
371       if (0 != (*scan_xp_++ & ~ *scan_yp_++)) break;           \
372     if (i == HARD_REG_SET_LONGS) goto TO; } while (0)
373
374#define GO_IF_HARD_REG_EQUAL(X,Y,TO)  \
375do { register HARD_REG_ELT_TYPE *scan_xp_ = (X), *scan_yp_ = (Y); \
376     register int i;                                            \
377     for (i = 0; i < HARD_REG_SET_LONGS; i++)                   \
378       if (*scan_xp_++ != *scan_yp_++) break;                   \
379     if (i == HARD_REG_SET_LONGS) goto TO; } while (0)
380
381#endif
382#endif
383#endif
384#endif
385
386/* Define some standard sets of registers.  */
387
388/* Indexed by hard register number, contains 1 for registers
389   that are fixed use (stack pointer, pc, frame pointer, etc.).
390   These are the registers that cannot be used to allocate
391   a pseudo reg whose life does not cross calls.  */
392
393extern char fixed_regs[FIRST_PSEUDO_REGISTER];
394
395/* The same info as a HARD_REG_SET.  */
396
397extern HARD_REG_SET fixed_reg_set;
398
399/* Indexed by hard register number, contains 1 for registers
400   that are fixed use or are clobbered by function calls.
401   These are the registers that cannot be used to allocate
402   a pseudo reg whose life crosses calls.  */
403
404extern char call_used_regs[FIRST_PSEUDO_REGISTER];
405
406/* The same info as a HARD_REG_SET.  */
407
408extern HARD_REG_SET call_used_reg_set;
409 
410/* Registers that we don't want to caller save.  */
411extern HARD_REG_SET losing_caller_save_reg_set;
412
413/* Indexed by hard register number, contains 1 for registers that are
414   fixed use -- i.e. in fixed_regs -- or a function value return register
415   or STRUCT_VALUE_REGNUM or STATIC_CHAIN_REGNUM.  These are the
416   registers that cannot hold quantities across calls even if we are
417   willing to save and restore them.  */
418
419extern char call_fixed_regs[FIRST_PSEUDO_REGISTER];
420
421/* The same info as a HARD_REG_SET.  */
422
423extern HARD_REG_SET call_fixed_reg_set;
424
425/* Indexed by hard register number, contains 1 for registers
426   that are being used for global register decls.
427   These must be exempt from ordinary flow analysis
428   and are also considered fixed.  */
429
430extern char global_regs[FIRST_PSEUDO_REGISTER];
431
432/* Table of register numbers in the order in which to try to use them.  */
433
434#ifdef REG_ALLOC_ORDER   /* Avoid undef symbol in certain broken linkers.  */
435extern int reg_alloc_order[FIRST_PSEUDO_REGISTER];
436#endif
437
438/* For each reg class, a HARD_REG_SET saying which registers are in it.  */
439
440extern HARD_REG_SET reg_class_contents[];
441
442/* For each reg class, number of regs it contains.  */
443
444extern int reg_class_size[N_REG_CLASSES];
445
446/* For each reg class, table listing all the containing classes.  */
447
448extern enum reg_class reg_class_superclasses[N_REG_CLASSES][N_REG_CLASSES];
449
450/* For each reg class, table listing all the classes contained in it.  */
451
452extern enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
453
454/* For each pair of reg classes,
455   a largest reg class contained in their union.  */
456
457extern enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
458
459/* For each pair of reg classes,
460   the smallest reg class that contains their union.  */
461
462extern enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
463
464/* Number of non-fixed registers.  */
465
466extern int n_non_fixed_regs;
467
468/* Vector indexed by hardware reg giving its name.  */
469
470extern char *reg_names[FIRST_PSEUDO_REGISTER];
Note: See TracBrowser for help on using the repository browser.