LCOV - code coverage report
Current view: top level - gcc - regcprop.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 91.8 % 648 595
Test Date: 2024-03-23 14:05:01 Functions: 89.3 % 28 25
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Copy propagation on hard registers for the GNU compiler.
       2                 :             :    Copyright (C) 2000-2024 Free Software Foundation, Inc.
       3                 :             : 
       4                 :             :    This file is part of GCC.
       5                 :             : 
       6                 :             :    GCC is free software; you can redistribute it and/or modify it
       7                 :             :    under the terms of the GNU General Public License as published by
       8                 :             :    the Free Software Foundation; either version 3, or (at your option)
       9                 :             :    any later version.
      10                 :             : 
      11                 :             :    GCC is distributed in the hope that it will be useful, but WITHOUT
      12                 :             :    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      13                 :             :    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      14                 :             :    License 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                 :             : #include "config.h"
      21                 :             : #include "system.h"
      22                 :             : #include "coretypes.h"
      23                 :             : #include "backend.h"
      24                 :             : #include "rtl.h"
      25                 :             : #include "df.h"
      26                 :             : #include "memmodel.h"
      27                 :             : #include "tm_p.h"
      28                 :             : #include "insn-config.h"
      29                 :             : #include "regs.h"
      30                 :             : #include "emit-rtl.h"
      31                 :             : #include "recog.h"
      32                 :             : #include "diagnostic-core.h"
      33                 :             : #include "addresses.h"
      34                 :             : #include "tree-pass.h"
      35                 :             : #include "rtl-iter.h"
      36                 :             : #include "cfgrtl.h"
      37                 :             : #include "target.h"
      38                 :             : #include "function-abi.h"
      39                 :             : 
      40                 :             : /* The following code does forward propagation of hard register copies.
      41                 :             :    The object is to eliminate as many dependencies as possible, so that
      42                 :             :    we have the most scheduling freedom.  As a side effect, we also clean
      43                 :             :    up some silly register allocation decisions made by reload.  This
      44                 :             :    code may be obsoleted by a new register allocator.  */
      45                 :             : 
      46                 :             : /* DEBUG_INSNs aren't changed right away, as doing so might extend the
      47                 :             :    lifetime of a register and get the DEBUG_INSN subsequently reset.
      48                 :             :    So they are queued instead, and updated only when the register is
      49                 :             :    used in some subsequent real insn before it is set.  */
      50                 :             : struct queued_debug_insn_change
      51                 :             : {
      52                 :             :   struct queued_debug_insn_change *next;
      53                 :             :   rtx_insn *insn;
      54                 :             :   rtx *loc;
      55                 :             :   rtx new_rtx;
      56                 :             : };
      57                 :             : 
      58                 :             : /* For each register, we have a list of registers that contain the same
      59                 :             :    value.  The OLDEST_REGNO field points to the head of the list, and
      60                 :             :    the NEXT_REGNO field runs through the list.  The MODE field indicates
      61                 :             :    what mode the data is known to be in; this field is VOIDmode when the
      62                 :             :    register is not known to contain valid data.  */
      63                 :             : 
      64                 :             : struct value_data_entry
      65                 :             : {
      66                 :             :   machine_mode mode;
      67                 :             :   unsigned int oldest_regno;
      68                 :             :   unsigned int next_regno;
      69                 :             :   struct queued_debug_insn_change *debug_insn_changes;
      70                 :             : };
      71                 :             : 
      72                 :             : struct value_data
      73                 :             : {
      74                 :             :   struct value_data_entry e[FIRST_PSEUDO_REGISTER];
      75                 :             :   unsigned int max_value_regs;
      76                 :             :   unsigned int n_debug_insn_changes;
      77                 :             : };
      78                 :             : 
      79                 :             : static object_allocator<queued_debug_insn_change> queued_debug_insn_change_pool
      80                 :             :   ("debug insn changes pool");
      81                 :             : 
      82                 :             : static bool skip_debug_insn_p;
      83                 :             : 
      84                 :             : static void kill_value_one_regno (unsigned, struct value_data *);
      85                 :             : static void kill_value_regno (unsigned, unsigned, struct value_data *);
      86                 :             : static void kill_value (const_rtx, struct value_data *);
      87                 :             : static void set_value_regno (unsigned, machine_mode, struct value_data *);
      88                 :             : static void init_value_data (struct value_data *);
      89                 :             : static void kill_clobbered_value (rtx, const_rtx, void *);
      90                 :             : static void kill_set_value (rtx, const_rtx, void *);
      91                 :             : static void copy_value (rtx, rtx, struct value_data *);
      92                 :             : static bool mode_change_ok (machine_mode, machine_mode,
      93                 :             :                             unsigned int);
      94                 :             : static rtx maybe_mode_change (machine_mode, machine_mode,
      95                 :             :                               machine_mode, unsigned int, unsigned int);
      96                 :             : static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
      97                 :             : static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx_insn *,
      98                 :             :                                       struct value_data *);
      99                 :             : static bool replace_oldest_value_addr (rtx *, enum reg_class,
     100                 :             :                                        machine_mode, addr_space_t,
     101                 :             :                                        rtx_insn *, struct value_data *);
     102                 :             : static bool replace_oldest_value_mem (rtx, rtx_insn *, struct value_data *);
     103                 :             : static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
     104                 :             : extern void debug_value_data (struct value_data *);
     105                 :             : static void validate_value_data (struct value_data *);
     106                 :             : 
     107                 :             : /* Free all queued updates for DEBUG_INSNs that change some reg to
     108                 :             :    register REGNO.  */
     109                 :             : 
     110                 :             : static void
     111                 :      278392 : free_debug_insn_changes (struct value_data *vd, unsigned int regno)
     112                 :             : {
     113                 :      278392 :   struct queued_debug_insn_change *cur, *next;
     114                 :      688318 :   for (cur = vd->e[regno].debug_insn_changes; cur; cur = next)
     115                 :             :     {
     116                 :      409926 :       next = cur->next;
     117                 :      409926 :       --vd->n_debug_insn_changes;
     118                 :      409926 :       queued_debug_insn_change_pool.remove (cur);
     119                 :             :     }
     120                 :      278392 :   vd->e[regno].debug_insn_changes = NULL;
     121                 :      278392 : }
     122                 :             : 
     123                 :             : /* Kill register REGNO.  This involves removing it from any value
     124                 :             :    lists, and resetting the value mode to VOIDmode.  This is only a
     125                 :             :    helper function; it does not handle any hard registers overlapping
     126                 :             :    with REGNO.  */
     127                 :             : 
     128                 :             : static void
     129                 :    81485905 : kill_value_one_regno (unsigned int regno, struct value_data *vd)
     130                 :             : {
     131                 :    81485905 :   unsigned int i, next;
     132                 :             : 
     133                 :    81485905 :   if (vd->e[regno].oldest_regno != regno)
     134                 :             :     {
     135                 :      158559 :       for (i = vd->e[regno].oldest_regno;
     136                 :     3654582 :            vd->e[i].next_regno != regno;
     137                 :      158559 :            i = vd->e[i].next_regno)
     138                 :      158559 :         continue;
     139                 :     3496023 :       vd->e[i].next_regno = vd->e[regno].next_regno;
     140                 :             :     }
     141                 :    77989882 :   else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
     142                 :             :     {
     143                 :     4620698 :       for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
     144                 :     2372684 :         vd->e[i].oldest_regno = next;
     145                 :             :     }
     146                 :             : 
     147                 :    81485905 :   vd->e[regno].mode = VOIDmode;
     148                 :    81485905 :   vd->e[regno].oldest_regno = regno;
     149                 :    81485905 :   vd->e[regno].next_regno = INVALID_REGNUM;
     150                 :    81485905 :   if (vd->e[regno].debug_insn_changes)
     151                 :      125260 :     free_debug_insn_changes (vd, regno);
     152                 :             : 
     153                 :    81485905 :   if (flag_checking)
     154                 :    81485554 :     validate_value_data (vd);
     155                 :    81485905 : }
     156                 :             : 
     157                 :             : /* Kill the value in register REGNO for NREGS, and any other registers
     158                 :             :    whose values overlap.  */
     159                 :             : 
     160                 :             : static void
     161                 :    81194711 : kill_value_regno (unsigned int regno, unsigned int nregs,
     162                 :             :                   struct value_data *vd)
     163                 :             : {
     164                 :    81194711 :   unsigned int j;
     165                 :             : 
     166                 :             :   /* Kill the value we're told to kill.  */
     167                 :   162597260 :   for (j = 0; j < nregs; ++j)
     168                 :    81402549 :     kill_value_one_regno (regno + j, vd);
     169                 :             : 
     170                 :             :   /* Kill everything that overlapped what we're told to kill.  */
     171                 :    81194711 :   if (regno < vd->max_value_regs)
     172                 :             :     j = 0;
     173                 :             :   else
     174                 :    69897778 :     j = regno - vd->max_value_regs;
     175                 :   147648207 :   for (; j < regno; ++j)
     176                 :             :     {
     177                 :    66453496 :       unsigned int i, n;
     178                 :    66453496 :       if (vd->e[j].mode == VOIDmode)
     179                 :    51095067 :         continue;
     180                 :    15358429 :       n = hard_regno_nregs (j, vd->e[j].mode);
     181                 :    15358429 :       if (j + n > regno)
     182                 :      125034 :         for (i = 0; i < n; ++i)
     183                 :       83356 :           kill_value_one_regno (j + i, vd);
     184                 :             :     }
     185                 :    81194711 : }
     186                 :             : 
     187                 :             : /* Kill X.  This is a convenience function wrapping kill_value_regno
     188                 :             :    so that we mind the mode the register is in.  */
     189                 :             : 
     190                 :             : static void
     191                 :    88878768 : kill_value (const_rtx x, struct value_data *vd)
     192                 :             : {
     193                 :    88878768 :   if (GET_CODE (x) == SUBREG)
     194                 :             :     {
     195                 :           6 :       rtx tmp = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
     196                 :           3 :                                  GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
     197                 :           3 :       x = tmp ? tmp : SUBREG_REG (x);
     198                 :             :     }
     199                 :    88878768 :   if (REG_P (x))
     200                 :    67097344 :     kill_value_regno (REGNO (x), REG_NREGS (x), vd);
     201                 :    88878768 : }
     202                 :             : 
     203                 :             : /* Remember that REGNO is valid in MODE.  */
     204                 :             : 
     205                 :             : static void
     206                 :    52179156 : set_value_regno (unsigned int regno, machine_mode mode,
     207                 :             :                  struct value_data *vd)
     208                 :             : {
     209                 :    52179156 :   unsigned int nregs;
     210                 :             : 
     211                 :    52179156 :   vd->e[regno].mode = mode;
     212                 :             : 
     213                 :    49547136 :   nregs = hard_regno_nregs (regno, mode);
     214                 :    52179156 :   if (nregs > vd->max_value_regs)
     215                 :     4505551 :     vd->max_value_regs = nregs;
     216                 :           0 : }
     217                 :             : 
     218                 :             : /* Initialize VD such that there are no known relationships between regs.  */
     219                 :             : 
     220                 :             : static void
     221                 :     4653892 : init_value_data (struct value_data *vd)
     222                 :             : {
     223                 :     4653892 :   int i;
     224                 :   432811956 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
     225                 :             :     {
     226                 :   428158064 :       vd->e[i].mode = VOIDmode;
     227                 :   428158064 :       vd->e[i].oldest_regno = i;
     228                 :   428158064 :       vd->e[i].next_regno = INVALID_REGNUM;
     229                 :   428158064 :       vd->e[i].debug_insn_changes = NULL;
     230                 :             :     }
     231                 :     4653892 :   vd->max_value_regs = 0;
     232                 :     4653892 :   vd->n_debug_insn_changes = 0;
     233                 :     4653892 : }
     234                 :             : 
     235                 :             : /* Called through note_stores.  If X is clobbered, kill its value.  */
     236                 :             : 
     237                 :             : static void
     238                 :    75049085 : kill_clobbered_value (rtx x, const_rtx set, void *data)
     239                 :             : {
     240                 :    75049085 :   struct value_data *const vd = (struct value_data *) data;
     241                 :             : 
     242                 :    75049085 :   if (GET_CODE (set) == CLOBBER)
     243                 :     9885370 :     kill_value (x, vd);
     244                 :    75049085 : }
     245                 :             : 
     246                 :             : /* A structure passed as data to kill_set_value through note_stores.  */
     247                 :             : struct kill_set_value_data
     248                 :             : {
     249                 :             :   struct value_data *vd;
     250                 :             :   rtx ignore_set_reg;
     251                 :             : };
     252                 :             :   
     253                 :             : /* Called through note_stores.  If X is set, not clobbered, kill its
     254                 :             :    current value and install it as the root of its own value list.  */
     255                 :             : 
     256                 :             : static void
     257                 :    74942382 : kill_set_value (rtx x, const_rtx set, void *data)
     258                 :             : {
     259                 :    74942382 :   struct kill_set_value_data *ksvd = (struct kill_set_value_data *) data;
     260                 :    74942382 :   if (rtx_equal_p (x, ksvd->ignore_set_reg))
     261                 :             :     return;
     262                 :             : 
     263                 :    74882008 :   if (GET_CODE (set) != CLOBBER)
     264                 :             :     {
     265                 :    64996638 :       kill_value (x, ksvd->vd);
     266                 :    64996638 :       if (REG_P (x))
     267                 :    44399223 :         set_value_regno (REGNO (x), GET_MODE (x), ksvd->vd);
     268                 :             :     }
     269                 :             : }
     270                 :             : 
     271                 :             : /* Kill any register used in X as the base of an auto-increment expression,
     272                 :             :    and install that register as the root of its own value list.  */
     273                 :             : 
     274                 :             : static void
     275                 :    69470218 : kill_autoinc_value (rtx_insn *insn, struct value_data *vd)
     276                 :             : {
     277                 :    69470218 :   subrtx_iterator::array_type array;
     278                 :   444745243 :   FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
     279                 :             :     {
     280                 :   375275025 :       const_rtx x = *iter;
     281                 :   375275025 :       if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
     282                 :             :         {
     283                 :     5087539 :           x = XEXP (x, 0);
     284                 :     5087539 :           kill_value (x, vd);
     285                 :     5087539 :           set_value_regno (REGNO (x), GET_MODE (x), vd);
     286                 :     5087539 :           iter.skip_subrtxes ();
     287                 :             :         }
     288                 :             :     }
     289                 :    69470218 : }
     290                 :             : 
     291                 :             : /* Assert that SRC has been copied to DEST.  Adjust the data structures
     292                 :             :    to reflect that SRC contains an older copy of the shared value.  */
     293                 :             : 
     294                 :             : static void
     295                 :     6754751 : copy_value (rtx dest, rtx src, struct value_data *vd)
     296                 :             : {
     297                 :     6754751 :   unsigned int dr = REGNO (dest);
     298                 :     6754751 :   unsigned int sr = REGNO (src);
     299                 :     6754751 :   unsigned int dn, sn;
     300                 :     6754751 :   unsigned int i;
     301                 :             : 
     302                 :             :   /* ??? At present, it's possible to see noop sets.  It'd be nice if
     303                 :             :      this were cleaned up beforehand...  */
     304                 :     6754751 :   if (sr == dr)
     305                 :             :     return;
     306                 :             : 
     307                 :             :   /* Do not propagate copies to the stack pointer, as that can leave
     308                 :             :      memory accesses with no scheduling dependency on the stack update.  */
     309                 :     6754751 :   if (dr == STACK_POINTER_REGNUM)
     310                 :             :     return;
     311                 :             : 
     312                 :             :   /* Likewise with the frame pointer, if we're using one.  */
     313                 :     6748719 :   if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
     314                 :             :     return;
     315                 :             : 
     316                 :             :   /* Do not propagate copies to fixed or global registers, patterns
     317                 :             :      can be relying to see particular fixed register or users can
     318                 :             :      expect the chosen global register in asm.  */
     319                 :     6701031 :   if (fixed_regs[dr] || global_regs[dr])
     320                 :             :     return;
     321                 :             : 
     322                 :             :   /* If SRC and DEST overlap, don't record anything.  */
     323                 :     6701014 :   dn = REG_NREGS (dest);
     324                 :     6701014 :   sn = REG_NREGS (src);
     325                 :     6701014 :   if ((dr > sr && dr < sr + sn)
     326                 :     6701014 :       || (sr > dr && sr < dr + dn))
     327                 :             :     return;
     328                 :             : 
     329                 :             :   /* If SRC had no assigned mode (i.e. we didn't know it was live)
     330                 :             :      assign it now and assume the value came from an input argument
     331                 :             :      or somesuch.  */
     332                 :     6701014 :   if (vd->e[sr].mode == VOIDmode)
     333                 :     2613073 :     set_value_regno (sr, vd->e[dr].mode, vd);
     334                 :             : 
     335                 :             :   /* If we are narrowing the input to a smaller number of hard regs,
     336                 :             :      and it is in big endian, we are really extracting a high part.
     337                 :             :      Since we generally associate a low part of a value with the value itself,
     338                 :             :      we must not do the same for the high part.
     339                 :             :      Note we can still get low parts for the same mode combination through
     340                 :             :      a two-step copy involving differently sized hard regs.
     341                 :             :      Assume hard regs fr* are 32 bits each, while r* are 64 bits each:
     342                 :             :      (set (reg:DI r0) (reg:DI fr0))
     343                 :             :      (set (reg:SI fr2) (reg:SI r0))
     344                 :             :      loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
     345                 :             :      (set (reg:SI fr2) (reg:SI fr0))
     346                 :             :      loads the high part of (reg:DI fr0) into fr2.
     347                 :             : 
     348                 :             :      We can't properly represent the latter case in our tables, so don't
     349                 :             :      record anything then.  */
     350                 :     4087941 :   else if (sn < hard_regno_nregs (sr, vd->e[sr].mode)
     351                 :     4087941 :            && maybe_ne (subreg_lowpart_offset (GET_MODE (dest),
     352                 :             :                                                vd->e[sr].mode), 0U))
     353                 :           0 :     return;
     354                 :             : 
     355                 :             :   /* If SRC had been assigned a mode narrower than the copy, we can't
     356                 :             :      link DEST into the chain, because not all of the pieces of the
     357                 :             :      copy came from oldest_regno.  */
     358                 :     4087941 :   else if (sn > hard_regno_nregs (sr, vd->e[sr].mode))
     359                 :             :     return;
     360                 :             : 
     361                 :             :   /* If a narrower value is copied using wider mode, the upper bits
     362                 :             :      are undefined (could be e.g. a former paradoxical subreg).  Signal
     363                 :             :      in that case we've only copied value using the narrower mode.
     364                 :             :      Consider:
     365                 :             :      (set (reg:DI r14) (mem:DI ...))
     366                 :             :      (set (reg:QI si) (reg:QI r14))
     367                 :             :      (set (reg:DI bp) (reg:DI r14))
     368                 :             :      (set (reg:DI r14) (const_int ...))
     369                 :             :      (set (reg:DI dx) (reg:DI si))
     370                 :             :      (set (reg:DI si) (const_int ...))
     371                 :             :      (set (reg:DI dx) (reg:DI bp))
     372                 :             :      The last set is not redundant, while the low 8 bits of dx are already
     373                 :             :      equal to low 8 bits of bp, the other bits are undefined.  */
     374                 :     4087941 :   else if (partial_subreg_p (vd->e[sr].mode, GET_MODE (src)))
     375                 :             :     {
     376                 :       19018 :       if (!REG_CAN_CHANGE_MODE_P (sr, GET_MODE (src), vd->e[sr].mode)
     377                 :       19018 :           || !REG_CAN_CHANGE_MODE_P (dr, vd->e[sr].mode, GET_MODE (dest)))
     378                 :          71 :         return;
     379                 :       18947 :       set_value_regno (dr, vd->e[sr].mode, vd);
     380                 :             :     }
     381                 :             : 
     382                 :             :   /* Link DR at the end of the value chain used by SR.  */
     383                 :             : 
     384                 :     6700943 :   vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
     385                 :             : 
     386                 :     7083700 :   for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
     387                 :      382757 :     continue;
     388                 :     6700943 :   vd->e[i].next_regno = dr;
     389                 :             : 
     390                 :     6700943 :   if (flag_checking)
     391                 :     6700906 :     validate_value_data (vd);
     392                 :      382757 : }
     393                 :             : 
     394                 :             : /* Return true if a mode change from ORIG to NEW is allowed for REGNO.  */
     395                 :             : 
     396                 :             : static bool
     397                 :      472266 : mode_change_ok (machine_mode orig_mode, machine_mode new_mode,
     398                 :             :                 unsigned int regno ATTRIBUTE_UNUSED)
     399                 :             : {
     400                 :      472266 :   if (partial_subreg_p (orig_mode, new_mode))
     401                 :             :     return false;
     402                 :             : 
     403                 :      461100 :   return REG_CAN_CHANGE_MODE_P (regno, orig_mode, new_mode);
     404                 :             : }
     405                 :             : 
     406                 :             : /* Register REGNO was originally set in ORIG_MODE.  It - or a copy of it -
     407                 :             :    was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
     408                 :             :    in NEW_MODE.
     409                 :             :    Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX.  */
     410                 :             : 
     411                 :             : static rtx
     412                 :     1875420 : maybe_mode_change (machine_mode orig_mode, machine_mode copy_mode,
     413                 :             :                    machine_mode new_mode, unsigned int regno,
     414                 :             :                    unsigned int copy_regno ATTRIBUTE_UNUSED)
     415                 :             : {
     416                 :     1875420 :   if (partial_subreg_p (copy_mode, orig_mode)
     417                 :     1875420 :       && partial_subreg_p (copy_mode, new_mode))
     418                 :             :     return NULL_RTX;
     419                 :             : 
     420                 :             :   /* Avoid creating multiple copies of the stack pointer.  Some ports
     421                 :             :      assume there is one and only one stack pointer.
     422                 :             : 
     423                 :             :      It's unclear if we need to do the same for other special registers.  */
     424                 :     1874051 :   if (regno == STACK_POINTER_REGNUM)
     425                 :             :     {
     426                 :       69739 :       if (orig_mode == new_mode && new_mode == GET_MODE (stack_pointer_rtx))
     427                 :             :         return stack_pointer_rtx;
     428                 :             :       else
     429                 :             :         return NULL_RTX;
     430                 :             :     }
     431                 :             : 
     432                 :     1804312 :   if (orig_mode == new_mode)
     433                 :     1559162 :     return gen_raw_REG (new_mode, regno);
     434                 :      245150 :   else if (mode_change_ok (orig_mode, new_mode, regno)
     435                 :      245150 :            && mode_change_ok (copy_mode, new_mode, copy_regno))
     436                 :             :     {
     437                 :      227116 :       int copy_nregs = hard_regno_nregs (copy_regno, copy_mode);
     438                 :      227116 :       int use_nregs = hard_regno_nregs (copy_regno, new_mode);
     439                 :      227116 :       poly_uint64 bytes_per_reg;
     440                 :      454232 :       if (!can_div_trunc_p (GET_MODE_SIZE (copy_mode),
     441                 :             :                             copy_nregs, &bytes_per_reg))
     442                 :      227003 :         return NULL_RTX;
     443                 :      227116 :       poly_uint64 copy_offset = bytes_per_reg * (copy_nregs - use_nregs);
     444                 :      227116 :       poly_uint64 offset
     445                 :      454232 :         = subreg_size_lowpart_offset (GET_MODE_SIZE (new_mode) + copy_offset,
     446                 :      227116 :                                       GET_MODE_SIZE (orig_mode));
     447                 :      227116 :       regno += subreg_regno_offset (regno, orig_mode, offset, new_mode);
     448                 :      227116 :       if (targetm.hard_regno_mode_ok (regno, new_mode))
     449                 :      227003 :         return gen_raw_REG (new_mode, regno);
     450                 :             :     }
     451                 :             :   return NULL_RTX;
     452                 :             : }
     453                 :             : 
     454                 :             : /* Find the oldest copy of the value contained in REGNO that is in
     455                 :             :    register class CL and has mode MODE.  If found, return an rtx
     456                 :             :    of that oldest register, otherwise return NULL.  */
     457                 :             : 
     458                 :             : static rtx
     459                 :    76221151 : find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
     460                 :             : {
     461                 :    76221151 :   unsigned int regno = REGNO (reg);
     462                 :    76221151 :   machine_mode mode = GET_MODE (reg);
     463                 :    76221151 :   unsigned int i;
     464                 :             : 
     465                 :    76221151 :   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
     466                 :             : 
     467                 :             :   /* If we are accessing REG in some mode other that what we set it in,
     468                 :             :      make sure that the replacement is valid.  In particular, consider
     469                 :             :         (set (reg:DI r11) (...))
     470                 :             :         (set (reg:SI r9) (reg:SI r11))
     471                 :             :         (set (reg:SI r10) (...))
     472                 :             :         (set (...) (reg:DI r9))
     473                 :             :      Replacing r9 with r11 is invalid.  */
     474                 :    76221151 :   if (mode != vd->e[regno].mode
     475                 :    76221151 :       && (REG_NREGS (reg) > hard_regno_nregs (regno, vd->e[regno].mode)
     476                 :     4408739 :           || !REG_CAN_CHANGE_MODE_P (regno, mode, vd->e[regno].mode)))
     477                 :    32045756 :     return NULL_RTX;
     478                 :             : 
     479                 :    44908841 :   for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
     480                 :             :     {
     481                 :     2217892 :       machine_mode oldmode = vd->e[i].mode;
     482                 :     2217892 :       rtx new_rtx;
     483                 :             : 
     484                 :     2217892 :       if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i))
     485                 :      717673 :         continue;
     486                 :             : 
     487                 :     1500219 :       new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
     488                 :     1500219 :       if (new_rtx)
     489                 :             :         {
     490                 :             :           /* NEW_RTX may be the global stack pointer rtx, in which case we
     491                 :             :              must not modify it's attributes.  */
     492                 :     1484446 :           if (new_rtx != stack_pointer_rtx)
     493                 :             :             {
     494                 :     1449222 :               ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg);
     495                 :     1449222 :               REG_ATTRS (new_rtx) = REG_ATTRS (reg);
     496                 :     1449222 :               REG_POINTER (new_rtx) = REG_POINTER (reg);
     497                 :             :             }
     498                 :     1484446 :           return new_rtx;
     499                 :             :         }
     500                 :             :     }
     501                 :             : 
     502                 :             :   return NULL_RTX;
     503                 :             : }
     504                 :             : 
     505                 :             : /* If possible, replace the register at *LOC with the oldest register
     506                 :             :    in register class CL.  Return true if successfully replaced.  */
     507                 :             : 
     508                 :             : static bool
     509                 :    57822471 : replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx_insn *insn,
     510                 :             :                           struct value_data *vd)
     511                 :             : {
     512                 :    57822471 :   rtx new_rtx = find_oldest_value_reg (cl, *loc, vd);
     513                 :    57822471 :   if (new_rtx && (!DEBUG_INSN_P (insn) || !skip_debug_insn_p))
     514                 :             :     {
     515                 :     1129656 :       if (DEBUG_INSN_P (insn))
     516                 :             :         {
     517                 :      514840 :           struct queued_debug_insn_change *change;
     518                 :             : 
     519                 :      514840 :           if (dump_file)
     520                 :           2 :             fprintf (dump_file, "debug_insn %u: queued replacing reg %u with %u\n",
     521                 :           2 :                      INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
     522                 :             : 
     523                 :      514840 :           change = queued_debug_insn_change_pool.allocate ();
     524                 :      514840 :           change->next = vd->e[REGNO (new_rtx)].debug_insn_changes;
     525                 :      514840 :           change->insn = insn;
     526                 :      514840 :           change->loc = loc;
     527                 :      514840 :           change->new_rtx = new_rtx;
     528                 :      514840 :           vd->e[REGNO (new_rtx)].debug_insn_changes = change;
     529                 :      514840 :           ++vd->n_debug_insn_changes;
     530                 :      514840 :           return true;
     531                 :             :         }
     532                 :      614816 :       if (dump_file)
     533                 :          30 :         fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
     534                 :          30 :                  INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
     535                 :             : 
     536                 :      614816 :       validate_change (insn, loc, new_rtx, 1);
     537                 :      614816 :       return true;
     538                 :             :     }
     539                 :             :   return false;
     540                 :             : }
     541                 :             : 
     542                 :             : /* Similar to replace_oldest_value_reg, but *LOC contains an address.
     543                 :             :    Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
     544                 :             :    BASE_REG_CLASS depending on how the register is being considered.  */
     545                 :             : 
     546                 :             : static bool
     547                 :    83295501 : replace_oldest_value_addr (rtx *loc, enum reg_class cl,
     548                 :             :                            machine_mode mode, addr_space_t as,
     549                 :             :                            rtx_insn *insn, struct value_data *vd)
     550                 :             : {
     551                 :    83295501 :   rtx x = *loc;
     552                 :    83295501 :   RTX_CODE code = GET_CODE (x);
     553                 :    83295501 :   const char *fmt;
     554                 :    83295501 :   int i, j;
     555                 :    83295501 :   bool changed = false;
     556                 :             : 
     557                 :    83295501 :   switch (code)
     558                 :             :     {
     559                 :    23913106 :     case PLUS:
     560                 :    23913106 :       if (DEBUG_INSN_P (insn))
     561                 :             :         break;
     562                 :             : 
     563                 :    19347385 :       {
     564                 :    19347385 :         rtx orig_op0 = XEXP (x, 0);
     565                 :    19347385 :         rtx orig_op1 = XEXP (x, 1);
     566                 :    19347385 :         RTX_CODE code0 = GET_CODE (orig_op0);
     567                 :    19347385 :         RTX_CODE code1 = GET_CODE (orig_op1);
     568                 :    19347385 :         rtx op0 = orig_op0;
     569                 :    19347385 :         rtx op1 = orig_op1;
     570                 :    19347385 :         rtx *locI = NULL;
     571                 :    19347385 :         rtx *locB = NULL;
     572                 :    19347385 :         enum rtx_code index_code = SCRATCH;
     573                 :             : 
     574                 :    19347385 :         if (GET_CODE (op0) == SUBREG)
     575                 :             :           {
     576                 :           0 :             op0 = SUBREG_REG (op0);
     577                 :           0 :             code0 = GET_CODE (op0);
     578                 :             :           }
     579                 :             : 
     580                 :    19347385 :         if (GET_CODE (op1) == SUBREG)
     581                 :             :           {
     582                 :           0 :             op1 = SUBREG_REG (op1);
     583                 :           0 :             code1 = GET_CODE (op1);
     584                 :             :           }
     585                 :             : 
     586                 :    19347385 :         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
     587                 :    18917107 :             || code0 == ZERO_EXTEND || code1 == MEM)
     588                 :             :           {
     589                 :      430278 :             locI = &XEXP (x, 0);
     590                 :      430278 :             locB = &XEXP (x, 1);
     591                 :      430278 :             index_code = GET_CODE (*locI);
     592                 :             :           }
     593                 :    18917107 :         else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
     594                 :    18916051 :                  || code1 == ZERO_EXTEND || code0 == MEM)
     595                 :             :           {
     596                 :        1056 :             locI = &XEXP (x, 1);
     597                 :        1056 :             locB = &XEXP (x, 0);
     598                 :        1056 :             index_code = GET_CODE (*locI);
     599                 :             :           }
     600                 :    18916051 :         else if (code0 == CONST_INT || code0 == CONST
     601                 :    18916051 :                  || code0 == SYMBOL_REF || code0 == LABEL_REF)
     602                 :             :           {
     603                 :      633744 :             locB = &XEXP (x, 1);
     604                 :      633744 :             index_code = GET_CODE (XEXP (x, 0));
     605                 :             :           }
     606                 :    18282307 :         else if (code1 == CONST_INT || code1 == CONST
     607                 :             :                  || code1 == SYMBOL_REF || code1 == LABEL_REF)
     608                 :             :           {
     609                 :    17429465 :             locB = &XEXP (x, 0);
     610                 :    17429465 :             index_code = GET_CODE (XEXP (x, 1));
     611                 :             :           }
     612                 :      852842 :         else if (code0 == REG && code1 == REG)
     613                 :             :           {
     614                 :      680348 :             int index_op;
     615                 :      680348 :             unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
     616                 :             : 
     617                 :         400 :             if (REGNO_OK_FOR_INDEX_P (regno1)
     618                 :      680350 :                 && regno_ok_for_base_p (regno0, mode, as, PLUS, REG))
     619                 :             :               index_op = 1;
     620                 :           0 :             else if (REGNO_OK_FOR_INDEX_P (regno0)
     621                 :         398 :                      && regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
     622                 :             :               index_op = 0;
     623                 :           0 :             else if (regno_ok_for_base_p (regno0, mode, as, PLUS, REG)
     624                 :           0 :                      || REGNO_OK_FOR_INDEX_P (regno1))
     625                 :             :               index_op = 1;
     626                 :           0 :             else if (regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
     627                 :             :               index_op = 0;
     628                 :             :             else
     629                 :      679950 :               index_op = 1;
     630                 :             : 
     631                 :      680348 :             locI = &XEXP (x, index_op);
     632                 :      680348 :             locB = &XEXP (x, !index_op);
     633                 :      680348 :             index_code = GET_CODE (*locI);
     634                 :             :           }
     635                 :      172494 :         else if (code0 == REG)
     636                 :             :           {
     637                 :           0 :             locI = &XEXP (x, 0);
     638                 :           0 :             locB = &XEXP (x, 1);
     639                 :           0 :             index_code = GET_CODE (*locI);
     640                 :             :           }
     641                 :      172494 :         else if (code1 == REG)
     642                 :             :           {
     643                 :      172494 :             locI = &XEXP (x, 1);
     644                 :      172494 :             locB = &XEXP (x, 0);
     645                 :      172494 :             index_code = GET_CODE (*locI);
     646                 :             :           }
     647                 :             : 
     648                 :    19347385 :         if (locI)
     649                 :     1284176 :           changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS,
     650                 :             :                                                 mode, as, insn, vd);
     651                 :    19347385 :         if (locB)
     652                 :    19347385 :           changed |= replace_oldest_value_addr (locB,
     653                 :             :                                                 base_reg_class (mode, as, PLUS,
     654                 :             :                                                                 index_code),
     655                 :             :                                                 mode, as, insn, vd);
     656                 :             :         return changed;
     657                 :             :       }
     658                 :             : 
     659                 :             :     case POST_INC:
     660                 :             :     case POST_DEC:
     661                 :             :     case POST_MODIFY:
     662                 :             :     case PRE_INC:
     663                 :             :     case PRE_DEC:
     664                 :             :     case PRE_MODIFY:
     665                 :             :       return false;
     666                 :             : 
     667                 :     1622624 :     case MEM:
     668                 :     1622624 :       return replace_oldest_value_mem (x, insn, vd);
     669                 :             : 
     670                 :    31678069 :     case REG:
     671                 :    31678069 :       return replace_oldest_value_reg (loc, cl, insn, vd);
     672                 :             : 
     673                 :             :     default:
     674                 :             :       break;
     675                 :             :     }
     676                 :             : 
     677                 :    25590459 :   fmt = GET_RTX_FORMAT (code);
     678                 :    60289631 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     679                 :             :     {
     680                 :    34699172 :       if (fmt[i] == 'e')
     681                 :    13068778 :         changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode, as,
     682                 :             :                                               insn, vd);
     683                 :    21630394 :       else if (fmt[i] == 'E')
     684                 :      322189 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
     685                 :      184099 :           changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
     686                 :             :                                                 mode, as, insn, vd);
     687                 :             :     }
     688                 :             : 
     689                 :             :   return changed;
     690                 :             : }
     691                 :             : 
     692                 :             : /* Similar to replace_oldest_value_reg, but X contains a memory.  */
     693                 :             : 
     694                 :             : static bool
     695                 :    28451968 : replace_oldest_value_mem (rtx x, rtx_insn *insn, struct value_data *vd)
     696                 :             : {
     697                 :    28451968 :   enum reg_class cl;
     698                 :             : 
     699                 :    28451968 :   if (DEBUG_INSN_P (insn))
     700                 :             :     cl = ALL_REGS;
     701                 :             :   else
     702                 :    26829344 :     cl = base_reg_class (GET_MODE (x), MEM_ADDR_SPACE (x), MEM, SCRATCH);
     703                 :             : 
     704                 :    28451968 :   return replace_oldest_value_addr (&XEXP (x, 0), cl,
     705                 :    28451968 :                                     GET_MODE (x), MEM_ADDR_SPACE (x),
     706                 :    28451968 :                                     insn, vd);
     707                 :             : }
     708                 :             : 
     709                 :             : /* Apply all queued updates for DEBUG_INSNs that change some reg to
     710                 :             :    register REGNO.  */
     711                 :             : 
     712                 :             : static void
     713                 :      173129 : apply_debug_insn_changes (struct value_data *vd, unsigned int regno)
     714                 :             : {
     715                 :      173129 :   struct queued_debug_insn_change *change;
     716                 :      173129 :   rtx_insn *last_insn = vd->e[regno].debug_insn_changes->insn;
     717                 :             : 
     718                 :      173129 :   for (change = vd->e[regno].debug_insn_changes;
     719                 :      442612 :        change;
     720                 :      269483 :        change = change->next)
     721                 :             :     {
     722                 :      269483 :       if (last_insn != change->insn)
     723                 :             :         {
     724                 :       92696 :           apply_change_group ();
     725                 :       92696 :           last_insn = change->insn;
     726                 :             :         }
     727                 :      269483 :       validate_change (change->insn, change->loc, change->new_rtx, 1);
     728                 :             :     }
     729                 :      173129 :   apply_change_group ();
     730                 :      173129 : }
     731                 :             : 
     732                 :             : /* Called via note_uses, for all used registers in a real insn
     733                 :             :    apply DEBUG_INSN changes that change registers to the used
     734                 :             :    registers.  */
     735                 :             : 
     736                 :             : static void
     737                 :      989057 : cprop_find_used_regs (rtx *loc, void *data)
     738                 :             : {
     739                 :      989057 :   struct value_data *const vd = (struct value_data *) data;
     740                 :      989057 :   subrtx_iterator::array_type array;
     741                 :     3572445 :   FOR_EACH_SUBRTX (iter, array, *loc, NONCONST)
     742                 :             :     {
     743                 :     2583388 :       const_rtx x = *iter;
     744                 :     2583388 :       if (REG_P (x))
     745                 :             :         {
     746                 :      875094 :           unsigned int regno = REGNO (x);
     747                 :      875094 :           if (vd->e[regno].debug_insn_changes)
     748                 :             :             {
     749                 :      153132 :               apply_debug_insn_changes (vd, regno);
     750                 :      153132 :               free_debug_insn_changes (vd, regno);
     751                 :             :             }
     752                 :             :         }
     753                 :             :     }
     754                 :      989057 : }
     755                 :             : 
     756                 :             : /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD.  */
     757                 :             : 
     758                 :             : static void
     759                 :    69530592 : kill_clobbered_values (rtx_insn *insn, struct value_data *vd)
     760                 :             : {
     761                 :           0 :   note_stores (insn, kill_clobbered_value, vd);
     762                 :       60374 : }
     763                 :             : 
     764                 :             : /* Perform the forward copy propagation on basic block BB.  */
     765                 :             : 
     766                 :             : static bool
     767                 :    11062857 : copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
     768                 :             : {
     769                 :    11062857 :   bool anything_changed = false;
     770                 :    11062857 :   rtx_insn *insn, *next;
     771                 :             : 
     772                 :    11062857 :   for (insn = BB_HEAD (bb); ; insn = next)
     773                 :             :     {
     774                 :   137119628 :       int n_ops, i, predicated;
     775                 :   137119628 :       bool is_asm, any_replacements;
     776                 :   137119628 :       rtx set;
     777                 :   137119628 :       rtx link;
     778                 :   137119628 :       bool changed = false;
     779                 :   137119628 :       struct kill_set_value_data ksvd;
     780                 :             : 
     781                 :   137119628 :       next = NEXT_INSN (insn);
     782                 :   137119628 :       if (!NONDEBUG_INSN_P (insn))
     783                 :             :         {
     784                 :    67306520 :           if (DEBUG_BIND_INSN_P (insn))
     785                 :             :             {
     786                 :    31198869 :               rtx loc = INSN_VAR_LOCATION_LOC (insn);
     787                 :    31198869 :               if (!VAR_LOC_UNKNOWN_P (loc))
     788                 :    18364803 :                 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn),
     789                 :    18364803 :                                            ALL_REGS, GET_MODE (loc),
     790                 :             :                                            ADDR_SPACE_GENERIC, insn, vd);
     791                 :             :             }
     792                 :             : 
     793                 :    67306520 :           if (insn == BB_END (bb))
     794                 :             :             break;
     795                 :             :           else
     796                 :    67108844 :             continue;
     797                 :             :         }
     798                 :             : 
     799                 :    69813108 :       set = single_set (insn);
     800                 :             : 
     801                 :             :       /* Detect noop sets and remove them before processing side effects.  */
     802                 :    69813108 :       if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
     803                 :             :         {
     804                 :     7082131 :           unsigned int regno = REGNO (SET_SRC (set));
     805                 :     7082131 :           rtx r1 = find_oldest_value_reg (REGNO_REG_CLASS (regno),
     806                 :             :                                           SET_DEST (set), vd);
     807                 :     7082131 :           rtx r2 = find_oldest_value_reg (REGNO_REG_CLASS (regno),
     808                 :             :                                           SET_SRC (set), vd);
     809                 :     7082131 :           if (rtx_equal_p (r1 ? r1 : SET_DEST (set), r2 ? r2 : SET_SRC (set)))
     810                 :             :             {
     811                 :       83993 :               bool last = insn == BB_END (bb);
     812                 :       83993 :               delete_insn (insn);
     813                 :       83993 :               if (last)
     814                 :             :                 break;
     815                 :       82586 :               continue;
     816                 :       82586 :             }
     817                 :             :         }
     818                 :             : 
     819                 :             :       /* Detect obviously dead sets (via REG_UNUSED notes) and remove them.  */
     820                 :             :       if (set
     821                 :    63974041 :           && !RTX_FRAME_RELATED_P (insn)
     822                 :    59998854 :           && NONJUMP_INSN_P (insn)
     823                 :    50752272 :           && !may_trap_p (set)
     824                 :    43955954 :           && find_reg_note (insn, REG_UNUSED, SET_DEST (set))
     825                 :      387868 :           && !side_effects_p (SET_SRC (set))
     826                 :      258897 :           && !side_effects_p (SET_DEST (set)))
     827                 :             :         {
     828                 :      258897 :           bool last = insn == BB_END (bb);
     829                 :      258897 :           delete_insn (insn);
     830                 :      258897 :           if (last)
     831                 :             :             break;
     832                 :      258863 :           continue;
     833                 :      258863 :         }
     834                 :             :          
     835                 :             : 
     836                 :    69470218 :       extract_constrain_insn (insn);
     837                 :    69470218 :       preprocess_constraints (insn);
     838                 :    69470218 :       const operand_alternative *op_alt = which_op_alt ();
     839                 :    69470218 :       n_ops = recog_data.n_operands;
     840                 :    69470218 :       is_asm = asm_noperands (PATTERN (insn)) >= 0;
     841                 :             : 
     842                 :             :       /* Simplify the code below by promoting OP_OUT to OP_INOUT
     843                 :             :          in predicated instructions.  */
     844                 :             : 
     845                 :    69470218 :       predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
     846                 :   214844471 :       for (i = 0; i < n_ops; ++i)
     847                 :             :         {
     848                 :   145374253 :           int matches = op_alt[i].matches;
     849                 :   145374253 :           if (matches >= 0 || op_alt[i].matched >= 0
     850                 :   128939472 :               || (predicated && recog_data.operand_type[i] == OP_OUT))
     851                 :    16434781 :             recog_data.operand_type[i] = OP_INOUT;
     852                 :             :         }
     853                 :             : 
     854                 :             :       /* Apply changes to earlier DEBUG_INSNs if possible.  */
     855                 :    69470218 :       if (vd->n_debug_insn_changes)
     856                 :      728322 :         note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
     857                 :             : 
     858                 :             :       /* For each earlyclobber operand, zap the value data.  */
     859                 :   214844471 :       for (i = 0; i < n_ops; i++)
     860                 :   145374253 :         if (op_alt[i].earlyclobber)
     861                 :       12226 :           kill_value (recog_data.operand[i], vd);
     862                 :             : 
     863                 :             :       /* Within asms, a clobber cannot overlap inputs or outputs.
     864                 :             :          I wouldn't think this were true for regular insns, but
     865                 :             :          scan_rtx treats them like that...  */
     866                 :    69470218 :       kill_clobbered_values (insn, vd);
     867                 :             : 
     868                 :             :       /* Kill all auto-incremented values.  */
     869                 :             :       /* ??? REG_INC is useless, since stack pushes aren't done that way.  */
     870                 :    69470218 :       kill_autoinc_value (insn, vd);
     871                 :             : 
     872                 :             :       /* Kill all early-clobbered operands.  */
     873                 :   284314689 :       for (i = 0; i < n_ops; i++)
     874                 :   145374253 :         if (op_alt[i].earlyclobber)
     875                 :       12226 :           kill_value (recog_data.operand[i], vd);
     876                 :             : 
     877                 :             :       /* If we have dead sets in the insn, then we need to note these as we
     878                 :             :          would clobbers.  */
     879                 :   135566500 :       for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
     880                 :             :         {
     881                 :    66096305 :           if (REG_NOTE_KIND (link) == REG_UNUSED)
     882                 :             :             {
     883                 :     8824395 :               kill_value (XEXP (link, 0), vd);
     884                 :             :               /* Furthermore, if the insn looked like a single-set,
     885                 :             :                  but the dead store kills the source value of that
     886                 :             :                  set, then we can no-longer use the plain move
     887                 :             :                  special case below.  */
     888                 :     8824395 :               if (set
     889                 :     8824395 :                   && reg_overlap_mentioned_p (XEXP (link, 0), SET_SRC (set)))
     890                 :             :                 set = NULL;
     891                 :             :             }
     892                 :             : 
     893                 :             :           /* We need to keep CFI info correct, and the same on all paths,
     894                 :             :              so we cannot normally replace the registers REG_CFA_REGISTER
     895                 :             :              refers to.  Bail.  */
     896                 :    66096305 :           if (REG_NOTE_KIND (link) == REG_CFA_REGISTER)
     897                 :          23 :             goto did_replacement;
     898                 :             :         }
     899                 :             : 
     900                 :             :       /* Special-case plain move instructions, since we may well
     901                 :             :          be able to do the move from a different register class.  */
     902                 :    69470195 :       if (set && REG_P (SET_SRC (set)))
     903                 :             :         {
     904                 :    16358384 :           rtx src = SET_SRC (set);
     905                 :    16358384 :           rtx dest = SET_DEST (set);
     906                 :    16358384 :           unsigned int regno = REGNO (src);
     907                 :    16358384 :           machine_mode mode = GET_MODE (src);
     908                 :    16358384 :           unsigned int i;
     909                 :    16358384 :           rtx new_rtx;
     910                 :             : 
     911                 :             :           /* If we are accessing SRC in some mode other that what we
     912                 :             :              set it in, make sure that the replacement is valid.  */
     913                 :    16358384 :           if (mode != vd->e[regno].mode)
     914                 :             :             {
     915                 :     6354930 :               if (REG_NREGS (src)
     916                 :     6354930 :                   > hard_regno_nregs (regno, vd->e[regno].mode))
     917                 :     5050701 :                 goto no_move_special_case;
     918                 :             : 
     919                 :             :               /* And likewise, if we are narrowing on big endian the transformation
     920                 :             :                  is also invalid.  */
     921                 :     1304229 :               if (REG_NREGS (src) < hard_regno_nregs (regno, vd->e[regno].mode)
     922                 :     1304229 :                   && maybe_ne (subreg_lowpart_offset (mode,
     923                 :             :                                                       vd->e[regno].mode), 0U))
     924                 :           0 :                 goto no_move_special_case;
     925                 :             :             }
     926                 :             : 
     927                 :             :           /* If the destination is also a register, try to find a source
     928                 :             :              register in the same class.  */
     929                 :    11307683 :           if (REG_P (dest))
     930                 :             :             {
     931                 :     4234418 :               new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno),
     932                 :             :                                                src, vd);
     933                 :             : 
     934                 :     4234418 :               if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
     935                 :             :                 {
     936                 :       97536 :                   if (dump_file)
     937                 :           1 :                     fprintf (dump_file,
     938                 :             :                              "insn %u: replaced reg %u with %u\n",
     939                 :           1 :                              INSN_UID (insn), regno, REGNO (new_rtx));
     940                 :       97536 :                   changed = true;
     941                 :       97536 :                   goto did_replacement;
     942                 :             :                 }
     943                 :             :               /* We need to re-extract as validate_change clobbers
     944                 :             :                  recog_data.  */
     945                 :     4136882 :               extract_constrain_insn (insn);
     946                 :     4136882 :               preprocess_constraints (insn);
     947                 :             :             }
     948                 :             : 
     949                 :             :           /* Otherwise, try all valid registers and see if its valid.  */
     950                 :    11235017 :           for (i = vd->e[regno].oldest_regno; i != regno;
     951                 :       24870 :                i = vd->e[i].next_regno)
     952                 :             :             {
     953                 :      375201 :               new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
     954                 :             :                                        mode, i, regno);
     955                 :      375201 :               if (new_rtx != NULL_RTX)
     956                 :             :                 {
     957                 :             :                   /* Don't propagate for a more expensive reg-reg move.  */
     958                 :      371346 :                   if (REG_P (dest))
     959                 :             :                     {
     960                 :      181628 :                       enum reg_class from = REGNO_REG_CLASS (regno);
     961                 :      181628 :                       enum reg_class to = REGNO_REG_CLASS (REGNO (dest));
     962                 :      181628 :                       enum reg_class new_from = REGNO_REG_CLASS (i);
     963                 :      181628 :                       unsigned int original_cost
     964                 :      181628 :                         = targetm.register_move_cost (mode, from, to);
     965                 :      181628 :                       unsigned int after_cost
     966                 :      181628 :                         = targetm.register_move_cost (mode, new_from, to);
     967                 :      181628 :                       if (after_cost > original_cost)
     968                 :       14223 :                         continue;
     969                 :             :                     }
     970                 :             : 
     971                 :      357123 :                   if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
     972                 :             :                     {
     973                 :             :                       /* NEW_RTX may be the global stack pointer rtx, in which
     974                 :             :                          case we must not modify it's attributes.  */
     975                 :      350331 :                       if (new_rtx != stack_pointer_rtx)
     976                 :             :                         {
     977                 :      315936 :                           ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
     978                 :      315936 :                           REG_ATTRS (new_rtx) = REG_ATTRS (src);
     979                 :      315936 :                           REG_POINTER (new_rtx) = REG_POINTER (src);
     980                 :             :                         }
     981                 :      350331 :                       if (dump_file)
     982                 :           4 :                         fprintf (dump_file,
     983                 :             :                                  "insn %u: replaced reg %u with %u\n",
     984                 :           4 :                                  INSN_UID (insn), regno, REGNO (new_rtx));
     985                 :      350331 :                       changed = true;
     986                 :      350331 :                       goto did_replacement;
     987                 :             :                     }
     988                 :             :                   /* We need to re-extract as validate_change clobbers
     989                 :             :                      recog_data.  */
     990                 :        6792 :                   extract_constrain_insn (insn);
     991                 :        6792 :                   preprocess_constraints (insn);
     992                 :             :                 }
     993                 :             :             }
     994                 :             :         }
     995                 :    53111811 :       no_move_special_case:
     996                 :             : 
     997                 :             :       any_replacements = false;
     998                 :             : 
     999                 :             :       /* For each input operand, replace a hard register with the
    1000                 :             :          eldest live copy that's in an appropriate register class.  */
    1001                 :   213500812 :       for (i = 0; i < n_ops; i++)
    1002                 :             :         {
    1003                 :   144478484 :           bool replaced = false;
    1004                 :             : 
    1005                 :             :           /* Don't scan match_operand here, since we've no reg class
    1006                 :             :              information to pass down.  Any operands that we could
    1007                 :             :              substitute in will be represented elsewhere.  */
    1008                 :   144478484 :           if (recog_data.constraints[i][0] == '\0')
    1009                 :    25567660 :             continue;
    1010                 :             : 
    1011                 :             :           /* Don't replace in asms intentionally referencing hard regs.  */
    1012                 :      172286 :           if (is_asm && REG_P (recog_data.operand[i])
    1013                 :   119065547 :               && (REGNO (recog_data.operand[i])
    1014                 :      154723 :                   == ORIGINAL_REGNO (recog_data.operand[i])))
    1015                 :        2003 :             continue;
    1016                 :             : 
    1017                 :   118908821 :           if (recog_data.operand_type[i] == OP_IN)
    1018                 :             :             {
    1019                 :    61205340 :               if (op_alt[i].is_address)
    1020                 :     2594292 :                 replaced
    1021                 :     2594292 :                   = replace_oldest_value_addr (recog_data.operand_loc[i],
    1022                 :             :                                                alternative_class (op_alt, i),
    1023                 :             :                                                VOIDmode, ADDR_SPACE_GENERIC,
    1024                 :             :                                                insn, vd);
    1025                 :    58611048 :               else if (REG_P (recog_data.operand[i]))
    1026                 :    26144402 :                 replaced
    1027                 :    26144402 :                   = replace_oldest_value_reg (recog_data.operand_loc[i],
    1028                 :             :                                               alternative_class (op_alt, i),
    1029                 :             :                                               insn, vd);
    1030                 :    32466646 :               else if (MEM_P (recog_data.operand[i]))
    1031                 :    13555410 :                 replaced = replace_oldest_value_mem (recog_data.operand[i],
    1032                 :             :                                                      insn, vd);
    1033                 :             :             }
    1034                 :    57703481 :           else if (MEM_P (recog_data.operand[i]))
    1035                 :    13273934 :             replaced = replace_oldest_value_mem (recog_data.operand[i],
    1036                 :             :                                                  insn, vd);
    1037                 :             : 
    1038                 :             :           /* If we performed any replacement, update match_dups.  */
    1039                 :    55568038 :           if (replaced)
    1040                 :             :             {
    1041                 :      613378 :               int j;
    1042                 :      613378 :               rtx new_rtx;
    1043                 :             : 
    1044                 :      613378 :               new_rtx = *recog_data.operand_loc[i];
    1045                 :      613378 :               recog_data.operand[i] = new_rtx;
    1046                 :      648592 :               for (j = 0; j < recog_data.n_dups; j++)
    1047                 :       35214 :                 if (recog_data.dup_num[j] == i)
    1048                 :       12277 :                   validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1);
    1049                 :             : 
    1050                 :             :               any_replacements = true;
    1051                 :             :             }
    1052                 :             :         }
    1053                 :             : 
    1054                 :    69022328 :       if (any_replacements)
    1055                 :             :         {
    1056                 :      608692 :           if (! apply_change_group ())
    1057                 :             :             {
    1058                 :         324 :               if (dump_file)
    1059                 :           0 :                 fprintf (dump_file,
    1060                 :             :                          "insn %u: reg replacements not verified\n",
    1061                 :           0 :                          INSN_UID (insn));
    1062                 :             :             }
    1063                 :             :           else
    1064                 :             :             changed = true;
    1065                 :             :         }
    1066                 :             : 
    1067                 :      447890 :     did_replacement:
    1068                 :      447890 :       if (changed)
    1069                 :             :         {
    1070                 :     1056235 :           anything_changed = true;
    1071                 :             : 
    1072                 :             :           /* If something changed, perhaps further changes to earlier
    1073                 :             :              DEBUG_INSNs can be applied.  */
    1074                 :     1056235 :           if (vd->n_debug_insn_changes)
    1075                 :      124987 :             note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
    1076                 :     1056235 :           df_insn_rescan (insn);
    1077                 :             :         }
    1078                 :             : 
    1079                 :    69470218 :       ksvd.vd = vd;
    1080                 :    69470218 :       ksvd.ignore_set_reg = NULL_RTX;
    1081                 :             : 
    1082                 :             :       /* Clobber call-clobbered registers.  */
    1083                 :    69470218 :       if (CALL_P (insn))
    1084                 :             :         {
    1085                 :     5284450 :           unsigned int set_regno = INVALID_REGNUM;
    1086                 :     5284450 :           unsigned int set_nregs = 0;
    1087                 :     5284450 :           unsigned int regno;
    1088                 :     5284450 :           rtx exp;
    1089                 :             : 
    1090                 :    14736350 :           for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1))
    1091                 :             :             {
    1092                 :     9512274 :               rtx x = XEXP (exp, 0);
    1093                 :     9512274 :               if (GET_CODE (x) == SET)
    1094                 :             :                 {
    1095                 :       60374 :                   rtx dest = SET_DEST (x);
    1096                 :       60374 :                   kill_value (dest, vd);
    1097                 :       60374 :                   set_value_regno (REGNO (dest), GET_MODE (dest), vd);
    1098                 :       60374 :                   copy_value (dest, SET_SRC (x), vd);
    1099                 :       60374 :                   ksvd.ignore_set_reg = dest;
    1100                 :       60374 :                   set_regno = REGNO (dest);
    1101                 :       60374 :                   set_nregs = REG_NREGS (dest);
    1102                 :       60374 :                   break;
    1103                 :             :                 }
    1104                 :             :             }
    1105                 :             : 
    1106                 :     5284450 :           function_abi callee_abi = insn_callee_abi (insn);
    1107                 :   496738300 :           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    1108                 :   486169400 :             if (vd->e[regno].mode != VOIDmode
    1109                 :    24820787 :                 && callee_abi.clobbers_reg_p (vd->e[regno].mode, regno)
    1110                 :   500327141 :                 && (regno < set_regno || regno >= set_regno + set_nregs))
    1111                 :    14097367 :               kill_value_regno (regno, 1, vd);
    1112                 :             : 
    1113                 :             :           /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
    1114                 :             :              of the SET isn't clobbered by CALLEE_ABI, but instead among
    1115                 :             :              CLOBBERs on the CALL_INSN, we could wrongly assume the
    1116                 :             :              value in it is still live.  */
    1117                 :     5284450 :           if (ksvd.ignore_set_reg)
    1118                 :       60374 :             kill_clobbered_values (insn, vd);
    1119                 :             :         }
    1120                 :             : 
    1121                 :   145681139 :       bool copy_p = (set
    1122                 :    63401958 :                      && REG_P (SET_DEST (set))
    1123                 :   112366500 :                      && REG_P (SET_SRC (set)));
    1124                 :     6740706 :       bool noop_p = (copy_p
    1125                 :     6740706 :                      && rtx_equal_p (SET_DEST (set), SET_SRC (set)));
    1126                 :             : 
    1127                 :             :       /* If a noop move is using narrower mode than we have recorded,
    1128                 :             :          we need to either remove the noop move, or kill_set_value.  */
    1129                 :       46329 :       if (noop_p
    1130                 :       46329 :           && partial_subreg_p (GET_MODE (SET_DEST (set)),
    1131                 :       46329 :                                vd->e[REGNO (SET_DEST (set))].mode))
    1132                 :             :         {
    1133                 :        6335 :           if (noop_move_p (insn))
    1134                 :             :             {
    1135                 :        6335 :               bool last = insn == BB_END (bb);
    1136                 :        6335 :               delete_insn (insn);
    1137                 :        6335 :               if (last)
    1138                 :             :                 break;
    1139                 :             :             }
    1140                 :             :           else
    1141                 :             :             noop_p = false;
    1142                 :             :         }
    1143                 :             : 
    1144                 :    69470215 :       if (!noop_p)
    1145                 :             :         {
    1146                 :             :           /* Notice stores.  */
    1147                 :    69423889 :           note_stores (insn, kill_set_value, &ksvd);
    1148                 :             : 
    1149                 :             :           /* Notice copies.  */
    1150                 :    69423889 :           if (copy_p)
    1151                 :             :             {
    1152                 :     6694377 :               df_insn_rescan (insn);
    1153                 :     6694377 :               copy_value (SET_DEST (set), SET_SRC (set), vd);
    1154                 :             :             }
    1155                 :             :         }
    1156                 :             : 
    1157                 :    69470215 :       if (insn == BB_END (bb))
    1158                 :             :         break;
    1159                 :             :     }
    1160                 :             : 
    1161                 :    11062857 :   return anything_changed;
    1162                 :             : }
    1163                 :             : 
    1164                 :             : /* Dump the value chain data to stderr.  */
    1165                 :             : 
    1166                 :             : DEBUG_FUNCTION void
    1167                 :           0 : debug_value_data (struct value_data *vd)
    1168                 :             : {
    1169                 :           0 :   HARD_REG_SET set;
    1170                 :           0 :   unsigned int i, j;
    1171                 :             : 
    1172                 :           0 :   CLEAR_HARD_REG_SET (set);
    1173                 :             : 
    1174                 :           0 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1175                 :           0 :     if (vd->e[i].oldest_regno == i)
    1176                 :             :       {
    1177                 :           0 :         if (vd->e[i].mode == VOIDmode)
    1178                 :             :           {
    1179                 :           0 :             if (vd->e[i].next_regno != INVALID_REGNUM)
    1180                 :           0 :               fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
    1181                 :             :                        i, vd->e[i].next_regno);
    1182                 :           0 :             continue;
    1183                 :             :           }
    1184                 :             : 
    1185                 :           0 :         SET_HARD_REG_BIT (set, i);
    1186                 :           0 :         fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
    1187                 :             : 
    1188                 :           0 :         for (j = vd->e[i].next_regno;
    1189                 :           0 :              j != INVALID_REGNUM;
    1190                 :           0 :              j = vd->e[j].next_regno)
    1191                 :             :           {
    1192                 :           0 :             if (TEST_HARD_REG_BIT (set, j))
    1193                 :             :               {
    1194                 :           0 :                 fprintf (stderr, "[%u] Loop in regno chain\n", j);
    1195                 :           0 :                 return;
    1196                 :             :               }
    1197                 :             : 
    1198                 :           0 :             if (vd->e[j].oldest_regno != i)
    1199                 :             :               {
    1200                 :           0 :                 fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
    1201                 :             :                          j, vd->e[j].oldest_regno);
    1202                 :           0 :                 return;
    1203                 :             :               }
    1204                 :           0 :             SET_HARD_REG_BIT (set, j);
    1205                 :           0 :             fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
    1206                 :             :           }
    1207                 :           0 :         fputc ('\n', stderr);
    1208                 :             :       }
    1209                 :             : 
    1210                 :           0 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1211                 :           0 :     if (! TEST_HARD_REG_BIT (set, i)
    1212                 :           0 :         && (vd->e[i].mode != VOIDmode
    1213                 :           0 :             || vd->e[i].oldest_regno != i
    1214                 :           0 :             || vd->e[i].next_regno != INVALID_REGNUM))
    1215                 :           0 :       fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
    1216                 :           0 :                i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
    1217                 :             :                vd->e[i].next_regno);
    1218                 :             : }
    1219                 :             : 
    1220                 :             : /* Do copyprop_hardreg_forward_1 for a single basic block BB.
    1221                 :             :    DEBUG_INSN is skipped since we do not want to involve DF related
    1222                 :             :    staff as how it is handled in function pass_cprop_hardreg::execute.
    1223                 :             : 
    1224                 :             :    NOTE: Currently it is only used for shrink-wrap.  Maybe extend it
    1225                 :             :    to handle DEBUG_INSN for other uses.  */
    1226                 :             : 
    1227                 :             : void
    1228                 :      339914 : copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb)
    1229                 :             : {
    1230                 :      339914 :   struct value_data *vd;
    1231                 :      339914 :   vd = XNEWVEC (struct value_data, 1);
    1232                 :      339914 :   init_value_data (vd);
    1233                 :             : 
    1234                 :      339914 :   skip_debug_insn_p = true;
    1235                 :      339914 :   copyprop_hardreg_forward_1 (bb, vd);
    1236                 :      339914 :   free (vd);
    1237                 :      339914 :   skip_debug_insn_p = false;
    1238                 :      339914 : }
    1239                 :             : 
    1240                 :             : static void
    1241                 :    88186460 : validate_value_data (struct value_data *vd)
    1242                 :             : {
    1243                 :    88186460 :   HARD_REG_SET set;
    1244                 :    88186460 :   unsigned int i, j;
    1245                 :             : 
    1246                 :    88186460 :   CLEAR_HARD_REG_SET (set);
    1247                 :             : 
    1248                 :  8201340780 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1249                 :  8113154320 :     if (vd->e[i].oldest_regno == i)
    1250                 :             :       {
    1251                 :  8081497470 :         if (vd->e[i].mode == VOIDmode)
    1252                 :             :           {
    1253                 :  7750643675 :             if (vd->e[i].next_regno != INVALID_REGNUM)
    1254                 :           0 :               internal_error ("%qs: [%u] bad %<next_regno%> for empty chain (%u)",
    1255                 :             :                               __func__, i, vd->e[i].next_regno);
    1256                 :  7750643675 :             continue;
    1257                 :             :           }
    1258                 :             : 
    1259                 :   330853795 :         SET_HARD_REG_BIT (set, i);
    1260                 :             : 
    1261                 :   330853795 :         for (j = vd->e[i].next_regno;
    1262                 :   362510645 :              j != INVALID_REGNUM;
    1263                 :    31656850 :              j = vd->e[j].next_regno)
    1264                 :             :           {
    1265                 :    31656850 :             if (TEST_HARD_REG_BIT (set, j))
    1266                 :           0 :               internal_error ("%qs: loop in %<next_regno%> chain (%u)",
    1267                 :             :                               __func__, j);
    1268                 :    31656850 :             if (vd->e[j].oldest_regno != i)
    1269                 :           0 :               internal_error ("%qs: [%u] bad %<oldest_regno%> (%u)",
    1270                 :             :                               __func__, j, vd->e[j].oldest_regno);
    1271                 :             : 
    1272                 :    31656850 :             SET_HARD_REG_BIT (set, j);
    1273                 :             :           }
    1274                 :             :       }
    1275                 :             : 
    1276                 :  8201340780 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1277                 :  8113154320 :     if (! TEST_HARD_REG_BIT (set, i)
    1278                 :  8113154320 :         && (vd->e[i].mode != VOIDmode
    1279                 :  7750643675 :             || vd->e[i].oldest_regno != i
    1280                 :  7750643675 :             || vd->e[i].next_regno != INVALID_REGNUM))
    1281                 :           0 :       internal_error ("%qs: [%u] non-empty register in chain (%s %u %i)",
    1282                 :             :                       __func__, i,
    1283                 :           0 :                       GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
    1284                 :             :                       vd->e[i].next_regno);
    1285                 :    88186460 : }
    1286                 :             : 
    1287                 :             : 
    1288                 :             : namespace {
    1289                 :             : 
    1290                 :             : const pass_data pass_data_cprop_hardreg =
    1291                 :             : {
    1292                 :             :   RTL_PASS, /* type */
    1293                 :             :   "cprop_hardreg", /* name */
    1294                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    1295                 :             :   TV_CPROP_REGISTERS, /* tv_id */
    1296                 :             :   0, /* properties_required */
    1297                 :             :   0, /* properties_provided */
    1298                 :             :   0, /* properties_destroyed */
    1299                 :             :   0, /* todo_flags_start */
    1300                 :             :   TODO_df_finish, /* todo_flags_finish */
    1301                 :             : };
    1302                 :             : 
    1303                 :             : class pass_cprop_hardreg : public rtl_opt_pass
    1304                 :             : {
    1305                 :             : public:
    1306                 :      285617 :   pass_cprop_hardreg (gcc::context *ctxt)
    1307                 :      571234 :     : rtl_opt_pass (pass_data_cprop_hardreg, ctxt)
    1308                 :             :   {}
    1309                 :             : 
    1310                 :             :   /* opt_pass methods: */
    1311                 :     1419745 :   bool gate (function *) final override
    1312                 :             :     {
    1313                 :     1419745 :       return (optimize > 0 && (flag_cprop_registers));
    1314                 :             :     }
    1315                 :             : 
    1316                 :             :   unsigned int execute (function *) final override;
    1317                 :             : 
    1318                 :             : }; // class pass_cprop_hardreg
    1319                 :             : 
    1320                 :             : static bool
    1321                 :    10722943 : cprop_hardreg_bb (basic_block bb, struct value_data *all_vd, sbitmap visited)
    1322                 :             : {
    1323                 :    10722943 :   bitmap_set_bit (visited, bb->index);
    1324                 :             : 
    1325                 :             :   /* If a block has a single predecessor, that we've already
    1326                 :             :      processed, begin with the value data that was live at
    1327                 :             :      the end of the predecessor block.  */
    1328                 :             :   /* ??? Ought to use more intelligent queuing of blocks.  */
    1329                 :    10722943 :   if (single_pred_p (bb)
    1330                 :     7983196 :       && bitmap_bit_p (visited, single_pred (bb)->index)
    1331                 :    17249381 :       && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
    1332                 :             :     {
    1333                 :     6408965 :       all_vd[bb->index] = all_vd[single_pred (bb)->index];
    1334                 :     6408965 :       if (all_vd[bb->index].n_debug_insn_changes)
    1335                 :             :         {
    1336                 :             :           unsigned int regno;
    1337                 :             : 
    1338                 :      513075 :           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    1339                 :             :             {
    1340                 :      513075 :               if (all_vd[bb->index].e[regno].debug_insn_changes)
    1341                 :             :                 {
    1342                 :             :                   struct queued_debug_insn_change *cur;
    1343                 :       89646 :                   for (cur = all_vd[bb->index].e[regno].debug_insn_changes;
    1344                 :      153187 :                        cur; cur = cur->next)
    1345                 :       89646 :                     --all_vd[bb->index].n_debug_insn_changes;
    1346                 :       63541 :                   all_vd[bb->index].e[regno].debug_insn_changes = NULL;
    1347                 :       63541 :                   if (all_vd[bb->index].n_debug_insn_changes == 0)
    1348                 :             :                     break;
    1349                 :             :                 }
    1350                 :             :             }
    1351                 :             :         }
    1352                 :             :     }
    1353                 :             :   else
    1354                 :     4313978 :     init_value_data (all_vd + bb->index);
    1355                 :             : 
    1356                 :    10722943 :   return copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
    1357                 :             : }
    1358                 :             : 
    1359                 :             : static void
    1360                 :       45434 : cprop_hardreg_debug (function *fun, struct value_data *all_vd)
    1361                 :             : {
    1362                 :       45434 :   basic_block bb;
    1363                 :             : 
    1364                 :     2745055 :   FOR_EACH_BB_FN (bb, fun)
    1365                 :     2699621 :     if (all_vd[bb->index].n_debug_insn_changes)
    1366                 :             :       {
    1367                 :       71360 :         unsigned int regno;
    1368                 :       71360 :         bitmap live;
    1369                 :             : 
    1370                 :       71360 :         live = df_get_live_out (bb);
    1371                 :      663503 :         for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    1372                 :      663503 :           if (all_vd[bb->index].e[regno].debug_insn_changes)
    1373                 :             :             {
    1374                 :       74706 :               if (REGNO_REG_SET_P (live, regno))
    1375                 :       19997 :                 apply_debug_insn_changes (all_vd + bb->index, regno);
    1376                 :             : 
    1377                 :       74706 :               struct queued_debug_insn_change *cur;
    1378                 :       74706 :               for (cur = all_vd[bb->index].e[regno].debug_insn_changes;
    1379                 :      179620 :                    cur; cur = cur->next)
    1380                 :      104914 :                 --all_vd[bb->index].n_debug_insn_changes;
    1381                 :       74706 :               all_vd[bb->index].e[regno].debug_insn_changes = NULL;
    1382                 :       74706 :               if (all_vd[bb->index].n_debug_insn_changes == 0)
    1383                 :             :                 break;
    1384                 :             :             }
    1385                 :             :       }
    1386                 :             : 
    1387                 :       45434 :   queued_debug_insn_change_pool.release ();
    1388                 :       45434 : }
    1389                 :             : 
    1390                 :             : unsigned int
    1391                 :      977859 : pass_cprop_hardreg::execute (function *fun)
    1392                 :             : {
    1393                 :      977859 :   struct value_data *all_vd;
    1394                 :      977859 :   basic_block bb;
    1395                 :             : 
    1396                 :      977859 :   all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (fun));
    1397                 :             : 
    1398                 :      977859 :   auto_sbitmap visited (last_basic_block_for_fn (fun));
    1399                 :      977859 :   bitmap_clear (visited);
    1400                 :             : 
    1401                 :      977859 :   auto_vec<int> worklist1, worklist2;
    1402                 :      977859 :   auto_vec<int> *curr = &worklist1;
    1403                 :      977859 :   auto_vec<int> *next = &worklist2;
    1404                 :      977859 :   bool any_debug_changes = false;
    1405                 :             : 
    1406                 :             :   /* We need accurate notes.  Earlier passes such as if-conversion may
    1407                 :             :      leave notes in an inconsistent state.  */
    1408                 :      977859 :   df_note_add_problem ();
    1409                 :      977859 :   df_analyze ();
    1410                 :             : 
    1411                 :             :   /* It is tempting to set DF_LR_RUN_DCE, but DCE may choose to delete
    1412                 :             :      an insn and this pass would not have visibility into the removal.
    1413                 :             :      This pass would then potentially use the source of that
    1414                 :             :      INSN for propagation purposes, generating invalid code.
    1415                 :             : 
    1416                 :             :      So we just ask for updated notes and handle trivial deletions
    1417                 :             :      within this pass where we can update this passes internal
    1418                 :             :      data structures appropriately.  */
    1419                 :      977859 :   df_set_flags (DF_DEFER_INSN_RESCAN);
    1420                 :             : 
    1421                 :    11131752 :   FOR_EACH_BB_FN (bb, fun)
    1422                 :             :     {
    1423                 :    10153893 :       if (cprop_hardreg_bb (bb, all_vd, visited))
    1424                 :      563160 :         curr->safe_push (bb->index);
    1425                 :    10153893 :       if (all_vd[bb->index].n_debug_insn_changes)
    1426                 :       60236 :         any_debug_changes = true;
    1427                 :             :     }
    1428                 :             : 
    1429                 :             :   /* We must call df_analyze here unconditionally to ensure that the
    1430                 :             :      REG_UNUSED and REG_DEAD notes are consistent with and without -g.  */
    1431                 :      977859 :   df_analyze ();
    1432                 :             : 
    1433                 :      977859 :   if (MAY_HAVE_DEBUG_BIND_INSNS && any_debug_changes)
    1434                 :       37165 :     cprop_hardreg_debug (fun, all_vd);
    1435                 :             : 
    1436                 :             :   /* Repeat pass up to PASSES times, but only processing basic blocks
    1437                 :             :      that have changed on the previous iteration.  CURR points to the
    1438                 :             :      current worklist, and each iteration populates the NEXT worklist,
    1439                 :             :      swapping pointers after each cycle.  */
    1440                 :             : 
    1441                 :      977859 :   unsigned int passes = optimize > 1 ? 3 : 2;
    1442                 :     1189439 :   for (unsigned int pass = 2; pass <= passes && !curr->is_empty (); pass++)
    1443                 :             :     {
    1444                 :      211580 :       any_debug_changes = false;
    1445                 :      211580 :       bitmap_clear (visited);
    1446                 :      211580 :       next->truncate (0);
    1447                 :      780630 :       for (int index : *curr)
    1448                 :             :         {
    1449                 :      569050 :           bb = BASIC_BLOCK_FOR_FN (fun, index);
    1450                 :      569050 :           if (cprop_hardreg_bb (bb, all_vd, visited))
    1451                 :        6368 :             next->safe_push (bb->index);
    1452                 :      569050 :           if (all_vd[bb->index].n_debug_insn_changes)
    1453                 :       11124 :             any_debug_changes = true;
    1454                 :             :         }
    1455                 :             : 
    1456                 :      211580 :       df_analyze ();
    1457                 :      211580 :       if (MAY_HAVE_DEBUG_BIND_INSNS && any_debug_changes)
    1458                 :        8269 :         cprop_hardreg_debug (fun, all_vd);
    1459                 :      211580 :       std::swap (curr, next);
    1460                 :             :     }
    1461                 :             : 
    1462                 :      977859 :   free (all_vd);
    1463                 :      977859 :   return 0;
    1464                 :      977859 : }
    1465                 :             : 
    1466                 :             : } // anon namespace
    1467                 :             : 
    1468                 :             : rtl_opt_pass *
    1469                 :      285617 : make_pass_cprop_hardreg (gcc::context *ctxt)
    1470                 :             : {
    1471                 :      285617 :   return new pass_cprop_hardreg (ctxt);
    1472                 :             : }
        

Generated by: LCOV version 2.0-1

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