gcc/hard-reg-set.h

   1 /* Sets (bit vectors) of hard registers, and operations on them.
   2    Copyright (C) 1987, 1992, 1994, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, 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
  39 typedef 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)
  50 typedef 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)  \
 128 do { 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)  \
 133 do { 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)  \
 138 do { 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)  \
 143 do { 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)  \
 148 do { 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)  \
 153 do { 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)  \
 158 do { 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)  \
 163 do { 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)  \
 168 do { 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)  \
 174 do { 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)  \
 182 do { 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)  \
 188 do { 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)  \
 194 do { 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)  \
 200 do { 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)  \
 206 do { 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)  \
 212 do { 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)  \
 218 do { 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)  \
 224 do { 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)  \
 230 do { 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)  \
 237 do { 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)  \
 246 do { 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)  \
 253 do { 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)  \
 260 do { 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)  \
 267 do { 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)  \
 274 do { 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)  \
 281 do { 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)  \
 288 do { 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)  \
 295 do { 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)  \
 302 do { 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)  \
 310 do { 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)  \
 320 do { 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)  \
 326 do { 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)  \
 332 do { 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)  \
 338 do { 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)  \
 344 do { 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)  \
 350 do { 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)  \
 356 do { 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)  \
 362 do { 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)  \
 368 do { 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)  \
 375 do { 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
 393 extern char fixed_regs[FIRST_PSEUDO_REGISTER];
 394
 395 /* The same info as a HARD_REG_SET.  */
 396
 397 extern 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
 404 extern char call_used_regs[FIRST_PSEUDO_REGISTER];
 405
 406 /* The same info as a HARD_REG_SET.  */
 407
 408 extern HARD_REG_SET call_used_reg_set;
 409
 410 /* Registers that we don't want to caller save.  */
 411 extern 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
 419 extern char call_fixed_regs[FIRST_PSEUDO_REGISTER];
 420
 421 /* The same info as a HARD_REG_SET.  */
 422
 423 extern 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
 430 extern char global_regs[FIRST_PSEUDO_REGISTER];
 431
 432 #ifdef REG_ALLOC_ORDER
 433 /* Table of register numbers in the order in which to try to use them.  */
 434
 435 extern int reg_alloc_order[FIRST_PSEUDO_REGISTER];
 436
 437 /* The inverse of reg_alloc_order.  */
 438
 439 extern int inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
 440 #endif
 441
 442 /* For each reg class, a HARD_REG_SET saying which registers are in it.  */
 443
 444 extern HARD_REG_SET reg_class_contents[];
 445
 446 /* For each reg class, number of regs it contains.  */
 447
 448 extern unsigned int reg_class_size[N_REG_CLASSES];
 449
 450 /* For each reg class, table listing all the containing classes.  */
 451
 452 extern enum reg_class reg_class_superclasses[N_REG_CLASSES][N_REG_CLASSES];
 453
 454 /* For each reg class, table listing all the classes contained in it.  */
 455
 456 extern enum reg_class reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
 457
 458 /* For each pair of reg classes,
 459    a largest reg class contained in their union.  */
 460
 461 extern enum reg_class reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
 462
 463 /* For each pair of reg classes,
 464    the smallest reg class that contains their union.  */
 465
 466 extern enum reg_class reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
 467
 468 /* Number of non-fixed registers.  */
 469
 470 extern int n_non_fixed_regs;
 471
 472 /* Vector indexed by hardware reg giving its name.  */
 473
 474 extern const char *reg_names[FIRST_PSEUDO_REGISTER];