LCOV - code coverage report
Current view: top level - gcc - reginfo.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 91.8 % 523 480
Test Date: 2024-11-30 13:30:02 Functions: 94.9 % 39 37
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Compute different info about registers.
       2                 :             :    Copyright (C) 1987-2024 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                 :             : 
      21                 :             : /* This file contains regscan pass of the compiler and passes for
      22                 :             :    dealing with info about modes of pseudo-registers inside
      23                 :             :    subregisters.  It also defines some tables of information about the
      24                 :             :    hardware registers, function init_reg_sets to initialize the
      25                 :             :    tables, and other auxiliary functions to deal with info about
      26                 :             :    registers and their classes.  */
      27                 :             : 
      28                 :             : #include "config.h"
      29                 :             : #include "system.h"
      30                 :             : #include "coretypes.h"
      31                 :             : #include "backend.h"
      32                 :             : #include "target.h"
      33                 :             : #include "rtl.h"
      34                 :             : #include "tree.h"
      35                 :             : #include "df.h"
      36                 :             : #include "memmodel.h"
      37                 :             : #include "tm_p.h"
      38                 :             : #include "insn-config.h"
      39                 :             : #include "regs.h"
      40                 :             : #include "ira.h"
      41                 :             : #include "recog.h"
      42                 :             : #include "diagnostic-core.h"
      43                 :             : #include "reload.h"
      44                 :             : #include "output.h"
      45                 :             : #include "tree-pass.h"
      46                 :             : #include "function-abi.h"
      47                 :             : 
      48                 :             : /* Maximum register number used in this function, plus one.  */
      49                 :             : 
      50                 :             : int max_regno;
      51                 :             : 
      52                 :             : /* Used to cache the results of simplifiable_subregs.  SHAPE is the input
      53                 :             :    parameter and SIMPLIFIABLE_REGS is the result.  */
      54                 :             : class simplifiable_subreg
      55                 :             : {
      56                 :             : public:
      57                 :             :   simplifiable_subreg (const subreg_shape &);
      58                 :             : 
      59                 :             :   subreg_shape shape;
      60                 :             :   HARD_REG_SET simplifiable_regs;
      61                 :             : };
      62                 :             : 
      63                 :             : struct target_hard_regs default_target_hard_regs;
      64                 :             : struct target_regs default_target_regs;
      65                 :             : #if SWITCHABLE_TARGET
      66                 :             : struct target_hard_regs *this_target_hard_regs = &default_target_hard_regs;
      67                 :             : struct target_regs *this_target_regs = &default_target_regs;
      68                 :             : #endif
      69                 :             : 
      70                 :             : #define call_used_regs \
      71                 :             :   (this_target_hard_regs->x_call_used_regs)
      72                 :             : #define regs_invalidated_by_call \
      73                 :             :   (this_target_hard_regs->x_regs_invalidated_by_call)
      74                 :             : 
      75                 :             : /* Data for initializing fixed_regs.  */
      76                 :             : static const char initial_fixed_regs[] = FIXED_REGISTERS;
      77                 :             : 
      78                 :             : /* Data for initializing call_used_regs.  */
      79                 :             : #ifdef CALL_REALLY_USED_REGISTERS
      80                 :             : #ifdef CALL_USED_REGISTERS
      81                 :             : #error CALL_USED_REGISTERS and CALL_REALLY_USED_REGISTERS are both defined
      82                 :             : #endif
      83                 :             : static const char initial_call_used_regs[] = CALL_REALLY_USED_REGISTERS;
      84                 :             : #else
      85                 :             : static const char initial_call_used_regs[] = CALL_USED_REGISTERS;
      86                 :             : #endif
      87                 :             : 
      88                 :             : /* Indexed by hard register number, contains 1 for registers
      89                 :             :    that are being used for global register decls.
      90                 :             :    These must be exempt from ordinary flow analysis
      91                 :             :    and are also considered fixed.  */
      92                 :             : char global_regs[FIRST_PSEUDO_REGISTER];
      93                 :             : 
      94                 :             : /* The set of global registers.  */
      95                 :             : HARD_REG_SET global_reg_set;
      96                 :             : 
      97                 :             : /* Declaration for the global register. */
      98                 :             : tree global_regs_decl[FIRST_PSEUDO_REGISTER];
      99                 :             : 
     100                 :             : /* Used to initialize reg_alloc_order.  */
     101                 :             : #ifdef REG_ALLOC_ORDER
     102                 :             : static int initial_reg_alloc_order[FIRST_PSEUDO_REGISTER] = REG_ALLOC_ORDER;
     103                 :             : #endif
     104                 :             : 
     105                 :             : /* The same information, but as an array of unsigned ints.  We copy from
     106                 :             :    these unsigned ints to the table above.  We do this so the tm.h files
     107                 :             :    do not have to be aware of the wordsize for machines with <= 64 regs.
     108                 :             :    Note that we hard-code 32 here, not HOST_BITS_PER_INT.  */
     109                 :             : #define N_REG_INTS  \
     110                 :             :   ((FIRST_PSEUDO_REGISTER + (32 - 1)) / 32)
     111                 :             : 
     112                 :             : static const unsigned int_reg_class_contents[N_REG_CLASSES][N_REG_INTS]
     113                 :             :   = REG_CLASS_CONTENTS;
     114                 :             : 
     115                 :             : /* Array containing all of the register names.  */
     116                 :             : static const char *const initial_reg_names[] = REGISTER_NAMES;
     117                 :             : 
     118                 :             : /* Array containing all of the register class names.  */
     119                 :             : const char * reg_class_names[] = REG_CLASS_NAMES;
     120                 :             : 
     121                 :             : /* No more global register variables may be declared; true once
     122                 :             :    reginfo has been initialized.  */
     123                 :             : static int no_global_reg_vars = 0;
     124                 :             : 
     125                 :             : static void
     126                 :      254120 : clear_global_regs_cache (void)
     127                 :             : {
     128                 :    23633160 :   for (size_t i = 0 ; i < FIRST_PSEUDO_REGISTER ; i++)
     129                 :             :   {
     130                 :    23379040 :     global_regs[i] = 0;
     131                 :    23379040 :     global_regs_decl[i] = NULL;
     132                 :             :   }
     133                 :           0 : }
     134                 :             : 
     135                 :             : void
     136                 :      254120 : reginfo_cc_finalize (void)
     137                 :             : {
     138                 :      254120 :   clear_global_regs_cache ();
     139                 :      254120 :   no_global_reg_vars = 0;
     140                 :      254120 :   CLEAR_HARD_REG_SET (global_reg_set);
     141                 :      254120 : }
     142                 :             : 
     143                 :             : /* In insn-preds.cc.  */
     144                 :             : extern void init_reg_class_start_regs ();
     145                 :             : 
     146                 :             : /* Given a register bitmap, turn on the bits in a HARD_REG_SET that
     147                 :             :    correspond to the hard registers, if any, set in that map.  This
     148                 :             :    could be done far more efficiently by having all sorts of special-cases
     149                 :             :    with moving single words, but probably isn't worth the trouble.  */
     150                 :             : void
     151                 :    61829523 : reg_set_to_hard_reg_set (HARD_REG_SET *to, const_bitmap from)
     152                 :             : {
     153                 :    61829523 :   unsigned i;
     154                 :    61829523 :   bitmap_iterator bi;
     155                 :             : 
     156                 :   375145303 :   EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi)
     157                 :             :     {
     158                 :   347286336 :       if (i >= FIRST_PSEUDO_REGISTER)
     159                 :    33970556 :         return;
     160                 :   313315780 :       SET_HARD_REG_BIT (*to, i);
     161                 :             :     }
     162                 :             : }
     163                 :             : 
     164                 :             : /* Function called only once per target_globals to initialize the
     165                 :             :    target_hard_regs structure.  Once this is done, various switches
     166                 :             :    may override.  */
     167                 :             : void
     168                 :      845513 : init_reg_sets (void)
     169                 :             : {
     170                 :      845513 :   int i, j;
     171                 :             : 
     172                 :             :   /* First copy the register information from the initial int form into
     173                 :             :      the regsets.  */
     174                 :             : 
     175                 :    29592955 :   for (i = 0; i < N_REG_CLASSES; i++)
     176                 :             :     {
     177                 :    28747442 :       CLEAR_HARD_REG_SET (reg_class_contents[i]);
     178                 :             : 
     179                 :             :       /* Note that we hard-code 32 here, not HOST_BITS_PER_INT.  */
     180                 :  2673512106 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
     181                 :  2644764664 :         if (int_reg_class_contents[i][j / 32]
     182                 :  2644764664 :             & ((unsigned) 1 << (j % 32)))
     183                 :   503925748 :           SET_HARD_REG_BIT (reg_class_contents[i], j);
     184                 :             :     }
     185                 :             : 
     186                 :             :   /* Sanity check: make sure the target macros FIXED_REGISTERS and
     187                 :             :      CALL_USED_REGISTERS had the right number of initializers.  */
     188                 :      845513 :   gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs);
     189                 :      845513 :   gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs);
     190                 :             : #ifdef REG_ALLOC_ORDER
     191                 :      845513 :   gcc_assert (sizeof reg_alloc_order == sizeof initial_reg_alloc_order);
     192                 :             : #endif
     193                 :      845513 :   gcc_assert (sizeof reg_names == sizeof initial_reg_names);
     194                 :             : 
     195                 :      845513 :   memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
     196                 :      845513 :   memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
     197                 :             : #ifdef REG_ALLOC_ORDER
     198                 :      845513 :   memcpy (reg_alloc_order, initial_reg_alloc_order, sizeof reg_alloc_order);
     199                 :             : #endif
     200                 :      845513 :   memcpy (reg_names, initial_reg_names, sizeof reg_names);
     201                 :             : 
     202                 :     3382052 :   SET_HARD_REG_SET (accessible_reg_set);
     203                 :      845513 :   SET_HARD_REG_SET (operand_reg_set);
     204                 :             : 
     205                 :      845513 :   init_reg_class_start_regs ();
     206                 :      845513 : }
     207                 :             : 
     208                 :             : /* We need to save copies of some of the register information which
     209                 :             :    can be munged by command-line switches so we can restore it during
     210                 :             :    subsequent back-end reinitialization.  */
     211                 :             : static char saved_fixed_regs[FIRST_PSEUDO_REGISTER];
     212                 :             : static char saved_call_used_regs[FIRST_PSEUDO_REGISTER];
     213                 :             : static const char *saved_reg_names[FIRST_PSEUDO_REGISTER];
     214                 :             : static HARD_REG_SET saved_accessible_reg_set;
     215                 :             : static HARD_REG_SET saved_operand_reg_set;
     216                 :             : 
     217                 :             : /* Save the register information.  */
     218                 :             : void
     219                 :      275349 : save_register_info (void)
     220                 :             : {
     221                 :             :   /* Sanity check:  make sure the target macros FIXED_REGISTERS and
     222                 :             :      CALL_USED_REGISTERS had the right number of initializers.  */
     223                 :      275349 :   gcc_assert (sizeof fixed_regs == sizeof saved_fixed_regs);
     224                 :      275349 :   gcc_assert (sizeof call_used_regs == sizeof saved_call_used_regs);
     225                 :      275349 :   memcpy (saved_fixed_regs, fixed_regs, sizeof fixed_regs);
     226                 :      275349 :   memcpy (saved_call_used_regs, call_used_regs, sizeof call_used_regs);
     227                 :             : 
     228                 :             :   /* And similarly for reg_names.  */
     229                 :      275349 :   gcc_assert (sizeof reg_names == sizeof saved_reg_names);
     230                 :      275349 :   memcpy (saved_reg_names, reg_names, sizeof reg_names);
     231                 :      275349 :   saved_accessible_reg_set = accessible_reg_set;
     232                 :      275349 :   saved_operand_reg_set = operand_reg_set;
     233                 :      275349 : }
     234                 :             : 
     235                 :             : /* Restore the register information.  */
     236                 :             : static void
     237                 :      882273 : restore_register_info (void)
     238                 :             : {
     239                 :      882273 :   memcpy (fixed_regs, saved_fixed_regs, sizeof fixed_regs);
     240                 :      882273 :   memcpy (call_used_regs, saved_call_used_regs, sizeof call_used_regs);
     241                 :             : 
     242                 :      882273 :   memcpy (reg_names, saved_reg_names, sizeof reg_names);
     243                 :      882273 :   accessible_reg_set = saved_accessible_reg_set;
     244                 :      882273 :   operand_reg_set = saved_operand_reg_set;
     245                 :      882273 : }
     246                 :             : 
     247                 :             : /* After switches have been processed, which perhaps alter
     248                 :             :    `fixed_regs' and `call_used_regs', convert them to HARD_REG_SETs.  */
     249                 :             : static void
     250                 :      882273 : init_reg_sets_1 (void)
     251                 :             : {
     252                 :      882273 :   unsigned int i, j;
     253                 :      882273 :   unsigned int /* machine_mode */ m;
     254                 :             : 
     255                 :      882273 :   restore_register_info ();
     256                 :             : 
     257                 :             : #ifdef REG_ALLOC_ORDER
     258                 :    82933662 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     259                 :    81169116 :     inv_reg_alloc_order[reg_alloc_order[i]] = i;
     260                 :             : #endif
     261                 :             : 
     262                 :             :   /* Let the target tweak things if necessary.  */
     263                 :             : 
     264                 :      882273 :   targetm.conditional_register_usage ();
     265                 :             : 
     266                 :             :   /* Compute number of hard regs in each class.  */
     267                 :             : 
     268                 :      882273 :   memset (reg_class_size, 0, sizeof reg_class_size);
     269                 :    30879555 :   for (i = 0; i < N_REG_CLASSES; i++)
     270                 :             :     {
     271                 :             :       bool any_nonfixed = false;
     272                 :  2789747226 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
     273                 :  2759749944 :         if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
     274                 :             :           {
     275                 :   547799063 :             reg_class_size[i]++;
     276                 :   547799063 :             if (!fixed_regs[j])
     277                 :  2759749944 :               any_nonfixed = true;
     278                 :             :           }
     279                 :    29997282 :       class_only_fixed_regs[i] = !any_nonfixed;
     280                 :             :     }
     281                 :             : 
     282                 :             :   /* Initialize the table of subunions.
     283                 :             :      reg_class_subunion[I][J] gets the largest-numbered reg-class
     284                 :             :      that is contained in the union of classes I and J.  */
     285                 :             : 
     286                 :      882273 :   memset (reg_class_subunion, 0, sizeof reg_class_subunion);
     287                 :    30879555 :   for (i = 0; i < N_REG_CLASSES; i++)
     288                 :             :     {
     289                 :  1049904870 :       for (j = 0; j < N_REG_CLASSES; j++)
     290                 :             :         {
     291                 :  1019907588 :           HARD_REG_SET c;
     292                 :  1019907588 :           int k;
     293                 :             : 
     294                 :  1019907588 :           c = reg_class_contents[i] | reg_class_contents[j];
     295                 : 35696765580 :           for (k = 0; k < N_REG_CLASSES; k++)
     296                 : 34676857992 :             if (hard_reg_set_subset_p (reg_class_contents[k], c)
     297                 : 48844035451 :                 && !hard_reg_set_subset_p (reg_class_contents[k],
     298                 :             :                                           reg_class_contents
     299                 : 14167177459 :                                           [(int) reg_class_subunion[i][j]]))
     300                 : 11596097554 :               reg_class_subunion[i][j] = (enum reg_class) k;
     301                 :             :         }
     302                 :             :     }
     303                 :             : 
     304                 :             :   /* Initialize the table of superunions.
     305                 :             :      reg_class_superunion[I][J] gets the smallest-numbered reg-class
     306                 :             :      containing the union of classes I and J.  */
     307                 :             : 
     308                 :      882273 :   memset (reg_class_superunion, 0, sizeof reg_class_superunion);
     309                 :    30879555 :   for (i = 0; i < N_REG_CLASSES; i++)
     310                 :             :     {
     311                 :  1049904870 :       for (j = 0; j < N_REG_CLASSES; j++)
     312                 :             :         {
     313                 :  1019907588 :           HARD_REG_SET c;
     314                 :  1019907588 :           int k;
     315                 :             : 
     316                 :  1019907588 :           c = reg_class_contents[i] | reg_class_contents[j];
     317                 : 25800547682 :           for (k = 0; k < N_REG_CLASSES; k++)
     318                 : 25800547682 :             if (hard_reg_set_subset_p (c, reg_class_contents[k]))
     319                 :             :               break;
     320                 :             : 
     321                 :  1019907588 :           reg_class_superunion[i][j] = (enum reg_class) k;
     322                 :             :         }
     323                 :             :     }
     324                 :             : 
     325                 :             :   /* Initialize the tables of subclasses and superclasses of each reg class.
     326                 :             :      First clear the whole table, then add the elements as they are found.  */
     327                 :             : 
     328                 :    30879555 :   for (i = 0; i < N_REG_CLASSES; i++)
     329                 :             :     {
     330                 :  1049904870 :       for (j = 0; j < N_REG_CLASSES; j++)
     331                 :  1019907588 :         reg_class_subclasses[i][j] = LIM_REG_CLASSES;
     332                 :             :     }
     333                 :             : 
     334                 :    30879555 :   for (i = 0; i < N_REG_CLASSES; i++)
     335                 :             :     {
     336                 :    29997282 :       if (i == (int) NO_REGS)
     337                 :      882273 :         continue;
     338                 :             : 
     339                 :   494955153 :       for (j = i + 1; j < N_REG_CLASSES; j++)
     340                 :   465840144 :         if (hard_reg_set_subset_p (reg_class_contents[i],
     341                 :             :                                   reg_class_contents[j]))
     342                 :             :           {
     343                 :             :             /* Reg class I is a subclass of J.
     344                 :             :                Add J to the table of superclasses of I.  */
     345                 :   191389191 :             enum reg_class *p;
     346                 :             : 
     347                 :             :             /* Add I to the table of superclasses of J.  */
     348                 :   191389191 :             p = &reg_class_subclasses[j][0];
     349                 :  1760711444 :             while (*p != LIM_REG_CLASSES) p++;
     350                 :   191389191 :             *p = (enum reg_class) i;
     351                 :             :           }
     352                 :             :     }
     353                 :             : 
     354                 :             :   /* Initialize "constant" tables.  */
     355                 :             : 
     356                 :     2646819 :   CLEAR_HARD_REG_SET (fixed_reg_set);
     357                 :     2646819 :   CLEAR_HARD_REG_SET (regs_invalidated_by_call);
     358                 :             : 
     359                 :    82051389 :   operand_reg_set &= accessible_reg_set;
     360                 :    82051389 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     361                 :             :     {
     362                 :             :       /* As a special exception, registers whose class is NO_REGS are
     363                 :             :          not accepted by `register_operand'.  The reason for this change
     364                 :             :          is to allow the representation of special architecture artifacts
     365                 :             :          (such as a condition code register) without extending the rtl
     366                 :             :          definitions.  Since registers of class NO_REGS cannot be used
     367                 :             :          as registers in any case where register classes are examined,
     368                 :             :          it is better to apply this exception in a target-independent way.  */
     369                 :    81169116 :       if (REGNO_REG_CLASS (i) == NO_REGS)
     370                 :     1764546 :         CLEAR_HARD_REG_BIT (operand_reg_set, i);
     371                 :             : 
     372                 :             :       /* If a register is too limited to be treated as a register operand,
     373                 :             :          then it should never be allocated to a pseudo.  */
     374                 :    81169116 :       if (!TEST_HARD_REG_BIT (operand_reg_set, i))
     375                 :    36260426 :         fixed_regs[i] = 1;
     376                 :             : 
     377                 :    81169116 :       if (fixed_regs[i])
     378                 :    38907410 :         SET_HARD_REG_BIT (fixed_reg_set, i);
     379                 :             : 
     380                 :             :       /* There are a couple of fixed registers that we know are safe to
     381                 :             :          exclude from being clobbered by calls:
     382                 :             : 
     383                 :             :          The frame pointer is always preserved across calls.  The arg
     384                 :             :          pointer is if it is fixed.  The stack pointer usually is,
     385                 :             :          unless TARGET_RETURN_POPS_ARGS, in which case an explicit
     386                 :             :          CLOBBER will be present.  If we are generating PIC code, the
     387                 :             :          PIC offset table register is preserved across calls, though the
     388                 :             :          target can override that.  */
     389                 :             : 
     390                 :    81169116 :       if (i == STACK_POINTER_REGNUM)
     391                 :             :         ;
     392                 :    80286843 :       else if (global_regs[i])
     393                 :          97 :         SET_HARD_REG_BIT (regs_invalidated_by_call, i);
     394                 :    80286746 :       else if (i == FRAME_POINTER_REGNUM)
     395                 :             :         ;
     396                 :    79404473 :       else if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
     397                 :             :                && i == HARD_FRAME_POINTER_REGNUM)
     398                 :             :         ;
     399                 :    78522212 :       else if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
     400                 :      882273 :                && i == ARG_POINTER_REGNUM && fixed_regs[i])
     401                 :             :         ;
     402                 :    77639939 :       else if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
     403                 :    77639939 :                && i == (unsigned) PIC_OFFSET_TABLE_REGNUM && fixed_regs[i])
     404                 :             :         ;
     405                 :    77639939 :       else if (call_used_regs[i])
     406                 :    72720407 :         SET_HARD_REG_BIT (regs_invalidated_by_call, i);
     407                 :             :     }
     408                 :             : 
     409                 :      882273 :   SET_HARD_REG_SET (savable_regs);
     410                 :      882273 :   fixed_nonglobal_reg_set = fixed_reg_set;
     411                 :             : 
     412                 :             :   /* Preserve global registers if called more than once.  */
     413                 :    82051389 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     414                 :             :     {
     415                 :    81169116 :       if (global_regs[i])
     416                 :             :         {
     417                 :          97 :           fixed_regs[i] = call_used_regs[i] = 1;
     418                 :          97 :           SET_HARD_REG_BIT (fixed_reg_set, i);
     419                 :          97 :           SET_HARD_REG_BIT (global_reg_set, i);
     420                 :             :         }
     421                 :             :     }
     422                 :             : 
     423                 :             :   /* Recalculate eh_return_data_regs.  */
     424                 :     2646819 :   CLEAR_HARD_REG_SET (eh_return_data_regs);
     425                 :     1764546 :   for (i = 0; ; ++i)
     426                 :             :     {
     427                 :     2646819 :       unsigned int regno = EH_RETURN_DATA_REGNO (i);
     428                 :     2646819 :       if (regno == INVALID_REGNUM)
     429                 :             :         break;
     430                 :     1764546 :       SET_HARD_REG_BIT (eh_return_data_regs, regno);
     431                 :     1764546 :     }
     432                 :             : 
     433                 :      882273 :   memset (have_regs_of_mode, 0, sizeof (have_regs_of_mode));
     434                 :      882273 :   memset (contains_reg_of_mode, 0, sizeof (contains_reg_of_mode));
     435                 :   115577763 :   for (m = 0; m < (unsigned int) MAX_MACHINE_MODE; m++)
     436                 :             :     {
     437                 :             :       HARD_REG_SET ok_regs, ok_regs2;
     438                 :   344086470 :       CLEAR_HARD_REG_SET (ok_regs);
     439                 : 10666680570 :       CLEAR_HARD_REG_SET (ok_regs2);
     440                 : 10666680570 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
     441                 : 10551985080 :         if (!TEST_HARD_REG_BIT (fixed_nonglobal_reg_set, j)
     442                 : 10551985080 :             && targetm.hard_regno_mode_ok (j, (machine_mode) m))
     443                 :             :           {
     444                 :  1146702793 :             SET_HARD_REG_BIT (ok_regs, j);
     445                 :  1146702793 :             if (!fixed_regs[j])
     446                 :  1146699169 :               SET_HARD_REG_BIT (ok_regs2, j);
     447                 :             :           }
     448                 :             : 
     449                 :  4014342150 :       for (i = 0; i < N_REG_CLASSES; i++)
     450                 :  3899646660 :         if ((targetm.class_max_nregs ((reg_class_t) i, (machine_mode) m)
     451                 :  3899646660 :              <= reg_class_size[i])
     452                 :  7098258252 :             && hard_reg_set_intersect_p (ok_regs, reg_class_contents[i]))
     453                 :             :           {
     454                 :   862985386 :              contains_reg_of_mode[i][m] = 1;
     455                 :  1725970772 :              if (hard_reg_set_intersect_p (ok_regs2, reg_class_contents[i]))
     456                 :             :                {
     457                 :   862984206 :                  have_regs_of_mode[m] = 1;
     458                 :   862984206 :                  contains_allocatable_reg_of_mode[i][m] = 1;
     459                 :             :                }
     460                 :             :           }
     461                 :             :      }
     462                 :             : 
     463                 :      882273 :   default_function_abi.initialize (0, regs_invalidated_by_call);
     464                 :      882273 : }
     465                 :             : 
     466                 :             : /* Compute the table of register modes.
     467                 :             :    These values are used to record death information for individual registers
     468                 :             :    (as opposed to a multi-register mode).
     469                 :             :    This function might be invoked more than once, if the target has support
     470                 :             :    for changing register usage conventions on a per-function basis.
     471                 :             : */
     472                 :             : void
     473                 :      836744 : init_reg_modes_target (void)
     474                 :             : {
     475                 :      836744 :   int i, j;
     476                 :             : 
     477                 :      836744 :   this_target_regs->x_hard_regno_max_nregs = 1;
     478                 :    77817192 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     479                 : 10084438688 :     for (j = 0; j < MAX_MACHINE_MODE; j++)
     480                 :             :       {
     481                 : 10007458240 :         unsigned char nregs = targetm.hard_regno_nregs (i, (machine_mode) j);
     482                 : 10007458240 :         this_target_regs->x_hard_regno_nregs[i][j] = nregs;
     483                 : 10007458240 :         if (nregs > this_target_regs->x_hard_regno_max_nregs)
     484                 :     4198998 :           this_target_regs->x_hard_regno_max_nregs = nregs;
     485                 :             :       }
     486                 :             : 
     487                 :    77817192 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     488                 :             :     {
     489                 :    76980448 :       reg_raw_mode[i] = choose_hard_reg_mode (i, 1, NULL);
     490                 :             : 
     491                 :             :       /* If we couldn't find a valid mode, just use the previous mode
     492                 :             :          if it is suitable, otherwise fall back on word_mode.  */
     493                 :    76980448 :       if (reg_raw_mode[i] == VOIDmode)
     494                 :             :         {
     495                 :    12874200 :           if (i > 0 && hard_regno_nregs (i, reg_raw_mode[i - 1]) == 1)
     496                 :    12874200 :             reg_raw_mode[i] = reg_raw_mode[i - 1];
     497                 :             :           else
     498                 :           0 :             reg_raw_mode[i] = word_mode;
     499                 :             :         }
     500                 :             :     }
     501                 :      836744 : }
     502                 :             : 
     503                 :             : /* Finish initializing the register sets and initialize the register modes.
     504                 :             :    This function might be invoked more than once, if the target has support
     505                 :             :    for changing register usage conventions on a per-function basis.
     506                 :             : */
     507                 :             : void
     508                 :      882273 : init_regs (void)
     509                 :             : {
     510                 :             :   /* This finishes what was started by init_reg_sets, but couldn't be done
     511                 :             :      until after register usage was specified.  */
     512                 :      882273 :   init_reg_sets_1 ();
     513                 :      882273 : }
     514                 :             : 
     515                 :             : /* The same as previous function plus initializing IRA.  */
     516                 :             : void
     517                 :       45529 : reinit_regs (void)
     518                 :             : {
     519                 :       45529 :   init_regs ();
     520                 :             :   /* caller_save needs to be re-initialized.  */
     521                 :       45529 :   caller_save_initialized_p = false;
     522                 :       45529 :   if (this_target_rtl->target_specific_initialized)
     523                 :             :     {
     524                 :        1073 :       ira_init ();
     525                 :        1073 :       recog_init ();
     526                 :             :     }
     527                 :       45529 : }
     528                 :             : 
     529                 :             : /* Initialize some fake stack-frame MEM references for use in
     530                 :             :    memory_move_secondary_cost.  */
     531                 :             : void
     532                 :      208849 : init_fake_stack_mems (void)
     533                 :             : {
     534                 :      208849 :   int i;
     535                 :             : 
     536                 :    27359219 :   for (i = 0; i < MAX_MACHINE_MODE; i++)
     537                 :    27150370 :     top_of_stack[i] = gen_rtx_MEM ((machine_mode) i, stack_pointer_rtx);
     538                 :      208849 : }
     539                 :             : 
     540                 :             : 
     541                 :             : /* Compute cost of moving data from a register of class FROM to one of
     542                 :             :    TO, using MODE.  */
     543                 :             : 
     544                 :             : int
     545                 :  5407823928 : register_move_cost (machine_mode mode, reg_class_t from, reg_class_t to)
     546                 :             : {
     547                 :  5407823928 :   return targetm.register_move_cost (mode, from, to);
     548                 :             : }
     549                 :             : 
     550                 :             : /* Compute cost of moving registers to/from memory.  */
     551                 :             : 
     552                 :             : int
     553                 :  1801828827 : memory_move_cost (machine_mode mode, reg_class_t rclass, bool in)
     554                 :             : {
     555                 :  1801828827 :   return targetm.memory_move_cost (mode, rclass, in);
     556                 :             : }
     557                 :             : 
     558                 :             : /* Compute extra cost of moving registers to/from memory due to reloads.
     559                 :             :    Only needed if secondary reloads are required for memory moves.  */
     560                 :             : int
     561                 :           0 : memory_move_secondary_cost (machine_mode mode, reg_class_t rclass,
     562                 :             :                             bool in)
     563                 :             : {
     564                 :           0 :   reg_class_t altclass;
     565                 :           0 :   int partial_cost = 0;
     566                 :             :   /* We need a memory reference to feed to SECONDARY... macros.  */
     567                 :             :   /* mem may be unused even if the SECONDARY_ macros are defined.  */
     568                 :           0 :   rtx mem ATTRIBUTE_UNUSED = top_of_stack[(int) mode];
     569                 :             : 
     570                 :           0 :   altclass = secondary_reload_class (in ? 1 : 0, rclass, mode, mem);
     571                 :             : 
     572                 :           0 :   if (altclass == NO_REGS)
     573                 :             :     return 0;
     574                 :             : 
     575                 :           0 :   if (in)
     576                 :           0 :     partial_cost = register_move_cost (mode, altclass, rclass);
     577                 :             :   else
     578                 :           0 :     partial_cost = register_move_cost (mode, rclass, altclass);
     579                 :             : 
     580                 :           0 :   if (rclass == altclass)
     581                 :             :     /* This isn't simply a copy-to-temporary situation.  Can't guess
     582                 :             :        what it is, so TARGET_MEMORY_MOVE_COST really ought not to be
     583                 :             :        calling here in that case.
     584                 :             : 
     585                 :             :        I'm tempted to put in an assert here, but returning this will
     586                 :             :        probably only give poor estimates, which is what we would've
     587                 :             :        had before this code anyways.  */
     588                 :             :     return partial_cost;
     589                 :             : 
     590                 :             :   /* Check if the secondary reload register will also need a
     591                 :             :      secondary reload.  */
     592                 :           0 :   return memory_move_secondary_cost (mode, altclass, in) + partial_cost;
     593                 :             : }
     594                 :             : 
     595                 :             : /* Return a machine mode that is legitimate for hard reg REGNO and large
     596                 :             :    enough to save nregs.  If we can't find one, return VOIDmode.
     597                 :             :    If ABI is nonnull, only consider modes that are preserved across
     598                 :             :    calls that use ABI.  */
     599                 :             : machine_mode
     600                 :    76980448 : choose_hard_reg_mode (unsigned int regno ATTRIBUTE_UNUSED,
     601                 :             :                       unsigned int nregs, const predefined_function_abi *abi)
     602                 :             : {
     603                 :    76980448 :   unsigned int /* machine_mode */ m;
     604                 :    76980448 :   machine_mode found_mode = VOIDmode, mode;
     605                 :             : 
     606                 :             :   /* We first look for the largest integer mode that can be validly
     607                 :             :      held in REGNO.  If none, we look for the largest floating-point mode.
     608                 :             :      If we still didn't find a valid mode, try CCmode.
     609                 :             : 
     610                 :             :      The tests use maybe_gt rather than known_gt because we want (for example)
     611                 :             :      N V4SFs to win over plain V4SF even though N might be 1.  */
     612                 :   615843584 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_INT)
     613                 :   538863136 :     if (hard_regno_nregs (regno, mode) == nregs
     614                 :   458046816 :         && targetm.hard_regno_mode_ok (regno, mode)
     615                 :   222887966 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     616                 :  1207527034 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     617                 :             :       found_mode = mode;
     618                 :             : 
     619                 :   538863136 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_FLOAT)
     620                 :   461882688 :     if (hard_regno_nregs (regno, mode) == nregs
     621                 :   407842176 :         && targetm.hard_regno_mode_ok (regno, mode)
     622                 :   237185590 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     623                 :  1173439458 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     624                 :             :       found_mode = mode;
     625                 :             : 
     626                 :  2386393888 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_VECTOR_FLOAT)
     627                 :  2309413440 :     if (hard_regno_nregs (regno, mode) == nregs
     628                 :  1588346912 :         && targetm.hard_regno_mode_ok (regno, mode)
     629                 :   357019704 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     630                 :  3380472552 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     631                 :             :       found_mode = mode;
     632                 :             : 
     633                 :  2540354784 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_VECTOR_INT)
     634                 :  2463374336 :     if (hard_regno_nregs (regno, mode) == nregs
     635                 :  1768594720 :         && targetm.hard_regno_mode_ok (regno, mode)
     636                 :   522505296 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     637                 :  4030890224 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     638                 :             :       found_mode = mode;
     639                 :             : 
     640                 :    76980448 :   if (found_mode != VOIDmode)
     641                 :             :     return found_mode;
     642                 :             : 
     643                 :             :   /* Iterate over all of the CCmodes.  */
     644                 :  1661608544 :   for (m = (unsigned int) CCmode; m < (unsigned int) NUM_MACHINE_MODES; ++m)
     645                 :             :     {
     646                 :  1648734344 :       mode = (machine_mode) m;
     647                 :  1648734344 :       if (hard_regno_nregs (regno, mode) == nregs
     648                 :  1391250344 :           && targetm.hard_regno_mode_ok (regno, mode)
     649                 :  1649571088 :           && (!abi || !abi->clobbers_reg_p (mode, regno)))
     650                 :             :         return mode;
     651                 :             :     }
     652                 :             : 
     653                 :             :   /* We can't find a mode valid for this register.  */
     654                 :             :   return VOIDmode;
     655                 :             : }
     656                 :             : 
     657                 :             : /* Specify the usage characteristics of the register named NAME.
     658                 :             :    It should be a fixed register if FIXED and a
     659                 :             :    call-used register if CALL_USED.  */
     660                 :             : void
     661                 :          93 : fix_register (const char *name, int fixed, int call_used)
     662                 :             : {
     663                 :          93 :   int i;
     664                 :          93 :   int reg, nregs;
     665                 :             : 
     666                 :             :   /* Decode the name and update the primary form of
     667                 :             :      the register info.  */
     668                 :             : 
     669                 :          93 :   if ((reg = decode_reg_name_and_count (name, &nregs)) >= 0)
     670                 :             :     {
     671                 :          93 :       gcc_assert (nregs >= 1);
     672                 :         186 :       for (i = reg; i < reg + nregs; i++)
     673                 :             :         {
     674                 :          93 :           if ((i == STACK_POINTER_REGNUM
     675                 :             : #ifdef HARD_FRAME_POINTER_REGNUM
     676                 :          93 :                || i == HARD_FRAME_POINTER_REGNUM
     677                 :             : #else
     678                 :             :                || i == FRAME_POINTER_REGNUM
     679                 :             : #endif
     680                 :             :                )
     681                 :           3 :               && (fixed == 0 || call_used == 0))
     682                 :             :             {
     683                 :           0 :               switch (fixed)
     684                 :             :                 {
     685                 :           0 :                 case 0:
     686                 :           0 :                   switch (call_used)
     687                 :             :                     {
     688                 :           0 :                     case 0:
     689                 :           0 :                       error ("cannot use %qs as a call-saved register", name);
     690                 :           0 :                       break;
     691                 :             : 
     692                 :           0 :                     case 1:
     693                 :           0 :                       error ("cannot use %qs as a call-used register", name);
     694                 :           0 :                       break;
     695                 :             : 
     696                 :           0 :                     default:
     697                 :           0 :                       gcc_unreachable ();
     698                 :             :                     }
     699                 :             :                   break;
     700                 :             : 
     701                 :           0 :                 case 1:
     702                 :           0 :                   switch (call_used)
     703                 :             :                     {
     704                 :           0 :                     case 1:
     705                 :           0 :                       error ("cannot use %qs as a fixed register", name);
     706                 :           0 :                       break;
     707                 :             : 
     708                 :           0 :                     case 0:
     709                 :           0 :                     default:
     710                 :           0 :                       gcc_unreachable ();
     711                 :             :                     }
     712                 :           0 :                   break;
     713                 :             : 
     714                 :           0 :                 default:
     715                 :           0 :                   gcc_unreachable ();
     716                 :             :                 }
     717                 :             :             }
     718                 :             :           else
     719                 :             :             {
     720                 :          93 :               fixed_regs[i] = fixed;
     721                 :             : #ifdef CALL_REALLY_USED_REGISTERS
     722                 :             :               if (fixed == 0)
     723                 :             :                 call_used_regs[i] = call_used;
     724                 :             : #else
     725                 :          93 :               call_used_regs[i] = call_used;
     726                 :             : #endif
     727                 :             :             }
     728                 :             :         }
     729                 :             :     }
     730                 :             :   else
     731                 :             :     {
     732                 :           0 :       warning (0, "unknown register name: %s", name);
     733                 :             :     }
     734                 :          93 : }
     735                 :             : 
     736                 :             : /* Mark register number I as global.  */
     737                 :             : void
     738                 :         109 : globalize_reg (tree decl, int i)
     739                 :             : {
     740                 :         109 :   location_t loc = DECL_SOURCE_LOCATION (decl);
     741                 :             : 
     742                 :             : #ifdef STACK_REGS
     743                 :         109 :   if (IN_RANGE (i, FIRST_STACK_REG, LAST_STACK_REG))
     744                 :             :     {
     745                 :           1 :       error ("stack register used for global register variable");
     746                 :           1 :       return;
     747                 :             :     }
     748                 :             : #endif
     749                 :             : 
     750                 :         108 :   if (fixed_regs[i] == 0 && no_global_reg_vars)
     751                 :           0 :     error_at (loc, "global register variable follows a function definition");
     752                 :             : 
     753                 :         108 :   if (global_regs[i])
     754                 :             :     {
     755                 :           0 :       auto_diagnostic_group d;
     756                 :           0 :       warning_at (loc, 0,
     757                 :             :                   "register of %qD used for multiple global register variables",
     758                 :             :                   decl);
     759                 :           0 :       inform (DECL_SOURCE_LOCATION (global_regs_decl[i]),
     760                 :             :               "conflicts with %qD", global_regs_decl[i]);
     761                 :           0 :       return;
     762                 :           0 :     }
     763                 :             : 
     764                 :         108 :   if (call_used_regs[i] && ! fixed_regs[i])
     765                 :          23 :     warning_at (loc, 0, "call-clobbered register used for global register variable");
     766                 :             : 
     767                 :         108 :   global_regs[i] = 1;
     768                 :         108 :   global_regs_decl[i] = decl;
     769                 :         108 :   SET_HARD_REG_BIT (global_reg_set, i);
     770                 :             : 
     771                 :             :   /* If we're globalizing the frame pointer, we need to set the
     772                 :             :      appropriate regs_invalidated_by_call bit, even if it's already
     773                 :             :      set in fixed_regs.  */
     774                 :         108 :   if (i != STACK_POINTER_REGNUM)
     775                 :             :     {
     776                 :          87 :       SET_HARD_REG_BIT (regs_invalidated_by_call, i);
     777                 :         783 :       for (unsigned int j = 0; j < NUM_ABI_IDS; ++j)
     778                 :         696 :         function_abis[j].add_full_reg_clobber (i);
     779                 :             :     }
     780                 :             : 
     781                 :             :   /* If already fixed, nothing else to do.  */
     782                 :         108 :   if (fixed_regs[i])
     783                 :             :     return;
     784                 :             : 
     785                 :          73 :   fixed_regs[i] = call_used_regs[i] = 1;
     786                 :             : 
     787                 :          73 :   SET_HARD_REG_BIT (fixed_reg_set, i);
     788                 :             : 
     789                 :          73 :   reinit_regs ();
     790                 :             : }
     791                 :             : 
     792                 :             : 
     793                 :             : /* Structure used to record preferences of given pseudo.  */
     794                 :             : struct reg_pref
     795                 :             : {
     796                 :             :   /* (enum reg_class) prefclass is the preferred class.  May be
     797                 :             :      NO_REGS if no class is better than memory.  */
     798                 :             :   char prefclass;
     799                 :             : 
     800                 :             :   /* altclass is a register class that we should use for allocating
     801                 :             :      pseudo if no register in the preferred class is available.
     802                 :             :      If no register in this class is available, memory is preferred.
     803                 :             : 
     804                 :             :      It might appear to be more general to have a bitmask of classes here,
     805                 :             :      but since it is recommended that there be a class corresponding to the
     806                 :             :      union of most major pair of classes, that generality is not required.  */
     807                 :             :   char altclass;
     808                 :             : 
     809                 :             :   /* allocnoclass is a register class that IRA uses for allocating
     810                 :             :      the pseudo.  */
     811                 :             :   char allocnoclass;
     812                 :             : };
     813                 :             : 
     814                 :             : /* Record preferences of each pseudo.  This is available after RA is
     815                 :             :    run.  */
     816                 :             : static struct reg_pref *reg_pref;
     817                 :             : 
     818                 :             : /* Current size of reg_info.  */
     819                 :             : static int reg_info_size;
     820                 :             : /* Max_reg_num still last resize_reg_info call.  */
     821                 :             : static int max_regno_since_last_resize;
     822                 :             : 
     823                 :             : /* Return the reg_class in which pseudo reg number REGNO is best allocated.
     824                 :             :    This function is sometimes called before the info has been computed.
     825                 :             :    When that happens, just return GENERAL_REGS, which is innocuous.  */
     826                 :             : enum reg_class
     827                 :    70604291 : reg_preferred_class (int regno)
     828                 :             : {
     829                 :    70604291 :   if (reg_pref == 0)
     830                 :             :     return GENERAL_REGS;
     831                 :             : 
     832                 :    70604291 :   gcc_assert (regno < reg_info_size);
     833                 :    70604291 :   return (enum reg_class) reg_pref[regno].prefclass;
     834                 :             : }
     835                 :             : 
     836                 :             : enum reg_class
     837                 :     2315165 : reg_alternate_class (int regno)
     838                 :             : {
     839                 :     2315165 :   if (reg_pref == 0)
     840                 :             :     return ALL_REGS;
     841                 :             : 
     842                 :     2315165 :   gcc_assert (regno < reg_info_size);
     843                 :     2315165 :   return (enum reg_class) reg_pref[regno].altclass;
     844                 :             : }
     845                 :             : 
     846                 :             : /* Return the reg_class which is used by IRA for its allocation.  */
     847                 :             : enum reg_class
     848                 :   220188870 : reg_allocno_class (int regno)
     849                 :             : {
     850                 :   220188870 :   if (reg_pref == 0)
     851                 :             :     return NO_REGS;
     852                 :             : 
     853                 :   220188870 :   gcc_assert (regno < reg_info_size);
     854                 :   220188870 :   return (enum reg_class) reg_pref[regno].allocnoclass;
     855                 :             : }
     856                 :             : 
     857                 :             : 
     858                 :             : 
     859                 :             : /* Allocate space for reg info and initilize it.  */
     860                 :             : static void
     861                 :     1522637 : allocate_reg_info (void)
     862                 :             : {
     863                 :     1522637 :   int i;
     864                 :             : 
     865                 :     1522637 :   max_regno_since_last_resize = max_reg_num ();
     866                 :     1522637 :   reg_info_size = max_regno_since_last_resize * 3 / 2 + 1;
     867                 :     1522637 :   gcc_assert (! reg_pref && ! reg_renumber);
     868                 :     1522637 :   reg_renumber = XNEWVEC (short, reg_info_size);
     869                 :     1522637 :   reg_pref = XCNEWVEC (struct reg_pref, reg_info_size);
     870                 :     1522637 :   memset (reg_renumber, -1, reg_info_size * sizeof (short));
     871                 :   310645938 :   for (i = 0; i < reg_info_size; i++)
     872                 :             :     {
     873                 :   309123301 :       reg_pref[i].prefclass = GENERAL_REGS;
     874                 :   309123301 :       reg_pref[i].altclass = ALL_REGS;
     875                 :   309123301 :       reg_pref[i].allocnoclass = GENERAL_REGS;
     876                 :             :     }
     877                 :     1522637 : }
     878                 :             : 
     879                 :             : 
     880                 :             : /* Resize reg info. The new elements will be initialized.  Return TRUE
     881                 :             :    if new pseudos were added since the last call.  */
     882                 :             : bool
     883                 :  1274413651 : resize_reg_info (void)
     884                 :             : {
     885                 :  1274413651 :   int old, i;
     886                 :  1274413651 :   bool change_p;
     887                 :             : 
     888                 :  1274413651 :   if (reg_pref == NULL)
     889                 :             :     {
     890                 :     1522637 :       allocate_reg_info ();
     891                 :     1522637 :       return true;
     892                 :             :     }
     893                 :  1272891014 :   change_p = max_regno_since_last_resize != max_reg_num ();
     894                 :  1272891014 :   max_regno_since_last_resize = max_reg_num ();
     895                 :  1272891014 :   if (reg_info_size >= max_reg_num ())
     896                 :             :     return change_p;
     897                 :        3080 :   old = reg_info_size;
     898                 :        3080 :   reg_info_size = max_reg_num () * 3 / 2 + 1;
     899                 :        3080 :   gcc_assert (reg_pref && reg_renumber);
     900                 :        3080 :   reg_renumber = XRESIZEVEC (short, reg_renumber, reg_info_size);
     901                 :        3080 :   reg_pref = XRESIZEVEC (struct reg_pref, reg_pref, reg_info_size);
     902                 :        3080 :   memset (reg_pref + old, -1,
     903                 :        3080 :           (reg_info_size - old) * sizeof (struct reg_pref));
     904                 :        3080 :   memset (reg_renumber + old, -1, (reg_info_size - old) * sizeof (short));
     905                 :     2166471 :   for (i = old; i < reg_info_size; i++)
     906                 :             :     {
     907                 :     2163391 :       reg_pref[i].prefclass = GENERAL_REGS;
     908                 :     2163391 :       reg_pref[i].altclass = ALL_REGS;
     909                 :     2163391 :       reg_pref[i].allocnoclass = GENERAL_REGS;
     910                 :             :     }
     911                 :             :   return true;
     912                 :             : }
     913                 :             : 
     914                 :             : 
     915                 :             : /* Free up the space allocated by allocate_reg_info.  */
     916                 :             : void
     917                 :     1522639 : free_reg_info (void)
     918                 :             : {
     919                 :     1522639 :   if (reg_pref)
     920                 :             :     {
     921                 :     1522637 :       free (reg_pref);
     922                 :     1522637 :       reg_pref = NULL;
     923                 :             :     }
     924                 :             : 
     925                 :     1522639 :   if (reg_renumber)
     926                 :             :     {
     927                 :     1522637 :       free (reg_renumber);
     928                 :     1522637 :       reg_renumber = NULL;
     929                 :             :     }
     930                 :     1522639 : }
     931                 :             : 
     932                 :             : /* Initialize some global data for this pass.  */
     933                 :             : static unsigned int
     934                 :     1486699 : reginfo_init (void)
     935                 :             : {
     936                 :     1486699 :   if (df)
     937                 :     1051273 :     df_compute_regs_ever_live (true);
     938                 :             : 
     939                 :             :   /* This prevents dump_reg_info from losing if called
     940                 :             :      before reginfo is run.  */
     941                 :     1486699 :   reg_pref = NULL;
     942                 :     1486699 :   reg_info_size = max_regno_since_last_resize = 0;
     943                 :             :   /* No more global register variables may be declared.  */
     944                 :     1486699 :   no_global_reg_vars = 1;
     945                 :     1486699 :   return 1;
     946                 :             : }
     947                 :             : 
     948                 :             : namespace {
     949                 :             : 
     950                 :             : const pass_data pass_data_reginfo_init =
     951                 :             : {
     952                 :             :   RTL_PASS, /* type */
     953                 :             :   "reginfo", /* name */
     954                 :             :   OPTGROUP_NONE, /* optinfo_flags */
     955                 :             :   TV_NONE, /* tv_id */
     956                 :             :   0, /* properties_required */
     957                 :             :   0, /* properties_provided */
     958                 :             :   0, /* properties_destroyed */
     959                 :             :   0, /* todo_flags_start */
     960                 :             :   0, /* todo_flags_finish */
     961                 :             : };
     962                 :             : 
     963                 :             : class pass_reginfo_init : public rtl_opt_pass
     964                 :             : {
     965                 :             : public:
     966                 :      281608 :   pass_reginfo_init (gcc::context *ctxt)
     967                 :      563216 :     : rtl_opt_pass (pass_data_reginfo_init, ctxt)
     968                 :             :   {}
     969                 :             : 
     970                 :             :   /* opt_pass methods: */
     971                 :     1486699 :   unsigned int execute (function *) final override { return reginfo_init (); }
     972                 :             : 
     973                 :             : }; // class pass_reginfo_init
     974                 :             : 
     975                 :             : } // anon namespace
     976                 :             : 
     977                 :             : rtl_opt_pass *
     978                 :      281608 : make_pass_reginfo_init (gcc::context *ctxt)
     979                 :             : {
     980                 :      281608 :   return new pass_reginfo_init (ctxt);
     981                 :             : }
     982                 :             : 
     983                 :             : 
     984                 :             : 
     985                 :             : /* Set up preferred, alternate, and allocno classes for REGNO as
     986                 :             :    PREFCLASS, ALTCLASS, and ALLOCNOCLASS.  */
     987                 :             : void
     988                 :    45255375 : setup_reg_classes (int regno,
     989                 :             :                    enum reg_class prefclass, enum reg_class altclass,
     990                 :             :                    enum reg_class allocnoclass)
     991                 :             : {
     992                 :    45255375 :   if (reg_pref == NULL)
     993                 :             :     return;
     994                 :    45255375 :   gcc_assert (reg_info_size >= max_reg_num ());
     995                 :    45255375 :   reg_pref[regno].prefclass = prefclass;
     996                 :    45255375 :   reg_pref[regno].altclass = altclass;
     997                 :    45255375 :   reg_pref[regno].allocnoclass = allocnoclass;
     998                 :             : }
     999                 :             : 
    1000                 :             : 
    1001                 :             : /* This is the `regscan' pass of the compiler, run just before cse and
    1002                 :             :    again just before loop.  It finds the first and last use of each
    1003                 :             :    pseudo-register.  */
    1004                 :             : 
    1005                 :             : static void reg_scan_mark_refs (rtx, rtx_insn *);
    1006                 :             : 
    1007                 :             : void
    1008                 :     2344604 : reg_scan (rtx_insn *f, unsigned int nregs ATTRIBUTE_UNUSED)
    1009                 :             : {
    1010                 :     2344604 :   rtx_insn *insn;
    1011                 :             : 
    1012                 :     2344604 :   timevar_push (TV_REG_SCAN);
    1013                 :             : 
    1014                 :   319797204 :   for (insn = f; insn; insn = NEXT_INSN (insn))
    1015                 :   315107996 :     if (INSN_P (insn))
    1016                 :             :       {
    1017                 :   269811322 :         reg_scan_mark_refs (PATTERN (insn), insn);
    1018                 :   269811322 :         if (REG_NOTES (insn))
    1019                 :   103923224 :           reg_scan_mark_refs (REG_NOTES (insn), insn);
    1020                 :             :       }
    1021                 :             : 
    1022                 :     2344604 :   timevar_pop (TV_REG_SCAN);
    1023                 :     2344604 : }
    1024                 :             : 
    1025                 :             : 
    1026                 :             : /* X is the expression to scan.  INSN is the insn it appears in.
    1027                 :             :    NOTE_FLAG is nonzero if X is from INSN's notes rather than its body.
    1028                 :             :    We should only record information for REGs with numbers
    1029                 :             :    greater than or equal to MIN_REGNO.  */
    1030                 :             : static void
    1031                 :  1320285104 : reg_scan_mark_refs (rtx x, rtx_insn *insn)
    1032                 :             : {
    1033                 :  1390860097 :   enum rtx_code code;
    1034                 :  1390860097 :   rtx dest;
    1035                 :  1390860097 :   rtx note;
    1036                 :             : 
    1037                 :  1390860097 :   if (!x)
    1038                 :             :     return;
    1039                 :  1390860097 :   code = GET_CODE (x);
    1040                 :  1390860097 :   switch (code)
    1041                 :             :     {
    1042                 :             :     case CONST:
    1043                 :             :     CASE_CONST_ANY:
    1044                 :             :     case PC:
    1045                 :             :     case SYMBOL_REF:
    1046                 :             :     case LABEL_REF:
    1047                 :             :     case ADDR_VEC:
    1048                 :             :     case ADDR_DIFF_VEC:
    1049                 :             :     case REG:
    1050                 :             :       return;
    1051                 :             : 
    1052                 :   160840970 :     case EXPR_LIST:
    1053                 :   160840970 :       if (XEXP (x, 0))
    1054                 :   160427546 :         reg_scan_mark_refs (XEXP (x, 0), insn);
    1055                 :   160840970 :       if (XEXP (x, 1))
    1056                 :             :         reg_scan_mark_refs (XEXP (x, 1), insn);
    1057                 :             :       break;
    1058                 :             : 
    1059                 :    13436726 :     case INSN_LIST:
    1060                 :    13436726 :     case INT_LIST:
    1061                 :    13436726 :       if (XEXP (x, 1))
    1062                 :             :         reg_scan_mark_refs (XEXP (x, 1), insn);
    1063                 :             :       break;
    1064                 :             : 
    1065                 :    60218990 :     case CLOBBER:
    1066                 :    60218990 :       if (MEM_P (XEXP (x, 0)))
    1067                 :      220521 :         reg_scan_mark_refs (XEXP (XEXP (x, 0), 0), insn);
    1068                 :             :       break;
    1069                 :             : 
    1070                 :   147992054 :     case SET:
    1071                 :             :       /* Count a set of the destination if it is a register.  */
    1072                 :   147992054 :       for (dest = SET_DEST (x);
    1073                 :   148782966 :            GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
    1074                 :   148782966 :            || GET_CODE (dest) == ZERO_EXTRACT;
    1075                 :      790912 :            dest = XEXP (dest, 0))
    1076                 :             :         ;
    1077                 :             : 
    1078                 :             :       /* If this is setting a pseudo from another pseudo or the sum of a
    1079                 :             :          pseudo and a constant integer and the other pseudo is known to be
    1080                 :             :          a pointer, set the destination to be a pointer as well.
    1081                 :             : 
    1082                 :             :          Likewise if it is setting the destination from an address or from a
    1083                 :             :          value equivalent to an address or to the sum of an address and
    1084                 :             :          something else.
    1085                 :             : 
    1086                 :             :          But don't do any of this if the pseudo corresponds to a user
    1087                 :             :          variable since it should have already been set as a pointer based
    1088                 :             :          on the type.  */
    1089                 :             : 
    1090                 :   147992054 :       if (REG_P (SET_DEST (x))
    1091                 :   112735788 :           && REGNO (SET_DEST (x)) >= FIRST_PSEUDO_REGISTER
    1092                 :             :           /* If the destination pseudo is set more than once, then other
    1093                 :             :              sets might not be to a pointer value (consider access to a
    1094                 :             :              union in two threads of control in the presence of global
    1095                 :             :              optimizations).  So only set REG_POINTER on the destination
    1096                 :             :              pseudo if this is the only set of that pseudo.  */
    1097                 :    67026413 :           && DF_REG_DEF_COUNT (REGNO (SET_DEST (x))) == 1
    1098                 :    51152393 :           && ! REG_USERVAR_P (SET_DEST (x))
    1099                 :    47259662 :           && ! REG_POINTER (SET_DEST (x))
    1100                 :   184841787 :           && ((REG_P (SET_SRC (x))
    1101                 :     4508064 :                && REG_POINTER (SET_SRC (x)))
    1102                 :    36507957 :               || ((GET_CODE (SET_SRC (x)) == PLUS
    1103                 :    30491600 :                    || GET_CODE (SET_SRC (x)) == LO_SUM)
    1104                 :     6016357 :                   && CONST_INT_P (XEXP (SET_SRC (x), 1))
    1105                 :     3999310 :                   && REG_P (XEXP (SET_SRC (x), 0))
    1106                 :     3939066 :                   && REG_POINTER (XEXP (SET_SRC (x), 0)))
    1107                 :             :               || GET_CODE (SET_SRC (x)) == CONST
    1108                 :             :               || GET_CODE (SET_SRC (x)) == SYMBOL_REF
    1109                 :             :               || GET_CODE (SET_SRC (x)) == LABEL_REF
    1110                 :             :               || (GET_CODE (SET_SRC (x)) == HIGH
    1111                 :           0 :                   && (GET_CODE (XEXP (SET_SRC (x), 0)) == CONST
    1112                 :             :                       || GET_CODE (XEXP (SET_SRC (x), 0)) == SYMBOL_REF
    1113                 :             :                       || GET_CODE (XEXP (SET_SRC (x), 0)) == LABEL_REF))
    1114                 :    33882473 :               || ((GET_CODE (SET_SRC (x)) == PLUS
    1115                 :    30267539 :                    || GET_CODE (SET_SRC (x)) == LO_SUM)
    1116                 :     3614934 :                   && (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST
    1117                 :             :                       || GET_CODE (XEXP (SET_SRC (x), 1)) == SYMBOL_REF
    1118                 :             :                       || GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF))
    1119                 :    33867178 :               || ((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
    1120                 :     2756689 :                   && (GET_CODE (XEXP (note, 0)) == CONST
    1121                 :             :                       || GET_CODE (XEXP (note, 0)) == SYMBOL_REF
    1122                 :             :                       || GET_CODE (XEXP (note, 0)) == LABEL_REF))))
    1123                 :     3015133 :         REG_POINTER (SET_DEST (x)) = 1;
    1124                 :             : 
    1125                 :             :       /* If this is setting a register from a register or from a simple
    1126                 :             :          conversion of a register, propagate REG_EXPR.  */
    1127                 :   147992054 :       if (REG_P (dest) && !REG_ATTRS (dest))
    1128                 :    67189808 :         set_reg_attrs_from_value (dest, SET_SRC (x));
    1129                 :             : 
    1130                 :             :       /* fall through */
    1131                 :             : 
    1132                 :   513035050 :     default:
    1133                 :   513035050 :       {
    1134                 :   513035050 :         const char *fmt = GET_RTX_FORMAT (code);
    1135                 :   513035050 :         int i;
    1136                 :  1443082956 :         for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1137                 :             :           {
    1138                 :   930047906 :             if (fmt[i] == 'e')
    1139                 :   730464568 :               reg_scan_mark_refs (XEXP (x, i), insn);
    1140                 :   199583338 :             else if (fmt[i] == 'E' && XVEC (x, i) != 0)
    1141                 :             :               {
    1142                 :    28308621 :                 int j;
    1143                 :    83967065 :                 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1144                 :    55658444 :                   reg_scan_mark_refs (XVECEXP (x, i, j), insn);
    1145                 :             :               }
    1146                 :             :           }
    1147                 :             :       }
    1148                 :             :     }
    1149                 :             : }
    1150                 :             : 
    1151                 :             : 
    1152                 :             : /* Return true if C1 is a subset of C2, i.e., if every register in C1
    1153                 :             :    is also in C2.  */
    1154                 :             : bool
    1155                 : 78910529830 : reg_class_subset_p (reg_class_t c1, reg_class_t c2)
    1156                 :             : {
    1157                 : 78910529830 :   return (c1 == c2
    1158                 : 78910529830 :           || c2 == ALL_REGS
    1159                 : >15640*10^7 :           || hard_reg_set_subset_p (reg_class_contents[(int) c1],
    1160                 : 77490660776 :                                    reg_class_contents[(int) c2]));
    1161                 :             : }
    1162                 :             : 
    1163                 :             : /* Return true if there is a register that is in both C1 and C2.  */
    1164                 :             : bool
    1165                 : 46207814812 : reg_classes_intersect_p (reg_class_t c1, reg_class_t c2)
    1166                 :             : {
    1167                 : 46207814812 :   return (c1 == c2
    1168                 : 46207814812 :           || c1 == ALL_REGS
    1169                 : 44881675307 :           || c2 == ALL_REGS
    1170                 : 91087953049 :           || hard_reg_set_intersect_p (reg_class_contents[(int) c1],
    1171                 : 44880138237 :                                       reg_class_contents[(int) c2]));
    1172                 :             : }
    1173                 :             : 
    1174                 :             : 
    1175                 :             : inline hashval_t
    1176                 :     8345463 : simplifiable_subregs_hasher::hash (const simplifiable_subreg *value)
    1177                 :             : {
    1178                 :     8345463 :   inchash::hash h;
    1179                 :     8345463 :   h.add_hwi (value->shape.unique_id ());
    1180                 :     8345463 :   return h.end ();
    1181                 :             : }
    1182                 :             : 
    1183                 :             : inline bool
    1184                 :    10919023 : simplifiable_subregs_hasher::equal (const simplifiable_subreg *value,
    1185                 :             :                                     const subreg_shape *compare)
    1186                 :             : {
    1187                 :    36611132 :   return value->shape == *compare;
    1188                 :             : }
    1189                 :             : 
    1190                 :      138022 : inline simplifiable_subreg::simplifiable_subreg (const subreg_shape &shape_in)
    1191                 :      138022 :   : shape (shape_in)
    1192                 :             : {
    1193                 :    12974068 :   CLEAR_HARD_REG_SET (simplifiable_regs);
    1194                 :             : }
    1195                 :             : 
    1196                 :             : /* Return the set of hard registers that are able to form the subreg
    1197                 :             :    described by SHAPE.  */
    1198                 :             : 
    1199                 :             : const HARD_REG_SET &
    1200                 :     3231859 : simplifiable_subregs (const subreg_shape &shape)
    1201                 :             : {
    1202                 :     3231859 :   if (!this_target_hard_regs->x_simplifiable_subregs)
    1203                 :      108478 :     this_target_hard_regs->x_simplifiable_subregs
    1204                 :       54239 :       = new hash_table <simplifiable_subregs_hasher> (30);
    1205                 :     3231859 :   inchash::hash h;
    1206                 :     3231859 :   h.add_hwi (shape.unique_id ());
    1207                 :     3231859 :   simplifiable_subreg **slot
    1208                 :     3231859 :     = (this_target_hard_regs->x_simplifiable_subregs
    1209                 :     3231859 :        ->find_slot_with_hash (&shape, h.end (), INSERT));
    1210                 :             : 
    1211                 :     3231859 :   if (!*slot)
    1212                 :             :     {
    1213                 :      138022 :       simplifiable_subreg *info = new simplifiable_subreg (shape);
    1214                 :    12836046 :       for (unsigned int i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1215                 :    12698024 :         if (targetm.hard_regno_mode_ok (i, shape.inner_mode)
    1216                 :    19165149 :             && simplify_subreg_regno (i, shape.inner_mode, shape.offset,
    1217                 :     6467125 :                                       shape.outer_mode) >= 0)
    1218                 :     4982982 :           SET_HARD_REG_BIT (info->simplifiable_regs, i);
    1219                 :      138022 :       *slot = info;
    1220                 :             :     }
    1221                 :     3231859 :   return (*slot)->simplifiable_regs;
    1222                 :             : }
    1223                 :             : 
    1224                 :             : /* Passes for keeping and updating info about modes of registers
    1225                 :             :    inside subregisters.  */
    1226                 :             : 
    1227                 :             : static HARD_REG_SET **valid_mode_changes;
    1228                 :             : static obstack valid_mode_changes_obstack;
    1229                 :             : 
    1230                 :             : /* Restrict the choice of register for SUBREG_REG (SUBREG) based
    1231                 :             :    on information about SUBREG.
    1232                 :             : 
    1233                 :             :    If PARTIAL_DEF, SUBREG is a partial definition of a multipart inner
    1234                 :             :    register and we want to ensure that the other parts of the inner
    1235                 :             :    register are correctly preserved.  If !PARTIAL_DEF we need to
    1236                 :             :    ensure that SUBREG itself can be formed.  */
    1237                 :             : 
    1238                 :             : static void
    1239                 :     3236934 : record_subregs_of_mode (rtx subreg, bool partial_def)
    1240                 :             : {
    1241                 :     3236934 :   unsigned int regno;
    1242                 :             : 
    1243                 :     3236934 :   if (!REG_P (SUBREG_REG (subreg)))
    1244                 :        5075 :     return;
    1245                 :             : 
    1246                 :     3231971 :   regno = REGNO (SUBREG_REG (subreg));
    1247                 :     3231971 :   if (regno < FIRST_PSEUDO_REGISTER)
    1248                 :             :     return;
    1249                 :             : 
    1250                 :     3231859 :   subreg_shape shape (shape_of_subreg (subreg));
    1251                 :     3231859 :   if (partial_def)
    1252                 :             :     {
    1253                 :             :       /* The number of independently-accessible SHAPE.outer_mode values
    1254                 :             :          in SHAPE.inner_mode is GET_MODE_SIZE (SHAPE.inner_mode) / SIZE.
    1255                 :             :          We need to check that the assignment will preserve all the other
    1256                 :             :          SIZE-byte chunks in the inner register besides the one that
    1257                 :             :          includes SUBREG.
    1258                 :             : 
    1259                 :             :          In practice it is enough to check whether an equivalent
    1260                 :             :          SHAPE.inner_mode value in an adjacent SIZE-byte chunk can be formed.
    1261                 :             :          If the underlying registers are small enough, both subregs will
    1262                 :             :          be valid.  If the underlying registers are too large, one of the
    1263                 :             :          subregs will be invalid.
    1264                 :             : 
    1265                 :             :          This relies on the fact that we've already been passed
    1266                 :             :          SUBREG with PARTIAL_DEF set to false.
    1267                 :             : 
    1268                 :             :          The size of the outer mode must ordered wrt the size of the
    1269                 :             :          inner mode's registers, since otherwise we wouldn't know at
    1270                 :             :          compile time how many registers the outer mode occupies.  */
    1271                 :      663940 :       poly_uint64 size = ordered_max (REGMODE_NATURAL_SIZE (shape.inner_mode),
    1272                 :      663940 :                                       GET_MODE_SIZE (shape.outer_mode));
    1273                 :      663940 :       gcc_checking_assert (known_lt (size, GET_MODE_SIZE (shape.inner_mode)));
    1274                 :      331970 :       if (known_ge (shape.offset, size))
    1275                 :     3231859 :         shape.offset -= size;
    1276                 :             :       else
    1277                 :     3231859 :         shape.offset += size;
    1278                 :             :     }
    1279                 :             : 
    1280                 :     3231859 :   if (valid_mode_changes[regno])
    1281                 :     4617530 :     *valid_mode_changes[regno] &= simplifiable_subregs (shape);
    1282                 :             :   else
    1283                 :             :     {
    1284                 :     1846188 :       valid_mode_changes[regno]
    1285                 :     1846188 :         = XOBNEW (&valid_mode_changes_obstack, HARD_REG_SET);
    1286                 :     1846188 :       *valid_mode_changes[regno] = simplifiable_subregs (shape);
    1287                 :             :     }
    1288                 :             : }
    1289                 :             : 
    1290                 :             : /* Call record_subregs_of_mode for all the subregs in X.  */
    1291                 :             : static void
    1292                 :   452616335 : find_subregs_of_mode (rtx x)
    1293                 :             : {
    1294                 :   452616335 :   enum rtx_code code = GET_CODE (x);
    1295                 :   452616335 :   const char * const fmt = GET_RTX_FORMAT (code);
    1296                 :   452616335 :   int i;
    1297                 :             : 
    1298                 :   452616335 :   if (code == SUBREG)
    1299                 :     2904964 :     record_subregs_of_mode (x, false);
    1300                 :             : 
    1301                 :             :   /* Time for some deep diving.  */
    1302                 :  1093148655 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1303                 :             :     {
    1304                 :   640532320 :       if (fmt[i] == 'e')
    1305                 :   342610381 :         find_subregs_of_mode (XEXP (x, i));
    1306                 :   297921939 :       else if (fmt[i] == 'E')
    1307                 :             :         {
    1308                 :    13606836 :           int j;
    1309                 :    40818470 :           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1310                 :    27211634 :             find_subregs_of_mode (XVECEXP (x, i, j));
    1311                 :             :         }
    1312                 :             :     }
    1313                 :   452616335 : }
    1314                 :             : 
    1315                 :             : void
    1316                 :     1522752 : init_subregs_of_mode (void)
    1317                 :             : {
    1318                 :     1522752 :   basic_block bb;
    1319                 :     1522752 :   rtx_insn *insn;
    1320                 :             : 
    1321                 :     1522752 :   gcc_obstack_init (&valid_mode_changes_obstack);
    1322                 :     1522752 :   valid_mode_changes = XCNEWVEC (HARD_REG_SET *, max_reg_num ());
    1323                 :             : 
    1324                 :    16267402 :   FOR_EACH_BB_FN (bb, cfun)
    1325                 :   164051874 :     FOR_BB_INSNS (bb, insn)
    1326                 :   149307224 :       if (NONDEBUG_INSN_P (insn))
    1327                 :             :         {
    1328                 :    82794320 :           find_subregs_of_mode (PATTERN (insn));
    1329                 :    82794320 :           df_ref def;
    1330                 :   641536147 :           FOR_EACH_INSN_DEF (def, insn)
    1331                 :   558741827 :             if (DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL)
    1332                 :   558741827 :                 && read_modify_subreg_p (DF_REF_REG (def)))
    1333                 :      331970 :               record_subregs_of_mode (DF_REF_REG (def), true);
    1334                 :             :         }
    1335                 :     1522752 : }
    1336                 :             : 
    1337                 :             : const HARD_REG_SET *
    1338                 :   111868062 : valid_mode_changes_for_regno (unsigned int regno)
    1339                 :             : {
    1340                 :   111868062 :   return valid_mode_changes[regno];
    1341                 :             : }
    1342                 :             : 
    1343                 :             : void
    1344                 :     1522752 : finish_subregs_of_mode (void)
    1345                 :             : {
    1346                 :     1522752 :   XDELETEVEC (valid_mode_changes);
    1347                 :     1522752 :   obstack_free (&valid_mode_changes_obstack, NULL);
    1348                 :     1522752 : }
    1349                 :             : 
    1350                 :             : /* Free all data attached to the structure.  This isn't a destructor because
    1351                 :             :    we don't want to run on exit.  */
    1352                 :             : 
    1353                 :             : void
    1354                 :       57243 : target_hard_regs::finalize ()
    1355                 :             : {
    1356                 :       57243 :   delete x_simplifiable_subregs;
    1357                 :       57243 : }
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.