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