LCOV - code coverage report
Current view: top level - gcc - postreload.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 97.7 % 1020 997
Test Date: 2024-11-30 13:30:02 Functions: 100.0 % 27 27
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Perform simple optimizations to clean up the result of reload.
       2                 :             :    Copyright (C) 1987-2024 Free Software Foundation, Inc.
       3                 :             : 
       4                 :             : This file is part of GCC.
       5                 :             : 
       6                 :             : GCC is free software; you can redistribute it and/or modify it under
       7                 :             : the terms of the GNU General Public License as published by the Free
       8                 :             : Software Foundation; either version 3, or (at your option) any later
       9                 :             : version.
      10                 :             : 
      11                 :             : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :             : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :             : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :             : for more details.
      15                 :             : 
      16                 :             : You should have received a copy of the GNU General Public License
      17                 :             : along with GCC; see the file COPYING3.  If not see
      18                 :             : <http://www.gnu.org/licenses/>.  */
      19                 :             : 
      20                 :             : #include "config.h"
      21                 :             : #include "system.h"
      22                 :             : #include "coretypes.h"
      23                 :             : #include "backend.h"
      24                 :             : #include "target.h"
      25                 :             : #include "rtl.h"
      26                 :             : #include "tree.h"
      27                 :             : #include "predict.h"
      28                 :             : #include "df.h"
      29                 :             : #include "memmodel.h"
      30                 :             : #include "tm_p.h"
      31                 :             : #include "optabs.h"
      32                 :             : #include "regs.h"
      33                 :             : #include "emit-rtl.h"
      34                 :             : #include "recog.h"
      35                 :             : 
      36                 :             : #include "cfgrtl.h"
      37                 :             : #include "cfgbuild.h"
      38                 :             : #include "cfgcleanup.h"
      39                 :             : #include "reload.h"
      40                 :             : #include "cselib.h"
      41                 :             : #include "tree-pass.h"
      42                 :             : #include "dbgcnt.h"
      43                 :             : #include "function-abi.h"
      44                 :             : #include "rtl-iter.h"
      45                 :             : 
      46                 :             : static bool reload_cse_simplify (rtx_insn *, rtx);
      47                 :             : static void reload_cse_regs_1 (void);
      48                 :             : static int reload_cse_simplify_set (rtx, rtx_insn *);
      49                 :             : static int reload_cse_simplify_operands (rtx_insn *, rtx);
      50                 :             : 
      51                 :             : static void reload_combine (void);
      52                 :             : static void reload_combine_note_use (rtx *, rtx_insn *, int, rtx);
      53                 :             : static void reload_combine_note_store (rtx, const_rtx, void *);
      54                 :             : 
      55                 :             : static bool reload_cse_move2add (rtx_insn *);
      56                 :             : static void move2add_note_store (rtx, const_rtx, void *);
      57                 :             : 
      58                 :             : /* Call cse / combine like post-reload optimization phases.
      59                 :             :    FIRST is the first instruction.  */
      60                 :             : 
      61                 :             : static void
      62                 :     1051273 : reload_cse_regs (rtx_insn *first ATTRIBUTE_UNUSED)
      63                 :             : {
      64                 :     1051273 :   bool moves_converted;
      65                 :     1051273 :   reload_cse_regs_1 ();
      66                 :     1051273 :   reload_combine ();
      67                 :     1051273 :   moves_converted = reload_cse_move2add (first);
      68                 :     1051273 :   if (flag_expensive_optimizations)
      69                 :             :     {
      70                 :      968941 :       if (moves_converted)
      71                 :        8018 :         reload_combine ();
      72                 :      968941 :       reload_cse_regs_1 ();
      73                 :             :     }
      74                 :     1051273 : }
      75                 :             : 
      76                 :             : /* Try to simplify INSN.  Return true if the CFG may have changed.  */
      77                 :             : static bool
      78                 :   188737601 : reload_cse_simplify (rtx_insn *insn, rtx testreg)
      79                 :             : {
      80                 :   188737601 :   rtx body = PATTERN (insn);
      81                 :   188737601 :   basic_block insn_bb = BLOCK_FOR_INSN (insn);
      82                 :   188737601 :   unsigned insn_bb_succs = EDGE_COUNT (insn_bb->succs);
      83                 :             : 
      84                 :             :   /* If NO_FUNCTION_CSE has been set by the target, then we should not try
      85                 :             :      to cse function calls.  */
      86                 :   188737601 :   if (NO_FUNCTION_CSE && CALL_P (insn))
      87                 :             :     return false;
      88                 :             : 
      89                 :             :   /* Remember if this insn has been sp += const_int.  */
      90                 :   179997074 :   rtx sp_set = set_for_reg_notes (insn);
      91                 :   179997074 :   rtx sp_addend = NULL_RTX;
      92                 :   179997074 :   if (sp_set
      93                 :    66350643 :       && SET_DEST (sp_set) == stack_pointer_rtx
      94                 :     3284067 :       && GET_CODE (SET_SRC (sp_set)) == PLUS
      95                 :     3256748 :       && XEXP (SET_SRC (sp_set), 0) == stack_pointer_rtx
      96                 :     3256742 :       && CONST_INT_P (XEXP (SET_SRC (sp_set), 1)))
      97                 :   179997074 :     sp_addend = XEXP (SET_SRC (sp_set), 1);
      98                 :             : 
      99                 :   179997074 :   if (GET_CODE (body) == SET)
     100                 :             :     {
     101                 :    85499004 :       int count = 0;
     102                 :             : 
     103                 :             :       /* Simplify even if we may think it is a no-op.
     104                 :             :          We may think a memory load of a value smaller than WORD_SIZE
     105                 :             :          is redundant because we haven't taken into account possible
     106                 :             :          implicit extension.  reload_cse_simplify_set() will bring
     107                 :             :          this out, so it's safer to simplify before we delete.  */
     108                 :    85499004 :       count += reload_cse_simplify_set (body, insn);
     109                 :             : 
     110                 :    85499004 :       if (!count && cselib_redundant_set_p (body))
     111                 :             :         {
     112                 :      240776 :           if (check_for_inc_dec (insn))
     113                 :      240776 :             delete_insn_and_edges (insn);
     114                 :             :           /* We're done with this insn.  */
     115                 :      240776 :           goto done;
     116                 :             :         }
     117                 :             : 
     118                 :    85258228 :       if (count > 0)
     119                 :      166811 :         apply_change_group ();
     120                 :             :       else
     121                 :    85091417 :         reload_cse_simplify_operands (insn, testreg);
     122                 :             :     }
     123                 :    94498070 :   else if (GET_CODE (body) == PARALLEL)
     124                 :             :     {
     125                 :    13620533 :       int i;
     126                 :    13620533 :       int count = 0;
     127                 :    13620533 :       rtx value = NULL_RTX;
     128                 :             : 
     129                 :             :       /* Registers mentioned in the clobber list for an asm cannot be reused
     130                 :             :          within the body of the asm.  Invalidate those registers now so that
     131                 :             :          we don't try to substitute values for them.  */
     132                 :    13620533 :       if (asm_noperands (body) >= 0)
     133                 :             :         {
     134                 :     1009661 :           for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
     135                 :             :             {
     136                 :      765021 :               rtx part = XVECEXP (body, 0, i);
     137                 :      765021 :               if (GET_CODE (part) == CLOBBER && REG_P (XEXP (part, 0)))
     138                 :      299330 :                 cselib_invalidate_rtx (XEXP (part, 0));
     139                 :             :             }
     140                 :             :         }
     141                 :             : 
     142                 :             :       /* If every action in a PARALLEL is a noop, we can delete
     143                 :             :          the entire PARALLEL.  */
     144                 :    27418625 :       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
     145                 :             :         {
     146                 :    27414459 :           rtx part = XVECEXP (body, 0, i);
     147                 :    27414459 :           if (GET_CODE (part) == SET)
     148                 :             :             {
     149                 :    13417005 :               if (! cselib_redundant_set_p (part))
     150                 :             :                 break;
     151                 :        4282 :               if (REG_P (SET_DEST (part))
     152                 :        4282 :                   && REG_FUNCTION_VALUE_P (SET_DEST (part)))
     153                 :             :                 {
     154                 :           0 :                   if (value)
     155                 :             :                     break;
     156                 :             :                   value = SET_DEST (part);
     157                 :             :                 }
     158                 :             :             }
     159                 :    13997454 :           else if (GET_CODE (part) != CLOBBER && GET_CODE (part) != USE)
     160                 :             :             break;
     161                 :             :         }
     162                 :             : 
     163                 :    13620533 :       if (i < 0)
     164                 :             :         {
     165                 :        4166 :           if (check_for_inc_dec (insn))
     166                 :        4166 :             delete_insn_and_edges (insn);
     167                 :             :           /* We're done with this insn.  */
     168                 :        4166 :           goto done;
     169                 :             :         }
     170                 :             : 
     171                 :             :       /* It's not a no-op, but we can try to simplify it.  */
     172                 :    41806392 :       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
     173                 :    28190025 :         if (GET_CODE (XVECEXP (body, 0, i)) == SET)
     174                 :    14196531 :           count += reload_cse_simplify_set (XVECEXP (body, 0, i), insn);
     175                 :             : 
     176                 :    13616367 :       if (count > 0)
     177                 :        4853 :         apply_change_group ();
     178                 :             :       else
     179                 :    13611514 :         reload_cse_simplify_operands (insn, testreg);
     180                 :             :     }
     181                 :             : 
     182                 :             :   /* If sp += const_int insn is changed into sp = reg;, add REG_EQUAL
     183                 :             :      note so that the stack_adjustments pass can undo it if beneficial.  */
     184                 :   179752132 :   if (sp_addend
     185                 :     3256742 :       && SET_DEST (sp_set) == stack_pointer_rtx
     186                 :     3256742 :       && REG_P (SET_SRC (sp_set)))
     187                 :        2962 :     set_dst_reg_note (insn, REG_EQUAL,
     188                 :        2962 :                       gen_rtx_PLUS (Pmode, stack_pointer_rtx,
     189                 :             :                                     sp_addend), stack_pointer_rtx);
     190                 :             : 
     191                 :   179749170 : done:
     192                 :   359991989 :   return (EDGE_COUNT (insn_bb->succs) != insn_bb_succs);
     193                 :             : }
     194                 :             : 
     195                 :             : /* Do a very simple CSE pass over the hard registers.
     196                 :             : 
     197                 :             :    This function detects no-op moves where we happened to assign two
     198                 :             :    different pseudo-registers to the same hard register, and then
     199                 :             :    copied one to the other.  Reload will generate a useless
     200                 :             :    instruction copying a register to itself.
     201                 :             : 
     202                 :             :    This function also detects cases where we load a value from memory
     203                 :             :    into two different registers, and (if memory is more expensive than
     204                 :             :    registers) changes it to simply copy the first register into the
     205                 :             :    second register.
     206                 :             : 
     207                 :             :    Another optimization is performed that scans the operands of each
     208                 :             :    instruction to see whether the value is already available in a
     209                 :             :    hard register.  It then replaces the operand with the hard register
     210                 :             :    if possible, much like an optional reload would.  */
     211                 :             : 
     212                 :             : static void
     213                 :     2020214 : reload_cse_regs_1 (void)
     214                 :             : {
     215                 :     2020214 :   bool cfg_changed = false;
     216                 :     2020214 :   basic_block bb;
     217                 :     2020214 :   rtx_insn *insn;
     218                 :     2020214 :   rtx testreg = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
     219                 :             : 
     220                 :     2020214 :   cselib_init (CSELIB_RECORD_MEMORY);
     221                 :     2020214 :   init_alias_analysis ();
     222                 :             : 
     223                 :    22943958 :   FOR_EACH_BB_FN (bb, cfun)
     224                 :   252918100 :     FOR_BB_INSNS (bb, insn)
     225                 :             :       {
     226                 :   231994356 :         if (INSN_P (insn))
     227                 :   188737601 :           cfg_changed |= reload_cse_simplify (insn, testreg);
     228                 :             : 
     229                 :   231994356 :         cselib_process_insn (insn);
     230                 :             :       }
     231                 :             : 
     232                 :             :   /* Clean up.  */
     233                 :     2020214 :   end_alias_analysis ();
     234                 :     2020214 :   cselib_finish ();
     235                 :     2020214 :   if (cfg_changed)
     236                 :          81 :     cleanup_cfg (0);
     237                 :     2020214 : }
     238                 :             : 
     239                 :             : /* Try to simplify a single SET instruction.  SET is the set pattern.
     240                 :             :    INSN is the instruction it came from.
     241                 :             :    This function only handles one case: if we set a register to a value
     242                 :             :    which is not a register, we try to find that value in some other register
     243                 :             :    and change the set into a register copy.  */
     244                 :             : 
     245                 :             : static int
     246                 :    99695535 : reload_cse_simplify_set (rtx set, rtx_insn *insn)
     247                 :             : {
     248                 :    99695535 :   int did_change = 0;
     249                 :    99695535 :   int dreg;
     250                 :    99695535 :   rtx src;
     251                 :    99695535 :   reg_class_t dclass;
     252                 :    99695535 :   int old_cost;
     253                 :    99695535 :   cselib_val *val;
     254                 :    99695535 :   struct elt_loc_list *l;
     255                 :    99695535 :   enum rtx_code extend_op = UNKNOWN;
     256                 :    99695535 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
     257                 :             : 
     258                 :    99695535 :   dreg = true_regnum (SET_DEST (set));
     259                 :    99695535 :   if (dreg < 0)
     260                 :             :     return 0;
     261                 :             : 
     262                 :    67529092 :   src = SET_SRC (set);
     263                 :    67529092 :   if (side_effects_p (src) || true_regnum (src) >= 0)
     264                 :    10585759 :     return 0;
     265                 :             : 
     266                 :    56943333 :   dclass = REGNO_REG_CLASS (dreg);
     267                 :             : 
     268                 :             :   /* When replacing a memory with a register, we need to honor assumptions
     269                 :             :      that combine made wrt the contents of sign bits.  We'll do this by
     270                 :             :      generating an extend instruction instead of a reg->reg copy.  Thus
     271                 :             :      the destination must be a register that we can widen.  */
     272                 :    56943333 :   if (MEM_P (src)
     273                 :             :       && (extend_op = load_extend_op (GET_MODE (src))) != UNKNOWN
     274                 :             :       && !REG_P (SET_DEST (set)))
     275                 :             :     return 0;
     276                 :             : 
     277                 :    56943333 :   val = cselib_lookup (src, GET_MODE (SET_DEST (set)), 0, VOIDmode);
     278                 :    56943333 :   if (! val)
     279                 :             :     return 0;
     280                 :             : 
     281                 :             :   /* If memory loads are cheaper than register copies, don't change them.  */
     282                 :     5646292 :   if (MEM_P (src))
     283                 :      698067 :     old_cost = memory_move_cost (GET_MODE (src), dclass, true);
     284                 :     4948225 :   else if (REG_P (src))
     285                 :           0 :     old_cost = register_move_cost (GET_MODE (src),
     286                 :           0 :                                    REGNO_REG_CLASS (REGNO (src)), dclass);
     287                 :             :   else
     288                 :     4948225 :     old_cost = set_src_cost (src, GET_MODE (SET_DEST (set)), speed);
     289                 :             : 
     290                 :    11363816 :   for (l = val->locs; l; l = l->next)
     291                 :             :     {
     292                 :     5717524 :       rtx this_rtx = l->loc;
     293                 :     5717524 :       int this_cost;
     294                 :             : 
     295                 :     5717524 :       if (CONSTANT_P (this_rtx) && ! references_value_p (this_rtx, 0))
     296                 :             :         {
     297                 :     1983053 :           if (extend_op != UNKNOWN)
     298                 :             :             {
     299                 :             :               wide_int result;
     300                 :             : 
     301                 :             :               if (!CONST_SCALAR_INT_P (this_rtx))
     302                 :             :                 continue;
     303                 :             : 
     304                 :             :               switch (extend_op)
     305                 :             :                 {
     306                 :             :                 case ZERO_EXTEND:
     307                 :             :                   result = wide_int::from (rtx_mode_t (this_rtx,
     308                 :             :                                                        GET_MODE (src)),
     309                 :             :                                            BITS_PER_WORD, UNSIGNED);
     310                 :             :                   break;
     311                 :             :                 case SIGN_EXTEND:
     312                 :             :                   result = wide_int::from (rtx_mode_t (this_rtx,
     313                 :             :                                                        GET_MODE (src)),
     314                 :             :                                            BITS_PER_WORD, SIGNED);
     315                 :             :                   break;
     316                 :             :                 default:
     317                 :             :                   gcc_unreachable ();
     318                 :             :                 }
     319                 :             :               this_rtx = immed_wide_int_const (result, word_mode);
     320                 :             :             }
     321                 :             : 
     322                 :     1983053 :           this_cost = set_src_cost (this_rtx, GET_MODE (SET_DEST (set)), speed);
     323                 :             :         }
     324                 :     3734471 :       else if (REG_P (this_rtx))
     325                 :             :         {
     326                 :      842695 :           if (extend_op != UNKNOWN)
     327                 :             :             {
     328                 :             :               this_rtx = gen_rtx_fmt_e (extend_op, word_mode, this_rtx);
     329                 :             :               this_cost = set_src_cost (this_rtx, word_mode, speed);
     330                 :             :             }
     331                 :             :           else
     332                 :      842695 :             this_cost = register_move_cost (GET_MODE (this_rtx),
     333                 :      842695 :                                             REGNO_REG_CLASS (REGNO (this_rtx)),
     334                 :             :                                             dclass);
     335                 :             :         }
     336                 :             :       else
     337                 :     2891776 :         continue;
     338                 :             : 
     339                 :             :       /* If equal costs, prefer registers over anything else.  That
     340                 :             :          tends to lead to smaller instructions on some machines.  */
     341                 :     2825748 :       if (this_cost < old_cost
     342                 :     2659241 :           || (this_cost == old_cost
     343                 :     1996032 :               && REG_P (this_rtx)
     344                 :       20738 :               && !REG_P (SET_SRC (set))))
     345                 :             :         {
     346                 :      171825 :           if (extend_op != UNKNOWN
     347                 :             :               && REG_CAN_CHANGE_MODE_P (REGNO (SET_DEST (set)),
     348                 :             :                                         GET_MODE (SET_DEST (set)), word_mode))
     349                 :             :             {
     350                 :             :               rtx wide_dest = gen_rtx_REG (word_mode, REGNO (SET_DEST (set)));
     351                 :             :               ORIGINAL_REGNO (wide_dest) = ORIGINAL_REGNO (SET_DEST (set));
     352                 :             :               validate_change (insn, &SET_DEST (set), wide_dest, 1);
     353                 :             :             }
     354                 :             : 
     355                 :      171825 :           validate_unshare_change (insn, &SET_SRC (set), this_rtx, 1);
     356                 :      171825 :           old_cost = this_cost, did_change = 1;
     357                 :             :         }
     358                 :             :     }
     359                 :             : 
     360                 :             :   return did_change;
     361                 :             : }
     362                 :             : 
     363                 :             : /* Try to replace operands in INSN with equivalent values that are already
     364                 :             :    in registers.  This can be viewed as optional reloading.
     365                 :             : 
     366                 :             :    For each non-register operand in the insn, see if any hard regs are
     367                 :             :    known to be equivalent to that operand.  Record the alternatives which
     368                 :             :    can accept these hard registers.  Among all alternatives, select the
     369                 :             :    ones which are better or equal to the one currently matching, where
     370                 :             :    "better" is in terms of '?' and '!' constraints.  Among the remaining
     371                 :             :    alternatives, select the one which replaces most operands with
     372                 :             :    hard registers.  */
     373                 :             : 
     374                 :             : static int
     375                 :    98702931 : reload_cse_simplify_operands (rtx_insn *insn, rtx testreg)
     376                 :             : {
     377                 :    98702931 :   int i, j;
     378                 :             : 
     379                 :             :   /* For each operand, all registers that are equivalent to it.  */
     380                 :    98702931 :   HARD_REG_SET equiv_regs[MAX_RECOG_OPERANDS];
     381                 :             : 
     382                 :    98702931 :   const char *constraints[MAX_RECOG_OPERANDS];
     383                 :             : 
     384                 :             :   /* Vector recording how bad an alternative is.  */
     385                 :    98702931 :   int *alternative_reject;
     386                 :             :   /* Vector recording how many registers can be introduced by choosing
     387                 :             :      this alternative.  */
     388                 :    98702931 :   int *alternative_nregs;
     389                 :             :   /* Array of vectors recording, for each operand and each alternative,
     390                 :             :      which hard register to substitute, or -1 if the operand should be
     391                 :             :      left as it is.  */
     392                 :    98702931 :   int *op_alt_regno[MAX_RECOG_OPERANDS];
     393                 :             :   /* Array of alternatives, sorted in order of decreasing desirability.  */
     394                 :    98702931 :   int *alternative_order;
     395                 :             : 
     396                 :    98702931 :   extract_constrain_insn (insn);
     397                 :             : 
     398                 :    98702931 :   if (recog_data.n_alternatives == 0 || recog_data.n_operands == 0)
     399                 :             :     return 0;
     400                 :             : 
     401                 :    84924860 :   alternative_reject = XALLOCAVEC (int, recog_data.n_alternatives);
     402                 :    84924860 :   alternative_nregs = XALLOCAVEC (int, recog_data.n_alternatives);
     403                 :    84924860 :   alternative_order = XALLOCAVEC (int, recog_data.n_alternatives);
     404                 :    84924860 :   memset (alternative_reject, 0, recog_data.n_alternatives * sizeof (int));
     405                 :    84924860 :   memset (alternative_nregs, 0, recog_data.n_alternatives * sizeof (int));
     406                 :             : 
     407                 :             :   /* For each operand, find out which regs are equivalent.  */
     408                 :   274479118 :   for (i = 0; i < recog_data.n_operands; i++)
     409                 :             :     {
     410                 :             :       cselib_val *v;
     411                 :             :       struct elt_loc_list *l;
     412                 :             :       rtx op;
     413                 :             : 
     414                 :   189554258 :       CLEAR_HARD_REG_SET (equiv_regs[i]);
     415                 :             : 
     416                 :             :       /* cselib blows up on CODE_LABELs.  Trying to fix that doesn't seem
     417                 :             :          right, so avoid the problem here.  Similarly NOTE_INSN_DELETED_LABEL.
     418                 :             :          Likewise if we have a constant and the insn pattern doesn't tell us
     419                 :             :          the mode we need.  */
     420                 :   189554258 :       if (LABEL_P (recog_data.operand[i])
     421                 :   189541227 :           || (NOTE_P (recog_data.operand[i])
     422                 :          80 :               && NOTE_KIND (recog_data.operand[i]) == NOTE_INSN_DELETED_LABEL)
     423                 :   189541147 :           || (CONSTANT_P (recog_data.operand[i])
     424                 :    32776823 :               && recog_data.operand_mode[i] == VOIDmode))
     425                 :      542103 :         continue;
     426                 :             : 
     427                 :   189012155 :       op = recog_data.operand[i];
     428                 :   189012155 :       if (MEM_P (op) && load_extend_op (GET_MODE (op)) != UNKNOWN)
     429                 :             :         {
     430                 :             :           rtx set = single_set (insn);
     431                 :             : 
     432                 :             :           /* We might have multiple sets, some of which do implicit
     433                 :             :              extension.  Punt on this for now.  */
     434                 :             :           if (! set)
     435                 :             :             continue;
     436                 :             :           /* If the destination is also a MEM or a STRICT_LOW_PART, no
     437                 :             :              extension applies.
     438                 :             :              Also, if there is an explicit extension, we don't have to
     439                 :             :              worry about an implicit one.  */
     440                 :             :           else if (MEM_P (SET_DEST (set))
     441                 :             :                    || GET_CODE (SET_DEST (set)) == STRICT_LOW_PART
     442                 :             :                    || GET_CODE (SET_SRC (set)) == ZERO_EXTEND
     443                 :             :                    || GET_CODE (SET_SRC (set)) == SIGN_EXTEND)
     444                 :             :             ; /* Continue ordinary processing.  */
     445                 :             :           /* If the register cannot change mode to word_mode, it follows that
     446                 :             :              it cannot have been used in word_mode.  */
     447                 :             :           else if (REG_P (SET_DEST (set))
     448                 :             :                    && !REG_CAN_CHANGE_MODE_P (REGNO (SET_DEST (set)),
     449                 :             :                                               GET_MODE (SET_DEST (set)),
     450                 :             :                                               word_mode))
     451                 :             :             ; /* Continue ordinary processing.  */
     452                 :             :           /* If this is a straight load, make the extension explicit.  */
     453                 :             :           else if (REG_P (SET_DEST (set))
     454                 :             :                    && recog_data.n_operands == 2
     455                 :             :                    && SET_SRC (set) == op
     456                 :             :                    && SET_DEST (set) == recog_data.operand[1-i])
     457                 :             :             {
     458                 :             :               validate_change (insn, recog_data.operand_loc[i],
     459                 :             :                                gen_rtx_fmt_e (load_extend_op (GET_MODE (op)),
     460                 :             :                                               word_mode, op),
     461                 :             :                                1);
     462                 :             :               validate_change (insn, recog_data.operand_loc[1-i],
     463                 :             :                                gen_rtx_REG (word_mode, REGNO (SET_DEST (set))),
     464                 :             :                                1);
     465                 :             :               if (! apply_change_group ())
     466                 :             :                 return 0;
     467                 :             :               return reload_cse_simplify_operands (insn, testreg);
     468                 :             :             }
     469                 :             :           else
     470                 :             :             /* ??? There might be arithmetic operations with memory that are
     471                 :             :                safe to optimize, but is it worth the trouble?  */
     472                 :             :             continue;
     473                 :             :         }
     474                 :             : 
     475                 :   189012155 :       if (side_effects_p (op))
     476                 :     4473353 :         continue;
     477                 :   184538802 :       v = cselib_lookup (op, recog_data.operand_mode[i], 0, VOIDmode);
     478                 :   184538802 :       if (! v)
     479                 :   121898146 :         continue;
     480                 :             : 
     481                 :   183410593 :       for (l = v->locs; l; l = l->next)
     482                 :   120769937 :         if (REG_P (l->loc))
     483                 :    65121561 :           SET_HARD_REG_BIT (equiv_regs[i], REGNO (l->loc));
     484                 :             :     }
     485                 :             : 
     486                 :    84924860 :   alternative_mask preferred = get_preferred_alternatives (insn);
     487                 :   274479118 :   for (i = 0; i < recog_data.n_operands; i++)
     488                 :             :     {
     489                 :   189554258 :       machine_mode mode;
     490                 :   189554258 :       int regno;
     491                 :   189554258 :       const char *p;
     492                 :             : 
     493                 :   189554258 :       op_alt_regno[i] = XALLOCAVEC (int, recog_data.n_alternatives);
     494                 :  2773048054 :       for (j = 0; j < recog_data.n_alternatives; j++)
     495                 :  2583493796 :         op_alt_regno[i][j] = -1;
     496                 :             : 
     497                 :   189554258 :       p = constraints[i] = recog_data.constraints[i];
     498                 :   189554258 :       mode = recog_data.operand_mode[i];
     499                 :             : 
     500                 :             :       /* Add the reject values for each alternative given by the constraints
     501                 :             :          for this operand.  */
     502                 :   189554258 :       j = 0;
     503                 :  7487103444 :       while (*p != '\0')
     504                 :             :         {
     505                 :  7297549186 :           char c = *p++;
     506                 :  7297549186 :           if (c == ',')
     507                 :  2385624259 :             j++;
     508                 :  4911924927 :           else if (c == '?')
     509                 :   589734313 :             alternative_reject[j] += 3;
     510                 :  4322190614 :           else if (c == '!')
     511                 :    18615703 :             alternative_reject[j] += 300;
     512                 :             :         }
     513                 :             : 
     514                 :             :       /* We won't change operands which are already registers.  We
     515                 :             :          also don't want to modify output operands.  */
     516                 :   189554258 :       regno = true_regnum (recog_data.operand[i]);
     517                 :   189554258 :       if (regno >= 0
     518                 :    76123177 :           || constraints[i][0] == '='
     519                 :    57813883 :           || constraints[i][0] == '+')
     520                 :   131855711 :         continue;
     521                 :             : 
     522                 :  5365964871 :       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
     523                 :             :         {
     524                 :  5308266324 :           enum reg_class rclass = NO_REGS;
     525                 :             : 
     526                 :  5308266324 :           if (! TEST_HARD_REG_BIT (equiv_regs[i], regno))
     527                 :  5307512461 :             continue;
     528                 :             : 
     529                 :      753863 :           set_mode_and_regno (testreg, mode, regno);
     530                 :             : 
     531                 :             :           /* We found a register equal to this operand.  Now look for all
     532                 :             :              alternatives that can accept this register and have not been
     533                 :             :              assigned a register they can use yet.  */
     534                 :      753863 :           j = 0;
     535                 :      753863 :           p = constraints[i];
     536                 :    39138846 :           for (;;)
     537                 :             :             {
     538                 :    39138846 :               char c = *p;
     539                 :             : 
     540                 :    39138846 :               switch (c)
     541                 :             :                 {
     542                 :      197444 :                 case 'g':
     543                 :      197444 :                   rclass = reg_class_subunion[rclass][GENERAL_REGS];
     544                 :      197444 :                   break;
     545                 :             : 
     546                 :    24714084 :                 default:
     547                 :    24714084 :                   rclass
     548                 :    24714084 :                     = (reg_class_subunion
     549                 :    24714084 :                        [rclass]
     550                 :    24714084 :                        [reg_class_for_constraint (lookup_constraint (p))]);
     551                 :    24714084 :                   break;
     552                 :             : 
     553                 :    14227318 :                 case ',': case '\0':
     554                 :             :                   /* See if REGNO fits this alternative, and set it up as the
     555                 :             :                      replacement register if we don't have one for this
     556                 :             :                      alternative yet and the operand being replaced is not
     557                 :             :                      a cheap CONST_INT.  */
     558                 :    14227318 :                   if (op_alt_regno[i][j] == -1
     559                 :    14156995 :                       && TEST_BIT (preferred, j)
     560                 :    12193220 :                       && reg_fits_class_p (testreg, rclass, 0, mode)
     561                 :    17186883 :                       && (!CONST_INT_P (recog_data.operand[i])
     562                 :     2805885 :                           || (set_src_cost (recog_data.operand[i], mode,
     563                 :             :                                             optimize_bb_for_speed_p
     564                 :     2805885 :                                              (BLOCK_FOR_INSN (insn)))
     565                 :     2805885 :                               > set_src_cost (testreg, mode,
     566                 :             :                                               optimize_bb_for_speed_p
     567                 :     2805885 :                                                (BLOCK_FOR_INSN (insn))))))
     568                 :             :                     {
     569                 :      153680 :                       alternative_nregs[j]++;
     570                 :      153680 :                       op_alt_regno[i][j] = regno;
     571                 :             :                     }
     572                 :    14227318 :                   j++;
     573                 :    14227318 :                   rclass = NO_REGS;
     574                 :    14227318 :                   break;
     575                 :             :                 }
     576                 :    39138846 :               p += CONSTRAINT_LEN (c, p);
     577                 :             : 
     578                 :    39138846 :               if (c == '\0')
     579                 :             :                 break;
     580                 :             :             }
     581                 :             :         }
     582                 :             :     }
     583                 :             : 
     584                 :             :   /* The loop below sets alternative_order[0] but -Wmaybe-uninitialized
     585                 :             :      can't know that.  Clear it here to avoid the warning.  */
     586                 :    84924860 :   alternative_order[0] = 0;
     587                 :    84924860 :   gcc_assert (!recog_data.n_alternatives
     588                 :             :               || (which_alternative >= 0
     589                 :             :                   && which_alternative < recog_data.n_alternatives));
     590                 :             : 
     591                 :             :   /* Record all alternatives which are better or equal to the currently
     592                 :             :      matching one in the alternative_order array.  */
     593                 :  1320351979 :   for (i = j = 0; i < recog_data.n_alternatives; i++)
     594                 :  1235427119 :     if (alternative_reject[i] <= alternative_reject[which_alternative])
     595                 :   718382858 :       alternative_order[j++] = i;
     596                 :    84924860 :   recog_data.n_alternatives = j;
     597                 :             : 
     598                 :             :   /* Sort it.  Given a small number of alternatives, a dumb algorithm
     599                 :             :      won't hurt too much.  */
     600                 :   718382858 :   for (i = 0; i < recog_data.n_alternatives - 1; i++)
     601                 :             :     {
     602                 :   633457998 :       int best = i;
     603                 :   633457998 :       int best_reject = alternative_reject[alternative_order[i]];
     604                 :   633457998 :       int best_nregs = alternative_nregs[alternative_order[i]];
     605                 :             : 
     606                 :  4407835043 :       for (j = i + 1; j < recog_data.n_alternatives; j++)
     607                 :             :         {
     608                 :  3774377045 :           int this_reject = alternative_reject[alternative_order[j]];
     609                 :  3774377045 :           int this_nregs = alternative_nregs[alternative_order[j]];
     610                 :             : 
     611                 :  3774377045 :           if (this_reject < best_reject
     612                 :  3767167951 :               || (this_reject == best_reject && this_nregs > best_nregs))
     613                 :             :             {
     614                 :     7298239 :               best = j;
     615                 :     7298239 :               best_reject = this_reject;
     616                 :     7298239 :               best_nregs = this_nregs;
     617                 :             :             }
     618                 :             :         }
     619                 :             : 
     620                 :   633457998 :       std::swap (alternative_order[best], alternative_order[i]);
     621                 :             :     }
     622                 :             : 
     623                 :             :   /* Substitute the operands as determined by op_alt_regno for the best
     624                 :             :      alternative.  */
     625                 :    84924860 :   j = alternative_order[0];
     626                 :             : 
     627                 :   274479118 :   for (i = 0; i < recog_data.n_operands; i++)
     628                 :             :     {
     629                 :   189554258 :       machine_mode mode = recog_data.operand_mode[i];
     630                 :   189554258 :       if (op_alt_regno[i][j] == -1)
     631                 :   189499869 :         continue;
     632                 :             : 
     633                 :       54389 :       validate_change (insn, recog_data.operand_loc[i],
     634                 :             :                        gen_rtx_REG (mode, op_alt_regno[i][j]), 1);
     635                 :             :     }
     636                 :             : 
     637                 :    86219024 :   for (i = recog_data.n_dups - 1; i >= 0; i--)
     638                 :             :     {
     639                 :     1294164 :       int op = recog_data.dup_num[i];
     640                 :     1294164 :       machine_mode mode = recog_data.operand_mode[op];
     641                 :             : 
     642                 :     1294164 :       if (op_alt_regno[op][j] == -1)
     643                 :     1293821 :         continue;
     644                 :             : 
     645                 :         343 :       validate_change (insn, recog_data.dup_loc[i],
     646                 :             :                        gen_rtx_REG (mode, op_alt_regno[op][j]), 1);
     647                 :             :     }
     648                 :             : 
     649                 :    84924860 :   return apply_change_group ();
     650                 :             : }
     651                 :             : 
     652                 :             : /* If reload couldn't use reg+reg+offset addressing, try to use reg+reg
     653                 :             :    addressing now.
     654                 :             :    This code might also be useful when reload gave up on reg+reg addressing
     655                 :             :    because of clashes between the return register and INDEX_REG_CLASS.  */
     656                 :             : 
     657                 :             : /* The maximum number of uses of a register we can keep track of to
     658                 :             :    replace them with reg+reg addressing.  */
     659                 :             : #define RELOAD_COMBINE_MAX_USES 16
     660                 :             : 
     661                 :             : /* Describes a recorded use of a register.  */
     662                 :             : struct reg_use
     663                 :             : {
     664                 :             :   /* The insn where a register has been used.  */
     665                 :             :   rtx_insn *insn;
     666                 :             :   /* Points to the memory reference enclosing the use, if any, NULL_RTX
     667                 :             :      otherwise.  */
     668                 :             :   rtx containing_mem;
     669                 :             :   /* Location of the register within INSN.  */
     670                 :             :   rtx *usep;
     671                 :             :   /* The reverse uid of the insn.  */
     672                 :             :   int ruid;
     673                 :             : };
     674                 :             : 
     675                 :             : /* If the register is used in some unknown fashion, USE_INDEX is negative.
     676                 :             :    If it is dead, USE_INDEX is RELOAD_COMBINE_MAX_USES, and STORE_RUID
     677                 :             :    indicates where it is first set or clobbered.
     678                 :             :    Otherwise, USE_INDEX is the index of the last encountered use of the
     679                 :             :    register (which is first among these we have seen since we scan backwards).
     680                 :             :    USE_RUID indicates the first encountered, i.e. last, of these uses.
     681                 :             :    If ALL_OFFSETS_MATCH is true, all encountered uses were inside a PLUS
     682                 :             :    with a constant offset; OFFSET contains this constant in that case.
     683                 :             :    STORE_RUID is always meaningful if we only want to use a value in a
     684                 :             :    register in a different place: it denotes the next insn in the insn
     685                 :             :    stream (i.e. the last encountered) that sets or clobbers the register.
     686                 :             :    REAL_STORE_RUID is similar, but clobbers are ignored when updating it.
     687                 :             :    EXPR is the expression used when storing the register.  */
     688                 :             : static struct
     689                 :             :   {
     690                 :             :     struct reg_use reg_use[RELOAD_COMBINE_MAX_USES];
     691                 :             :     rtx offset;
     692                 :             :     int use_index;
     693                 :             :     int store_ruid;
     694                 :             :     int real_store_ruid;
     695                 :             :     int use_ruid;
     696                 :             :     bool all_offsets_match;
     697                 :             :     rtx expr;
     698                 :             :   } reg_state[FIRST_PSEUDO_REGISTER];
     699                 :             : 
     700                 :             : /* Reverse linear uid.  This is increased in reload_combine while scanning
     701                 :             :    the instructions from last to first.  It is used to set last_label_ruid
     702                 :             :    and the store_ruid / use_ruid fields in reg_state.  */
     703                 :             : static int reload_combine_ruid;
     704                 :             : 
     705                 :             : /* The RUID of the last label we encountered in reload_combine.  */
     706                 :             : static int last_label_ruid;
     707                 :             : 
     708                 :             : /* The RUID of the last jump we encountered in reload_combine.  */
     709                 :             : static int last_jump_ruid;
     710                 :             : 
     711                 :             : /* The register numbers of the first and last index register.  A value of
     712                 :             :    -1 in LAST_INDEX_REG indicates that we've previously computed these
     713                 :             :    values and found no suitable index registers.  */
     714                 :             : static int first_index_reg = -1;
     715                 :             : static int last_index_reg;
     716                 :             : 
     717                 :             : #define LABEL_LIVE(LABEL) \
     718                 :             :   (label_live[CODE_LABEL_NUMBER (LABEL) - min_labelno])
     719                 :             : 
     720                 :             : /* Subroutine of reload_combine_split_ruids, called to fix up a single
     721                 :             :    ruid pointed to by *PRUID if it is higher than SPLIT_RUID.  */
     722                 :             : 
     723                 :             : static inline void
     724                 :      179946 : reload_combine_split_one_ruid (int *pruid, int split_ruid)
     725                 :             : {
     726                 :      179946 :   if (*pruid > split_ruid)
     727                 :        7890 :     (*pruid)++;
     728                 :             : }
     729                 :             : 
     730                 :             : /* Called when we insert a new insn in a position we've already passed in
     731                 :             :    the scan.  Examine all our state, increasing all ruids that are higher
     732                 :             :    than SPLIT_RUID by one in order to make room for a new insn.  */
     733                 :             : 
     734                 :             : static void
     735                 :         638 : reload_combine_split_ruids (int split_ruid)
     736                 :             : {
     737                 :         638 :   unsigned i;
     738                 :             : 
     739                 :         638 :   reload_combine_split_one_ruid (&reload_combine_ruid, split_ruid);
     740                 :         638 :   reload_combine_split_one_ruid (&last_label_ruid, split_ruid);
     741                 :         638 :   reload_combine_split_one_ruid (&last_jump_ruid, split_ruid);
     742                 :             : 
     743                 :       59334 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     744                 :             :     {
     745                 :       58696 :       int j, idx = reg_state[i].use_index;
     746                 :       58696 :       reload_combine_split_one_ruid (&reg_state[i].use_ruid, split_ruid);
     747                 :       58696 :       reload_combine_split_one_ruid (&reg_state[i].store_ruid, split_ruid);
     748                 :       58696 :       reload_combine_split_one_ruid (&reg_state[i].real_store_ruid,
     749                 :             :                                      split_ruid);
     750                 :       58696 :       if (idx < 0)
     751                 :       24237 :         continue;
     752                 :       36403 :       for (j = idx; j < RELOAD_COMBINE_MAX_USES; j++)
     753                 :             :         {
     754                 :        3394 :           reload_combine_split_one_ruid (&reg_state[i].reg_use[j].ruid,
     755                 :             :                                          split_ruid);
     756                 :             :         }
     757                 :             :     }
     758                 :         638 : }
     759                 :             : 
     760                 :             : /* Called when we are about to rescan a previously encountered insn with
     761                 :             :    reload_combine_note_use after modifying some part of it.  This clears all
     762                 :             :    information about uses in that particular insn.  */
     763                 :             : 
     764                 :             : static void
     765                 :        5694 : reload_combine_purge_insn_uses (rtx_insn *insn)
     766                 :             : {
     767                 :        5694 :   unsigned i;
     768                 :             : 
     769                 :      529542 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     770                 :             :     {
     771                 :      523848 :       int j, k, idx = reg_state[i].use_index;
     772                 :      523848 :       if (idx < 0)
     773                 :      122475 :         continue;
     774                 :             :       j = k = RELOAD_COMBINE_MAX_USES;
     775                 :      455094 :       while (j-- > idx)
     776                 :             :         {
     777                 :       53721 :           if (reg_state[i].reg_use[j].insn != insn)
     778                 :             :             {
     779                 :       47400 :               k--;
     780                 :       47400 :               if (k != j)
     781                 :        3909 :                 reg_state[i].reg_use[k] = reg_state[i].reg_use[j];
     782                 :             :             }
     783                 :             :         }
     784                 :      401373 :       reg_state[i].use_index = k;
     785                 :             :     }
     786                 :        5694 : }
     787                 :             : 
     788                 :             : /* Called when we need to forget about all uses of REGNO after an insn
     789                 :             :    which is identified by RUID.  */
     790                 :             : 
     791                 :             : static void
     792                 :         638 : reload_combine_purge_reg_uses_after_ruid (unsigned regno, int ruid)
     793                 :             : {
     794                 :         638 :   int j, k, idx = reg_state[regno].use_index;
     795                 :         638 :   if (idx < 0)
     796                 :             :     return;
     797                 :             :   j = k = RELOAD_COMBINE_MAX_USES;
     798                 :        2540 :   while (j-- > idx)
     799                 :             :     {
     800                 :        1902 :       if (reg_state[regno].reg_use[j].ruid >= ruid)
     801                 :             :         {
     802                 :         828 :           k--;
     803                 :         828 :           if (k != j)
     804                 :         627 :             reg_state[regno].reg_use[k] = reg_state[regno].reg_use[j];
     805                 :             :         }
     806                 :             :     }
     807                 :         638 :   reg_state[regno].use_index = k;
     808                 :             : }
     809                 :             : 
     810                 :             : /* Find the use of REGNO with the ruid that is highest among those
     811                 :             :    lower than RUID_LIMIT, and return it if it is the only use of this
     812                 :             :    reg in the insn.  Return NULL otherwise.  */
     813                 :             : 
     814                 :             : static struct reg_use *
     815                 :     3622790 : reload_combine_closest_single_use (unsigned regno, int ruid_limit)
     816                 :             : {
     817                 :     3622790 :   int i, best_ruid = 0;
     818                 :     3622790 :   int use_idx = reg_state[regno].use_index;
     819                 :     3622790 :   struct reg_use *retval;
     820                 :             : 
     821                 :     3622790 :   if (use_idx < 0)
     822                 :             :     return NULL;
     823                 :             :   retval = NULL;
     824                 :     3551796 :   for (i = use_idx; i < RELOAD_COMBINE_MAX_USES; i++)
     825                 :             :     {
     826                 :     2063003 :       struct reg_use *use = reg_state[regno].reg_use + i;
     827                 :     2063003 :       int this_ruid = use->ruid;
     828                 :     2063003 :       if (this_ruid >= ruid_limit)
     829                 :      773931 :         continue;
     830                 :     1289072 :       if (this_ruid > best_ruid)
     831                 :             :         {
     832                 :             :           best_ruid = this_ruid;
     833                 :             :           retval = use;
     834                 :             :         }
     835                 :      343177 :       else if (this_ruid == best_ruid)
     836                 :     2063003 :         retval = NULL;
     837                 :             :     }
     838                 :     1488793 :   if (last_label_ruid >= best_ruid)
     839                 :      614639 :     return NULL;
     840                 :             :   return retval;
     841                 :             : }
     842                 :             : 
     843                 :             : /* After we've moved an add insn, fix up any debug insns that occur
     844                 :             :    between the old location of the add and the new location.  REG is
     845                 :             :    the destination register of the add insn; REPLACEMENT is the
     846                 :             :    SET_SRC of the add.  FROM and TO specify the range in which we
     847                 :             :    should make this change on debug insns.  */
     848                 :             : 
     849                 :             : static void
     850                 :         751 : fixup_debug_insns (rtx reg, rtx replacement, rtx_insn *from, rtx_insn *to)
     851                 :             : {
     852                 :         751 :   rtx_insn *insn;
     853                 :        7495 :   for (insn = from; insn != to; insn = NEXT_INSN (insn))
     854                 :             :     {
     855                 :        6744 :       rtx t;
     856                 :             : 
     857                 :        6744 :       if (!DEBUG_BIND_INSN_P (insn))
     858                 :        4923 :         continue;
     859                 :             : 
     860                 :        1821 :       t = INSN_VAR_LOCATION_LOC (insn);
     861                 :        1821 :       t = simplify_replace_rtx (t, reg, replacement);
     862                 :        1821 :       validate_change (insn, &INSN_VAR_LOCATION_LOC (insn), t, 0);
     863                 :             :     }
     864                 :         751 : }
     865                 :             : 
     866                 :             : /* Subroutine of reload_combine_recognize_const_pattern.  Try to replace REG
     867                 :             :    with SRC in the insn described by USE, taking costs into account.  Return
     868                 :             :    true if we made the replacement.  */
     869                 :             : 
     870                 :             : static bool
     871                 :      742631 : try_replace_in_use (struct reg_use *use, rtx reg, rtx src)
     872                 :             : {
     873                 :      742631 :   rtx_insn *use_insn = use->insn;
     874                 :      742631 :   rtx mem = use->containing_mem;
     875                 :      742631 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (use_insn));
     876                 :             : 
     877                 :      742631 :   if (mem != NULL_RTX)
     878                 :             :     {
     879                 :       16484 :       addr_space_t as = MEM_ADDR_SPACE (mem);
     880                 :       16484 :       rtx oldaddr = XEXP (mem, 0);
     881                 :       16484 :       rtx newaddr = NULL_RTX;
     882                 :       16484 :       int old_cost = address_cost (oldaddr, GET_MODE (mem), as, speed);
     883                 :       16484 :       int new_cost;
     884                 :             : 
     885                 :       16484 :       newaddr = simplify_replace_rtx (oldaddr, reg, src);
     886                 :       16484 :       if (memory_address_addr_space_p (GET_MODE (mem), newaddr, as))
     887                 :             :         {
     888                 :        5630 :           XEXP (mem, 0) = newaddr;
     889                 :        5630 :           new_cost = address_cost (newaddr, GET_MODE (mem), as, speed);
     890                 :        5630 :           XEXP (mem, 0) = oldaddr;
     891                 :        5630 :           if (new_cost <= old_cost
     892                 :        5630 :               && validate_change (use_insn,
     893                 :             :                                   &XEXP (mem, 0), newaddr, 0))
     894                 :             :             return true;
     895                 :             :         }
     896                 :             :     }
     897                 :             :   else
     898                 :             :     {
     899                 :      726147 :       rtx new_set = single_set (use_insn);
     900                 :      726147 :       if (new_set
     901                 :      725211 :           && REG_P (SET_DEST (new_set))
     902                 :      286888 :           && GET_CODE (SET_SRC (new_set)) == PLUS
     903                 :       15752 :           && REG_P (XEXP (SET_SRC (new_set), 0))
     904                 :       14811 :           && CONSTANT_P (XEXP (SET_SRC (new_set), 1)))
     905                 :             :         {
     906                 :        1129 :           rtx new_src;
     907                 :        1129 :           machine_mode mode = GET_MODE (SET_DEST (new_set));
     908                 :        1129 :           int old_cost = set_src_cost (SET_SRC (new_set), mode, speed);
     909                 :             : 
     910                 :        1129 :           gcc_assert (rtx_equal_p (XEXP (SET_SRC (new_set), 0), reg));
     911                 :        1129 :           new_src = simplify_replace_rtx (SET_SRC (new_set), reg, src);
     912                 :             : 
     913                 :        1129 :           if (set_src_cost (new_src, mode, speed) <= old_cost
     914                 :        1129 :               && validate_change (use_insn, &SET_SRC (new_set),
     915                 :             :                                   new_src, 0))
     916                 :             :             return true;
     917                 :             :         }
     918                 :             :     }
     919                 :             :   return false;
     920                 :             : }
     921                 :             : 
     922                 :             : /* Called by reload_combine when scanning INSN.  This function tries to detect
     923                 :             :    patterns where a constant is added to a register, and the result is used
     924                 :             :    in an address.
     925                 :             :    Return true if no further processing is needed on INSN; false if it wasn't
     926                 :             :    recognized and should be handled normally.  */
     927                 :             : 
     928                 :             : static bool
     929                 :    59191993 : reload_combine_recognize_const_pattern (rtx_insn *insn)
     930                 :             : {
     931                 :    59191993 :   int from_ruid = reload_combine_ruid;
     932                 :    59191993 :   rtx set, pat, reg, src, addreg;
     933                 :    59191993 :   unsigned int regno;
     934                 :    59191993 :   struct reg_use *use;
     935                 :    59191993 :   bool must_move_add;
     936                 :    59191993 :   rtx_insn *add_moved_after_insn = NULL;
     937                 :    59191993 :   int add_moved_after_ruid = 0;
     938                 :    59191993 :   int clobbered_regno = -1;
     939                 :             : 
     940                 :    59191993 :   set = single_set (insn);
     941                 :    59191993 :   if (set == NULL_RTX)
     942                 :             :     return false;
     943                 :             : 
     944                 :    55065882 :   reg = SET_DEST (set);
     945                 :    55065882 :   src = SET_SRC (set);
     946                 :    55065882 :   if (!REG_P (reg)
     947                 :    37711668 :       || REG_NREGS (reg) != 1
     948                 :    37114467 :       || GET_MODE (reg) != Pmode
     949                 :    76301189 :       || reg == stack_pointer_rtx)
     950                 :             :     return false;
     951                 :             : 
     952                 :    19558674 :   regno = REGNO (reg);
     953                 :             : 
     954                 :             :   /* We look for a REG1 = REG2 + CONSTANT insn, followed by either
     955                 :             :      uses of REG1 inside an address, or inside another add insn.  If
     956                 :             :      possible and profitable, merge the addition into subsequent
     957                 :             :      uses.  */
     958                 :    19558674 :   if (GET_CODE (src) != PLUS
     959                 :     3776208 :       || !REG_P (XEXP (src, 0))
     960                 :     3549057 :       || !CONSTANT_P (XEXP (src, 1)))
     961                 :             :     return false;
     962                 :             : 
     963                 :     2974529 :   addreg = XEXP (src, 0);
     964                 :     2974529 :   must_move_add = rtx_equal_p (reg, addreg);
     965                 :             : 
     966                 :     2974529 :   pat = PATTERN (insn);
     967                 :     2974529 :   if (must_move_add && set != pat)
     968                 :             :     {
     969                 :             :       /* We have to be careful when moving the add; apart from the
     970                 :             :          single_set there may also be clobbers.  Recognize one special
     971                 :             :          case, that of one clobber alongside the set (likely a clobber
     972                 :             :          of the CC register).  */
     973                 :      905733 :       gcc_assert (GET_CODE (PATTERN (insn)) == PARALLEL);
     974                 :      905733 :       if (XVECLEN (pat, 0) != 2 || XVECEXP (pat, 0, 0) != set
     975                 :      905733 :           || GET_CODE (XVECEXP (pat, 0, 1)) != CLOBBER
     976                 :      905733 :           || !REG_P (XEXP (XVECEXP (pat, 0, 1), 0)))
     977                 :             :         return false;
     978                 :      905733 :       clobbered_regno = REGNO (XEXP (XVECEXP (pat, 0, 1), 0));
     979                 :             :     }
     980                 :             : 
     981                 :     3622790 :   do
     982                 :             :     {
     983                 :     3622790 :       use = reload_combine_closest_single_use (regno, from_ruid);
     984                 :             : 
     985                 :     3622790 :       if (use)
     986                 :             :         /* Start the search for the next use from here.  */
     987                 :      846364 :         from_ruid = use->ruid;
     988                 :             : 
     989                 :      846364 :       if (use && GET_MODE (*use->usep) == Pmode)
     990                 :             :         {
     991                 :      841704 :           bool delete_add = false;
     992                 :      841704 :           rtx_insn *use_insn = use->insn;
     993                 :      841704 :           int use_ruid = use->ruid;
     994                 :             : 
     995                 :             :           /* Avoid moving the add insn past a jump.  */
     996                 :      841704 :           if (must_move_add && use_ruid <= last_jump_ruid)
     997                 :             :             break;
     998                 :             : 
     999                 :             :           /* If the add clobbers another hard reg in parallel, don't move
    1000                 :             :              it past a real set of this hard reg.  */
    1001                 :      841408 :           if (must_move_add && clobbered_regno >= 0
    1002                 :      110029 :               && reg_state[clobbered_regno].real_store_ruid >= use_ruid)
    1003                 :             :             break;
    1004                 :             : 
    1005                 :      819523 :           gcc_assert (reg_state[regno].store_ruid <= use_ruid);
    1006                 :             :           /* Avoid moving a use of ADDREG past a point where it is stored.  */
    1007                 :      819523 :           if (reg_state[REGNO (addreg)].store_ruid > use_ruid)
    1008                 :             :             break;
    1009                 :             : 
    1010                 :             :           /* We also must not move the addition past an insn that sets
    1011                 :             :              the same register, unless we can combine two add insns.  */
    1012                 :      742651 :           if (must_move_add && reg_state[regno].store_ruid == use_ruid)
    1013                 :             :             {
    1014                 :       28085 :               if (use->containing_mem == NULL_RTX)
    1015                 :             :                 delete_add = true;
    1016                 :             :               else
    1017                 :             :                 break;
    1018                 :             :             }
    1019                 :             : 
    1020                 :      742631 :           if (try_replace_in_use (use, reg, src))
    1021                 :             :             {
    1022                 :        5694 :               reload_combine_purge_insn_uses (use_insn);
    1023                 :        5694 :               reload_combine_note_use (&PATTERN (use_insn), use_insn,
    1024                 :             :                                        use_ruid, NULL_RTX);
    1025                 :             : 
    1026                 :        5694 :               if (delete_add)
    1027                 :             :                 {
    1028                 :          69 :                   fixup_debug_insns (reg, src, insn, use_insn);
    1029                 :          69 :                   delete_insn (insn);
    1030                 :          69 :                   return true;
    1031                 :             :                 }
    1032                 :        5625 :               if (must_move_add)
    1033                 :             :                 {
    1034                 :        1176 :                   add_moved_after_insn = use_insn;
    1035                 :        1176 :                   add_moved_after_ruid = use_ruid;
    1036                 :             :                 }
    1037                 :        5625 :               continue;
    1038                 :             :             }
    1039                 :             :         }
    1040                 :             :       /* If we get here, we couldn't handle this use.  */
    1041                 :     3518023 :       if (must_move_add)
    1042                 :             :         break;
    1043                 :             :     }
    1044                 :     2615443 :   while (use);
    1045                 :             : 
    1046                 :     2974460 :   if (!must_move_add || add_moved_after_insn == NULL_RTX)
    1047                 :             :     /* Process the add normally.  */
    1048                 :             :     return false;
    1049                 :             : 
    1050                 :         638 :   fixup_debug_insns (reg, src, insn, add_moved_after_insn);
    1051                 :             : 
    1052                 :         638 :   reorder_insns (insn, insn, add_moved_after_insn);
    1053                 :         638 :   reload_combine_purge_reg_uses_after_ruid (regno, add_moved_after_ruid);
    1054                 :         638 :   reload_combine_split_ruids (add_moved_after_ruid - 1);
    1055                 :         638 :   reload_combine_note_use (&PATTERN (insn), insn,
    1056                 :             :                            add_moved_after_ruid, NULL_RTX);
    1057                 :         638 :   reg_state[regno].store_ruid = add_moved_after_ruid;
    1058                 :             : 
    1059                 :         638 :   return true;
    1060                 :             : }
    1061                 :             : 
    1062                 :             : /* Called by reload_combine when scanning INSN.  Try to detect a pattern we
    1063                 :             :    can handle and improve.  Return true if no further processing is needed on
    1064                 :             :    INSN; false if it wasn't recognized and should be handled normally.  */
    1065                 :             : 
    1066                 :             : static bool
    1067                 :    59191286 : reload_combine_recognize_pattern (rtx_insn *insn)
    1068                 :             : {
    1069                 :    59191286 :   rtx set, reg, src;
    1070                 :             : 
    1071                 :    59191286 :   set = single_set (insn);
    1072                 :    59191286 :   if (set == NULL_RTX)
    1073                 :             :     return false;
    1074                 :             : 
    1075                 :    55065175 :   reg = SET_DEST (set);
    1076                 :    55065175 :   src = SET_SRC (set);
    1077                 :    55065175 :   if (!REG_P (reg) || REG_NREGS (reg) != 1)
    1078                 :             :     return false;
    1079                 :             : 
    1080                 :    37113760 :   unsigned int regno = REGNO (reg);
    1081                 :    37113760 :   machine_mode mode = GET_MODE (reg);
    1082                 :             : 
    1083                 :    37113760 :   if (reg_state[regno].use_index < 0
    1084                 :    37113760 :       || reg_state[regno].use_index >= RELOAD_COMBINE_MAX_USES)
    1085                 :             :     return false;
    1086                 :             : 
    1087                 :    24206115 :   for (int i = reg_state[regno].use_index;
    1088                 :    44387484 :        i < RELOAD_COMBINE_MAX_USES; i++)
    1089                 :             :     {
    1090                 :    24939344 :       struct reg_use *use = reg_state[regno].reg_use + i;
    1091                 :    24939344 :       if (GET_MODE (*use->usep) != mode)
    1092                 :             :         return false;
    1093                 :             :       /* Don't try to adjust (use (REGX)).  */
    1094                 :    24210405 :       if (GET_CODE (PATTERN (use->insn)) == USE
    1095                 :    24210405 :           && &XEXP (PATTERN (use->insn), 0) == use->usep)
    1096                 :             :         return false;
    1097                 :             :     }
    1098                 :             : 
    1099                 :             :   /* Look for (set (REGX) (CONST_INT))
    1100                 :             :      (set (REGX) (PLUS (REGX) (REGY)))
    1101                 :             :      ...
    1102                 :             :      ... (MEM (REGX)) ...
    1103                 :             :      and convert it to
    1104                 :             :      (set (REGZ) (CONST_INT))
    1105                 :             :      ...
    1106                 :             :      ... (MEM (PLUS (REGZ) (REGY)))... .
    1107                 :             : 
    1108                 :             :      First, check that we have (set (REGX) (PLUS (REGX) (REGY)))
    1109                 :             :      and that we know all uses of REGX before it dies.
    1110                 :             :      Also, explicitly check that REGX != REGY; our life information
    1111                 :             :      does not yet show whether REGY changes in this insn.  */
    1112                 :             : 
    1113                 :    19448140 :   if (GET_CODE (src) == PLUS
    1114                 :     2266425 :       && reg_state[regno].all_offsets_match
    1115                 :     2029146 :       && last_index_reg != -1
    1116                 :     2029146 :       && REG_P (XEXP (src, 1))
    1117                 :      645983 :       && rtx_equal_p (XEXP (src, 0), reg)
    1118                 :      459756 :       && !rtx_equal_p (XEXP (src, 1), reg)
    1119                 :    19901279 :       && last_label_ruid < reg_state[regno].use_ruid)
    1120                 :             :     {
    1121                 :      425109 :       rtx base = XEXP (src, 1);
    1122                 :      425109 :       rtx_insn *prev = prev_nonnote_nondebug_insn (insn);
    1123                 :      425109 :       rtx prev_set = prev ? single_set (prev) : NULL_RTX;
    1124                 :      425109 :       rtx index_reg = NULL_RTX;
    1125                 :      425109 :       rtx reg_sum = NULL_RTX;
    1126                 :      425109 :       int i;
    1127                 :             : 
    1128                 :             :       /* Now we need to set INDEX_REG to an index register (denoted as
    1129                 :             :          REGZ in the illustration above) and REG_SUM to the expression
    1130                 :             :          register+register that we want to use to substitute uses of REG
    1131                 :             :          (typically in MEMs) with.  First check REG and BASE for being
    1132                 :             :          index registers; we can use them even if they are not dead.  */
    1133                 :      425109 :       if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], regno)
    1134                 :      425109 :           || TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS],
    1135                 :             :                                 REGNO (base)))
    1136                 :             :         {
    1137                 :             :           index_reg = reg;
    1138                 :             :           reg_sum = src;
    1139                 :             :         }
    1140                 :             :       else
    1141                 :             :         {
    1142                 :             :           /* Otherwise, look for a free index register.  Since we have
    1143                 :             :              checked above that neither REG nor BASE are index registers,
    1144                 :             :              if we find anything at all, it will be different from these
    1145                 :             :              two registers.  */
    1146                 :     8619834 :           for (i = first_index_reg; i <= last_index_reg; i++)
    1147                 :             :             {
    1148                 :     8532853 :               if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], i)
    1149                 :     2961285 :                   && reg_state[i].use_index == RELOAD_COMBINE_MAX_USES
    1150                 :     1557835 :                   && reg_state[i].store_ruid <= reg_state[regno].use_ruid
    1151                 :     1543079 :                   && (crtl->abi->clobbers_full_reg_p (i)
    1152                 :      311262 :                       || df_regs_ever_live_p (i))
    1153                 :     1301770 :                   && (!frame_pointer_needed || i != HARD_FRAME_POINTER_REGNUM)
    1154                 :     1300793 :                   && !fixed_regs[i] && !global_regs[i]
    1155                 :      506121 :                   && hard_regno_nregs (i, GET_MODE (reg)) == 1
    1156                 :     8653972 :                   && targetm.hard_regno_scratch_ok (i))
    1157                 :             :                 {
    1158                 :      121119 :                   index_reg = gen_rtx_REG (GET_MODE (reg), i);
    1159                 :      121119 :                   reg_sum = gen_rtx_PLUS (GET_MODE (reg), index_reg, base);
    1160                 :      121119 :                   break;
    1161                 :             :                 }
    1162                 :             :             }
    1163                 :             :         }
    1164                 :             : 
    1165                 :             :       /* Check that PREV_SET is indeed (set (REGX) (CONST_INT)) and that
    1166                 :             :          (REGY), i.e. BASE, is not clobbered before the last use we'll
    1167                 :             :          create.  */
    1168                 :      425109 :       if (reg_sum
    1169                 :      425109 :           && prev_set
    1170                 :      332985 :           && CONST_INT_P (SET_SRC (prev_set))
    1171                 :        7011 :           && rtx_equal_p (SET_DEST (prev_set), reg)
    1172                 :      425109 :           && (reg_state[REGNO (base)].store_ruid
    1173                 :        2118 :               <= reg_state[regno].use_ruid))
    1174                 :             :         {
    1175                 :             :           /* Change destination register and, if necessary, the constant
    1176                 :             :              value in PREV, the constant loading instruction.  */
    1177                 :        2099 :           validate_change (prev, &SET_DEST (prev_set), index_reg, 1);
    1178                 :        2099 :           if (reg_state[regno].offset != const0_rtx)
    1179                 :             :             {
    1180                 :           0 :               HOST_WIDE_INT c
    1181                 :           0 :                 = trunc_int_for_mode (UINTVAL (SET_SRC (prev_set))
    1182                 :           0 :                                       + UINTVAL (reg_state[regno].offset),
    1183                 :           0 :                                       GET_MODE (index_reg));
    1184                 :           0 :               validate_change (prev, &SET_SRC (prev_set), GEN_INT (c), 1);
    1185                 :             :             }
    1186                 :             : 
    1187                 :             :           /* Now for every use of REG that we have recorded, replace REG
    1188                 :             :              with REG_SUM.  */
    1189                 :        4238 :           for (i = reg_state[regno].use_index;
    1190                 :        4238 :                i < RELOAD_COMBINE_MAX_USES; i++)
    1191                 :        2139 :             validate_unshare_change (reg_state[regno].reg_use[i].insn,
    1192                 :             :                                      reg_state[regno].reg_use[i].usep,
    1193                 :             :                                      /* Each change must have its own
    1194                 :             :                                         replacement.  */
    1195                 :             :                                      reg_sum, 1);
    1196                 :             : 
    1197                 :        2099 :           if (apply_change_group ())
    1198                 :             :             {
    1199                 :          44 :               struct reg_use *lowest_ruid = NULL;
    1200                 :             : 
    1201                 :             :               /* For every new use of REG_SUM, we have to record the use
    1202                 :             :                  of BASE therein, i.e. operand 1.  */
    1203                 :         102 :               for (i = reg_state[regno].use_index;
    1204                 :         102 :                    i < RELOAD_COMBINE_MAX_USES; i++)
    1205                 :             :                 {
    1206                 :          58 :                   struct reg_use *use = reg_state[regno].reg_use + i;
    1207                 :          58 :                   reload_combine_note_use (&XEXP (*use->usep, 1), use->insn,
    1208                 :             :                                            use->ruid, use->containing_mem);
    1209                 :          58 :                   if (lowest_ruid == NULL || use->ruid < lowest_ruid->ruid)
    1210                 :          58 :                     lowest_ruid = use;
    1211                 :             :                 }
    1212                 :             : 
    1213                 :          44 :               fixup_debug_insns (reg, reg_sum, insn, lowest_ruid->insn);
    1214                 :             : 
    1215                 :             :               /* Delete the reg-reg addition.  */
    1216                 :          44 :               delete_insn (insn);
    1217                 :             : 
    1218                 :          44 :               if (reg_state[regno].offset != const0_rtx)
    1219                 :             :                 /* Previous REG_EQUIV / REG_EQUAL notes for PREV
    1220                 :             :                    are now invalid.  */
    1221                 :           0 :                 remove_reg_equal_equiv_notes (prev);
    1222                 :             : 
    1223                 :          44 :               reg_state[regno].use_index = RELOAD_COMBINE_MAX_USES;
    1224                 :          44 :               return true;
    1225                 :             :             }
    1226                 :             :         }
    1227                 :             :     }
    1228                 :             :   return false;
    1229                 :             : }
    1230                 :             : 
    1231                 :             : static void
    1232                 :     1059291 : reload_combine (void)
    1233                 :             : {
    1234                 :     1059291 :   rtx_insn *insn, *prev;
    1235                 :     1059291 :   basic_block bb;
    1236                 :     1059291 :   unsigned int r;
    1237                 :     1059291 :   int min_labelno, n_labels;
    1238                 :     1059291 :   HARD_REG_SET ever_live_at_start, *label_live;
    1239                 :             : 
    1240                 :             :   /* To avoid wasting too much time later searching for an index register,
    1241                 :             :      determine the minimum and maximum index register numbers.  */
    1242                 :     1059291 :   if (INDEX_REG_CLASS == NO_REGS)
    1243                 :             :     last_index_reg = -1;
    1244                 :     1059291 :   else if (first_index_reg == -1 && last_index_reg == 0)
    1245                 :             :     {
    1246                 :    12796800 :       for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1247                 :    12659200 :         if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], r))
    1248                 :             :           {
    1249                 :     4265600 :             if (first_index_reg == -1)
    1250                 :      137600 :               first_index_reg = r;
    1251                 :             : 
    1252                 :     4265600 :             last_index_reg = r;
    1253                 :             :           }
    1254                 :             : 
    1255                 :             :       /* If no index register is available, we can quit now.  Set LAST_INDEX_REG
    1256                 :             :          to -1 so we'll know to quit early the next time we get here.  */
    1257                 :      137600 :       if (first_index_reg == -1)
    1258                 :             :         {
    1259                 :           0 :           last_index_reg = -1;
    1260                 :           0 :           return;
    1261                 :             :         }
    1262                 :             :     }
    1263                 :             : 
    1264                 :             :   /* Set up LABEL_LIVE and EVER_LIVE_AT_START.  The register lifetime
    1265                 :             :      information is a bit fuzzy immediately after reload, but it's
    1266                 :             :      still good enough to determine which registers are live at a jump
    1267                 :             :      destination.  */
    1268                 :     1059291 :   min_labelno = get_first_label_num ();
    1269                 :     1059291 :   n_labels = max_label_num () - min_labelno;
    1270                 :     1059291 :   label_live = XNEWVEC (HARD_REG_SET, n_labels);
    1271                 :     1059291 :   CLEAR_HARD_REG_SET (ever_live_at_start);
    1272                 :             : 
    1273                 :    12359279 :   FOR_EACH_BB_REVERSE_FN (bb, cfun)
    1274                 :             :     {
    1275                 :    11299988 :       insn = BB_HEAD (bb);
    1276                 :    11299988 :       if (LABEL_P (insn))
    1277                 :             :         {
    1278                 :     5200738 :           HARD_REG_SET live;
    1279                 :     5200738 :           bitmap live_in = df_get_live_in (bb);
    1280                 :             : 
    1281                 :    10401476 :           REG_SET_TO_HARD_REG_SET (live, live_in);
    1282                 :     5200738 :           compute_use_by_pseudos (&live, live_in);
    1283                 :     5200738 :           LABEL_LIVE (insn) = live;
    1284                 :    10401476 :           ever_live_at_start |= live;
    1285                 :             :         }
    1286                 :             :     }
    1287                 :             : 
    1288                 :             :   /* Initialize last_label_ruid, reload_combine_ruid and reg_state.  */
    1289                 :     1059291 :   last_label_ruid = last_jump_ruid = reload_combine_ruid = 0;
    1290                 :    98514063 :   for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1291                 :             :     {
    1292                 :    97454772 :       reg_state[r].store_ruid = 0;
    1293                 :    97454772 :       reg_state[r].real_store_ruid = 0;
    1294                 :    97454772 :       if (fixed_regs[r])
    1295                 :    48221480 :         reg_state[r].use_index = -1;
    1296                 :             :       else
    1297                 :    49233292 :         reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
    1298                 :             :     }
    1299                 :             : 
    1300                 :   130402860 :   for (insn = get_last_insn (); insn; insn = prev)
    1301                 :             :     {
    1302                 :   129343569 :       bool control_flow_insn;
    1303                 :   129343569 :       rtx note;
    1304                 :             : 
    1305                 :   129343569 :       prev = PREV_INSN (insn);
    1306                 :             : 
    1307                 :             :       /* We cannot do our optimization across labels.  Invalidating all the use
    1308                 :             :          information we have would be costly, so we just note where the label
    1309                 :             :          is and then later disable any optimization that would cross it.  */
    1310                 :   129343569 :       if (LABEL_P (insn))
    1311                 :     5207879 :         last_label_ruid = reload_combine_ruid;
    1312                 :   124135690 :       else if (BARRIER_P (insn))
    1313                 :             :         {
    1314                 :             :           /* Crossing a barrier resets all the use information.  */
    1315                 :   279525450 :           for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1316                 :   276519800 :             if (! fixed_regs[r])
    1317                 :   134392307 :               reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
    1318                 :             :         }
    1319                 :   121130040 :       else if (INSN_P (insn) && volatile_insn_p (PATTERN (insn)))
    1320                 :             :         /* Optimizations across insns being marked as volatile must be
    1321                 :             :            prevented.  All the usage information is invalidated
    1322                 :             :            here.  */
    1323                 :    47382384 :         for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1324                 :    46872896 :           if (! fixed_regs[r]
    1325                 :    22271170 :               && reg_state[r].use_index != RELOAD_COMBINE_MAX_USES)
    1326                 :      664788 :             reg_state[r].use_index = -1;
    1327                 :             : 
    1328                 :   129343569 :       if (! NONDEBUG_INSN_P (insn))
    1329                 :    70151576 :         continue;
    1330                 :             : 
    1331                 :    59191993 :       reload_combine_ruid++;
    1332                 :             : 
    1333                 :    59191993 :       control_flow_insn = control_flow_insn_p (insn);
    1334                 :    59191993 :       if (control_flow_insn)
    1335                 :     8673458 :         last_jump_ruid = reload_combine_ruid;
    1336                 :             : 
    1337                 :    59191993 :       if (reload_combine_recognize_const_pattern (insn)
    1338                 :    59191993 :           || reload_combine_recognize_pattern (insn))
    1339                 :         751 :         continue;
    1340                 :             : 
    1341                 :    59191242 :       note_stores (insn, reload_combine_note_store, NULL);
    1342                 :             : 
    1343                 :    59191242 :       if (CALL_P (insn))
    1344                 :             :         {
    1345                 :     4720134 :           rtx link;
    1346                 :     4720134 :           HARD_REG_SET used_regs = insn_callee_abi (insn).full_reg_clobbers ();
    1347                 :             : 
    1348                 :   438972462 :           for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1349                 :   434252328 :             if (TEST_HARD_REG_BIT (used_regs, r))
    1350                 :             :               {
    1351                 :   385009402 :                 reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
    1352                 :   385009402 :                 reg_state[r].store_ruid = reload_combine_ruid;
    1353                 :             :               }
    1354                 :             : 
    1355                 :    13590529 :           for (link = CALL_INSN_FUNCTION_USAGE (insn); link;
    1356                 :     8870395 :                link = XEXP (link, 1))
    1357                 :             :             {
    1358                 :     8870395 :               rtx setuse = XEXP (link, 0);
    1359                 :     8870395 :               rtx usage_rtx = XEXP (setuse, 0);
    1360                 :             : 
    1361                 :     8870395 :               if (GET_CODE (setuse) == USE && REG_P (usage_rtx))
    1362                 :             :                 {
    1363                 :     8343646 :                   unsigned int end_regno = END_REGNO (usage_rtx);
    1364                 :    16739707 :                   for (unsigned int i = REGNO (usage_rtx); i < end_regno; ++i)
    1365                 :     8396061 :                     reg_state[i].use_index = -1;
    1366                 :             :                  }
    1367                 :             :              }
    1368                 :             :         }
    1369                 :             : 
    1370                 :    59191242 :       if (control_flow_insn && !ANY_RETURN_P (PATTERN (insn)))
    1371                 :             :         {
    1372                 :             :           /* Non-spill registers might be used at the call destination in
    1373                 :             :              some unknown fashion, so we have to mark the unknown use.  */
    1374                 :     8673458 :           HARD_REG_SET *live;
    1375                 :             : 
    1376                 :    10073745 :           if ((condjump_p (insn) || condjump_in_parallel_p (insn))
    1377                 :     8673540 :               && JUMP_LABEL (insn))
    1378                 :             :             {
    1379                 :     7273253 :               if (ANY_RETURN_P (JUMP_LABEL (insn)))
    1380                 :             :                 live = NULL;
    1381                 :             :               else
    1382                 :     7273253 :                 live = &LABEL_LIVE (JUMP_LABEL (insn));
    1383                 :             :             }
    1384                 :             :           else
    1385                 :             :             live = &ever_live_at_start;
    1386                 :             : 
    1387                 :     8673458 :           if (live)
    1388                 :   806631594 :             for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1389                 :   797958136 :               if (TEST_HARD_REG_BIT (*live, r))
    1390                 :    40891610 :                 reg_state[r].use_index = -1;
    1391                 :             :         }
    1392                 :             : 
    1393                 :    59191242 :       reload_combine_note_use (&PATTERN (insn), insn, reload_combine_ruid,
    1394                 :             :                                NULL_RTX);
    1395                 :             : 
    1396                 :    82846953 :       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    1397                 :             :         {
    1398                 :    23655711 :           if (REG_NOTE_KIND (note) == REG_INC && REG_P (XEXP (note, 0)))
    1399                 :             :             {
    1400                 :           0 :               int regno = REGNO (XEXP (note, 0));
    1401                 :           0 :               reg_state[regno].store_ruid = reload_combine_ruid;
    1402                 :           0 :               reg_state[regno].real_store_ruid = reload_combine_ruid;
    1403                 :           0 :               reg_state[regno].use_index = -1;
    1404                 :             :             }
    1405                 :             :         }
    1406                 :             :     }
    1407                 :             : 
    1408                 :     1059291 :   free (label_live);
    1409                 :             : }
    1410                 :             : 
    1411                 :             : /* Check if DST is a register or a subreg of a register; if it is,
    1412                 :             :    update store_ruid, real_store_ruid and use_index in the reg_state
    1413                 :             :    structure accordingly.  Called via note_stores from reload_combine.  */
    1414                 :             : 
    1415                 :             : static void
    1416                 :    63703781 : reload_combine_note_store (rtx dst, const_rtx set, void *data ATTRIBUTE_UNUSED)
    1417                 :             : {
    1418                 :    63703781 :   int regno = 0;
    1419                 :    63703781 :   int i;
    1420                 :    63703781 :   machine_mode mode = GET_MODE (dst);
    1421                 :             : 
    1422                 :    63703781 :   if (GET_CODE (dst) == SUBREG)
    1423                 :             :     {
    1424                 :        7110 :       regno = subreg_regno_offset (REGNO (SUBREG_REG (dst)),
    1425                 :        3555 :                                    GET_MODE (SUBREG_REG (dst)),
    1426                 :        3555 :                                    SUBREG_BYTE (dst),
    1427                 :             :                                    GET_MODE (dst));
    1428                 :        3555 :       dst = SUBREG_REG (dst);
    1429                 :             :     }
    1430                 :             : 
    1431                 :             :   /* Some targets do argument pushes without adding REG_INC notes.  */
    1432                 :             : 
    1433                 :    63703781 :   if (MEM_P (dst))
    1434                 :             :     {
    1435                 :    10254179 :       dst = XEXP (dst, 0);
    1436                 :    10254179 :       if (GET_CODE (dst) == PRE_INC || GET_CODE (dst) == POST_INC
    1437                 :    10254179 :           || GET_CODE (dst) == PRE_DEC || GET_CODE (dst) == POST_DEC
    1438                 :     8662477 :           || GET_CODE (dst) == PRE_MODIFY || GET_CODE (dst) == POST_MODIFY)
    1439                 :             :         {
    1440                 :     1675504 :           unsigned int end_regno = END_REGNO (XEXP (dst, 0));
    1441                 :     3351008 :           for (unsigned int i = REGNO (XEXP (dst, 0)); i < end_regno; ++i)
    1442                 :             :             {
    1443                 :             :               /* We could probably do better, but for now mark the register
    1444                 :             :                  as used in an unknown fashion and set/clobbered at this
    1445                 :             :                  insn.  */
    1446                 :     1675504 :               reg_state[i].use_index = -1;
    1447                 :     1675504 :               reg_state[i].store_ruid = reload_combine_ruid;
    1448                 :     1675504 :               reg_state[i].real_store_ruid = reload_combine_ruid;
    1449                 :             :             }
    1450                 :             :         }
    1451                 :             :       else
    1452                 :             :         return;
    1453                 :             :     }
    1454                 :             : 
    1455                 :    55125106 :   if (!REG_P (dst))
    1456                 :             :     return;
    1457                 :    46163590 :   regno += REGNO (dst);
    1458                 :             : 
    1459                 :             :   /* note_stores might have stripped a STRICT_LOW_PART, so we have to be
    1460                 :             :      careful with registers / register parts that are not full words.
    1461                 :             :      Similarly for ZERO_EXTRACT.  */
    1462                 :    46163590 :   if (GET_CODE (SET_DEST (set)) == ZERO_EXTRACT
    1463                 :    46162151 :       || GET_CODE (SET_DEST (set)) == STRICT_LOW_PART)
    1464                 :             :     {
    1465                 :       10524 :       for (i = end_hard_regno (mode, regno) - 1; i >= regno; i--)
    1466                 :             :         {
    1467                 :        5262 :           reg_state[i].use_index = -1;
    1468                 :        5262 :           reg_state[i].store_ruid = reload_combine_ruid;
    1469                 :        5262 :           reg_state[i].real_store_ruid = reload_combine_ruid;
    1470                 :             :         }
    1471                 :             :     }
    1472                 :             :   else
    1473                 :             :     {
    1474                 :    92920529 :       for (i = end_hard_regno (mode, regno) - 1; i >= regno; i--)
    1475                 :             :         {
    1476                 :    46762201 :           reg_state[i].store_ruid = reload_combine_ruid;
    1477                 :    46762201 :           if (GET_CODE (set) == SET)
    1478                 :    39109148 :             reg_state[i].real_store_ruid = reload_combine_ruid;
    1479                 :    46762201 :           reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
    1480                 :             :         }
    1481                 :             :     }
    1482                 :             : }
    1483                 :             : 
    1484                 :             : /* XP points to a piece of rtl that has to be checked for any uses of
    1485                 :             :    registers.
    1486                 :             :    *XP is the pattern of INSN, or a part of it.
    1487                 :             :    Called from reload_combine, and recursively by itself.  */
    1488                 :             : static void
    1489                 :   211475832 : reload_combine_note_use (rtx *xp, rtx_insn *insn, int ruid, rtx containing_mem)
    1490                 :             : {
    1491                 :   249970820 :   rtx x = *xp;
    1492                 :   249970820 :   enum rtx_code code = x->code;
    1493                 :   249970820 :   const char *fmt;
    1494                 :   249970820 :   int i, j;
    1495                 :   249970820 :   rtx offset = const0_rtx; /* For the REG case below.  */
    1496                 :             : 
    1497                 :   249970820 :   switch (code)
    1498                 :             :     {
    1499                 :    55946269 :     case SET:
    1500                 :    55946269 :       if (REG_P (SET_DEST (x)))
    1501                 :             :         {
    1502                 :    38494988 :           reload_combine_note_use (&SET_SRC (x), insn, ruid, NULL_RTX);
    1503                 :    38494988 :           return;
    1504                 :             :         }
    1505                 :             :       break;
    1506                 :             : 
    1507                 :      659203 :     case USE:
    1508                 :             :       /* If this is the USE of a return value, we can't change it.  */
    1509                 :      659203 :       if (REG_P (XEXP (x, 0)) && REG_FUNCTION_VALUE_P (XEXP (x, 0)))
    1510                 :             :         {
    1511                 :             :           /* Mark the return register as used in an unknown fashion.  */
    1512                 :      543104 :           rtx reg = XEXP (x, 0);
    1513                 :      543104 :           unsigned int end_regno = END_REGNO (reg);
    1514                 :     1114132 :           for (unsigned int regno = REGNO (reg); regno < end_regno; ++regno)
    1515                 :      571028 :             reg_state[regno].use_index = -1;
    1516                 :             :           return;
    1517                 :             :         }
    1518                 :             :       break;
    1519                 :             : 
    1520                 :     7336740 :     case CLOBBER:
    1521                 :     7336740 :       if (REG_P (SET_DEST (x)))
    1522                 :             :         {
    1523                 :             :           /* No spurious CLOBBERs of pseudo registers may remain.  */
    1524                 :     7229272 :           gcc_assert (REGNO (SET_DEST (x)) < FIRST_PSEUDO_REGISTER);
    1525                 :             :           return;
    1526                 :             :         }
    1527                 :             :       break;
    1528                 :             : 
    1529                 :    22499210 :     case PLUS:
    1530                 :             :       /* We are interested in (plus (reg) (const_int)) .  */
    1531                 :    22499210 :       if (!REG_P (XEXP (x, 0))
    1532                 :    19887708 :           || !CONST_INT_P (XEXP (x, 1)))
    1533                 :             :         break;
    1534                 :             :       offset = XEXP (x, 1);
    1535                 :             :       x = XEXP (x, 0);
    1536                 :             :       /* Fall through.  */
    1537                 :    57117716 :     case REG:
    1538                 :    57117716 :       {
    1539                 :    57117716 :         int regno = REGNO (x);
    1540                 :    57117716 :         int use_index;
    1541                 :    57117716 :         int nregs;
    1542                 :             : 
    1543                 :             :         /* No spurious USEs of pseudo registers may remain.  */
    1544                 :    57117716 :         gcc_assert (regno < FIRST_PSEUDO_REGISTER);
    1545                 :             : 
    1546                 :    57117716 :         nregs = REG_NREGS (x);
    1547                 :             : 
    1548                 :             :         /* We can't substitute into multi-hard-reg uses.  */
    1549                 :    57117716 :         if (nregs > 1)
    1550                 :             :           {
    1551                 :     1186887 :             while (--nregs >= 0)
    1552                 :      791258 :               reg_state[regno + nregs].use_index = -1;
    1553                 :             :             return;
    1554                 :             :           }
    1555                 :             : 
    1556                 :             :         /* We may be called to update uses in previously seen insns.
    1557                 :             :            Don't add uses beyond the last store we saw.  */
    1558                 :    56722087 :         if (ruid < reg_state[regno].store_ruid)
    1559                 :             :           return;
    1560                 :             : 
    1561                 :             :         /* If this register is already used in some unknown fashion, we
    1562                 :             :            can't do anything.
    1563                 :             :            If we decrement the index from zero to -1, we can't store more
    1564                 :             :            uses, so this register becomes used in an unknown fashion.  */
    1565                 :    56720116 :         use_index = --reg_state[regno].use_index;
    1566                 :    56720116 :         if (use_index < 0)
    1567                 :             :           return;
    1568                 :             : 
    1569                 :    34744066 :         if (use_index == RELOAD_COMBINE_MAX_USES - 1)
    1570                 :             :           {
    1571                 :             :             /* This is the first use of this register we have seen since we
    1572                 :             :                marked it as dead.  */
    1573                 :    26549796 :             reg_state[regno].offset = offset;
    1574                 :    26549796 :             reg_state[regno].all_offsets_match = true;
    1575                 :    26549796 :             reg_state[regno].use_ruid = ruid;
    1576                 :             :           }
    1577                 :             :         else
    1578                 :             :           {
    1579                 :     8194270 :             if (reg_state[regno].use_ruid > ruid)
    1580                 :         748 :               reg_state[regno].use_ruid = ruid;
    1581                 :             : 
    1582                 :     8194270 :             if (! rtx_equal_p (offset, reg_state[regno].offset))
    1583                 :     3886634 :               reg_state[regno].all_offsets_match = false;
    1584                 :             :           }
    1585                 :             : 
    1586                 :    34744066 :         reg_state[regno].reg_use[use_index].insn = insn;
    1587                 :    34744066 :         reg_state[regno].reg_use[use_index].ruid = ruid;
    1588                 :    34744066 :         reg_state[regno].reg_use[use_index].containing_mem = containing_mem;
    1589                 :    34744066 :         reg_state[regno].reg_use[use_index].usep = xp;
    1590                 :    34744066 :         return;
    1591                 :             :       }
    1592                 :             : 
    1593                 :             :     case MEM:
    1594                 :   146585740 :       containing_mem = x;
    1595                 :             :       break;
    1596                 :             : 
    1597                 :             :     default:
    1598                 :             :       break;
    1599                 :             :     }
    1600                 :             : 
    1601                 :             :   /* Recursively process the components of X.  */
    1602                 :   146585740 :   fmt = GET_RTX_FORMAT (code);
    1603                 :   374496080 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1604                 :             :     {
    1605                 :   227910340 :       if (fmt[i] == 'e')
    1606                 :   132853069 :         reload_combine_note_use (&XEXP (x, i), insn, ruid, containing_mem);
    1607                 :    95057271 :       else if (fmt[i] == 'E')
    1608                 :             :         {
    1609                 :    29098675 :           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1610                 :    19425131 :             reload_combine_note_use (&XVECEXP (x, i, j), insn, ruid,
    1611                 :             :                                      containing_mem);
    1612                 :             :         }
    1613                 :             :     }
    1614                 :             : }
    1615                 :             : 
    1616                 :             : /* See if we can reduce the cost of a constant by replacing a move
    1617                 :             :    with an add.  We track situations in which a register is set to a
    1618                 :             :    constant or to a register plus a constant.  */
    1619                 :             : /* We cannot do our optimization across labels.  Invalidating all the
    1620                 :             :    information about register contents we have would be costly, so we
    1621                 :             :    use move2add_last_label_luid to note where the label is and then
    1622                 :             :    later disable any optimization that would cross it.
    1623                 :             :    reg_offset[n] / reg_base_reg[n] / reg_symbol_ref[n] / reg_mode[n]
    1624                 :             :    are only valid if reg_set_luid[n] is greater than
    1625                 :             :    move2add_last_label_luid.
    1626                 :             :    For a set that established a new (potential) base register with
    1627                 :             :    non-constant value, we use move2add_luid from the place where the
    1628                 :             :    setting insn is encountered; registers based off that base then
    1629                 :             :    get the same reg_set_luid.  Constants all get
    1630                 :             :    move2add_last_label_luid + 1 as their reg_set_luid.  */
    1631                 :             : static int reg_set_luid[FIRST_PSEUDO_REGISTER];
    1632                 :             : 
    1633                 :             : /* If reg_base_reg[n] is negative, register n has been set to
    1634                 :             :    reg_offset[n] or reg_symbol_ref[n] + reg_offset[n] in mode reg_mode[n].
    1635                 :             :    If reg_base_reg[n] is non-negative, register n has been set to the
    1636                 :             :    sum of reg_offset[n] and the value of register reg_base_reg[n]
    1637                 :             :    before reg_set_luid[n], calculated in mode reg_mode[n] .
    1638                 :             :    For multi-hard-register registers, all but the first one are
    1639                 :             :    recorded as BLKmode in reg_mode.  Setting reg_mode to VOIDmode
    1640                 :             :    marks it as invalid.  */
    1641                 :             : static HOST_WIDE_INT reg_offset[FIRST_PSEUDO_REGISTER];
    1642                 :             : static int reg_base_reg[FIRST_PSEUDO_REGISTER];
    1643                 :             : static rtx reg_symbol_ref[FIRST_PSEUDO_REGISTER];
    1644                 :             : static machine_mode reg_mode[FIRST_PSEUDO_REGISTER];
    1645                 :             : 
    1646                 :             : /* move2add_luid is linearly increased while scanning the instructions
    1647                 :             :    from first to last.  It is used to set reg_set_luid in
    1648                 :             :    reload_cse_move2add and move2add_note_store.  */
    1649                 :             : static int move2add_luid;
    1650                 :             : 
    1651                 :             : /* move2add_last_label_luid is set whenever a label is found.  Labels
    1652                 :             :    invalidate all previously collected reg_offset data.  */
    1653                 :             : static int move2add_last_label_luid;
    1654                 :             : 
    1655                 :             : /* ??? We don't know how zero / sign extension is handled, hence we
    1656                 :             :    can't go from a narrower to a wider mode.  */
    1657                 :             : #define MODES_OK_FOR_MOVE2ADD(OUTMODE, INMODE) \
    1658                 :             :   (GET_MODE_SIZE (OUTMODE) == GET_MODE_SIZE (INMODE) \
    1659                 :             :    || (GET_MODE_SIZE (OUTMODE) <= GET_MODE_SIZE (INMODE) \
    1660                 :             :        && TRULY_NOOP_TRUNCATION_MODES_P (OUTMODE, INMODE)))
    1661                 :             : 
    1662                 :             : /* Record that REG is being set to a value with the mode of REG.  */
    1663                 :             : 
    1664                 :             : static void
    1665                 :    51770519 : move2add_record_mode (rtx reg)
    1666                 :             : {
    1667                 :    51770519 :   int regno, nregs;
    1668                 :    51770519 :   machine_mode mode = GET_MODE (reg);
    1669                 :             : 
    1670                 :    51770519 :   if (GET_CODE (reg) == SUBREG)
    1671                 :             :     {
    1672                 :        3516 :       regno = subreg_regno (reg);
    1673                 :        3516 :       nregs = subreg_nregs (reg);
    1674                 :             :     }
    1675                 :    51767003 :   else if (REG_P (reg))
    1676                 :             :     {
    1677                 :    51767003 :       regno = REGNO (reg);
    1678                 :    51767003 :       nregs = REG_NREGS (reg);
    1679                 :             :     }
    1680                 :             :   else
    1681                 :           0 :     gcc_unreachable ();
    1682                 :    52423864 :   for (int i = nregs - 1; i > 0; i--)
    1683                 :      653345 :     reg_mode[regno + i] = BLKmode;
    1684                 :    51770519 :   reg_mode[regno] = mode;
    1685                 :    51770519 : }
    1686                 :             : 
    1687                 :             : /* Record that REG is being set to the sum of SYM and OFF.  */
    1688                 :             : 
    1689                 :             : static void
    1690                 :     2171431 : move2add_record_sym_value (rtx reg, rtx sym, rtx off)
    1691                 :             : {
    1692                 :     2171431 :   int regno = REGNO (reg);
    1693                 :             : 
    1694                 :     2171431 :   move2add_record_mode (reg);
    1695                 :     2171431 :   reg_set_luid[regno] = move2add_luid;
    1696                 :     2171431 :   reg_base_reg[regno] = -1;
    1697                 :     2171431 :   reg_symbol_ref[regno] = sym;
    1698                 :     2171431 :   reg_offset[regno] = INTVAL (off);
    1699                 :     2171431 : }
    1700                 :             : 
    1701                 :             : /* Check if REGNO contains a valid value in MODE.  */
    1702                 :             : 
    1703                 :             : static bool
    1704                 :   217499765 : move2add_valid_value_p (int regno, scalar_int_mode mode)
    1705                 :             : {
    1706                 :   217499765 :   if (reg_set_luid[regno] <= move2add_last_label_luid)
    1707                 :             :     return false;
    1708                 :             : 
    1709                 :    20854280 :   if (mode != reg_mode[regno])
    1710                 :             :     {
    1711                 :    11006151 :       scalar_int_mode old_mode;
    1712                 :    11006151 :       if (!is_a <scalar_int_mode> (reg_mode[regno], &old_mode)
    1713                 :     7107636 :           || !MODES_OK_FOR_MOVE2ADD (mode, old_mode)
    1714                 :      527724 :           || !REG_CAN_CHANGE_MODE_P (regno, old_mode, mode))
    1715                 :    10478427 :         return false;
    1716                 :             :       /* The value loaded into regno in reg_mode[regno] is also valid in
    1717                 :             :          mode after truncation only if (REG:mode regno) is the lowpart of
    1718                 :             :          (REG:reg_mode[regno] regno).  Now, for big endian, the starting
    1719                 :             :          regno of the lowpart might be different.  */
    1720                 :      527724 :       poly_int64 s_off = subreg_lowpart_offset (mode, old_mode);
    1721                 :      527724 :       s_off = subreg_regno_offset (regno, old_mode, s_off, mode);
    1722                 :      527724 :       if (maybe_ne (s_off, 0))
    1723                 :             :         /* We could in principle adjust regno, check reg_mode[regno] to be
    1724                 :             :            BLKmode, and return s_off to the caller (vs. -1 for failure),
    1725                 :             :            but we currently have no callers that could make use of this
    1726                 :             :            information.  */
    1727                 :             :         return false;
    1728                 :             :     }
    1729                 :             : 
    1730                 :    10424683 :   for (int i = end_hard_regno (mode, regno) - 1; i > regno; i--)
    1731                 :       53622 :     if (reg_mode[i] != BLKmode)
    1732                 :             :       return false;
    1733                 :             :   return true;
    1734                 :             : }
    1735                 :             : 
    1736                 :             : /* This function is called with INSN that sets REG (of mode MODE)
    1737                 :             :    to (SYM + OFF), while REG is known to already have value (SYM + offset).
    1738                 :             :    This function tries to change INSN into an add instruction
    1739                 :             :    (set (REG) (plus (REG) (OFF - offset))) using the known value.
    1740                 :             :    It also updates the information about REG's known value.
    1741                 :             :    Return true if we made a change.  */
    1742                 :             : 
    1743                 :             : static bool
    1744                 :      148608 : move2add_use_add2_insn (scalar_int_mode mode, rtx reg, rtx sym, rtx off,
    1745                 :             :                         rtx_insn *insn)
    1746                 :             : {
    1747                 :      148608 :   rtx set = single_set (insn);
    1748                 :      148608 :   rtx src = SET_SRC (set);
    1749                 :      148608 :   int regno = REGNO (reg);
    1750                 :      148608 :   rtx new_src = gen_int_mode (UINTVAL (off) - reg_offset[regno], mode);
    1751                 :      148608 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
    1752                 :      148608 :   bool changed = false;
    1753                 :             : 
    1754                 :             :   /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
    1755                 :             :      use (set (reg) (reg)) instead.
    1756                 :             :      We don't delete this insn, nor do we convert it into a
    1757                 :             :      note, to avoid losing register notes or the return
    1758                 :             :      value flag.  jump2 already knows how to get rid of
    1759                 :             :      no-op moves.  */
    1760                 :      148608 :   if (new_src == const0_rtx)
    1761                 :             :     {
    1762                 :             :       /* If the constants are different, this is a
    1763                 :             :          truncation, that, if turned into (set (reg)
    1764                 :             :          (reg)), would be discarded.  Maybe we should
    1765                 :             :          try a truncMN pattern?  */
    1766                 :       16749 :       if (INTVAL (off) == reg_offset [regno])
    1767                 :       15231 :         changed = validate_change (insn, &SET_SRC (set), reg, 0);
    1768                 :             :     }
    1769                 :             :   else
    1770                 :             :     {
    1771                 :      131859 :       struct full_rtx_costs oldcst, newcst;
    1772                 :      131859 :       rtx tem = gen_rtx_PLUS (mode, reg, new_src);
    1773                 :             : 
    1774                 :      131859 :       get_full_set_rtx_cost (set, &oldcst);
    1775                 :      131859 :       SET_SRC (set) = tem;
    1776                 :      131859 :       get_full_set_rtx_cost (set, &newcst);
    1777                 :      131859 :       SET_SRC (set) = src;
    1778                 :             : 
    1779                 :      131859 :       if (costs_lt_p (&newcst, &oldcst, speed)
    1780                 :      131859 :           && have_add2_insn (reg, new_src))
    1781                 :        2715 :         changed = validate_change (insn, &SET_SRC (set), tem, 0);
    1782                 :      129144 :       else if (sym == NULL_RTX && mode != BImode)
    1783                 :             :         {
    1784                 :      127485 :           scalar_int_mode narrow_mode;
    1785                 :      430330 :           FOR_EACH_MODE_UNTIL (narrow_mode, mode)
    1786                 :             :             {
    1787                 :      302845 :               if (have_insn_for (STRICT_LOW_PART, narrow_mode)
    1788                 :      302845 :                   && ((reg_offset[regno] & ~GET_MODE_MASK (narrow_mode))
    1789                 :      225207 :                       == (INTVAL (off) & ~GET_MODE_MASK (narrow_mode))))
    1790                 :             :                 {
    1791                 :      115868 :                   rtx narrow_reg = gen_lowpart_common (narrow_mode, reg);
    1792                 :      115868 :                   rtx narrow_src = gen_int_mode (INTVAL (off),
    1793                 :             :                                                  narrow_mode);
    1794                 :      115868 :                   rtx new_set
    1795                 :      115868 :                     = gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode,
    1796                 :             :                                                             narrow_reg),
    1797                 :             :                                    narrow_src);
    1798                 :      115868 :                   get_full_set_rtx_cost (new_set, &newcst);
    1799                 :             : 
    1800                 :             :                   /* We perform this replacement only if NEXT is either a
    1801                 :             :                      naked SET, or else its single_set is the first element
    1802                 :             :                      in a PARALLEL.  */
    1803                 :      115868 :                   rtx *setloc = GET_CODE (PATTERN (insn)) == PARALLEL
    1804                 :      115868 :                     ? &XVECEXP (PATTERN (insn), 0, 0) : &PATTERN (insn);
    1805                 :      115868 :                   if (*setloc == set && costs_lt_p (&newcst, &oldcst, speed))
    1806                 :             :                     {
    1807                 :           0 :                       changed = validate_change (insn, setloc, new_set, 0);
    1808                 :           0 :                       if (changed)
    1809                 :             :                         break;
    1810                 :             :                     }
    1811                 :             :                 }
    1812                 :             :             }
    1813                 :             :         }
    1814                 :             :     }
    1815                 :      148608 :   move2add_record_sym_value (reg, sym, off);
    1816                 :      148608 :   return changed;
    1817                 :             : }
    1818                 :             : 
    1819                 :             : 
    1820                 :             : /* This function is called with INSN that sets REG (of mode MODE) to
    1821                 :             :    (SYM + OFF), but REG doesn't have known value (SYM + offset).  This
    1822                 :             :    function tries to find another register which is known to already have
    1823                 :             :    value (SYM + offset) and change INSN into an add instruction
    1824                 :             :    (set (REG) (plus (the found register) (OFF - offset))) if such
    1825                 :             :    a register is found.  It also updates the information about
    1826                 :             :    REG's known value.
    1827                 :             :    Return true iff we made a change.  */
    1828                 :             : 
    1829                 :             : static bool
    1830                 :     1944090 : move2add_use_add3_insn (scalar_int_mode mode, rtx reg, rtx sym, rtx off,
    1831                 :             :                         rtx_insn *insn)
    1832                 :             : {
    1833                 :     1944090 :   rtx set = single_set (insn);
    1834                 :     1944090 :   rtx src = SET_SRC (set);
    1835                 :     1944090 :   int regno = REGNO (reg);
    1836                 :     1944090 :   int min_regno = 0;
    1837                 :     1944090 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
    1838                 :     1944090 :   int i;
    1839                 :     1944090 :   bool changed = false;
    1840                 :     1944090 :   struct full_rtx_costs oldcst, newcst, mincst;
    1841                 :     1944090 :   rtx plus_expr;
    1842                 :             : 
    1843                 :     1944090 :   init_costs_to_max (&mincst);
    1844                 :     1944090 :   get_full_set_rtx_cost (set, &oldcst);
    1845                 :             : 
    1846                 :     1944090 :   plus_expr = gen_rtx_PLUS (GET_MODE (reg), reg, const0_rtx);
    1847                 :     1944090 :   SET_SRC (set) = plus_expr;
    1848                 :             : 
    1849                 :   180799711 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    1850                 :   178855631 :     if (move2add_valid_value_p (i, mode)
    1851                 :     3579562 :         && reg_base_reg[i] < 0
    1852                 :     1506541 :         && reg_symbol_ref[i] != NULL_RTX
    1853                 :   179817725 :         && rtx_equal_p (sym, reg_symbol_ref[i]))
    1854                 :             :       {
    1855                 :      167406 :         rtx new_src = gen_int_mode (UINTVAL (off) - reg_offset[i],
    1856                 :       83703 :                                     GET_MODE (reg));
    1857                 :             :         /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
    1858                 :             :            use (set (reg) (reg)) instead.
    1859                 :             :            We don't delete this insn, nor do we convert it into a
    1860                 :             :            note, to avoid losing register notes or the return
    1861                 :             :            value flag.  jump2 already knows how to get rid of
    1862                 :             :            no-op moves.  */
    1863                 :       83703 :         if (new_src == const0_rtx)
    1864                 :             :           {
    1865                 :          10 :             init_costs_to_zero (&mincst);
    1866                 :          10 :             min_regno = i;
    1867                 :          10 :             break;
    1868                 :             :           }
    1869                 :             :         else
    1870                 :             :           {
    1871                 :       83693 :             XEXP (plus_expr, 1) = new_src;
    1872                 :       83693 :             get_full_set_rtx_cost (set, &newcst);
    1873                 :             : 
    1874                 :       83693 :             if (costs_lt_p (&newcst, &mincst, speed))
    1875                 :             :               {
    1876                 :       83158 :                 mincst = newcst;
    1877                 :       83158 :                 min_regno = i;
    1878                 :             :               }
    1879                 :             :           }
    1880                 :             :       }
    1881                 :     1944090 :   SET_SRC (set) = src;
    1882                 :             : 
    1883                 :     1944090 :   if (costs_lt_p (&mincst, &oldcst, speed))
    1884                 :             :     {
    1885                 :          36 :       rtx tem;
    1886                 :             : 
    1887                 :          36 :       tem = gen_rtx_REG (GET_MODE (reg), min_regno);
    1888                 :          36 :       if (i != min_regno)
    1889                 :             :         {
    1890                 :          52 :           rtx new_src = gen_int_mode (UINTVAL (off) - reg_offset[min_regno],
    1891                 :          26 :                                       GET_MODE (reg));
    1892                 :          26 :           tem = gen_rtx_PLUS (GET_MODE (reg), tem, new_src);
    1893                 :             :         }
    1894                 :          36 :       if (validate_change (insn, &SET_SRC (set), tem, 0))
    1895                 :     1944090 :         changed = true;
    1896                 :             :     }
    1897                 :     1944090 :   reg_set_luid[regno] = move2add_luid;
    1898                 :     1944090 :   move2add_record_sym_value (reg, sym, off);
    1899                 :     1944090 :   return changed;
    1900                 :             : }
    1901                 :             : 
    1902                 :             : /* Perform any invalidations necessary for INSN.  */
    1903                 :             : 
    1904                 :             : static void
    1905                 :    94021346 : reload_cse_move2add_invalidate (rtx_insn *insn)
    1906                 :             : {
    1907                 :   116335084 :   for (rtx note = REG_NOTES (insn); note; note = XEXP (note, 1))
    1908                 :             :     {
    1909                 :    22313738 :       if (REG_NOTE_KIND (note) == REG_INC
    1910                 :           0 :           && REG_P (XEXP (note, 0)))
    1911                 :             :         {
    1912                 :             :           /* Reset the information about this register.  */
    1913                 :           0 :           int regno = REGNO (XEXP (note, 0));
    1914                 :           0 :           if (regno < FIRST_PSEUDO_REGISTER)
    1915                 :             :             {
    1916                 :           0 :               move2add_record_mode (XEXP (note, 0));
    1917                 :           0 :               reg_mode[regno] = VOIDmode;
    1918                 :             :             }
    1919                 :             :         }
    1920                 :             :     }
    1921                 :             : 
    1922                 :             :   /* There are no REG_INC notes for SP autoinc.  */
    1923                 :    94021346 :   subrtx_var_iterator::array_type array;
    1924                 :   492570505 :   FOR_EACH_SUBRTX_VAR (iter, array, PATTERN (insn), NONCONST)
    1925                 :             :     {
    1926                 :   398549159 :       rtx mem = *iter;
    1927                 :   398549159 :       if (mem
    1928                 :   398549159 :           && MEM_P (mem)
    1929                 :    26945072 :           && GET_RTX_CLASS (GET_CODE (XEXP (mem, 0))) == RTX_AUTOINC)
    1930                 :             :         {
    1931                 :     1642351 :           if (XEXP (XEXP (mem, 0), 0) == stack_pointer_rtx)
    1932                 :     1642351 :             reg_mode[STACK_POINTER_REGNUM] = VOIDmode;
    1933                 :             :         }
    1934                 :             :     }
    1935                 :             : 
    1936                 :    94021346 :   note_stores (insn, move2add_note_store, insn);
    1937                 :             : 
    1938                 :             :   /* If INSN is a conditional branch, we try to extract an
    1939                 :             :      implicit set out of it.  */
    1940                 :    94021346 :   if (any_condjump_p (insn))
    1941                 :             :     {
    1942                 :     4805956 :       rtx cnd = fis_get_condition (insn);
    1943                 :             : 
    1944                 :     4805956 :       if (cnd != NULL_RTX
    1945                 :     4359025 :           && GET_CODE (cnd) == NE
    1946                 :     2171400 :           && REG_P (XEXP (cnd, 0))
    1947                 :     1328350 :           && !reg_set_p (XEXP (cnd, 0), insn)
    1948                 :             :           /* The following two checks, which are also in
    1949                 :             :              move2add_note_store, are intended to reduce the
    1950                 :             :              number of calls to gen_rtx_SET to avoid memory
    1951                 :             :              allocation if possible.  */
    1952                 :     1328350 :           && SCALAR_INT_MODE_P (GET_MODE (XEXP (cnd, 0)))
    1953                 :     1328349 :           && REG_NREGS (XEXP (cnd, 0)) == 1
    1954                 :     6134305 :           && CONST_INT_P (XEXP (cnd, 1)))
    1955                 :             :         {
    1956                 :      890816 :           rtx implicit_set = gen_rtx_SET (XEXP (cnd, 0), XEXP (cnd, 1));
    1957                 :      890816 :           move2add_note_store (SET_DEST (implicit_set), implicit_set, insn);
    1958                 :             :         }
    1959                 :             :     }
    1960                 :             : 
    1961                 :             :   /* If this is a CALL_INSN, all call used registers are stored with
    1962                 :             :      unknown values.  */
    1963                 :    94021346 :   if (CALL_P (insn))
    1964                 :             :     {
    1965                 :     4527631 :       function_abi callee_abi = insn_callee_abi (insn);
    1966                 :   421069683 :       for (int i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--)
    1967                 :   416542052 :         if (reg_mode[i] != VOIDmode
    1968                 :    20287268 :             && reg_mode[i] != BLKmode
    1969                 :   436256479 :             && callee_abi.clobbers_reg_p (reg_mode[i], i))
    1970                 :             :             /* Reset the information about this register.  */
    1971                 :     7712248 :           reg_mode[i] = VOIDmode;
    1972                 :             :     }
    1973                 :    94021346 : }
    1974                 :             : 
    1975                 :             : /* Convert move insns with constant inputs to additions if they are cheaper.
    1976                 :             :    Return true if any changes were made.  */
    1977                 :             : static bool
    1978                 :     1051273 : reload_cse_move2add (rtx_insn *first)
    1979                 :             : {
    1980                 :     1051273 :   int i;
    1981                 :     1051273 :   rtx_insn *insn;
    1982                 :     1051273 :   bool changed = false;
    1983                 :             : 
    1984                 :    97768389 :   for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--)
    1985                 :             :     {
    1986                 :    96717116 :       reg_set_luid[i] = 0;
    1987                 :    96717116 :       reg_offset[i] = 0;
    1988                 :    96717116 :       reg_base_reg[i] = 0;
    1989                 :    96717116 :       reg_symbol_ref[i] = NULL_RTX;
    1990                 :    96717116 :       reg_mode[i] = VOIDmode;
    1991                 :             :     }
    1992                 :             : 
    1993                 :     1051273 :   move2add_last_label_luid = 0;
    1994                 :     1051273 :   move2add_luid = 2;
    1995                 :   124451392 :   for (insn = first; insn; insn = NEXT_INSN (insn), move2add_luid++)
    1996                 :             :     {
    1997                 :   123400119 :       rtx set;
    1998                 :             : 
    1999                 :   123400119 :       if (LABEL_P (insn))
    2000                 :             :         {
    2001                 :     4975037 :           move2add_last_label_luid = move2add_luid;
    2002                 :             :           /* We're going to increment move2add_luid twice after a
    2003                 :             :              label, so that we can use move2add_last_label_luid + 1 as
    2004                 :             :              the luid for constants.  */
    2005                 :     4975037 :           move2add_luid++;
    2006                 :   128375156 :           continue;
    2007                 :             :         }
    2008                 :   118425082 :       if (! INSN_P (insn))
    2009                 :    22311038 :         continue;
    2010                 :    96114044 :       set = single_set (insn);
    2011                 :             :       /* For simplicity, we only perform this optimization on
    2012                 :             :          single-sets.  */
    2013                 :    96114044 :       scalar_int_mode mode;
    2014                 :    96114044 :       if (set
    2015                 :    52473776 :           && REG_P (SET_DEST (set))
    2016                 :   132054269 :           && is_a <scalar_int_mode> (GET_MODE (SET_DEST (set)), &mode))
    2017                 :             :         {
    2018                 :    26526521 :           rtx reg = SET_DEST (set);
    2019                 :    26526521 :           int regno = REGNO (reg);
    2020                 :    26526521 :           rtx src = SET_SRC (set);
    2021                 :             : 
    2022                 :             :           /* Check if we have valid information on the contents of this
    2023                 :             :              register in the mode of REG.  */
    2024                 :    26526521 :           if (move2add_valid_value_p (regno, mode)
    2025                 :    26526521 :               && dbg_cnt (cse2_move2add))
    2026                 :             :             {
    2027                 :             :               /* Try to transform (set (REGX) (CONST_INT A))
    2028                 :             :                                   ...
    2029                 :             :                                   (set (REGX) (CONST_INT B))
    2030                 :             :                  to
    2031                 :             :                                   (set (REGX) (CONST_INT A))
    2032                 :             :                                   ...
    2033                 :             :                                   (set (REGX) (plus (REGX) (CONST_INT B-A)))
    2034                 :             :                  or
    2035                 :             :                                   (set (REGX) (CONST_INT A))
    2036                 :             :                                   ...
    2037                 :             :                                   (set (STRICT_LOW_PART (REGX)) (CONST_INT B))
    2038                 :             :               */
    2039                 :             : 
    2040                 :     3826950 :               if (CONST_INT_P (src)
    2041                 :      368493 :                   && reg_base_reg[regno] < 0
    2042                 :      153233 :                   && reg_symbol_ref[regno] == NULL_RTX)
    2043                 :             :                 {
    2044                 :      146634 :                   changed |= move2add_use_add2_insn (mode, reg, NULL_RTX,
    2045                 :             :                                                      src, insn);
    2046                 :      146634 :                   continue;
    2047                 :             :                 }
    2048                 :             : 
    2049                 :             :               /* Try to transform (set (REGX) (REGY))
    2050                 :             :                                   (set (REGX) (PLUS (REGX) (CONST_INT A)))
    2051                 :             :                                   ...
    2052                 :             :                                   (set (REGX) (REGY))
    2053                 :             :                                   (set (REGX) (PLUS (REGX) (CONST_INT B)))
    2054                 :             :                  to
    2055                 :             :                                   (set (REGX) (REGY))
    2056                 :             :                                   (set (REGX) (PLUS (REGX) (CONST_INT A)))
    2057                 :             :                                   ...
    2058                 :             :                                   (set (REGX) (plus (REGX) (CONST_INT B-A)))  */
    2059                 :     3680316 :               else if (REG_P (src)
    2060                 :      459240 :                        && reg_set_luid[regno] == reg_set_luid[REGNO (src)]
    2061                 :      110372 :                        && reg_base_reg[regno] == reg_base_reg[REGNO (src)]
    2062                 :     3790688 :                        && move2add_valid_value_p (REGNO (src), mode))
    2063                 :             :                 {
    2064                 :       84715 :                   rtx_insn *next = next_nonnote_nondebug_insn (insn);
    2065                 :       84715 :                   rtx set = NULL_RTX;
    2066                 :       84715 :                   if (next)
    2067                 :       84701 :                     set = single_set (next);
    2068                 :       84701 :                   if (set
    2069                 :       65081 :                       && SET_DEST (set) == reg
    2070                 :        5107 :                       && GET_CODE (SET_SRC (set)) == PLUS
    2071                 :         647 :                       && XEXP (SET_SRC (set), 0) == reg
    2072                 :         647 :                       && CONST_INT_P (XEXP (SET_SRC (set), 1)))
    2073                 :             :                     {
    2074                 :         404 :                       rtx src3 = XEXP (SET_SRC (set), 1);
    2075                 :         404 :                       unsigned HOST_WIDE_INT added_offset = UINTVAL (src3);
    2076                 :         404 :                       HOST_WIDE_INT base_offset = reg_offset[REGNO (src)];
    2077                 :         404 :                       HOST_WIDE_INT regno_offset = reg_offset[regno];
    2078                 :         404 :                       rtx new_src =
    2079                 :         808 :                         gen_int_mode (added_offset
    2080                 :         404 :                                       + base_offset
    2081                 :         404 :                                       - regno_offset,
    2082                 :             :                                       mode);
    2083                 :         404 :                       bool success = false;
    2084                 :         404 :                       bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
    2085                 :             : 
    2086                 :         404 :                       if (new_src == const0_rtx)
    2087                 :             :                         /* See above why we create (set (reg) (reg)) here.  */
    2088                 :          28 :                         success
    2089                 :          28 :                           = validate_change (next, &SET_SRC (set), reg, 0);
    2090                 :             :                       else
    2091                 :             :                         {
    2092                 :         376 :                           rtx old_src = SET_SRC (set);
    2093                 :         376 :                           struct full_rtx_costs oldcst, newcst;
    2094                 :         376 :                           rtx tem = gen_rtx_PLUS (mode, reg, new_src);
    2095                 :             : 
    2096                 :         376 :                           get_full_set_rtx_cost (set, &oldcst);
    2097                 :         376 :                           SET_SRC (set) = tem;
    2098                 :         376 :                           get_full_set_src_cost (tem, mode, &newcst);
    2099                 :         376 :                           SET_SRC (set) = old_src;
    2100                 :         376 :                           costs_add_n_insns (&oldcst, 1);
    2101                 :             : 
    2102                 :         376 :                           rtx *setloc = GET_CODE (PATTERN (next)) == PARALLEL
    2103                 :         376 :                             ? &XVECEXP (PATTERN (next), 0, 0) : &PATTERN (next);
    2104                 :         376 :                           if (*setloc == set
    2105                 :         376 :                               && costs_lt_p (&newcst, &oldcst, speed)
    2106                 :         752 :                               && have_add2_insn (reg, new_src))
    2107                 :             :                             {
    2108                 :         376 :                               rtx newpat = gen_rtx_SET (reg, tem);
    2109                 :         376 :                               success
    2110                 :         376 :                                 = validate_change (next, setloc, newpat, 0);
    2111                 :             :                             }
    2112                 :             :                         }
    2113                 :         404 :                       if (success)
    2114                 :         404 :                         delete_insn (insn);
    2115                 :         404 :                       changed |= success;
    2116                 :         404 :                       insn = next;
    2117                 :             :                       /* Make sure to perform any invalidations related to
    2118                 :             :                          NEXT/INSN since we're going to bypass the normal
    2119                 :             :                          flow with the continue below.
    2120                 :             : 
    2121                 :             :                          Do this before recording the new mode/offset.  */
    2122                 :         404 :                       reload_cse_move2add_invalidate (insn);
    2123                 :         404 :                       move2add_record_mode (reg);
    2124                 :         404 :                       reg_offset[regno]
    2125                 :         404 :                         = trunc_int_for_mode (added_offset + base_offset,
    2126                 :             :                                               mode);
    2127                 :         404 :                       continue;
    2128                 :         404 :                     }
    2129                 :             :                 }
    2130                 :             :             }
    2131                 :             : 
    2132                 :             :           /* Try to transform
    2133                 :             :              (set (REGX) (CONST (PLUS (SYMBOL_REF) (CONST_INT A))))
    2134                 :             :              ...
    2135                 :             :              (set (REGY) (CONST (PLUS (SYMBOL_REF) (CONST_INT B))))
    2136                 :             :              to
    2137                 :             :              (set (REGX) (CONST (PLUS (SYMBOL_REF) (CONST_INT A))))
    2138                 :             :              ...
    2139                 :             :              (set (REGY) (CONST (PLUS (REGX) (CONST_INT B-A))))  */
    2140                 :    26379483 :           if ((GET_CODE (src) == SYMBOL_REF
    2141                 :    24608533 :                || (GET_CODE (src) == CONST
    2142                 :      175321 :                    && GET_CODE (XEXP (src, 0)) == PLUS
    2143                 :      175133 :                    && GET_CODE (XEXP (XEXP (src, 0), 0)) == SYMBOL_REF
    2144                 :      175114 :                    && CONST_INT_P (XEXP (XEXP (src, 0), 1))))
    2145                 :    26554597 :               && dbg_cnt (cse2_move2add))
    2146                 :             :             {
    2147                 :     1946064 :               rtx sym, off;
    2148                 :             : 
    2149                 :     1946064 :               if (GET_CODE (src) == SYMBOL_REF)
    2150                 :             :                 {
    2151                 :     1770950 :                   sym = src;
    2152                 :     1770950 :                   off = const0_rtx;
    2153                 :             :                 }
    2154                 :             :               else
    2155                 :             :                 {
    2156                 :      175114 :                   sym = XEXP (XEXP (src, 0), 0);
    2157                 :      175114 :                   off = XEXP (XEXP (src, 0), 1);
    2158                 :             :                 }
    2159                 :             : 
    2160                 :             :               /* If the reg already contains the value which is sum of
    2161                 :             :                  sym and some constant value, we can use an add2 insn.  */
    2162                 :     1946064 :               if (move2add_valid_value_p (regno, mode)
    2163                 :      224753 :                   && reg_base_reg[regno] < 0
    2164                 :      162015 :                   && reg_symbol_ref[regno] != NULL_RTX
    2165                 :     1999954 :                   && rtx_equal_p (sym, reg_symbol_ref[regno]))
    2166                 :        1974 :                 changed |= move2add_use_add2_insn (mode, reg, sym, off, insn);
    2167                 :             : 
    2168                 :             :               /* Otherwise, we have to find a register whose value is sum
    2169                 :             :                  of sym and some constant value.  */
    2170                 :             :               else
    2171                 :     1944090 :                 changed |= move2add_use_add3_insn (mode, reg, sym, off, insn);
    2172                 :             : 
    2173                 :     1946064 :               continue;
    2174                 :     1946064 :             }
    2175                 :             :         }
    2176                 :    94020942 :       reload_cse_move2add_invalidate (insn);
    2177                 :             :     }
    2178                 :     1051273 :   return changed;
    2179                 :             : }
    2180                 :             : 
    2181                 :             : /* SET is a SET or CLOBBER that sets DST.  DATA is the insn which
    2182                 :             :    contains SET.
    2183                 :             :    Update reg_set_luid, reg_offset and reg_base_reg accordingly.
    2184                 :             :    Called from reload_cse_move2add via note_stores.  */
    2185                 :             : 
    2186                 :             : static void
    2187                 :    59562514 : move2add_note_store (rtx dst, const_rtx set, void *data)
    2188                 :             : {
    2189                 :    59562514 :   rtx_insn *insn = (rtx_insn *) data;
    2190                 :    59562514 :   unsigned int regno = 0;
    2191                 :    59562514 :   scalar_int_mode mode;
    2192                 :             : 
    2193                 :    59562514 :   if (GET_CODE (dst) == SUBREG)
    2194                 :        3516 :     regno = subreg_regno (dst);
    2195                 :    59558998 :   else if (REG_P (dst))
    2196                 :    42848167 :     regno = REGNO (dst);
    2197                 :             :   else
    2198                 :    59562514 :     return;
    2199                 :             : 
    2200                 :    42851683 :   if (!is_a <scalar_int_mode> (GET_MODE (dst), &mode))
    2201                 :    16394229 :     goto invalidate;
    2202                 :             : 
    2203                 :    26457454 :   if (GET_CODE (set) == SET)
    2204                 :             :     {
    2205                 :    25907642 :       rtx note, sym = NULL_RTX;
    2206                 :    25907642 :       rtx off;
    2207                 :             : 
    2208                 :    25907642 :       note = find_reg_equal_equiv_note (insn);
    2209                 :    25907642 :       if (note && GET_CODE (XEXP (note, 0)) == SYMBOL_REF)
    2210                 :             :         {
    2211                 :       68599 :           sym = XEXP (note, 0);
    2212                 :       68599 :           off = const0_rtx;
    2213                 :             :         }
    2214                 :     4146400 :       else if (note && GET_CODE (XEXP (note, 0)) == CONST
    2215                 :       10328 :                && GET_CODE (XEXP (XEXP (note, 0), 0)) == PLUS
    2216                 :       10153 :                && GET_CODE (XEXP (XEXP (XEXP (note, 0), 0), 0)) == SYMBOL_REF
    2217                 :       10134 :                && CONST_INT_P (XEXP (XEXP (XEXP (note, 0), 0), 1)))
    2218                 :             :         {
    2219                 :             :           sym = XEXP (XEXP (XEXP (note, 0), 0), 0);
    2220                 :             :           off = XEXP (XEXP (XEXP (note, 0), 0), 1);
    2221                 :             :         }
    2222                 :             : 
    2223                 :       78733 :       if (sym != NULL_RTX)
    2224                 :             :         {
    2225                 :       78733 :           move2add_record_sym_value (dst, sym, off);
    2226                 :       78733 :           return;
    2227                 :             :         }
    2228                 :             :     }
    2229                 :             : 
    2230                 :    26378721 :   if (GET_CODE (set) == SET
    2231                 :    25828909 :       && GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
    2232                 :    25827555 :       && GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
    2233                 :             :     {
    2234                 :    25823947 :       rtx src = SET_SRC (set);
    2235                 :    25823947 :       rtx base_reg;
    2236                 :    25823947 :       unsigned HOST_WIDE_INT offset;
    2237                 :    25823947 :       int base_regno;
    2238                 :             : 
    2239                 :    25823947 :       switch (GET_CODE (src))
    2240                 :             :         {
    2241                 :     5815519 :         case PLUS:
    2242                 :     5815519 :           if (REG_P (XEXP (src, 0)))
    2243                 :             :             {
    2244                 :     5526363 :               base_reg = XEXP (src, 0);
    2245                 :             : 
    2246                 :     5526363 :               if (CONST_INT_P (XEXP (src, 1)))
    2247                 :     4805003 :                 offset = UINTVAL (XEXP (src, 1));
    2248                 :      721360 :               else if (REG_P (XEXP (src, 1))
    2249                 :      721360 :                        && move2add_valid_value_p (REGNO (XEXP (src, 1)), mode))
    2250                 :             :                 {
    2251                 :       85168 :                   if (reg_base_reg[REGNO (XEXP (src, 1))] < 0
    2252                 :       85168 :                       && reg_symbol_ref[REGNO (XEXP (src, 1))] == NULL_RTX)
    2253                 :       13473 :                     offset = reg_offset[REGNO (XEXP (src, 1))];
    2254                 :             :                   /* Maybe the first register is known to be a
    2255                 :             :                      constant.  */
    2256                 :       71695 :                   else if (move2add_valid_value_p (REGNO (base_reg), mode)
    2257                 :       18051 :                            && reg_base_reg[REGNO (base_reg)] < 0
    2258                 :       72510 :                            && reg_symbol_ref[REGNO (base_reg)] == NULL_RTX)
    2259                 :             :                     {
    2260                 :         677 :                       offset = reg_offset[REGNO (base_reg)];
    2261                 :         677 :                       base_reg = XEXP (src, 1);
    2262                 :             :                     }
    2263                 :             :                   else
    2264                 :       71018 :                     goto invalidate;
    2265                 :             :                 }
    2266                 :             :               else
    2267                 :      636192 :                 goto invalidate;
    2268                 :             : 
    2269                 :             :               break;
    2270                 :             :             }
    2271                 :             : 
    2272                 :      289156 :           goto invalidate;
    2273                 :             : 
    2274                 :             :         case REG:
    2275                 :             :           base_reg = src;
    2276                 :             :           offset = 0;
    2277                 :             :           break;
    2278                 :             : 
    2279                 :     4292071 :         case CONST_INT:
    2280                 :             :           /* Start tracking the register as a constant.  */
    2281                 :     4292071 :           reg_base_reg[regno] = -1;
    2282                 :     4292071 :           reg_symbol_ref[regno] = NULL_RTX;
    2283                 :     4292071 :           reg_offset[regno] = INTVAL (SET_SRC (set));
    2284                 :             :           /* We assign the same luid to all registers set to constants.  */
    2285                 :     4292071 :           reg_set_luid[regno] = move2add_last_label_luid + 1;
    2286                 :     4292071 :           move2add_record_mode (dst);
    2287                 :     4292071 :           return;
    2288                 :             : 
    2289                 :    11157914 :         default:
    2290                 :    11157914 :           goto invalidate;
    2291                 :             :         }
    2292                 :             : 
    2293                 :     9377596 :       base_regno = REGNO (base_reg);
    2294                 :             :       /* If information about the base register is not valid, set it
    2295                 :             :          up as a new base register, pretending its value is known
    2296                 :             :          starting from the current insn.  */
    2297                 :     9377596 :       if (!move2add_valid_value_p (base_regno, mode))
    2298                 :             :         {
    2299                 :     6825734 :           reg_base_reg[base_regno] = base_regno;
    2300                 :     6825734 :           reg_symbol_ref[base_regno] = NULL_RTX;
    2301                 :     6825734 :           reg_offset[base_regno] = 0;
    2302                 :     6825734 :           reg_set_luid[base_regno] = move2add_luid;
    2303                 :     6825734 :           gcc_assert (GET_MODE (base_reg) == mode);
    2304                 :     6825734 :           move2add_record_mode (base_reg);
    2305                 :             :         }
    2306                 :             : 
    2307                 :             :       /* Copy base information from our base register.  */
    2308                 :     9377596 :       reg_set_luid[regno] = reg_set_luid[base_regno];
    2309                 :     9377596 :       reg_base_reg[regno] = reg_base_reg[base_regno];
    2310                 :     9377596 :       reg_symbol_ref[regno] = reg_symbol_ref[base_regno];
    2311                 :             : 
    2312                 :             :       /* Compute the sum of the offsets or constants.  */
    2313                 :     9377596 :       reg_offset[regno]
    2314                 :     9377596 :         = trunc_int_for_mode (offset + reg_offset[base_regno], mode);
    2315                 :             : 
    2316                 :     9377596 :       move2add_record_mode (dst);
    2317                 :     9377596 :     }
    2318                 :             :   else
    2319                 :             :     {
    2320                 :      554774 :     invalidate:
    2321                 :             :       /* Invalidate the contents of the register.  */
    2322                 :    29103283 :       move2add_record_mode (dst);
    2323                 :    29103283 :       reg_mode[regno] = VOIDmode;
    2324                 :             :     }
    2325                 :             : }
    2326                 :             : 
    2327                 :             : namespace {
    2328                 :             : 
    2329                 :             : const pass_data pass_data_postreload_cse =
    2330                 :             : {
    2331                 :             :   RTL_PASS, /* type */
    2332                 :             :   "postreload", /* name */
    2333                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    2334                 :             :   TV_RELOAD_CSE_REGS, /* tv_id */
    2335                 :             :   0, /* properties_required */
    2336                 :             :   0, /* properties_provided */
    2337                 :             :   0, /* properties_destroyed */
    2338                 :             :   0, /* todo_flags_start */
    2339                 :             :   TODO_df_finish, /* todo_flags_finish */
    2340                 :             : };
    2341                 :             : 
    2342                 :             : class pass_postreload_cse : public rtl_opt_pass
    2343                 :             : {
    2344                 :             : public:
    2345                 :      281608 :   pass_postreload_cse (gcc::context *ctxt)
    2346                 :      563216 :     : rtl_opt_pass (pass_data_postreload_cse, ctxt)
    2347                 :             :   {}
    2348                 :             : 
    2349                 :             :   /* opt_pass methods: */
    2350                 :     1486709 :   bool gate (function *) final override
    2351                 :             :   {
    2352                 :     1486709 :     return (optimize > 0 && reload_completed);
    2353                 :             :   }
    2354                 :             : 
    2355                 :             :   unsigned int execute (function *) final override;
    2356                 :             : 
    2357                 :             : }; // class pass_postreload_cse
    2358                 :             : 
    2359                 :             : unsigned int
    2360                 :     1051273 : pass_postreload_cse::execute (function *fun)
    2361                 :             : {
    2362                 :     1051273 :   if (!dbg_cnt (postreload_cse))
    2363                 :             :     return 0;
    2364                 :             : 
    2365                 :             :   /* Do a very simple CSE pass over just the hard registers.  */
    2366                 :     1051273 :   reload_cse_regs (get_insns ());
    2367                 :             :   /* Reload_cse_regs can eliminate potentially-trapping MEMs.
    2368                 :             :      Remove any EH edges associated with them.  */
    2369                 :     1051273 :   if (fun->can_throw_non_call_exceptions
    2370                 :     1051273 :       && purge_all_dead_edges ())
    2371                 :         101 :     cleanup_cfg (0);
    2372                 :             : 
    2373                 :             :   return 0;
    2374                 :             : }
    2375                 :             : 
    2376                 :             : } // anon namespace
    2377                 :             : 
    2378                 :             : rtl_opt_pass *
    2379                 :      281608 : make_pass_postreload_cse (gcc::context *ctxt)
    2380                 :             : {
    2381                 :      281608 :   return new pass_postreload_cse (ctxt);
    2382                 :             : }
        

Generated by: LCOV version 2.1-beta

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