gcc/hard-reg-set.h

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