LCOV - code coverage report
Current view: top level - gcc - postreload.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 960 995 96.5 %
Date: 2020-04-04 11:58:09 Functions: 24 27 88.9 %
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-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #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                 :            : 
      45                 :            : static int reload_cse_noop_set_p (rtx);
      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                 :     688548 : reload_cse_regs (rtx_insn *first ATTRIBUTE_UNUSED)
      63                 :            : {
      64                 :     688548 :   bool moves_converted;
      65                 :     688548 :   reload_cse_regs_1 ();
      66                 :     688548 :   reload_combine ();
      67                 :     688548 :   moves_converted = reload_cse_move2add (first);
      68                 :     688548 :   if (flag_expensive_optimizations)
      69                 :            :     {
      70                 :     645401 :       if (moves_converted)
      71                 :       6482 :         reload_combine ();
      72                 :     645401 :       reload_cse_regs_1 ();
      73                 :            :     }
      74                 :     688548 : }
      75                 :            : 
      76                 :            : /* See whether a single set SET is a noop.  */
      77                 :            : static int
      78                 :   64926300 : reload_cse_noop_set_p (rtx set)
      79                 :            : {
      80                 :   64926300 :   if (cselib_reg_set_mode (SET_DEST (set)) != GET_MODE (SET_DEST (set)))
      81                 :            :     return 0;
      82                 :            : 
      83                 :   33994500 :   return rtx_equal_for_cselib_p (SET_DEST (set), SET_SRC (set));
      84                 :            : }
      85                 :            : 
      86                 :            : /* Try to simplify INSN.  Return true if the CFG may have changed.  */
      87                 :            : static bool
      88                 :  128439000 : reload_cse_simplify (rtx_insn *insn, rtx testreg)
      89                 :            : {
      90                 :  128439000 :   rtx body = PATTERN (insn);
      91                 :  128439000 :   basic_block insn_bb = BLOCK_FOR_INSN (insn);
      92                 :  128439000 :   unsigned insn_bb_succs = EDGE_COUNT (insn_bb->succs);
      93                 :            : 
      94                 :            :   /* If NO_FUNCTION_CSE has been set by the target, then we should not try
      95                 :            :      to cse function calls.  */
      96                 :  128439000 :   if (NO_FUNCTION_CSE && CALL_P (insn))
      97                 :            :     return false;
      98                 :            : 
      99                 :  122292000 :   if (GET_CODE (body) == SET)
     100                 :            :     {
     101                 :   56325000 :       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                 :   56325000 :       count += reload_cse_simplify_set (body, insn);
     109                 :            : 
     110                 :   56325000 :       if (!count && reload_cse_noop_set_p (body))
     111                 :            :         {
     112                 :     161650 :           if (check_for_inc_dec (insn))
     113                 :     161649 :             delete_insn_and_edges (insn);
     114                 :            :           /* We're done with this insn.  */
     115                 :     161650 :           goto done;
     116                 :            :         }
     117                 :            : 
     118                 :   56163400 :       if (count > 0)
     119                 :     109812 :         apply_change_group ();
     120                 :            :       else
     121                 :   56053600 :         reload_cse_simplify_operands (insn, testreg);
     122                 :            :     }
     123                 :   65967300 :   else if (GET_CODE (body) == PARALLEL)
     124                 :            :     {
     125                 :    8805870 :       int i;
     126                 :    8805870 :       int count = 0;
     127                 :    8805870 :       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                 :    8805870 :       if (asm_noperands (body) >= 0)
     133                 :            :         {
     134                 :     540954 :           for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
     135                 :            :             {
     136                 :     417024 :               rtx part = XVECEXP (body, 0, i);
     137                 :     417024 :               if (GET_CODE (part) == CLOBBER && REG_P (XEXP (part, 0)))
     138                 :     175320 :                 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                 :   17746800 :       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
     145                 :            :         {
     146                 :   17743800 :           rtx part = XVECEXP (body, 0, i);
     147                 :   17743800 :           if (GET_CODE (part) == SET)
     148                 :            :             {
     149                 :    8711090 :               if (! reload_cse_noop_set_p (part))
     150                 :            :                 break;
     151                 :       3147 :               if (REG_P (SET_DEST (part))
     152                 :       3147 :                   && REG_FUNCTION_VALUE_P (SET_DEST (part)))
     153                 :            :                 {
     154                 :          0 :                   if (value)
     155                 :            :                     break;
     156                 :            :                   value = SET_DEST (part);
     157                 :            :                 }
     158                 :            :             }
     159                 :    9032660 :           else if (GET_CODE (part) != CLOBBER && GET_CODE (part) != USE)
     160                 :            :             break;
     161                 :            :         }
     162                 :            : 
     163                 :    8805870 :       if (i < 0)
     164                 :            :         {
     165                 :       3060 :           if (check_for_inc_dec (insn))
     166                 :       3060 :             delete_insn_and_edges (insn);
     167                 :            :           /* We're done with this insn.  */
     168                 :       3060 :           goto done;
     169                 :            :         }
     170                 :            : 
     171                 :            :       /* It's not a no-op, but we can try to simplify it.  */
     172                 :   27147000 :       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
     173                 :   18344200 :         if (GET_CODE (XVECEXP (body, 0, i)) == SET)
     174                 :    9314160 :           count += reload_cse_simplify_set (XVECEXP (body, 0, i), insn);
     175                 :            : 
     176                 :    8802810 :       if (count > 0)
     177                 :       1916 :         apply_change_group ();
     178                 :            :       else
     179                 :    8800900 :         reload_cse_simplify_operands (insn, testreg);
     180                 :            :     }
     181                 :            : 
     182                 :   57161400 : done:
     183                 :  244584000 :   return (EDGE_COUNT (insn_bb->succs) != insn_bb_succs);
     184                 :            : }
     185                 :            : 
     186                 :            : /* Do a very simple CSE pass over the hard registers.
     187                 :            : 
     188                 :            :    This function detects no-op moves where we happened to assign two
     189                 :            :    different pseudo-registers to the same hard register, and then
     190                 :            :    copied one to the other.  Reload will generate a useless
     191                 :            :    instruction copying a register to itself.
     192                 :            : 
     193                 :            :    This function also detects cases where we load a value from memory
     194                 :            :    into two different registers, and (if memory is more expensive than
     195                 :            :    registers) changes it to simply copy the first register into the
     196                 :            :    second register.
     197                 :            : 
     198                 :            :    Another optimization is performed that scans the operands of each
     199                 :            :    instruction to see whether the value is already available in a
     200                 :            :    hard register.  It then replaces the operand with the hard register
     201                 :            :    if possible, much like an optional reload would.  */
     202                 :            : 
     203                 :            : static void
     204                 :    1333950 : reload_cse_regs_1 (void)
     205                 :            : {
     206                 :    1333950 :   bool cfg_changed = false;
     207                 :    1333950 :   basic_block bb;
     208                 :    1333950 :   rtx_insn *insn;
     209                 :    1333950 :   rtx testreg = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
     210                 :            : 
     211                 :    1333950 :   cselib_init (CSELIB_RECORD_MEMORY);
     212                 :    1333950 :   init_alias_analysis ();
     213                 :            : 
     214                 :   14906200 :   FOR_EACH_BB_FN (bb, cfun)
     215                 :  328406000 :     FOR_BB_INSNS (bb, insn)
     216                 :            :       {
     217                 :  157417000 :         if (INSN_P (insn))
     218                 :  128439000 :           cfg_changed |= reload_cse_simplify (insn, testreg);
     219                 :            : 
     220                 :  157417000 :         cselib_process_insn (insn);
     221                 :            :       }
     222                 :            : 
     223                 :            :   /* Clean up.  */
     224                 :    1333950 :   end_alias_analysis ();
     225                 :    1333950 :   cselib_finish ();
     226                 :    1333950 :   if (cfg_changed)
     227                 :         68 :     cleanup_cfg (0);
     228                 :    1333950 : }
     229                 :            : 
     230                 :            : /* Try to simplify a single SET instruction.  SET is the set pattern.
     231                 :            :    INSN is the instruction it came from.
     232                 :            :    This function only handles one case: if we set a register to a value
     233                 :            :    which is not a register, we try to find that value in some other register
     234                 :            :    and change the set into a register copy.  */
     235                 :            : 
     236                 :            : static int
     237                 :   65639200 : reload_cse_simplify_set (rtx set, rtx_insn *insn)
     238                 :            : {
     239                 :   65639200 :   int did_change = 0;
     240                 :   65639200 :   int dreg;
     241                 :   65639200 :   rtx src;
     242                 :   65639200 :   reg_class_t dclass;
     243                 :   65639200 :   int old_cost;
     244                 :   65639200 :   cselib_val *val;
     245                 :   65639200 :   struct elt_loc_list *l;
     246                 :   65639200 :   enum rtx_code extend_op = UNKNOWN;
     247                 :   65639200 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
     248                 :            : 
     249                 :   65639200 :   dreg = true_regnum (SET_DEST (set));
     250                 :   65639200 :   if (dreg < 0)
     251                 :            :     return 0;
     252                 :            : 
     253                 :   42331000 :   src = SET_SRC (set);
     254                 :   42331000 :   if (side_effects_p (src) || true_regnum (src) >= 0)
     255                 :    7063120 :     return 0;
     256                 :            : 
     257                 :   35267900 :   dclass = REGNO_REG_CLASS (dreg);
     258                 :            : 
     259                 :            :   /* When replacing a memory with a register, we need to honor assumptions
     260                 :            :      that combine made wrt the contents of sign bits.  We'll do this by
     261                 :            :      generating an extend instruction instead of a reg->reg copy.  Thus
     262                 :            :      the destination must be a register that we can widen.  */
     263                 :   35267900 :   if (MEM_P (src)
     264                 :            :       && (extend_op = load_extend_op (GET_MODE (src))) != UNKNOWN
     265                 :            :       && !REG_P (SET_DEST (set)))
     266                 :            :     return 0;
     267                 :            : 
     268                 :   35267900 :   val = cselib_lookup (src, GET_MODE (SET_DEST (set)), 0, VOIDmode);
     269                 :   35267900 :   if (! val)
     270                 :            :     return 0;
     271                 :            : 
     272                 :            :   /* If memory loads are cheaper than register copies, don't change them.  */
     273                 :    3883510 :   if (MEM_P (src))
     274                 :     408699 :     old_cost = memory_move_cost (GET_MODE (src), dclass, true);
     275                 :    3474810 :   else if (REG_P (src))
     276                 :          0 :     old_cost = register_move_cost (GET_MODE (src),
     277                 :          0 :                                    REGNO_REG_CLASS (REGNO (src)), dclass);
     278                 :            :   else
     279                 :    3474810 :     old_cost = set_src_cost (src, GET_MODE (SET_DEST (set)), speed);
     280                 :            : 
     281                 :    7507640 :   for (l = val->locs; l; l = l->next)
     282                 :            :     {
     283                 :    3624130 :       rtx this_rtx = l->loc;
     284                 :    3624130 :       int this_cost;
     285                 :            : 
     286                 :    3624130 :       if (CONSTANT_P (this_rtx) && ! references_value_p (this_rtx, 0))
     287                 :            :         {
     288                 :    1199790 :           if (extend_op != UNKNOWN)
     289                 :            :             {
     290                 :            :               wide_int result;
     291                 :            : 
     292                 :            :               if (!CONST_SCALAR_INT_P (this_rtx))
     293                 :            :                 continue;
     294                 :            : 
     295                 :            :               switch (extend_op)
     296                 :            :                 {
     297                 :            :                 case ZERO_EXTEND:
     298                 :            :                   result = wide_int::from (rtx_mode_t (this_rtx,
     299                 :            :                                                        GET_MODE (src)),
     300                 :            :                                            BITS_PER_WORD, UNSIGNED);
     301                 :            :                   break;
     302                 :            :                 case SIGN_EXTEND:
     303                 :            :                   result = wide_int::from (rtx_mode_t (this_rtx,
     304                 :            :                                                        GET_MODE (src)),
     305                 :            :                                            BITS_PER_WORD, SIGNED);
     306                 :            :                   break;
     307                 :            :                 default:
     308                 :            :                   gcc_unreachable ();
     309                 :            :                 }
     310                 :            :               this_rtx = immed_wide_int_const (result, word_mode);
     311                 :            :             }
     312                 :            : 
     313                 :    1199790 :           this_cost = set_src_cost (this_rtx, GET_MODE (SET_DEST (set)), speed);
     314                 :            :         }
     315                 :    2424340 :       else if (REG_P (this_rtx))
     316                 :            :         {
     317                 :     516791 :           if (extend_op != UNKNOWN)
     318                 :            :             {
     319                 :            :               this_rtx = gen_rtx_fmt_e (extend_op, word_mode, this_rtx);
     320                 :            :               this_cost = set_src_cost (this_rtx, word_mode, speed);
     321                 :            :             }
     322                 :            :           else
     323                 :     516791 :             this_cost = register_move_cost (GET_MODE (this_rtx),
     324                 :     516791 :                                             REGNO_REG_CLASS (REGNO (this_rtx)),
     325                 :            :                                             dclass);
     326                 :            :         }
     327                 :            :       else
     328                 :    1907540 :         continue;
     329                 :            : 
     330                 :            :       /* If equal costs, prefer registers over anything else.  That
     331                 :            :          tends to lead to smaller instructions on some machines.  */
     332                 :    1716580 :       if (this_cost < old_cost
     333                 :    1611190 :           || (this_cost == old_cost
     334                 :    1218060 :               && REG_P (this_rtx)
     335                 :      18626 :               && !REG_P (SET_SRC (set))))
     336                 :            :         {
     337                 :     112040 :           if (extend_op != UNKNOWN
     338                 :            :               && REG_CAN_CHANGE_MODE_P (REGNO (SET_DEST (set)),
     339                 :            :                                         GET_MODE (SET_DEST (set)), word_mode))
     340                 :            :             {
     341                 :            :               rtx wide_dest = gen_rtx_REG (word_mode, REGNO (SET_DEST (set)));
     342                 :            :               ORIGINAL_REGNO (wide_dest) = ORIGINAL_REGNO (SET_DEST (set));
     343                 :            :               validate_change (insn, &SET_DEST (set), wide_dest, 1);
     344                 :            :             }
     345                 :            : 
     346                 :     112040 :           validate_unshare_change (insn, &SET_SRC (set), this_rtx, 1);
     347                 :     112040 :           old_cost = this_cost, did_change = 1;
     348                 :            :         }
     349                 :            :     }
     350                 :            : 
     351                 :            :   return did_change;
     352                 :            : }
     353                 :            : 
     354                 :            : /* Try to replace operands in INSN with equivalent values that are already
     355                 :            :    in registers.  This can be viewed as optional reloading.
     356                 :            : 
     357                 :            :    For each non-register operand in the insn, see if any hard regs are
     358                 :            :    known to be equivalent to that operand.  Record the alternatives which
     359                 :            :    can accept these hard registers.  Among all alternatives, select the
     360                 :            :    ones which are better or equal to the one currently matching, where
     361                 :            :    "better" is in terms of '?' and '!' constraints.  Among the remaining
     362                 :            :    alternatives, select the one which replaces most operands with
     363                 :            :    hard registers.  */
     364                 :            : 
     365                 :            : static int
     366                 :   64854500 : reload_cse_simplify_operands (rtx_insn *insn, rtx testreg)
     367                 :            : {
     368                 :   64854500 :   int i, j;
     369                 :            : 
     370                 :            :   /* For each operand, all registers that are equivalent to it.  */
     371                 :   64854500 :   HARD_REG_SET equiv_regs[MAX_RECOG_OPERANDS];
     372                 :            : 
     373                 :   64854500 :   const char *constraints[MAX_RECOG_OPERANDS];
     374                 :            : 
     375                 :            :   /* Vector recording how bad an alternative is.  */
     376                 :   64854500 :   int *alternative_reject;
     377                 :            :   /* Vector recording how many registers can be introduced by choosing
     378                 :            :      this alternative.  */
     379                 :   64854500 :   int *alternative_nregs;
     380                 :            :   /* Array of vectors recording, for each operand and each alternative,
     381                 :            :      which hard register to substitute, or -1 if the operand should be
     382                 :            :      left as it is.  */
     383                 :   64854500 :   int *op_alt_regno[MAX_RECOG_OPERANDS];
     384                 :            :   /* Array of alternatives, sorted in order of decreasing desirability.  */
     385                 :   64854500 :   int *alternative_order;
     386                 :            : 
     387                 :   64854500 :   extract_constrain_insn (insn);
     388                 :            : 
     389                 :   64854500 :   if (recog_data.n_alternatives == 0 || recog_data.n_operands == 0)
     390                 :            :     return 0;
     391                 :            : 
     392                 :   56108800 :   alternative_reject = XALLOCAVEC (int, recog_data.n_alternatives);
     393                 :   56108800 :   alternative_nregs = XALLOCAVEC (int, recog_data.n_alternatives);
     394                 :   56108800 :   alternative_order = XALLOCAVEC (int, recog_data.n_alternatives);
     395                 :   56108800 :   memset (alternative_reject, 0, recog_data.n_alternatives * sizeof (int));
     396                 :   56108800 :   memset (alternative_nregs, 0, recog_data.n_alternatives * sizeof (int));
     397                 :            : 
     398                 :            :   /* For each operand, find out which regs are equivalent.  */
     399                 :  180197000 :   for (i = 0; i < recog_data.n_operands; i++)
     400                 :            :     {
     401                 :            :       cselib_val *v;
     402                 :            :       struct elt_loc_list *l;
     403                 :            :       rtx op;
     404                 :            : 
     405                 :  372264000 :       CLEAR_HARD_REG_SET (equiv_regs[i]);
     406                 :            : 
     407                 :            :       /* cselib blows up on CODE_LABELs.  Trying to fix that doesn't seem
     408                 :            :          right, so avoid the problem here.  Similarly NOTE_INSN_DELETED_LABEL.
     409                 :            :          Likewise if we have a constant and the insn pattern doesn't tell us
     410                 :            :          the mode we need.  */
     411                 :  124088000 :       if (LABEL_P (recog_data.operand[i])
     412                 :  124082000 :           || (NOTE_P (recog_data.operand[i])
     413                 :         32 :               && NOTE_KIND (recog_data.operand[i]) == NOTE_INSN_DELETED_LABEL)
     414                 :  124082000 :           || (CONSTANT_P (recog_data.operand[i])
     415                 :   21363200 :               && recog_data.operand_mode[i] == VOIDmode))
     416                 :     264605 :         continue;
     417                 :            : 
     418                 :  123823000 :       op = recog_data.operand[i];
     419                 :  123823000 :       if (MEM_P (op) && load_extend_op (GET_MODE (op)) != UNKNOWN)
     420                 :            :         {
     421                 :            :           rtx set = single_set (insn);
     422                 :            : 
     423                 :            :           /* We might have multiple sets, some of which do implicit
     424                 :            :              extension.  Punt on this for now.  */
     425                 :            :           if (! set)
     426                 :            :             continue;
     427                 :            :           /* If the destination is also a MEM or a STRICT_LOW_PART, no
     428                 :            :              extension applies.
     429                 :            :              Also, if there is an explicit extension, we don't have to
     430                 :            :              worry about an implicit one.  */
     431                 :            :           else if (MEM_P (SET_DEST (set))
     432                 :            :                    || GET_CODE (SET_DEST (set)) == STRICT_LOW_PART
     433                 :            :                    || GET_CODE (SET_SRC (set)) == ZERO_EXTEND
     434                 :            :                    || GET_CODE (SET_SRC (set)) == SIGN_EXTEND)
     435                 :            :             ; /* Continue ordinary processing.  */
     436                 :            :           /* If the register cannot change mode to word_mode, it follows that
     437                 :            :              it cannot have been used in word_mode.  */
     438                 :            :           else if (REG_P (SET_DEST (set))
     439                 :            :                    && !REG_CAN_CHANGE_MODE_P (REGNO (SET_DEST (set)),
     440                 :            :                                               GET_MODE (SET_DEST (set)),
     441                 :            :                                               word_mode))
     442                 :            :             ; /* Continue ordinary processing.  */
     443                 :            :           /* If this is a straight load, make the extension explicit.  */
     444                 :            :           else if (REG_P (SET_DEST (set))
     445                 :            :                    && recog_data.n_operands == 2
     446                 :            :                    && SET_SRC (set) == op
     447                 :            :                    && SET_DEST (set) == recog_data.operand[1-i])
     448                 :            :             {
     449                 :            :               validate_change (insn, recog_data.operand_loc[i],
     450                 :            :                                gen_rtx_fmt_e (load_extend_op (GET_MODE (op)),
     451                 :            :                                               word_mode, op),
     452                 :            :                                1);
     453                 :            :               validate_change (insn, recog_data.operand_loc[1-i],
     454                 :            :                                gen_rtx_REG (word_mode, REGNO (SET_DEST (set))),
     455                 :            :                                1);
     456                 :            :               if (! apply_change_group ())
     457                 :            :                 return 0;
     458                 :            :               return reload_cse_simplify_operands (insn, testreg);
     459                 :            :             }
     460                 :            :           else
     461                 :            :             /* ??? There might be arithmetic operations with memory that are
     462                 :            :                safe to optimize, but is it worth the trouble?  */
     463                 :            :             continue;
     464                 :            :         }
     465                 :            : 
     466                 :  123823000 :       if (side_effects_p (op))
     467                 :    4366080 :         continue;
     468                 :  119457000 :       v = cselib_lookup (op, recog_data.operand_mode[i], 0, VOIDmode);
     469                 :  119457000 :       if (! v)
     470                 :   78486600 :         continue;
     471                 :            : 
     472                 :  123573000 :       for (l = v->locs; l; l = l->next)
     473                 :   82601900 :         if (REG_P (l->loc))
     474                 :   82601900 :           SET_HARD_REG_BIT (equiv_regs[i], REGNO (l->loc));
     475                 :            :     }
     476                 :            : 
     477                 :   56108800 :   alternative_mask preferred = get_preferred_alternatives (insn);
     478                 :  180197000 :   for (i = 0; i < recog_data.n_operands; i++)
     479                 :            :     {
     480                 :  124088000 :       machine_mode mode;
     481                 :  124088000 :       int regno;
     482                 :  124088000 :       const char *p;
     483                 :            : 
     484                 :  124088000 :       op_alt_regno[i] = XALLOCAVEC (int, recog_data.n_alternatives);
     485                 : 1743210000 :       for (j = 0; j < recog_data.n_alternatives; j++)
     486                 : 1619130000 :         op_alt_regno[i][j] = -1;
     487                 :            : 
     488                 :  124088000 :       p = constraints[i] = recog_data.constraints[i];
     489                 :  124088000 :       mode = recog_data.operand_mode[i];
     490                 :            : 
     491                 :            :       /* Add the reject values for each alternative given by the constraints
     492                 :            :          for this operand.  */
     493                 :  124088000 :       j = 0;
     494                 : 4634480000 :       while (*p != '\0')
     495                 :            :         {
     496                 : 4510390000 :           char c = *p++;
     497                 : 4510390000 :           if (c == ',')
     498                 : 1491170000 :             j++;
     499                 : 3019220000 :           else if (c == '?')
     500                 :  244831000 :             alternative_reject[j] += 3;
     501                 : 2774390000 :           else if (c == '!')
     502                 :    8466470 :             alternative_reject[j] += 300;
     503                 :            :         }
     504                 :            : 
     505                 :            :       /* We won't change operands which are already registers.  We
     506                 :            :          also don't want to modify output operands.  */
     507                 :  124088000 :       regno = true_regnum (recog_data.operand[i]);
     508                 :  124088000 :       if (regno >= 0
     509                 :   52521000 :           || constraints[i][0] == '='
     510                 :   38086700 :           || constraints[i][0] == '+')
     511                 :   86094500 :         continue;
     512                 :            : 
     513                 : 2925500000 :       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
     514                 :            :         {
     515                 : 2887500000 :           enum reg_class rclass = NO_REGS;
     516                 :            : 
     517                 : 2887500000 :           if (! TEST_HARD_REG_BIT (equiv_regs[i], regno))
     518                 : 2887040000 :             continue;
     519                 :            : 
     520                 :     461917 :           set_mode_and_regno (testreg, mode, regno);
     521                 :            : 
     522                 :            :           /* We found a register equal to this operand.  Now look for all
     523                 :            :              alternatives that can accept this register and have not been
     524                 :            :              assigned a register they can use yet.  */
     525                 :     461917 :           j = 0;
     526                 :     461917 :           p = constraints[i];
     527                 :   22369400 :           for (;;)
     528                 :            :             {
     529                 :   22369400 :               char c = *p;
     530                 :            : 
     531                 :   22369400 :               switch (c)
     532                 :            :                 {
     533                 :     133510 :                 case 'g':
     534                 :     133510 :                   rclass = reg_class_subunion[rclass][GENERAL_REGS];
     535                 :     133510 :                   break;
     536                 :            : 
     537                 :   14082100 :                 default:
     538                 :   14082100 :                   rclass
     539                 :   14082100 :                     = (reg_class_subunion
     540                 :   14082100 :                        [rclass]
     541                 :   14625300 :                        [reg_class_for_constraint (lookup_constraint (p))]);
     542                 :   14082100 :                   break;
     543                 :            : 
     544                 :    8153730 :                 case ',': case '\0':
     545                 :            :                   /* See if REGNO fits this alternative, and set it up as the
     546                 :            :                      replacement register if we don't have one for this
     547                 :            :                      alternative yet and the operand being replaced is not
     548                 :            :                      a cheap CONST_INT.  */
     549                 :    8153730 :                   if (op_alt_regno[i][j] == -1
     550                 :    8126710 :                       && TEST_BIT (preferred, j)
     551                 :    7102450 :                       && reg_fits_class_p (testreg, rclass, 0, mode)
     552                 :    9896030 :                       && (!CONST_INT_P (recog_data.operand[i])
     553                 :    1668330 :                           || (set_src_cost (recog_data.operand[i], mode,
     554                 :            :                                             optimize_bb_for_speed_p
     555                 :    1668330 :                                              (BLOCK_FOR_INSN (insn)))
     556                 :    1668330 :                               > set_src_cost (testreg, mode,
     557                 :            :                                               optimize_bb_for_speed_p
     558                 :    1668330 :                                                (BLOCK_FOR_INSN (insn))))))
     559                 :            :                     {
     560                 :      79475 :                       alternative_nregs[j]++;
     561                 :      79475 :                       op_alt_regno[i][j] = regno;
     562                 :            :                     }
     563                 :    8153730 :                   j++;
     564                 :    8153730 :                   rclass = NO_REGS;
     565                 :    8153730 :                   break;
     566                 :            :                 }
     567                 :   22369400 :               p += CONSTRAINT_LEN (c, p);
     568                 :            : 
     569                 :   22369400 :               if (c == '\0')
     570                 :            :                 break;
     571                 :            :             }
     572                 :            :         }
     573                 :            :     }
     574                 :            : 
     575                 :            :   /* Record all alternatives which are better or equal to the currently
     576                 :            :      matching one in the alternative_order array.  */
     577                 :  847083000 :   for (i = j = 0; i < recog_data.n_alternatives; i++)
     578                 :  790974000 :     if (alternative_reject[i] <= alternative_reject[which_alternative])
     579                 :  540633000 :       alternative_order[j++] = i;
     580                 :   56108800 :   recog_data.n_alternatives = j;
     581                 :            : 
     582                 :            :   /* Sort it.  Given a small number of alternatives, a dumb algorithm
     583                 :            :      won't hurt too much.  */
     584                 :  540633000 :   for (i = 0; i < recog_data.n_alternatives - 1; i++)
     585                 :            :     {
     586                 :  484524000 :       int best = i;
     587                 :  484524000 :       int best_reject = alternative_reject[alternative_order[i]];
     588                 :  484524000 :       int best_nregs = alternative_nregs[alternative_order[i]];
     589                 :            : 
     590                 : 4179490000 :       for (j = i + 1; j < recog_data.n_alternatives; j++)
     591                 :            :         {
     592                 : 3694960000 :           int this_reject = alternative_reject[alternative_order[j]];
     593                 : 3694960000 :           int this_nregs = alternative_nregs[alternative_order[j]];
     594                 :            : 
     595                 : 3694960000 :           if (this_reject < best_reject
     596                 : 3692070000 :               || (this_reject == best_reject && this_nregs > best_nregs))
     597                 :            :             {
     598                 :    2937930 :               best = j;
     599                 :    2937930 :               best_reject = this_reject;
     600                 :    2937930 :               best_nregs = this_nregs;
     601                 :            :             }
     602                 :            :         }
     603                 :            : 
     604                 :  484524000 :       std::swap (alternative_order[best], alternative_order[i]);
     605                 :            :     }
     606                 :            : 
     607                 :            :   /* Substitute the operands as determined by op_alt_regno for the best
     608                 :            :      alternative.  */
     609                 :   56108800 :   j = alternative_order[0];
     610                 :            : 
     611                 :  180197000 :   for (i = 0; i < recog_data.n_operands; i++)
     612                 :            :     {
     613                 :  124088000 :       machine_mode mode = recog_data.operand_mode[i];
     614                 :  124088000 :       if (op_alt_regno[i][j] == -1)
     615                 :  124057000 :         continue;
     616                 :            : 
     617                 :      30925 :       validate_change (insn, recog_data.operand_loc[i],
     618                 :            :                        gen_rtx_REG (mode, op_alt_regno[i][j]), 1);
     619                 :            :     }
     620                 :            : 
     621                 :   57038900 :   for (i = recog_data.n_dups - 1; i >= 0; i--)
     622                 :            :     {
     623                 :     930091 :       int op = recog_data.dup_num[i];
     624                 :     930091 :       machine_mode mode = recog_data.operand_mode[op];
     625                 :            : 
     626                 :     930091 :       if (op_alt_regno[op][j] == -1)
     627                 :     929928 :         continue;
     628                 :            : 
     629                 :        163 :       validate_change (insn, recog_data.dup_loc[i],
     630                 :            :                        gen_rtx_REG (mode, op_alt_regno[op][j]), 1);
     631                 :            :     }
     632                 :            : 
     633                 :   56108800 :   return apply_change_group ();
     634                 :            : }
     635                 :            : 
     636                 :            : /* If reload couldn't use reg+reg+offset addressing, try to use reg+reg
     637                 :            :    addressing now.
     638                 :            :    This code might also be useful when reload gave up on reg+reg addressing
     639                 :            :    because of clashes between the return register and INDEX_REG_CLASS.  */
     640                 :            : 
     641                 :            : /* The maximum number of uses of a register we can keep track of to
     642                 :            :    replace them with reg+reg addressing.  */
     643                 :            : #define RELOAD_COMBINE_MAX_USES 16
     644                 :            : 
     645                 :            : /* Describes a recorded use of a register.  */
     646                 :            : struct reg_use
     647                 :            : {
     648                 :            :   /* The insn where a register has been used.  */
     649                 :            :   rtx_insn *insn;
     650                 :            :   /* Points to the memory reference enclosing the use, if any, NULL_RTX
     651                 :            :      otherwise.  */
     652                 :            :   rtx containing_mem;
     653                 :            :   /* Location of the register within INSN.  */
     654                 :            :   rtx *usep;
     655                 :            :   /* The reverse uid of the insn.  */
     656                 :            :   int ruid;
     657                 :            : };
     658                 :            : 
     659                 :            : /* If the register is used in some unknown fashion, USE_INDEX is negative.
     660                 :            :    If it is dead, USE_INDEX is RELOAD_COMBINE_MAX_USES, and STORE_RUID
     661                 :            :    indicates where it is first set or clobbered.
     662                 :            :    Otherwise, USE_INDEX is the index of the last encountered use of the
     663                 :            :    register (which is first among these we have seen since we scan backwards).
     664                 :            :    USE_RUID indicates the first encountered, i.e. last, of these uses.
     665                 :            :    If ALL_OFFSETS_MATCH is true, all encountered uses were inside a PLUS
     666                 :            :    with a constant offset; OFFSET contains this constant in that case.
     667                 :            :    STORE_RUID is always meaningful if we only want to use a value in a
     668                 :            :    register in a different place: it denotes the next insn in the insn
     669                 :            :    stream (i.e. the last encountered) that sets or clobbers the register.
     670                 :            :    REAL_STORE_RUID is similar, but clobbers are ignored when updating it.
     671                 :            :    EXPR is the expression used when storing the register.  */
     672                 :            : static struct
     673                 :            :   {
     674                 :            :     struct reg_use reg_use[RELOAD_COMBINE_MAX_USES];
     675                 :            :     rtx offset;
     676                 :            :     int use_index;
     677                 :            :     int store_ruid;
     678                 :            :     int real_store_ruid;
     679                 :            :     int use_ruid;
     680                 :            :     bool all_offsets_match;
     681                 :            :     rtx expr;
     682                 :            :   } reg_state[FIRST_PSEUDO_REGISTER];
     683                 :            : 
     684                 :            : /* Reverse linear uid.  This is increased in reload_combine while scanning
     685                 :            :    the instructions from last to first.  It is used to set last_label_ruid
     686                 :            :    and the store_ruid / use_ruid fields in reg_state.  */
     687                 :            : static int reload_combine_ruid;
     688                 :            : 
     689                 :            : /* The RUID of the last label we encountered in reload_combine.  */
     690                 :            : static int last_label_ruid;
     691                 :            : 
     692                 :            : /* The RUID of the last jump we encountered in reload_combine.  */
     693                 :            : static int last_jump_ruid;
     694                 :            : 
     695                 :            : /* The register numbers of the first and last index register.  A value of
     696                 :            :    -1 in LAST_INDEX_REG indicates that we've previously computed these
     697                 :            :    values and found no suitable index registers.  */
     698                 :            : static int first_index_reg = -1;
     699                 :            : static int last_index_reg;
     700                 :            : 
     701                 :            : #define LABEL_LIVE(LABEL) \
     702                 :            :   (label_live[CODE_LABEL_NUMBER (LABEL) - min_labelno])
     703                 :            : 
     704                 :            : /* Subroutine of reload_combine_split_ruids, called to fix up a single
     705                 :            :    ruid pointed to by *PRUID if it is higher than SPLIT_RUID.  */
     706                 :            : 
     707                 :            : static inline void
     708                 :     139894 : reload_combine_split_one_ruid (int *pruid, int split_ruid)
     709                 :            : {
     710                 :     139894 :   if (*pruid > split_ruid)
     711                 :       9738 :     (*pruid)++;
     712                 :            : }
     713                 :            : 
     714                 :            : /* Called when we insert a new insn in a position we've already passed in
     715                 :            :    the scan.  Examine all our state, increasing all ruids that are higher
     716                 :            :    than SPLIT_RUID by one in order to make room for a new insn.  */
     717                 :            : 
     718                 :            : static void
     719                 :        596 : reload_combine_split_ruids (int split_ruid)
     720                 :            : {
     721                 :        596 :   unsigned i;
     722                 :            : 
     723                 :        596 :   reload_combine_split_one_ruid (&reload_combine_ruid, split_ruid);
     724                 :        596 :   reload_combine_split_one_ruid (&last_label_ruid, split_ruid);
     725                 :        596 :   reload_combine_split_one_ruid (&last_jump_ruid, split_ruid);
     726                 :            : 
     727                 :      45892 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     728                 :            :     {
     729                 :      45296 :       int j, idx = reg_state[i].use_index;
     730                 :      45296 :       reload_combine_split_one_ruid (&reg_state[i].use_ruid, split_ruid);
     731                 :      45296 :       reload_combine_split_one_ruid (&reg_state[i].store_ruid, split_ruid);
     732                 :      45296 :       reload_combine_split_one_ruid (&reg_state[i].real_store_ruid,
     733                 :            :                                      split_ruid);
     734                 :      45296 :       if (idx < 0)
     735                 :      14312 :         continue;
     736                 :      33202 :       for (j = idx; j < RELOAD_COMBINE_MAX_USES; j++)
     737                 :            :         {
     738                 :       3786 :           reload_combine_split_one_ruid (&reg_state[i].reg_use[j].ruid,
     739                 :            :                                          split_ruid);
     740                 :            :         }
     741                 :            :     }
     742                 :        596 : }
     743                 :            : 
     744                 :            : /* Called when we are about to rescan a previously encountered insn with
     745                 :            :    reload_combine_note_use after modifying some part of it.  This clears all
     746                 :            :    information about uses in that particular insn.  */
     747                 :            : 
     748                 :            : static void
     749                 :      13306 : reload_combine_purge_insn_uses (rtx_insn *insn)
     750                 :            : {
     751                 :      13306 :   unsigned i;
     752                 :            : 
     753                 :    1024560 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     754                 :            :     {
     755                 :    1011260 :       int j, k, idx = reg_state[i].use_index;
     756                 :    1011260 :       if (idx < 0)
     757                 :     176948 :         continue;
     758                 :            :       j = k = RELOAD_COMBINE_MAX_USES;
     759                 :     983607 :       while (j-- > idx)
     760                 :            :         {
     761                 :     149299 :           if (reg_state[i].reg_use[j].insn != insn)
     762                 :            :             {
     763                 :     134576 :               k--;
     764                 :     134576 :               if (k != j)
     765                 :       2915 :                 reg_state[i].reg_use[k] = reg_state[i].reg_use[j];
     766                 :            :             }
     767                 :            :         }
     768                 :     834308 :       reg_state[i].use_index = k;
     769                 :            :     }
     770                 :      13306 : }
     771                 :            : 
     772                 :            : /* Called when we need to forget about all uses of REGNO after an insn
     773                 :            :    which is identified by RUID.  */
     774                 :            : 
     775                 :            : static void
     776                 :        596 : reload_combine_purge_reg_uses_after_ruid (unsigned regno, int ruid)
     777                 :            : {
     778                 :        596 :   int j, k, idx = reg_state[regno].use_index;
     779                 :          0 :   if (idx < 0)
     780                 :            :     return;
     781                 :            :   j = k = RELOAD_COMBINE_MAX_USES;
     782                 :       2288 :   while (j-- > idx)
     783                 :            :     {
     784                 :       1692 :       if (reg_state[regno].reg_use[j].ruid >= ruid)
     785                 :            :         {
     786                 :        813 :           k--;
     787                 :        813 :           if (k != j)
     788                 :        497 :             reg_state[regno].reg_use[k] = reg_state[regno].reg_use[j];
     789                 :            :         }
     790                 :            :     }
     791                 :        596 :   reg_state[regno].use_index = k;
     792                 :            : }
     793                 :            : 
     794                 :            : /* Find the use of REGNO with the ruid that is highest among those
     795                 :            :    lower than RUID_LIMIT, and return it if it is the only use of this
     796                 :            :    reg in the insn.  Return NULL otherwise.  */
     797                 :            : 
     798                 :            : static struct reg_use *
     799                 :    2337900 : reload_combine_closest_single_use (unsigned regno, int ruid_limit)
     800                 :            : {
     801                 :    2337900 :   int i, best_ruid = 0;
     802                 :    2337900 :   int use_idx = reg_state[regno].use_index;
     803                 :    2337900 :   struct reg_use *retval;
     804                 :            : 
     805                 :          0 :   if (use_idx < 0)
     806                 :            :     return NULL;
     807                 :            :   retval = NULL;
     808                 :    2461060 :   for (i = use_idx; i < RELOAD_COMBINE_MAX_USES; i++)
     809                 :            :     {
     810                 :    1423020 :       struct reg_use *use = reg_state[regno].reg_use + i; 
     811                 :    1423020 :       int this_ruid = use->ruid;
     812                 :    1423020 :       if (this_ruid >= ruid_limit)
     813                 :     505530 :         continue;
     814                 :     917486 :       if (this_ruid > best_ruid)
     815                 :            :         {
     816                 :            :           best_ruid = this_ruid;
     817                 :            :           retval = use;
     818                 :            :         }
     819                 :     245743 :       else if (this_ruid == best_ruid)
     820                 :      32771 :         retval = NULL;
     821                 :            :     }
     822                 :    1038040 :   if (last_label_ruid >= best_ruid)
     823                 :          0 :     return NULL;
     824                 :            :   return retval;
     825                 :            : }
     826                 :            : 
     827                 :            : /* After we've moved an add insn, fix up any debug insns that occur
     828                 :            :    between the old location of the add and the new location.  REG is
     829                 :            :    the destination register of the add insn; REPLACEMENT is the
     830                 :            :    SET_SRC of the add.  FROM and TO specify the range in which we
     831                 :            :    should make this change on debug insns.  */
     832                 :            : 
     833                 :            : static void
     834                 :        674 : fixup_debug_insns (rtx reg, rtx replacement, rtx_insn *from, rtx_insn *to)
     835                 :            : {
     836                 :        674 :   rtx_insn *insn;
     837                 :       9278 :   for (insn = from; insn != to; insn = NEXT_INSN (insn))
     838                 :            :     {
     839                 :       4302 :       rtx t;
     840                 :            : 
     841                 :       4302 :       if (!DEBUG_BIND_INSN_P (insn))
     842                 :       3676 :         continue;
     843                 :            :       
     844                 :        626 :       t = INSN_VAR_LOCATION_LOC (insn);
     845                 :        626 :       t = simplify_replace_rtx (t, reg, replacement);
     846                 :        626 :       validate_change (insn, &INSN_VAR_LOCATION_LOC (insn), t, 0);
     847                 :            :     }
     848                 :        674 : }
     849                 :            : 
     850                 :            : /* Subroutine of reload_combine_recognize_const_pattern.  Try to replace REG
     851                 :            :    with SRC in the insn described by USE, taking costs into account.  Return
     852                 :            :    true if we made the replacement.  */
     853                 :            : 
     854                 :            : static bool
     855                 :     508892 : try_replace_in_use (struct reg_use *use, rtx reg, rtx src)
     856                 :            : {
     857                 :     508892 :   rtx_insn *use_insn = use->insn;
     858                 :     508892 :   rtx mem = use->containing_mem;
     859                 :     508892 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (use_insn));
     860                 :            : 
     861                 :     508892 :   if (mem != NULL_RTX)
     862                 :            :     {
     863                 :      23253 :       addr_space_t as = MEM_ADDR_SPACE (mem);
     864                 :      23253 :       rtx oldaddr = XEXP (mem, 0);
     865                 :      23253 :       rtx newaddr = NULL_RTX;
     866                 :      23253 :       int old_cost = address_cost (oldaddr, GET_MODE (mem), as, speed);
     867                 :      23253 :       int new_cost;
     868                 :            : 
     869                 :      23253 :       newaddr = simplify_replace_rtx (oldaddr, reg, src);
     870                 :      23253 :       if (memory_address_addr_space_p (GET_MODE (mem), newaddr, as))
     871                 :            :         {
     872                 :      12762 :           XEXP (mem, 0) = newaddr;
     873                 :      12762 :           new_cost = address_cost (newaddr, GET_MODE (mem), as, speed);
     874                 :      12762 :           XEXP (mem, 0) = oldaddr;
     875                 :      12762 :           if (new_cost <= old_cost
     876                 :      12762 :               && validate_change (use_insn,
     877                 :            :                                   &XEXP (mem, 0), newaddr, 0))
     878                 :      12539 :             return true;
     879                 :            :         }
     880                 :            :     }
     881                 :            :   else
     882                 :            :     {
     883                 :     485639 :       rtx new_set = single_set (use_insn);
     884                 :     485639 :       if (new_set
     885                 :     484712 :           && REG_P (SET_DEST (new_set))
     886                 :     147508 :           && GET_CODE (SET_SRC (new_set)) == PLUS
     887                 :      13500 :           && REG_P (XEXP (SET_SRC (new_set), 0))
     888                 :      12730 :           && CONSTANT_P (XEXP (SET_SRC (new_set), 1)))
     889                 :            :         {
     890                 :        977 :           rtx new_src;
     891                 :        977 :           machine_mode mode = GET_MODE (SET_DEST (new_set));
     892                 :        977 :           int old_cost = set_src_cost (SET_SRC (new_set), mode, speed);
     893                 :            : 
     894                 :        977 :           gcc_assert (rtx_equal_p (XEXP (SET_SRC (new_set), 0), reg));
     895                 :        977 :           new_src = simplify_replace_rtx (SET_SRC (new_set), reg, src);
     896                 :            : 
     897                 :        977 :           if (set_src_cost (new_src, mode, speed) <= old_cost
     898                 :        977 :               && validate_change (use_insn, &SET_SRC (new_set),
     899                 :            :                                   new_src, 0))
     900                 :        767 :             return true;
     901                 :            :         }
     902                 :            :     }
     903                 :            :   return false;
     904                 :            : }
     905                 :            : 
     906                 :            : /* Called by reload_combine when scanning INSN.  This function tries to detect
     907                 :            :    patterns where a constant is added to a register, and the result is used
     908                 :            :    in an address.
     909                 :            :    Return true if no further processing is needed on INSN; false if it wasn't
     910                 :            :    recognized and should be handled normally.  */
     911                 :            : 
     912                 :            : static bool
     913                 :   39120100 : reload_combine_recognize_const_pattern (rtx_insn *insn)
     914                 :            : {
     915                 :   39120100 :   int from_ruid = reload_combine_ruid;
     916                 :   39120100 :   rtx set, pat, reg, src, addreg;
     917                 :   39120100 :   unsigned int regno;
     918                 :   39120100 :   struct reg_use *use;
     919                 :   39120100 :   bool must_move_add;
     920                 :   39120100 :   rtx_insn *add_moved_after_insn = NULL;
     921                 :   39120100 :   int add_moved_after_ruid = 0;
     922                 :   39120100 :   int clobbered_regno = -1;
     923                 :            : 
     924                 :   39120100 :   set = single_set (insn);
     925                 :   39120100 :   if (set == NULL_RTX)
     926                 :            :     return false;
     927                 :            : 
     928                 :   36186900 :   reg = SET_DEST (set);
     929                 :   36186900 :   src = SET_SRC (set);
     930                 :   36186900 :   if (!REG_P (reg)
     931                 :   23663200 :       || REG_NREGS (reg) != 1
     932                 :   28103500 :       || GET_MODE (reg) != Pmode
     933                 :   50304400 :       || reg == stack_pointer_rtx)
     934                 :            :     return false;
     935                 :            : 
     936                 :   12856700 :   regno = REGNO (reg);
     937                 :            : 
     938                 :            :   /* We look for a REG1 = REG2 + CONSTANT insn, followed by either
     939                 :            :      uses of REG1 inside an address, or inside another add insn.  If
     940                 :            :      possible and profitable, merge the addition into subsequent
     941                 :            :      uses.  */
     942                 :   12856700 :   if (GET_CODE (src) != PLUS
     943                 :    2397740 :       || !REG_P (XEXP (src, 0))
     944                 :    2239830 :       || !CONSTANT_P (XEXP (src, 1)))
     945                 :            :     return false;
     946                 :            : 
     947                 :    1893080 :   addreg = XEXP (src, 0);
     948                 :    1893080 :   must_move_add = rtx_equal_p (reg, addreg);
     949                 :            : 
     950                 :    1893080 :   pat = PATTERN (insn);
     951                 :    1893080 :   if (must_move_add && set != pat)
     952                 :            :     {
     953                 :            :       /* We have to be careful when moving the add; apart from the
     954                 :            :          single_set there may also be clobbers.  Recognize one special
     955                 :            :          case, that of one clobber alongside the set (likely a clobber
     956                 :            :          of the CC register).  */
     957                 :     437361 :       gcc_assert (GET_CODE (PATTERN (insn)) == PARALLEL);
     958                 :     437361 :       if (XVECLEN (pat, 0) != 2 || XVECEXP (pat, 0, 0) != set
     959                 :     437361 :           || GET_CODE (XVECEXP (pat, 0, 1)) != CLOBBER
     960                 :     437361 :           || !REG_P (XEXP (XVECEXP (pat, 0, 1), 0)))
     961                 :            :         return false;
     962                 :     437361 :       clobbered_regno = REGNO (XEXP (XVECEXP (pat, 0, 1), 0));
     963                 :            :     }
     964                 :            : 
     965                 :    2337900 :   do
     966                 :            :     {
     967                 :    2337900 :       use = reload_combine_closest_single_use (regno, from_ruid);
     968                 :            : 
     969                 :     628652 :       if (use)
     970                 :            :         /* Start the search for the next use from here.  */
     971                 :     598004 :         from_ruid = use->ruid;
     972                 :            : 
     973                 :    2626720 :       if (use && GET_MODE (*use->usep) == Pmode)
     974                 :            :         {
     975                 :     594267 :           bool delete_add = false;
     976                 :     594267 :           rtx_insn *use_insn = use->insn;
     977                 :     594267 :           int use_ruid = use->ruid;
     978                 :            : 
     979                 :            :           /* Avoid moving the add insn past a jump.  */
     980                 :     594267 :           if (must_move_add && use_ruid <= last_jump_ruid)
     981                 :            :             break;
     982                 :            : 
     983                 :            :           /* If the add clobbers another hard reg in parallel, don't move
     984                 :            :              it past a real set of this hard reg.  */
     985                 :     593987 :           if (must_move_add && clobbered_regno >= 0
     986                 :      67926 :               && reg_state[clobbered_regno].real_store_ruid >= use_ruid)
     987                 :            :             break;
     988                 :            : 
     989                 :            :           /* Do not separate cc0 setter and cc0 user on HAVE_cc0 targets.  */
     990                 :     584097 :           if (HAVE_cc0 && must_move_add && sets_cc0_p (PATTERN (use_insn)))
     991                 :            :             break;
     992                 :            : 
     993                 :     584097 :           gcc_assert (reg_state[regno].store_ruid <= use_ruid);
     994                 :            :           /* Avoid moving a use of ADDREG past a point where it is stored.  */
     995                 :     584097 :           if (reg_state[REGNO (addreg)].store_ruid > use_ruid)
     996                 :            :             break;
     997                 :            : 
     998                 :            :           /* We also must not move the addition past an insn that sets
     999                 :            :              the same register, unless we can combine two add insns.  */
    1000                 :     508915 :           if (must_move_add && reg_state[regno].store_ruid == use_ruid)
    1001                 :            :             {
    1002                 :      16317 :               if (use->containing_mem == NULL_RTX)
    1003                 :            :                 delete_add = true;
    1004                 :            :               else
    1005                 :            :                 break;
    1006                 :            :             }
    1007                 :            : 
    1008                 :     508892 :           if (try_replace_in_use (use, reg, src))
    1009                 :            :             {
    1010                 :      13306 :               reload_combine_purge_insn_uses (use_insn);
    1011                 :      13306 :               reload_combine_note_use (&PATTERN (use_insn), use_insn,
    1012                 :            :                                        use_ruid, NULL_RTX);
    1013                 :            : 
    1014                 :      13306 :               if (delete_add)
    1015                 :            :                 {
    1016                 :         23 :                   fixup_debug_insns (reg, src, insn, use_insn);
    1017                 :         23 :                   delete_insn (insn);
    1018                 :         23 :                   return true;
    1019                 :            :                 }
    1020                 :      13283 :               if (must_move_add)
    1021                 :            :                 {
    1022                 :        852 :                   add_moved_after_insn = use_insn;
    1023                 :        852 :                   add_moved_after_ruid = use_ruid;
    1024                 :            :                 }
    1025                 :      13283 :               continue;
    1026                 :            :             }
    1027                 :            :         }
    1028                 :            :       /* If we get here, we couldn't handle this use.  */
    1029                 :    2239220 :       if (must_move_add)
    1030                 :            :         break;
    1031                 :            :     }
    1032                 :    1809550 :   while (use);
    1033                 :            : 
    1034                 :    1893060 :   if (!must_move_add || add_moved_after_insn == NULL_RTX)
    1035                 :            :     /* Process the add normally.  */
    1036                 :            :     return false;
    1037                 :            : 
    1038                 :        596 :   fixup_debug_insns (reg, src, insn, add_moved_after_insn);
    1039                 :            : 
    1040                 :        596 :   reorder_insns (insn, insn, add_moved_after_insn);
    1041                 :        596 :   reload_combine_purge_reg_uses_after_ruid (regno, add_moved_after_ruid);
    1042                 :        596 :   reload_combine_split_ruids (add_moved_after_ruid - 1);
    1043                 :        596 :   reload_combine_note_use (&PATTERN (insn), insn,
    1044                 :            :                            add_moved_after_ruid, NULL_RTX);
    1045                 :        596 :   reg_state[regno].store_ruid = add_moved_after_ruid;
    1046                 :            : 
    1047                 :        596 :   return true;
    1048                 :            : }
    1049                 :            : 
    1050                 :            : /* Called by reload_combine when scanning INSN.  Try to detect a pattern we
    1051                 :            :    can handle and improve.  Return true if no further processing is needed on
    1052                 :            :    INSN; false if it wasn't recognized and should be handled normally.  */
    1053                 :            : 
    1054                 :            : static bool
    1055                 :   39119500 : reload_combine_recognize_pattern (rtx_insn *insn)
    1056                 :            : {
    1057                 :   39119500 :   rtx set, reg, src;
    1058                 :            : 
    1059                 :   39119500 :   set = single_set (insn);
    1060                 :   39119500 :   if (set == NULL_RTX)
    1061                 :            :     return false;
    1062                 :            : 
    1063                 :   36186300 :   reg = SET_DEST (set);
    1064                 :   36186300 :   src = SET_SRC (set);
    1065                 :   36186300 :   if (!REG_P (reg) || REG_NREGS (reg) != 1)
    1066                 :            :     return false;
    1067                 :            : 
    1068                 :   23353500 :   unsigned int regno = REGNO (reg);
    1069                 :   23353500 :   machine_mode mode = GET_MODE (reg);
    1070                 :            : 
    1071                 :   23353500 :   if (reg_state[regno].use_index < 0
    1072                 :   23353500 :       || reg_state[regno].use_index >= RELOAD_COMBINE_MAX_USES)
    1073                 :            :     return false;
    1074                 :            : 
    1075                 :   15074500 :   for (int i = reg_state[regno].use_index;
    1076                 :   27553200 :        i < RELOAD_COMBINE_MAX_USES; i++)
    1077                 :            :     {
    1078                 :   15393100 :       struct reg_use *use = reg_state[regno].reg_use + i;
    1079                 :   15393100 :       if (GET_MODE (*use->usep) != mode)
    1080                 :            :         return false;
    1081                 :            :       /* Don't try to adjust (use (REGX)).  */
    1082                 :   15076600 :       if (GET_CODE (PATTERN (use->insn)) == USE
    1083                 :   15076600 :           && &XEXP (PATTERN (use->insn), 0) == use->usep)
    1084                 :            :         return false;
    1085                 :            :     }
    1086                 :            : 
    1087                 :            :   /* Look for (set (REGX) (CONST_INT))
    1088                 :            :      (set (REGX) (PLUS (REGX) (REGY)))
    1089                 :            :      ...
    1090                 :            :      ... (MEM (REGX)) ...
    1091                 :            :      and convert it to
    1092                 :            :      (set (REGZ) (CONST_INT))
    1093                 :            :      ...
    1094                 :            :      ... (MEM (PLUS (REGZ) (REGY)))... .
    1095                 :            : 
    1096                 :            :      First, check that we have (set (REGX) (PLUS (REGX) (REGY)))
    1097                 :            :      and that we know all uses of REGX before it dies.
    1098                 :            :      Also, explicitly check that REGX != REGY; our life information
    1099                 :            :      does not yet show whether REGY changes in this insn.  */
    1100                 :            : 
    1101                 :   12160100 :   if (GET_CODE (src) == PLUS
    1102                 :    1345090 :       && reg_state[regno].all_offsets_match
    1103                 :    1256330 :       && last_index_reg != -1
    1104                 :    1256330 :       && REG_P (XEXP (src, 1))
    1105                 :     335853 :       && rtx_equal_p (XEXP (src, 0), reg)
    1106                 :     205399 :       && !rtx_equal_p (XEXP (src, 1), reg)
    1107                 :   12359300 :       && last_label_ruid < reg_state[regno].use_ruid)
    1108                 :            :     {
    1109                 :     182385 :       rtx base = XEXP (src, 1);
    1110                 :     182385 :       rtx_insn *prev = prev_nonnote_nondebug_insn (insn);
    1111                 :     182385 :       rtx prev_set = prev ? single_set (prev) : NULL_RTX;
    1112                 :     182385 :       rtx index_reg = NULL_RTX;
    1113                 :     182385 :       rtx reg_sum = NULL_RTX;
    1114                 :     182385 :       int i;
    1115                 :            : 
    1116                 :            :       /* Now we need to set INDEX_REG to an index register (denoted as
    1117                 :            :          REGZ in the illustration above) and REG_SUM to the expression
    1118                 :            :          register+register that we want to use to substitute uses of REG
    1119                 :            :          (typically in MEMs) with.  First check REG and BASE for being
    1120                 :            :          index registers; we can use them even if they are not dead.  */
    1121                 :     182385 :       if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], regno)
    1122                 :     182385 :           || TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS],
    1123                 :            :                                 REGNO (base)))
    1124                 :            :         {
    1125                 :            :           index_reg = reg;
    1126                 :            :           reg_sum = src;
    1127                 :            :         }
    1128                 :            :       else
    1129                 :            :         {
    1130                 :            :           /* Otherwise, look for a free index register.  Since we have
    1131                 :            :              checked above that neither REG nor BASE are index registers,
    1132                 :            :              if we find anything at all, it will be different from these
    1133                 :            :              two registers.  */
    1134                 :    2007020 :           for (i = first_index_reg; i <= last_index_reg; i++)
    1135                 :            :             {
    1136                 :    1964870 :               if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], i)
    1137                 :     691481 :                   && reg_state[i].use_index == RELOAD_COMBINE_MAX_USES
    1138                 :     402755 :                   && reg_state[i].store_ruid <= reg_state[regno].use_ruid
    1139                 :     400679 :                   && (crtl->abi->clobbers_full_reg_p (i)
    1140                 :     134786 :                       || df_regs_ever_live_p (i))
    1141                 :     299108 :                   && (!frame_pointer_needed || i != HARD_FRAME_POINTER_REGNUM)
    1142                 :     298352 :                   && !fixed_regs[i] && !global_regs[i]
    1143                 :     224752 :                   && hard_regno_nregs (i, GET_MODE (reg)) == 1
    1144                 :    1986220 :                   && targetm.hard_regno_scratch_ok (i))
    1145                 :            :                 {
    1146                 :      21349 :                   index_reg = gen_rtx_REG (GET_MODE (reg), i);
    1147                 :      21349 :                   reg_sum = gen_rtx_PLUS (GET_MODE (reg), index_reg, base);
    1148                 :      21349 :                   break;
    1149                 :            :                 }
    1150                 :            :             }
    1151                 :            :         }
    1152                 :            : 
    1153                 :            :       /* Check that PREV_SET is indeed (set (REGX) (CONST_INT)) and that
    1154                 :            :          (REGY), i.e. BASE, is not clobbered before the last use we'll
    1155                 :            :          create.  */
    1156                 :     182385 :       if (reg_sum
    1157                 :     182385 :           && prev_set
    1158                 :     136106 :           && CONST_INT_P (SET_SRC (prev_set))
    1159                 :       3339 :           && rtx_equal_p (SET_DEST (prev_set), reg)
    1160                 :     183480 :           && (reg_state[REGNO (base)].store_ruid
    1161                 :       1095 :               <= reg_state[regno].use_ruid))
    1162                 :            :         {
    1163                 :            :           /* Change destination register and, if necessary, the constant
    1164                 :            :              value in PREV, the constant loading instruction.  */
    1165                 :       1077 :           validate_change (prev, &SET_DEST (prev_set), index_reg, 1);
    1166                 :       1077 :           if (reg_state[regno].offset != const0_rtx)
    1167                 :            :             {
    1168                 :          0 :               HOST_WIDE_INT c
    1169                 :          0 :                 = trunc_int_for_mode (UINTVAL (SET_SRC (prev_set))
    1170                 :          0 :                                       + UINTVAL (reg_state[regno].offset),
    1171                 :          0 :                                       GET_MODE (index_reg));
    1172                 :          0 :               validate_change (prev, &SET_SRC (prev_set), GEN_INT (c), 1);
    1173                 :            :             }
    1174                 :            : 
    1175                 :            :           /* Now for every use of REG that we have recorded, replace REG
    1176                 :            :              with REG_SUM.  */
    1177                 :       2208 :           for (i = reg_state[regno].use_index;
    1178                 :       2208 :                i < RELOAD_COMBINE_MAX_USES; i++)
    1179                 :       1131 :             validate_unshare_change (reg_state[regno].reg_use[i].insn,
    1180                 :            :                                      reg_state[regno].reg_use[i].usep,
    1181                 :            :                                      /* Each change must have its own
    1182                 :            :                                         replacement.  */
    1183                 :            :                                      reg_sum, 1);
    1184                 :            : 
    1185                 :       1077 :           if (apply_change_group ())
    1186                 :            :             {
    1187                 :         55 :               struct reg_use *lowest_ruid = NULL;
    1188                 :            : 
    1189                 :            :               /* For every new use of REG_SUM, we have to record the use
    1190                 :            :                  of BASE therein, i.e. operand 1.  */
    1191                 :        128 :               for (i = reg_state[regno].use_index;
    1192                 :        128 :                    i < RELOAD_COMBINE_MAX_USES; i++)
    1193                 :            :                 {
    1194                 :         73 :                   struct reg_use *use = reg_state[regno].reg_use + i;
    1195                 :         73 :                   reload_combine_note_use (&XEXP (*use->usep, 1), use->insn,
    1196                 :            :                                            use->ruid, use->containing_mem);
    1197                 :         73 :                   if (lowest_ruid == NULL || use->ruid < lowest_ruid->ruid)
    1198                 :         73 :                     lowest_ruid = use;
    1199                 :            :                 }
    1200                 :            : 
    1201                 :         55 :               fixup_debug_insns (reg, reg_sum, insn, lowest_ruid->insn);
    1202                 :            : 
    1203                 :            :               /* Delete the reg-reg addition.  */
    1204                 :         55 :               delete_insn (insn);
    1205                 :            : 
    1206                 :         55 :               if (reg_state[regno].offset != const0_rtx
    1207                 :            :                   /* Previous REG_EQUIV / REG_EQUAL notes for PREV
    1208                 :            :                      are now invalid.  */
    1209                 :         55 :                   && remove_reg_equal_equiv_notes (prev))
    1210                 :          0 :                 df_notes_rescan (prev);
    1211                 :            : 
    1212                 :         55 :               reg_state[regno].use_index = RELOAD_COMBINE_MAX_USES;
    1213                 :         55 :               return true;
    1214                 :            :             }
    1215                 :            :         }
    1216                 :            :     }
    1217                 :            :   return false;
    1218                 :            : }
    1219                 :            : 
    1220                 :            : static void
    1221                 :     695030 : reload_combine (void)
    1222                 :            : {
    1223                 :     695030 :   rtx_insn *insn, *prev;
    1224                 :     695030 :   basic_block bb;
    1225                 :     695030 :   unsigned int r;
    1226                 :     695030 :   int min_labelno, n_labels;
    1227                 :     695030 :   HARD_REG_SET ever_live_at_start, *label_live;
    1228                 :            : 
    1229                 :            :   /* To avoid wasting too much time later searching for an index register,
    1230                 :            :      determine the minimum and maximum index register numbers.  */
    1231                 :     695030 :   if (INDEX_REG_CLASS == NO_REGS)
    1232                 :            :     last_index_reg = -1;
    1233                 :     695030 :   else if (first_index_reg == -1 && last_index_reg == 0)
    1234                 :            :     {
    1235                 :    8182250 :       for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1236                 :    8075990 :         if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], r))
    1237                 :            :           {
    1238                 :    1593940 :             if (first_index_reg == -1)
    1239                 :     106263 :               first_index_reg = r;
    1240                 :            : 
    1241                 :    1593940 :             last_index_reg = r;
    1242                 :            :           }
    1243                 :            : 
    1244                 :            :       /* If no index register is available, we can quit now.  Set LAST_INDEX_REG
    1245                 :            :          to -1 so we'll know to quit early the next time we get here.  */
    1246                 :     106263 :       if (first_index_reg == -1)
    1247                 :            :         {
    1248                 :          0 :           last_index_reg = -1;
    1249                 :          0 :           return;
    1250                 :            :         }
    1251                 :            :     }
    1252                 :            : 
    1253                 :            :   /* Set up LABEL_LIVE and EVER_LIVE_AT_START.  The register lifetime
    1254                 :            :      information is a bit fuzzy immediately after reload, but it's
    1255                 :            :      still good enough to determine which registers are live at a jump
    1256                 :            :      destination.  */
    1257                 :     695030 :   min_labelno = get_first_label_num ();
    1258                 :     695030 :   n_labels = max_label_num () - min_labelno;
    1259                 :     695030 :   label_live = XNEWVEC (HARD_REG_SET, n_labels);
    1260                 :     695030 :   CLEAR_HARD_REG_SET (ever_live_at_start);
    1261                 :            : 
    1262                 :    8010150 :   FOR_EACH_BB_REVERSE_FN (bb, cfun)
    1263                 :            :     {
    1264                 :    7315120 :       insn = BB_HEAD (bb);
    1265                 :    7315120 :       if (LABEL_P (insn))
    1266                 :            :         {
    1267                 :    3356540 :           HARD_REG_SET live;
    1268                 :    3356540 :           bitmap live_in = df_get_live_in (bb);
    1269                 :            : 
    1270                 :    6713090 :           REG_SET_TO_HARD_REG_SET (live, live_in);
    1271                 :    3356540 :           compute_use_by_pseudos (&live, live_in);
    1272                 :    3356540 :           LABEL_LIVE (insn) = live;
    1273                 :    6713090 :           ever_live_at_start |= live;
    1274                 :            :         }
    1275                 :            :     }
    1276                 :            : 
    1277                 :            :   /* Initialize last_label_ruid, reload_combine_ruid and reg_state.  */
    1278                 :     695030 :   last_label_ruid = last_jump_ruid = reload_combine_ruid = 0;
    1279                 :   53517300 :   for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1280                 :            :     {
    1281                 :   52822300 :       reg_state[r].store_ruid = 0;
    1282                 :   52822300 :       reg_state[r].real_store_ruid = 0;
    1283                 :   52822300 :       if (fixed_regs[r])
    1284                 :   20754600 :         reg_state[r].use_index = -1;
    1285                 :            :       else
    1286                 :   32067700 :         reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
    1287                 :            :     }
    1288                 :            : 
    1289                 :   87881500 :   for (insn = get_last_insn (); insn; insn = prev)
    1290                 :            :     {
    1291                 :   87186500 :       bool control_flow_insn;
    1292                 :   87186500 :       rtx note;
    1293                 :            : 
    1294                 :   87186500 :       prev = PREV_INSN (insn);
    1295                 :            : 
    1296                 :            :       /* We cannot do our optimization across labels.  Invalidating all the use
    1297                 :            :          information we have would be costly, so we just note where the label
    1298                 :            :          is and then later disable any optimization that would cross it.  */
    1299                 :   87186500 :       if (LABEL_P (insn))
    1300                 :    3359760 :         last_label_ruid = reload_combine_ruid;
    1301                 :   83826700 :       else if (BARRIER_P (insn))
    1302                 :            :         {
    1303                 :            :           /* Crossing a barrier resets all the use information.  */
    1304                 :  149875000 :           for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1305                 :  147929000 :             if (! fixed_regs[r])
    1306                 :   85566800 :               reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
    1307                 :            :         }
    1308                 :   81880300 :       else if (INSN_P (insn) && volatile_insn_p (PATTERN (insn)))
    1309                 :            :         /* Optimizations across insns being marked as volatile must be
    1310                 :            :            prevented.  All the usage information is invalidated
    1311                 :            :            here.  */
    1312                 :   26372000 :         for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1313                 :   26029500 :           if (! fixed_regs[r]
    1314                 :   14873900 :               && reg_state[r].use_index != RELOAD_COMBINE_MAX_USES)
    1315                 :     552101 :             reg_state[r].use_index = -1;
    1316                 :            : 
    1317                 :   87186500 :       if (! NONDEBUG_INSN_P (insn))
    1318                 :   48066400 :         continue;
    1319                 :            : 
    1320                 :   39120100 :       reload_combine_ruid++;
    1321                 :            : 
    1322                 :   39120100 :       control_flow_insn = control_flow_insn_p (insn);
    1323                 :   39120100 :       if (control_flow_insn)
    1324                 :    5605470 :         last_jump_ruid = reload_combine_ruid;
    1325                 :            : 
    1326                 :   39120100 :       if (reload_combine_recognize_const_pattern (insn)
    1327                 :   39120100 :           || reload_combine_recognize_pattern (insn))
    1328                 :        674 :         continue;
    1329                 :            : 
    1330                 :   39119400 :       note_stores (insn, reload_combine_note_store, NULL);
    1331                 :            : 
    1332                 :   39119400 :       if (CALL_P (insn))
    1333                 :            :         {
    1334                 :    3295180 :           rtx link;
    1335                 :    3295180 :           HARD_REG_SET used_regs = insn_callee_abi (insn).full_reg_clobbers ();
    1336                 :            : 
    1337                 :  253729000 :           for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1338                 :  250434000 :             if (TEST_HARD_REG_BIT (used_regs, r))
    1339                 :            :               {
    1340                 :  216616000 :                 reg_state[r].use_index = RELOAD_COMBINE_MAX_USES;
    1341                 :  216616000 :                 reg_state[r].store_ruid = reload_combine_ruid;
    1342                 :            :               }
    1343                 :            : 
    1344                 :    8840920 :           for (link = CALL_INSN_FUNCTION_USAGE (insn); link;
    1345                 :    5545740 :                link = XEXP (link, 1))
    1346                 :            :             {
    1347                 :    5545740 :               rtx setuse = XEXP (link, 0);
    1348                 :    5545740 :               rtx usage_rtx = XEXP (setuse, 0);
    1349                 :            : 
    1350                 :    5545740 :               if (GET_CODE (setuse) == USE && REG_P (usage_rtx))
    1351                 :            :                 {
    1352                 :    5389150 :                   unsigned int end_regno = END_REGNO (usage_rtx);
    1353                 :   10815000 :                   for (unsigned int i = REGNO (usage_rtx); i < end_regno; ++i)
    1354                 :    5425830 :                     reg_state[i].use_index = -1;
    1355                 :            :                  }
    1356                 :            :              }
    1357                 :            :         }
    1358                 :            : 
    1359                 :   39119400 :       if (control_flow_insn && !ANY_RETURN_P (PATTERN (insn)))
    1360                 :            :         {
    1361                 :            :           /* Non-spill registers might be used at the call destination in
    1362                 :            :              some unknown fashion, so we have to mark the unknown use.  */
    1363                 :    5605470 :           HARD_REG_SET *live;
    1364                 :            : 
    1365                 :    6589700 :           if ((condjump_p (insn) || condjump_in_parallel_p (insn))
    1366                 :    5605480 :               && JUMP_LABEL (insn))
    1367                 :            :             {
    1368                 :    4621260 :               if (ANY_RETURN_P (JUMP_LABEL (insn)))
    1369                 :            :                 live = NULL;
    1370                 :            :               else
    1371                 :    4621260 :                 live = &LABEL_LIVE (JUMP_LABEL (insn));
    1372                 :            :             }
    1373                 :            :           else
    1374                 :            :             live = &ever_live_at_start;
    1375                 :            : 
    1376                 :    5605470 :           if (live)
    1377                 :  431621000 :             for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
    1378                 :  426016000 :               if (TEST_HARD_REG_BIT (*live, r))
    1379                 :   25784300 :                 reg_state[r].use_index = -1;
    1380                 :            :         }
    1381                 :            : 
    1382                 :   39119400 :       reload_combine_note_use (&PATTERN (insn), insn, reload_combine_ruid,
    1383                 :            :                                NULL_RTX);
    1384                 :            : 
    1385                 :   54621300 :       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    1386                 :            :         {
    1387                 :   15501900 :           if (REG_NOTE_KIND (note) == REG_INC && REG_P (XEXP (note, 0)))
    1388                 :            :             {
    1389                 :          0 :               int regno = REGNO (XEXP (note, 0));
    1390                 :          0 :               reg_state[regno].store_ruid = reload_combine_ruid;
    1391                 :          0 :               reg_state[regno].real_store_ruid = reload_combine_ruid;
    1392                 :          0 :               reg_state[regno].use_index = -1;
    1393                 :            :             }
    1394                 :            :         }
    1395                 :            :     }
    1396                 :            : 
    1397                 :     695030 :   free (label_live);
    1398                 :            : }
    1399                 :            : 
    1400                 :            : /* Check if DST is a register or a subreg of a register; if it is,
    1401                 :            :    update store_ruid, real_store_ruid and use_index in the reg_state
    1402                 :            :    structure accordingly.  Called via note_stores from reload_combine.  */
    1403                 :            : 
    1404                 :            : static void
    1405                 :   41656600 : reload_combine_note_store (rtx dst, const_rtx set, void *data ATTRIBUTE_UNUSED)
    1406                 :            : {
    1407                 :   41656600 :   int regno = 0;
    1408                 :   41656600 :   int i;
    1409                 :   41656600 :   machine_mode mode = GET_MODE (dst);
    1410                 :            : 
    1411                 :   41656600 :   if (GET_CODE (dst) == SUBREG)
    1412                 :            :     {
    1413                 :          0 :       regno = subreg_regno_offset (REGNO (SUBREG_REG (dst)),
    1414                 :          0 :                                    GET_MODE (SUBREG_REG (dst)),
    1415                 :          0 :                                    SUBREG_BYTE (dst),
    1416                 :            :                                    GET_MODE (dst));
    1417                 :          0 :       dst = SUBREG_REG (dst);
    1418                 :            :     }
    1419                 :            : 
    1420                 :            :   /* Some targets do argument pushes without adding REG_INC notes.  */
    1421                 :            : 
    1422                 :   41656600 :   if (MEM_P (dst))
    1423                 :            :     {
    1424                 :    8004650 :       dst = XEXP (dst, 0);
    1425                 :    8004650 :       if (GET_CODE (dst) == PRE_INC || GET_CODE (dst) == POST_INC
    1426                 :    8004650 :           || GET_CODE (dst) == PRE_DEC || GET_CODE (dst) == POST_DEC
    1427                 :    6416650 :           || GET_CODE (dst) == PRE_MODIFY || GET_CODE (dst) == POST_MODIFY)
    1428                 :            :         {
    1429                 :    1649630 :           unsigned int end_regno = END_REGNO (XEXP (dst, 0));
    1430                 :    3299260 :           for (unsigned int i = REGNO (XEXP (dst, 0)); i < end_regno; ++i)
    1431                 :            :             {
    1432                 :            :               /* We could probably do better, but for now mark the register
    1433                 :            :                  as used in an unknown fashion and set/clobbered at this
    1434                 :            :                  insn.  */
    1435                 :    1649630 :               reg_state[i].use_index = -1;
    1436                 :    1649630 :               reg_state[i].store_ruid = reload_combine_ruid;
    1437                 :    1649630 :               reg_state[i].real_store_ruid = reload_combine_ruid;
    1438                 :            :             }
    1439                 :            :         }
    1440                 :            :       else
    1441                 :            :         return;
    1442                 :            :     }
    1443                 :            : 
    1444                 :   35301600 :   if (!REG_P (dst))
    1445                 :            :     return;
    1446                 :   29023700 :   regno += REGNO (dst);
    1447                 :            : 
    1448                 :            :   /* note_stores might have stripped a STRICT_LOW_PART, so we have to be
    1449                 :            :      careful with registers / register parts that are not full words.
    1450                 :            :      Similarly for ZERO_EXTRACT.  */
    1451                 :   29023700 :   if (GET_CODE (SET_DEST (set)) == ZERO_EXTRACT
    1452                 :   29023100 :       || GET_CODE (SET_DEST (set)) == STRICT_LOW_PART)
    1453                 :            :     {
    1454                 :       4812 :       for (i = end_hard_regno (mode, regno) - 1; i >= regno; i--)
    1455                 :            :         {
    1456                 :       2406 :           reg_state[i].use_index = -1;
    1457                 :       2406 :           reg_state[i].store_ruid = reload_combine_ruid;
    1458                 :       2406 :           reg_state[i].real_store_ruid = reload_combine_ruid;
    1459                 :            :         }
    1460                 :            :     }
    1461                 :            :   else
    1462                 :            :     {
    1463                 :   58363000 :       for (i = end_hard_regno (mode, regno) - 1; i >= regno; i--)
    1464                 :            :         {
    1465                 :   29341800 :           reg_state[i].store_ruid = reload_combine_ruid;
    1466                 :   29341800 :           if (GET_CODE (set) == SET)
    1467                 :   24581100 :             reg_state[i].real_store_ruid = reload_combine_ruid;
    1468                 :   29341800 :           reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
    1469                 :            :         }
    1470                 :            :     }
    1471                 :            : }
    1472                 :            : 
    1473                 :            : /* XP points to a piece of rtl that has to be checked for any uses of
    1474                 :            :    registers.
    1475                 :            :    *XP is the pattern of INSN, or a part of it.
    1476                 :            :    Called from reload_combine, and recursively by itself.  */
    1477                 :            : static void
    1478                 :  140471000 : reload_combine_note_use (rtx *xp, rtx_insn *insn, int ruid, rtx containing_mem)
    1479                 :            : {
    1480                 :  164734000 :   rtx x = *xp;
    1481                 :  164734000 :   enum rtx_code code = x->code;
    1482                 :  164734000 :   const char *fmt;
    1483                 :  164734000 :   int i, j;
    1484                 :  164734000 :   rtx offset = const0_rtx; /* For the REG case below.  */
    1485                 :            : 
    1486                 :  164734000 :   switch (code)
    1487                 :            :     {
    1488                 :   36874100 :     case SET:
    1489                 :   36874100 :       if (REG_P (SET_DEST (x)))
    1490                 :            :         {
    1491                 :   24263300 :           reload_combine_note_use (&SET_SRC (x), insn, ruid, NULL_RTX);
    1492                 :   24263300 :           return;
    1493                 :            :         }
    1494                 :            :       break;
    1495                 :            : 
    1496                 :     455941 :     case USE:
    1497                 :            :       /* If this is the USE of a return value, we can't change it.  */
    1498                 :     455941 :       if (REG_P (XEXP (x, 0)) && REG_FUNCTION_VALUE_P (XEXP (x, 0)))
    1499                 :            :         {
    1500                 :            :           /* Mark the return register as used in an unknown fashion.  */
    1501                 :     360018 :           rtx reg = XEXP (x, 0);
    1502                 :     360018 :           unsigned int end_regno = END_REGNO (reg);
    1503                 :     741647 :           for (unsigned int regno = REGNO (reg); regno < end_regno; ++regno)
    1504                 :     381629 :             reg_state[regno].use_index = -1;
    1505                 :            :           return;
    1506                 :            :         }
    1507                 :            :       break;
    1508                 :            : 
    1509                 :    4684000 :     case CLOBBER:
    1510                 :    4684000 :       if (REG_P (SET_DEST (x)))
    1511                 :            :         {
    1512                 :            :           /* No spurious CLOBBERs of pseudo registers may remain.  */
    1513                 :    4646060 :           gcc_assert (REGNO (SET_DEST (x)) < FIRST_PSEUDO_REGISTER);
    1514                 :            :           return;
    1515                 :            :         }
    1516                 :            :       break;
    1517                 :            : 
    1518                 :   15543000 :     case PLUS:
    1519                 :            :       /* We are interested in (plus (reg) (const_int)) .  */
    1520                 :   15543000 :       if (!REG_P (XEXP (x, 0))
    1521                 :   14079200 :           || !CONST_INT_P (XEXP (x, 1)))
    1522                 :            :         break;
    1523                 :            :       offset = XEXP (x, 1);
    1524                 :            :       x = XEXP (x, 0);
    1525                 :            :       /* Fall through.  */
    1526                 :   38555600 :     case REG:
    1527                 :   38555600 :       {
    1528                 :   38555600 :         int regno = REGNO (x);
    1529                 :   38555600 :         int use_index;
    1530                 :   38555600 :         int nregs;
    1531                 :            : 
    1532                 :            :         /* No spurious USEs of pseudo registers may remain.  */
    1533                 :   38555600 :         gcc_assert (regno < FIRST_PSEUDO_REGISTER);
    1534                 :            : 
    1535                 :   38555600 :         nregs = REG_NREGS (x);
    1536                 :            : 
    1537                 :            :         /* We can't substitute into multi-hard-reg uses.  */
    1538                 :   38555600 :         if (nregs > 1)
    1539                 :            :           {
    1540                 :     681096 :             while (--nregs >= 0)
    1541                 :     454156 :               reg_state[regno + nregs].use_index = -1;
    1542                 :            :             return;
    1543                 :            :           }
    1544                 :            : 
    1545                 :            :         /* We may be called to update uses in previously seen insns.
    1546                 :            :            Don't add uses beyond the last store we saw.  */
    1547                 :   38328700 :         if (ruid < reg_state[regno].store_ruid)
    1548                 :            :           return;
    1549                 :            : 
    1550                 :            :         /* If this register is already used in some unknown fashion, we
    1551                 :            :            can't do anything.
    1552                 :            :            If we decrement the index from zero to -1, we can't store more
    1553                 :            :            uses, so this register becomes used in an unknown fashion.  */
    1554                 :   38322500 :         use_index = --reg_state[regno].use_index;
    1555                 :   38322500 :         if (use_index < 0)
    1556                 :            :           return;
    1557                 :            : 
    1558                 :   22368800 :         if (use_index == RELOAD_COMBINE_MAX_USES - 1)
    1559                 :            :           {
    1560                 :            :             /* This is the first use of this register we have seen since we
    1561                 :            :                marked it as dead.  */
    1562                 :   16868500 :             reg_state[regno].offset = offset;
    1563                 :   16868500 :             reg_state[regno].all_offsets_match = true;
    1564                 :   16868500 :             reg_state[regno].use_ruid = ruid;
    1565                 :            :           }
    1566                 :            :         else
    1567                 :            :           {
    1568                 :    5500340 :             if (reg_state[regno].use_ruid > ruid)
    1569                 :       1122 :               reg_state[regno].use_ruid = ruid;
    1570                 :            : 
    1571                 :    5500340 :             if (! rtx_equal_p (offset, reg_state[regno].offset))
    1572                 :    2557370 :               reg_state[regno].all_offsets_match = false;
    1573                 :            :           }
    1574                 :            : 
    1575                 :   22368800 :         reg_state[regno].reg_use[use_index].insn = insn;
    1576                 :   22368800 :         reg_state[regno].reg_use[use_index].ruid = ruid;
    1577                 :   22368800 :         reg_state[regno].reg_use[use_index].containing_mem = containing_mem;
    1578                 :   22368800 :         reg_state[regno].reg_use[use_index].usep = xp;
    1579                 :   22368800 :         return;
    1580                 :            :       }
    1581                 :            : 
    1582                 :   19007200 :     case MEM:
    1583                 :   19007200 :       containing_mem = x;
    1584                 :   19007200 :       break;
    1585                 :            : 
    1586                 :            :     default:
    1587                 :            :       break;
    1588                 :            :     }
    1589                 :            : 
    1590                 :            :   /* Recursively process the components of X.  */
    1591                 :   96909100 :   fmt = GET_RTX_FORMAT (code);
    1592                 :  249018000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1593                 :            :     {
    1594                 :  152109000 :       if (fmt[i] == 'e')
    1595                 :   89031800 :         reload_combine_note_use (&XEXP (x, i), insn, ruid, containing_mem);
    1596                 :   63076800 :       else if (fmt[i] == 'E')
    1597                 :            :         {
    1598                 :   18623400 :           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1599                 :   12305600 :             reload_combine_note_use (&XVECEXP (x, i, j), insn, ruid,
    1600                 :            :                                      containing_mem);
    1601                 :            :         }
    1602                 :            :     }
    1603                 :            : }
    1604                 :            : 
    1605                 :            : /* See if we can reduce the cost of a constant by replacing a move
    1606                 :            :    with an add.  We track situations in which a register is set to a
    1607                 :            :    constant or to a register plus a constant.  */
    1608                 :            : /* We cannot do our optimization across labels.  Invalidating all the
    1609                 :            :    information about register contents we have would be costly, so we
    1610                 :            :    use move2add_last_label_luid to note where the label is and then
    1611                 :            :    later disable any optimization that would cross it.
    1612                 :            :    reg_offset[n] / reg_base_reg[n] / reg_symbol_ref[n] / reg_mode[n]
    1613                 :            :    are only valid if reg_set_luid[n] is greater than
    1614                 :            :    move2add_last_label_luid.
    1615                 :            :    For a set that established a new (potential) base register with
    1616                 :            :    non-constant value, we use move2add_luid from the place where the
    1617                 :            :    setting insn is encountered; registers based off that base then
    1618                 :            :    get the same reg_set_luid.  Constants all get
    1619                 :            :    move2add_last_label_luid + 1 as their reg_set_luid.  */
    1620                 :            : static int reg_set_luid[FIRST_PSEUDO_REGISTER];
    1621                 :            : 
    1622                 :            : /* If reg_base_reg[n] is negative, register n has been set to
    1623                 :            :    reg_offset[n] or reg_symbol_ref[n] + reg_offset[n] in mode reg_mode[n].
    1624                 :            :    If reg_base_reg[n] is non-negative, register n has been set to the
    1625                 :            :    sum of reg_offset[n] and the value of register reg_base_reg[n]
    1626                 :            :    before reg_set_luid[n], calculated in mode reg_mode[n] .
    1627                 :            :    For multi-hard-register registers, all but the first one are
    1628                 :            :    recorded as BLKmode in reg_mode.  Setting reg_mode to VOIDmode
    1629                 :            :    marks it as invalid.  */
    1630                 :            : static HOST_WIDE_INT reg_offset[FIRST_PSEUDO_REGISTER];
    1631                 :            : static int reg_base_reg[FIRST_PSEUDO_REGISTER];
    1632                 :            : static rtx reg_symbol_ref[FIRST_PSEUDO_REGISTER];
    1633                 :            : static machine_mode reg_mode[FIRST_PSEUDO_REGISTER];
    1634                 :            : 
    1635                 :            : /* move2add_luid is linearly increased while scanning the instructions
    1636                 :            :    from first to last.  It is used to set reg_set_luid in
    1637                 :            :    reload_cse_move2add and move2add_note_store.  */
    1638                 :            : static int move2add_luid;
    1639                 :            : 
    1640                 :            : /* move2add_last_label_luid is set whenever a label is found.  Labels
    1641                 :            :    invalidate all previously collected reg_offset data.  */
    1642                 :            : static int move2add_last_label_luid;
    1643                 :            : 
    1644                 :            : /* ??? We don't know how zero / sign extension is handled, hence we
    1645                 :            :    can't go from a narrower to a wider mode.  */
    1646                 :            : #define MODES_OK_FOR_MOVE2ADD(OUTMODE, INMODE) \
    1647                 :            :   (GET_MODE_SIZE (OUTMODE) == GET_MODE_SIZE (INMODE) \
    1648                 :            :    || (GET_MODE_SIZE (OUTMODE) <= GET_MODE_SIZE (INMODE) \
    1649                 :            :        && TRULY_NOOP_TRUNCATION_MODES_P (OUTMODE, INMODE)))
    1650                 :            : 
    1651                 :            : /* Record that REG is being set to a value with the mode of REG.  */
    1652                 :            : 
    1653                 :            : static void
    1654                 :   32809500 : move2add_record_mode (rtx reg)
    1655                 :            : {
    1656                 :   32809500 :   int regno, nregs;
    1657                 :   32809500 :   machine_mode mode = GET_MODE (reg);
    1658                 :            : 
    1659                 :   32809500 :   if (GET_CODE (reg) == SUBREG)
    1660                 :            :     {
    1661                 :          0 :       regno = subreg_regno (reg);
    1662                 :          0 :       nregs = subreg_nregs (reg);
    1663                 :            :     }
    1664                 :   32809500 :   else if (REG_P (reg))
    1665                 :            :     {
    1666                 :   32809500 :       regno = REGNO (reg);
    1667                 :   32809500 :       nregs = REG_NREGS (reg);
    1668                 :            :     }
    1669                 :            :   else
    1670                 :          0 :     gcc_unreachable ();
    1671                 :   33144300 :   for (int i = nregs - 1; i > 0; i--)
    1672                 :     334863 :     reg_mode[regno + i] = BLKmode;
    1673                 :   32809500 :   reg_mode[regno] = mode;
    1674                 :   32809500 : }
    1675                 :            : 
    1676                 :            : /* Record that REG is being set to the sum of SYM and OFF.  */
    1677                 :            : 
    1678                 :            : static void
    1679                 :    1262710 : move2add_record_sym_value (rtx reg, rtx sym, rtx off)
    1680                 :            : {
    1681                 :          0 :   int regno = REGNO (reg);
    1682                 :            : 
    1683                 :    1262710 :   move2add_record_mode (reg);
    1684                 :    1262710 :   reg_set_luid[regno] = move2add_luid;
    1685                 :    1262710 :   reg_base_reg[regno] = -1;
    1686                 :    1262710 :   reg_symbol_ref[regno] = sym;
    1687                 :    1262710 :   reg_offset[regno] = INTVAL (off);
    1688                 :          0 : }
    1689                 :            : 
    1690                 :            : /* Check if REGNO contains a valid value in MODE.  */
    1691                 :            : 
    1692                 :            : static bool
    1693                 :  104849000 : move2add_valid_value_p (int regno, scalar_int_mode mode)
    1694                 :            : {
    1695                 :  104849000 :   if (reg_set_luid[regno] <= move2add_last_label_luid)
    1696                 :            :     return false;
    1697                 :            : 
    1698                 :   11439400 :   if (mode != reg_mode[regno])
    1699                 :            :     {
    1700                 :    6253930 :       scalar_int_mode old_mode;
    1701                 :    6253930 :       if (!is_a <scalar_int_mode> (reg_mode[regno], &old_mode)
    1702                 :    3649620 :           || !MODES_OK_FOR_MOVE2ADD (mode, old_mode))
    1703                 :    5941010 :         return false;
    1704                 :            :       /* The value loaded into regno in reg_mode[regno] is also valid in
    1705                 :            :          mode after truncation only if (REG:mode regno) is the lowpart of
    1706                 :            :          (REG:reg_mode[regno] regno).  Now, for big endian, the starting
    1707                 :            :          regno of the lowpart might be different.  */
    1708                 :     312918 :       poly_int64 s_off = subreg_lowpart_offset (mode, old_mode);
    1709                 :     312918 :       s_off = subreg_regno_offset (regno, old_mode, s_off, mode);
    1710                 :     312918 :       if (maybe_ne (s_off, 0))
    1711                 :            :         /* We could in principle adjust regno, check reg_mode[regno] to be
    1712                 :            :            BLKmode, and return s_off to the caller (vs. -1 for failure),
    1713                 :            :            but we currently have no callers that could make use of this
    1714                 :            :            information.  */
    1715                 :            :         return false;
    1716                 :            :     }
    1717                 :            : 
    1718                 :    5505980 :   for (int i = end_hard_regno (mode, regno) - 1; i > regno; i--)
    1719                 :       9138 :     if (reg_mode[i] != BLKmode)
    1720                 :            :       return false;
    1721                 :            :   return true;
    1722                 :            : }
    1723                 :            : 
    1724                 :            : /* This function is called with INSN that sets REG (of mode MODE)
    1725                 :            :    to (SYM + OFF), while REG is known to already have value (SYM + offset).
    1726                 :            :    This function tries to change INSN into an add instruction
    1727                 :            :    (set (REG) (plus (REG) (OFF - offset))) using the known value.
    1728                 :            :    It also updates the information about REG's known value.
    1729                 :            :    Return true if we made a change.  */
    1730                 :            : 
    1731                 :            : static bool
    1732                 :      96606 : move2add_use_add2_insn (scalar_int_mode mode, rtx reg, rtx sym, rtx off,
    1733                 :            :                         rtx_insn *insn)
    1734                 :            : {
    1735                 :      96606 :   rtx pat = PATTERN (insn);
    1736                 :      96606 :   rtx src = SET_SRC (pat);
    1737                 :      96606 :   int regno = REGNO (reg);
    1738                 :      96606 :   rtx new_src = gen_int_mode (UINTVAL (off) - reg_offset[regno], mode);
    1739                 :      96606 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
    1740                 :      96606 :   bool changed = false;
    1741                 :            : 
    1742                 :            :   /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
    1743                 :            :      use (set (reg) (reg)) instead.
    1744                 :            :      We don't delete this insn, nor do we convert it into a
    1745                 :            :      note, to avoid losing register notes or the return
    1746                 :            :      value flag.  jump2 already knows how to get rid of
    1747                 :            :      no-op moves.  */
    1748                 :      96606 :   if (new_src == const0_rtx)
    1749                 :            :     {
    1750                 :            :       /* If the constants are different, this is a
    1751                 :            :          truncation, that, if turned into (set (reg)
    1752                 :            :          (reg)), would be discarded.  Maybe we should
    1753                 :            :          try a truncMN pattern?  */
    1754                 :      11208 :       if (INTVAL (off) == reg_offset [regno])
    1755                 :      10296 :         changed = validate_change (insn, &SET_SRC (pat), reg, 0);
    1756                 :            :     }
    1757                 :            :   else
    1758                 :            :     {
    1759                 :      85398 :       struct full_rtx_costs oldcst, newcst;
    1760                 :      85398 :       rtx tem = gen_rtx_PLUS (mode, reg, new_src);
    1761                 :            : 
    1762                 :      85398 :       get_full_set_rtx_cost (pat, &oldcst);
    1763                 :      85398 :       SET_SRC (pat) = tem;
    1764                 :      85398 :       get_full_set_rtx_cost (pat, &newcst);
    1765                 :      85398 :       SET_SRC (pat) = src;
    1766                 :            : 
    1767                 :      85398 :       if (costs_lt_p (&newcst, &oldcst, speed)
    1768                 :       2658 :           && have_add2_insn (reg, new_src))
    1769                 :       2658 :         changed = validate_change (insn, &SET_SRC (pat), tem, 0);   
    1770                 :      82740 :       else if (sym == NULL_RTX && mode != BImode)
    1771                 :            :         {
    1772                 :      82621 :           scalar_int_mode narrow_mode;
    1773                 :     269991 :           FOR_EACH_MODE_UNTIL (narrow_mode, mode)
    1774                 :            :             {
    1775                 :     187370 :               if (have_insn_for (STRICT_LOW_PART, narrow_mode)
    1776                 :     187370 :                   && ((reg_offset[regno] & ~GET_MODE_MASK (narrow_mode))
    1777                 :     147562 :                       == (INTVAL (off) & ~GET_MODE_MASK (narrow_mode))))
    1778                 :            :                 {
    1779                 :      63081 :                   rtx narrow_reg = gen_lowpart_common (narrow_mode, reg);
    1780                 :      63081 :                   rtx narrow_src = gen_int_mode (INTVAL (off),
    1781                 :            :                                                  narrow_mode);
    1782                 :      63081 :                   rtx new_set
    1783                 :      63081 :                     = gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode,
    1784                 :            :                                                             narrow_reg),
    1785                 :            :                                    narrow_src);
    1786                 :      63081 :                   get_full_set_rtx_cost (new_set, &newcst);
    1787                 :     250451 :                   if (costs_lt_p (&newcst, &oldcst, speed))
    1788                 :            :                     {
    1789                 :          0 :                       changed = validate_change (insn, &PATTERN (insn),
    1790                 :            :                                                  new_set, 0);
    1791                 :          0 :                       if (changed)
    1792                 :            :                         break;
    1793                 :            :                     }
    1794                 :            :                 }
    1795                 :            :             }
    1796                 :            :         }
    1797                 :            :     }
    1798                 :      96606 :   move2add_record_sym_value (reg, sym, off);
    1799                 :      96606 :   return changed;
    1800                 :            : }
    1801                 :            : 
    1802                 :            : 
    1803                 :            : /* This function is called with INSN that sets REG (of mode MODE) to
    1804                 :            :    (SYM + OFF), but REG doesn't have known value (SYM + offset).  This
    1805                 :            :    function tries to find another register which is known to already have
    1806                 :            :    value (SYM + offset) and change INSN into an add instruction
    1807                 :            :    (set (REG) (plus (the found register) (OFF - offset))) if such
    1808                 :            :    a register is found.  It also updates the information about
    1809                 :            :    REG's known value.
    1810                 :            :    Return true iff we made a change.  */
    1811                 :            : 
    1812                 :            : static bool
    1813                 :    1103990 : move2add_use_add3_insn (scalar_int_mode mode, rtx reg, rtx sym, rtx off,
    1814                 :            :                         rtx_insn *insn)
    1815                 :            : {
    1816                 :    1103990 :   rtx pat = PATTERN (insn);
    1817                 :    1103990 :   rtx src = SET_SRC (pat);
    1818                 :    1103990 :   int regno = REGNO (reg);
    1819                 :    1103990 :   int min_regno = 0;
    1820                 :    1103990 :   bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
    1821                 :    1103990 :   int i;
    1822                 :    1103990 :   bool changed = false;
    1823                 :    1103990 :   struct full_rtx_costs oldcst, newcst, mincst;
    1824                 :    1103990 :   rtx plus_expr;
    1825                 :            : 
    1826                 :    1103990 :   init_costs_to_max (&mincst);
    1827                 :    1103990 :   get_full_set_rtx_cost (pat, &oldcst);
    1828                 :            : 
    1829                 :    1103990 :   plus_expr = gen_rtx_PLUS (GET_MODE (reg), reg, const0_rtx);
    1830                 :    1103990 :   SET_SRC (pat) = plus_expr;
    1831                 :            : 
    1832                 :   85007100 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    1833                 :   83903100 :     if (move2add_valid_value_p (i, mode)
    1834                 :    2331010 :         && reg_base_reg[i] < 0
    1835                 :     858922 :         && reg_symbol_ref[i] != NULL_RTX
    1836                 :   84413200 :         && rtx_equal_p (sym, reg_symbol_ref[i]))
    1837                 :            :       {
    1838                 :      15282 :         rtx new_src = gen_int_mode (UINTVAL (off) - reg_offset[i],
    1839                 :       7641 :                                     GET_MODE (reg));
    1840                 :            :         /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
    1841                 :            :            use (set (reg) (reg)) instead.
    1842                 :            :            We don't delete this insn, nor do we convert it into a
    1843                 :            :            note, to avoid losing register notes or the return
    1844                 :            :            value flag.  jump2 already knows how to get rid of
    1845                 :            :            no-op moves.  */
    1846                 :       7641 :         if (new_src == const0_rtx)
    1847                 :            :           {
    1848                 :            :             init_costs_to_zero (&mincst);
    1849                 :            :             min_regno = i;
    1850                 :            :             break;
    1851                 :            :           }
    1852                 :            :         else
    1853                 :            :           {
    1854                 :       7641 :             XEXP (plus_expr, 1) = new_src;
    1855                 :       7641 :             get_full_set_rtx_cost (pat, &newcst);
    1856                 :            : 
    1857                 :   83910700 :             if (costs_lt_p (&newcst, &mincst, speed))
    1858                 :            :               {
    1859                 :       6822 :                 mincst = newcst;
    1860                 :       6822 :                 min_regno = i;
    1861                 :            :               }
    1862                 :            :           }
    1863                 :            :       }
    1864                 :    1103990 :   SET_SRC (pat) = src;
    1865                 :            : 
    1866                 :    1103990 :   if (costs_lt_p (&mincst, &oldcst, speed))
    1867                 :            :     {
    1868                 :        530 :       rtx tem;
    1869                 :            : 
    1870                 :        530 :       tem = gen_rtx_REG (GET_MODE (reg), min_regno);
    1871                 :        530 :       if (i != min_regno)
    1872                 :            :         {
    1873                 :       1060 :           rtx new_src = gen_int_mode (UINTVAL (off) - reg_offset[min_regno],
    1874                 :        530 :                                       GET_MODE (reg));
    1875                 :        530 :           tem = gen_rtx_PLUS (GET_MODE (reg), tem, new_src);
    1876                 :            :         }
    1877                 :        530 :       if (validate_change (insn, &SET_SRC (pat), tem, 0))
    1878                 :        530 :         changed = true;
    1879                 :            :     }
    1880                 :    1103990 :   reg_set_luid[regno] = move2add_luid;
    1881                 :    1103990 :   move2add_record_sym_value (reg, sym, off);
    1882                 :    1103990 :   return changed;
    1883                 :            : }
    1884                 :            : 
    1885                 :            : /* Convert move insns with constant inputs to additions if they are cheaper.
    1886                 :            :    Return true if any changes were made.  */
    1887                 :            : static bool
    1888                 :     688548 : reload_cse_move2add (rtx_insn *first)
    1889                 :            : {
    1890                 :     688548 :   int i;
    1891                 :     688548 :   rtx_insn *insn;
    1892                 :     688548 :   bool changed = false;
    1893                 :            : 
    1894                 :   53018200 :   for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--)
    1895                 :            :     {
    1896                 :   52329600 :       reg_set_luid[i] = 0;
    1897                 :   52329600 :       reg_offset[i] = 0;
    1898                 :   52329600 :       reg_base_reg[i] = 0;
    1899                 :   52329600 :       reg_symbol_ref[i] = NULL_RTX;
    1900                 :   52329600 :       reg_mode[i] = VOIDmode;
    1901                 :            :     }
    1902                 :            : 
    1903                 :     688548 :   move2add_last_label_luid = 0;
    1904                 :     688548 :   move2add_luid = 2;
    1905                 :   84092200 :   for (insn = first; insn; insn = NEXT_INSN (insn), move2add_luid++)
    1906                 :            :     {
    1907                 :   83403700 :       rtx pat, note;
    1908                 :            : 
    1909                 :   83403700 :       if (LABEL_P (insn))
    1910                 :            :         {
    1911                 :    3219480 :           move2add_last_label_luid = move2add_luid;
    1912                 :            :           /* We're going to increment move2add_luid twice after a
    1913                 :            :              label, so that we can use move2add_last_label_luid + 1 as
    1914                 :            :              the luid for constants.  */
    1915                 :    3219480 :           move2add_luid++;
    1916                 :   83403700 :           continue;
    1917                 :            :         }
    1918                 :   80184200 :       if (! INSN_P (insn))
    1919                 :   14934600 :         continue;
    1920                 :   65249600 :       pat = PATTERN (insn);
    1921                 :            :       /* For simplicity, we only perform this optimization on
    1922                 :            :          straightforward SETs.  */
    1923                 :   65249600 :       scalar_int_mode mode;
    1924                 :   65249600 :       if (GET_CODE (pat) == SET
    1925                 :   30177500 :           && REG_P (SET_DEST (pat))
    1926                 :   83617200 :           && is_a <scalar_int_mode> (GET_MODE (SET_DEST (pat)), &mode))
    1927                 :            :         {
    1928                 :   13068100 :           rtx reg = SET_DEST (pat);
    1929                 :   13068100 :           int regno = REGNO (reg);
    1930                 :   13068100 :           rtx src = SET_SRC (pat);
    1931                 :            : 
    1932                 :            :           /* Check if we have valid information on the contents of this
    1933                 :            :              register in the mode of REG.  */
    1934                 :   13068100 :           if (move2add_valid_value_p (regno, mode)
    1935                 :   13068100 :               && dbg_cnt (cse2_move2add))
    1936                 :            :             {
    1937                 :            :               /* Try to transform (set (REGX) (CONST_INT A))
    1938                 :            :                                   ...
    1939                 :            :                                   (set (REGX) (CONST_INT B))
    1940                 :            :                  to
    1941                 :            :                                   (set (REGX) (CONST_INT A))
    1942                 :            :                                   ...
    1943                 :            :                                   (set (REGX) (plus (REGX) (CONST_INT B-A)))
    1944                 :            :                  or
    1945                 :            :                                   (set (REGX) (CONST_INT A))
    1946                 :            :                                   ...
    1947                 :            :                                   (set (STRICT_LOW_PART (REGX)) (CONST_INT B))
    1948                 :            :               */
    1949                 :            : 
    1950                 :    1317770 :               if (CONST_INT_P (src)
    1951                 :     189179 :                   && reg_base_reg[regno] < 0
    1952                 :      98438 :                   && reg_symbol_ref[regno] == NULL_RTX)
    1953                 :            :                 {
    1954                 :      96230 :                   changed |= move2add_use_add2_insn (mode, reg, NULL_RTX,
    1955                 :            :                                                      src, insn);
    1956                 :      96230 :                   continue;
    1957                 :            :                 }
    1958                 :            : 
    1959                 :            :               /* Try to transform (set (REGX) (REGY))
    1960                 :            :                                   (set (REGX) (PLUS (REGX) (CONST_INT A)))
    1961                 :            :                                   ...
    1962                 :            :                                   (set (REGX) (REGY))
    1963                 :            :                                   (set (REGX) (PLUS (REGX) (CONST_INT B)))
    1964                 :            :                  to
    1965                 :            :                                   (set (REGX) (REGY))
    1966                 :            :                                   (set (REGX) (PLUS (REGX) (CONST_INT A)))
    1967                 :            :                                   ...
    1968                 :            :                                   (set (REGX) (plus (REGX) (CONST_INT B-A)))  */
    1969                 :    1221540 :               else if (REG_P (src)
    1970                 :     295216 :                        && reg_set_luid[regno] == reg_set_luid[REGNO (src)]
    1971                 :      90306 :                        && reg_base_reg[regno] == reg_base_reg[REGNO (src)]
    1972                 :    1311850 :                        && move2add_valid_value_p (REGNO (src), mode))
    1973                 :            :                 {
    1974                 :      70967 :                   rtx_insn *next = next_nonnote_nondebug_insn (insn);
    1975                 :      70967 :                   rtx set = NULL_RTX;
    1976                 :      70967 :                   if (next)
    1977                 :      70932 :                     set = single_set (next);
    1978                 :      70932 :                   if (set
    1979                 :      56907 :                       && SET_DEST (set) == reg
    1980                 :       3999 :                       && GET_CODE (SET_SRC (set)) == PLUS
    1981                 :        288 :                       && XEXP (SET_SRC (set), 0) == reg
    1982                 :        288 :                       && CONST_INT_P (XEXP (SET_SRC (set), 1)))
    1983                 :            :                     {
    1984                 :        138 :                       rtx src3 = XEXP (SET_SRC (set), 1);
    1985                 :        138 :                       unsigned HOST_WIDE_INT added_offset = UINTVAL (src3);
    1986                 :        138 :                       HOST_WIDE_INT base_offset = reg_offset[REGNO (src)];
    1987                 :        138 :                       HOST_WIDE_INT regno_offset = reg_offset[regno];
    1988                 :        138 :                       rtx new_src =
    1989                 :        276 :                         gen_int_mode (added_offset
    1990                 :        138 :                                       + base_offset
    1991                 :        138 :                                       - regno_offset,
    1992                 :            :                                       mode);
    1993                 :        138 :                       bool success = false;
    1994                 :        138 :                       bool speed = optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn));
    1995                 :            : 
    1996                 :        138 :                       if (new_src == const0_rtx)
    1997                 :            :                         /* See above why we create (set (reg) (reg)) here.  */
    1998                 :         11 :                         success
    1999                 :         11 :                           = validate_change (next, &SET_SRC (set), reg, 0);
    2000                 :            :                       else
    2001                 :            :                         {
    2002                 :        127 :                           rtx old_src = SET_SRC (set);
    2003                 :        127 :                           struct full_rtx_costs oldcst, newcst;
    2004                 :        127 :                           rtx tem = gen_rtx_PLUS (mode, reg, new_src);
    2005                 :            : 
    2006                 :        127 :                           get_full_set_rtx_cost (set, &oldcst);
    2007                 :        127 :                           SET_SRC (set) = tem;
    2008                 :        127 :                           get_full_set_src_cost (tem, mode, &newcst);
    2009                 :        127 :                           SET_SRC (set) = old_src;
    2010                 :        127 :                           costs_add_n_insns (&oldcst, 1);
    2011                 :            : 
    2012                 :        127 :                           if (costs_lt_p (&newcst, &oldcst, speed)
    2013                 :        127 :                               && have_add2_insn (reg, new_src))
    2014                 :            :                             {
    2015                 :        127 :                               rtx newpat = gen_rtx_SET (reg, tem);
    2016                 :        127 :                               success
    2017                 :        127 :                                 = validate_change (next, &PATTERN (next),
    2018                 :            :                                                    newpat, 0);
    2019                 :            :                             }
    2020                 :            :                         }
    2021                 :        138 :                       if (success)
    2022                 :        107 :                         delete_insn (insn);
    2023                 :        138 :                       changed |= success;
    2024                 :        138 :                       insn = next;
    2025                 :        138 :                       move2add_record_mode (reg);
    2026                 :        138 :                       reg_offset[regno]
    2027                 :        138 :                         = trunc_int_for_mode (added_offset + base_offset,
    2028                 :            :                                               mode);
    2029                 :        138 :                       continue;
    2030                 :            :                     }
    2031                 :            :                 }
    2032                 :            :             }
    2033                 :            : 
    2034                 :            :           /* Try to transform
    2035                 :            :              (set (REGX) (CONST (PLUS (SYMBOL_REF) (CONST_INT A))))
    2036                 :            :              ...
    2037                 :            :              (set (REGY) (CONST (PLUS (SYMBOL_REF) (CONST_INT B))))
    2038                 :            :              to
    2039                 :            :              (set (REGX) (CONST (PLUS (SYMBOL_REF) (CONST_INT A))))
    2040                 :            :              ...
    2041                 :            :              (set (REGY) (CONST (PLUS (REGX) (CONST_INT B-A))))  */
    2042                 :   12971700 :           if ((GET_CODE (src) == SYMBOL_REF
    2043                 :   11899100 :                || (GET_CODE (src) == CONST
    2044                 :      31903 :                    && GET_CODE (XEXP (src, 0)) == PLUS
    2045                 :      31757 :                    && GET_CODE (XEXP (XEXP (src, 0), 0)) == SYMBOL_REF
    2046                 :      31733 :                    && CONST_INT_P (XEXP (XEXP (src, 0), 1))))
    2047                 :   13003400 :               && dbg_cnt (cse2_move2add))
    2048                 :            :             {
    2049                 :    1104360 :               rtx sym, off;
    2050                 :            : 
    2051                 :    1104360 :               if (GET_CODE (src) == SYMBOL_REF)
    2052                 :            :                 {
    2053                 :    1072630 :                   sym = src;
    2054                 :    1072630 :                   off = const0_rtx;
    2055                 :            :                 }
    2056                 :            :               else
    2057                 :            :                 {
    2058                 :      31733 :                   sym = XEXP (XEXP (src, 0), 0);
    2059                 :      31733 :                   off = XEXP (XEXP (src, 0), 1);
    2060                 :            :                 }
    2061                 :            : 
    2062                 :            :               /* If the reg already contains the value which is sum of
    2063                 :            :                  sym and some constant value, we can use an add2 insn.  */
    2064                 :    1104360 :               if (move2add_valid_value_p (regno, mode)
    2065                 :      79446 :                   && reg_base_reg[regno] < 0
    2066                 :      51702 :                   && reg_symbol_ref[regno] != NULL_RTX
    2067                 :    1108280 :                   && rtx_equal_p (sym, reg_symbol_ref[regno]))
    2068                 :        376 :                 changed |= move2add_use_add2_insn (mode, reg, sym, off, insn);
    2069                 :            : 
    2070                 :            :               /* Otherwise, we have to find a register whose value is sum
    2071                 :            :                  of sym and some constant value.  */
    2072                 :            :               else
    2073                 :    1103990 :                 changed |= move2add_use_add3_insn (mode, reg, sym, off, insn);
    2074                 :            : 
    2075                 :    1104360 :               continue;
    2076                 :            :             }
    2077                 :            :         }
    2078                 :            : 
    2079                 :   78831500 :       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
    2080                 :            :         {
    2081                 :   14782600 :           if (REG_NOTE_KIND (note) == REG_INC
    2082                 :          0 :               && REG_P (XEXP (note, 0)))
    2083                 :            :             {
    2084                 :            :               /* Reset the information about this register.  */
    2085                 :          0 :               int regno = REGNO (XEXP (note, 0));
    2086                 :          0 :               if (regno < FIRST_PSEUDO_REGISTER)
    2087                 :            :                 {
    2088                 :          0 :                   move2add_record_mode (XEXP (note, 0));
    2089                 :          0 :                   reg_mode[regno] = VOIDmode;
    2090                 :            :                 }
    2091                 :            :             }
    2092                 :            :         }
    2093                 :   64048800 :       note_stores (insn, move2add_note_store, insn);
    2094                 :            : 
    2095                 :            :       /* If INSN is a conditional branch, we try to extract an
    2096                 :            :          implicit set out of it.  */
    2097                 :   64048800 :       if (any_condjump_p (insn))
    2098                 :            :         {
    2099                 :    3014950 :           rtx cnd = fis_get_condition (insn);
    2100                 :            : 
    2101                 :    3014950 :           if (cnd != NULL_RTX
    2102                 :    2722480 :               && GET_CODE (cnd) == NE
    2103                 :    1167990 :               && REG_P (XEXP (cnd, 0))
    2104                 :     760328 :               && !reg_set_p (XEXP (cnd, 0), insn)
    2105                 :            :               /* The following two checks, which are also in
    2106                 :            :                  move2add_note_store, are intended to reduce the
    2107                 :            :                  number of calls to gen_rtx_SET to avoid memory
    2108                 :            :                  allocation if possible.  */
    2109                 :     760328 :               && SCALAR_INT_MODE_P (GET_MODE (XEXP (cnd, 0)))
    2110                 :     760328 :               && REG_NREGS (XEXP (cnd, 0)) == 1
    2111                 :    3775280 :               && CONST_INT_P (XEXP (cnd, 1)))
    2112                 :            :             {
    2113                 :     533253 :               rtx implicit_set =
    2114                 :     533253 :                 gen_rtx_SET (XEXP (cnd, 0), XEXP (cnd, 1));
    2115                 :     533253 :               move2add_note_store (SET_DEST (implicit_set), implicit_set, insn);
    2116                 :            :             }
    2117                 :            :         }
    2118                 :            : 
    2119                 :            :       /* If this is a CALL_INSN, all call used registers are stored with
    2120                 :            :          unknown values.  */
    2121                 :   64048800 :       if (CALL_P (insn))
    2122                 :            :         {
    2123                 :    3161080 :           function_abi callee_abi = insn_callee_abi (insn);
    2124                 :  243403000 :           for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--)
    2125                 :  240242000 :             if (reg_mode[i] != VOIDmode
    2126                 :   14812400 :                 && reg_mode[i] != BLKmode
    2127                 :  254763000 :                 && callee_abi.clobbers_reg_p (reg_mode[i], i))
    2128                 :            :               /* Reset the information about this register.  */
    2129                 :    5096570 :               reg_mode[i] = VOIDmode;
    2130                 :            :         }
    2131                 :            :     }
    2132                 :     688548 :   return changed;
    2133                 :            : }
    2134                 :            : 
    2135                 :            : /* SET is a SET or CLOBBER that sets DST.  DATA is the insn which
    2136                 :            :    contains SET.
    2137                 :            :    Update reg_set_luid, reg_offset and reg_base_reg accordingly.
    2138                 :            :    Called from reload_cse_move2add via note_stores.  */
    2139                 :            : 
    2140                 :            : static void
    2141                 :   38988000 : move2add_note_store (rtx dst, const_rtx set, void *data)
    2142                 :            : {
    2143                 :   38988000 :   rtx_insn *insn = (rtx_insn *) data;
    2144                 :   38988000 :   unsigned int regno = 0;
    2145                 :   38988000 :   scalar_int_mode mode;
    2146                 :            : 
    2147                 :            :   /* Some targets do argument pushes without adding REG_INC notes.  */
    2148                 :            : 
    2149                 :   38988000 :   if (MEM_P (dst))
    2150                 :            :     {
    2151                 :    7667370 :       dst = XEXP (dst, 0);
    2152                 :    7667370 :       if (GET_CODE (dst) == PRE_INC || GET_CODE (dst) == POST_INC
    2153                 :    7667370 :           || GET_CODE (dst) == PRE_DEC || GET_CODE (dst) == POST_DEC)
    2154                 :    1572780 :         reg_mode[REGNO (XEXP (dst, 0))] = VOIDmode;
    2155                 :    7667370 :       return;
    2156                 :            :     }
    2157                 :            : 
    2158                 :   31320700 :   if (GET_CODE (dst) == SUBREG)
    2159                 :          0 :     regno = subreg_regno (dst);
    2160                 :   31320700 :   else if (REG_P (dst))
    2161                 :   26954900 :     regno = REGNO (dst);
    2162                 :            :   else
    2163                 :            :     return;
    2164                 :            : 
    2165                 :   26954900 :   if (!is_a <scalar_int_mode> (GET_MODE (dst), &mode))
    2166                 :    9838080 :     goto invalidate;
    2167                 :            : 
    2168                 :   17116800 :   if (GET_CODE (set) == SET)
    2169                 :            :     {
    2170                 :   16886200 :       rtx note, sym = NULL_RTX;
    2171                 :   16886200 :       rtx off;
    2172                 :            : 
    2173                 :   16886200 :       note = find_reg_equal_equiv_note (insn);
    2174                 :   16886200 :       if (note && GET_CODE (XEXP (note, 0)) == SYMBOL_REF)
    2175                 :            :         {
    2176                 :      53645 :           sym = XEXP (note, 0);
    2177                 :      53645 :           off = const0_rtx;
    2178                 :            :         }
    2179                 :   16832500 :       else if (note && GET_CODE (XEXP (note, 0)) == CONST
    2180                 :       8636 :                && GET_CODE (XEXP (XEXP (note, 0), 0)) == PLUS
    2181                 :       8490 :                && GET_CODE (XEXP (XEXP (XEXP (note, 0), 0), 0)) == SYMBOL_REF
    2182                 :       8467 :                && CONST_INT_P (XEXP (XEXP (XEXP (note, 0), 0), 1)))
    2183                 :            :         {
    2184                 :            :           sym = XEXP (XEXP (XEXP (note, 0), 0), 0);
    2185                 :            :           off = XEXP (XEXP (XEXP (note, 0), 0), 1);
    2186                 :            :         }
    2187                 :            : 
    2188                 :      62112 :       if (sym != NULL_RTX)
    2189                 :            :         {
    2190                 :      62112 :           move2add_record_sym_value (dst, sym, off);
    2191                 :      62112 :           return;
    2192                 :            :         }
    2193                 :            :     }
    2194                 :            : 
    2195                 :   17054700 :   if (GET_CODE (set) == SET
    2196                 :   16824100 :       && GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
    2197                 :   16823500 :       && GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
    2198                 :            :     {
    2199                 :   16821800 :       rtx src = SET_SRC (set);
    2200                 :   16821800 :       rtx base_reg;
    2201                 :   16821800 :       unsigned HOST_WIDE_INT offset;
    2202                 :   16821800 :       int base_regno;
    2203                 :            : 
    2204                 :   16821800 :       switch (GET_CODE (src))
    2205                 :            :         {
    2206                 :    3966740 :         case PLUS:
    2207                 :    3966740 :           if (REG_P (XEXP (src, 0)))
    2208                 :            :             {
    2209                 :    3752800 :               base_reg = XEXP (src, 0);
    2210                 :            : 
    2211                 :    3752800 :               if (CONST_INT_P (XEXP (src, 1)))
    2212                 :    3295120 :                 offset = UINTVAL (XEXP (src, 1));
    2213                 :     457671 :               else if (REG_P (XEXP (src, 1))
    2214                 :     457671 :                        && move2add_valid_value_p (REGNO (XEXP (src, 1)), mode))
    2215                 :            :                 {
    2216                 :      46766 :                   if (reg_base_reg[REGNO (XEXP (src, 1))] < 0
    2217                 :      46766 :                       && reg_symbol_ref[REGNO (XEXP (src, 1))] == NULL_RTX)
    2218                 :       5740 :                     offset = reg_offset[REGNO (XEXP (src, 1))];
    2219                 :            :                   /* Maybe the first register is known to be a
    2220                 :            :                      constant.  */
    2221                 :      41026 :                   else if (move2add_valid_value_p (REGNO (base_reg), mode)
    2222                 :      10107 :                            && reg_base_reg[REGNO (base_reg)] < 0
    2223                 :      41737 :                            && reg_symbol_ref[REGNO (base_reg)] == NULL_RTX)
    2224                 :            :                     {
    2225                 :        580 :                       offset = reg_offset[REGNO (base_reg)];
    2226                 :        580 :                       base_reg = XEXP (src, 1);
    2227                 :            :                     }
    2228                 :            :                   else
    2229                 :      40446 :                     goto invalidate;
    2230                 :            :                 }
    2231                 :            :               else
    2232                 :     410905 :                 goto invalidate;
    2233                 :            : 
    2234                 :            :               break;
    2235                 :            :             }
    2236                 :            : 
    2237                 :     213946 :           goto invalidate;
    2238                 :            : 
    2239                 :            :         case REG:
    2240                 :            :           base_reg = src;
    2241                 :            :           offset = 0;
    2242                 :            :           break;
    2243                 :            : 
    2244                 :    2614700 :         case CONST_INT:
    2245                 :            :           /* Start tracking the register as a constant.  */
    2246                 :    2614700 :           reg_base_reg[regno] = -1;
    2247                 :    2614700 :           reg_symbol_ref[regno] = NULL_RTX;
    2248                 :    2614700 :           reg_offset[regno] = INTVAL (SET_SRC (set));
    2249                 :            :           /* We assign the same luid to all registers set to constants.  */
    2250                 :    2614700 :           reg_set_luid[regno] = move2add_last_label_luid + 1;
    2251                 :    2614700 :           move2add_record_mode (dst);
    2252                 :    2614700 :           return;
    2253                 :            : 
    2254                 :    7247180 :         default:
    2255                 :    7247180 :           goto invalidate;
    2256                 :            :         }
    2257                 :            : 
    2258                 :    6294590 :       base_regno = REGNO (base_reg);
    2259                 :            :       /* If information about the base register is not valid, set it
    2260                 :            :          up as a new base register, pretending its value is known
    2261                 :            :          starting from the current insn.  */
    2262                 :    6294590 :       if (!move2add_valid_value_p (base_regno, mode))
    2263                 :            :         {
    2264                 :    4653830 :           reg_base_reg[base_regno] = base_regno;
    2265                 :    4653830 :           reg_symbol_ref[base_regno] = NULL_RTX;
    2266                 :    4653830 :           reg_offset[base_regno] = 0;
    2267                 :    4653830 :           reg_set_luid[base_regno] = move2add_luid;
    2268                 :    4653830 :           gcc_assert (GET_MODE (base_reg) == mode);
    2269                 :    4653830 :           move2add_record_mode (base_reg);
    2270                 :            :         }
    2271                 :            : 
    2272                 :            :       /* Copy base information from our base register.  */
    2273                 :    6294590 :       reg_set_luid[regno] = reg_set_luid[base_regno];
    2274                 :    6294590 :       reg_base_reg[regno] = reg_base_reg[base_regno];
    2275                 :    6294590 :       reg_symbol_ref[regno] = reg_symbol_ref[base_regno];
    2276                 :            : 
    2277                 :            :       /* Compute the sum of the offsets or constants.  */
    2278                 :    6294590 :       reg_offset[regno]
    2279                 :    6294590 :         = trunc_int_for_mode (offset + reg_offset[base_regno], mode);
    2280                 :            : 
    2281                 :    6294590 :       move2add_record_mode (dst);
    2282                 :            :     }
    2283                 :            :   else
    2284                 :            :     {
    2285                 :     232963 :     invalidate:
    2286                 :            :       /* Invalidate the contents of the register.  */
    2287                 :   17983500 :       move2add_record_mode (dst);
    2288                 :   17983500 :       reg_mode[regno] = VOIDmode;
    2289                 :            :     }
    2290                 :            : }
    2291                 :            : 
    2292                 :            : namespace {
    2293                 :            : 
    2294                 :            : const pass_data pass_data_postreload_cse =
    2295                 :            : {
    2296                 :            :   RTL_PASS, /* type */
    2297                 :            :   "postreload", /* name */
    2298                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    2299                 :            :   TV_RELOAD_CSE_REGS, /* tv_id */
    2300                 :            :   0, /* properties_required */
    2301                 :            :   0, /* properties_provided */
    2302                 :            :   0, /* properties_destroyed */
    2303                 :            :   0, /* todo_flags_start */
    2304                 :            :   TODO_df_finish, /* todo_flags_finish */
    2305                 :            : };
    2306                 :            : 
    2307                 :            : class pass_postreload_cse : public rtl_opt_pass
    2308                 :            : {
    2309                 :            : public:
    2310                 :     200773 :   pass_postreload_cse (gcc::context *ctxt)
    2311                 :     401546 :     : rtl_opt_pass (pass_data_postreload_cse, ctxt)
    2312                 :            :   {}
    2313                 :            : 
    2314                 :            :   /* opt_pass methods: */
    2315                 :     944101 :   virtual bool gate (function *) { return (optimize > 0 && reload_completed); }
    2316                 :            : 
    2317                 :            :   virtual unsigned int execute (function *);
    2318                 :            : 
    2319                 :            : }; // class pass_postreload_cse
    2320                 :            : 
    2321                 :            : unsigned int
    2322                 :     688548 : pass_postreload_cse::execute (function *fun)
    2323                 :            : {
    2324                 :     688548 :   if (!dbg_cnt (postreload_cse))
    2325                 :            :     return 0;
    2326                 :            : 
    2327                 :            :   /* Do a very simple CSE pass over just the hard registers.  */
    2328                 :     688548 :   reload_cse_regs (get_insns ());
    2329                 :            :   /* Reload_cse_regs can eliminate potentially-trapping MEMs.
    2330                 :            :      Remove any EH edges associated with them.  */
    2331                 :     688548 :   if (fun->can_throw_non_call_exceptions
    2332                 :     688548 :       && purge_all_dead_edges ())
    2333                 :         75 :     cleanup_cfg (0);
    2334                 :            : 
    2335                 :            :   return 0;
    2336                 :            : }
    2337                 :            : 
    2338                 :            : } // anon namespace
    2339                 :            : 
    2340                 :            : rtl_opt_pass *
    2341                 :     200773 : make_pass_postreload_cse (gcc::context *ctxt)
    2342                 :            : {
    2343                 :     200773 :   return new pass_postreload_cse (ctxt);
    2344                 :            : }

Generated by: LCOV version 1.0

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