LCOV - code coverage report
Current view: top level - gcc - hard-reg-set.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 94 94 100.0 %
Date: 2020-03-28 11:57:23 Functions: 9 11 81.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Sets (bit vectors) of hard registers, and operations on them.
       2                 :            :    Copyright (C) 1987-2020 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 "array-traits.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                 :            : typedef HARD_REG_ELT_TYPE HARD_REG_SET;
      48                 :            : typedef const HARD_REG_SET const_hard_reg_set;
      49                 :            : 
      50                 :            : #else
      51                 :            : 
      52                 :            : #define HARD_REG_SET_LONGS \
      53                 :            :  ((FIRST_PSEUDO_REGISTER + HOST_BITS_PER_WIDEST_FAST_INT - 1)   \
      54                 :            :   / HOST_BITS_PER_WIDEST_FAST_INT)
      55                 :            : 
      56                 :            : struct HARD_REG_SET
      57                 :            : {
      58                 :            :   HARD_REG_SET
      59                 : 1419533780 :   operator~ () const
      60                 :            :   {
      61                 :  873920442 :     HARD_REG_SET res;
      62                 :27938810372 :     for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
      63                 :18625906228 :       res.elts[i] = ~elts[i];
      64                 : 9226605824 :     return res;
      65                 :            :   }
      66                 :            : 
      67                 :            :   HARD_REG_SET
      68                 : 8389375383 :   operator& (const HARD_REG_SET &other) const
      69                 :            :   {
      70                 :  758100948 :     HARD_REG_SET res;
      71                 :27613535850 :     for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
      72                 :18408989664 :       res.elts[i] = elts[i] & other.elts[i];
      73                 : 9064306943 :     return res;
      74                 :            :   }
      75                 :            : 
      76                 :            :   HARD_REG_SET &
      77                 : 1126413401 :   operator&= (const HARD_REG_SET &other)
      78                 :            :   {
      79                 : 3380620015 :     for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
      80                 : 2253742980 :       elts[i] &= other.elts[i];
      81                 : 1125610645 :     return *this;
      82                 :            :   }
      83                 :            : 
      84                 :            :   HARD_REG_SET
      85                 :  971491970 :   operator| (const HARD_REG_SET &other) const
      86                 :            :   {
      87                 :  271830400 :     HARD_REG_SET res;
      88                 : 5766732720 :     for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
      89                 : 3844482150 :       res.elts[i] = elts[i] | other.elts[i];
      90                 : 1835917570 :     return res;
      91                 :            :   }
      92                 :            : 
      93                 :            :   HARD_REG_SET &
      94                 :  259807587 :   operator|= (const HARD_REG_SET &other)
      95                 :            :   {
      96                 : 5878025357 :     for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
      97                 : 3918550738 :       elts[i] |= other.elts[i];
      98                 : 1465129649 :     return *this;
      99                 :            :   }
     100                 :            : 
     101                 :            :   bool
     102                 :  209772863 :   operator== (const HARD_REG_SET &other) const
     103                 :            :   {
     104                 :  155151063 :     HARD_REG_ELT_TYPE bad = 0;
     105                 : 1996837610 :     for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i)
     106                 : 2104505390 :       bad |= (elts[i] ^ other.elts[i]);
     107                 :  665612173 :     return bad == 0;
     108                 :            :   }
     109                 :            : 
     110                 :            :   bool
     111                 :            :   operator!= (const HARD_REG_SET &other) const
     112                 :            :   {
     113                 : 1159920000 :     return !operator== (other);
     114                 :            :   }
     115                 :            : 
     116                 :            :   HARD_REG_ELT_TYPE elts[HARD_REG_SET_LONGS];
     117                 :            : };
     118                 :            : typedef const HARD_REG_SET &const_hard_reg_set;
     119                 :            : 
     120                 :            : template<>
     121                 :            : struct array_traits<HARD_REG_SET>
     122                 :            : {
     123                 :            :   typedef HARD_REG_ELT_TYPE element_type;
     124                 :            :   static const bool has_constant_size = true;
     125                 :            :   static const size_t constant_size = HARD_REG_SET_LONGS;
     126                 :   98354900 :   static const element_type *base (const HARD_REG_SET &x) { return x.elts; }
     127                 :   98354900 :   static size_t size (const HARD_REG_SET &) { return HARD_REG_SET_LONGS; }
     128                 :            : };
     129                 :            : 
     130                 :            : #endif
     131                 :            : 
     132                 :            : /* HARD_REG_SET wrapped into a structure, to make it possible to
     133                 :            :    use HARD_REG_SET even in APIs that should not include
     134                 :            :    hard-reg-set.h.  */
     135                 :            : struct hard_reg_set_container
     136                 :            : {
     137                 :            :   HARD_REG_SET set;
     138                 :            : };
     139                 :            : 
     140                 :            : /* HARD_CONST is used to cast a constant to the appropriate type
     141                 :            :    for use with a HARD_REG_SET.  */
     142                 :            : 
     143                 :            : #define HARD_CONST(X) ((HARD_REG_ELT_TYPE) (X))
     144                 :            : 
     145                 :            : /* Define macros SET_HARD_REG_BIT, CLEAR_HARD_REG_BIT and TEST_HARD_REG_BIT
     146                 :            :    to set, clear or test one bit in a hard reg set of type HARD_REG_SET.
     147                 :            :    All three take two arguments: the set and the register number.
     148                 :            : 
     149                 :            :    In the case where sets are arrays of longs, the first argument
     150                 :            :    is actually a pointer to a long.
     151                 :            : 
     152                 :            :    Define two macros for initializing a set:
     153                 :            :    CLEAR_HARD_REG_SET and SET_HARD_REG_SET.
     154                 :            :    These take just one argument.
     155                 :            : 
     156                 :            :    Also define:
     157                 :            : 
     158                 :            :    hard_reg_set_subset_p (X, Y), which returns true if X is a subset of Y.
     159                 :            :    hard_reg_set_intersect_p (X, Y), which returns true if X and Y intersect.
     160                 :            :    hard_reg_set_empty_p (X), which returns true if X is empty.  */
     161                 :            : 
     162                 :            : #define UHOST_BITS_PER_WIDE_INT ((unsigned) HOST_BITS_PER_WIDEST_FAST_INT)
     163                 :            : 
     164                 :            : #if FIRST_PSEUDO_REGISTER <= HOST_BITS_PER_WIDEST_FAST_INT
     165                 :            : 
     166                 :            : #define SET_HARD_REG_BIT(SET, BIT)  \
     167                 :            :  ((SET) |= HARD_CONST (1) << (BIT))
     168                 :            : #define CLEAR_HARD_REG_BIT(SET, BIT)  \
     169                 :            :  ((SET) &= ~(HARD_CONST (1) << (BIT)))
     170                 :            : #define TEST_HARD_REG_BIT(SET, BIT)  \
     171                 :            :  (!!((SET) & (HARD_CONST (1) << (BIT))))
     172                 :            : 
     173                 :            : #define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0))
     174                 :            : #define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0))
     175                 :            : 
     176                 :            : static inline bool
     177                 :            : hard_reg_set_subset_p (const_hard_reg_set x, const_hard_reg_set y)
     178                 :            : {
     179                 :            :   return (x & ~y) == HARD_CONST (0);
     180                 :            : }
     181                 :            : 
     182                 :            : static inline bool
     183                 :            : hard_reg_set_intersect_p (const_hard_reg_set x, const_hard_reg_set y)
     184                 :            : {
     185                 :            :   return (x & y) != HARD_CONST (0);
     186                 :            : }
     187                 :            : 
     188                 :            : static inline bool
     189                 :            : hard_reg_set_empty_p (const_hard_reg_set x)
     190                 :            : {
     191                 :            :   return x == HARD_CONST (0);
     192                 :            : }
     193                 :            : 
     194                 :            : #else
     195                 :            : 
     196                 :            : inline void
     197                 :11790268552 : SET_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
     198                 :            : {
     199                 :11790268552 :   set.elts[bit / UHOST_BITS_PER_WIDE_INT]
     200                 : 4131782272 :     |= HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT);
     201                 : 7866623676 : }
     202                 :            : 
     203                 :            : inline void
     204                 :  462732345 : CLEAR_HARD_REG_BIT (HARD_REG_SET &set, unsigned int bit)
     205                 :            : {
     206                 :  462732345 :   set.elts[bit / UHOST_BITS_PER_WIDE_INT]
     207                 :  455944338 :     &= ~(HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT));
     208                 :  107709398 : }
     209                 :            : 
     210                 :            : inline bool
     211                 :54293636739 : TEST_HARD_REG_BIT (const_hard_reg_set set, unsigned int bit)
     212                 :            : {
     213                 :54293636739 :   return (set.elts[bit / UHOST_BITS_PER_WIDE_INT]
     214                 :50387127243 :           & (HARD_CONST (1) << (bit % UHOST_BITS_PER_WIDE_INT)));
     215                 :            : }
     216                 :            : 
     217                 :            : inline void
     218                 :  734955319 : CLEAR_HARD_REG_SET (HARD_REG_SET &set)
     219                 :            : {
     220                 :12312021313 :   for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
     221                 : 8254147072 :     set.elts[i] = 0;
     222                 :  566625000 : }
     223                 :            : 
     224                 :            : inline void
     225                 :   18482181 : SET_HARD_REG_SET (HARD_REG_SET &set)
     226                 :            : {
     227                 :   56816449 :   for (unsigned int i = 0; i < ARRAY_SIZE (set.elts); ++i)
     228                 :   37879766 :     set.elts[i] = -1;
     229                 :            : }
     230                 :            : 
     231                 :            : static inline bool
     232                 :34177802082 : hard_reg_set_subset_p (const_hard_reg_set x, const_hard_reg_set y)
     233                 :            : {
     234                 :38728760000 :   HARD_REG_ELT_TYPE bad = 0;
     235                 :>21771*10^7 :   for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
     236                 :>14514*10^7 :     bad |= (x.elts[i] & ~y.elts[i]);
     237                 :72483956162 :   return bad == 0;
     238                 :            : }
     239                 :            : 
     240                 :            : static inline bool
     241                 :21230115795 : hard_reg_set_intersect_p (const_hard_reg_set x, const_hard_reg_set y)
     242                 :            : {
     243                 :21635274110 :   HARD_REG_ELT_TYPE good = 0;
     244                 :79539805340 :   for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
     245                 :53026570220 :     good |= (x.elts[i] & y.elts[i]);
     246                 :26513275110 :   return good != 0;
     247                 :            : }
     248                 :            : 
     249                 :            : static inline bool
     250                 : 1394648460 : hard_reg_set_empty_p (const_hard_reg_set x)
     251                 :            : {
     252                 :  314813460 :   HARD_REG_ELT_TYPE bad = 0;
     253                 : 4271170500 :   for (unsigned int i = 0; i < ARRAY_SIZE (x.elts); ++i)
     254                 : 2847441900 :     bad |= x.elts[i];
     255                 : 1423723490 :   return bad == 0;
     256                 :            : }
     257                 :            : #endif
     258                 :            : 
     259                 :            : /* Iterator for hard register sets.  */
     260                 :            : 
     261                 :            : struct hard_reg_set_iterator
     262                 :            : {
     263                 :            :   /* Pointer to the current element.  */
     264                 :            :   const HARD_REG_ELT_TYPE *pelt;
     265                 :            : 
     266                 :            :   /* The length of the set.  */
     267                 :            :   unsigned short length;
     268                 :            : 
     269                 :            :   /* Word within the current element.  */
     270                 :            :   unsigned short word_no;
     271                 :            : 
     272                 :            :   /* Contents of the actually processed word.  When finding next bit
     273                 :            :      it is shifted right, so that the actual bit is always the least
     274                 :            :      significant bit of ACTUAL.  */
     275                 :            :   HARD_REG_ELT_TYPE bits;
     276                 :            : };
     277                 :            : 
     278                 :            : #define HARD_REG_ELT_BITS UHOST_BITS_PER_WIDE_INT
     279                 :            : 
     280                 :            : /* The implementation of the iterator functions is fully analogous to
     281                 :            :    the bitmap iterators.  */
     282                 :            : static inline void
     283                 :   24527606 : hard_reg_set_iter_init (hard_reg_set_iterator *iter, const_hard_reg_set set,
     284                 :            :                         unsigned min, unsigned *regno)
     285                 :            : {
     286                 :            : #ifdef HARD_REG_SET_LONGS
     287                 :   24527606 :   iter->pelt = set.elts;
     288                 :   24527606 :   iter->length = HARD_REG_SET_LONGS;
     289                 :            : #else
     290                 :            :   iter->pelt = &set;
     291                 :            :   iter->length = 1;
     292                 :            : #endif
     293                 :   24527606 :   iter->word_no = min / HARD_REG_ELT_BITS;
     294                 :   24527606 :   if (iter->word_no < iter->length)
     295                 :            :     {
     296                 :   24527606 :       iter->bits = iter->pelt[iter->word_no];
     297                 :   24527606 :       iter->bits >>= min % HARD_REG_ELT_BITS;
     298                 :            : 
     299                 :            :       /* This is required for correct search of the next bit.  */
     300                 :   24527606 :       min += !iter->bits;
     301                 :            :     }
     302                 :   24527606 :   *regno = min;
     303                 :   24527606 : }
     304                 :            : 
     305                 :            : static inline bool
     306                 : 1646202120 : hard_reg_set_iter_set (hard_reg_set_iterator *iter, unsigned *regno)
     307                 :            : {
     308                 : 1695209967 :   while (1)
     309                 :            :     {
     310                 :            :       /* Return false when we're advanced past the end of the set.  */
     311                 : 1695209967 :       if (iter->word_no >= iter->length)
     312                 :            :         return false;
     313                 :            : 
     314                 : 1670683620 :       if (iter->bits)
     315                 :            :         {
     316                 :            :           /* Find the correct bit and return it.  */
     317                 : 1862036096 :           while (!(iter->bits & 1))
     318                 :            :             {
     319                 :  240360963 :               iter->bits >>= 1;
     320                 :  240360963 :               *regno += 1;
     321                 :            :             }
     322                 : 1621674873 :           return (*regno < FIRST_PSEUDO_REGISTER);
     323                 :            :         }
     324                 :            : 
     325                 :            :       /* Round to the beginning of the next word.  */
     326                 :   49008449 :       *regno = (*regno + HARD_REG_ELT_BITS - 1);
     327                 :   49008449 :       *regno -= *regno % HARD_REG_ELT_BITS;
     328                 :            : 
     329                 :            :       /* Find the next non-zero word.  */
     330                 :   49053640 :       while (++iter->word_no < iter->length)
     331                 :            :         {
     332                 :   24526760 :           iter->bits = iter->pelt[iter->word_no];
     333                 :   24526760 :           if (iter->bits)
     334                 :            :             break;
     335                 :      45111 :           *regno += HARD_REG_ELT_BITS;
     336                 :            :         }
     337                 :            :     }
     338                 :            : }
     339                 :            : 
     340                 :            : static inline void
     341                 : 1621674027 : hard_reg_set_iter_next (hard_reg_set_iterator *iter, unsigned *regno)
     342                 :            : {
     343                 : 1621674027 :   iter->bits >>= 1;
     344                 : 1621674027 :   *regno += 1;
     345                 : 1621674027 : }
     346                 :            : 
     347                 :            : #define EXECUTE_IF_SET_IN_HARD_REG_SET(SET, MIN, REGNUM, ITER)          \
     348                 :            :   for (hard_reg_set_iter_init (&(ITER), (SET), (MIN), &(REGNUM));       \
     349                 :            :        hard_reg_set_iter_set (&(ITER), &(REGNUM));                      \
     350                 :            :        hard_reg_set_iter_next (&(ITER), &(REGNUM)))
     351                 :            : 
     352                 :            : 
     353                 :            : /* Define some standard sets of registers.  */
     354                 :            : 
     355                 :            : /* Indexed by hard register number, contains 1 for registers
     356                 :            :    that are being used for global register decls.
     357                 :            :    These must be exempt from ordinary flow analysis
     358                 :            :    and are also considered fixed.  */
     359                 :            : 
     360                 :            : extern char global_regs[FIRST_PSEUDO_REGISTER];
     361                 :            : 
     362                 :            : class simplifiable_subreg;
     363                 :            : class subreg_shape;
     364                 :            : 
     365                 :            : struct simplifiable_subregs_hasher : nofree_ptr_hash <simplifiable_subreg>
     366                 :            : {
     367                 :            :   typedef const subreg_shape *compare_type;
     368                 :            : 
     369                 :            :   static inline hashval_t hash (const simplifiable_subreg *);
     370                 :            :   static inline bool equal (const simplifiable_subreg *, const subreg_shape *);
     371                 :            : };
     372                 :            : 
     373                 :            : struct target_hard_regs {
     374                 :            :   void finalize ();
     375                 :            : 
     376                 :            :   /* The set of registers that actually exist on the current target.  */
     377                 :            :   HARD_REG_SET x_accessible_reg_set;
     378                 :            : 
     379                 :            :   /* The set of registers that should be considered to be register
     380                 :            :      operands.  It is a subset of x_accessible_reg_set.  */
     381                 :            :   HARD_REG_SET x_operand_reg_set;
     382                 :            : 
     383                 :            :   /* Indexed by hard register number, contains 1 for registers
     384                 :            :      that are fixed use (stack pointer, pc, frame pointer, etc.;.
     385                 :            :      These are the registers that cannot be used to allocate
     386                 :            :      a pseudo reg whose life does not cross calls.  */
     387                 :            :   char x_fixed_regs[FIRST_PSEUDO_REGISTER];
     388                 :            : 
     389                 :            :   /* The same info as a HARD_REG_SET.  */
     390                 :            :   HARD_REG_SET x_fixed_reg_set;
     391                 :            : 
     392                 :            :   /* Indexed by hard register number, contains 1 for registers
     393                 :            :      that are fixed use or are clobbered by function calls.
     394                 :            :      These are the registers that cannot be used to allocate
     395                 :            :      a pseudo reg whose life crosses calls.  */
     396                 :            :   char x_call_used_regs[FIRST_PSEUDO_REGISTER];
     397                 :            : 
     398                 :            :   /* For targets that use reload rather than LRA, this is the set
     399                 :            :      of registers that we are able to save and restore around calls
     400                 :            :      (i.e. those for which we know a suitable mode and set of
     401                 :            :      load/store instructions exist).  For LRA targets it contains
     402                 :            :      all registers.
     403                 :            : 
     404                 :            :      This is legacy information and should be removed if all targets
     405                 :            :      switch to LRA.  */
     406                 :            :   HARD_REG_SET x_savable_regs;
     407                 :            : 
     408                 :            :   /* Contains registers that are fixed use -- i.e. in fixed_reg_set -- but
     409                 :            :      only if they are not merely part of that set because they are global
     410                 :            :      regs.  Global regs that are not otherwise fixed can still take part
     411                 :            :      in register allocation.  */
     412                 :            :   HARD_REG_SET x_fixed_nonglobal_reg_set;
     413                 :            : 
     414                 :            :   /* Contains 1 for registers that are set or clobbered by calls.  */
     415                 :            :   /* ??? Ideally, this would be just call_used_regs plus global_regs, but
     416                 :            :      for someone's bright idea to have call_used_regs strictly include
     417                 :            :      fixed_regs.  Which leaves us guessing as to the set of fixed_regs
     418                 :            :      that are actually preserved.  We know for sure that those associated
     419                 :            :      with the local stack frame are safe, but scant others.  */
     420                 :            :   HARD_REG_SET x_regs_invalidated_by_call;
     421                 :            : 
     422                 :            :   /* Table of register numbers in the order in which to try to use them.  */
     423                 :            :   int x_reg_alloc_order[FIRST_PSEUDO_REGISTER];
     424                 :            : 
     425                 :            :   /* The inverse of reg_alloc_order.  */
     426                 :            :   int x_inv_reg_alloc_order[FIRST_PSEUDO_REGISTER];
     427                 :            : 
     428                 :            :   /* For each reg class, a HARD_REG_SET saying which registers are in it.  */
     429                 :            :   HARD_REG_SET x_reg_class_contents[N_REG_CLASSES];
     430                 :            : 
     431                 :            :   /* For each reg class, a boolean saying whether the class contains only
     432                 :            :      fixed registers.  */
     433                 :            :   bool x_class_only_fixed_regs[N_REG_CLASSES];
     434                 :            : 
     435                 :            :   /* For each reg class, number of regs it contains.  */
     436                 :            :   unsigned int x_reg_class_size[N_REG_CLASSES];
     437                 :            : 
     438                 :            :   /* For each reg class, table listing all the classes contained in it.  */
     439                 :            :   enum reg_class x_reg_class_subclasses[N_REG_CLASSES][N_REG_CLASSES];
     440                 :            : 
     441                 :            :   /* For each pair of reg classes,
     442                 :            :      a largest reg class contained in their union.  */
     443                 :            :   enum reg_class x_reg_class_subunion[N_REG_CLASSES][N_REG_CLASSES];
     444                 :            : 
     445                 :            :   /* For each pair of reg classes,
     446                 :            :      the smallest reg class that contains their union.  */
     447                 :            :   enum reg_class x_reg_class_superunion[N_REG_CLASSES][N_REG_CLASSES];
     448                 :            : 
     449                 :            :   /* Vector indexed by hardware reg giving its name.  */
     450                 :            :   const char *x_reg_names[FIRST_PSEUDO_REGISTER];
     451                 :            : 
     452                 :            :   /* Records which registers can form a particular subreg, with the subreg
     453                 :            :      being identified by its outer mode, inner mode and offset.  */
     454                 :            :   hash_table <simplifiable_subregs_hasher> *x_simplifiable_subregs;
     455                 :            : };
     456                 :            : 
     457                 :            : extern struct target_hard_regs default_target_hard_regs;
     458                 :            : #if SWITCHABLE_TARGET
     459                 :            : extern struct target_hard_regs *this_target_hard_regs;
     460                 :            : #else
     461                 :            : #define this_target_hard_regs (&default_target_hard_regs)
     462                 :            : #endif
     463                 :            : 
     464                 :            : #define accessible_reg_set \
     465                 :            :   (this_target_hard_regs->x_accessible_reg_set)
     466                 :            : #define operand_reg_set \
     467                 :            :   (this_target_hard_regs->x_operand_reg_set)
     468                 :            : #define fixed_regs \
     469                 :            :   (this_target_hard_regs->x_fixed_regs)
     470                 :            : #define fixed_reg_set \
     471                 :            :   (this_target_hard_regs->x_fixed_reg_set)
     472                 :            : #define fixed_nonglobal_reg_set \
     473                 :            :   (this_target_hard_regs->x_fixed_nonglobal_reg_set)
     474                 :            : #ifdef IN_TARGET_CODE
     475                 :            : #define call_used_regs \
     476                 :            :   (this_target_hard_regs->x_call_used_regs)
     477                 :            : #endif
     478                 :            : #define savable_regs \
     479                 :            :   (this_target_hard_regs->x_savable_regs)
     480                 :            : #ifdef IN_TARGET_CODE
     481                 :            : #define regs_invalidated_by_call \
     482                 :            :   (this_target_hard_regs->x_regs_invalidated_by_call)
     483                 :            : #define call_used_or_fixed_regs \
     484                 :            :   (regs_invalidated_by_call | fixed_reg_set)
     485                 :            : #endif
     486                 :            : #define reg_alloc_order \
     487                 :            :   (this_target_hard_regs->x_reg_alloc_order)
     488                 :            : #define inv_reg_alloc_order \
     489                 :            :   (this_target_hard_regs->x_inv_reg_alloc_order)
     490                 :            : #define reg_class_contents \
     491                 :            :   (this_target_hard_regs->x_reg_class_contents)
     492                 :            : #define class_only_fixed_regs \
     493                 :            :   (this_target_hard_regs->x_class_only_fixed_regs)
     494                 :            : #define reg_class_size \
     495                 :            :   (this_target_hard_regs->x_reg_class_size)
     496                 :            : #define reg_class_subclasses \
     497                 :            :   (this_target_hard_regs->x_reg_class_subclasses)
     498                 :            : #define reg_class_subunion \
     499                 :            :   (this_target_hard_regs->x_reg_class_subunion)
     500                 :            : #define reg_class_superunion \
     501                 :            :   (this_target_hard_regs->x_reg_class_superunion)
     502                 :            : #define reg_names \
     503                 :            :   (this_target_hard_regs->x_reg_names)
     504                 :            : 
     505                 :            : /* Vector indexed by reg class giving its name.  */
     506                 :            : 
     507                 :            : extern const char * reg_class_names[];
     508                 :            : 
     509                 :            : /* Given a hard REGN a FROM mode and a TO mode, return true if
     510                 :            :    REGN can change from mode FROM to mode TO.  */
     511                 :            : #define REG_CAN_CHANGE_MODE_P(REGN, FROM, TO)                          \
     512                 :            :   (targetm.can_change_mode_class (FROM, TO, REGNO_REG_CLASS (REGN)))
     513                 :            : 
     514                 :            : #ifdef IN_TARGET_CODE
     515                 :            : /* Return true if register REGNO is either fixed or call-used
     516                 :            :    (aka call-clobbered).  */
     517                 :            : 
     518                 :            : inline bool
     519                 :  137325700 : call_used_or_fixed_reg_p (unsigned int regno)
     520                 :            : {
     521                 :  137325700 :   return fixed_regs[regno] || this_target_hard_regs->x_call_used_regs[regno];
     522                 :            : }
     523                 :            : #endif
     524                 :            : 
     525                 :            : #endif /* ! GCC_HARD_REG_SET_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.