LCOV - code coverage report
Current view: top level - gcc - regcprop.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 561 621 90.3 %
Date: 2020-04-04 11:58:09 Functions: 22 28 78.6 %
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-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    This file is part of GCC.
       5                 :            : 
       6                 :            :    GCC is free software; you can redistribute it and/or modify it
       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                 :      98602 : free_debug_insn_changes (struct value_data *vd, unsigned int regno)
     112                 :            : {
     113                 :      98602 :   struct queued_debug_insn_change *cur, *next;
     114                 :     377209 :   for (cur = vd->e[regno].debug_insn_changes; cur; cur = next)
     115                 :            :     {
     116                 :     278607 :       next = cur->next;
     117                 :     278607 :       --vd->n_debug_insn_changes;
     118                 :     278607 :       queued_debug_insn_change_pool.remove (cur);
     119                 :            :     }
     120                 :     188743 :   vd->e[regno].debug_insn_changes = NULL;
     121                 :     188743 : }
     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                 :   54953000 : kill_value_one_regno (unsigned int regno, struct value_data *vd)
     130                 :            : {
     131                 :   54953000 :   unsigned int i, next;
     132                 :            : 
     133                 :   54953000 :   if (vd->e[regno].oldest_regno != regno)
     134                 :            :     {
     135                 :      68892 :       for (i = vd->e[regno].oldest_regno;
     136                 :    2046740 :            vd->e[i].next_regno != regno;
     137                 :      68892 :            i = vd->e[i].next_regno)
     138                 :      68892 :         continue;
     139                 :    1977850 :       vd->e[i].next_regno = vd->e[regno].next_regno;
     140                 :            :     }
     141                 :   52975200 :   else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
     142                 :            :     {
     143                 :    3099670 :       for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
     144                 :    1598560 :         vd->e[i].oldest_regno = next;
     145                 :            :     }
     146                 :            : 
     147                 :   54953000 :   vd->e[regno].mode = VOIDmode;
     148                 :   54953000 :   vd->e[regno].oldest_regno = regno;
     149                 :   54953000 :   vd->e[regno].next_regno = INVALID_REGNUM;
     150                 :   54953000 :   if (vd->e[regno].debug_insn_changes)
     151                 :     206692 :     free_debug_insn_changes (vd, regno);
     152                 :            : 
     153                 :   54953000 :   if (flag_checking)
     154                 :   54952900 :     validate_value_data (vd);
     155                 :   54953000 : }
     156                 :            : 
     157                 :            : /* Kill the value in register REGNO for NREGS, and any other registers
     158                 :            :    whose values overlap.  */
     159                 :            : 
     160                 :            : static void
     161                 :   54713800 : kill_value_regno (unsigned int regno, unsigned int nregs,
     162                 :            :                   struct value_data *vd)
     163                 :            : {
     164                 :   54713800 :   unsigned int j;
     165                 :            : 
     166                 :            :   /* Kill the value we're told to kill.  */
     167                 :  109585000 :   for (j = 0; j < nregs; ++j)
     168                 :   54871600 :     kill_value_one_regno (regno + j, vd);
     169                 :            : 
     170                 :            :   /* Kill everything that overlapped what we're told to kill.  */
     171                 :   54713800 :   if (regno < vd->max_value_regs)
     172                 :            :     j = 0;
     173                 :            :   else
     174                 :   46920600 :     j = regno - vd->max_value_regs;
     175                 :   99085000 :   for (; j < regno; ++j)
     176                 :            :     {
     177                 :   44371200 :       unsigned int i, n;
     178                 :   44371200 :       if (vd->e[j].mode == VOIDmode)
     179                 :   34491900 :         continue;
     180                 :    9879310 :       n = hard_regno_nregs (j, vd->e[j].mode);
     181                 :    9879310 :       if (j + n > regno)
     182                 :     122211 :         for (i = 0; i < n; ++i)
     183                 :      81474 :           kill_value_one_regno (j + i, vd);
     184                 :            :     }
     185                 :   54713800 : }
     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                 :   61898200 : kill_value (const_rtx x, struct value_data *vd)
     192                 :            : {
     193                 :   61898200 :   if (GET_CODE (x) == SUBREG)
     194                 :            :     {
     195                 :          4 :       rtx tmp = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
     196                 :          2 :                                  GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
     197                 :          2 :       x = tmp ? tmp : SUBREG_REG (x);
     198                 :            :     }
     199                 :   61898200 :   if (REG_P (x))
     200                 :   45428500 :     kill_value_regno (REGNO (x), REG_NREGS (x), vd);
     201                 :   61898200 : }
     202                 :            : 
     203                 :            : /* Remember that REGNO is valid in MODE.  */
     204                 :            : 
     205                 :            : static void
     206                 :   35449600 : set_value_regno (unsigned int regno, machine_mode mode,
     207                 :            :                  struct value_data *vd)
     208                 :            : {
     209                 :   35449600 :   unsigned int nregs;
     210                 :            : 
     211                 :   35449600 :   vd->e[regno].mode = mode;
     212                 :            : 
     213                 :   33732600 :   nregs = hard_regno_nregs (regno, mode);
     214                 :   35449600 :   if (nregs > vd->max_value_regs)
     215                 :    3216540 :     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                 :    3326360 : init_value_data (struct value_data *vd)
     222                 :            : {
     223                 :    3326360 :   int i;
     224                 :  256129000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
     225                 :            :     {
     226                 :  252803000 :       vd->e[i].mode = VOIDmode;
     227                 :  252803000 :       vd->e[i].oldest_regno = i;
     228                 :  252803000 :       vd->e[i].next_regno = INVALID_REGNUM;
     229                 :  252803000 :       vd->e[i].debug_insn_changes = NULL;
     230                 :            :     }
     231                 :    3326360 :   vd->max_value_regs = 0;
     232                 :    3326360 :   vd->n_debug_insn_changes = 0;
     233                 :    3061880 : }
     234                 :            : 
     235                 :            : /* Called through note_stores.  If X is clobbered, kill its value.  */
     236                 :            : 
     237                 :            : static void
     238                 :   51827500 : kill_clobbered_value (rtx x, const_rtx set, void *data)
     239                 :            : {
     240                 :   51827500 :   struct value_data *const vd = (struct value_data *) data;
     241                 :            : 
     242                 :   51827500 :   if (GET_CODE (set) == CLOBBER)
     243                 :    6515470 :     kill_value (x, vd);
     244                 :   51827500 : }
     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                 :   51783100 : kill_set_value (rtx x, const_rtx set, void *data)
     258                 :            : {
     259                 :   51783100 :   struct kill_set_value_data *ksvd = (struct kill_set_value_data *) data;
     260                 :   51783100 :   if (rtx_equal_p (x, ksvd->ignore_set_reg))
     261                 :            :     return;
     262                 :            : 
     263                 :   51754700 :   if (GET_CODE (set) != CLOBBER)
     264                 :            :     {
     265                 :   45239300 :       kill_value (x, ksvd->vd);
     266                 :   45239300 :       if (REG_P (x))
     267                 :   29556500 :         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                 :   48385700 : kill_autoinc_value (rtx_insn *insn, struct value_data *vd)
     276                 :            : {
     277                 :   48385700 :   subrtx_iterator::array_type array;
     278                 :  313529000 :   FOR_EACH_SUBRTX (iter, array, PATTERN (insn), NONCONST)
     279                 :            :     {
     280                 :  265143000 :       const_rtx x = *iter;
     281                 :  265143000 :       if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
     282                 :            :         {
     283                 :    4147670 :           x = XEXP (x, 0);
     284                 :    4147670 :           kill_value (x, vd);
     285                 :    4147670 :           set_value_regno (REGNO (x), GET_MODE (x), vd);
     286                 :    4147670 :           iter.skip_subrtxes ();
     287                 :            :         }
     288                 :            :     }
     289                 :   48385700 : }
     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                 :    4147080 : copy_value (rtx dest, rtx src, struct value_data *vd)
     296                 :            : {
     297                 :    4147080 :   unsigned int dr = REGNO (dest);
     298                 :    4147080 :   unsigned int sr = REGNO (src);
     299                 :    4147080 :   unsigned int dn, sn;
     300                 :    4147080 :   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                 :    4147080 :   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                 :    4147080 :   if (dr == STACK_POINTER_REGNUM)
     310                 :            :     return;
     311                 :            : 
     312                 :            :   /* Likewise with the frame pointer, if we're using one.  */
     313                 :    4145900 :   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                 :    4110730 :   if (fixed_regs[dr] || global_regs[dr])
     320                 :            :     return;
     321                 :            : 
     322                 :            :   /* If SRC and DEST overlap, don't record anything.  */
     323                 :    4110720 :   dn = REG_NREGS (dest);
     324                 :    4110720 :   sn = REG_NREGS (src);
     325                 :    4110720 :   if ((dr > sr && dr < sr + sn)
     326                 :    4110720 :       || (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                 :    4110720 :   if (vd->e[sr].mode == VOIDmode)
     333                 :    1717000 :     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                 :    2393720 :   else if (sn < hard_regno_nregs (sr, vd->e[sr].mode)
     351                 :    2443340 :            && maybe_ne (subreg_lowpart_offset (GET_MODE (dest),
     352                 :      49627 :                                                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                 :    2393720 :   else if (sn > hard_regno_nregs (sr, vd->e[sr].mode))
     359                 :            :     return;
     360                 :            : 
     361                 :            :   /* Link DR at the end of the value chain used by SR.  */
     362                 :            : 
     363                 :    4110720 :   vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
     364                 :            : 
     365                 :    4327330 :   for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
     366                 :     216616 :     continue;
     367                 :    4110720 :   vd->e[i].next_regno = dr;
     368                 :            : 
     369                 :    4110720 :   if (flag_checking)
     370                 :    4110710 :     validate_value_data (vd);
     371                 :            : }
     372                 :            : 
     373                 :            : /* Return true if a mode change from ORIG to NEW is allowed for REGNO.  */
     374                 :            : 
     375                 :            : static bool
     376                 :      87450 : mode_change_ok (machine_mode orig_mode, machine_mode new_mode,
     377                 :            :                 unsigned int regno ATTRIBUTE_UNUSED)
     378                 :            : {
     379                 :          0 :   if (partial_subreg_p (orig_mode, new_mode))
     380                 :            :     return false;
     381                 :            : 
     382                 :      84820 :   return REG_CAN_CHANGE_MODE_P (regno, orig_mode, new_mode);
     383                 :            : }
     384                 :            : 
     385                 :            : /* Register REGNO was originally set in ORIG_MODE.  It - or a copy of it -
     386                 :            :    was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
     387                 :            :    in NEW_MODE.
     388                 :            :    Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX.  */
     389                 :            : 
     390                 :            : static rtx
     391                 :    1263680 : maybe_mode_change (machine_mode orig_mode, machine_mode copy_mode,
     392                 :            :                    machine_mode new_mode, unsigned int regno,
     393                 :            :                    unsigned int copy_regno ATTRIBUTE_UNUSED)
     394                 :            : {
     395                 :    1263680 :   if (partial_subreg_p (copy_mode, orig_mode)
     396                 :    1263680 :       && partial_subreg_p (copy_mode, new_mode))
     397                 :            :     return NULL_RTX;
     398                 :            : 
     399                 :            :   /* Avoid creating multiple copies of the stack pointer.  Some ports
     400                 :            :      assume there is one and only one stack pointer.
     401                 :            : 
     402                 :            :      It's unclear if we need to do the same for other special registers.  */
     403                 :    1261920 :   if (regno == STACK_POINTER_REGNUM)
     404                 :            :     return NULL_RTX;
     405                 :            : 
     406                 :    1236470 :   if (orig_mode == new_mode)
     407                 :    1149020 :     return gen_raw_REG (new_mode, regno);
     408                 :     172270 :   else if (mode_change_ok (orig_mode, new_mode, regno))
     409                 :            :     {
     410                 :      80020 :       int copy_nregs = hard_regno_nregs (copy_regno, copy_mode);
     411                 :      80020 :       int use_nregs = hard_regno_nregs (copy_regno, new_mode);
     412                 :      80020 :       poly_uint64 bytes_per_reg;
     413                 :     160040 :       if (!can_div_trunc_p (GET_MODE_SIZE (copy_mode),
     414                 :            :                             copy_nregs, &bytes_per_reg))
     415                 :      79760 :         return NULL_RTX;
     416                 :      80020 :       poly_uint64 copy_offset = bytes_per_reg * (copy_nregs - use_nregs);
     417                 :      80020 :       poly_uint64 offset
     418                 :      80020 :         = subreg_size_lowpart_offset (GET_MODE_SIZE (new_mode) + copy_offset,
     419                 :     160040 :                                       GET_MODE_SIZE (orig_mode));
     420                 :      80020 :       regno += subreg_regno_offset (regno, orig_mode, offset, new_mode);
     421                 :      80020 :       if (targetm.hard_regno_mode_ok (regno, new_mode))
     422                 :      79760 :         return gen_raw_REG (new_mode, regno);
     423                 :            :     }
     424                 :            :   return NULL_RTX;
     425                 :            : }
     426                 :            : 
     427                 :            : /* Find the oldest copy of the value contained in REGNO that is in
     428                 :            :    register class CL and has mode MODE.  If found, return an rtx
     429                 :            :    of that oldest register, otherwise return NULL.  */
     430                 :            : 
     431                 :            : static rtx
     432                 :   51440600 : find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
     433                 :            : {
     434                 :   51440600 :   unsigned int regno = REGNO (reg);
     435                 :   51440600 :   machine_mode mode = GET_MODE (reg);
     436                 :   51440600 :   unsigned int i;
     437                 :            : 
     438                 :   51440600 :   gcc_assert (regno < FIRST_PSEUDO_REGISTER);
     439                 :            : 
     440                 :            :   /* If we are accessing REG in some mode other that what we set it in,
     441                 :            :      make sure that the replacement is valid.  In particular, consider
     442                 :            :         (set (reg:DI r11) (...))
     443                 :            :         (set (reg:SI r9) (reg:SI r11))
     444                 :            :         (set (reg:SI r10) (...))
     445                 :            :         (set (...) (reg:DI r9))
     446                 :            :      Replacing r9 with r11 is invalid.  */
     447                 :   51440600 :   if (mode != vd->e[regno].mode
     448                 :   51440600 :       && REG_NREGS (reg) > hard_regno_nregs (regno, vd->e[regno].mode))
     449                 :            :     return NULL_RTX;
     450                 :            : 
     451                 :   30106600 :   for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
     452                 :            :     {
     453                 :    1354890 :       machine_mode oldmode = vd->e[i].mode;
     454                 :    1354890 :       rtx new_rtx;
     455                 :            : 
     456                 :    1354890 :       if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i))
     457                 :     292921 :         continue;
     458                 :            : 
     459                 :    1061970 :       new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
     460                 :    1061970 :       if (new_rtx)
     461                 :            :         {
     462                 :    1036100 :           ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg);
     463                 :    1036100 :           REG_ATTRS (new_rtx) = REG_ATTRS (reg);
     464                 :    1036100 :           REG_POINTER (new_rtx) = REG_POINTER (reg);
     465                 :    1036100 :           return new_rtx;
     466                 :            :         }
     467                 :            :     }
     468                 :            : 
     469                 :            :   return NULL_RTX;
     470                 :            : }
     471                 :            : 
     472                 :            : /* If possible, replace the register at *LOC with the oldest register
     473                 :            :    in register class CL.  Return true if successfully replaced.  */
     474                 :            : 
     475                 :            : static bool
     476                 :   40333300 : replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx_insn *insn,
     477                 :            :                           struct value_data *vd)
     478                 :            : {
     479                 :   40333300 :   rtx new_rtx = find_oldest_value_reg (cl, *loc, vd);
     480                 :   40333300 :   if (new_rtx && (!DEBUG_INSN_P (insn) || !skip_debug_insn_p))
     481                 :            :     {
     482                 :     814120 :       if (DEBUG_INSN_P (insn))
     483                 :            :         {
     484                 :     328380 :           struct queued_debug_insn_change *change;
     485                 :            : 
     486                 :     328380 :           if (dump_file)
     487                 :          0 :             fprintf (dump_file, "debug_insn %u: queued replacing reg %u with %u\n",
     488                 :          0 :                      INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
     489                 :            : 
     490                 :     328380 :           change = queued_debug_insn_change_pool.allocate ();
     491                 :     328380 :           change->next = vd->e[REGNO (new_rtx)].debug_insn_changes;
     492                 :     328380 :           change->insn = insn;
     493                 :     328380 :           change->loc = loc;
     494                 :     328380 :           change->new_rtx = new_rtx;
     495                 :     328380 :           vd->e[REGNO (new_rtx)].debug_insn_changes = change;
     496                 :     328380 :           ++vd->n_debug_insn_changes;
     497                 :     328380 :           return true;
     498                 :            :         }
     499                 :     485740 :       if (dump_file)
     500                 :         14 :         fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
     501                 :         14 :                  INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
     502                 :            : 
     503                 :     485740 :       validate_change (insn, loc, new_rtx, 1);
     504                 :     485740 :       return true;
     505                 :            :     }
     506                 :            :   return false;
     507                 :            : }
     508                 :            : 
     509                 :            : /* Similar to replace_oldest_value_reg, but *LOC contains an address.
     510                 :            :    Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
     511                 :            :    BASE_REG_CLASS depending on how the register is being considered.  */
     512                 :            : 
     513                 :            : static bool
     514                 :   60332200 : replace_oldest_value_addr (rtx *loc, enum reg_class cl,
     515                 :            :                            machine_mode mode, addr_space_t as,
     516                 :            :                            rtx_insn *insn, struct value_data *vd)
     517                 :            : {
     518                 :   60332200 :   rtx x = *loc;
     519                 :   60332200 :   RTX_CODE code = GET_CODE (x);
     520                 :   60332200 :   const char *fmt;
     521                 :   60332200 :   int i, j;
     522                 :   60332200 :   bool changed = false;
     523                 :            : 
     524                 :   60332200 :   switch (code)
     525                 :            :     {
     526                 :   17607400 :     case PLUS:
     527                 :   17607400 :       if (DEBUG_INSN_P (insn))
     528                 :            :         break;
     529                 :            : 
     530                 :   14633600 :       {
     531                 :   14633600 :         rtx orig_op0 = XEXP (x, 0);
     532                 :   14633600 :         rtx orig_op1 = XEXP (x, 1);
     533                 :   14633600 :         RTX_CODE code0 = GET_CODE (orig_op0);
     534                 :   14633600 :         RTX_CODE code1 = GET_CODE (orig_op1);
     535                 :   14633600 :         rtx op0 = orig_op0;
     536                 :   14633600 :         rtx op1 = orig_op1;
     537                 :   14633600 :         rtx *locI = NULL;
     538                 :   14633600 :         rtx *locB = NULL;
     539                 :   14633600 :         enum rtx_code index_code = SCRATCH;
     540                 :            : 
     541                 :   14633600 :         if (GET_CODE (op0) == SUBREG)
     542                 :            :           {
     543                 :          0 :             op0 = SUBREG_REG (op0);
     544                 :          0 :             code0 = GET_CODE (op0);
     545                 :            :           }
     546                 :            : 
     547                 :   14633600 :         if (GET_CODE (op1) == SUBREG)
     548                 :            :           {
     549                 :          0 :             op1 = SUBREG_REG (op1);
     550                 :          0 :             code1 = GET_CODE (op1);
     551                 :            :           }
     552                 :            : 
     553                 :   14633600 :         if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
     554                 :   14309100 :             || code0 == ZERO_EXTEND || code1 == MEM)
     555                 :            :           {
     556                 :     324486 :             locI = &XEXP (x, 0);
     557                 :     324486 :             locB = &XEXP (x, 1);
     558                 :     324486 :             index_code = GET_CODE (*locI);
     559                 :            :           }
     560                 :   14309100 :         else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
     561                 :   14308700 :                  || code1 == ZERO_EXTEND || code0 == MEM)
     562                 :            :           {
     563                 :        396 :             locI = &XEXP (x, 1);
     564                 :        396 :             locB = &XEXP (x, 0);
     565                 :        396 :             index_code = GET_CODE (*locI);
     566                 :            :           }
     567                 :   14308700 :         else if (code0 == CONST_INT || code0 == CONST
     568                 :   14308700 :                  || code0 == SYMBOL_REF || code0 == LABEL_REF)
     569                 :            :           {
     570                 :     459848 :             locB = &XEXP (x, 1);
     571                 :     459848 :             index_code = GET_CODE (XEXP (x, 0));
     572                 :            :           }
     573                 :   13848800 :         else if (code1 == CONST_INT || code1 == CONST
     574                 :     571154 :                  || code1 == SYMBOL_REF || code1 == LABEL_REF)
     575                 :            :           {
     576                 :   13313500 :             locB = &XEXP (x, 0);
     577                 :   13313500 :             index_code = GET_CODE (XEXP (x, 1));
     578                 :            :           }
     579                 :     535335 :         else if (code0 == REG && code1 == REG)
     580                 :            :           {
     581                 :     401327 :             int index_op;
     582                 :     401327 :             unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
     583                 :            : 
     584                 :       1343 :             if (REGNO_OK_FOR_INDEX_P (regno1)
     585                 :     401327 :                 && regno_ok_for_base_p (regno0, mode, as, PLUS, REG))
     586                 :            :               index_op = 1;
     587                 :          0 :             else if (REGNO_OK_FOR_INDEX_P (regno0)
     588                 :       1343 :                      && regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
     589                 :            :               index_op = 0;
     590                 :          0 :             else if (regno_ok_for_base_p (regno0, mode, as, PLUS, REG)
     591                 :          0 :                      || REGNO_OK_FOR_INDEX_P (regno1))
     592                 :            :               index_op = 1;
     593                 :          0 :             else if (regno_ok_for_base_p (regno1, mode, as, PLUS, REG))
     594                 :            :               index_op = 0;
     595                 :            :             else
     596                 :          0 :               index_op = 1;
     597                 :            : 
     598                 :     401327 :             locI = &XEXP (x, index_op);
     599                 :     401327 :             locB = &XEXP (x, !index_op);
     600                 :     401327 :             index_code = GET_CODE (*locI);
     601                 :            :           }
     602                 :     134008 :         else if (code0 == REG)
     603                 :            :           {
     604                 :          0 :             locI = &XEXP (x, 0);
     605                 :          0 :             locB = &XEXP (x, 1);
     606                 :          0 :             index_code = GET_CODE (*locI);
     607                 :            :           }
     608                 :     134008 :         else if (code1 == REG)
     609                 :            :           {
     610                 :     134008 :             locI = &XEXP (x, 1);
     611                 :     134008 :             locB = &XEXP (x, 0);
     612                 :     134008 :             index_code = GET_CODE (*locI);
     613                 :            :           }
     614                 :            : 
     615                 :   14633600 :         if (locI)
     616                 :     860217 :           changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS,
     617                 :            :                                                 mode, as, insn, vd);
     618                 :   14633600 :         if (locB)
     619                 :   14633600 :           changed |= replace_oldest_value_addr (locB,
     620                 :            :                                                 base_reg_class (mode, as, PLUS,
     621                 :            :                                                                 index_code),
     622                 :            :                                                 mode, as, insn, vd);
     623                 :            :         return changed;
     624                 :            :       }
     625                 :            : 
     626                 :            :     case POST_INC:
     627                 :            :     case POST_DEC:
     628                 :            :     case POST_MODIFY:
     629                 :            :     case PRE_INC:
     630                 :            :     case PRE_DEC:
     631                 :            :     case PRE_MODIFY:
     632                 :            :       return false;
     633                 :            : 
     634                 :    1163130 :     case MEM:
     635                 :    1163130 :       return replace_oldest_value_mem (x, insn, vd);
     636                 :            : 
     637                 :   22880100 :     case REG:
     638                 :   22880100 :       return replace_oldest_value_reg (loc, cl, insn, vd);
     639                 :            : 
     640                 :            :     default:
     641                 :            :       break;
     642                 :            :     }
     643                 :            : 
     644                 :   17531900 :   fmt = GET_RTX_FORMAT (code);
     645                 :   41147400 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     646                 :            :     {
     647                 :   23615400 :       if (fmt[i] == 'e')
     648                 :    8488490 :         changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode, as,
     649                 :            :                                               insn, vd);
     650                 :   15126900 :       else if (fmt[i] == 'E')
     651                 :     261157 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
     652                 :     146553 :           changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
     653                 :            :                                                 mode, as, insn, vd);
     654                 :            :     }
     655                 :            : 
     656                 :            :   return changed;
     657                 :            : }
     658                 :            : 
     659                 :            : /* Similar to replace_oldest_value_reg, but X contains a memory.  */
     660                 :            : 
     661                 :            : static bool
     662                 :   21121100 : replace_oldest_value_mem (rtx x, rtx_insn *insn, struct value_data *vd)
     663                 :            : {
     664                 :   21121100 :   enum reg_class cl;
     665                 :            : 
     666                 :   21121100 :   if (DEBUG_INSN_P (insn))
     667                 :            :     cl = ALL_REGS;
     668                 :            :   else
     669                 :   19958000 :     cl = base_reg_class (GET_MODE (x), MEM_ADDR_SPACE (x), MEM, SCRATCH);
     670                 :            : 
     671                 :   21121100 :   return replace_oldest_value_addr (&XEXP (x, 0), cl,
     672                 :   21121100 :                                     GET_MODE (x), MEM_ADDR_SPACE (x),
     673                 :   21121100 :                                     insn, vd);
     674                 :            : }
     675                 :            : 
     676                 :            : /* Apply all queued updates for DEBUG_INSNs that change some reg to
     677                 :            :    register REGNO.  */
     678                 :            : 
     679                 :            : static void
     680                 :     108365 : apply_debug_insn_changes (struct value_data *vd, unsigned int regno)
     681                 :            : {
     682                 :     108365 :   struct queued_debug_insn_change *change;
     683                 :     108365 :   rtx_insn *last_insn = vd->e[regno].debug_insn_changes->insn;
     684                 :            : 
     685                 :     108365 :   for (change = vd->e[regno].debug_insn_changes;
     686                 :     283991 :        change;
     687                 :     175626 :        change = change->next)
     688                 :            :     {
     689                 :     175626 :       if (last_insn != change->insn)
     690                 :            :         {
     691                 :      66080 :           apply_change_group ();
     692                 :      66080 :           last_insn = change->insn;
     693                 :            :         }
     694                 :     175626 :       validate_change (change->insn, change->loc, change->new_rtx, 1);
     695                 :            :     }
     696                 :     108365 :   apply_change_group ();
     697                 :     108365 : }
     698                 :            : 
     699                 :            : /* Called via note_uses, for all used registers in a real insn
     700                 :            :    apply DEBUG_INSN changes that change registers to the used
     701                 :            :    registers.  */
     702                 :            : 
     703                 :            : static void
     704                 :     616769 : cprop_find_used_regs (rtx *loc, void *data)
     705                 :            : {
     706                 :     616769 :   struct value_data *const vd = (struct value_data *) data;
     707                 :     616769 :   subrtx_iterator::array_type array;
     708                 :    2216280 :   FOR_EACH_SUBRTX (iter, array, *loc, NONCONST)
     709                 :            :     {
     710                 :    1599510 :       const_rtx x = *iter;
     711                 :    1599510 :       if (REG_P (x))
     712                 :            :         {
     713                 :     514375 :           unsigned int regno = REGNO (x);
     714                 :     514375 :           if (vd->e[regno].debug_insn_changes)
     715                 :            :             {
     716                 :      98602 :               apply_debug_insn_changes (vd, regno);
     717                 :    1698120 :               free_debug_insn_changes (vd, regno);
     718                 :            :             }
     719                 :            :         }
     720                 :            :     }
     721                 :     616769 : }
     722                 :            : 
     723                 :            : /* Apply clobbers of INSN in PATTERN and C_I_F_U to value_data VD.  */
     724                 :            : 
     725                 :            : static void
     726                 :   48414100 : kill_clobbered_values (rtx_insn *insn, struct value_data *vd)
     727                 :            : {
     728                 :          0 :   note_stores (insn, kill_clobbered_value, vd);
     729                 :      28377 : }
     730                 :            : 
     731                 :            : /* Perform the forward copy propagation on basic block BB.  */
     732                 :            : 
     733                 :            : static bool
     734                 :    7876020 : copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
     735                 :            : {
     736                 :    7876020 :   bool anything_changed = false;
     737                 :    7876020 :   rtx_insn *insn, *next;
     738                 :            : 
     739                 :    7876020 :   for (insn = BB_HEAD (bb); ; insn = next)
     740                 :            :     {
     741                 :   98901600 :       int n_ops, i, predicated;
     742                 :   98901600 :       bool is_asm, any_replacements;
     743                 :   98901600 :       rtx set;
     744                 :   98901600 :       rtx link;
     745                 :   98901600 :       bool changed = false;
     746                 :   98901600 :       struct kill_set_value_data ksvd;
     747                 :            : 
     748                 :   98901600 :       next = NEXT_INSN (insn);
     749                 :   98901600 :       if (!NONDEBUG_INSN_P (insn))
     750                 :            :         {
     751                 :   50335000 :           if (DEBUG_BIND_INSN_P (insn))
     752                 :            :             {
     753                 :   24682100 :               rtx loc = INSN_VAR_LOCATION_LOC (insn);
     754                 :   24682100 :               if (!VAR_LOC_UNKNOWN_P (loc))
     755                 :   13005700 :                 replace_oldest_value_addr (&INSN_VAR_LOCATION_LOC (insn),
     756                 :   13005700 :                                            ALL_REGS, GET_MODE (loc),
     757                 :            :                                            ADDR_SPACE_GENERIC, insn, vd);
     758                 :            :             }
     759                 :            : 
     760                 :   50335000 :           if (insn == BB_END (bb))
     761                 :            :             break;
     762                 :            :           else
     763                 :   50183300 :             continue;
     764                 :            :         }
     765                 :            : 
     766                 :   48566600 :       set = single_set (insn);
     767                 :            : 
     768                 :            :       /* Detect noop sets and remove them before processing side effects.  */
     769                 :   48566600 :       if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
     770                 :            :         {
     771                 :    4313900 :           unsigned int regno = REGNO (SET_SRC (set));
     772                 :    4313900 :           rtx r1 = find_oldest_value_reg (REGNO_REG_CLASS (regno),
     773                 :            :                                           SET_DEST (set), vd);
     774                 :    4313900 :           rtx r2 = find_oldest_value_reg (REGNO_REG_CLASS (regno),
     775                 :            :                                           SET_SRC (set), vd);
     776                 :    4313900 :           if (rtx_equal_p (r1 ? r1 : SET_DEST (set), r2 ? r2 : SET_SRC (set)))
     777                 :            :             {
     778                 :      46532 :               bool last = insn == BB_END (bb);
     779                 :      46532 :               delete_insn (insn);
     780                 :      46532 :               if (last)
     781                 :            :                 break;
     782                 :      45503 :               continue;
     783                 :            :             }
     784                 :            :         }
     785                 :            : 
     786                 :            :       /* Detect obviously dead sets (via REG_UNUSED notes) and remove them.  */
     787                 :   48520000 :       if (set
     788                 :   44364500 :           && !RTX_FRAME_RELATED_P (insn)
     789                 :   41744700 :           && !may_trap_p (set)
     790                 :   36965600 :           && find_reg_note (insn, REG_UNUSED, SET_DEST (set))
     791                 :     426644 :           && !side_effects_p (SET_SRC (set))
     792                 :   48654400 :           && !side_effects_p (SET_DEST (set)))
     793                 :            :         {
     794                 :     134358 :           bool last = insn == BB_END (bb);
     795                 :     134358 :           delete_insn (insn);
     796                 :     134358 :           if (last)
     797                 :            :             break;
     798                 :     134327 :           continue;
     799                 :            :         }
     800                 :            :          
     801                 :            : 
     802                 :   48385700 :       extract_constrain_insn (insn);
     803                 :   48385700 :       preprocess_constraints (insn);
     804                 :   48385700 :       const operand_alternative *op_alt = which_op_alt ();
     805                 :   48385700 :       n_ops = recog_data.n_operands;
     806                 :   48385700 :       is_asm = asm_noperands (PATTERN (insn)) >= 0;
     807                 :            : 
     808                 :            :       /* Simplify the code below by promoting OP_OUT to OP_INOUT
     809                 :            :          in predicated instructions.  */
     810                 :            : 
     811                 :   48385700 :       predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
     812                 :  149244000 :       for (i = 0; i < n_ops; ++i)
     813                 :            :         {
     814                 :  100858000 :           int matches = op_alt[i].matches;
     815                 :  100858000 :           if (matches >= 0 || op_alt[i].matched >= 0
     816                 :   89973600 :               || (predicated && recog_data.operand_type[i] == OP_OUT))
     817                 :   10884500 :             recog_data.operand_type[i] = OP_INOUT;
     818                 :            :         }
     819                 :            : 
     820                 :            :       /* Apply changes to earlier DEBUG_INSNs if possible.  */
     821                 :   48385700 :       if (vd->n_debug_insn_changes)
     822                 :     448053 :         note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
     823                 :            : 
     824                 :            :       /* For each earlyclobber operand, zap the value data.  */
     825                 :  149244000 :       for (i = 0; i < n_ops; i++)
     826                 :  100858000 :         if (op_alt[i].earlyclobber)
     827                 :       9938 :           kill_value (recog_data.operand[i], vd);
     828                 :            : 
     829                 :            :       /* Within asms, a clobber cannot overlap inputs or outputs.
     830                 :            :          I wouldn't think this were true for regular insns, but
     831                 :            :          scan_rtx treats them like that...  */
     832                 :   48385700 :       kill_clobbered_values (insn, vd);
     833                 :            : 
     834                 :            :       /* Kill all auto-incremented values.  */
     835                 :            :       /* ??? REG_INC is useless, since stack pushes aren't done that way.  */
     836                 :   48385700 :       kill_autoinc_value (insn, vd);
     837                 :            : 
     838                 :            :       /* Kill all early-clobbered operands.  */
     839                 :  149244000 :       for (i = 0; i < n_ops; i++)
     840                 :  100858000 :         if (op_alt[i].earlyclobber)
     841                 :       9938 :           kill_value (recog_data.operand[i], vd);
     842                 :            : 
     843                 :            :       /* If we have dead sets in the insn, then we need to note these as we
     844                 :            :          would clobbers.  */
     845                 :   93339600 :       for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
     846                 :            :         {
     847                 :   44953900 :           if (REG_NOTE_KIND (link) == REG_UNUSED)
     848                 :            :             {
     849                 :    5947560 :               kill_value (XEXP (link, 0), vd);
     850                 :            :               /* Furthermore, if the insn looked like a single-set,
     851                 :            :                  but the dead store kills the source value of that
     852                 :            :                  set, then we can no-longer use the plain move
     853                 :            :                  special case below.  */
     854                 :    5947560 :               if (set
     855                 :    5947560 :                   && reg_overlap_mentioned_p (XEXP (link, 0), SET_SRC (set)))
     856                 :            :                 set = NULL;
     857                 :            :             }
     858                 :            : 
     859                 :            :           /* We need to keep CFI info correct, and the same on all paths,
     860                 :            :              so we cannot normally replace the registers REG_CFA_REGISTER
     861                 :            :              refers to.  Bail.  */
     862                 :   44953900 :           if (REG_NOTE_KIND (link) == REG_CFA_REGISTER)
     863                 :          0 :             goto did_replacement;
     864                 :            :         }
     865                 :            : 
     866                 :            :       /* Special-case plain move instructions, since we may well
     867                 :            :          be able to do the move from a different register class.  */
     868                 :   48385700 :       if (set && REG_P (SET_SRC (set)))
     869                 :            :         {
     870                 :   10765800 :           rtx src = SET_SRC (set);
     871                 :   10765800 :           unsigned int regno = REGNO (src);
     872                 :   10765800 :           machine_mode mode = GET_MODE (src);
     873                 :   10765800 :           unsigned int i;
     874                 :   10765800 :           rtx new_rtx;
     875                 :            : 
     876                 :            :           /* If we are accessing SRC in some mode other that what we
     877                 :            :              set it in, make sure that the replacement is valid.  */
     878                 :   10765800 :           if (mode != vd->e[regno].mode)
     879                 :            :             {
     880                 :    4063520 :               if (REG_NREGS (src)
     881                 :    4063520 :                   > hard_regno_nregs (regno, vd->e[regno].mode))
     882                 :    3492350 :                 goto no_move_special_case;
     883                 :            : 
     884                 :            :               /* And likewise, if we are narrowing on big endian the transformation
     885                 :            :                  is also invalid.  */
     886                 :     571164 :               if (REG_NREGS (src) < hard_regno_nregs (regno, vd->e[regno].mode)
     887                 :     650980 :                   && maybe_ne (subreg_lowpart_offset (mode,
     888                 :      79816 :                                                       vd->e[regno].mode), 0U))
     889                 :          0 :                 goto no_move_special_case;
     890                 :            :             }
     891                 :            : 
     892                 :            :           /* If the destination is also a register, try to find a source
     893                 :            :              register in the same class.  */
     894                 :    7273440 :           if (REG_P (SET_DEST (set)))
     895                 :            :             {
     896                 :    2479520 :               new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno),
     897                 :            :                                                src, vd);
     898                 :            : 
     899                 :    2479520 :               if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
     900                 :            :                 {
     901                 :      52869 :                   if (dump_file)
     902                 :          1 :                     fprintf (dump_file,
     903                 :            :                              "insn %u: replaced reg %u with %u\n",
     904                 :          1 :                              INSN_UID (insn), regno, REGNO (new_rtx));
     905                 :      52869 :                   changed = true;
     906                 :      52869 :                   goto did_replacement;
     907                 :            :                 }
     908                 :            :               /* We need to re-extract as validate_change clobbers
     909                 :            :                  recog_data.  */
     910                 :    2426650 :               extract_constrain_insn (insn);
     911                 :    2426650 :               preprocess_constraints (insn);
     912                 :            :             }
     913                 :            : 
     914                 :            :           /* Otherwise, try all valid registers and see if its valid.  */
     915                 :    7233280 :           for (i = vd->e[regno].oldest_regno; i != regno;
     916                 :      12719 :                i = vd->e[i].next_regno)
     917                 :            :             {
     918                 :     201715 :               new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
     919                 :            :                                        mode, i, regno);
     920                 :     201715 :               if (new_rtx != NULL_RTX)
     921                 :            :                 {
     922                 :     192684 :                   if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
     923                 :            :                     {
     924                 :     188996 :                       ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
     925                 :     188996 :                       REG_ATTRS (new_rtx) = REG_ATTRS (src);
     926                 :     188996 :                       REG_POINTER (new_rtx) = REG_POINTER (src);
     927                 :     188996 :                       if (dump_file)
     928                 :          0 :                         fprintf (dump_file,
     929                 :            :                                  "insn %u: replaced reg %u with %u\n",
     930                 :          0 :                                  INSN_UID (insn), regno, REGNO (new_rtx));
     931                 :     188996 :                       changed = true;
     932                 :     188996 :                       goto did_replacement;
     933                 :            :                     }
     934                 :            :                   /* We need to re-extract as validate_change clobbers
     935                 :            :                      recog_data.  */
     936                 :       3688 :                   extract_constrain_insn (insn);
     937                 :       3688 :                   preprocess_constraints (insn);
     938                 :            :                 }
     939                 :            :             }
     940                 :            :         }
     941                 :   37619900 :       no_move_special_case:
     942                 :            : 
     943                 :            :       any_replacements = false;
     944                 :            : 
     945                 :            :       /* For each input operand, replace a hard register with the
     946                 :            :          eldest live copy that's in an appropriate register class.  */
     947                 :  148518000 :       for (i = 0; i < n_ops; i++)
     948                 :            :         {
     949                 :  100374000 :           bool replaced = false;
     950                 :            : 
     951                 :            :           /* Don't scan match_operand here, since we've no reg class
     952                 :            :              information to pass down.  Any operands that we could
     953                 :            :              substitute in will be represented elsewhere.  */
     954                 :  100374000 :           if (recog_data.constraints[i][0] == '\0')
     955                 :   17787600 :             continue;
     956                 :            : 
     957                 :            :           /* Don't replace in asms intentionally referencing hard regs.  */
     958                 :     138155 :           if (is_asm && REG_P (recog_data.operand[i])
     959                 :   82720900 :               && (REGNO (recog_data.operand[i])
     960                 :     134205 :                   == ORIGINAL_REGNO (recog_data.operand[i])))
     961                 :       1359 :             continue;
     962                 :            : 
     963                 :   82585400 :           if (recog_data.operand_type[i] == OP_IN)
     964                 :            :             {
     965                 :   42959700 :               if (op_alt[i].is_address)
     966                 :    2076560 :                 replaced
     967                 :    2076560 :                   = replace_oldest_value_addr (recog_data.operand_loc[i],
     968                 :            :                                                alternative_class (op_alt, i),
     969                 :            :                                                VOIDmode, ADDR_SPACE_GENERIC,
     970                 :            :                                                insn, vd);
     971                 :   40883200 :               else if (REG_P (recog_data.operand[i]))
     972                 :   17453200 :                 replaced
     973                 :   17453200 :                   = replace_oldest_value_reg (recog_data.operand_loc[i],
     974                 :            :                                               alternative_class (op_alt, i),
     975                 :            :                                               insn, vd);
     976                 :   23430000 :               else if (MEM_P (recog_data.operand[i]))
     977                 :    9507440 :                 replaced = replace_oldest_value_mem (recog_data.operand[i],
     978                 :            :                                                      insn, vd);
     979                 :            :             }
     980                 :   39625600 :           else if (MEM_P (recog_data.operand[i]))
     981                 :   10450500 :             replaced = replace_oldest_value_mem (recog_data.operand[i],
     982                 :            :                                                  insn, vd);
     983                 :            : 
     984                 :            :           /* If we performed any replacement, update match_dups.  */
     985                 :   39487700 :           if (replaced)
     986                 :            :             {
     987                 :     484185 :               int j;
     988                 :     484185 :               rtx new_rtx;
     989                 :            : 
     990                 :     484185 :               new_rtx = *recog_data.operand_loc[i];
     991                 :     484185 :               recog_data.operand[i] = new_rtx;
     992                 :     504583 :               for (j = 0; j < recog_data.n_dups; j++)
     993                 :      20398 :                 if (recog_data.dup_num[j] == i)
     994                 :       6022 :                   validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1);
     995                 :            : 
     996                 :            :               any_replacements = true;
     997                 :            :             }
     998                 :            :         }
     999                 :            : 
    1000                 :   48143800 :       if (any_replacements)
    1001                 :            :         {
    1002                 :     480510 :           if (! apply_change_group ())
    1003                 :            :             {
    1004                 :         28 :               if (dump_file)
    1005                 :          0 :                 fprintf (dump_file,
    1006                 :            :                          "insn %u: reg replacements not verified\n",
    1007                 :          0 :                          INSN_UID (insn));
    1008                 :            :             }
    1009                 :            :           else
    1010                 :            :             changed = true;
    1011                 :            :         }
    1012                 :            : 
    1013                 :     241865 :     did_replacement:
    1014                 :     241865 :       if (changed)
    1015                 :            :         {
    1016                 :     722347 :           anything_changed = true;
    1017                 :            : 
    1018                 :            :           /* If something changed, perhaps further changes to earlier
    1019                 :            :              DEBUG_INSNs can be applied.  */
    1020                 :     722347 :           if (vd->n_debug_insn_changes)
    1021                 :      76487 :             note_uses (&PATTERN (insn), cprop_find_used_regs, vd);
    1022                 :     722347 :           df_insn_rescan (insn);
    1023                 :            :         }
    1024                 :            : 
    1025                 :   48385700 :       ksvd.vd = vd;
    1026                 :   48385700 :       ksvd.ignore_set_reg = NULL_RTX;
    1027                 :            : 
    1028                 :            :       /* Clobber call-clobbered registers.  */
    1029                 :   48385700 :       if (CALL_P (insn))
    1030                 :            :         {
    1031                 :    3809380 :           unsigned int set_regno = INVALID_REGNUM;
    1032                 :    3809380 :           unsigned int set_nregs = 0;
    1033                 :    3809380 :           unsigned int regno;
    1034                 :    3809380 :           rtx exp;
    1035                 :            : 
    1036                 :    9783140 :           for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1))
    1037                 :            :             {
    1038                 :    6002140 :               rtx x = XEXP (exp, 0);
    1039                 :    6002140 :               if (GET_CODE (x) == SET)
    1040                 :            :                 {
    1041                 :      28377 :                   rtx dest = SET_DEST (x);
    1042                 :      28377 :                   kill_value (dest, vd);
    1043                 :      28377 :                   set_value_regno (REGNO (dest), GET_MODE (dest), vd);
    1044                 :      28377 :                   copy_value (dest, SET_SRC (x), vd);
    1045                 :      28377 :                   ksvd.ignore_set_reg = dest;
    1046                 :      28377 :                   set_regno = REGNO (dest);
    1047                 :      28377 :                   set_nregs = REG_NREGS (dest);
    1048                 :      28377 :                   break;
    1049                 :            :                 }
    1050                 :            :             }
    1051                 :            : 
    1052                 :    3809380 :           function_abi callee_abi = insn_callee_abi (insn);
    1053                 :  293322000 :           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    1054                 :  289512000 :             if (vd->e[regno].mode != VOIDmode
    1055                 :   16322900 :                 && callee_abi.clobbers_reg_p (vd->e[regno].mode, regno)
    1056                 :  298826000 :                 && (regno < set_regno || regno >= set_regno + set_nregs))
    1057                 :    9285250 :               kill_value_regno (regno, 1, vd);
    1058                 :            : 
    1059                 :            :           /* If SET was seen in CALL_INSN_FUNCTION_USAGE, and SET_SRC
    1060                 :            :              of the SET isn't clobbered by CALLEE_ABI, but instead among
    1061                 :            :              CLOBBERs on the CALL_INSN, we could wrongly assume the
    1062                 :            :              value in it is still live.  */
    1063                 :    3809380 :           if (ksvd.ignore_set_reg)
    1064                 :    3837750 :             kill_clobbered_values (insn, vd);
    1065                 :            :         }
    1066                 :            : 
    1067                 :  100906000 :       bool copy_p = (set
    1068                 :   44005200 :                      && REG_P (SET_DEST (set))
    1069                 :   76804800 :                      && REG_P (SET_SRC (set)));
    1070                 :    4134680 :       bool noop_p = (copy_p
    1071                 :    4134680 :                      && rtx_equal_p (SET_DEST (set), SET_SRC (set)));
    1072                 :            : 
    1073                 :            :       /* If a noop move is using narrower mode than we have recorded,
    1074                 :            :          we need to either remove the noop move, or kill_set_value.  */
    1075                 :      15983 :       if (noop_p
    1076                 :      15983 :           && partial_subreg_p (GET_MODE (SET_DEST (set)),
    1077                 :      15983 :                                vd->e[REGNO (SET_DEST (set))].mode))
    1078                 :            :         {
    1079                 :        749 :           if (noop_move_p (insn))
    1080                 :            :             {
    1081                 :        749 :               bool last = insn == BB_END (bb);
    1082                 :        749 :               delete_insn (insn);
    1083                 :        749 :               if (last)
    1084                 :            :                 break;
    1085                 :            :             }
    1086                 :            :           else
    1087                 :            :             noop_p = false;
    1088                 :            :         }
    1089                 :            : 
    1090                 :   48385700 :       if (!noop_p)
    1091                 :            :         {
    1092                 :            :           /* Notice stores.  */
    1093                 :   48369700 :           note_stores (insn, kill_set_value, &ksvd);
    1094                 :            : 
    1095                 :            :           /* Notice copies.  */
    1096                 :   48369700 :           if (copy_p)
    1097                 :            :             {
    1098                 :    4118700 :               df_insn_rescan (insn);
    1099                 :    4118700 :               copy_value (SET_DEST (set), SET_SRC (set), vd);
    1100                 :            :             }
    1101                 :            :         }
    1102                 :            : 
    1103                 :   48385700 :       if (insn == BB_END (bb))
    1104                 :            :         break;
    1105                 :            :     }
    1106                 :            : 
    1107                 :    7876020 :   return anything_changed;
    1108                 :            : }
    1109                 :            : 
    1110                 :            : /* Dump the value chain data to stderr.  */
    1111                 :            : 
    1112                 :            : DEBUG_FUNCTION void
    1113                 :          0 : debug_value_data (struct value_data *vd)
    1114                 :            : {
    1115                 :          0 :   HARD_REG_SET set;
    1116                 :          0 :   unsigned int i, j;
    1117                 :            : 
    1118                 :          0 :   CLEAR_HARD_REG_SET (set);
    1119                 :            : 
    1120                 :          0 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1121                 :          0 :     if (vd->e[i].oldest_regno == i)
    1122                 :            :       {
    1123                 :          0 :         if (vd->e[i].mode == VOIDmode)
    1124                 :            :           {
    1125                 :          0 :             if (vd->e[i].next_regno != INVALID_REGNUM)
    1126                 :          0 :               fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
    1127                 :            :                        i, vd->e[i].next_regno);
    1128                 :          0 :             continue;
    1129                 :            :           }
    1130                 :            : 
    1131                 :          0 :         SET_HARD_REG_BIT (set, i);
    1132                 :          0 :         fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
    1133                 :            : 
    1134                 :          0 :         for (j = vd->e[i].next_regno;
    1135                 :          0 :              j != INVALID_REGNUM;
    1136                 :          0 :              j = vd->e[j].next_regno)
    1137                 :            :           {
    1138                 :          0 :             if (TEST_HARD_REG_BIT (set, j))
    1139                 :            :               {
    1140                 :          0 :                 fprintf (stderr, "[%u] Loop in regno chain\n", j);
    1141                 :          0 :                 return;
    1142                 :            :               }
    1143                 :            : 
    1144                 :          0 :             if (vd->e[j].oldest_regno != i)
    1145                 :            :               {
    1146                 :          0 :                 fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
    1147                 :            :                          j, vd->e[j].oldest_regno);
    1148                 :          0 :                 return;
    1149                 :            :               }
    1150                 :          0 :             SET_HARD_REG_BIT (set, j);
    1151                 :          0 :             fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
    1152                 :            :           }
    1153                 :          0 :         fputc ('\n', stderr);
    1154                 :            :       }
    1155                 :            : 
    1156                 :          0 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1157                 :          0 :     if (! TEST_HARD_REG_BIT (set, i)
    1158                 :          0 :         && (vd->e[i].mode != VOIDmode
    1159                 :          0 :             || vd->e[i].oldest_regno != i
    1160                 :          0 :             || vd->e[i].next_regno != INVALID_REGNUM))
    1161                 :          0 :       fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
    1162                 :          0 :                i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
    1163                 :            :                vd->e[i].next_regno);
    1164                 :            : }
    1165                 :            : 
    1166                 :            : /* Do copyprop_hardreg_forward_1 for a single basic block BB.
    1167                 :            :    DEBUG_INSN is skipped since we do not want to involve DF related
    1168                 :            :    staff as how it is handled in function pass_cprop_hardreg::execute.
    1169                 :            : 
    1170                 :            :    NOTE: Currently it is only used for shrink-wrap.  Maybe extend it
    1171                 :            :    to handle DEBUG_INSN for other uses.  */
    1172                 :            : 
    1173                 :            : void
    1174                 :     264480 : copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb)
    1175                 :            : {
    1176                 :     264480 :   struct value_data *vd;
    1177                 :     264480 :   vd = XNEWVEC (struct value_data, 1);
    1178                 :     264480 :   init_value_data (vd);
    1179                 :            : 
    1180                 :     264480 :   skip_debug_insn_p = true;
    1181                 :     264480 :   copyprop_hardreg_forward_1 (bb, vd);
    1182                 :     264480 :   free (vd);
    1183                 :     264480 :   skip_debug_insn_p = false;
    1184                 :     264480 : }
    1185                 :            : 
    1186                 :            : static void
    1187                 :   59063600 : validate_value_data (struct value_data *vd)
    1188                 :            : {
    1189                 :   59063600 :   HARD_REG_SET set;
    1190                 :   59063600 :   unsigned int i, j;
    1191                 :            : 
    1192                 :   59063600 :   CLEAR_HARD_REG_SET (set);
    1193                 :            : 
    1194                 : 4547900000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1195                 : 4488840000 :     if (vd->e[i].oldest_regno == i)
    1196                 :            :       {
    1197                 : 4470900000 :         if (vd->e[i].mode == VOIDmode)
    1198                 :            :           {
    1199                 : 4266520000 :             if (vd->e[i].next_regno != INVALID_REGNUM)
    1200                 :          0 :               internal_error ("%qs: [%u] bad %<next_regno%> for empty chain (%u)",
    1201                 :            :                               __func__, i, vd->e[i].next_regno);
    1202                 : 4266520000 :             continue;
    1203                 :            :           }
    1204                 :            : 
    1205                 :  204380000 :         SET_HARD_REG_BIT (set, i);
    1206                 :            : 
    1207                 :  204380000 :         for (j = vd->e[i].next_regno;
    1208                 :  222319000 :              j != INVALID_REGNUM;
    1209                 :   17938900 :              j = vd->e[j].next_regno)
    1210                 :            :           {
    1211                 :   17938900 :             if (TEST_HARD_REG_BIT (set, j))
    1212                 :          0 :               internal_error ("%qs: loop in %<next_regno%> chain (%u)",
    1213                 :            :                               __func__, j);
    1214                 :   17938900 :             if (vd->e[j].oldest_regno != i)
    1215                 :          0 :               internal_error ("%qs: [%u] bad %<oldest_regno%> (%u)",
    1216                 :            :                               __func__, j, vd->e[j].oldest_regno);
    1217                 :            : 
    1218                 :   17938900 :             SET_HARD_REG_BIT (set, j);
    1219                 :            :           }
    1220                 :            :       }
    1221                 :            : 
    1222                 : 4547900000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
    1223                 : 4488840000 :     if (! TEST_HARD_REG_BIT (set, i)
    1224                 : 4488840000 :         && (vd->e[i].mode != VOIDmode
    1225                 : 4266520000 :             || vd->e[i].oldest_regno != i
    1226                 : 4266520000 :             || vd->e[i].next_regno != INVALID_REGNUM))
    1227                 :          0 :       internal_error ("%qs: [%u] non-empty register in chain (%s %u %i)",
    1228                 :            :                       __func__, i,
    1229                 :          0 :                       GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
    1230                 :            :                       vd->e[i].next_regno);
    1231                 :   59063600 : }
    1232                 :            : 
    1233                 :            : 
    1234                 :            : namespace {
    1235                 :            : 
    1236                 :            : const pass_data pass_data_cprop_hardreg =
    1237                 :            : {
    1238                 :            :   RTL_PASS, /* type */
    1239                 :            :   "cprop_hardreg", /* name */
    1240                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1241                 :            :   TV_CPROP_REGISTERS, /* tv_id */
    1242                 :            :   0, /* properties_required */
    1243                 :            :   0, /* properties_provided */
    1244                 :            :   0, /* properties_destroyed */
    1245                 :            :   0, /* todo_flags_start */
    1246                 :            :   TODO_df_finish, /* todo_flags_finish */
    1247                 :            : };
    1248                 :            : 
    1249                 :            : class pass_cprop_hardreg : public rtl_opt_pass
    1250                 :            : {
    1251                 :            : public:
    1252                 :     200773 :   pass_cprop_hardreg (gcc::context *ctxt)
    1253                 :     401546 :     : rtl_opt_pass (pass_data_cprop_hardreg, ctxt)
    1254                 :            :   {}
    1255                 :            : 
    1256                 :            :   /* opt_pass methods: */
    1257                 :     944101 :   virtual bool gate (function *)
    1258                 :            :     {
    1259                 :     944101 :       return (optimize > 0 && (flag_cprop_registers));
    1260                 :            :     }
    1261                 :            : 
    1262                 :            :   virtual unsigned int execute (function *);
    1263                 :            : 
    1264                 :            : }; // class pass_cprop_hardreg
    1265                 :            : 
    1266                 :            : static bool
    1267                 :    7611540 : cprop_hardreg_bb (basic_block bb, struct value_data *all_vd, sbitmap visited)
    1268                 :            : {
    1269                 :    7611540 :   bitmap_set_bit (visited, bb->index);
    1270                 :            : 
    1271                 :            :   /* If a block has a single predecessor, that we've already
    1272                 :            :      processed, begin with the value data that was live at
    1273                 :            :      the end of the predecessor block.  */
    1274                 :            :   /* ??? Ought to use more intelligent queuing of blocks.  */
    1275                 :    7611540 :   if (single_pred_p (bb)
    1276                 :    5664850 :       && bitmap_bit_p (visited, single_pred (bb)->index)
    1277                 :   12248300 :       && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
    1278                 :            :     {
    1279                 :    4549660 :       all_vd[bb->index] = all_vd[single_pred (bb)->index];
    1280                 :    4549660 :       if (all_vd[bb->index].n_debug_insn_changes)
    1281                 :            :         {
    1282                 :            :           unsigned int regno;
    1283                 :            : 
    1284                 :     153493 :           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    1285                 :            :             {
    1286                 :     153493 :               if (all_vd[bb->index].e[regno].debug_insn_changes)
    1287                 :            :                 {
    1288                 :            :                   struct queued_debug_insn_change *cur;
    1289                 :      46397 :                   for (cur = all_vd[bb->index].e[regno].debug_insn_changes;
    1290                 :      79462 :                        cur; cur = cur->next)
    1291                 :      46397 :                     --all_vd[bb->index].n_debug_insn_changes;
    1292                 :      33065 :                   all_vd[bb->index].e[regno].debug_insn_changes = NULL;
    1293                 :      33065 :                   if (all_vd[bb->index].n_debug_insn_changes == 0)
    1294                 :            :                     break;
    1295                 :            :                 }
    1296                 :            :             }
    1297                 :            :         }
    1298                 :            :     }
    1299                 :            :   else
    1300                 :    3061880 :     init_value_data (all_vd + bb->index);
    1301                 :            : 
    1302                 :    7611540 :   return copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
    1303                 :            : }
    1304                 :            : 
    1305                 :            : static void
    1306                 :      24494 : cprop_hardreg_debug (function *fun, struct value_data *all_vd)
    1307                 :            : {
    1308                 :      24494 :   basic_block bb;
    1309                 :            : 
    1310                 :    1207070 :   FOR_EACH_BB_FN (bb, fun)
    1311                 :    1182580 :     if (all_vd[bb->index].n_debug_insn_changes)
    1312                 :            :       {
    1313                 :      34250 :         unsigned int regno;
    1314                 :      34250 :         bitmap live;
    1315                 :            : 
    1316                 :      34250 :         live = df_get_live_out (bb);
    1317                 :     191510 :         for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
    1318                 :     191510 :           if (all_vd[bb->index].e[regno].debug_insn_changes)
    1319                 :            :             {
    1320                 :      36541 :               if (REGNO_REG_SET_P (live, regno))
    1321                 :       9763 :                 apply_debug_insn_changes (all_vd + bb->index, regno);
    1322                 :            : 
    1323                 :      36541 :               struct queued_debug_insn_change *cur;
    1324                 :      36541 :               for (cur = all_vd[bb->index].e[regno].debug_insn_changes;
    1325                 :      86314 :                    cur; cur = cur->next)
    1326                 :      49773 :                 --all_vd[bb->index].n_debug_insn_changes;
    1327                 :      36541 :               all_vd[bb->index].e[regno].debug_insn_changes = NULL;
    1328                 :      36541 :               if (all_vd[bb->index].n_debug_insn_changes == 0)
    1329                 :            :                 break;
    1330                 :            :             }
    1331                 :            :       }
    1332                 :            : 
    1333                 :      24494 :   queued_debug_insn_change_pool.release ();
    1334                 :      24494 : }
    1335                 :            : 
    1336                 :            : unsigned int
    1337                 :     688547 : pass_cprop_hardreg::execute (function *fun)
    1338                 :            : {
    1339                 :     688547 :   struct value_data *all_vd;
    1340                 :     688547 :   basic_block bb;
    1341                 :            : 
    1342                 :     688547 :   all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (fun));
    1343                 :            : 
    1344                 :     688547 :   auto_sbitmap visited (last_basic_block_for_fn (fun));
    1345                 :     688547 :   bitmap_clear (visited);
    1346                 :            : 
    1347                 :     688547 :   auto_vec<int> worklist;
    1348                 :     688547 :   bool any_debug_changes = false;
    1349                 :            : 
    1350                 :            :   /* We need accurate notes.  Earlier passes such as if-conversion may
    1351                 :            :      leave notes in an inconsistent state.  */
    1352                 :     688547 :   df_note_add_problem ();
    1353                 :     688547 :   df_analyze ();
    1354                 :            : 
    1355                 :            :   /* It is tempting to set DF_LR_RUN_DCE, but DCE may choose to delete
    1356                 :            :      an insn and this pass would not have visibility into the removal.
    1357                 :            :      This pass would then potentially use the source of that
    1358                 :            :      INSN for propagation purposes, generating invalid code.
    1359                 :            : 
    1360                 :            :      So we just ask for updated notes and handle trivial deletions
    1361                 :            :      within this pass where we can update this passes internal
    1362                 :            :      data structures appropriately.  */
    1363                 :     688547 :   df_set_flags (DF_DEFER_INSN_RESCAN);
    1364                 :            : 
    1365                 :    7925750 :   FOR_EACH_BB_FN (bb, fun)
    1366                 :            :     {
    1367                 :    7237200 :       if (cprop_hardreg_bb (bb, all_vd, visited))
    1368                 :     374336 :         worklist.safe_push (bb->index);
    1369                 :    7237200 :       if (all_vd[bb->index].n_debug_insn_changes)
    1370                 :      29656 :         any_debug_changes = true;
    1371                 :            :     }
    1372                 :            : 
    1373                 :            :   /* We must call df_analyze here unconditionally to ensure that the
    1374                 :            :      REG_UNUSED and REG_DEAD notes are consistent with and without -g.  */
    1375                 :     688547 :   df_analyze ();
    1376                 :            : 
    1377                 :     688547 :   if (MAY_HAVE_DEBUG_BIND_INSNS && any_debug_changes)
    1378                 :      20999 :     cprop_hardreg_debug (fun, all_vd);
    1379                 :            : 
    1380                 :            :   /* Second pass if we've changed anything, only for the bbs where we have
    1381                 :            :      changed anything though.  */
    1382                 :     688547 :   if (!worklist.is_empty ())
    1383                 :            :     {
    1384                 :     132273 :       unsigned int i;
    1385                 :     132273 :       int index;
    1386                 :            : 
    1387                 :     132273 :       any_debug_changes = false;
    1388                 :     132273 :       bitmap_clear (visited);
    1389                 :     506609 :       FOR_EACH_VEC_ELT (worklist, i, index)
    1390                 :            :         {
    1391                 :     374336 :           bb = BASIC_BLOCK_FOR_FN (fun, index);
    1392                 :     374336 :           cprop_hardreg_bb (bb, all_vd, visited);
    1393                 :     374336 :           if (all_vd[bb->index].n_debug_insn_changes)
    1394                 :       4594 :             any_debug_changes = true;
    1395                 :            :         }
    1396                 :            : 
    1397                 :     132273 :       df_analyze ();
    1398                 :     132273 :       if (MAY_HAVE_DEBUG_BIND_INSNS && any_debug_changes)
    1399                 :       3495 :         cprop_hardreg_debug (fun, all_vd);
    1400                 :            :     }
    1401                 :            : 
    1402                 :     688547 :   free (all_vd);
    1403                 :     688547 :   return 0;
    1404                 :            : }
    1405                 :            : 
    1406                 :            : } // anon namespace
    1407                 :            : 
    1408                 :            : rtl_opt_pass *
    1409                 :     200773 : make_pass_cprop_hardreg (gcc::context *ctxt)
    1410                 :            : {
    1411                 :     200773 :   return new pass_cprop_hardreg (ctxt);
    1412                 :            : }

Generated by: LCOV version 1.0

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