LCOV - code coverage report
Current view: top level - gcc - reginfo.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 465 511 91.0 %
Date: 2020-04-04 11:58:09 Functions: 34 36 94.4 %
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-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : 
      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                 :            : /* Declaration for the global register. */
      95                 :            : tree global_regs_decl[FIRST_PSEUDO_REGISTER];
      96                 :            : 
      97                 :            : /* Used to initialize reg_alloc_order.  */
      98                 :            : #ifdef REG_ALLOC_ORDER
      99                 :            : static int initial_reg_alloc_order[FIRST_PSEUDO_REGISTER] = REG_ALLOC_ORDER;
     100                 :            : #endif
     101                 :            : 
     102                 :            : /* The same information, but as an array of unsigned ints.  We copy from
     103                 :            :    these unsigned ints to the table above.  We do this so the tm.h files
     104                 :            :    do not have to be aware of the wordsize for machines with <= 64 regs.
     105                 :            :    Note that we hard-code 32 here, not HOST_BITS_PER_INT.  */
     106                 :            : #define N_REG_INTS  \
     107                 :            :   ((FIRST_PSEUDO_REGISTER + (32 - 1)) / 32)
     108                 :            : 
     109                 :            : static const unsigned int_reg_class_contents[N_REG_CLASSES][N_REG_INTS]
     110                 :            :   = REG_CLASS_CONTENTS;
     111                 :            : 
     112                 :            : /* Array containing all of the register names.  */
     113                 :            : static const char *const initial_reg_names[] = REGISTER_NAMES;
     114                 :            : 
     115                 :            : /* Array containing all of the register class names.  */
     116                 :            : const char * reg_class_names[] = REG_CLASS_NAMES;
     117                 :            : 
     118                 :            : /* No more global register variables may be declared; true once
     119                 :            :    reginfo has been initialized.  */
     120                 :            : static int no_global_reg_vars = 0;
     121                 :            : 
     122                 :            : /* Given a register bitmap, turn on the bits in a HARD_REG_SET that
     123                 :            :    correspond to the hard registers, if any, set in that map.  This
     124                 :            :    could be done far more efficiently by having all sorts of special-cases
     125                 :            :    with moving single words, but probably isn't worth the trouble.  */
     126                 :            : void
     127                 :   41049100 : reg_set_to_hard_reg_set (HARD_REG_SET *to, const_bitmap from)
     128                 :            : {
     129                 :   41049100 :   unsigned i;
     130                 :   41049100 :   bitmap_iterator bi;
     131                 :            : 
     132                 :  249051000 :   EXECUTE_IF_SET_IN_BITMAP (from, 0, i, bi)
     133                 :            :     {
     134                 :  230284000 :       if (i >= FIRST_PSEUDO_REGISTER)
     135                 :   22282100 :         return;
     136                 :  208002000 :       SET_HARD_REG_BIT (*to, i);
     137                 :            :     }
     138                 :            : }
     139                 :            : 
     140                 :            : /* Function called only once per target_globals to initialize the
     141                 :            :    target_hard_regs structure.  Once this is done, various switches
     142                 :            :    may override.  */
     143                 :            : void
     144                 :     451182 : init_reg_sets (void)
     145                 :            : {
     146                 :     451182 :   int i, j;
     147                 :            : 
     148                 :            :   /* First copy the register information from the initial int form into
     149                 :            :      the regsets.  */
     150                 :            : 
     151                 :   13986600 :   for (i = 0; i < N_REG_CLASSES; i++)
     152                 :            :     {
     153                 :   13535500 :       CLEAR_HARD_REG_SET (reg_class_contents[i]);
     154                 :            : 
     155                 :            :       /* Note that we hard-code 32 here, not HOST_BITS_PER_INT.  */
     156                 : 1042230000 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
     157                 : 1028690000 :         if (int_reg_class_contents[i][j / 32]
     158                 : 1028690000 :             & ((unsigned) 1 << (j % 32)))
     159                 : 1028690000 :           SET_HARD_REG_BIT (reg_class_contents[i], j);
     160                 :            :     }
     161                 :            : 
     162                 :            :   /* Sanity check: make sure the target macros FIXED_REGISTERS and
     163                 :            :      CALL_USED_REGISTERS had the right number of initializers.  */
     164                 :     451182 :   gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs);
     165                 :     451182 :   gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs);
     166                 :            : #ifdef REG_ALLOC_ORDER
     167                 :     451182 :   gcc_assert (sizeof reg_alloc_order == sizeof initial_reg_alloc_order);
     168                 :            : #endif
     169                 :     451182 :   gcc_assert (sizeof reg_names == sizeof initial_reg_names);
     170                 :            : 
     171                 :     451182 :   memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
     172                 :     451182 :   memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
     173                 :            : #ifdef REG_ALLOC_ORDER
     174                 :     451182 :   memcpy (reg_alloc_order, initial_reg_alloc_order, sizeof reg_alloc_order);
     175                 :            : #endif
     176                 :     451182 :   memcpy (reg_names, initial_reg_names, sizeof reg_names);
     177                 :            : 
     178                 :     451182 :   SET_HARD_REG_SET (accessible_reg_set);
     179                 :    1353550 :   SET_HARD_REG_SET (operand_reg_set);
     180                 :     451182 : }
     181                 :            : 
     182                 :            : /* We need to save copies of some of the register information which
     183                 :            :    can be munged by command-line switches so we can restore it during
     184                 :            :    subsequent back-end reinitialization.  */
     185                 :            : static char saved_fixed_regs[FIRST_PSEUDO_REGISTER];
     186                 :            : static char saved_call_used_regs[FIRST_PSEUDO_REGISTER];
     187                 :            : static const char *saved_reg_names[FIRST_PSEUDO_REGISTER];
     188                 :            : static HARD_REG_SET saved_accessible_reg_set;
     189                 :            : static HARD_REG_SET saved_operand_reg_set;
     190                 :            : 
     191                 :            : /* Save the register information.  */
     192                 :            : void
     193                 :     198583 : save_register_info (void)
     194                 :            : {
     195                 :            :   /* Sanity check:  make sure the target macros FIXED_REGISTERS and
     196                 :            :      CALL_USED_REGISTERS had the right number of initializers.  */
     197                 :     198583 :   gcc_assert (sizeof fixed_regs == sizeof saved_fixed_regs);
     198                 :     198583 :   gcc_assert (sizeof call_used_regs == sizeof saved_call_used_regs);
     199                 :     198583 :   memcpy (saved_fixed_regs, fixed_regs, sizeof fixed_regs);
     200                 :     198583 :   memcpy (saved_call_used_regs, call_used_regs, sizeof call_used_regs);
     201                 :            : 
     202                 :            :   /* And similarly for reg_names.  */
     203                 :     198583 :   gcc_assert (sizeof reg_names == sizeof saved_reg_names);
     204                 :     198583 :   memcpy (saved_reg_names, reg_names, sizeof reg_names);
     205                 :     198583 :   saved_accessible_reg_set = accessible_reg_set;
     206                 :     198583 :   saved_operand_reg_set = operand_reg_set;
     207                 :     198583 : }
     208                 :            : 
     209                 :            : /* Restore the register information.  */
     210                 :            : static void
     211                 :     458396 : restore_register_info (void)
     212                 :            : {
     213                 :     458396 :   memcpy (fixed_regs, saved_fixed_regs, sizeof fixed_regs);
     214                 :     458396 :   memcpy (call_used_regs, saved_call_used_regs, sizeof call_used_regs);
     215                 :            : 
     216                 :     458396 :   memcpy (reg_names, saved_reg_names, sizeof reg_names);
     217                 :     458396 :   accessible_reg_set = saved_accessible_reg_set;
     218                 :     458396 :   operand_reg_set = saved_operand_reg_set;
     219                 :     458396 : }
     220                 :            : 
     221                 :            : /* After switches have been processed, which perhaps alter
     222                 :            :    `fixed_regs' and `call_used_regs', convert them to HARD_REG_SETs.  */
     223                 :            : static void
     224                 :     458396 : init_reg_sets_1 (void)
     225                 :            : {
     226                 :     458396 :   unsigned int i, j;
     227                 :     458396 :   unsigned int /* machine_mode */ m;
     228                 :            : 
     229                 :     458396 :   restore_register_info ();
     230                 :            : 
     231                 :            : #ifdef REG_ALLOC_ORDER
     232                 :   35296500 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     233                 :   34838100 :     inv_reg_alloc_order[reg_alloc_order[i]] = i;
     234                 :            : #endif
     235                 :            : 
     236                 :            :   /* Let the target tweak things if necessary.  */
     237                 :            : 
     238                 :     458396 :   targetm.conditional_register_usage ();
     239                 :            : 
     240                 :            :   /* Compute number of hard regs in each class.  */
     241                 :            : 
     242                 :     458396 :   memset (reg_class_size, 0, sizeof reg_class_size);
     243                 :   14210300 :   for (i = 0; i < N_REG_CLASSES; i++)
     244                 :            :     {
     245                 :            :       bool any_nonfixed = false;
     246                 : 1058890000 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)    
     247                 : 1045140000 :         if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
     248                 :            :           {
     249                 :  195736000 :             reg_class_size[i]++;
     250                 :  195736000 :             if (!fixed_regs[j])
     251                 :  183817000 :               any_nonfixed = true;
     252                 :            :           }
     253                 :   13751900 :       class_only_fixed_regs[i] = !any_nonfixed;
     254                 :            :     }
     255                 :            : 
     256                 :            :   /* Initialize the table of subunions.
     257                 :            :      reg_class_subunion[I][J] gets the largest-numbered reg-class
     258                 :            :      that is contained in the union of classes I and J.  */
     259                 :            : 
     260                 :     458396 :   memset (reg_class_subunion, 0, sizeof reg_class_subunion);
     261                 :   14210300 :   for (i = 0; i < N_REG_CLASSES; i++)
     262                 :            :     {
     263                 :  426308000 :       for (j = 0; j < N_REG_CLASSES; j++)
     264                 :            :         {
     265                 :            :           HARD_REG_SET c;
     266                 :            :           int k;
     267                 :            : 
     268                 : 1237670000 :           c = reg_class_contents[i] | reg_class_contents[j];
     269                 :12789200000 :           for (k = 0; k < N_REG_CLASSES; k++)
     270                 :37130100000 :             if (hard_reg_set_subset_p (reg_class_contents[k], c)
     271                 :17199600000 :                 && !hard_reg_set_subset_p (reg_class_contents[k],
     272                 :            :                                           reg_class_contents
     273                 : 4822860000 :                                           [(int) reg_class_subunion[i][j]]))
     274                 : 4410300000 :               reg_class_subunion[i][j] = (enum reg_class) k;
     275                 :            :         }
     276                 :            :     }
     277                 :            : 
     278                 :            :   /* Initialize the table of superunions.
     279                 :            :      reg_class_superunion[I][J] gets the smallest-numbered reg-class
     280                 :            :      containing the union of classes I and J.  */
     281                 :            : 
     282                 :     458396 :   memset (reg_class_superunion, 0, sizeof reg_class_superunion);
     283                 :   14210300 :   for (i = 0; i < N_REG_CLASSES; i++)
     284                 :            :     {
     285                 :  426308000 :       for (j = 0; j < N_REG_CLASSES; j++)
     286                 :            :         {
     287                 :            :           HARD_REG_SET c;
     288                 :            :           int k;
     289                 :            : 
     290                 : 1237670000 :           c = reg_class_contents[i] | reg_class_contents[j];
     291                 : 9469210000 :           for (k = 0; k < N_REG_CLASSES; k++)
     292                 :28407600000 :             if (hard_reg_set_subset_p (c, reg_class_contents[k]))
     293                 :            :               break;
     294                 :            : 
     295                 :  412556000 :           reg_class_superunion[i][j] = (enum reg_class) k;
     296                 :            :         }
     297                 :            :     }
     298                 :            : 
     299                 :            :   /* Initialize the tables of subclasses and superclasses of each reg class.
     300                 :            :      First clear the whole table, then add the elements as they are found.  */
     301                 :            : 
     302                 :   14210300 :   for (i = 0; i < N_REG_CLASSES; i++)
     303                 :            :     {
     304                 :  426308000 :       for (j = 0; j < N_REG_CLASSES; j++)
     305                 :  412556000 :         reg_class_subclasses[i][j] = LIM_REG_CLASSES;
     306                 :            :     }
     307                 :            : 
     308                 :   14210300 :   for (i = 0; i < N_REG_CLASSES; i++)
     309                 :            :     {
     310                 :   13751900 :       if (i == (int) NO_REGS)
     311                 :     458396 :         continue;
     312                 :            : 
     313                 :  199402000 :       for (j = i + 1; j < N_REG_CLASSES; j++)
     314                 :  558326000 :         if (hard_reg_set_subset_p (reg_class_contents[i],
     315                 :            :                                   reg_class_contents[j]))
     316                 :            :           {
     317                 :            :             /* Reg class I is a subclass of J.
     318                 :            :                Add J to the table of superclasses of I.  */
     319                 :   70569500 :             enum reg_class *p;
     320                 :            : 
     321                 :            :             /* Add I to the table of superclasses of J.  */
     322                 :   70569500 :             p = &reg_class_subclasses[j][0];
     323                 :  600380000 :             while (*p != LIM_REG_CLASSES) p++;
     324                 :   70569500 :             *p = (enum reg_class) i;
     325                 :            :           }
     326                 :            :     }
     327                 :            : 
     328                 :            :   /* Initialize "constant" tables.  */
     329                 :            : 
     330                 :    1375190 :   CLEAR_HARD_REG_SET (fixed_reg_set);
     331                 :    1375190 :   CLEAR_HARD_REG_SET (regs_invalidated_by_call);
     332                 :            : 
     333                 :    1375190 :   operand_reg_set &= accessible_reg_set;
     334                 :   35296500 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     335                 :            :     {
     336                 :            :       /* As a special exception, registers whose class is NO_REGS are
     337                 :            :          not accepted by `register_operand'.  The reason for this change
     338                 :            :          is to allow the representation of special architecture artifacts
     339                 :            :          (such as a condition code register) without extending the rtl
     340                 :            :          definitions.  Since registers of class NO_REGS cannot be used
     341                 :            :          as registers in any case where register classes are examined,
     342                 :            :          it is better to apply this exception in a target-independent way.  */
     343                 :   34838100 :       if (REGNO_REG_CLASS (i) == NO_REGS)
     344                 :     916792 :         CLEAR_HARD_REG_BIT (operand_reg_set, i);
     345                 :            : 
     346                 :            :       /* If a register is too limited to be treated as a register operand,
     347                 :            :          then it should never be allocated to a pseudo.  */
     348                 :   34838100 :       if (!TEST_HARD_REG_BIT (operand_reg_set, i))
     349                 :    7707060 :         fixed_regs[i] = 1;
     350                 :            : 
     351                 :   34838100 :       if (fixed_regs[i])
     352                 :    9082390 :         SET_HARD_REG_BIT (fixed_reg_set, i);
     353                 :            : 
     354                 :            :       /* There are a couple of fixed registers that we know are safe to
     355                 :            :          exclude from being clobbered by calls:
     356                 :            : 
     357                 :            :          The frame pointer is always preserved across calls.  The arg
     358                 :            :          pointer is if it is fixed.  The stack pointer usually is,
     359                 :            :          unless TARGET_RETURN_POPS_ARGS, in which case an explicit
     360                 :            :          CLOBBER will be present.  If we are generating PIC code, the
     361                 :            :          PIC offset table register is preserved across calls, though the
     362                 :            :          target can override that.  */
     363                 :            : 
     364                 :   34838100 :       if (i == STACK_POINTER_REGNUM)
     365                 :            :         ;
     366                 :   34379700 :       else if (global_regs[i])
     367                 :         54 :         SET_HARD_REG_BIT (regs_invalidated_by_call, i);
     368                 :   34379600 :       else if (i == FRAME_POINTER_REGNUM)
     369                 :            :         ;
     370                 :   33921200 :       else if (!HARD_FRAME_POINTER_IS_FRAME_POINTER
     371                 :            :                && i == HARD_FRAME_POINTER_REGNUM)
     372                 :            :         ;
     373                 :   33462900 :       else if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
     374                 :     458396 :                && i == ARG_POINTER_REGNUM && fixed_regs[i])
     375                 :            :         ;
     376                 :   33004500 :       else if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
     377                 :   33004500 :                && i == (unsigned) PIC_OFFSET_TABLE_REGNUM && fixed_regs[i])
     378                 :            :         ;
     379                 :   33004500 :       else if (call_used_regs[i])
     380                 :   34838100 :         SET_HARD_REG_BIT (regs_invalidated_by_call, i);
     381                 :            :     }
     382                 :            : 
     383                 :     458396 :   SET_HARD_REG_SET (savable_regs);
     384                 :     458396 :   fixed_nonglobal_reg_set = fixed_reg_set;
     385                 :            : 
     386                 :            :   /* Preserve global registers if called more than once.  */
     387                 :   35296500 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     388                 :            :     {
     389                 :   34838100 :       if (global_regs[i])
     390                 :            :         {
     391                 :         54 :           fixed_regs[i] = call_used_regs[i] = 1;
     392                 :   34838100 :           SET_HARD_REG_BIT (fixed_reg_set, i);
     393                 :            :         }
     394                 :            :     }
     395                 :            : 
     396                 :     458396 :   memset (have_regs_of_mode, 0, sizeof (have_regs_of_mode));
     397                 :     458396 :   memset (contains_reg_of_mode, 0, sizeof (contains_reg_of_mode));
     398                 :   51340400 :   for (m = 0; m < (unsigned int) MAX_MACHINE_MODE; m++)
     399                 :            :     {
     400                 :            :       HARD_REG_SET ok_regs, ok_regs2;
     401                 :  152646000 :       CLEAR_HARD_REG_SET (ok_regs);
     402                 :  152646000 :       CLEAR_HARD_REG_SET (ok_regs2);
     403                 : 3917910000 :       for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
     404                 : 3867030000 :         if (!TEST_HARD_REG_BIT (fixed_nonglobal_reg_set, j)
     405                 : 3867030000 :             && targetm.hard_regno_mode_ok (j, (machine_mode) m))
     406                 :            :           {
     407                 :  477310000 :             SET_HARD_REG_BIT (ok_regs, j);
     408                 :  477310000 :             if (!fixed_regs[j])
     409                 : 3867030000 :               SET_HARD_REG_BIT (ok_regs2, j);
     410                 :            :           }
     411                 :            : 
     412                 : 1577340000 :       for (i = 0; i < N_REG_CLASSES; i++)
     413                 : 1526460000 :         if ((targetm.class_max_nregs ((reg_class_t) i, (machine_mode) m)
     414                 : 1526460000 :              <= reg_class_size[i])
     415                 : 5219820000 :             && hard_reg_set_intersect_p (ok_regs, reg_class_contents[i]))
     416                 :            :           {
     417                 :  277974000 :              contains_reg_of_mode[i][m] = 1;
     418                 :  555949000 :              if (hard_reg_set_intersect_p (ok_regs2, reg_class_contents[i]))
     419                 :            :                {
     420                 :  277974000 :                  have_regs_of_mode[m] = 1;
     421                 :  277974000 :                  contains_allocatable_reg_of_mode[i][m] = 1;
     422                 :            :                }
     423                 :            :           }
     424                 :            :      }
     425                 :            : 
     426                 :     458396 :   default_function_abi.initialize (0, regs_invalidated_by_call);
     427                 :     458396 : }
     428                 :            : 
     429                 :            : /* Compute the table of register modes.
     430                 :            :    These values are used to record death information for individual registers
     431                 :            :    (as opposed to a multi-register mode).
     432                 :            :    This function might be invoked more than once, if the target has support
     433                 :            :    for changing register usage conventions on a per-function basis.
     434                 :            : */
     435                 :            : void
     436                 :     448992 : init_reg_modes_target (void)
     437                 :            : {
     438                 :     448992 :   int i, j;
     439                 :            : 
     440                 :   34572400 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     441                 : 3821820000 :     for (j = 0; j < MAX_MACHINE_MODE; j++)
     442                 : 7575390000 :       this_target_regs->x_hard_regno_nregs[i][j]
     443                 : 3787700000 :         = targetm.hard_regno_nregs (i, (machine_mode) j);
     444                 :            : 
     445                 :   34572400 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     446                 :            :     {
     447                 :   34123400 :       reg_raw_mode[i] = choose_hard_reg_mode (i, 1, NULL);
     448                 :            : 
     449                 :            :       /* If we couldn't find a valid mode, just use the previous mode
     450                 :            :          if it is suitable, otherwise fall back on word_mode.  */
     451                 :   34123400 :       if (reg_raw_mode[i] == VOIDmode)
     452                 :            :         {
     453                 :    4119660 :           if (i > 0 && hard_regno_nregs (i, reg_raw_mode[i - 1]) == 1)
     454                 :    4119660 :             reg_raw_mode[i] = reg_raw_mode[i - 1];
     455                 :            :           else
     456                 :          0 :             reg_raw_mode[i] = word_mode;
     457                 :            :         }
     458                 :            :     }
     459                 :     448992 : }
     460                 :            : 
     461                 :            : /* Finish initializing the register sets and initialize the register modes.
     462                 :            :    This function might be invoked more than once, if the target has support
     463                 :            :    for changing register usage conventions on a per-function basis.
     464                 :            : */
     465                 :            : void
     466                 :     458396 : init_regs (void)
     467                 :            : {
     468                 :            :   /* This finishes what was started by init_reg_sets, but couldn't be done
     469                 :            :      until after register usage was specified.  */
     470                 :     458396 :   init_reg_sets_1 ();
     471                 :     458396 : }
     472                 :            : 
     473                 :            : /* The same as previous function plus initializing IRA.  */
     474                 :            : void
     475                 :       9404 : reinit_regs (void)
     476                 :            : {
     477                 :       9404 :   init_regs ();
     478                 :            :   /* caller_save needs to be re-initialized.  */
     479                 :       9404 :   caller_save_initialized_p = false;
     480                 :       9404 :   if (this_target_rtl->target_specific_initialized)
     481                 :            :     {
     482                 :        158 :       ira_init ();
     483                 :        158 :       recog_init ();
     484                 :            :     }
     485                 :       9404 : }
     486                 :            : 
     487                 :            : /* Initialize some fake stack-frame MEM references for use in
     488                 :            :    memory_move_secondary_cost.  */
     489                 :            : void
     490                 :     151703 : init_fake_stack_mems (void)
     491                 :            : {
     492                 :     151703 :   int i;
     493                 :            : 
     494                 :   16990700 :   for (i = 0; i < MAX_MACHINE_MODE; i++)
     495                 :   16839000 :     top_of_stack[i] = gen_rtx_MEM ((machine_mode) i, stack_pointer_rtx);
     496                 :     151703 : }
     497                 :            : 
     498                 :            : 
     499                 :            : /* Compute cost of moving data from a register of class FROM to one of
     500                 :            :    TO, using MODE.  */
     501                 :            : 
     502                 :            : int
     503                 : 1910990000 : register_move_cost (machine_mode mode, reg_class_t from, reg_class_t to)
     504                 :            : {
     505                 : 1910990000 :   return targetm.register_move_cost (mode, from, to);
     506                 :            : }
     507                 :            : 
     508                 :            : /* Compute cost of moving registers to/from memory.  */
     509                 :            : 
     510                 :            : int
     511                 :  978090000 : memory_move_cost (machine_mode mode, reg_class_t rclass, bool in)
     512                 :            : {
     513                 :  978090000 :   return targetm.memory_move_cost (mode, rclass, in);
     514                 :            : }
     515                 :            : 
     516                 :            : /* Compute extra cost of moving registers to/from memory due to reloads.
     517                 :            :    Only needed if secondary reloads are required for memory moves.  */
     518                 :            : int
     519                 :          0 : memory_move_secondary_cost (machine_mode mode, reg_class_t rclass,
     520                 :            :                             bool in)
     521                 :            : {
     522                 :          0 :   reg_class_t altclass;
     523                 :          0 :   int partial_cost = 0;
     524                 :            :   /* We need a memory reference to feed to SECONDARY... macros.  */
     525                 :            :   /* mem may be unused even if the SECONDARY_ macros are defined.  */
     526                 :          0 :   rtx mem ATTRIBUTE_UNUSED = top_of_stack[(int) mode];
     527                 :            : 
     528                 :          0 :   altclass = secondary_reload_class (in ? 1 : 0, rclass, mode, mem);
     529                 :            : 
     530                 :          0 :   if (altclass == NO_REGS)
     531                 :            :     return 0;
     532                 :            : 
     533                 :          0 :   if (in)
     534                 :          0 :     partial_cost = register_move_cost (mode, altclass, rclass);
     535                 :            :   else
     536                 :          0 :     partial_cost = register_move_cost (mode, rclass, altclass);
     537                 :            : 
     538                 :          0 :   if (rclass == altclass)
     539                 :            :     /* This isn't simply a copy-to-temporary situation.  Can't guess
     540                 :            :        what it is, so TARGET_MEMORY_MOVE_COST really ought not to be
     541                 :            :        calling here in that case.
     542                 :            : 
     543                 :            :        I'm tempted to put in an assert here, but returning this will
     544                 :            :        probably only give poor estimates, which is what we would've
     545                 :            :        had before this code anyways.  */
     546                 :            :     return partial_cost;
     547                 :            : 
     548                 :            :   /* Check if the secondary reload register will also need a
     549                 :            :      secondary reload.  */
     550                 :          0 :   return memory_move_secondary_cost (mode, altclass, in) + partial_cost;
     551                 :            : }
     552                 :            : 
     553                 :            : /* Return a machine mode that is legitimate for hard reg REGNO and large
     554                 :            :    enough to save nregs.  If we can't find one, return VOIDmode.
     555                 :            :    If ABI is nonnull, only consider modes that are preserved across
     556                 :            :    calls that use ABI.  */
     557                 :            : machine_mode
     558                 :   34123400 : choose_hard_reg_mode (unsigned int regno ATTRIBUTE_UNUSED,
     559                 :            :                       unsigned int nregs, const predefined_function_abi *abi)
     560                 :            : {
     561                 :   34123400 :   unsigned int /* machine_mode */ m;
     562                 :   34123400 :   machine_mode found_mode = VOIDmode, mode;
     563                 :            : 
     564                 :            :   /* We first look for the largest integer mode that can be validly
     565                 :            :      held in REGNO.  If none, we look for the largest floating-point mode.
     566                 :            :      If we still didn't find a valid mode, try CCmode.
     567                 :            : 
     568                 :            :      The tests use maybe_gt rather than known_gt because we want (for example)
     569                 :            :      N V4SFs to win over plain V4SF even though N might be 1.  */
     570                 :  272987000 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_INT)
     571                 :  238864000 :     if (hard_regno_nregs (regno, mode) == nregs
     572                 :  217161000 :         && targetm.hard_regno_mode_ok (regno, mode)
     573                 :   91145200 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     574                 :  512299000 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     575                 :   91145200 :       found_mode = mode;
     576                 :            : 
     577                 :  170617000 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_FLOAT)
     578                 :  136494000 :     if (hard_regno_nregs (regno, mode) == nregs
     579                 :  121975000 :         && targetm.hard_regno_mode_ok (regno, mode)
     580                 :   63091400 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     581                 :  325768000 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     582                 :   10804100 :       found_mode = mode;
     583                 :            : 
     584                 :  545974000 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_VECTOR_FLOAT)
     585                 :  511851000 :     if (hard_regno_nregs (regno, mode) == nregs
     586                 :  384186000 :         && targetm.hard_regno_mode_ok (regno, mode)
     587                 :   59156800 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     588                 :  689321000 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     589                 :          0 :       found_mode = mode;
     590                 :            : 
     591                 : 1126070000 :   FOR_EACH_MODE_IN_CLASS (mode, MODE_VECTOR_INT)
     592                 : 1091950000 :     if (hard_regno_nregs (regno, mode) == nregs
     593                 :  891992000 :         && targetm.hard_regno_mode_ok (regno, mode)
     594                 :  176625000 :         && (!abi || !abi->clobbers_reg_p (mode, regno))
     595                 : 1621820000 :         && maybe_gt (GET_MODE_SIZE (mode), GET_MODE_SIZE (found_mode)))
     596                 :          0 :       found_mode = mode;
     597                 :            : 
     598                 :   34123400 :   if (found_mode != VOIDmode)
     599                 :            :     return found_mode;
     600                 :            : 
     601                 :            :   /* Iterate over all of the CCmodes.  */
     602                 :  453612000 :   for (m = (unsigned int) CCmode; m < (unsigned int) NUM_MACHINE_MODES; ++m)
     603                 :            :     {
     604                 :  449492000 :       mode = (machine_mode) m;
     605                 :  449492000 :       if (hard_regno_nregs (regno, mode) == nregs
     606                 :  375338000 :           && targetm.hard_regno_mode_ok (regno, mode)
     607                 :  449941000 :           && (!abi || !abi->clobbers_reg_p (mode, regno)))
     608                 :     448992 :         return mode;
     609                 :            :     }
     610                 :            : 
     611                 :            :   /* We can't find a mode valid for this register.  */
     612                 :            :   return VOIDmode;
     613                 :            : }
     614                 :            : 
     615                 :            : /* Specify the usage characteristics of the register named NAME.
     616                 :            :    It should be a fixed register if FIXED and a
     617                 :            :    call-used register if CALL_USED.  */
     618                 :            : void
     619                 :         83 : fix_register (const char *name, int fixed, int call_used)
     620                 :            : {
     621                 :         83 :   int i;
     622                 :         83 :   int reg, nregs;
     623                 :            : 
     624                 :            :   /* Decode the name and update the primary form of
     625                 :            :      the register info.  */
     626                 :            : 
     627                 :         83 :   if ((reg = decode_reg_name_and_count (name, &nregs)) >= 0)
     628                 :            :     {
     629                 :         83 :       gcc_assert (nregs >= 1);
     630                 :        166 :       for (i = reg; i < reg + nregs; i++)
     631                 :            :         {
     632                 :         83 :           if ((i == STACK_POINTER_REGNUM
     633                 :            : #ifdef HARD_FRAME_POINTER_REGNUM
     634                 :         83 :                || i == HARD_FRAME_POINTER_REGNUM
     635                 :            : #else
     636                 :            :                || i == FRAME_POINTER_REGNUM
     637                 :            : #endif
     638                 :            :                )
     639                 :          3 :               && (fixed == 0 || call_used == 0))
     640                 :            :             {
     641                 :          0 :               switch (fixed)
     642                 :            :                 {
     643                 :          0 :                 case 0:
     644                 :          0 :                   switch (call_used)
     645                 :            :                     {
     646                 :          0 :                     case 0:
     647                 :          0 :                       error ("cannot use %qs as a call-saved register", name);
     648                 :          0 :                       break;
     649                 :            : 
     650                 :          0 :                     case 1:
     651                 :          0 :                       error ("cannot use %qs as a call-used register", name);
     652                 :          0 :                       break;
     653                 :            : 
     654                 :          0 :                     default:
     655                 :          0 :                       gcc_unreachable ();
     656                 :            :                     }
     657                 :            :                   break;
     658                 :            : 
     659                 :          0 :                 case 1:
     660                 :          0 :                   switch (call_used)
     661                 :            :                     {
     662                 :          0 :                     case 1:
     663                 :          0 :                       error ("cannot use %qs as a fixed register", name);
     664                 :          0 :                       break;
     665                 :            : 
     666                 :          0 :                     case 0:
     667                 :          0 :                     default:
     668                 :          0 :                       gcc_unreachable ();
     669                 :            :                     }
     670                 :          0 :                   break;
     671                 :            : 
     672                 :          0 :                 default:
     673                 :          0 :                   gcc_unreachable ();
     674                 :            :                 }
     675                 :            :             }
     676                 :            :           else
     677                 :            :             {
     678                 :         83 :               fixed_regs[i] = fixed;
     679                 :            : #ifdef CALL_REALLY_USED_REGISTERS
     680                 :            :               if (fixed == 0)
     681                 :            :                 call_used_regs[i] = call_used;
     682                 :            : #else
     683                 :         83 :               call_used_regs[i] = call_used;
     684                 :            : #endif
     685                 :            :             }
     686                 :            :         }
     687                 :            :     }
     688                 :            :   else
     689                 :            :     {
     690                 :          0 :       warning (0, "unknown register name: %s", name);
     691                 :            :     }
     692                 :         83 : }
     693                 :            : 
     694                 :            : /* Mark register number I as global.  */
     695                 :            : void
     696                 :         76 : globalize_reg (tree decl, int i)
     697                 :            : {
     698                 :         76 :   location_t loc = DECL_SOURCE_LOCATION (decl);
     699                 :            : 
     700                 :            : #ifdef STACK_REGS
     701                 :         76 :   if (IN_RANGE (i, FIRST_STACK_REG, LAST_STACK_REG))
     702                 :            :     {
     703                 :          1 :       error ("stack register used for global register variable");
     704                 :          1 :       return;
     705                 :            :     }
     706                 :            : #endif
     707                 :            : 
     708                 :         75 :   if (fixed_regs[i] == 0 && no_global_reg_vars)
     709                 :          0 :     error_at (loc, "global register variable follows a function definition");
     710                 :            : 
     711                 :         75 :   if (global_regs[i])
     712                 :            :     {
     713                 :          0 :       auto_diagnostic_group d;
     714                 :          0 :       warning_at (loc, 0, 
     715                 :            :                   "register of %qD used for multiple global register variables",
     716                 :            :                   decl);
     717                 :          0 :       inform (DECL_SOURCE_LOCATION (global_regs_decl[i]),
     718                 :            :               "conflicts with %qD", global_regs_decl[i]); 
     719                 :          0 :       return;
     720                 :            :     }
     721                 :            : 
     722                 :         75 :   if (call_used_regs[i] && ! fixed_regs[i])
     723                 :         18 :     warning_at (loc, 0, "call-clobbered register used for global register variable");
     724                 :            : 
     725                 :         75 :   global_regs[i] = 1;
     726                 :         75 :   global_regs_decl[i] = decl;
     727                 :            : 
     728                 :            :   /* If we're globalizing the frame pointer, we need to set the
     729                 :            :      appropriate regs_invalidated_by_call bit, even if it's already
     730                 :            :      set in fixed_regs.  */
     731                 :         75 :   if (i != STACK_POINTER_REGNUM)
     732                 :            :     {
     733                 :         70 :       SET_HARD_REG_BIT (regs_invalidated_by_call, i);
     734                 :        630 :       for (unsigned int j = 0; j < NUM_ABI_IDS; ++j)
     735                 :        560 :         function_abis[j].add_full_reg_clobber (i);
     736                 :            :     }
     737                 :            : 
     738                 :            :   /* If already fixed, nothing else to do.  */
     739                 :         75 :   if (fixed_regs[i])
     740                 :            :     return;
     741                 :            : 
     742                 :         54 :   fixed_regs[i] = call_used_regs[i] = 1;
     743                 :            : 
     744                 :         54 :   SET_HARD_REG_BIT (fixed_reg_set, i);
     745                 :            : 
     746                 :         54 :   reinit_regs ();
     747                 :            : }
     748                 :            : 
     749                 :            : 
     750                 :            : /* Structure used to record preferences of given pseudo.  */
     751                 :            : struct reg_pref
     752                 :            : {
     753                 :            :   /* (enum reg_class) prefclass is the preferred class.  May be
     754                 :            :      NO_REGS if no class is better than memory.  */
     755                 :            :   char prefclass;
     756                 :            : 
     757                 :            :   /* altclass is a register class that we should use for allocating
     758                 :            :      pseudo if no register in the preferred class is available.
     759                 :            :      If no register in this class is available, memory is preferred.
     760                 :            : 
     761                 :            :      It might appear to be more general to have a bitmask of classes here,
     762                 :            :      but since it is recommended that there be a class corresponding to the
     763                 :            :      union of most major pair of classes, that generality is not required.  */
     764                 :            :   char altclass;
     765                 :            : 
     766                 :            :   /* allocnoclass is a register class that IRA uses for allocating
     767                 :            :      the pseudo.  */
     768                 :            :   char allocnoclass;
     769                 :            : };
     770                 :            : 
     771                 :            : /* Record preferences of each pseudo.  This is available after RA is
     772                 :            :    run.  */
     773                 :            : static struct reg_pref *reg_pref;
     774                 :            : 
     775                 :            : /* Current size of reg_info.  */
     776                 :            : static int reg_info_size;
     777                 :            : /* Max_reg_num still last resize_reg_info call.  */
     778                 :            : static int max_regno_since_last_resize;
     779                 :            : 
     780                 :            : /* Return the reg_class in which pseudo reg number REGNO is best allocated.
     781                 :            :    This function is sometimes called before the info has been computed.
     782                 :            :    When that happens, just return GENERAL_REGS, which is innocuous.  */
     783                 :            : enum reg_class
     784                 :   37060300 : reg_preferred_class (int regno)
     785                 :            : {
     786                 :   37060300 :   if (reg_pref == 0)
     787                 :            :     return GENERAL_REGS;
     788                 :            : 
     789                 :   37060300 :   gcc_assert (regno < reg_info_size);
     790                 :   37060300 :   return (enum reg_class) reg_pref[regno].prefclass;
     791                 :            : }
     792                 :            : 
     793                 :            : enum reg_class
     794                 :    1339040 : reg_alternate_class (int regno)
     795                 :            : {
     796                 :    1339040 :   if (reg_pref == 0)
     797                 :            :     return ALL_REGS;
     798                 :            : 
     799                 :    1339040 :   gcc_assert (regno < reg_info_size);
     800                 :    1339040 :   return (enum reg_class) reg_pref[regno].altclass;
     801                 :            : }
     802                 :            : 
     803                 :            : /* Return the reg_class which is used by IRA for its allocation.  */
     804                 :            : enum reg_class
     805                 :  127543000 : reg_allocno_class (int regno)
     806                 :            : {
     807                 :  127543000 :   if (reg_pref == 0)
     808                 :            :     return NO_REGS;
     809                 :            : 
     810                 :  127543000 :   gcc_assert (regno < reg_info_size);
     811                 :  127543000 :   return (enum reg_class) reg_pref[regno].allocnoclass;
     812                 :            : }
     813                 :            : 
     814                 :            : 
     815                 :            : 
     816                 :            : /* Allocate space for reg info and initilize it.  */
     817                 :            : static void
     818                 :     964270 : allocate_reg_info (void)
     819                 :            : {
     820                 :     964270 :   int i;
     821                 :            : 
     822                 :     964270 :   max_regno_since_last_resize = max_reg_num ();
     823                 :     964270 :   reg_info_size = max_regno_since_last_resize * 3 / 2 + 1;
     824                 :     964270 :   gcc_assert (! reg_pref && ! reg_renumber);
     825                 :     964270 :   reg_renumber = XNEWVEC (short, reg_info_size);
     826                 :     964270 :   reg_pref = XCNEWVEC (struct reg_pref, reg_info_size);
     827                 :     964270 :   memset (reg_renumber, -1, reg_info_size * sizeof (short));
     828                 :  173302000 :   for (i = 0; i < reg_info_size; i++)
     829                 :            :     {
     830                 :  172337000 :       reg_pref[i].prefclass = GENERAL_REGS;
     831                 :  172337000 :       reg_pref[i].altclass = ALL_REGS;
     832                 :  172337000 :       reg_pref[i].allocnoclass = GENERAL_REGS;
     833                 :            :     }
     834                 :     964270 : }
     835                 :            : 
     836                 :            : 
     837                 :            : /* Resize reg info. The new elements will be initialized.  Return TRUE
     838                 :            :    if new pseudos were added since the last call.  */
     839                 :            : bool
     840                 :  707967000 : resize_reg_info (void)
     841                 :            : {
     842                 :  707967000 :   int old, i;
     843                 :  707967000 :   bool change_p;
     844                 :            : 
     845                 :  707967000 :   if (reg_pref == NULL)
     846                 :            :     {
     847                 :     964270 :       allocate_reg_info ();
     848                 :     964270 :       return true;
     849                 :            :     }
     850                 :  707003000 :   change_p = max_regno_since_last_resize != max_reg_num ();
     851                 :  707003000 :   max_regno_since_last_resize = max_reg_num ();
     852                 :  707003000 :   if (reg_info_size >= max_reg_num ())
     853                 :            :     return change_p;
     854                 :       3183 :   old = reg_info_size;
     855                 :       3183 :   reg_info_size = max_reg_num () * 3 / 2 + 1;
     856                 :       3183 :   gcc_assert (reg_pref && reg_renumber);
     857                 :       3183 :   reg_renumber = XRESIZEVEC (short, reg_renumber, reg_info_size);
     858                 :       3183 :   reg_pref = XRESIZEVEC (struct reg_pref, reg_pref, reg_info_size);
     859                 :       3183 :   memset (reg_pref + old, -1,
     860                 :       3183 :           (reg_info_size - old) * sizeof (struct reg_pref));
     861                 :       3183 :   memset (reg_renumber + old, -1, (reg_info_size - old) * sizeof (short));
     862                 :    1878690 :   for (i = old; i < reg_info_size; i++)
     863                 :            :     {
     864                 :    1875510 :       reg_pref[i].prefclass = GENERAL_REGS;
     865                 :    1875510 :       reg_pref[i].altclass = ALL_REGS;
     866                 :    1875510 :       reg_pref[i].allocnoclass = GENERAL_REGS;
     867                 :            :     }
     868                 :            :   return true;
     869                 :            : }
     870                 :            : 
     871                 :            : 
     872                 :            : /* Free up the space allocated by allocate_reg_info.  */
     873                 :            : void
     874                 :     964272 : free_reg_info (void)
     875                 :            : {
     876                 :     964272 :   if (reg_pref)
     877                 :            :     {
     878                 :     964270 :       free (reg_pref);
     879                 :     964270 :       reg_pref = NULL;
     880                 :            :     }
     881                 :            : 
     882                 :     964272 :   if (reg_renumber)
     883                 :            :     {
     884                 :     964270 :       free (reg_renumber);
     885                 :     964270 :       reg_renumber = NULL;
     886                 :            :     }
     887                 :     964272 : }
     888                 :            : 
     889                 :            : /* Initialize some global data for this pass.  */
     890                 :            : static unsigned int
     891                 :     944094 : reginfo_init (void)
     892                 :            : {
     893                 :          0 :   if (df)
     894                 :     688548 :     df_compute_regs_ever_live (true);
     895                 :            : 
     896                 :            :   /* This prevents dump_reg_info from losing if called
     897                 :            :      before reginfo is run.  */
     898                 :     944094 :   reg_pref = NULL;
     899                 :     944094 :   reg_info_size = max_regno_since_last_resize = 0;
     900                 :            :   /* No more global register variables may be declared.  */
     901                 :     944094 :   no_global_reg_vars = 1;
     902                 :     944094 :   return 1;
     903                 :            : }
     904                 :            : 
     905                 :            : namespace {
     906                 :            : 
     907                 :            : const pass_data pass_data_reginfo_init =
     908                 :            : {
     909                 :            :   RTL_PASS, /* type */
     910                 :            :   "reginfo", /* name */
     911                 :            :   OPTGROUP_NONE, /* optinfo_flags */
     912                 :            :   TV_NONE, /* tv_id */
     913                 :            :   0, /* properties_required */
     914                 :            :   0, /* properties_provided */
     915                 :            :   0, /* properties_destroyed */
     916                 :            :   0, /* todo_flags_start */
     917                 :            :   0, /* todo_flags_finish */
     918                 :            : };
     919                 :            : 
     920                 :            : class pass_reginfo_init : public rtl_opt_pass
     921                 :            : {
     922                 :            : public:
     923                 :     200773 :   pass_reginfo_init (gcc::context *ctxt)
     924                 :     401546 :     : rtl_opt_pass (pass_data_reginfo_init, ctxt)
     925                 :            :   {}
     926                 :            : 
     927                 :            :   /* opt_pass methods: */
     928                 :     944094 :   virtual unsigned int execute (function *) { return reginfo_init (); }
     929                 :            : 
     930                 :            : }; // class pass_reginfo_init
     931                 :            : 
     932                 :            : } // anon namespace
     933                 :            : 
     934                 :            : rtl_opt_pass *
     935                 :     200773 : make_pass_reginfo_init (gcc::context *ctxt)
     936                 :            : {
     937                 :     200773 :   return new pass_reginfo_init (ctxt);
     938                 :            : }
     939                 :            : 
     940                 :            : 
     941                 :            : 
     942                 :            : /* Set up preferred, alternate, and allocno classes for REGNO as
     943                 :            :    PREFCLASS, ALTCLASS, and ALLOCNOCLASS.  */
     944                 :            : void
     945                 :   27290700 : setup_reg_classes (int regno,
     946                 :            :                    enum reg_class prefclass, enum reg_class altclass,
     947                 :            :                    enum reg_class allocnoclass)
     948                 :            : {
     949                 :   27290700 :   if (reg_pref == NULL)
     950                 :            :     return;
     951                 :   27290700 :   gcc_assert (reg_info_size >= max_reg_num ());
     952                 :   27290700 :   reg_pref[regno].prefclass = prefclass;
     953                 :   27290700 :   reg_pref[regno].altclass = altclass;
     954                 :   27290700 :   reg_pref[regno].allocnoclass = allocnoclass;
     955                 :            : }
     956                 :            : 
     957                 :            : 
     958                 :            : /* This is the `regscan' pass of the compiler, run just before cse and
     959                 :            :    again just before loop.  It finds the first and last use of each
     960                 :            :    pseudo-register.  */
     961                 :            : 
     962                 :            : static void reg_scan_mark_refs (rtx, rtx_insn *);
     963                 :            : 
     964                 :            : void
     965                 :    1551540 : reg_scan (rtx_insn *f, unsigned int nregs ATTRIBUTE_UNUSED)
     966                 :            : {
     967                 :    1551540 :   rtx_insn *insn;
     968                 :            : 
     969                 :    1551540 :   timevar_push (TV_REG_SCAN);
     970                 :            : 
     971                 :  431314000 :   for (insn = f; insn; insn = NEXT_INSN (insn))
     972                 :  214881000 :     if (INSN_P (insn))
     973                 :            :       {
     974                 :  185637000 :         reg_scan_mark_refs (PATTERN (insn), insn);
     975                 :  185637000 :         if (REG_NOTES (insn))
     976                 :   70063700 :           reg_scan_mark_refs (REG_NOTES (insn), insn);
     977                 :            :       }
     978                 :            : 
     979                 :    1551540 :   timevar_pop (TV_REG_SCAN);
     980                 :    1551540 : }
     981                 :            : 
     982                 :            : 
     983                 :            : /* X is the expression to scan.  INSN is the insn it appears in.
     984                 :            :    NOTE_FLAG is nonzero if X is from INSN's notes rather than its body.
     985                 :            :    We should only record information for REGs with numbers
     986                 :            :    greater than or equal to MIN_REGNO.  */
     987                 :            : static void
     988                 :  903709000 : reg_scan_mark_refs (rtx x, rtx_insn *insn)
     989                 :            : {
     990                 :  950696000 :   enum rtx_code code;
     991                 :  950696000 :   rtx dest;
     992                 :  950696000 :   rtx note;
     993                 :            : 
     994                 :  950696000 :   if (!x)
     995                 :            :     return;
     996                 :  950696000 :   code = GET_CODE (x);
     997                 :  950696000 :   switch (code)
     998                 :            :     {
     999                 :            :     case CONST:
    1000                 :            :     CASE_CONST_ANY:
    1001                 :            :     case CC0:
    1002                 :            :     case PC:
    1003                 :            :     case SYMBOL_REF:
    1004                 :            :     case LABEL_REF:
    1005                 :            :     case ADDR_VEC:
    1006                 :            :     case ADDR_DIFF_VEC:
    1007                 :            :     case REG:
    1008                 :            :       return;
    1009                 :            : 
    1010                 :  108557000 :     case EXPR_LIST:
    1011                 :  108557000 :       if (XEXP (x, 0))
    1012                 :  108236000 :         reg_scan_mark_refs (XEXP (x, 0), insn);
    1013                 :  108557000 :       if (XEXP (x, 1))
    1014                 :            :         reg_scan_mark_refs (XEXP (x, 1), insn);
    1015                 :            :       break;
    1016                 :            : 
    1017                 :    8441640 :     case INSN_LIST:
    1018                 :    8441640 :     case INT_LIST:
    1019                 :    8441640 :       if (XEXP (x, 1))
    1020                 :            :         reg_scan_mark_refs (XEXP (x, 1), insn);
    1021                 :            :       break;
    1022                 :            : 
    1023                 :   46687400 :     case CLOBBER:
    1024                 :   46687400 :       if (MEM_P (XEXP (x, 0)))
    1025                 :      52628 :         reg_scan_mark_refs (XEXP (XEXP (x, 0), 0), insn);
    1026                 :            :       break;
    1027                 :            : 
    1028                 :   99971500 :     case SET:
    1029                 :            :       /* Count a set of the destination if it is a register.  */
    1030                 :   99971500 :       for (dest = SET_DEST (x);
    1031                 :  100597000 :            GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
    1032                 :  100597000 :            || GET_CODE (dest) == ZERO_EXTRACT;
    1033                 :     625786 :            dest = XEXP (dest, 0))
    1034                 :            :         ;
    1035                 :            : 
    1036                 :            :       /* If this is setting a pseudo from another pseudo or the sum of a
    1037                 :            :          pseudo and a constant integer and the other pseudo is known to be
    1038                 :            :          a pointer, set the destination to be a pointer as well.
    1039                 :            : 
    1040                 :            :          Likewise if it is setting the destination from an address or from a
    1041                 :            :          value equivalent to an address or to the sum of an address and
    1042                 :            :          something else.
    1043                 :            : 
    1044                 :            :          But don't do any of this if the pseudo corresponds to a user
    1045                 :            :          variable since it should have already been set as a pointer based
    1046                 :            :          on the type.  */
    1047                 :            : 
    1048                 :   99971500 :       if (REG_P (SET_DEST (x))
    1049                 :   72974000 :           && REGNO (SET_DEST (x)) >= FIRST_PSEUDO_REGISTER
    1050                 :            :           /* If the destination pseudo is set more than once, then other
    1051                 :            :              sets might not be to a pointer value (consider access to a
    1052                 :            :              union in two threads of control in the presence of global
    1053                 :            :              optimizations).  So only set REG_POINTER on the destination
    1054                 :            :              pseudo if this is the only set of that pseudo.  */
    1055                 :   42360300 :           && DF_REG_DEF_COUNT (REGNO (SET_DEST (x))) == 1
    1056                 :   33413900 :           && ! REG_USERVAR_P (SET_DEST (x))
    1057                 :   31025200 :           && ! REG_POINTER (SET_DEST (x))
    1058                 :  123828000 :           && ((REG_P (SET_SRC (x))
    1059                 :    3313180 :                && REG_POINTER (SET_SRC (x)))
    1060                 :   23530400 :               || ((GET_CODE (SET_SRC (x)) == PLUS
    1061                 :   19600000 :                    || GET_CODE (SET_SRC (x)) == LO_SUM)
    1062                 :    3930340 :                   && CONST_INT_P (XEXP (SET_SRC (x), 1))
    1063                 :    2670150 :                   && REG_P (XEXP (SET_SRC (x), 0))
    1064                 :    2629910 :                   && REG_POINTER (XEXP (SET_SRC (x), 0)))
    1065                 :   21882100 :               || GET_CODE (SET_SRC (x)) == CONST
    1066                 :   21866900 :               || GET_CODE (SET_SRC (x)) == SYMBOL_REF
    1067                 :   21783700 :               || GET_CODE (SET_SRC (x)) == LABEL_REF
    1068                 :   21782700 :               || (GET_CODE (SET_SRC (x)) == HIGH
    1069                 :          0 :                   && (GET_CODE (XEXP (SET_SRC (x), 0)) == CONST
    1070                 :          0 :                       || GET_CODE (XEXP (SET_SRC (x), 0)) == SYMBOL_REF
    1071                 :          0 :                       || GET_CODE (XEXP (SET_SRC (x), 0)) == LABEL_REF))
    1072                 :   21782700 :               || ((GET_CODE (SET_SRC (x)) == PLUS
    1073                 :   19500600 :                    || GET_CODE (SET_SRC (x)) == LO_SUM)
    1074                 :    2282080 :                   && (GET_CODE (XEXP (SET_SRC (x), 1)) == CONST
    1075                 :    2274550 :                       || GET_CODE (XEXP (SET_SRC (x), 1)) == SYMBOL_REF
    1076                 :    2268740 :                       || GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF))
    1077                 :   21769300 :               || ((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
    1078                 :    1659700 :                   && (GET_CODE (XEXP (note, 0)) == CONST
    1079                 :    1659630 :                       || GET_CODE (XEXP (note, 0)) == SYMBOL_REF
    1080                 :    1652370 :                       || GET_CODE (XEXP (note, 0)) == LABEL_REF))))
    1081                 :    2094450 :         REG_POINTER (SET_DEST (x)) = 1;
    1082                 :            : 
    1083                 :            :       /* If this is setting a register from a register or from a simple
    1084                 :            :          conversion of a register, propagate REG_EXPR.  */
    1085                 :   99971500 :       if (REG_P (dest) && !REG_ATTRS (dest))
    1086                 :   48943500 :         set_reg_attrs_from_value (dest, SET_SRC (x));
    1087                 :            : 
    1088                 :            :       /* fall through */
    1089                 :            : 
    1090                 :  354825000 :     default:
    1091                 :  354825000 :       {
    1092                 :  354825000 :         const char *fmt = GET_RTX_FORMAT (code);
    1093                 :  354825000 :         int i;
    1094                 : 1001670000 :         for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1095                 :            :           {
    1096                 :  646840000 :             if (fmt[i] == 'e')
    1097                 :  501937000 :               reg_scan_mark_refs (XEXP (x, i), insn);
    1098                 :  144903000 :             else if (fmt[i] == 'E' && XVEC (x, i) != 0)
    1099                 :            :               {
    1100                 :   19146400 :                 int j;
    1101                 :   56981600 :                 for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1102                 :   37835200 :                   reg_scan_mark_refs (XVECEXP (x, i, j), insn);
    1103                 :            :               }
    1104                 :            :           }
    1105                 :            :       }
    1106                 :            :     }
    1107                 :            : }
    1108                 :            : 
    1109                 :            : 
    1110                 :            : /* Return nonzero if C1 is a subset of C2, i.e., if every register in C1
    1111                 :            :    is also in C2.  */
    1112                 :            : int
    1113                 :23435200000 : reg_class_subset_p (reg_class_t c1, reg_class_t c2)
    1114                 :            : {
    1115                 :23435200000 :   return (c1 == c2
    1116                 :23435200000 :           || c2 == ALL_REGS
    1117                 :46331800000 :           || hard_reg_set_subset_p (reg_class_contents[(int) c1],
    1118                 :22896600000 :                                    reg_class_contents[(int) c2]));
    1119                 :            : }
    1120                 :            : 
    1121                 :            : /* Return nonzero if there is a register that is in both C1 and C2.  */
    1122                 :            : int
    1123                 :16449700000 : reg_classes_intersect_p (reg_class_t c1, reg_class_t c2)
    1124                 :            : {
    1125                 :16449700000 :   return (c1 == c2
    1126                 :16449700000 :           || c1 == ALL_REGS
    1127                 :15842800000 :           || c2 == ALL_REGS
    1128                 :32291700000 :           || hard_reg_set_intersect_p (reg_class_contents[(int) c1],
    1129                 :15842100000 :                                       reg_class_contents[(int) c2]));
    1130                 :            : }
    1131                 :            : 
    1132                 :            : 
    1133                 :            : inline hashval_t
    1134                 :    3806340 : simplifiable_subregs_hasher::hash (const simplifiable_subreg *value)
    1135                 :            : {
    1136                 :    3806340 :   inchash::hash h;
    1137                 :    3806340 :   h.add_hwi (value->shape.unique_id ());
    1138                 :    3806340 :   return h.end ();
    1139                 :            : }
    1140                 :            : 
    1141                 :            : inline bool
    1142                 :    5025360 : simplifiable_subregs_hasher::equal (const simplifiable_subreg *value,
    1143                 :            :                                     const subreg_shape *compare)
    1144                 :            : {
    1145                 :   21438900 :   return value->shape == *compare;
    1146                 :            : }
    1147                 :            : 
    1148                 :      82172 : inline simplifiable_subreg::simplifiable_subreg (const subreg_shape &shape_in)
    1149                 :      82172 :   : shape (shape_in)
    1150                 :            : {
    1151                 :    6409420 :   CLEAR_HARD_REG_SET (simplifiable_regs);
    1152                 :            : }
    1153                 :            : 
    1154                 :            : /* Return the set of hard registers that are able to form the subreg
    1155                 :            :    described by SHAPE.  */
    1156                 :            : 
    1157                 :            : const HARD_REG_SET &
    1158                 :    1861640 : simplifiable_subregs (const subreg_shape &shape)
    1159                 :            : {
    1160                 :    1861640 :   if (!this_target_hard_regs->x_simplifiable_subregs)
    1161                 :      75866 :     this_target_hard_regs->x_simplifiable_subregs
    1162                 :      37933 :       = new hash_table <simplifiable_subregs_hasher> (30);
    1163                 :    1861640 :   inchash::hash h;
    1164                 :    1861640 :   h.add_hwi (shape.unique_id ());
    1165                 :    1861640 :   simplifiable_subreg **slot
    1166                 :    1861640 :     = (this_target_hard_regs->x_simplifiable_subregs
    1167                 :    1861640 :        ->find_slot_with_hash (&shape, h.end (), INSERT));
    1168                 :            : 
    1169                 :    1861640 :   if (!*slot)
    1170                 :            :     {
    1171                 :      82172 :       simplifiable_subreg *info = new simplifiable_subreg (shape);
    1172                 :    6327240 :       for (unsigned int i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1173                 :    6245070 :         if (targetm.hard_regno_mode_ok (i, shape.inner_mode)
    1174                 :    9227200 :             && simplify_subreg_regno (i, shape.inner_mode, shape.offset,
    1175                 :    2982130 :                                       shape.outer_mode) >= 0)
    1176                 :    6245070 :           SET_HARD_REG_BIT (info->simplifiable_regs, i);
    1177                 :      82172 :       *slot = info;
    1178                 :            :     }
    1179                 :    1861640 :   return (*slot)->simplifiable_regs;
    1180                 :            : }
    1181                 :            : 
    1182                 :            : /* Passes for keeping and updating info about modes of registers
    1183                 :            :    inside subregisters.  */
    1184                 :            : 
    1185                 :            : static HARD_REG_SET **valid_mode_changes;
    1186                 :            : static obstack valid_mode_changes_obstack;
    1187                 :            : 
    1188                 :            : /* Restrict the choice of register for SUBREG_REG (SUBREG) based
    1189                 :            :    on information about SUBREG.
    1190                 :            : 
    1191                 :            :    If PARTIAL_DEF, SUBREG is a partial definition of a multipart inner
    1192                 :            :    register and we want to ensure that the other parts of the inner
    1193                 :            :    register are correctly preserved.  If !PARTIAL_DEF we need to
    1194                 :            :    ensure that SUBREG itself can be formed.  */
    1195                 :            : 
    1196                 :            : static void
    1197                 :    1863290 : record_subregs_of_mode (rtx subreg, bool partial_def)
    1198                 :            : {
    1199                 :    1863290 :   unsigned int regno;
    1200                 :            : 
    1201                 :    1863290 :   if (!REG_P (SUBREG_REG (subreg)))
    1202                 :       1644 :     return;
    1203                 :            : 
    1204                 :    1862130 :   regno = REGNO (SUBREG_REG (subreg));
    1205                 :    1862130 :   if (regno < FIRST_PSEUDO_REGISTER)
    1206                 :            :     return;
    1207                 :            : 
    1208                 :    1861640 :   subreg_shape shape (shape_of_subreg (subreg));
    1209                 :    1861640 :   if (partial_def)
    1210                 :            :     {
    1211                 :            :       /* The number of independently-accessible SHAPE.outer_mode values
    1212                 :            :          in SHAPE.inner_mode is GET_MODE_SIZE (SHAPE.inner_mode) / SIZE.
    1213                 :            :          We need to check that the assignment will preserve all the other
    1214                 :            :          SIZE-byte chunks in the inner register besides the one that
    1215                 :            :          includes SUBREG.
    1216                 :            : 
    1217                 :            :          In practice it is enough to check whether an equivalent
    1218                 :            :          SHAPE.inner_mode value in an adjacent SIZE-byte chunk can be formed.
    1219                 :            :          If the underlying registers are small enough, both subregs will
    1220                 :            :          be valid.  If the underlying registers are too large, one of the
    1221                 :            :          subregs will be invalid.
    1222                 :            : 
    1223                 :            :          This relies on the fact that we've already been passed
    1224                 :            :          SUBREG with PARTIAL_DEF set to false.
    1225                 :            : 
    1226                 :            :          The size of the outer mode must ordered wrt the size of the
    1227                 :            :          inner mode's registers, since otherwise we wouldn't know at
    1228                 :            :          compile time how many registers the outer mode occupies.  */
    1229                 :     576158 :       poly_uint64 size = ordered_max (REGMODE_NATURAL_SIZE (shape.inner_mode),
    1230                 :     864237 :                                       GET_MODE_SIZE (shape.outer_mode));
    1231                 :     576158 :       gcc_checking_assert (known_lt (size, GET_MODE_SIZE (shape.inner_mode)));
    1232                 :     288079 :       if (known_ge (shape.offset, size))
    1233                 :     153920 :         shape.offset -= size;
    1234                 :            :       else
    1235                 :     134159 :         shape.offset += size;
    1236                 :            :     }
    1237                 :            : 
    1238                 :    1861640 :   if (valid_mode_changes[regno])
    1239                 :    2666750 :     *valid_mode_changes[regno] &= simplifiable_subregs (shape);
    1240                 :            :   else
    1241                 :            :     {
    1242                 :    1056540 :       valid_mode_changes[regno]
    1243                 :    1056540 :         = XOBNEW (&valid_mode_changes_obstack, HARD_REG_SET);
    1244                 :    1056540 :       *valid_mode_changes[regno] = simplifiable_subregs (shape);
    1245                 :            :     }
    1246                 :            : }
    1247                 :            : 
    1248                 :            : /* Call record_subregs_of_mode for all the subregs in X.  */
    1249                 :            : static void
    1250                 :  290618000 : find_subregs_of_mode (rtx x)
    1251                 :            : {
    1252                 :  290618000 :   enum rtx_code code = GET_CODE (x);
    1253                 :  290618000 :   const char * const fmt = GET_RTX_FORMAT (code);
    1254                 :  290618000 :   int i;
    1255                 :            : 
    1256                 :  290618000 :   if (code == SUBREG)
    1257                 :    1575210 :     record_subregs_of_mode (x, false);
    1258                 :            : 
    1259                 :            :   /* Time for some deep diving.  */
    1260                 :  702118000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1261                 :            :     {
    1262                 :  411500000 :       if (fmt[i] == 'e')
    1263                 :  219945000 :         find_subregs_of_mode (XEXP (x, i));
    1264                 :  191555000 :       else if (fmt[i] == 'E')
    1265                 :            :         {
    1266                 :    8743050 :           int j;
    1267                 :   25895200 :           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1268                 :   17152200 :             find_subregs_of_mode (XVECEXP (x, i, j));
    1269                 :            :         }
    1270                 :            :     }
    1271                 :  290618000 : }
    1272                 :            : 
    1273                 :            : void
    1274                 :     964355 : init_subregs_of_mode (void)
    1275                 :            : {
    1276                 :     964355 :   basic_block bb;
    1277                 :     964355 :   rtx_insn *insn;
    1278                 :            : 
    1279                 :     964355 :   gcc_obstack_init (&valid_mode_changes_obstack);
    1280                 :     964355 :   valid_mode_changes = XCNEWVEC (HARD_REG_SET *, max_reg_num ());
    1281                 :            : 
    1282                 :   10290900 :   FOR_EACH_BB_FN (bb, cfun)
    1283                 :  206511000 :     FOR_BB_INSNS (bb, insn)
    1284                 :   98592400 :       if (NONDEBUG_INSN_P (insn))
    1285                 :            :         {
    1286                 :   53520900 :           find_subregs_of_mode (PATTERN (insn));
    1287                 :   53520900 :           df_ref def;
    1288                 :  365693000 :           FOR_EACH_INSN_DEF (def, insn)
    1289                 :  312172000 :             if (DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL)
    1290                 :  312172000 :                 && read_modify_subreg_p (DF_REF_REG (def)))
    1291                 :     288079 :               record_subregs_of_mode (DF_REF_REG (def), true);
    1292                 :            :         }
    1293                 :     964355 : }
    1294                 :            : 
    1295                 :            : const HARD_REG_SET *
    1296                 :   71023200 : valid_mode_changes_for_regno (unsigned int regno)
    1297                 :            : {
    1298                 :   71023200 :   return valid_mode_changes[regno];
    1299                 :            : }
    1300                 :            : 
    1301                 :            : void
    1302                 :     964355 : finish_subregs_of_mode (void)
    1303                 :            : {
    1304                 :     964355 :   XDELETEVEC (valid_mode_changes);
    1305                 :     964355 :   obstack_free (&valid_mode_changes_obstack, NULL);
    1306                 :     964355 : }
    1307                 :            : 
    1308                 :            : /* Free all data attached to the structure.  This isn't a destructor because
    1309                 :            :    we don't want to run on exit.  */
    1310                 :            : 
    1311                 :            : void
    1312                 :        310 : target_hard_regs::finalize ()
    1313                 :            : {
    1314                 :        310 :   delete x_simplifiable_subregs;
    1315                 :        310 : }

Generated by: LCOV version 1.0

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