LCOV - code coverage report
Current view: top level - gcc - cselib.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1323 1428 92.6 %
Date: 2020-04-04 11:58:09 Functions: 54 56 96.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Common subexpression elimination library for GNU compiler.
       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 "df.h"
      28                 :            : #include "memmodel.h"
      29                 :            : #include "tm_p.h"
      30                 :            : #include "regs.h"
      31                 :            : #include "emit-rtl.h"
      32                 :            : #include "dumpfile.h"
      33                 :            : #include "cselib.h"
      34                 :            : #include "function-abi.h"
      35                 :            : 
      36                 :            : /* A list of cselib_val structures.  */
      37                 :            : struct elt_list
      38                 :            : {
      39                 :            :   struct elt_list *next;
      40                 :            :   cselib_val *elt;
      41                 :            : };
      42                 :            : 
      43                 :            : static bool cselib_record_memory;
      44                 :            : static bool cselib_preserve_constants;
      45                 :            : static bool cselib_any_perm_equivs;
      46                 :            : static inline void promote_debug_loc (struct elt_loc_list *l);
      47                 :            : static struct elt_list *new_elt_list (struct elt_list *, cselib_val *);
      48                 :            : static void new_elt_loc_list (cselib_val *, rtx);
      49                 :            : static void unchain_one_value (cselib_val *);
      50                 :            : static void unchain_one_elt_list (struct elt_list **);
      51                 :            : static void unchain_one_elt_loc_list (struct elt_loc_list **);
      52                 :            : static void remove_useless_values (void);
      53                 :            : static unsigned int cselib_hash_rtx (rtx, int, machine_mode);
      54                 :            : static cselib_val *new_cselib_val (unsigned int, machine_mode, rtx);
      55                 :            : static void add_mem_for_addr (cselib_val *, cselib_val *, rtx);
      56                 :            : static cselib_val *cselib_lookup_mem (rtx, int);
      57                 :            : static void cselib_invalidate_regno (unsigned int, machine_mode);
      58                 :            : static void cselib_invalidate_mem (rtx);
      59                 :            : static void cselib_record_set (rtx, cselib_val *, cselib_val *);
      60                 :            : static void cselib_record_sets (rtx_insn *);
      61                 :            : static rtx autoinc_split (rtx, rtx *, machine_mode);
      62                 :            : 
      63                 :            : #define PRESERVED_VALUE_P(RTX) \
      64                 :            :   (RTL_FLAG_CHECK1 ("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging)
      65                 :            : 
      66                 :            : #define SP_BASED_VALUE_P(RTX) \
      67                 :            :   (RTL_FLAG_CHECK1 ("SP_BASED_VALUE_P", (RTX), VALUE)->jump)
      68                 :            : 
      69                 :            : #define SP_DERIVED_VALUE_P(RTX) \
      70                 :            :   (RTL_FLAG_CHECK1 ("SP_DERIVED_VALUE_P", (RTX), VALUE)->call)
      71                 :            : 
      72                 :            : struct expand_value_data
      73                 :            : {
      74                 :            :   bitmap regs_active;
      75                 :            :   cselib_expand_callback callback;
      76                 :            :   void *callback_arg;
      77                 :            :   bool dummy;
      78                 :            : };
      79                 :            : 
      80                 :            : static rtx cselib_expand_value_rtx_1 (rtx, struct expand_value_data *, int);
      81                 :            : 
      82                 :            : /* There are three ways in which cselib can look up an rtx:
      83                 :            :    - for a REG, the reg_values table (which is indexed by regno) is used
      84                 :            :    - for a MEM, we recursively look up its address and then follow the
      85                 :            :      addr_list of that value
      86                 :            :    - for everything else, we compute a hash value and go through the hash
      87                 :            :      table.  Since different rtx's can still have the same hash value,
      88                 :            :      this involves walking the table entries for a given value and comparing
      89                 :            :      the locations of the entries with the rtx we are looking up.  */
      90                 :            : 
      91                 :            : struct cselib_hasher : nofree_ptr_hash <cselib_val>
      92                 :            : {
      93                 :            :   struct key {
      94                 :            :     /* The rtx value and its mode (needed separately for constant
      95                 :            :        integers).  */
      96                 :            :     machine_mode mode;
      97                 :            :     rtx x;
      98                 :            :     /* The mode of the contaning MEM, if any, otherwise VOIDmode.  */
      99                 :            :     machine_mode memmode;
     100                 :            :   };
     101                 :            :   typedef key *compare_type;
     102                 :            :   static inline hashval_t hash (const cselib_val *);
     103                 :            :   static inline bool equal (const cselib_val *, const key *);
     104                 :            : };
     105                 :            : 
     106                 :            : /* The hash function for our hash table.  The value is always computed with
     107                 :            :    cselib_hash_rtx when adding an element; this function just extracts the
     108                 :            :    hash value from a cselib_val structure.  */
     109                 :            : 
     110                 :            : inline hashval_t
     111                 :   68129100 : cselib_hasher::hash (const cselib_val *v)
     112                 :            : {
     113                 :   68129100 :   return v->hash;
     114                 :            : }
     115                 :            : 
     116                 :            : /* The equality test for our hash table.  The first argument V is a table
     117                 :            :    element (i.e. a cselib_val), while the second arg X is an rtx.  We know
     118                 :            :    that all callers of htab_find_slot_with_hash will wrap CONST_INTs into a
     119                 :            :    CONST of an appropriate mode.  */
     120                 :            : 
     121                 :            : inline bool
     122                 :  396027000 : cselib_hasher::equal (const cselib_val *v, const key *x_arg)
     123                 :            : {
     124                 :  396027000 :   struct elt_loc_list *l;
     125                 :  396027000 :   rtx x = x_arg->x;
     126                 :  396027000 :   machine_mode mode = x_arg->mode;
     127                 :  396027000 :   machine_mode memmode = x_arg->memmode;
     128                 :            : 
     129                 :  396027000 :   if (mode != GET_MODE (v->val_rtx))
     130                 :            :     return false;
     131                 :            : 
     132                 :  334086000 :   if (GET_CODE (x) == VALUE)
     133                 :    9257280 :     return x == v->val_rtx;
     134                 :            : 
     135                 :  333141000 :   if (SP_DERIVED_VALUE_P (v->val_rtx) && GET_MODE (x) == Pmode)
     136                 :            :     {
     137                 :   12859000 :       rtx xoff = NULL;
     138                 :   12859000 :       if (autoinc_split (x, &xoff, memmode) == v->val_rtx && xoff == NULL_RTX)
     139                 :    6213230 :         return true;
     140                 :            :     }
     141                 :            : 
     142                 :            :   /* We don't guarantee that distinct rtx's have different hash values,
     143                 :            :      so we need to do a comparison.  */
     144                 :  546354000 :   for (l = v->locs; l; l = l->next)
     145                 :  355891000 :     if (rtx_equal_for_cselib_1 (l->loc, x, memmode, 0))
     146                 :            :       {
     147                 :  128152000 :         promote_debug_loc (l);
     148                 :  128152000 :         return true;
     149                 :            :       }
     150                 :            : 
     151                 :            :   return false;
     152                 :            : }
     153                 :            : 
     154                 :            : /* A table that enables us to look up elts by their value.  */
     155                 :            : static hash_table<cselib_hasher> *cselib_hash_table;
     156                 :            : 
     157                 :            : /* A table to hold preserved values.  */
     158                 :            : static hash_table<cselib_hasher> *cselib_preserved_hash_table;
     159                 :            : 
     160                 :            : /* This is a global so we don't have to pass this through every function.
     161                 :            :    It is used in new_elt_loc_list to set SETTING_INSN.  */
     162                 :            : static rtx_insn *cselib_current_insn;
     163                 :            : 
     164                 :            : /* The unique id that the next create value will take.  */
     165                 :            : static unsigned int next_uid;
     166                 :            : 
     167                 :            : /* The number of registers we had when the varrays were last resized.  */
     168                 :            : static unsigned int cselib_nregs;
     169                 :            : 
     170                 :            : /* Count values without known locations, or with only locations that
     171                 :            :    wouldn't have been known except for debug insns.  Whenever this
     172                 :            :    grows too big, we remove these useless values from the table.
     173                 :            : 
     174                 :            :    Counting values with only debug values is a bit tricky.  We don't
     175                 :            :    want to increment n_useless_values when we create a value for a
     176                 :            :    debug insn, for this would get n_useless_values out of sync, but we
     177                 :            :    want increment it if all locs in the list that were ever referenced
     178                 :            :    in nondebug insns are removed from the list.
     179                 :            : 
     180                 :            :    In the general case, once we do that, we'd have to stop accepting
     181                 :            :    nondebug expressions in the loc list, to avoid having two values
     182                 :            :    equivalent that, without debug insns, would have been made into
     183                 :            :    separate values.  However, because debug insns never introduce
     184                 :            :    equivalences themselves (no assignments), the only means for
     185                 :            :    growing loc lists is through nondebug assignments.  If the locs
     186                 :            :    also happen to be referenced in debug insns, it will work just fine.
     187                 :            : 
     188                 :            :    A consequence of this is that there's at most one debug-only loc in
     189                 :            :    each loc list.  If we keep it in the first entry, testing whether
     190                 :            :    we have a debug-only loc list takes O(1).
     191                 :            : 
     192                 :            :    Furthermore, since any additional entry in a loc list containing a
     193                 :            :    debug loc would have to come from an assignment (nondebug) that
     194                 :            :    references both the initial debug loc and the newly-equivalent loc,
     195                 :            :    the initial debug loc would be promoted to a nondebug loc, and the
     196                 :            :    loc list would not contain debug locs any more.
     197                 :            : 
     198                 :            :    So the only case we have to be careful with in order to keep
     199                 :            :    n_useless_values in sync between debug and nondebug compilations is
     200                 :            :    to avoid incrementing n_useless_values when removing the single loc
     201                 :            :    from a value that turns out to not appear outside debug values.  We
     202                 :            :    increment n_useless_debug_values instead, and leave such values
     203                 :            :    alone until, for other reasons, we garbage-collect useless
     204                 :            :    values.  */
     205                 :            : static int n_useless_values;
     206                 :            : static int n_useless_debug_values;
     207                 :            : 
     208                 :            : /* Count values whose locs have been taken exclusively from debug
     209                 :            :    insns for the entire life of the value.  */
     210                 :            : static int n_debug_values;
     211                 :            : 
     212                 :            : /* Number of useless values before we remove them from the hash table.  */
     213                 :            : #define MAX_USELESS_VALUES 32
     214                 :            : 
     215                 :            : /* This table maps from register number to values.  It does not
     216                 :            :    contain pointers to cselib_val structures, but rather elt_lists.
     217                 :            :    The purpose is to be able to refer to the same register in
     218                 :            :    different modes.  The first element of the list defines the mode in
     219                 :            :    which the register was set; if the mode is unknown or the value is
     220                 :            :    no longer valid in that mode, ELT will be NULL for the first
     221                 :            :    element.  */
     222                 :            : static struct elt_list **reg_values;
     223                 :            : static unsigned int reg_values_size;
     224                 :            : #define REG_VALUES(i) reg_values[i]
     225                 :            : 
     226                 :            : /* The largest number of hard regs used by any entry added to the
     227                 :            :    REG_VALUES table.  Cleared on each cselib_clear_table() invocation.  */
     228                 :            : static unsigned int max_value_regs;
     229                 :            : 
     230                 :            : /* Here the set of indices I with REG_VALUES(I) != 0 is saved.  This is used
     231                 :            :    in cselib_clear_table() for fast emptying.  */
     232                 :            : static unsigned int *used_regs;
     233                 :            : static unsigned int n_used_regs;
     234                 :            : 
     235                 :            : /* We pass this to cselib_invalidate_mem to invalidate all of
     236                 :            :    memory for a non-const call instruction.  */
     237                 :            : static GTY(()) rtx callmem;
     238                 :            : 
     239                 :            : /* Set by discard_useless_locs if it deleted the last location of any
     240                 :            :    value.  */
     241                 :            : static int values_became_useless;
     242                 :            : 
     243                 :            : /* Used as stop element of the containing_mem list so we can check
     244                 :            :    presence in the list by checking the next pointer.  */
     245                 :            : static cselib_val dummy_val;
     246                 :            : 
     247                 :            : /* If non-NULL, value of the eliminated arg_pointer_rtx or frame_pointer_rtx
     248                 :            :    that is constant through the whole function and should never be
     249                 :            :    eliminated.  */
     250                 :            : static cselib_val *cfa_base_preserved_val;
     251                 :            : static unsigned int cfa_base_preserved_regno = INVALID_REGNUM;
     252                 :            : 
     253                 :            : /* Used to list all values that contain memory reference.
     254                 :            :    May or may not contain the useless values - the list is compacted
     255                 :            :    each time memory is invalidated.  */
     256                 :            : static cselib_val *first_containing_mem = &dummy_val;
     257                 :            : 
     258                 :            : static object_allocator<elt_list> elt_list_pool ("elt_list");
     259                 :            : static object_allocator<elt_loc_list> elt_loc_list_pool ("elt_loc_list");
     260                 :            : static object_allocator<cselib_val> cselib_val_pool ("cselib_val_list");
     261                 :            : 
     262                 :            : static pool_allocator value_pool ("value", RTX_CODE_SIZE (VALUE));
     263                 :            : 
     264                 :            : /* If nonnull, cselib will call this function before freeing useless
     265                 :            :    VALUEs.  A VALUE is deemed useless if its "locs" field is null.  */
     266                 :            : void (*cselib_discard_hook) (cselib_val *);
     267                 :            : 
     268                 :            : /* If nonnull, cselib will call this function before recording sets or
     269                 :            :    even clobbering outputs of INSN.  All the recorded sets will be
     270                 :            :    represented in the array sets[n_sets].  new_val_min can be used to
     271                 :            :    tell whether values present in sets are introduced by this
     272                 :            :    instruction.  */
     273                 :            : void (*cselib_record_sets_hook) (rtx_insn *insn, struct cselib_set *sets,
     274                 :            :                                  int n_sets);
     275                 :            : 
     276                 :            : 
     277                 :            : 
     278                 :            : /* Allocate a struct elt_list and fill in its two elements with the
     279                 :            :    arguments.  */
     280                 :            : 
     281                 :            : static inline struct elt_list *
     282                 :  304701000 : new_elt_list (struct elt_list *next, cselib_val *elt)
     283                 :            : {
     284                 :  609402000 :   elt_list *el = elt_list_pool.allocate ();
     285                 :  304701000 :   el->next = next;
     286                 :  304701000 :   el->elt = elt;
     287                 :  304701000 :   return el;
     288                 :            : }
     289                 :            : 
     290                 :            : /* Allocate a struct elt_loc_list with LOC and prepend it to VAL's loc
     291                 :            :    list.  */
     292                 :            : 
     293                 :            : static inline void
     294                 :  461033000 : new_elt_loc_list (cselib_val *val, rtx loc)
     295                 :            : {
     296                 :  463186000 :   struct elt_loc_list *el, *next = val->locs;
     297                 :            : 
     298                 :  463186000 :   gcc_checking_assert (!next || !next->setting_insn
     299                 :            :                        || !DEBUG_INSN_P (next->setting_insn)
     300                 :            :                        || cselib_current_insn == next->setting_insn);
     301                 :            : 
     302                 :            :   /* If we're creating the first loc in a debug insn context, we've
     303                 :            :      just created a debug value.  Count it.  */
     304                 :  463186000 :   if (!next && cselib_current_insn && DEBUG_INSN_P (cselib_current_insn))
     305                 :    4226780 :     n_debug_values++;
     306                 :            : 
     307                 :  463186000 :   val = canonical_cselib_val (val);
     308                 :  463186000 :   next = val->locs;
     309                 :            : 
     310                 :  463186000 :   if (GET_CODE (loc) == VALUE)
     311                 :            :     {
     312                 :    4315280 :       loc = canonical_cselib_val (CSELIB_VAL_PTR (loc))->val_rtx;
     313                 :            : 
     314                 :    4315280 :       gcc_checking_assert (PRESERVED_VALUE_P (loc)
     315                 :            :                            == PRESERVED_VALUE_P (val->val_rtx));
     316                 :            : 
     317                 :    4315280 :       if (val->val_rtx == loc)
     318                 :            :         return;
     319                 :    4306870 :       else if (val->uid > CSELIB_VAL_PTR (loc)->uid)
     320                 :            :         {
     321                 :            :           /* Reverse the insertion.  */
     322                 :            :           new_elt_loc_list (CSELIB_VAL_PTR (loc), val->val_rtx);
     323                 :            :           return;
     324                 :            :         }
     325                 :            : 
     326                 :    2153440 :       gcc_checking_assert (val->uid < CSELIB_VAL_PTR (loc)->uid);
     327                 :            : 
     328                 :    2153440 :       if (CSELIB_VAL_PTR (loc)->locs)
     329                 :            :         {
     330                 :            :           /* Bring all locs from LOC to VAL.  */
     331                 :    1913490 :           for (el = CSELIB_VAL_PTR (loc)->locs; el->next; el = el->next)
     332                 :            :             {
     333                 :            :               /* Adjust values that have LOC as canonical so that VAL
     334                 :            :                  becomes their canonical.  */
     335                 :          0 :               if (el->loc && GET_CODE (el->loc) == VALUE)
     336                 :            :                 {
     337                 :          0 :                   gcc_checking_assert (CSELIB_VAL_PTR (el->loc)->locs->loc
     338                 :            :                                        == loc);
     339                 :          0 :                   CSELIB_VAL_PTR (el->loc)->locs->loc = val->val_rtx;
     340                 :            :                 }
     341                 :            :             }
     342                 :    1913490 :           el->next = val->locs;
     343                 :    1913490 :           next = val->locs = CSELIB_VAL_PTR (loc)->locs;
     344                 :            :         }
     345                 :            : 
     346                 :    2153440 :       if (CSELIB_VAL_PTR (loc)->addr_list)
     347                 :            :         {
     348                 :            :           /* Bring in addr_list into canonical node.  */
     349                 :            :           struct elt_list *last = CSELIB_VAL_PTR (loc)->addr_list;
     350                 :          4 :           while (last->next)
     351                 :            :             last = last->next;
     352                 :          4 :           last->next = val->addr_list;
     353                 :          4 :           val->addr_list = CSELIB_VAL_PTR (loc)->addr_list;
     354                 :          4 :           CSELIB_VAL_PTR (loc)->addr_list = NULL;
     355                 :            :         }
     356                 :            : 
     357                 :    2153440 :       if (CSELIB_VAL_PTR (loc)->next_containing_mem != NULL
     358                 :          0 :           && val->next_containing_mem == NULL)
     359                 :            :         {
     360                 :            :           /* Add VAL to the containing_mem list after LOC.  LOC will
     361                 :            :              be removed when we notice it doesn't contain any
     362                 :            :              MEMs.  */
     363                 :          0 :           val->next_containing_mem = CSELIB_VAL_PTR (loc)->next_containing_mem;
     364                 :          0 :           CSELIB_VAL_PTR (loc)->next_containing_mem = val;
     365                 :            :         }
     366                 :            : 
     367                 :            :       /* Chain LOC back to VAL.  */
     368                 :    2153440 :       el = elt_loc_list_pool.allocate ();
     369                 :    2153440 :       el->loc = val->val_rtx;
     370                 :    2153440 :       el->setting_insn = cselib_current_insn;
     371                 :    2153440 :       el->next = NULL;
     372                 :    2153440 :       CSELIB_VAL_PTR (loc)->locs = el;
     373                 :            :     }
     374                 :            : 
     375                 :  461025000 :   el = elt_loc_list_pool.allocate ();
     376                 :  461025000 :   el->loc = loc;
     377                 :  461025000 :   el->setting_insn = cselib_current_insn;
     378                 :  461025000 :   el->next = next;
     379                 :  461025000 :   val->locs = el;
     380                 :            : }
     381                 :            : 
     382                 :            : /* Promote loc L to a nondebug cselib_current_insn if L is marked as
     383                 :            :    originating from a debug insn, maintaining the debug values
     384                 :            :    count.  */
     385                 :            : 
     386                 :            : static inline void
     387                 :  983573000 : promote_debug_loc (struct elt_loc_list *l)
     388                 :            : {
     389                 :  983573000 :   if (l && l->setting_insn && DEBUG_INSN_P (l->setting_insn)
     390                 :   23918300 :       && (!cselib_current_insn || !DEBUG_INSN_P (cselib_current_insn)))
     391                 :            :     {
     392                 :    1613140 :       n_debug_values--;
     393                 :    1613140 :       l->setting_insn = cselib_current_insn;
     394                 :    1613140 :       if (cselib_preserve_constants && l->next)
     395                 :            :         {
     396                 :      11976 :           gcc_assert (l->next->setting_insn
     397                 :            :                       && DEBUG_INSN_P (l->next->setting_insn)
     398                 :            :                       && !l->next->next);
     399                 :      11976 :           l->next->setting_insn = cselib_current_insn;
     400                 :            :         }
     401                 :            :       else
     402                 :    1601160 :         gcc_assert (!l->next);
     403                 :            :     }
     404                 :  983573000 : }
     405                 :            : 
     406                 :            : /* The elt_list at *PL is no longer needed.  Unchain it and free its
     407                 :            :    storage.  */
     408                 :            : 
     409                 :            : static inline void
     410                 :   52255800 : unchain_one_elt_list (struct elt_list **pl)
     411                 :            : {
     412                 :   52255800 :   struct elt_list *l = *pl;
     413                 :            : 
     414                 :   52255800 :   *pl = l->next;
     415                 :   78135200 :   elt_list_pool.remove (l);
     416                 :   26376500 : }
     417                 :            : 
     418                 :            : /* Likewise for elt_loc_lists.  */
     419                 :            : 
     420                 :            : static void
     421                 :  145229000 : unchain_one_elt_loc_list (struct elt_loc_list **pl)
     422                 :            : {
     423                 :  145229000 :   struct elt_loc_list *l = *pl;
     424                 :            : 
     425                 :  145229000 :   *pl = l->next;
     426                 :          0 :   elt_loc_list_pool.remove (l);
     427                 :   26625600 : }
     428                 :            : 
     429                 :            : /* Likewise for cselib_vals.  This also frees the addr_list associated with
     430                 :            :    V.  */
     431                 :            : 
     432                 :            : static void
     433                 :    1559230 : unchain_one_value (cselib_val *v)
     434                 :            : {
     435                 :    1578630 :   while (v->addr_list)
     436                 :    1578630 :     unchain_one_elt_list (&v->addr_list);
     437                 :            : 
     438                 :    1559230 :   cselib_val_pool.remove (v);
     439                 :    1559230 : }
     440                 :            : 
     441                 :            : /* Remove all entries from the hash table.  Also used during
     442                 :            :    initialization.  */
     443                 :            : 
     444                 :            : void
     445                 :   39062900 : cselib_clear_table (void)
     446                 :            : {
     447                 :   39062900 :   cselib_reset_table (1);
     448                 :   39062900 : }
     449                 :            : 
     450                 :            : /* Return TRUE if V is a constant, a function invariant or a VALUE
     451                 :            :    equivalence; FALSE otherwise.  */
     452                 :            : 
     453                 :            : static bool
     454                 :   40675500 : invariant_or_equiv_p (cselib_val *v)
     455                 :            : {
     456                 :   40675500 :   struct elt_loc_list *l;
     457                 :            : 
     458                 :   40675500 :   if (v == cfa_base_preserved_val)
     459                 :            :     return true;
     460                 :            : 
     461                 :            :   /* Keep VALUE equivalences around.  */
     462                 :   56255600 :   for (l = v->locs; l; l = l->next)
     463                 :   26752100 :     if (GET_CODE (l->loc) == VALUE)
     464                 :            :       return true;
     465                 :            : 
     466                 :   29503400 :   if (v->locs != NULL
     467                 :   15918900 :       && v->locs->next == NULL)
     468                 :            :     {
     469                 :   15918900 :       if (CONSTANT_P (v->locs->loc)
     470                 :   15918900 :           && (GET_CODE (v->locs->loc) != CONST
     471                 :     130481 :               || !references_value_p (v->locs->loc, 0)))
     472                 :    2454510 :         return true;
     473                 :            :       /* Although a debug expr may be bound to different expressions,
     474                 :            :          we can preserve it as if it was constant, to get unification
     475                 :            :          and proper merging within var-tracking.  */
     476                 :   13464400 :       if (GET_CODE (v->locs->loc) == DEBUG_EXPR
     477                 :   13464400 :           || GET_CODE (v->locs->loc) == DEBUG_IMPLICIT_PTR
     478                 :   12146900 :           || GET_CODE (v->locs->loc) == ENTRY_VALUE
     479                 :   12146700 :           || GET_CODE (v->locs->loc) == DEBUG_PARAMETER_REF)
     480                 :            :         return true;
     481                 :            : 
     482                 :            :       /* (plus (value V) (const_int C)) is invariant iff V is invariant.  */
     483                 :   12141000 :       if (GET_CODE (v->locs->loc) == PLUS
     484                 :    8393630 :           && CONST_INT_P (XEXP (v->locs->loc, 1))
     485                 :    7642400 :           && GET_CODE (XEXP (v->locs->loc, 0)) == VALUE
     486                 :   19445400 :           && invariant_or_equiv_p (CSELIB_VAL_PTR (XEXP (v->locs->loc, 0))))
     487                 :    4682950 :         return true;
     488                 :            :     }
     489                 :            : 
     490                 :            :   return false;
     491                 :            : }
     492                 :            : 
     493                 :            : /* Remove from hash table all VALUEs except constants, function
     494                 :            :    invariants and VALUE equivalences.  */
     495                 :            : 
     496                 :            : int
     497                 :   30543400 : preserve_constants_and_equivs (cselib_val **x, void *info ATTRIBUTE_UNUSED)
     498                 :            : {
     499                 :   30543400 :   cselib_val *v = *x;
     500                 :            : 
     501                 :   30543400 :   if (invariant_or_equiv_p (v))
     502                 :            :     {
     503                 :   12122200 :       cselib_hasher::key lookup = {
     504                 :   12122200 :         GET_MODE (v->val_rtx), v->val_rtx, VOIDmode
     505                 :   12122200 :       };
     506                 :   12122200 :       cselib_val **slot
     507                 :   12122200 :         = cselib_preserved_hash_table->find_slot_with_hash (&lookup,
     508                 :            :                                                             v->hash, INSERT);
     509                 :   12122200 :       gcc_assert (!*slot);
     510                 :   12122200 :       *slot = v;
     511                 :            :     }
     512                 :            : 
     513                 :   30543400 :   cselib_hash_table->clear_slot (x);
     514                 :            : 
     515                 :   30543400 :   return 1;
     516                 :            : }
     517                 :            : 
     518                 :            : /* Remove all entries from the hash table, arranging for the next
     519                 :            :    value to be numbered NUM.  */
     520                 :            : 
     521                 :            : void
     522                 :   64082600 : cselib_reset_table (unsigned int num)
     523                 :            : {
     524                 :   64082600 :   unsigned int i;
     525                 :            : 
     526                 :   64082600 :   max_value_regs = 0;
     527                 :            : 
     528                 :   64082600 :   if (cfa_base_preserved_val)
     529                 :            :     {
     530                 :    2827690 :       unsigned int regno = cfa_base_preserved_regno;
     531                 :    2827690 :       unsigned int new_used_regs = 0;
     532                 :   18665000 :       for (i = 0; i < n_used_regs; i++)
     533                 :   15837300 :         if (used_regs[i] == regno)
     534                 :            :           {
     535                 :    2827690 :             new_used_regs = 1;
     536                 :    2827690 :             continue;
     537                 :            :           }
     538                 :            :         else
     539                 :   13009600 :           REG_VALUES (used_regs[i]) = 0;
     540                 :    2827690 :       gcc_assert (new_used_regs == 1);
     541                 :    2827690 :       n_used_regs = new_used_regs;
     542                 :    2827690 :       used_regs[0] = regno;
     543                 :    2827690 :       max_value_regs
     544                 :    2827690 :         = hard_regno_nregs (regno,
     545                 :    2827690 :                             GET_MODE (cfa_base_preserved_val->locs->loc));
     546                 :            : 
     547                 :            :       /* If cfa_base is sp + const_int, need to preserve also the
     548                 :            :          SP_DERIVED_VALUE_P value.  */
     549                 :    2827690 :       for (struct elt_loc_list *l = cfa_base_preserved_val->locs;
     550                 :    5655390 :            l; l = l->next)
     551                 :    5655390 :         if (GET_CODE (l->loc) == PLUS
     552                 :    2827690 :             && GET_CODE (XEXP (l->loc, 0)) == VALUE
     553                 :    2827690 :             && SP_DERIVED_VALUE_P (XEXP (l->loc, 0))
     554                 :    8483080 :             && CONST_INT_P (XEXP (l->loc, 1)))
     555                 :            :           {
     556                 :    2827690 :             if (! invariant_or_equiv_p (CSELIB_VAL_PTR (XEXP (l->loc, 0))))
     557                 :            :               {
     558                 :          0 :                 rtx val = cfa_base_preserved_val->val_rtx;
     559                 :          0 :                 rtx_insn *save_cselib_current_insn = cselib_current_insn;
     560                 :          0 :                 cselib_current_insn = l->setting_insn;
     561                 :          0 :                 new_elt_loc_list (CSELIB_VAL_PTR (XEXP (l->loc, 0)),
     562                 :          0 :                                   plus_constant (Pmode, val,
     563                 :          0 :                                                  -UINTVAL (XEXP (l->loc, 1))));
     564                 :          0 :                 cselib_current_insn = save_cselib_current_insn;
     565                 :            :               }
     566                 :            :             break;
     567                 :            :           }
     568                 :            :     }
     569                 :            :   else
     570                 :            :     {
     571                 :  230733000 :       for (i = 0; i < n_used_regs; i++)
     572                 :  169478000 :         REG_VALUES (used_regs[i]) = 0;
     573                 :   61254900 :       n_used_regs = 0;
     574                 :            :     }
     575                 :            : 
     576                 :   64082600 :   if (cselib_preserve_constants)
     577                 :    2827690 :     cselib_hash_table->traverse <void *, preserve_constants_and_equivs> (NULL);
     578                 :            :   else
     579                 :            :     {
     580                 :   61254900 :       cselib_hash_table->empty ();
     581                 :   61254900 :       gcc_checking_assert (!cselib_any_perm_equivs);
     582                 :            :     }
     583                 :            : 
     584                 :   64082600 :   n_useless_values = 0;
     585                 :   64082600 :   n_useless_debug_values = 0;
     586                 :   64082600 :   n_debug_values = 0;
     587                 :            : 
     588                 :   64082600 :   next_uid = num;
     589                 :            : 
     590                 :   64082600 :   first_containing_mem = &dummy_val;
     591                 :   64082600 : }
     592                 :            : 
     593                 :            : /* Return the number of the next value that will be generated.  */
     594                 :            : 
     595                 :            : unsigned int
     596                 :    3166410 : cselib_get_next_uid (void)
     597                 :            : {
     598                 :    3166410 :   return next_uid;
     599                 :            : }
     600                 :            : 
     601                 :            : /* Search for X, whose hashcode is HASH, in CSELIB_HASH_TABLE,
     602                 :            :    INSERTing if requested.  When X is part of the address of a MEM,
     603                 :            :    MEMMODE should specify the mode of the MEM.  */
     604                 :            : 
     605                 :            : static cselib_val **
     606                 :  475701000 : cselib_find_slot (machine_mode mode, rtx x, hashval_t hash,
     607                 :            :                   enum insert_option insert, machine_mode memmode)
     608                 :            : {
     609                 :  475701000 :   cselib_val **slot = NULL;
     610                 :  475701000 :   cselib_hasher::key lookup = { mode, x, memmode };
     611                 :  475701000 :   if (cselib_preserve_constants)
     612                 :  109904000 :     slot = cselib_preserved_hash_table->find_slot_with_hash (&lookup, hash,
     613                 :            :                                                              NO_INSERT);
     614                 :  109904000 :   if (!slot)
     615                 :  443946000 :     slot = cselib_hash_table->find_slot_with_hash (&lookup, hash, insert);
     616                 :  475701000 :   return slot;
     617                 :            : }
     618                 :            : 
     619                 :            : /* Return true if X contains a VALUE rtx.  If ONLY_USELESS is set, we
     620                 :            :    only return true for values which point to a cselib_val whose value
     621                 :            :    element has been set to zero, which implies the cselib_val will be
     622                 :            :    removed.  */
     623                 :            : 
     624                 :            : int
     625                 :   75161700 : references_value_p (const_rtx x, int only_useless)
     626                 :            : {
     627                 :   75161700 :   const enum rtx_code code = GET_CODE (x);
     628                 :   75161700 :   const char *fmt = GET_RTX_FORMAT (code);
     629                 :   75161700 :   int i, j;
     630                 :            : 
     631                 :   75161700 :   if (GET_CODE (x) == VALUE
     632                 :   75161700 :       && (! only_useless ||
     633                 :   26179800 :           (CSELIB_VAL_PTR (x)->locs == 0 && !PRESERVED_VALUE_P (x))))
     634                 :            :     return 1;
     635                 :            : 
     636                 :  172557000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     637                 :            :     {
     638                 :   99004900 :       if (fmt[i] == 'e' && references_value_p (XEXP (x, i), only_useless))
     639                 :            :         return 1;
     640                 :   98194600 :       else if (fmt[i] == 'E')
     641                 :    1344100 :         for (j = 0; j < XVECLEN (x, i); j++)
     642                 :    1008030 :           if (references_value_p (XVECEXP (x, i, j), only_useless))
     643                 :            :             return 1;
     644                 :            :     }
     645                 :            : 
     646                 :            :   return 0;
     647                 :            : }
     648                 :            : 
     649                 :            : /* For all locations found in X, delete locations that reference useless
     650                 :            :    values (i.e. values without any location).  Called through
     651                 :            :    htab_traverse.  */
     652                 :            : 
     653                 :            : int
     654                 :   45565500 : discard_useless_locs (cselib_val **x, void *info ATTRIBUTE_UNUSED)
     655                 :            : {
     656                 :   45565500 :   cselib_val *v = *x;
     657                 :   45565500 :   struct elt_loc_list **p = &v->locs;
     658                 :   45565500 :   bool had_locs = v->locs != NULL;
     659                 :   45565500 :   rtx_insn *setting_insn = v->locs ? v->locs->setting_insn : NULL;
     660                 :            : 
     661                 :   76484300 :   while (*p)
     662                 :            :     {
     663                 :   30918800 :       if (references_value_p ((*p)->loc, 1))
     664                 :   77230600 :         unchain_one_elt_loc_list (p);
     665                 :            :       else
     666                 :   30172600 :         p = &(*p)->next;
     667                 :            :     }
     668                 :            : 
     669                 :   45565500 :   if (had_locs && v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx))
     670                 :            :     {
     671                 :     672378 :       if (setting_insn && DEBUG_INSN_P (setting_insn))
     672                 :          0 :         n_useless_debug_values++;
     673                 :            :       else
     674                 :     672378 :         n_useless_values++;
     675                 :     672378 :       values_became_useless = 1;
     676                 :            :     }
     677                 :   45565500 :   return 1;
     678                 :            : }
     679                 :            : 
     680                 :            : /* If X is a value with no locations, remove it from the hashtable.  */
     681                 :            : 
     682                 :            : int
     683                 :   33326300 : discard_useless_values (cselib_val **x, void *info ATTRIBUTE_UNUSED)
     684                 :            : {
     685                 :   33326300 :   cselib_val *v = *x;
     686                 :            : 
     687                 :   33326300 :   if (v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx))
     688                 :            :     {
     689                 :    1559230 :       if (cselib_discard_hook)
     690                 :     283108 :         cselib_discard_hook (v);
     691                 :            : 
     692                 :    1559230 :       CSELIB_VAL_PTR (v->val_rtx) = NULL;
     693                 :    1559230 :       cselib_hash_table->clear_slot (x);
     694                 :    1559230 :       unchain_one_value (v);
     695                 :    1559230 :       n_useless_values--;
     696                 :            :     }
     697                 :            : 
     698                 :   33326300 :   return 1;
     699                 :            : }
     700                 :            : 
     701                 :            : /* Clean out useless values (i.e. those which no longer have locations
     702                 :            :    associated with them) from the hash table.  */
     703                 :            : 
     704                 :            : static void
     705                 :    2847590 : remove_useless_values (void)
     706                 :            : {
     707                 :    2880050 :   cselib_val **p, *v;
     708                 :            : 
     709                 :            :   /* First pass: eliminate locations that reference the value.  That in
     710                 :            :      turn can make more values useless.  */
     711                 :    2880050 :   do
     712                 :            :     {
     713                 :    2880050 :       values_became_useless = 0;
     714                 :    2880050 :       cselib_hash_table->traverse <void *, discard_useless_locs> (NULL);
     715                 :            :     }
     716                 :    2880050 :   while (values_became_useless);
     717                 :            : 
     718                 :            :   /* Second pass: actually remove the values.  */
     719                 :            : 
     720                 :    2847590 :   p = &first_containing_mem;
     721                 :    2953750 :   for (v = *p; v != &dummy_val; v = v->next_containing_mem)
     722                 :     106165 :     if (v->locs && v == canonical_cselib_val (v))
     723                 :            :       {
     724                 :     101860 :         *p = v;
     725                 :     101860 :         p = &(*p)->next_containing_mem;
     726                 :            :       }
     727                 :    2847590 :   *p = &dummy_val;
     728                 :            : 
     729                 :    2847590 :   n_useless_values += n_useless_debug_values;
     730                 :    2847590 :   n_debug_values -= n_useless_debug_values;
     731                 :    2847590 :   n_useless_debug_values = 0;
     732                 :            : 
     733                 :    2847590 :   cselib_hash_table->traverse <void *, discard_useless_values> (NULL);
     734                 :            : 
     735                 :    2847590 :   gcc_assert (!n_useless_values);
     736                 :    2847590 : }
     737                 :            : 
     738                 :            : /* Arrange for a value to not be removed from the hash table even if
     739                 :            :    it becomes useless.  */
     740                 :            : 
     741                 :            : void
     742                 :   30913900 : cselib_preserve_value (cselib_val *v)
     743                 :            : {
     744                 :   30913900 :   PRESERVED_VALUE_P (v->val_rtx) = 1;
     745                 :   30913900 : }
     746                 :            : 
     747                 :            : /* Test whether a value is preserved.  */
     748                 :            : 
     749                 :            : bool
     750                 :  190169000 : cselib_preserved_value_p (cselib_val *v)
     751                 :            : {
     752                 :  190169000 :   return PRESERVED_VALUE_P (v->val_rtx);
     753                 :            : }
     754                 :            : 
     755                 :            : /* Arrange for a REG value to be assumed constant through the whole function,
     756                 :            :    never invalidated and preserved across cselib_reset_table calls.  */
     757                 :            : 
     758                 :            : void
     759                 :     666649 : cselib_preserve_cfa_base_value (cselib_val *v, unsigned int regno)
     760                 :            : {
     761                 :     666649 :   if (cselib_preserve_constants
     762                 :     666649 :       && v->locs
     763                 :     666649 :       && REG_P (v->locs->loc))
     764                 :            :     {
     765                 :     338880 :       cfa_base_preserved_val = v;
     766                 :     338880 :       cfa_base_preserved_regno = regno;
     767                 :            :     }
     768                 :     666649 : }
     769                 :            : 
     770                 :            : /* Clean all non-constant expressions in the hash table, but retain
     771                 :            :    their values.  */
     772                 :            : 
     773                 :            : void
     774                 :    2827690 : cselib_preserve_only_values (void)
     775                 :            : {
     776                 :    2827690 :   int i;
     777                 :            : 
     778                 :  217732000 :   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     779                 :  214905000 :     cselib_invalidate_regno (i, reg_raw_mode[i]);
     780                 :            : 
     781                 :    2827690 :   cselib_invalidate_mem (callmem);
     782                 :            : 
     783                 :    2827690 :   remove_useless_values ();
     784                 :            : 
     785                 :    2827690 :   gcc_assert (first_containing_mem == &dummy_val);
     786                 :    2827690 : }
     787                 :            : 
     788                 :            : /* Arrange for a value to be marked as based on stack pointer
     789                 :            :    for find_base_term purposes.  */
     790                 :            : 
     791                 :            : void
     792                 :    1393780 : cselib_set_value_sp_based (cselib_val *v)
     793                 :            : {
     794                 :    1393780 :   SP_BASED_VALUE_P (v->val_rtx) = 1;
     795                 :    1393780 : }
     796                 :            : 
     797                 :            : /* Test whether a value is based on stack pointer for
     798                 :            :    find_base_term purposes.  */
     799                 :            : 
     800                 :            : bool
     801                 : 1218620000 : cselib_sp_based_value_p (cselib_val *v)
     802                 :            : {
     803                 : 1218620000 :   return SP_BASED_VALUE_P (v->val_rtx);
     804                 :            : }
     805                 :            : 
     806                 :            : /* Return the mode in which a register was last set.  If X is not a
     807                 :            :    register, return its mode.  If the mode in which the register was
     808                 :            :    set is not known, or the value was already clobbered, return
     809                 :            :    VOIDmode.  */
     810                 :            : 
     811                 :            : machine_mode
     812                 :   64926300 : cselib_reg_set_mode (const_rtx x)
     813                 :            : {
     814                 :   64926300 :   if (!REG_P (x))
     815                 :   23279000 :     return GET_MODE (x);
     816                 :            : 
     817                 :   41647300 :   if (REG_VALUES (REGNO (x)) == NULL
     818                 :   41647300 :       || REG_VALUES (REGNO (x))->elt == NULL)
     819                 :            :     return VOIDmode;
     820                 :            : 
     821                 :   12526700 :   return GET_MODE (REG_VALUES (REGNO (x))->elt->val_rtx);
     822                 :            : }
     823                 :            : 
     824                 :            : /* If x is a PLUS or an autoinc operation, expand the operation,
     825                 :            :    storing the offset, if any, in *OFF.  */
     826                 :            : 
     827                 :            : static rtx
     828                 : 1093770000 : autoinc_split (rtx x, rtx *off, machine_mode memmode)
     829                 :            : {
     830                 : 1093770000 :   switch (GET_CODE (x))
     831                 :            :     {
     832                 :  603121000 :     case PLUS:
     833                 :  603121000 :       *off = XEXP (x, 1);
     834                 :  603121000 :       x = XEXP (x, 0);
     835                 :  603121000 :       break;
     836                 :            : 
     837                 :   10544100 :     case PRE_DEC:
     838                 :   10544100 :       if (memmode == VOIDmode)
     839                 :            :         return x;
     840                 :            : 
     841                 :   21088100 :       *off = gen_int_mode (-GET_MODE_SIZE (memmode), GET_MODE (x));
     842                 :   10544100 :       x = XEXP (x, 0);
     843                 :   10544100 :       break;
     844                 :            : 
     845                 :          0 :     case PRE_INC:
     846                 :          0 :       if (memmode == VOIDmode)
     847                 :            :         return x;
     848                 :            : 
     849                 :          0 :       *off = gen_int_mode (GET_MODE_SIZE (memmode), GET_MODE (x));
     850                 :          0 :       x = XEXP (x, 0);
     851                 :          0 :       break;
     852                 :            : 
     853                 :    1255600 :     case PRE_MODIFY:
     854                 :    1255600 :       x = XEXP (x, 1);
     855                 :    1255600 :       break;
     856                 :            : 
     857                 :    2568520 :     case POST_DEC:
     858                 :    2568520 :     case POST_INC:
     859                 :    2568520 :     case POST_MODIFY:
     860                 :    2568520 :       x = XEXP (x, 0);
     861                 :    2568520 :       break;
     862                 :            : 
     863                 :            :     default:
     864                 :            :       break;
     865                 :            :     }
     866                 :            : 
     867                 : 1400440000 :   if (GET_MODE (x) == Pmode
     868                 : 1059250000 :       && (REG_P (x) || MEM_P (x) || GET_CODE (x) == VALUE)
     869                 : 1707350000 :       && (*off == NULL_RTX || CONST_INT_P (*off)))
     870                 :            :     {
     871                 :  610748000 :       cselib_val *e;
     872                 :  610748000 :       if (GET_CODE (x) == VALUE)
     873                 :  386492000 :         e = CSELIB_VAL_PTR (x);
     874                 :            :       else
     875                 :  224256000 :         e = cselib_lookup (x, GET_MODE (x), 0, memmode);
     876                 :  610748000 :       if (e)
     877                 : 1393900000 :         for (struct elt_loc_list *l = e->locs; l; l = l->next)
     878                 : 1100850000 :           if (GET_CODE (l->loc) == PLUS
     879                 :  475521000 :               && GET_CODE (XEXP (l->loc, 0)) == VALUE
     880                 :  474932000 :               && SP_DERIVED_VALUE_P (XEXP (l->loc, 0))
     881                 : 1408890000 :               && CONST_INT_P (XEXP (l->loc, 1)))
     882                 :            :             {
     883                 :  308031000 :               if (*off == NULL_RTX)
     884                 :    1634730 :                 *off = XEXP (l->loc, 1);
     885                 :            :               else
     886                 :  306396000 :                 *off = plus_constant (Pmode, *off,
     887                 :  306396000 :                                       INTVAL (XEXP (l->loc, 1)));
     888                 :  308031000 :               if (*off == const0_rtx)
     889                 :  197211000 :                 *off = NULL_RTX;
     890                 :  308031000 :               return XEXP (l->loc, 0);
     891                 :            :             }
     892                 :            :     }
     893                 :            :   return x;
     894                 :            : }
     895                 :            : 
     896                 :            : /* Return nonzero if we can prove that X and Y contain the same value,
     897                 :            :    taking our gathered information into account.  MEMMODE holds the
     898                 :            :    mode of the enclosing MEM, if any, as required to deal with autoinc
     899                 :            :    addressing modes.  If X and Y are not (known to be) part of
     900                 :            :    addresses, MEMMODE should be VOIDmode.  */
     901                 :            : 
     902                 :            : int
     903                 : 1169430000 : rtx_equal_for_cselib_1 (rtx x, rtx y, machine_mode memmode, int depth)
     904                 :            : {
     905                 : 1169430000 :   enum rtx_code code;
     906                 : 1169430000 :   const char *fmt;
     907                 : 1169430000 :   int i;
     908                 :            : 
     909                 : 1169430000 :   if (REG_P (x) || MEM_P (x))
     910                 :            :     {
     911                 :  112327000 :       cselib_val *e = cselib_lookup (x, GET_MODE (x), 0, memmode);
     912                 :            : 
     913                 :  112327000 :       if (e)
     914                 :   91452700 :         x = e->val_rtx;
     915                 :            :     }
     916                 :            : 
     917                 : 1169430000 :   if (REG_P (y) || MEM_P (y))
     918                 :            :     {
     919                 :  103476000 :       cselib_val *e = cselib_lookup (y, GET_MODE (y), 0, memmode);
     920                 :            : 
     921                 :  103476000 :       if (e)
     922                 :   93624100 :         y = e->val_rtx;
     923                 :            :     }
     924                 :            : 
     925                 : 1169430000 :   if (x == y)
     926                 :            :     return 1;
     927                 :            : 
     928                 :  933441000 :   if (GET_CODE (x) == VALUE)
     929                 :            :     {
     930                 :  319666000 :       cselib_val *e = canonical_cselib_val (CSELIB_VAL_PTR (x));
     931                 :  319666000 :       struct elt_loc_list *l;
     932                 :            : 
     933                 :  319666000 :       if (GET_CODE (y) == VALUE)
     934                 :   20502400 :         return e == canonical_cselib_val (CSELIB_VAL_PTR (y));
     935                 :            : 
     936                 :  299164000 :       if ((SP_DERIVED_VALUE_P (x)
     937                 :  109432000 :            || SP_DERIVED_VALUE_P (e->val_rtx))
     938                 :  330060000 :           && GET_MODE (y) == Pmode)
     939                 :            :         {
     940                 :  191498000 :           rtx yoff = NULL;
     941                 :  191498000 :           rtx yr = autoinc_split (y, &yoff, memmode);
     942                 :  191498000 :           if ((yr == x || yr == e->val_rtx) && yoff == NULL_RTX)
     943                 :          6 :             return 1;
     944                 :            :         }
     945                 :            : 
     946                 :  299164000 :       if (depth == 128)
     947                 :            :         return 0;
     948                 :            : 
     949                 :  969065000 :       for (l = e->locs; l; l = l->next)
     950                 :            :         {
     951                 :  687791000 :           rtx t = l->loc;
     952                 :            : 
     953                 :            :           /* Avoid infinite recursion.  We know we have the canonical
     954                 :            :              value, so we can just skip any values in the equivalence
     955                 :            :              list.  */
     956                 :  687791000 :           if (REG_P (t) || MEM_P (t) || GET_CODE (t) == VALUE)
     957                 :  423023000 :             continue;
     958                 :  264768000 :           else if (rtx_equal_for_cselib_1 (t, y, memmode, depth + 1))
     959                 :            :             return 1;
     960                 :            :         }
     961                 :            : 
     962                 :            :       return 0;
     963                 :            :     }
     964                 :  613774000 :   else if (GET_CODE (y) == VALUE)
     965                 :            :     {
     966                 :   32119100 :       cselib_val *e = canonical_cselib_val (CSELIB_VAL_PTR (y));
     967                 :   32119100 :       struct elt_loc_list *l;
     968                 :            : 
     969                 :   32119100 :       if ((SP_DERIVED_VALUE_P (y)
     970                 :   31502700 :            || SP_DERIVED_VALUE_P (e->val_rtx))
     971                 :   32465100 :           && GET_MODE (x) == Pmode)
     972                 :            :         {
     973                 :     569343 :           rtx xoff = NULL;
     974                 :     569343 :           rtx xr = autoinc_split (x, &xoff, memmode);
     975                 :     569343 :           if ((xr == y || xr == e->val_rtx) && xoff == NULL_RTX)
     976                 :          0 :             return 1;
     977                 :            :         }
     978                 :            : 
     979                 :   32119100 :       if (depth == 128)
     980                 :            :         return 0;
     981                 :            : 
     982                 :   75894600 :       for (l = e->locs; l; l = l->next)
     983                 :            :         {
     984                 :   43823000 :           rtx t = l->loc;
     985                 :            : 
     986                 :   43823000 :           if (REG_P (t) || MEM_P (t) || GET_CODE (t) == VALUE)
     987                 :   38812600 :             continue;
     988                 :    5010370 :           else if (rtx_equal_for_cselib_1 (x, t, memmode, depth + 1))
     989                 :            :             return 1;
     990                 :            :         }
     991                 :            : 
     992                 :            :       return 0;
     993                 :            :     }
     994                 :            : 
     995                 :  581655000 :   if (GET_MODE (x) != GET_MODE (y))
     996                 :            :     return 0;
     997                 :            : 
     998                 :  551321000 :   if (GET_CODE (x) != GET_CODE (y)
     999                 :  551321000 :       || (GET_CODE (x) == PLUS
    1000                 :  265624000 :           && GET_MODE (x) == Pmode
    1001                 :  179904000 :           && CONST_INT_P (XEXP (x, 1))
    1002                 :  172896000 :           && CONST_INT_P (XEXP (y, 1))))
    1003                 :            :     {
    1004                 :  444422000 :       rtx xorig = x, yorig = y;
    1005                 :  444422000 :       rtx xoff = NULL, yoff = NULL;
    1006                 :            : 
    1007                 :  444422000 :       x = autoinc_split (x, &xoff, memmode);
    1008                 :  444422000 :       y = autoinc_split (y, &yoff, memmode);
    1009                 :            : 
    1010                 :            :       /* Don't recurse if nothing changed.  */
    1011                 :  444422000 :       if (x != xorig || y != yorig)
    1012                 :            :         {
    1013                 :  417162000 :           if (!xoff != !yoff)
    1014                 :  444422000 :             return 0;
    1015                 :            : 
    1016                 :  358337000 :           if (xoff && !rtx_equal_for_cselib_1 (xoff, yoff, memmode, depth))
    1017                 :            :             return 0;
    1018                 :            : 
    1019                 :  284370000 :           return rtx_equal_for_cselib_1 (x, y, memmode, depth);
    1020                 :            :         }
    1021                 :            : 
    1022                 :   27259900 :       if (GET_CODE (xorig) != GET_CODE (yorig))
    1023                 :            :         return 0;
    1024                 :            :     }
    1025                 :            : 
    1026                 :            :   /* These won't be handled correctly by the code below.  */
    1027                 :  106898000 :   switch (GET_CODE (x))
    1028                 :            :     {
    1029                 :            :     CASE_CONST_UNIQUE:
    1030                 :            :     case DEBUG_EXPR:
    1031                 :            :       return 0;
    1032                 :            : 
    1033                 :     837222 :     case DEBUG_IMPLICIT_PTR:
    1034                 :     837222 :       return DEBUG_IMPLICIT_PTR_DECL (x)
    1035                 :     837222 :              == DEBUG_IMPLICIT_PTR_DECL (y);
    1036                 :            : 
    1037                 :       2394 :     case DEBUG_PARAMETER_REF:
    1038                 :       2394 :       return DEBUG_PARAMETER_REF_DECL (x)
    1039                 :       2394 :              == DEBUG_PARAMETER_REF_DECL (y);
    1040                 :            : 
    1041                 :     113311 :     case ENTRY_VALUE:
    1042                 :            :       /* ENTRY_VALUEs are function invariant, it is thus undesirable to
    1043                 :            :          use rtx_equal_for_cselib_1 to compare the operands.  */
    1044                 :     113311 :       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
    1045                 :            : 
    1046                 :         78 :     case LABEL_REF:
    1047                 :         78 :       return label_ref_label (x) == label_ref_label (y);
    1048                 :            : 
    1049                 :      36557 :     case REG:
    1050                 :      36557 :       return REGNO (x) == REGNO (y);
    1051                 :            : 
    1052                 :     836168 :     case MEM:
    1053                 :            :       /* We have to compare any autoinc operations in the addresses
    1054                 :            :          using this MEM's mode.  */
    1055                 :     836168 :       return rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 0), GET_MODE (x),
    1056                 :     836168 :                                      depth);
    1057                 :            : 
    1058                 :   25482900 :     default:
    1059                 :   25482900 :       break;
    1060                 :            :     }
    1061                 :            : 
    1062                 :   25482900 :   code = GET_CODE (x);
    1063                 :   25482900 :   fmt = GET_RTX_FORMAT (code);
    1064                 :            : 
    1065                 :   43269000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1066                 :            :     {
    1067                 :   36645100 :       int j;
    1068                 :            : 
    1069                 :   36645100 :       switch (fmt[i])
    1070                 :            :         {
    1071                 :          0 :         case 'w':
    1072                 :          0 :           if (XWINT (x, i) != XWINT (y, i))
    1073                 :            :             return 0;
    1074                 :            :           break;
    1075                 :            : 
    1076                 :     434981 :         case 'n':
    1077                 :     434981 :         case 'i':
    1078                 :     434981 :           if (XINT (x, i) != XINT (y, i))
    1079                 :            :             return 0;
    1080                 :            :           break;
    1081                 :            : 
    1082                 :     380870 :         case 'p':
    1083                 :     380870 :           if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
    1084                 :            :             return 0;
    1085                 :            :           break;
    1086                 :            : 
    1087                 :     941163 :         case 'V':
    1088                 :     941163 :         case 'E':
    1089                 :            :           /* Two vectors must have the same length.  */
    1090                 :     941163 :           if (XVECLEN (x, i) != XVECLEN (y, i))
    1091                 :            :             return 0;
    1092                 :            : 
    1093                 :            :           /* And the corresponding elements must match.  */
    1094                 :    2612730 :           for (j = 0; j < XVECLEN (x, i); j++)
    1095                 :    2173930 :             if (! rtx_equal_for_cselib_1 (XVECEXP (x, i, j),
    1096                 :    2173930 :                                           XVECEXP (y, i, j), memmode, depth))
    1097                 :            :               return 0;
    1098                 :            :           break;
    1099                 :            : 
    1100                 :   27549900 :         case 'e':
    1101                 :   27549900 :           if (i == 1
    1102                 :   18193000 :               && targetm.commutative_p (x, UNKNOWN)
    1103                 :   13463100 :               && rtx_equal_for_cselib_1 (XEXP (x, 1), XEXP (y, 0), memmode,
    1104                 :            :                                          depth)
    1105                 :   27752600 :               && rtx_equal_for_cselib_1 (XEXP (x, 0), XEXP (y, 1), memmode,
    1106                 :            :                                          depth))
    1107                 :            :             return 1;
    1108                 :   27402800 :           if (! rtx_equal_for_cselib_1 (XEXP (x, i), XEXP (y, i), memmode,
    1109                 :            :                                         depth))
    1110                 :            :             return 0;
    1111                 :            :           break;
    1112                 :            : 
    1113                 :    3702230 :         case 'S':
    1114                 :    3702230 :         case 's':
    1115                 :    3702230 :           if (strcmp (XSTR (x, i), XSTR (y, i)))
    1116                 :            :             return 0;
    1117                 :            :           break;
    1118                 :            : 
    1119                 :            :         case 'u':
    1120                 :            :           /* These are just backpointers, so they don't matter.  */
    1121                 :            :           break;
    1122                 :            : 
    1123                 :            :         case '0':
    1124                 :            :         case 't':
    1125                 :            :           break;
    1126                 :            : 
    1127                 :            :           /* It is believed that rtx's at this level will never
    1128                 :            :              contain anything but integers and other rtx's,
    1129                 :            :              except for within LABEL_REFs and SYMBOL_REFs.  */
    1130                 :          0 :         default:
    1131                 :          0 :           gcc_unreachable ();
    1132                 :            :         }
    1133                 :            :     }
    1134                 :            :   return 1;
    1135                 :            : }
    1136                 :            : 
    1137                 :            : /* Helper function for cselib_hash_rtx.  Arguments like for cselib_hash_rtx,
    1138                 :            :    except that it hashes (plus:P x c).  */
    1139                 :            : 
    1140                 :            : static unsigned int
    1141                 :  207895000 : cselib_hash_plus_const_int (rtx x, HOST_WIDE_INT c, int create,
    1142                 :            :                             machine_mode memmode)
    1143                 :            : {
    1144                 :  207895000 :   cselib_val *e = cselib_lookup (x, GET_MODE (x), create, memmode);
    1145                 :  207895000 :   if (! e)
    1146                 :            :     return 0;
    1147                 :            : 
    1148                 :  199488000 :   if (! SP_DERIVED_VALUE_P (e->val_rtx))
    1149                 :  341328000 :     for (struct elt_loc_list *l = e->locs; l; l = l->next)
    1150                 :  277146000 :       if (GET_CODE (l->loc) == PLUS
    1151                 :  103037000 :           && GET_CODE (XEXP (l->loc, 0)) == VALUE
    1152                 :  102707000 :           && SP_DERIVED_VALUE_P (XEXP (l->loc, 0))
    1153                 :  369965000 :           && CONST_INT_P (XEXP (l->loc, 1)))
    1154                 :            :         {
    1155                 :   92817600 :           e = CSELIB_VAL_PTR (XEXP (l->loc, 0));
    1156                 :  151137000 :           c = trunc_int_for_mode (c + UINTVAL (XEXP (l->loc, 1)), Pmode);
    1157                 :   92817600 :           break;
    1158                 :            :         }
    1159                 :  199488000 :   if (c == 0)
    1160                 :    6351220 :     return e->hash;
    1161                 :            : 
    1162                 :  193137000 :   unsigned hash = (unsigned) PLUS + (unsigned) GET_MODE (x);
    1163                 :  193137000 :   hash += e->hash;
    1164                 :  193137000 :   unsigned int tem_hash = (unsigned) CONST_INT + (unsigned) VOIDmode;
    1165                 :  193137000 :   tem_hash += ((unsigned) CONST_INT << 7) + (unsigned HOST_WIDE_INT) c;
    1166                 :  193137000 :   if (tem_hash == 0)
    1167                 :          0 :     tem_hash = (unsigned int) CONST_INT;
    1168                 :  193137000 :   hash += tem_hash;
    1169                 :  193137000 :   return hash ? hash : 1 + (unsigned int) PLUS;
    1170                 :            : }
    1171                 :            : 
    1172                 :            : /* Hash an rtx.  Return 0 if we couldn't hash the rtx.
    1173                 :            :    For registers and memory locations, we look up their cselib_val structure
    1174                 :            :    and return its VALUE element.
    1175                 :            :    Possible reasons for return 0 are: the object is volatile, or we couldn't
    1176                 :            :    find a register or memory location in the table and CREATE is zero.  If
    1177                 :            :    CREATE is nonzero, table elts are created for regs and mem.
    1178                 :            :    N.B. this hash function returns the same hash value for RTXes that
    1179                 :            :    differ only in the order of operands, thus it is suitable for comparisons
    1180                 :            :    that take commutativity into account.
    1181                 :            :    If we wanted to also support associative rules, we'd have to use a different
    1182                 :            :    strategy to avoid returning spurious 0, e.g. return ~(~0U >> 1) .
    1183                 :            :    MEMMODE indicates the mode of an enclosing MEM, and it's only
    1184                 :            :    used to compute autoinc values.
    1185                 :            :    We used to have a MODE argument for hashing for CONST_INTs, but that
    1186                 :            :    didn't make sense, since it caused spurious hash differences between
    1187                 :            :     (set (reg:SI 1) (const_int))
    1188                 :            :     (plus:SI (reg:SI 2) (reg:SI 1))
    1189                 :            :    and
    1190                 :            :     (plus:SI (reg:SI 2) (const_int))
    1191                 :            :    If the mode is important in any context, it must be checked specifically
    1192                 :            :    in a comparison anyway, since relying on hash differences is unsafe.  */
    1193                 :            : 
    1194                 :            : static unsigned int
    1195                 :  633124000 : cselib_hash_rtx (rtx x, int create, machine_mode memmode)
    1196                 :            : {
    1197                 :  633124000 :   cselib_val *e;
    1198                 :  633124000 :   poly_int64 offset;
    1199                 :  633124000 :   int i, j;
    1200                 :  633124000 :   enum rtx_code code;
    1201                 :  633124000 :   const char *fmt;
    1202                 :  633124000 :   unsigned int hash = 0;
    1203                 :            : 
    1204                 :  633124000 :   code = GET_CODE (x);
    1205                 :  633124000 :   hash += (unsigned) code + (unsigned) GET_MODE (x);
    1206                 :            : 
    1207                 :  633124000 :   switch (code)
    1208                 :            :     {
    1209                 :     203464 :     case VALUE:
    1210                 :     203464 :       e = CSELIB_VAL_PTR (x);
    1211                 :     203464 :       return e->hash;
    1212                 :            : 
    1213                 :  129273000 :     case MEM:
    1214                 :  129273000 :     case REG:
    1215                 :  129273000 :       e = cselib_lookup (x, GET_MODE (x), create, memmode);
    1216                 :  129273000 :       if (! e)
    1217                 :            :         return 0;
    1218                 :            : 
    1219                 :  114584000 :       return e->hash;
    1220                 :            : 
    1221                 :    7995750 :     case DEBUG_EXPR:
    1222                 :   15991500 :       hash += ((unsigned) DEBUG_EXPR << 7)
    1223                 :    7995750 :               + DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x));
    1224                 :    7995750 :       return hash ? hash : (unsigned int) DEBUG_EXPR;
    1225                 :            : 
    1226                 :    1127800 :     case DEBUG_IMPLICIT_PTR:
    1227                 :    2255600 :       hash += ((unsigned) DEBUG_IMPLICIT_PTR << 7)
    1228                 :    1127800 :               + DECL_UID (DEBUG_IMPLICIT_PTR_DECL (x));
    1229                 :    1127800 :       return hash ? hash : (unsigned int) DEBUG_IMPLICIT_PTR;
    1230                 :            : 
    1231                 :      13664 :     case DEBUG_PARAMETER_REF:
    1232                 :      27328 :       hash += ((unsigned) DEBUG_PARAMETER_REF << 7)
    1233                 :      13664 :               + DECL_UID (DEBUG_PARAMETER_REF_DECL (x));
    1234                 :      13664 :       return hash ? hash : (unsigned int) DEBUG_PARAMETER_REF;
    1235                 :            : 
    1236                 :     760693 :     case ENTRY_VALUE:
    1237                 :            :       /* ENTRY_VALUEs are function invariant, thus try to avoid
    1238                 :            :          recursing on argument if ENTRY_VALUE is one of the
    1239                 :            :          forms emitted by expand_debug_expr, otherwise
    1240                 :            :          ENTRY_VALUE hash would depend on the current value
    1241                 :            :          in some register or memory.  */
    1242                 :     760693 :       if (REG_P (ENTRY_VALUE_EXP (x)))
    1243                 :     747114 :         hash += (unsigned int) REG
    1244                 :     747114 :                 + (unsigned int) GET_MODE (ENTRY_VALUE_EXP (x))
    1245                 :     747114 :                 + (unsigned int) REGNO (ENTRY_VALUE_EXP (x));
    1246                 :      13579 :       else if (MEM_P (ENTRY_VALUE_EXP (x))
    1247                 :      13579 :                && REG_P (XEXP (ENTRY_VALUE_EXP (x), 0)))
    1248                 :      13579 :         hash += (unsigned int) MEM
    1249                 :      13579 :                 + (unsigned int) GET_MODE (XEXP (ENTRY_VALUE_EXP (x), 0))
    1250                 :      13579 :                 + (unsigned int) REGNO (XEXP (ENTRY_VALUE_EXP (x), 0));
    1251                 :            :       else
    1252                 :          0 :         hash += cselib_hash_rtx (ENTRY_VALUE_EXP (x), create, memmode);
    1253                 :     760693 :       return hash ? hash : (unsigned int) ENTRY_VALUE;
    1254                 :            : 
    1255                 :  105277000 :     case CONST_INT:
    1256                 :  105277000 :       hash += ((unsigned) CONST_INT << 7) + UINTVAL (x);
    1257                 :  105277000 :       return hash ? hash : (unsigned int) CONST_INT;
    1258                 :            : 
    1259                 :            :     case CONST_WIDE_INT:
    1260                 :     226395 :       for (i = 0; i < CONST_WIDE_INT_NUNITS (x); i++)
    1261                 :     150930 :         hash += CONST_WIDE_INT_ELT (x, i);
    1262                 :            :       return hash;
    1263                 :            : 
    1264                 :          0 :     case CONST_POLY_INT:
    1265                 :          0 :       {
    1266                 :          0 :         inchash::hash h;
    1267                 :          0 :         h.add_int (hash);
    1268                 :          0 :         for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    1269                 :          0 :           h.add_wide_int (CONST_POLY_INT_COEFFS (x)[i]);
    1270                 :          0 :         return h.end ();
    1271                 :            :       }
    1272                 :            : 
    1273                 :    1510220 :     case CONST_DOUBLE:
    1274                 :            :       /* This is like the general case, except that it only counts
    1275                 :            :          the integers representing the constant.  */
    1276                 :    1510220 :       hash += (unsigned) code + (unsigned) GET_MODE (x);
    1277                 :    1510220 :       if (TARGET_SUPPORTS_WIDE_INT == 0 && GET_MODE (x) == VOIDmode)
    1278                 :            :         hash += ((unsigned) CONST_DOUBLE_LOW (x)
    1279                 :            :                  + (unsigned) CONST_DOUBLE_HIGH (x));
    1280                 :            :       else
    1281                 :    1510220 :         hash += real_hash (CONST_DOUBLE_REAL_VALUE (x));
    1282                 :    1510220 :       return hash ? hash : (unsigned int) CONST_DOUBLE;
    1283                 :            : 
    1284                 :          0 :     case CONST_FIXED:
    1285                 :          0 :       hash += (unsigned int) code + (unsigned int) GET_MODE (x);
    1286                 :          0 :       hash += fixed_hash (CONST_FIXED_VALUE (x));
    1287                 :          0 :       return hash ? hash : (unsigned int) CONST_FIXED;
    1288                 :            : 
    1289                 :     780688 :     case CONST_VECTOR:
    1290                 :     780688 :       {
    1291                 :     780688 :         int units;
    1292                 :     780688 :         rtx elt;
    1293                 :            : 
    1294                 :     780688 :         units = const_vector_encoded_nelts (x);
    1295                 :            : 
    1296                 :    2308330 :         for (i = 0; i < units; ++i)
    1297                 :            :           {
    1298                 :    1527650 :             elt = CONST_VECTOR_ENCODED_ELT (x, i);
    1299                 :    1527650 :             hash += cselib_hash_rtx (elt, 0, memmode);
    1300                 :            :           }
    1301                 :            : 
    1302                 :            :         return hash;
    1303                 :            :       }
    1304                 :            : 
    1305                 :            :       /* Assume there is only one rtx object for any given label.  */
    1306                 :      93365 :     case LABEL_REF:
    1307                 :            :       /* We don't hash on the address of the CODE_LABEL to avoid bootstrap
    1308                 :            :          differences and differences between each stage's debugging dumps.  */
    1309                 :     186730 :       hash += (((unsigned int) LABEL_REF << 7)
    1310                 :      93365 :                + CODE_LABEL_NUMBER (label_ref_label (x)));
    1311                 :      93365 :       return hash ? hash : (unsigned int) LABEL_REF;
    1312                 :            : 
    1313                 :   41925100 :     case SYMBOL_REF:
    1314                 :   41925100 :       {
    1315                 :            :         /* Don't hash on the symbol's address to avoid bootstrap differences.
    1316                 :            :            Different hash values may cause expressions to be recorded in
    1317                 :            :            different orders and thus different registers to be used in the
    1318                 :            :            final assembler.  This also avoids differences in the dump files
    1319                 :            :            between various stages.  */
    1320                 :   41925100 :         unsigned int h = 0;
    1321                 :   41925100 :         const unsigned char *p = (const unsigned char *) XSTR (x, 0);
    1322                 :            : 
    1323                 :  849899000 :         while (*p)
    1324                 :  807974000 :           h += (h << 7) + *p++; /* ??? revisit */
    1325                 :            : 
    1326                 :   41925100 :         hash += ((unsigned int) SYMBOL_REF << 7) + h;
    1327                 :   41925100 :         return hash ? hash : (unsigned int) SYMBOL_REF;
    1328                 :            :       }
    1329                 :            : 
    1330                 :   16864000 :     case PRE_DEC:
    1331                 :   16864000 :     case PRE_INC:
    1332                 :            :       /* We can't compute these without knowing the MEM mode.  */
    1333                 :   16864000 :       gcc_assert (memmode != VOIDmode);
    1334                 :   33728000 :       offset = GET_MODE_SIZE (memmode);
    1335                 :   16864000 :       if (code == PRE_DEC)
    1336                 :   16864000 :         offset = -offset;
    1337                 :            :       /* Adjust the hash so that (mem:MEMMODE (pre_* (reg))) hashes
    1338                 :            :          like (mem:MEMMODE (plus (reg) (const_int I))).  */
    1339                 :   30395800 :       if (GET_MODE (x) == Pmode
    1340                 :   16864000 :           && (REG_P (XEXP (x, 0))
    1341                 :          0 :               || MEM_P (XEXP (x, 0))
    1342                 :          0 :               || GET_CODE (XEXP (x, 0)) == VALUE))
    1343                 :            :         {
    1344                 :   16864000 :           HOST_WIDE_INT c;
    1345                 :   16864000 :           if (offset.is_constant (&c))
    1346                 :   16864000 :             return cselib_hash_plus_const_int (XEXP (x, 0),
    1347                 :   16864000 :                                                trunc_int_for_mode (c, Pmode),
    1348                 :            :                                                create, memmode);
    1349                 :            :         }
    1350                 :          0 :       hash = ((unsigned) PLUS + (unsigned) GET_MODE (x)
    1351                 :          0 :               + cselib_hash_rtx (XEXP (x, 0), create, memmode)
    1352                 :          0 :               + cselib_hash_rtx (gen_int_mode (offset, GET_MODE (x)),
    1353                 :            :                                  create, memmode));
    1354                 :          0 :       return hash ? hash : 1 + (unsigned) PLUS;
    1355                 :            : 
    1356                 :     448564 :     case PRE_MODIFY:
    1357                 :     448564 :       gcc_assert (memmode != VOIDmode);
    1358                 :     448564 :       return cselib_hash_rtx (XEXP (x, 1), create, memmode);
    1359                 :            : 
    1360                 :    1700800 :     case POST_DEC:
    1361                 :    1700800 :     case POST_INC:
    1362                 :    1700800 :     case POST_MODIFY:
    1363                 :    1700800 :       gcc_assert (memmode != VOIDmode);
    1364                 :    1700800 :       return cselib_hash_rtx (XEXP (x, 0), create, memmode);
    1365                 :            : 
    1366                 :            :     case PC:
    1367                 :            :     case CC0:
    1368                 :            :     case CALL:
    1369                 :            :     case UNSPEC_VOLATILE:
    1370                 :            :       return 0;
    1371                 :            : 
    1372                 :     649606 :     case ASM_OPERANDS:
    1373                 :     649606 :       if (MEM_VOLATILE_P (x))
    1374                 :            :         return 0;
    1375                 :            : 
    1376                 :            :       break;
    1377                 :            : 
    1378                 :  221305000 :     case PLUS:
    1379                 :  311863000 :       if (GET_MODE (x) == Pmode
    1380                 :  215596000 :           && (REG_P (XEXP (x, 0))
    1381                 :   16621500 :               || MEM_P (XEXP (x, 0))
    1382                 :   16237700 :               || GET_CODE (XEXP (x, 0)) == VALUE)
    1383                 :  422239000 :           && CONST_INT_P (XEXP (x, 1)))
    1384                 :  191031000 :         return cselib_hash_plus_const_int (XEXP (x, 0), INTVAL (XEXP (x, 1)),
    1385                 :  191031000 :                                            create, memmode);
    1386                 :            :       break;
    1387                 :            : 
    1388                 :            :     default:
    1389                 :            :       break;
    1390                 :            :     }
    1391                 :            : 
    1392                 :  124494000 :   i = GET_RTX_LENGTH (code) - 1;
    1393                 :  124494000 :   fmt = GET_RTX_FORMAT (code);
    1394                 :  339951000 :   for (; i >= 0; i--)
    1395                 :            :     {
    1396                 :  231599000 :       switch (fmt[i])
    1397                 :            :         {
    1398                 :  212397000 :         case 'e':
    1399                 :  212397000 :           {
    1400                 :  212397000 :             rtx tem = XEXP (x, i);
    1401                 :  212397000 :             unsigned int tem_hash = cselib_hash_rtx (tem, create, memmode);
    1402                 :            : 
    1403                 :  212397000 :             if (tem_hash == 0)
    1404                 :            :               return 0;
    1405                 :            : 
    1406                 :  197026000 :             hash += tem_hash;
    1407                 :            :           }
    1408                 :  197026000 :           break;
    1409                 :            :         case 'E':
    1410                 :   20486200 :           for (j = 0; j < XVECLEN (x, i); j++)
    1411                 :            :             {
    1412                 :   13471800 :               unsigned int tem_hash
    1413                 :   13471800 :                 = cselib_hash_rtx (XVECEXP (x, i, j), create, memmode);
    1414                 :            : 
    1415                 :   13471800 :               if (tem_hash == 0)
    1416                 :            :                 return 0;
    1417                 :            : 
    1418                 :   12700700 :               hash += tem_hash;
    1419                 :            :             }
    1420                 :            :           break;
    1421                 :            : 
    1422                 :    1936370 :         case 's':
    1423                 :    1936370 :           {
    1424                 :    1936370 :             const unsigned char *p = (const unsigned char *) XSTR (x, i);
    1425                 :            : 
    1426                 :    1936370 :             if (p)
    1427                 :    9238680 :               while (*p)
    1428                 :    7302310 :                 hash += *p++;
    1429                 :            :             break;
    1430                 :            :           }
    1431                 :            : 
    1432                 :    6162930 :         case 'i':
    1433                 :    6162930 :           hash += XINT (x, i);
    1434                 :    6162930 :           break;
    1435                 :            : 
    1436                 :    3317680 :         case 'p':
    1437                 :    3317680 :           hash += constant_lower_bound (SUBREG_BYTE (x));
    1438                 :    3317680 :           break;
    1439                 :            : 
    1440                 :            :         case '0':
    1441                 :            :         case 't':
    1442                 :            :           /* unused */
    1443                 :            :           break;
    1444                 :            : 
    1445                 :          0 :         default:
    1446                 :          0 :           gcc_unreachable ();
    1447                 :            :         }
    1448                 :            :     }
    1449                 :            : 
    1450                 :  108352000 :   return hash ? hash : 1 + (unsigned int) GET_CODE (x);
    1451                 :            : }
    1452                 :            : 
    1453                 :            : /* Create a new value structure for VALUE and initialize it.  The mode of the
    1454                 :            :    value is MODE.  */
    1455                 :            : 
    1456                 :            : static inline cselib_val *
    1457                 :  268175000 : new_cselib_val (unsigned int hash, machine_mode mode, rtx x)
    1458                 :            : {
    1459                 :  268175000 :   cselib_val *e = cselib_val_pool.allocate ();
    1460                 :            : 
    1461                 :  268175000 :   gcc_assert (hash);
    1462                 :  268175000 :   gcc_assert (next_uid);
    1463                 :            : 
    1464                 :  268175000 :   e->hash = hash;
    1465                 :  268175000 :   e->uid = next_uid++;
    1466                 :            :   /* We use an alloc pool to allocate this RTL construct because it
    1467                 :            :      accounts for about 8% of the overall memory usage.  We know
    1468                 :            :      precisely when we can have VALUE RTXen (when cselib is active)
    1469                 :            :      so we don't need to put them in garbage collected memory.
    1470                 :            :      ??? Why should a VALUE be an RTX in the first place?  */
    1471                 :  268175000 :   e->val_rtx = (rtx_def*) value_pool.allocate ();
    1472                 :  268175000 :   memset (e->val_rtx, 0, RTX_HDR_SIZE);
    1473                 :  268175000 :   PUT_CODE (e->val_rtx, VALUE);
    1474                 :  268175000 :   PUT_MODE (e->val_rtx, mode);
    1475                 :  268175000 :   CSELIB_VAL_PTR (e->val_rtx) = e;
    1476                 :  268175000 :   e->addr_list = 0;
    1477                 :  268175000 :   e->locs = 0;
    1478                 :  268175000 :   e->next_containing_mem = 0;
    1479                 :            : 
    1480                 :  268175000 :   if (dump_file && (dump_flags & TDF_CSELIB))
    1481                 :            :     {
    1482                 :          0 :       fprintf (dump_file, "cselib value %u:%u ", e->uid, hash);
    1483                 :          0 :       if (flag_dump_noaddr || flag_dump_unnumbered)
    1484                 :          0 :         fputs ("# ", dump_file);
    1485                 :            :       else
    1486                 :          0 :         fprintf (dump_file, "%p ", (void*)e);
    1487                 :          0 :       print_rtl_single (dump_file, x);
    1488                 :          0 :       fputc ('\n', dump_file);
    1489                 :            :     }
    1490                 :            : 
    1491                 :  268175000 :   return e;
    1492                 :            : }
    1493                 :            : 
    1494                 :            : /* ADDR_ELT is a value that is used as address.  MEM_ELT is the value that
    1495                 :            :    contains the data at this address.  X is a MEM that represents the
    1496                 :            :    value.  Update the two value structures to represent this situation.  */
    1497                 :            : 
    1498                 :            : static void
    1499                 :   36138700 : add_mem_for_addr (cselib_val *addr_elt, cselib_val *mem_elt, rtx x)
    1500                 :            : {
    1501                 :   36138700 :   addr_elt = canonical_cselib_val (addr_elt);
    1502                 :   36138700 :   mem_elt = canonical_cselib_val (mem_elt);
    1503                 :            : 
    1504                 :            :   /* Avoid duplicates.  */
    1505                 :   36138700 :   addr_space_t as = MEM_ADDR_SPACE (x);
    1506                 :   70096200 :   for (elt_loc_list *l = mem_elt->locs; l; l = l->next)
    1507                 :   33957500 :     if (MEM_P (l->loc)
    1508                 :   13909500 :         && CSELIB_VAL_PTR (XEXP (l->loc, 0)) == addr_elt
    1509                 :   33957500 :         && MEM_ADDR_SPACE (l->loc) == as)
    1510                 :            :       {
    1511                 :          3 :         promote_debug_loc (l);
    1512                 :          3 :         return;
    1513                 :            :       }
    1514                 :            : 
    1515                 :   36138700 :   addr_elt->addr_list = new_elt_list (addr_elt->addr_list, mem_elt);
    1516                 :   36138700 :   new_elt_loc_list (mem_elt,
    1517                 :            :                     replace_equiv_address_nv (x, addr_elt->val_rtx));
    1518                 :   36138700 :   if (mem_elt->next_containing_mem == NULL)
    1519                 :            :     {
    1520                 :   30350800 :       mem_elt->next_containing_mem = first_containing_mem;
    1521                 :   30350800 :       first_containing_mem = mem_elt;
    1522                 :            :     }
    1523                 :            : }
    1524                 :            : 
    1525                 :            : /* Subroutine of cselib_lookup.  Return a value for X, which is a MEM rtx.
    1526                 :            :    If CREATE, make a new one if we haven't seen it before.  */
    1527                 :            : 
    1528                 :            : static cselib_val *
    1529                 :  170782000 : cselib_lookup_mem (rtx x, int create)
    1530                 :            : {
    1531                 :  170782000 :   machine_mode mode = GET_MODE (x);
    1532                 :  170782000 :   machine_mode addr_mode;
    1533                 :  170782000 :   cselib_val **slot;
    1534                 :  170782000 :   cselib_val *addr;
    1535                 :  170782000 :   cselib_val *mem_elt;
    1536                 :            : 
    1537                 :  337922000 :   if (MEM_VOLATILE_P (x) || mode == BLKmode
    1538                 :  166896000 :       || !cselib_record_memory
    1539                 :  307098000 :       || (FLOAT_MODE_P (mode) && flag_float_store))
    1540                 :            :     return 0;
    1541                 :            : 
    1542                 :  136307000 :   addr_mode = GET_MODE (XEXP (x, 0));
    1543                 :  136307000 :   if (addr_mode == VOIDmode)
    1544                 :     718476 :     addr_mode = Pmode;
    1545                 :            : 
    1546                 :            :   /* Look up the value for the address.  */
    1547                 :  136307000 :   addr = cselib_lookup (XEXP (x, 0), addr_mode, create, mode);
    1548                 :  136307000 :   if (! addr)
    1549                 :            :     return 0;
    1550                 :   86815900 :   addr = canonical_cselib_val (addr);
    1551                 :            : 
    1552                 :            :   /* Find a value that describes a value of our mode at that address.  */
    1553                 :   86815900 :   addr_space_t as = MEM_ADDR_SPACE (x);
    1554                 :   88630400 :   for (elt_list *l = addr->addr_list; l; l = l->next)
    1555                 :   58937600 :     if (GET_MODE (l->elt->val_rtx) == mode)
    1556                 :            :       {
    1557                 :   61495900 :         for (elt_loc_list *l2 = l->elt->locs; l2; l2 = l2->next)
    1558                 :   65961700 :           if (MEM_P (l2->loc) && MEM_ADDR_SPACE (l2->loc) == as)
    1559                 :            :             {
    1560                 :   57123200 :               promote_debug_loc (l->elt->locs);
    1561                 :   57123200 :               return l->elt;
    1562                 :            :             }
    1563                 :            :       }
    1564                 :            : 
    1565                 :   29692800 :   if (! create)
    1566                 :            :     return 0;
    1567                 :            : 
    1568                 :   18693900 :   mem_elt = new_cselib_val (next_uid, mode, x);
    1569                 :   18693900 :   add_mem_for_addr (addr, mem_elt, x);
    1570                 :   18693900 :   slot = cselib_find_slot (mode, x, mem_elt->hash, INSERT, VOIDmode);
    1571                 :   18693900 :   *slot = mem_elt;
    1572                 :   18693900 :   return mem_elt;
    1573                 :            : }
    1574                 :            : 
    1575                 :            : /* Search through the possible substitutions in P.  We prefer a non reg
    1576                 :            :    substitution because this allows us to expand the tree further.  If
    1577                 :            :    we find, just a reg, take the lowest regno.  There may be several
    1578                 :            :    non-reg results, we just take the first one because they will all
    1579                 :            :    expand to the same place.  */
    1580                 :            : 
    1581                 :            : static rtx
    1582                 :   14920800 : expand_loc (struct elt_loc_list *p, struct expand_value_data *evd,
    1583                 :            :             int max_depth)
    1584                 :            : {
    1585                 :   14920800 :   rtx reg_result = NULL;
    1586                 :   14920800 :   unsigned int regno = UINT_MAX;
    1587                 :   14920800 :   struct elt_loc_list *p_in = p;
    1588                 :            : 
    1589                 :   32282300 :   for (; p; p = p->next)
    1590                 :            :     {
    1591                 :            :       /* Return these right away to avoid returning stack pointer based
    1592                 :            :          expressions for frame pointer and vice versa, which is something
    1593                 :            :          that would confuse DSE.  See the comment in cselib_expand_value_rtx_1
    1594                 :            :          for more details.  */
    1595                 :   19591900 :       if (REG_P (p->loc)
    1596                 :   19591900 :           && (REGNO (p->loc) == STACK_POINTER_REGNUM
    1597                 :   16092500 :               || REGNO (p->loc) == FRAME_POINTER_REGNUM
    1598                 :   15781800 :               || REGNO (p->loc) == HARD_FRAME_POINTER_REGNUM
    1599                 :   15702900 :               || REGNO (p->loc) == cfa_base_preserved_regno))
    1600                 :     432179 :         return p->loc;
    1601                 :            :       /* Avoid infinite recursion trying to expand a reg into a
    1602                 :            :          the same reg.  */
    1603                 :   19159700 :       if ((REG_P (p->loc))
    1604                 :   15699400 :           && (REGNO (p->loc) < regno)
    1605                 :   34797300 :           && !bitmap_bit_p (evd->regs_active, REGNO (p->loc)))
    1606                 :            :         {
    1607                 :    2505750 :           reg_result = p->loc;
    1608                 :    2505750 :           regno = REGNO (p->loc);
    1609                 :            :         }
    1610                 :            :       /* Avoid infinite recursion and do not try to expand the
    1611                 :            :          value.  */
    1612                 :   16654000 :       else if (GET_CODE (p->loc) == VALUE
    1613                 :     254844 :                && CSELIB_VAL_PTR (p->loc)->locs == p_in)
    1614                 :          0 :         continue;
    1615                 :   16654000 :       else if (!REG_P (p->loc))
    1616                 :            :         {
    1617                 :    3460310 :           rtx result, note;
    1618                 :    3460310 :           if (dump_file && (dump_flags & TDF_CSELIB))
    1619                 :            :             {
    1620                 :          0 :               print_inline_rtx (dump_file, p->loc, 0);
    1621                 :          0 :               fprintf (dump_file, "\n");
    1622                 :            :             }
    1623                 :    3460310 :           if (GET_CODE (p->loc) == LO_SUM
    1624                 :          0 :               && GET_CODE (XEXP (p->loc, 1)) == SYMBOL_REF
    1625                 :          0 :               && p->setting_insn
    1626                 :          0 :               && (note = find_reg_note (p->setting_insn, REG_EQUAL, NULL_RTX))
    1627                 :    3460310 :               && XEXP (note, 0) == XEXP (p->loc, 1))
    1628                 :          0 :             return XEXP (p->loc, 1);
    1629                 :    3460310 :           result = cselib_expand_value_rtx_1 (p->loc, evd, max_depth - 1);
    1630                 :    3460310 :           if (result)
    1631                 :    1798310 :             return result;
    1632                 :            :         }
    1633                 :            : 
    1634                 :            :     }
    1635                 :            : 
    1636                 :   12690400 :   if (regno != UINT_MAX)
    1637                 :            :     {
    1638                 :    2171970 :       rtx result;
    1639                 :    2171970 :       if (dump_file && (dump_flags & TDF_CSELIB))
    1640                 :          0 :         fprintf (dump_file, "r%d\n", regno);
    1641                 :            : 
    1642                 :    2171970 :       result = cselib_expand_value_rtx_1 (reg_result, evd, max_depth - 1);
    1643                 :    2171970 :       if (result)
    1644                 :            :         return result;
    1645                 :            :     }
    1646                 :            : 
    1647                 :   11006800 :   if (dump_file && (dump_flags & TDF_CSELIB))
    1648                 :            :     {
    1649                 :          0 :       if (reg_result)
    1650                 :            :         {
    1651                 :          0 :           print_inline_rtx (dump_file, reg_result, 0);
    1652                 :          0 :           fprintf (dump_file, "\n");
    1653                 :            :         }
    1654                 :            :       else
    1655                 :          0 :         fprintf (dump_file, "NULL\n");
    1656                 :            :     }
    1657                 :            :   return reg_result;
    1658                 :            : }
    1659                 :            : 
    1660                 :            : 
    1661                 :            : /* Forward substitute and expand an expression out to its roots.
    1662                 :            :    This is the opposite of common subexpression.  Because local value
    1663                 :            :    numbering is such a weak optimization, the expanded expression is
    1664                 :            :    pretty much unique (not from a pointer equals point of view but
    1665                 :            :    from a tree shape point of view.
    1666                 :            : 
    1667                 :            :    This function returns NULL if the expansion fails.  The expansion
    1668                 :            :    will fail if there is no value number for one of the operands or if
    1669                 :            :    one of the operands has been overwritten between the current insn
    1670                 :            :    and the beginning of the basic block.  For instance x has no
    1671                 :            :    expansion in:
    1672                 :            : 
    1673                 :            :    r1 <- r1 + 3
    1674                 :            :    x <- r1 + 8
    1675                 :            : 
    1676                 :            :    REGS_ACTIVE is a scratch bitmap that should be clear when passing in.
    1677                 :            :    It is clear on return.  */
    1678                 :            : 
    1679                 :            : rtx
    1680                 :   24357000 : cselib_expand_value_rtx (rtx orig, bitmap regs_active, int max_depth)
    1681                 :            : {
    1682                 :   24357000 :   struct expand_value_data evd;
    1683                 :            : 
    1684                 :   24357000 :   evd.regs_active = regs_active;
    1685                 :   24357000 :   evd.callback = NULL;
    1686                 :   24357000 :   evd.callback_arg = NULL;
    1687                 :   24357000 :   evd.dummy = false;
    1688                 :            : 
    1689                 :   24357000 :   return cselib_expand_value_rtx_1 (orig, &evd, max_depth);
    1690                 :            : }
    1691                 :            : 
    1692                 :            : /* Same as cselib_expand_value_rtx, but using a callback to try to
    1693                 :            :    resolve some expressions.  The CB function should return ORIG if it
    1694                 :            :    can't or does not want to deal with a certain RTX.  Any other
    1695                 :            :    return value, including NULL, will be used as the expansion for
    1696                 :            :    VALUE, without any further changes.  */
    1697                 :            : 
    1698                 :            : rtx
    1699                 :   54402200 : cselib_expand_value_rtx_cb (rtx orig, bitmap regs_active, int max_depth,
    1700                 :            :                             cselib_expand_callback cb, void *data)
    1701                 :            : {
    1702                 :   54402200 :   struct expand_value_data evd;
    1703                 :            : 
    1704                 :   54402200 :   evd.regs_active = regs_active;
    1705                 :   54402200 :   evd.callback = cb;
    1706                 :   54402200 :   evd.callback_arg = data;
    1707                 :   54402200 :   evd.dummy = false;
    1708                 :            : 
    1709                 :   54402200 :   return cselib_expand_value_rtx_1 (orig, &evd, max_depth);
    1710                 :            : }
    1711                 :            : 
    1712                 :            : /* Similar to cselib_expand_value_rtx_cb, but no rtxs are actually copied
    1713                 :            :    or simplified.  Useful to find out whether cselib_expand_value_rtx_cb
    1714                 :            :    would return NULL or non-NULL, without allocating new rtx.  */
    1715                 :            : 
    1716                 :            : bool
    1717                 :          0 : cselib_dummy_expand_value_rtx_cb (rtx orig, bitmap regs_active, int max_depth,
    1718                 :            :                                   cselib_expand_callback cb, void *data)
    1719                 :            : {
    1720                 :          0 :   struct expand_value_data evd;
    1721                 :            : 
    1722                 :          0 :   evd.regs_active = regs_active;
    1723                 :          0 :   evd.callback = cb;
    1724                 :          0 :   evd.callback_arg = data;
    1725                 :          0 :   evd.dummy = true;
    1726                 :            : 
    1727                 :          0 :   return cselib_expand_value_rtx_1 (orig, &evd, max_depth) != NULL;
    1728                 :            : }
    1729                 :            : 
    1730                 :            : /* Internal implementation of cselib_expand_value_rtx and
    1731                 :            :    cselib_expand_value_rtx_cb.  */
    1732                 :            : 
    1733                 :            : static rtx
    1734                 :  133420000 : cselib_expand_value_rtx_1 (rtx orig, struct expand_value_data *evd,
    1735                 :            :                            int max_depth)
    1736                 :            : {
    1737                 :  133420000 :   rtx copy, scopy;
    1738                 :  133420000 :   int i, j;
    1739                 :  133420000 :   RTX_CODE code;
    1740                 :  133420000 :   const char *format_ptr;
    1741                 :  133420000 :   machine_mode mode;
    1742                 :            : 
    1743                 :  133420000 :   code = GET_CODE (orig);
    1744                 :            : 
    1745                 :            :   /* For the context of dse, if we end up expand into a huge tree, we
    1746                 :            :      will not have a useful address, so we might as well just give up
    1747                 :            :      quickly.  */
    1748                 :  133420000 :   if (max_depth <= 0)
    1749                 :            :     return NULL;
    1750                 :            : 
    1751                 :  131858000 :   switch (code)
    1752                 :            :     {
    1753                 :   32950200 :     case REG:
    1754                 :   32950200 :       {
    1755                 :   32950200 :         struct elt_list *l = REG_VALUES (REGNO (orig));
    1756                 :            : 
    1757                 :   32950200 :         if (l && l->elt == NULL)
    1758                 :   15602200 :           l = l->next;
    1759                 :   32959300 :         for (; l; l = l->next)
    1760                 :   24431800 :           if (GET_MODE (l->elt->val_rtx) == GET_MODE (orig))
    1761                 :            :             {
    1762                 :   24422600 :               rtx result;
    1763                 :   24422600 :               unsigned regno = REGNO (orig);
    1764                 :            : 
    1765                 :            :               /* The only thing that we are not willing to do (this
    1766                 :            :                  is requirement of dse and if others potential uses
    1767                 :            :                  need this function we should add a parm to control
    1768                 :            :                  it) is that we will not substitute the
    1769                 :            :                  STACK_POINTER_REGNUM, FRAME_POINTER or the
    1770                 :            :                  HARD_FRAME_POINTER.
    1771                 :            : 
    1772                 :            :                  These expansions confuses the code that notices that
    1773                 :            :                  stores into the frame go dead at the end of the
    1774                 :            :                  function and that the frame is not effected by calls
    1775                 :            :                  to subroutines.  If you allow the
    1776                 :            :                  STACK_POINTER_REGNUM substitution, then dse will
    1777                 :            :                  think that parameter pushing also goes dead which is
    1778                 :            :                  wrong.  If you allow the FRAME_POINTER or the
    1779                 :            :                  HARD_FRAME_POINTER then you lose the opportunity to
    1780                 :            :                  make the frame assumptions.  */
    1781                 :   24422600 :               if (regno == STACK_POINTER_REGNUM
    1782                 :   24422600 :                   || regno == FRAME_POINTER_REGNUM
    1783                 :   12988800 :                   || regno == HARD_FRAME_POINTER_REGNUM
    1784                 :   12507800 :                   || regno == cfa_base_preserved_regno)
    1785                 :            :                 return orig;
    1786                 :            : 
    1787                 :   12309400 :               bitmap_set_bit (evd->regs_active, regno);
    1788                 :            : 
    1789                 :   12309400 :               if (dump_file && (dump_flags & TDF_CSELIB))
    1790                 :          0 :                 fprintf (dump_file, "expanding: r%d into: ", regno);
    1791                 :            : 
    1792                 :   12309400 :               result = expand_loc (l->elt->locs, evd, max_depth);
    1793                 :   12309400 :               bitmap_clear_bit (evd->regs_active, regno);
    1794                 :            : 
    1795                 :   12309400 :               if (result)
    1796                 :            :                 return result;
    1797                 :            :               else
    1798                 :    9929820 :                 return orig;
    1799                 :            :             }
    1800                 :            :         return orig;
    1801                 :            :       }
    1802                 :            : 
    1803                 :            :     CASE_CONST_ANY:
    1804                 :            :     case SYMBOL_REF:
    1805                 :            :     case CODE_LABEL:
    1806                 :            :     case PC:
    1807                 :            :     case CC0:
    1808                 :            :     case SCRATCH:
    1809                 :            :       /* SCRATCH must be shared because they represent distinct values.  */
    1810                 :            :       return orig;
    1811                 :          0 :     case CLOBBER:
    1812                 :          0 :       if (REG_P (XEXP (orig, 0)) && HARD_REGISTER_NUM_P (REGNO (XEXP (orig, 0))))
    1813                 :            :         return orig;
    1814                 :            :       break;
    1815                 :            : 
    1816                 :     175626 :     case CONST:
    1817                 :     175626 :       if (shared_const_p (orig))
    1818                 :            :         return orig;
    1819                 :            :       break;
    1820                 :            : 
    1821                 :     275526 :     case SUBREG:
    1822                 :     275526 :       {
    1823                 :     275526 :         rtx subreg;
    1824                 :            : 
    1825                 :     275526 :         if (evd->callback)
    1826                 :            :           {
    1827                 :     235669 :             subreg = evd->callback (orig, evd->regs_active, max_depth,
    1828                 :            :                                     evd->callback_arg);
    1829                 :     235669 :             if (subreg != orig)
    1830                 :            :               return subreg;
    1831                 :            :           }
    1832                 :            : 
    1833                 :      39857 :         subreg = cselib_expand_value_rtx_1 (SUBREG_REG (orig), evd,
    1834                 :            :                                             max_depth - 1);
    1835                 :      39857 :         if (!subreg)
    1836                 :            :           return NULL;
    1837                 :      43504 :         scopy = simplify_gen_subreg (GET_MODE (orig), subreg,
    1838                 :      21752 :                                      GET_MODE (SUBREG_REG (orig)),
    1839                 :      21752 :                                      SUBREG_BYTE (orig));
    1840                 :      21752 :         if (scopy == NULL
    1841                 :      21729 :             || (GET_CODE (scopy) == SUBREG
    1842                 :      20598 :                 && !REG_P (SUBREG_REG (scopy))
    1843                 :        157 :                 && !MEM_P (SUBREG_REG (scopy))))
    1844                 :        180 :           return NULL;
    1845                 :            : 
    1846                 :            :         return scopy;
    1847                 :            :       }
    1848                 :            : 
    1849                 :   43408700 :     case VALUE:
    1850                 :   43408700 :       {
    1851                 :   43408700 :         rtx result;
    1852                 :            : 
    1853                 :   43408700 :         if (dump_file && (dump_flags & TDF_CSELIB))
    1854                 :            :           {
    1855                 :          0 :             fputs ("\nexpanding ", dump_file);
    1856                 :          0 :             print_rtl_single (dump_file, orig);
    1857                 :          0 :             fputs (" into...", dump_file);
    1858                 :            :           }
    1859                 :            : 
    1860                 :   43408700 :         if (evd->callback)
    1861                 :            :           {
    1862                 :   40797300 :             result = evd->callback (orig, evd->regs_active, max_depth,
    1863                 :            :                                     evd->callback_arg);
    1864                 :            : 
    1865                 :   40797300 :             if (result != orig)
    1866                 :            :               return result;
    1867                 :            :           }
    1868                 :            : 
    1869                 :    2611460 :         result = expand_loc (CSELIB_VAL_PTR (orig)->locs, evd, max_depth);
    1870                 :    2611460 :         return result;
    1871                 :            :       }
    1872                 :            : 
    1873                 :    3946000 :     case DEBUG_EXPR:
    1874                 :    3946000 :       if (evd->callback)
    1875                 :    3946000 :         return evd->callback (orig, evd->regs_active, max_depth,
    1876                 :    3946000 :                               evd->callback_arg);
    1877                 :            :       return orig;
    1878                 :            : 
    1879                 :            :     default:
    1880                 :            :       break;
    1881                 :            :     }
    1882                 :            : 
    1883                 :            :   /* Copy the various flags, fields, and other information.  We assume
    1884                 :            :      that all fields need copying, and then clear the fields that should
    1885                 :            :      not be copied.  That is the sensible default behavior, and forces
    1886                 :            :      us to explicitly document why we are *not* copying a flag.  */
    1887                 :   31352000 :   if (evd->dummy)
    1888                 :            :     copy = NULL;
    1889                 :            :   else
    1890                 :   31352000 :     copy = shallow_copy_rtx (orig);
    1891                 :            : 
    1892                 :   31352000 :   format_ptr = GET_RTX_FORMAT (code);
    1893                 :            : 
    1894                 :   82252600 :   for (i = 0; i < GET_RTX_LENGTH (code); i++)
    1895                 :   53444400 :     switch (*format_ptr++)
    1896                 :            :       {
    1897                 :   48628800 :       case 'e':
    1898                 :   48628800 :         if (XEXP (orig, i) != NULL)
    1899                 :            :           {
    1900                 :   48628800 :             rtx result = cselib_expand_value_rtx_1 (XEXP (orig, i), evd,
    1901                 :            :                                                     max_depth - 1);
    1902                 :   48628800 :             if (!result)
    1903                 :            :               return NULL;
    1904                 :   46117000 :             if (copy)
    1905                 :   46117000 :               XEXP (copy, i) = result;
    1906                 :            :           }
    1907                 :            :         break;
    1908                 :            : 
    1909                 :     236911 :       case 'E':
    1910                 :     236911 :       case 'V':
    1911                 :     236911 :         if (XVEC (orig, i) != NULL)
    1912                 :            :           {
    1913                 :     236911 :             if (copy)
    1914                 :     236911 :               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
    1915                 :     564571 :             for (j = 0; j < XVECLEN (orig, i); j++)
    1916                 :            :               {
    1917                 :     359533 :                 rtx result = cselib_expand_value_rtx_1 (XVECEXP (orig, i, j),
    1918                 :            :                                                         evd, max_depth - 1);
    1919                 :     359533 :                 if (!result)
    1920                 :            :                   return NULL;
    1921                 :     327660 :                 if (copy)
    1922                 :     327660 :                   XVECEXP (copy, i, j) = result;
    1923                 :            :               }
    1924                 :            :           }
    1925                 :            :         break;
    1926                 :            : 
    1927                 :            :       case 't':
    1928                 :            :       case 'w':
    1929                 :            :       case 'i':
    1930                 :            :       case 's':
    1931                 :            :       case 'S':
    1932                 :            :       case 'T':
    1933                 :            :       case 'u':
    1934                 :            :       case 'B':
    1935                 :            :       case '0':
    1936                 :            :         /* These are left unchanged.  */
    1937                 :            :         break;
    1938                 :            : 
    1939                 :          0 :       default:
    1940                 :          0 :         gcc_unreachable ();
    1941                 :            :       }
    1942                 :            : 
    1943                 :   28808300 :   if (evd->dummy)
    1944                 :            :     return orig;
    1945                 :            : 
    1946                 :   28808300 :   mode = GET_MODE (copy);
    1947                 :            :   /* If an operand has been simplified into CONST_INT, which doesn't
    1948                 :            :      have a mode and the mode isn't derivable from whole rtx's mode,
    1949                 :            :      try simplify_*_operation first with mode from original's operand
    1950                 :            :      and as a fallback wrap CONST_INT into gen_rtx_CONST.  */
    1951                 :   28808300 :   scopy = copy;
    1952                 :   28808300 :   switch (GET_RTX_CLASS (code))
    1953                 :            :     {
    1954                 :     276919 :     case RTX_UNARY:
    1955                 :     276919 :       if (CONST_INT_P (XEXP (copy, 0))
    1956                 :        825 :           && GET_MODE (XEXP (orig, 0)) != VOIDmode)
    1957                 :            :         {
    1958                 :        825 :           scopy = simplify_unary_operation (code, mode, XEXP (copy, 0),
    1959                 :            :                                             GET_MODE (XEXP (orig, 0)));
    1960                 :        825 :           if (scopy)
    1961                 :            :             return scopy;
    1962                 :            :         }
    1963                 :            :       break;
    1964                 :            :     case RTX_COMM_ARITH:
    1965                 :            :     case RTX_BIN_ARITH:
    1966                 :            :       /* These expressions can derive operand modes from the whole rtx's mode.  */
    1967                 :            :       break;
    1968                 :      36330 :     case RTX_TERNARY:
    1969                 :      36330 :     case RTX_BITFIELD_OPS:
    1970                 :      36330 :       if (CONST_INT_P (XEXP (copy, 0))
    1971                 :          1 :           && GET_MODE (XEXP (orig, 0)) != VOIDmode)
    1972                 :            :         {
    1973                 :          1 :           scopy = simplify_ternary_operation (code, mode,
    1974                 :            :                                               GET_MODE (XEXP (orig, 0)),
    1975                 :            :                                               XEXP (copy, 0), XEXP (copy, 1),
    1976                 :            :                                               XEXP (copy, 2));
    1977                 :          1 :           if (scopy)
    1978                 :            :             return scopy;
    1979                 :            :         }
    1980                 :            :       break;
    1981                 :     105767 :     case RTX_COMPARE:
    1982                 :     105767 :     case RTX_COMM_COMPARE:
    1983                 :     105767 :       if (CONST_INT_P (XEXP (copy, 0))
    1984                 :        378 :           && GET_MODE (XEXP (copy, 1)) == VOIDmode
    1985                 :        297 :           && (GET_MODE (XEXP (orig, 0)) != VOIDmode
    1986                 :          0 :               || GET_MODE (XEXP (orig, 1)) != VOIDmode))
    1987                 :            :         {
    1988                 :        297 :           scopy = simplify_relational_operation (code, mode,
    1989                 :            :                                                  (GET_MODE (XEXP (orig, 0))
    1990                 :            :                                                   != VOIDmode)
    1991                 :            :                                                  ? GET_MODE (XEXP (orig, 0))
    1992                 :          0 :                                                  : GET_MODE (XEXP (orig, 1)),
    1993                 :            :                                                  XEXP (copy, 0),
    1994                 :            :                                                  XEXP (copy, 1));
    1995                 :        297 :           if (scopy)
    1996                 :            :             return scopy;
    1997                 :            :         }
    1998                 :            :       break;
    1999                 :            :     default:
    2000                 :            :       break;
    2001                 :            :     }
    2002                 :   28807100 :   scopy = simplify_rtx (copy);
    2003                 :   28807100 :   if (scopy)
    2004                 :    2969450 :     return scopy;
    2005                 :            :   return copy;
    2006                 :            : }
    2007                 :            : 
    2008                 :            : /* Walk rtx X and replace all occurrences of REG and MEM subexpressions
    2009                 :            :    with VALUE expressions.  This way, it becomes independent of changes
    2010                 :            :    to registers and memory.
    2011                 :            :    X isn't actually modified; if modifications are needed, new rtl is
    2012                 :            :    allocated.  However, the return value can share rtl with X.
    2013                 :            :    If X is within a MEM, MEMMODE must be the mode of the MEM.  */
    2014                 :            : 
    2015                 :            : rtx
    2016                 :  375982000 : cselib_subst_to_values (rtx x, machine_mode memmode)
    2017                 :            : {
    2018                 :  382881000 :   enum rtx_code code = GET_CODE (x);
    2019                 :  382881000 :   const char *fmt = GET_RTX_FORMAT (code);
    2020                 :  382881000 :   cselib_val *e;
    2021                 :  382881000 :   struct elt_list *l;
    2022                 :  382881000 :   rtx copy = x;
    2023                 :  382881000 :   int i;
    2024                 :  382881000 :   poly_int64 offset;
    2025                 :            : 
    2026                 :  382881000 :   switch (code)
    2027                 :            :     {
    2028                 :  150383000 :     case REG:
    2029                 :  150383000 :       l = REG_VALUES (REGNO (x));
    2030                 :  150383000 :       if (l && l->elt == NULL)
    2031                 :   86281300 :         l = l->next;
    2032                 :  151521000 :       for (; l; l = l->next)
    2033                 :  151521000 :         if (GET_MODE (l->elt->val_rtx) == GET_MODE (x))
    2034                 :  150383000 :           return l->elt->val_rtx;
    2035                 :            : 
    2036                 :          0 :       gcc_unreachable ();
    2037                 :            : 
    2038                 :    4103490 :     case MEM:
    2039                 :    4103490 :       e = cselib_lookup_mem (x, 0);
    2040                 :            :       /* This used to happen for autoincrements, but we deal with them
    2041                 :            :          properly now.  Remove the if stmt for the next release.  */
    2042                 :    4103490 :       if (! e)
    2043                 :            :         {
    2044                 :            :           /* Assign a value that doesn't match any other.  */
    2045                 :          0 :           e = new_cselib_val (next_uid, GET_MODE (x), x);
    2046                 :            :         }
    2047                 :    4103490 :       return e->val_rtx;
    2048                 :            : 
    2049                 :     362584 :     case ENTRY_VALUE:
    2050                 :     362584 :       e = cselib_lookup (x, GET_MODE (x), 0, memmode);
    2051                 :     362584 :       if (! e)
    2052                 :            :         break;
    2053                 :        823 :       return e->val_rtx;
    2054                 :            : 
    2055                 :            :     CASE_CONST_ANY:
    2056                 :            :       return x;
    2057                 :            : 
    2058                 :    6324580 :     case PRE_DEC:
    2059                 :    6324580 :     case PRE_INC:
    2060                 :    6324580 :       gcc_assert (memmode != VOIDmode);
    2061                 :   12649200 :       offset = GET_MODE_SIZE (memmode);
    2062                 :    6324580 :       if (code == PRE_DEC)
    2063                 :    6324580 :         offset = -offset;
    2064                 :    6324580 :       return cselib_subst_to_values (plus_constant (GET_MODE (x),
    2065                 :            :                                                     XEXP (x, 0), offset),
    2066                 :    6324580 :                                      memmode);
    2067                 :            : 
    2068                 :     335146 :     case PRE_MODIFY:
    2069                 :     335146 :       gcc_assert (memmode != VOIDmode);
    2070                 :     335146 :       return cselib_subst_to_values (XEXP (x, 1), memmode);
    2071                 :            : 
    2072                 :     239840 :     case POST_DEC:
    2073                 :     239840 :     case POST_INC:
    2074                 :     239840 :     case POST_MODIFY:
    2075                 :     239840 :       gcc_assert (memmode != VOIDmode);
    2076                 :     239840 :       return cselib_subst_to_values (XEXP (x, 0), memmode);
    2077                 :            : 
    2078                 :   80283900 :     case PLUS:
    2079                 :  111840000 :       if (GET_MODE (x) == Pmode && CONST_INT_P (XEXP (x, 1)))
    2080                 :            :         {
    2081                 :   67701000 :           rtx t = cselib_subst_to_values (XEXP (x, 0), memmode);
    2082                 :   67701000 :           if (GET_CODE (t) == VALUE)
    2083                 :   64605100 :             for (struct elt_loc_list *l = CSELIB_VAL_PTR (t)->locs;
    2084                 :  136792000 :                  l; l = l->next)
    2085                 :   90214300 :               if (GET_CODE (l->loc) == PLUS
    2086                 :   21048100 :                   && GET_CODE (XEXP (l->loc, 0)) == VALUE
    2087                 :   20959200 :                   && SP_DERIVED_VALUE_P (XEXP (l->loc, 0))
    2088                 :  108242000 :                   && CONST_INT_P (XEXP (l->loc, 1)))
    2089                 :   30406700 :                 return plus_constant (Pmode, l->loc, INTVAL (XEXP (x, 1)));
    2090                 :   49673400 :           if (t != XEXP (x, 0))
    2091                 :            :             {
    2092                 :   46969300 :               copy = shallow_copy_rtx (x);
    2093                 :   46969300 :               XEXP (copy, 0) = t;
    2094                 :            :             }
    2095                 :   49673400 :           return copy;
    2096                 :            :         }
    2097                 :            : 
    2098                 :            :     default:
    2099                 :            :       break;
    2100                 :            :     }
    2101                 :            : 
    2102                 :  291817000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    2103                 :            :     {
    2104                 :  191631000 :       if (fmt[i] == 'e')
    2105                 :            :         {
    2106                 :  135410000 :           rtx t = cselib_subst_to_values (XEXP (x, i), memmode);
    2107                 :            : 
    2108                 :  135410000 :           if (t != XEXP (x, i))
    2109                 :            :             {
    2110                 :   99036300 :               if (x == copy)
    2111                 :   69822000 :                 copy = shallow_copy_rtx (x);
    2112                 :   99036300 :               XEXP (copy, i) = t;
    2113                 :            :             }
    2114                 :            :         }
    2115                 :   56221700 :       else if (fmt[i] == 'E')
    2116                 :            :         {
    2117                 :            :           int j;
    2118                 :            : 
    2119                 :   14489800 :           for (j = 0; j < XVECLEN (x, i); j++)
    2120                 :            :             {
    2121                 :    9463700 :               rtx t = cselib_subst_to_values (XVECEXP (x, i, j), memmode);
    2122                 :            : 
    2123                 :    9463700 :               if (t != XVECEXP (x, i, j))
    2124                 :            :                 {
    2125                 :    2558780 :                   if (XVEC (x, i) == XVEC (copy, i))
    2126                 :            :                     {
    2127                 :    1996650 :                       if (x == copy)
    2128                 :    1996650 :                         copy = shallow_copy_rtx (x);
    2129                 :    1996650 :                       XVEC (copy, i) = shallow_copy_rtvec (XVEC (x, i));
    2130                 :            :                     }
    2131                 :    2558780 :                   XVECEXP (copy, i, j) = t;
    2132                 :            :                 }
    2133                 :            :             }
    2134                 :            :         }
    2135                 :            :     }
    2136                 :            : 
    2137                 :            :   return copy;
    2138                 :            : }
    2139                 :            : 
    2140                 :            : /* Wrapper for cselib_subst_to_values, that indicates X is in INSN.  */
    2141                 :            : 
    2142                 :            : rtx
    2143                 :       1191 : cselib_subst_to_values_from_insn (rtx x, machine_mode memmode, rtx_insn *insn)
    2144                 :            : {
    2145                 :       1191 :   rtx ret;
    2146                 :       1191 :   gcc_assert (!cselib_current_insn);
    2147                 :       1191 :   cselib_current_insn = insn;
    2148                 :       1191 :   ret = cselib_subst_to_values (x, memmode);
    2149                 :       1191 :   cselib_current_insn = NULL;
    2150                 :       1191 :   return ret;
    2151                 :            : }
    2152                 :            : 
    2153                 :            : /* Look up the rtl expression X in our tables and return the value it
    2154                 :            :    has.  If CREATE is zero, we return NULL if we don't know the value.
    2155                 :            :    Otherwise, we create a new one if possible, using mode MODE if X
    2156                 :            :    doesn't have a mode (i.e. because it's a constant).  When X is part
    2157                 :            :    of an address, MEMMODE should be the mode of the enclosing MEM if
    2158                 :            :    we're tracking autoinc expressions.  */
    2159                 :            : 
    2160                 :            : static cselib_val *
    2161                 : 1642240000 : cselib_lookup_1 (rtx x, machine_mode mode,
    2162                 :            :                  int create, machine_mode memmode)
    2163                 :            : {
    2164                 : 1642240000 :   cselib_val **slot;
    2165                 : 1642240000 :   cselib_val *e;
    2166                 : 1642240000 :   unsigned int hashval;
    2167                 :            : 
    2168                 : 1642240000 :   if (GET_MODE (x) != VOIDmode)
    2169                 : 1588070000 :     mode = GET_MODE (x);
    2170                 :            : 
    2171                 : 1642240000 :   if (GET_CODE (x) == VALUE)
    2172                 :   49462300 :     return CSELIB_VAL_PTR (x);
    2173                 :            : 
    2174                 : 1592780000 :   if (REG_P (x))
    2175                 :            :     {
    2176                 : 1022520000 :       struct elt_list *l;
    2177                 : 1022520000 :       unsigned int i = REGNO (x);
    2178                 :            : 
    2179                 : 1022520000 :       l = REG_VALUES (i);
    2180                 : 1022520000 :       if (l && l->elt == NULL)
    2181                 :  432028000 :         l = l->next;
    2182                 : 1029690000 :       for (; l; l = l->next)
    2183                 :  805471000 :         if (mode == GET_MODE (l->elt->val_rtx))
    2184                 :            :           {
    2185                 :  798297000 :             promote_debug_loc (l->elt->locs);
    2186                 :  798297000 :             return l->elt;
    2187                 :            :           }
    2188                 :            : 
    2189                 :  224223000 :       if (! create)
    2190                 :            :         return 0;
    2191                 :            : 
    2192                 :   86074700 :       if (i < FIRST_PSEUDO_REGISTER)
    2193                 :            :         {
    2194                 :   49973500 :           unsigned int n = hard_regno_nregs (i, mode);
    2195                 :            : 
    2196                 :   49973500 :           if (n > max_value_regs)
    2197                 :   18112100 :             max_value_regs = n;
    2198                 :            :         }
    2199                 :            : 
    2200                 :   86074700 :       e = new_cselib_val (next_uid, GET_MODE (x), x);
    2201                 :  105130000 :       if (GET_MODE (x) == Pmode && x == stack_pointer_rtx)
    2202                 :    8505690 :         SP_DERIVED_VALUE_P (e->val_rtx) = 1;
    2203                 :   86074700 :       new_elt_loc_list (e, x);
    2204                 :            : 
    2205                 :   86074700 :       scalar_int_mode int_mode;
    2206                 :   86074700 :       if (REG_VALUES (i) == 0)
    2207                 :            :         {
    2208                 :            :           /* Maintain the invariant that the first entry of
    2209                 :            :              REG_VALUES, if present, must be the value used to set the
    2210                 :            :              register, or NULL.  */
    2211                 :   80045500 :           used_regs[n_used_regs++] = i;
    2212                 :   80045500 :           REG_VALUES (i) = new_elt_list (REG_VALUES (i), NULL);
    2213                 :            :         }
    2214                 :    6029280 :       else if (cselib_preserve_constants
    2215                 :    6029280 :                && is_int_mode (mode, &int_mode))
    2216                 :            :         {
    2217                 :            :           /* During var-tracking, try harder to find equivalences
    2218                 :            :              for SUBREGs.  If a setter sets say a DImode register
    2219                 :            :              and user uses that register only in SImode, add a lowpart
    2220                 :            :              subreg location.  */
    2221                 :     815143 :           struct elt_list *lwider = NULL;
    2222                 :     815143 :           scalar_int_mode lmode;
    2223                 :     815143 :           l = REG_VALUES (i);
    2224                 :     815143 :           if (l && l->elt == NULL)
    2225                 :     586653 :             l = l->next;
    2226                 :    1084890 :           for (; l; l = l->next)
    2227                 :     484135 :             if (is_int_mode (GET_MODE (l->elt->val_rtx), &lmode)
    2228                 :     428768 :                 && GET_MODE_SIZE (lmode) > GET_MODE_SIZE (int_mode)
    2229                 :     135732 :                 && (lwider == NULL
    2230                 :        618 :                     || partial_subreg_p (lmode,
    2231                 :        618 :                                          GET_MODE (lwider->elt->val_rtx))))
    2232                 :            :               {
    2233                 :     135555 :                 struct elt_loc_list *el;
    2234                 :     143483 :                 if (i < FIRST_PSEUDO_REGISTER
    2235                 :     135555 :                     && hard_regno_nregs (i, lmode) != 1)
    2236                 :       7928 :                   continue;
    2237                 :     258186 :                 for (el = l->elt->locs; el; el = el->next)
    2238                 :     240908 :                   if (!REG_P (el->loc))
    2239                 :            :                     break;
    2240                 :     127627 :                 if (el)
    2241                 :     110349 :                   lwider = l;
    2242                 :            :               }
    2243                 :     815143 :           if (lwider)
    2244                 :            :             {
    2245                 :     219816 :               rtx sub = lowpart_subreg (int_mode, lwider->elt->val_rtx,
    2246                 :     109908 :                                         GET_MODE (lwider->elt->val_rtx));
    2247                 :     109908 :               if (sub)
    2248                 :     109908 :                 new_elt_loc_list (e, sub);
    2249                 :            :             }
    2250                 :            :         }
    2251                 :   86074700 :       REG_VALUES (i)->next = new_elt_list (REG_VALUES (i)->next, e);
    2252                 :   86074700 :       slot = cselib_find_slot (mode, x, e->hash, INSERT, memmode);
    2253                 :   86074700 :       *slot = e;
    2254                 :   86074700 :       return e;
    2255                 :            :     }
    2256                 :            : 
    2257                 :  570257000 :   if (MEM_P (x))
    2258                 :  166678000 :     return cselib_lookup_mem (x, create);
    2259                 :            : 
    2260                 :  403578000 :   hashval = cselib_hash_rtx (x, create, memmode);
    2261                 :            :   /* Can't even create if hashing is not possible.  */
    2262                 :  403578000 :   if (! hashval)
    2263                 :            :     return 0;
    2264                 :            : 
    2265                 :  523861000 :   slot = cselib_find_slot (mode, x, hashval,
    2266                 :            :                            create ? INSERT : NO_INSERT, memmode);
    2267                 :  370933000 :   if (slot == 0)
    2268                 :            :     return 0;
    2269                 :            : 
    2270                 :  297771000 :   e = (cselib_val *) *slot;
    2271                 :  297771000 :   if (e)
    2272                 :            :     return e;
    2273                 :            : 
    2274                 :  163406000 :   e = new_cselib_val (hashval, mode, x);
    2275                 :            : 
    2276                 :            :   /* We have to fill the slot before calling cselib_subst_to_values:
    2277                 :            :      the hash table is inconsistent until we do so, and
    2278                 :            :      cselib_subst_to_values will need to do lookups.  */
    2279                 :  163406000 :   *slot = e;
    2280                 :  163406000 :   rtx v = cselib_subst_to_values (x, memmode);
    2281                 :            : 
    2282                 :            :   /* If cselib_preserve_constants, we might get a SP_DERIVED_VALUE_P
    2283                 :            :      VALUE that isn't in the hash tables anymore.  */
    2284                 :  163406000 :   if (GET_CODE (v) == VALUE && SP_DERIVED_VALUE_P (v) && PRESERVED_VALUE_P (v))
    2285                 :          0 :     PRESERVED_VALUE_P (e->val_rtx) = 1;
    2286                 :            : 
    2287                 :  163406000 :   new_elt_loc_list (e, v);
    2288                 :  163406000 :   return e;
    2289                 :            : }
    2290                 :            : 
    2291                 :            : /* Wrapper for cselib_lookup, that indicates X is in INSN.  */
    2292                 :            : 
    2293                 :            : cselib_val *
    2294                 :    1889680 : cselib_lookup_from_insn (rtx x, machine_mode mode,
    2295                 :            :                          int create, machine_mode memmode, rtx_insn *insn)
    2296                 :            : {
    2297                 :    1889680 :   cselib_val *ret;
    2298                 :            : 
    2299                 :    1889680 :   gcc_assert (!cselib_current_insn);
    2300                 :    1889680 :   cselib_current_insn = insn;
    2301                 :            : 
    2302                 :    1889680 :   ret = cselib_lookup (x, mode, create, memmode);
    2303                 :            : 
    2304                 :    1889680 :   cselib_current_insn = NULL;
    2305                 :            : 
    2306                 :    1889680 :   return ret;
    2307                 :            : }
    2308                 :            : 
    2309                 :            : /* Wrapper for cselib_lookup_1, that logs the lookup result and
    2310                 :            :    maintains invariants related with debug insns.  */
    2311                 :            : 
    2312                 :            : cselib_val *
    2313                 : 1642240000 : cselib_lookup (rtx x, machine_mode mode,
    2314                 :            :                int create, machine_mode memmode)
    2315                 :            : {
    2316                 : 1642240000 :   cselib_val *ret = cselib_lookup_1 (x, mode, create, memmode);
    2317                 :            : 
    2318                 :            :   /* ??? Should we return NULL if we're not to create an entry, the
    2319                 :            :      found loc is a debug loc and cselib_current_insn is not DEBUG?
    2320                 :            :      If so, we should also avoid converting val to non-DEBUG; probably
    2321                 :            :      easiest setting cselib_current_insn to NULL before the call
    2322                 :            :      above.  */
    2323                 :            : 
    2324                 : 1642240000 :   if (dump_file && (dump_flags & TDF_CSELIB))
    2325                 :            :     {
    2326                 :          0 :       fputs ("cselib lookup ", dump_file);
    2327                 :          0 :       print_inline_rtx (dump_file, x, 2);
    2328                 :          0 :       fprintf (dump_file, " => %u:%u\n",
    2329                 :            :                ret ? ret->uid : 0,
    2330                 :            :                ret ? ret->hash : 0);
    2331                 :            :     }
    2332                 :            : 
    2333                 : 1642240000 :   return ret;
    2334                 :            : }
    2335                 :            : 
    2336                 :            : /* Invalidate the value at *L, which is part of REG_VALUES (REGNO).  */
    2337                 :            : 
    2338                 :            : static void
    2339                 :  118603000 : cselib_invalidate_regno_val (unsigned int regno, struct elt_list **l)
    2340                 :            : {
    2341                 :  118603000 :   cselib_val *v = (*l)->elt;
    2342                 :  118603000 :   if (*l == REG_VALUES (regno))
    2343                 :            :     {
    2344                 :            :       /* Maintain the invariant that the first entry of
    2345                 :            :          REG_VALUES, if present, must be the value used to set
    2346                 :            :          the register, or NULL.  This is also nice because
    2347                 :            :          then we won't push the same regno onto user_regs
    2348                 :            :          multiple times.  */
    2349                 :   92246000 :       (*l)->elt = NULL;
    2350                 :   92246000 :       l = &(*l)->next;
    2351                 :            :     }
    2352                 :            :   else
    2353                 :   26357100 :     unchain_one_elt_list (l);
    2354                 :            : 
    2355                 :  118603000 :   v = canonical_cselib_val (v);
    2356                 :            : 
    2357                 :  118603000 :   bool had_locs = v->locs != NULL;
    2358                 :  118603000 :   rtx_insn *setting_insn = v->locs ? v->locs->setting_insn : NULL;
    2359                 :            : 
    2360                 :            :   /* Now, we clear the mapping from value to reg.  It must exist, so
    2361                 :            :      this code will crash intentionally if it doesn't.  */
    2362                 :  118603000 :   for (elt_loc_list **p = &v->locs; ; p = &(*p)->next)
    2363                 :            :     {
    2364                 :  135195000 :       rtx x = (*p)->loc;
    2365                 :            : 
    2366                 :  135195000 :       if (REG_P (x) && REGNO (x) == regno)
    2367                 :            :         {
    2368                 :  118603000 :           unchain_one_elt_loc_list (p);
    2369                 :  118603000 :           break;
    2370                 :            :         }
    2371                 :   16592000 :     }
    2372                 :            : 
    2373                 :  118603000 :   if (had_locs && v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx))
    2374                 :            :     {
    2375                 :   17574500 :       if (setting_insn && DEBUG_INSN_P (setting_insn))
    2376                 :          0 :         n_useless_debug_values++;
    2377                 :            :       else
    2378                 :   17574500 :         n_useless_values++;
    2379                 :            :     }
    2380                 :  118603000 : }
    2381                 :            : 
    2382                 :            : /* Invalidate any entries in reg_values that overlap REGNO.  This is called
    2383                 :            :    if REGNO is changing.  MODE is the mode of the assignment to REGNO, which
    2384                 :            :    is used to determine how many hard registers are being changed.  If MODE
    2385                 :            :    is VOIDmode, then only REGNO is being changed; this is used when
    2386                 :            :    invalidating call clobbered registers across a call.  */
    2387                 :            : 
    2388                 :            : static void
    2389                 :  470772000 : cselib_invalidate_regno (unsigned int regno, machine_mode mode)
    2390                 :            : {
    2391                 :  470772000 :   unsigned int endregno;
    2392                 :  470772000 :   unsigned int i;
    2393                 :            : 
    2394                 :            :   /* If we see pseudos after reload, something is _wrong_.  */
    2395                 :  470772000 :   gcc_assert (!reload_completed || regno < FIRST_PSEUDO_REGISTER
    2396                 :            :               || reg_renumber[regno] < 0);
    2397                 :            : 
    2398                 :            :   /* Determine the range of registers that must be invalidated.  For
    2399                 :            :      pseudos, only REGNO is affected.  For hard regs, we must take MODE
    2400                 :            :      into account, and we must also invalidate lower register numbers
    2401                 :            :      if they contain values that overlap REGNO.  */
    2402                 :  470772000 :   if (regno < FIRST_PSEUDO_REGISTER)
    2403                 :            :     {
    2404                 :  406822000 :       gcc_assert (mode != VOIDmode);
    2405                 :            : 
    2406                 :  406822000 :       if (regno < max_value_regs)
    2407                 :            :         i = 0;
    2408                 :            :       else
    2409                 :  380159000 :         i = regno - max_value_regs;
    2410                 :            : 
    2411                 :  406822000 :       endregno = end_hard_regno (mode, regno);
    2412                 :            :     }
    2413                 :            :   else
    2414                 :            :     {
    2415                 :   63950100 :       i = regno;
    2416                 :   63950100 :       endregno = regno + 1;
    2417                 :            :     }
    2418                 :            : 
    2419                 : 1297890000 :   for (; i < endregno; i++)
    2420                 :            :     {
    2421                 :  827121000 :       struct elt_list **l = &REG_VALUES (i);
    2422                 :            : 
    2423                 :            :       /* Go through all known values for this reg; if it overlaps the range
    2424                 :            :          we're invalidating, remove the value.  */
    2425                 : 1079400000 :       while (*l)
    2426                 :            :         {
    2427                 :  252275000 :           cselib_val *v = (*l)->elt;
    2428                 :  252275000 :           unsigned int this_last = i;
    2429                 :            : 
    2430                 :  252275000 :           if (i < FIRST_PSEUDO_REGISTER && v != NULL)
    2431                 :  111886000 :             this_last = end_hard_regno (GET_MODE (v->val_rtx), i) - 1;
    2432                 :            : 
    2433                 :  252275000 :           if (this_last < regno || v == NULL
    2434                 :   78368900 :               || (v == cfa_base_preserved_val
    2435                 :    2828830 :                   && i == cfa_base_preserved_regno))
    2436                 :            :             {
    2437                 :  176734000 :               l = &(*l)->next;
    2438                 :  176734000 :               continue;
    2439                 :            :             }
    2440                 :            : 
    2441                 :            :           /* We have an overlap.  */
    2442                 :   75541200 :           cselib_invalidate_regno_val (i, l);
    2443                 :            :         }
    2444                 :            :     }
    2445                 :  470772000 : }
    2446                 :            : 
    2447                 :            : /* Invalidate any locations in the table which are changed because of a
    2448                 :            :    store to MEM_RTX.  If this is called because of a non-const call
    2449                 :            :    instruction, MEM_RTX is (mem:BLK const0_rtx).  */
    2450                 :            : 
    2451                 :            : static void
    2452                 :   82612000 : cselib_invalidate_mem (rtx mem_rtx)
    2453                 :            : {
    2454                 :   82612000 :   cselib_val **vp, *v, *next;
    2455                 :   82612000 :   int num_mems = 0;
    2456                 :   82612000 :   rtx mem_addr;
    2457                 :            : 
    2458                 :   82612000 :   mem_addr = canon_rtx (get_addr (XEXP (mem_rtx, 0)));
    2459                 :   82612000 :   mem_rtx = canon_rtx (mem_rtx);
    2460                 :            : 
    2461                 :   82612000 :   vp = &first_containing_mem;
    2462                 :  255451000 :   for (v = *vp; v != &dummy_val; v = next)
    2463                 :            :     {
    2464                 :  172839000 :       bool has_mem = false;
    2465                 :  172839000 :       struct elt_loc_list **p = &v->locs;
    2466                 :  172839000 :       bool had_locs = v->locs != NULL;
    2467                 :  172839000 :       rtx_insn *setting_insn = v->locs ? v->locs->setting_insn : NULL;
    2468                 :            : 
    2469                 :  552493000 :       while (*p)
    2470                 :            :         {
    2471                 :  379654000 :           rtx x = (*p)->loc;
    2472                 :  379654000 :           cselib_val *addr;
    2473                 :  379654000 :           struct elt_list **mem_chain;
    2474                 :            : 
    2475                 :            :           /* MEMs may occur in locations only at the top level; below
    2476                 :            :              that every MEM or REG is substituted by its VALUE.  */
    2477                 :  379654000 :           if (!MEM_P (x))
    2478                 :            :             {
    2479                 :  110388000 :               p = &(*p)->next;
    2480                 :  110388000 :               continue;
    2481                 :            :             }
    2482                 :  512653000 :           if (num_mems < param_max_cselib_memory_locations
    2483                 :  538367000 :               && ! canon_anti_dependence (x, false, mem_rtx,
    2484                 :  269101000 :                                           GET_MODE (mem_rtx), mem_addr))
    2485                 :            :             {
    2486                 :  243387000 :               has_mem = true;
    2487                 :  243387000 :               num_mems++;
    2488                 :  243387000 :               p = &(*p)->next;
    2489                 :  243387000 :               continue;
    2490                 :            :             }
    2491                 :            : 
    2492                 :            :           /* This one overlaps.  */
    2493                 :            :           /* We must have a mapping from this MEM's address to the
    2494                 :            :              value (E).  Remove that, too.  */
    2495                 :   25879400 :           addr = cselib_lookup (XEXP (x, 0), VOIDmode, 0, GET_MODE (x));
    2496                 :   25879400 :           addr = canonical_cselib_val (addr);
    2497                 :   25879400 :           gcc_checking_assert (v == canonical_cselib_val (v));
    2498                 :   25879400 :           mem_chain = &addr->addr_list;
    2499                 :   25885700 :           for (;;)
    2500                 :            :             {
    2501                 :   25882500 :               cselib_val *canon = canonical_cselib_val ((*mem_chain)->elt);
    2502                 :            : 
    2503                 :   25882500 :               if (canon == v)
    2504                 :            :                 {
    2505                 :   25879400 :                   unchain_one_elt_list (mem_chain);
    2506                 :   25879400 :                   break;
    2507                 :            :                 }
    2508                 :            : 
    2509                 :            :               /* Record canonicalized elt.  */
    2510                 :       3181 :               (*mem_chain)->elt = canon;
    2511                 :            : 
    2512                 :       3181 :               mem_chain = &(*mem_chain)->next;
    2513                 :       3181 :             }
    2514                 :            : 
    2515                 :  578372000 :           unchain_one_elt_loc_list (p);
    2516                 :            :         }
    2517                 :            : 
    2518                 :  172839000 :       if (had_locs && v->locs == 0 && !PRESERVED_VALUE_P (v->val_rtx))
    2519                 :            :         {
    2520                 :    5305220 :           if (setting_insn && DEBUG_INSN_P (setting_insn))
    2521                 :          0 :             n_useless_debug_values++;
    2522                 :            :           else
    2523                 :    5305220 :             n_useless_values++;
    2524                 :            :         }
    2525                 :            : 
    2526                 :  172839000 :       next = v->next_containing_mem;
    2527                 :  172839000 :       if (has_mem)
    2528                 :            :         {
    2529                 :  151322000 :           *vp = v;
    2530                 :  151322000 :           vp = &(*vp)->next_containing_mem;
    2531                 :            :         }
    2532                 :            :       else
    2533                 :   21516700 :         v->next_containing_mem = NULL;
    2534                 :            :     }
    2535                 :   82612000 :   *vp = &dummy_val;
    2536                 :   82612000 : }
    2537                 :            : 
    2538                 :            : /* Invalidate DEST.  */
    2539                 :            : 
    2540                 :            : void
    2541                 :  343805000 : cselib_invalidate_rtx (rtx dest)
    2542                 :            : {
    2543                 :  343805000 :   while (GET_CODE (dest) == SUBREG
    2544                 :  343805000 :          || GET_CODE (dest) == ZERO_EXTRACT
    2545                 :  343805000 :          || GET_CODE (dest) == STRICT_LOW_PART)
    2546                 :          0 :     dest = XEXP (dest, 0);
    2547                 :            : 
    2548                 :  343805000 :   if (REG_P (dest))
    2549                 :  255868000 :     cselib_invalidate_regno (REGNO (dest), GET_MODE (dest));
    2550                 :   87937300 :   else if (MEM_P (dest))
    2551                 :   57735500 :     cselib_invalidate_mem (dest);
    2552                 :  343805000 : }
    2553                 :            : 
    2554                 :            : /* A wrapper for cselib_invalidate_rtx to be called via note_stores.  */
    2555                 :            : 
    2556                 :            : static void
    2557                 :  329474000 : cselib_invalidate_rtx_note_stores (rtx dest, const_rtx,
    2558                 :            :                                    void *data ATTRIBUTE_UNUSED)
    2559                 :            : {
    2560                 :  329474000 :   cselib_invalidate_rtx (dest);
    2561                 :  329474000 : }
    2562                 :            : 
    2563                 :            : /* Record the result of a SET instruction.  DEST is being set; the source
    2564                 :            :    contains the value described by SRC_ELT.  If DEST is a MEM, DEST_ADDR_ELT
    2565                 :            :    describes its address.  */
    2566                 :            : 
    2567                 :            : static void
    2568                 :  234833000 : cselib_record_set (rtx dest, cselib_val *src_elt, cselib_val *dest_addr_elt)
    2569                 :            : {
    2570                 :  234833000 :   if (src_elt == 0 || side_effects_p (dest))
    2571                 :   44006800 :     return;
    2572                 :            : 
    2573                 :  190826000 :   if (REG_P (dest))
    2574                 :            :     {
    2575                 :  173381000 :       unsigned int dreg = REGNO (dest);
    2576                 :  173381000 :       if (dreg < FIRST_PSEUDO_REGISTER)
    2577                 :            :         {
    2578                 :  129604000 :           unsigned int n = REG_NREGS (dest);
    2579                 :            : 
    2580                 :  129604000 :           if (n > max_value_regs)
    2581                 :   15850400 :             max_value_regs = n;
    2582                 :            :         }
    2583                 :            : 
    2584                 :  173381000 :       if (REG_VALUES (dreg) == 0)
    2585                 :            :         {
    2586                 :  102442000 :           used_regs[n_used_regs++] = dreg;
    2587                 :  102442000 :           REG_VALUES (dreg) = new_elt_list (REG_VALUES (dreg), src_elt);
    2588                 :            :         }
    2589                 :            :       else
    2590                 :            :         {
    2591                 :            :           /* The register should have been invalidated.  */
    2592                 :   70939500 :           gcc_assert (REG_VALUES (dreg)->elt == 0);
    2593                 :   70939500 :           REG_VALUES (dreg)->elt = src_elt;
    2594                 :            :         }
    2595                 :            : 
    2596                 :  173381000 :       if (src_elt->locs == 0 && !PRESERVED_VALUE_P (src_elt->val_rtx))
    2597                 :    3997920 :         n_useless_values--;
    2598                 :  173381000 :       new_elt_loc_list (src_elt, dest);
    2599                 :            :     }
    2600                 :   17444900 :   else if (MEM_P (dest) && dest_addr_elt != 0
    2601                 :   17444900 :            && cselib_record_memory)
    2602                 :            :     {
    2603                 :   17444900 :       if (src_elt->locs == 0 && !PRESERVED_VALUE_P (src_elt->val_rtx))
    2604                 :         24 :         n_useless_values--;
    2605                 :   17444900 :       add_mem_for_addr (dest_addr_elt, src_elt, dest);
    2606                 :            :     }
    2607                 :            : }
    2608                 :            : 
    2609                 :            : /* Make ELT and X's VALUE equivalent to each other at INSN.  */
    2610                 :            : 
    2611                 :            : void
    2612                 :    2819590 : cselib_add_permanent_equiv (cselib_val *elt, rtx x, rtx_insn *insn)
    2613                 :            : {
    2614                 :    2819590 :   cselib_val *nelt;
    2615                 :    2819590 :   rtx_insn *save_cselib_current_insn = cselib_current_insn;
    2616                 :            : 
    2617                 :    2819590 :   gcc_checking_assert (elt);
    2618                 :    2819590 :   gcc_checking_assert (PRESERVED_VALUE_P (elt->val_rtx));
    2619                 :    2819590 :   gcc_checking_assert (!side_effects_p (x));
    2620                 :            : 
    2621                 :    2819590 :   cselib_current_insn = insn;
    2622                 :            : 
    2623                 :    2819590 :   nelt = cselib_lookup (x, GET_MODE (elt->val_rtx), 1, VOIDmode);
    2624                 :            : 
    2625                 :    2819590 :   if (nelt != elt)
    2626                 :            :     {
    2627                 :    1921900 :       cselib_any_perm_equivs = true;
    2628                 :            : 
    2629                 :    1921900 :       if (!PRESERVED_VALUE_P (nelt->val_rtx))
    2630                 :    1913470 :         cselib_preserve_value (nelt);
    2631                 :            : 
    2632                 :    1921900 :       new_elt_loc_list (nelt, elt->val_rtx);
    2633                 :            :     }
    2634                 :            : 
    2635                 :    2819590 :   cselib_current_insn = save_cselib_current_insn;
    2636                 :    2819590 : }
    2637                 :            : 
    2638                 :            : /* Return TRUE if any permanent equivalences have been recorded since
    2639                 :            :    the table was last initialized.  */
    2640                 :            : bool
    2641                 : 1474790000 : cselib_have_permanent_equivalences (void)
    2642                 :            : {
    2643                 : 1474790000 :   return cselib_any_perm_equivs;
    2644                 :            : }
    2645                 :            : 
    2646                 :            : /* There is no good way to determine how many elements there can be
    2647                 :            :    in a PARALLEL.  Since it's fairly cheap, use a really large number.  */
    2648                 :            : #define MAX_SETS (FIRST_PSEUDO_REGISTER * 2)
    2649                 :            : 
    2650                 :            : struct cselib_record_autoinc_data
    2651                 :            : {
    2652                 :            :   struct cselib_set *sets;
    2653                 :            :   int n_sets;
    2654                 :            : };
    2655                 :            : 
    2656                 :            : /* Callback for for_each_inc_dec.  Records in ARG the SETs implied by
    2657                 :            :    autoinc RTXs: SRC plus SRCOFF if non-NULL is stored in DEST.  */
    2658                 :            : 
    2659                 :            : static int
    2660                 :   13275100 : cselib_record_autoinc_cb (rtx mem ATTRIBUTE_UNUSED, rtx op ATTRIBUTE_UNUSED,
    2661                 :            :                           rtx dest, rtx src, rtx srcoff, void *arg)
    2662                 :            : {
    2663                 :   13275100 :   struct cselib_record_autoinc_data *data;
    2664                 :   13275100 :   data = (struct cselib_record_autoinc_data *)arg;
    2665                 :            : 
    2666                 :   13275100 :   data->sets[data->n_sets].dest = dest;
    2667                 :            : 
    2668                 :   13275100 :   if (srcoff)
    2669                 :   12941300 :     data->sets[data->n_sets].src = gen_rtx_PLUS (GET_MODE (src), src, srcoff);
    2670                 :            :   else
    2671                 :     333877 :     data->sets[data->n_sets].src = src;
    2672                 :            : 
    2673                 :   13275100 :   data->n_sets++;
    2674                 :            : 
    2675                 :   13275100 :   return 0;
    2676                 :            : }
    2677                 :            : 
    2678                 :            : /* Record the effects of any sets and autoincs in INSN.  */
    2679                 :            : static void
    2680                 :  540178000 : cselib_record_sets (rtx_insn *insn)
    2681                 :            : {
    2682                 :  540178000 :   int n_sets = 0;
    2683                 :  540178000 :   int i;
    2684                 :  540178000 :   struct cselib_set sets[MAX_SETS];
    2685                 :  540178000 :   rtx cond = 0;
    2686                 :  540178000 :   int n_sets_before_autoinc;
    2687                 :  540178000 :   int n_strict_low_parts = 0;
    2688                 :  540178000 :   struct cselib_record_autoinc_data data;
    2689                 :            : 
    2690                 :  540178000 :   rtx body = PATTERN (insn);
    2691                 :  540178000 :   if (GET_CODE (body) == COND_EXEC)
    2692                 :            :     {
    2693                 :          0 :       cond = COND_EXEC_TEST (body);
    2694                 :          0 :       body = COND_EXEC_CODE (body);
    2695                 :            :     }
    2696                 :            : 
    2697                 :            :   /* Find all sets.  */
    2698                 :  540178000 :   if (GET_CODE (body) == SET)
    2699                 :            :     {
    2700                 :  236880000 :       sets[0].src = SET_SRC (body);
    2701                 :  236880000 :       sets[0].dest = SET_DEST (body);
    2702                 :  236880000 :       n_sets = 1;
    2703                 :            :     }
    2704                 :  303298000 :   else if (GET_CODE (body) == PARALLEL)
    2705                 :            :     {
    2706                 :            :       /* Look through the PARALLEL and record the values being
    2707                 :            :          set, if possible.  Also handle any CLOBBERs.  */
    2708                 :  139522000 :       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
    2709                 :            :         {
    2710                 :   94402000 :           rtx x = XVECEXP (body, 0, i);
    2711                 :            : 
    2712                 :   94402000 :           if (GET_CODE (x) == SET)
    2713                 :            :             {
    2714                 :   50582500 :               sets[n_sets].src = SET_SRC (x);
    2715                 :   50582500 :               sets[n_sets].dest = SET_DEST (x);
    2716                 :   50582500 :               n_sets++;
    2717                 :            :             }
    2718                 :            :         }
    2719                 :            :     }
    2720                 :            : 
    2721                 :  236880000 :   if (n_sets == 1
    2722                 :  276733000 :       && MEM_P (sets[0].src)
    2723                 :   40765300 :       && !cselib_record_memory
    2724                 :   71491600 :       && MEM_READONLY_P (sets[0].src))
    2725                 :            :     {
    2726                 :    2058070 :       rtx note = find_reg_equal_equiv_note (insn);
    2727                 :            : 
    2728                 :    2058070 :       if (note && CONSTANT_P (XEXP (note, 0)))
    2729                 :    1180450 :         sets[0].src = XEXP (note, 0);
    2730                 :            :     }
    2731                 :            : 
    2732                 :  540178000 :   data.sets = sets;
    2733                 :  540178000 :   data.n_sets = n_sets_before_autoinc = n_sets;
    2734                 :  540178000 :   for_each_inc_dec (PATTERN (insn), cselib_record_autoinc_cb, &data);
    2735                 :  540178000 :   n_sets = data.n_sets;
    2736                 :            : 
    2737                 :            :   /* Look up the values that are read.  Do this before invalidating the
    2738                 :            :      locations that are written.  */
    2739                 :  840915000 :   for (i = 0; i < n_sets; i++)
    2740                 :            :     {
    2741                 :  300738000 :       rtx dest = sets[i].dest;
    2742                 :  300738000 :       rtx orig = dest;
    2743                 :            : 
    2744                 :            :       /* A STRICT_LOW_PART can be ignored; we'll record the equivalence for
    2745                 :            :          the low part after invalidating any knowledge about larger modes.  */
    2746                 :  300738000 :       if (GET_CODE (sets[i].dest) == STRICT_LOW_PART)
    2747                 :      34569 :         sets[i].dest = dest = XEXP (dest, 0);
    2748                 :            : 
    2749                 :            :       /* We don't know how to record anything but REG or MEM.  */
    2750                 :  300738000 :       if (REG_P (dest)
    2751                 :   87383500 :           || (MEM_P (dest) && cselib_record_memory))
    2752                 :            :         {
    2753                 :  234833000 :           rtx src = sets[i].src;
    2754                 :  234833000 :           if (cond)
    2755                 :          0 :             src = gen_rtx_IF_THEN_ELSE (GET_MODE (dest), cond, src, dest);
    2756                 :  234833000 :           sets[i].src_elt = cselib_lookup (src, GET_MODE (dest), 1, VOIDmode);
    2757                 :  234833000 :           if (MEM_P (dest))
    2758                 :            :             {
    2759                 :   21479000 :               machine_mode address_mode = get_address_mode (dest);
    2760                 :            : 
    2761                 :   21479000 :               sets[i].dest_addr_elt = cselib_lookup (XEXP (dest, 0),
    2762                 :            :                                                      address_mode, 1,
    2763                 :   21479000 :                                                      GET_MODE (dest));
    2764                 :            :             }
    2765                 :            :           else
    2766                 :  213354000 :             sets[i].dest_addr_elt = 0;
    2767                 :            :         }
    2768                 :            : 
    2769                 :            :       /* Improve handling of STRICT_LOW_PART if the current value is known
    2770                 :            :          to be const0_rtx, then the low bits will be set to dest and higher
    2771                 :            :          bits will remain zero.  Used in code like:
    2772                 :            : 
    2773                 :            :          {di:SI=0;clobber flags:CC;}
    2774                 :            :          flags:CCNO=cmp(bx:SI,0)
    2775                 :            :          strict_low_part(di:QI)=flags:CCNO<=0
    2776                 :            : 
    2777                 :            :          where we can note both that di:QI=flags:CCNO<=0 and
    2778                 :            :          also that because di:SI is known to be 0 and strict_low_part(di:QI)
    2779                 :            :          preserves the upper bits that di:SI=zero_extend(flags:CCNO<=0).  */
    2780                 :  300738000 :       scalar_int_mode mode;
    2781                 :  300738000 :       if (dest != orig
    2782                 :      34569 :           && cselib_record_sets_hook
    2783                 :      12036 :           && REG_P (dest)
    2784                 :      12036 :           && HARD_REGISTER_P (dest)
    2785                 :      12036 :           && sets[i].src_elt
    2786                 :  300750000 :           && is_a <scalar_int_mode> (GET_MODE (dest), &mode)
    2787                 :  300750000 :           && n_sets + n_strict_low_parts < MAX_SETS)
    2788                 :            :         {
    2789                 :      12036 :           opt_scalar_int_mode wider_mode_iter;
    2790                 :      29792 :           FOR_EACH_WIDER_MODE (wider_mode_iter, mode)
    2791                 :            :             {
    2792                 :      29792 :               scalar_int_mode wider_mode = wider_mode_iter.require ();
    2793                 :      34747 :               if (GET_MODE_PRECISION (wider_mode) > BITS_PER_WORD)
    2794                 :            :                 break;
    2795                 :            : 
    2796                 :      28881 :               rtx reg = gen_lowpart (wider_mode, dest);
    2797                 :      28881 :               if (!REG_P (reg))
    2798                 :            :                 break;
    2799                 :            : 
    2800                 :      28879 :               cselib_val *v = cselib_lookup (reg, wider_mode, 0, VOIDmode);
    2801                 :      28879 :               if (!v)
    2802                 :      17756 :                 continue;
    2803                 :            : 
    2804                 :      11756 :               struct elt_loc_list *l;
    2805                 :      24962 :               for (l = v->locs; l; l = l->next)
    2806                 :      24329 :                 if (l->loc == const0_rtx)
    2807                 :            :                   break;
    2808                 :            : 
    2809                 :      11756 :               if (!l)
    2810                 :        633 :                 continue;
    2811                 :            : 
    2812                 :      11123 :               sets[n_sets + n_strict_low_parts].dest = reg;
    2813                 :      11123 :               sets[n_sets + n_strict_low_parts].src = dest;
    2814                 :      11123 :               sets[n_sets + n_strict_low_parts++].src_elt = sets[i].src_elt;
    2815                 :      11123 :               break;
    2816                 :            :             }
    2817                 :            :         }
    2818                 :            :     }
    2819                 :            : 
    2820                 :  540178000 :   if (cselib_record_sets_hook)
    2821                 :   50231500 :     cselib_record_sets_hook (insn, sets, n_sets);
    2822                 :            : 
    2823                 :            :   /* Invalidate all locations written by this insn.  Note that the elts we
    2824                 :            :      looked up in the previous loop aren't affected, just some of their
    2825                 :            :      locations may go away.  */
    2826                 :  540178000 :   note_pattern_stores (body, cselib_invalidate_rtx_note_stores, NULL);
    2827                 :            : 
    2828                 :  553453000 :   for (i = n_sets_before_autoinc; i < n_sets; i++)
    2829                 :   13275100 :     cselib_invalidate_rtx (sets[i].dest);
    2830                 :            : 
    2831                 :            :   /* If this is an asm, look for duplicate sets.  This can happen when the
    2832                 :            :      user uses the same value as an output multiple times.  This is valid
    2833                 :            :      if the outputs are not actually used thereafter.  Treat this case as
    2834                 :            :      if the value isn't actually set.  We do this by smashing the destination
    2835                 :            :      to pc_rtx, so that we won't record the value later.  */
    2836                 :  540178000 :   if (n_sets >= 2 && asm_noperands (body) >= 0)
    2837                 :            :     {
    2838                 :     626982 :       for (i = 0; i < n_sets; i++)
    2839                 :            :         {
    2840                 :     486634 :           rtx dest = sets[i].dest;
    2841                 :     486634 :           if (REG_P (dest) || MEM_P (dest))
    2842                 :            :             {
    2843                 :     486601 :               int j;
    2844                 :    1145010 :               for (j = i + 1; j < n_sets; j++)
    2845                 :     658407 :                 if (rtx_equal_p (dest, sets[j].dest))
    2846                 :            :                   {
    2847                 :          0 :                     sets[i].dest = pc_rtx;
    2848                 :          0 :                     sets[j].dest = pc_rtx;
    2849                 :            :                   }
    2850                 :            :             }
    2851                 :            :         }
    2852                 :            :     }
    2853                 :            : 
    2854                 :            :   /* Now enter the equivalences in our tables.  */
    2855                 :  840915000 :   for (i = 0; i < n_sets; i++)
    2856                 :            :     {
    2857                 :  300738000 :       rtx dest = sets[i].dest;
    2858                 :  300738000 :       if (REG_P (dest)
    2859                 :   87383500 :           || (MEM_P (dest) && cselib_record_memory))
    2860                 :  234833000 :         cselib_record_set (dest, sets[i].src_elt, sets[i].dest_addr_elt);
    2861                 :            :     }
    2862                 :            : 
    2863                 :            :   /* And deal with STRICT_LOW_PART.  */
    2864                 :  540189000 :   for (i = 0; i < n_strict_low_parts; i++)
    2865                 :            :     {
    2866                 :      11123 :       if (! PRESERVED_VALUE_P (sets[n_sets + i].src_elt->val_rtx))
    2867                 :          0 :         continue;
    2868                 :      11123 :       machine_mode dest_mode = GET_MODE (sets[n_sets + i].dest);
    2869                 :      11123 :       cselib_val *v
    2870                 :      11123 :         = cselib_lookup (sets[n_sets + i].dest, dest_mode, 1, VOIDmode);
    2871                 :      11123 :       cselib_preserve_value (v);
    2872                 :      11123 :       rtx r = gen_rtx_ZERO_EXTEND (dest_mode,
    2873                 :            :                                    sets[n_sets + i].src_elt->val_rtx);
    2874                 :      11123 :       cselib_add_permanent_equiv (v, r, insn);
    2875                 :            :     }
    2876                 :  540178000 : }
    2877                 :            : 
    2878                 :            : /* Return true if INSN in the prologue initializes hard_frame_pointer_rtx.  */
    2879                 :            : 
    2880                 :            : bool
    2881                 :   27933900 : fp_setter_insn (rtx_insn *insn)
    2882                 :            : {
    2883                 :   27933900 :   rtx expr, pat = NULL_RTX;
    2884                 :            : 
    2885                 :   27933900 :   if (!RTX_FRAME_RELATED_P (insn))
    2886                 :            :     return false;
    2887                 :            : 
    2888                 :     456232 :   expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
    2889                 :     456232 :   if (expr)
    2890                 :         19 :     pat = XEXP (expr, 0);
    2891                 :     456232 :   if (!modified_in_p (hard_frame_pointer_rtx, pat ? pat : insn))
    2892                 :            :     return false;
    2893                 :            : 
    2894                 :            :   /* Don't return true for frame pointer restores in the epilogue.  */
    2895                 :     103705 :   if (find_reg_note (insn, REG_CFA_RESTORE, hard_frame_pointer_rtx))
    2896                 :      29111 :     return false;
    2897                 :            :   return true;
    2898                 :            : }
    2899                 :            : 
    2900                 :            : /* V is one of the values in REG_VALUES (REGNO).  Return true if it
    2901                 :            :    would be invalidated by CALLEE_ABI.  */
    2902                 :            : 
    2903                 :            : static bool
    2904                 :   73130200 : cselib_invalidated_by_call_p (const function_abi &callee_abi,
    2905                 :            :                               unsigned int regno, cselib_val *v)
    2906                 :            : {
    2907                 :   73130200 :   machine_mode mode = GET_MODE (v->val_rtx);
    2908                 :   73130200 :   if (mode == VOIDmode)
    2909                 :            :     {
    2910                 :          0 :       v = REG_VALUES (regno)->elt;
    2911                 :          0 :       if (!v)
    2912                 :            :         /* If we don't know what the mode of the constant value is, and we
    2913                 :            :            don't know what mode the register was set in, conservatively
    2914                 :            :            assume that the register is clobbered.  The value's going to be
    2915                 :            :            essentially useless in this case anyway.  */
    2916                 :            :         return true;
    2917                 :          0 :       mode = GET_MODE (v->val_rtx);
    2918                 :            :     }
    2919                 :   73130200 :   return callee_abi.clobbers_reg_p (mode, regno);
    2920                 :            : }
    2921                 :            : 
    2922                 :            : /* Record the effects of INSN.  */
    2923                 :            : 
    2924                 :            : void
    2925                 :  627284000 : cselib_process_insn (rtx_insn *insn)
    2926                 :            : {
    2927                 :  627284000 :   int i;
    2928                 :  627284000 :   rtx x;
    2929                 :            : 
    2930                 :  627284000 :   cselib_current_insn = insn;
    2931                 :            : 
    2932                 :            :   /* Forget everything at a CODE_LABEL or a setjmp.  */
    2933                 :  627284000 :   if ((LABEL_P (insn)
    2934                 :  605095000 :        || (CALL_P (insn)
    2935                 :   23342200 :            && find_reg_note (insn, REG_SETJMP, NULL)))
    2936                 :  627287000 :       && !cselib_preserve_constants)
    2937                 :            :     {
    2938                 :   22192100 :       cselib_reset_table (next_uid);
    2939                 :   22192100 :       cselib_current_insn = NULL;
    2940                 :   22192100 :       return;
    2941                 :            :     }
    2942                 :            : 
    2943                 :  605092000 :   if (! INSN_P (insn))
    2944                 :            :     {
    2945                 :   64914500 :       cselib_current_insn = NULL;
    2946                 :   64914500 :       return;
    2947                 :            :     }
    2948                 :            : 
    2949                 :            :   /* If this is a call instruction, forget anything stored in a
    2950                 :            :      call clobbered register, or, if this is not a const call, in
    2951                 :            :      memory.  */
    2952                 :  540178000 :   if (CALL_P (insn))
    2953                 :            :     {
    2954                 :   23339600 :       function_abi callee_abi = insn_callee_abi (insn);
    2955                 : 1797150000 :       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    2956                 :            :         {
    2957                 : 1773810000 :           elt_list **l = &REG_VALUES (i);
    2958                 : 1914940000 :           while (*l)
    2959                 :            :             {
    2960                 :  141135000 :               cselib_val *v = (*l)->elt;
    2961                 :  141135000 :               if (v && cselib_invalidated_by_call_p (callee_abi, i, v))
    2962                 :   43061900 :                 cselib_invalidate_regno_val (i, l);
    2963                 :            :               else
    2964                 :   98073100 :                 l = &(*l)->next;
    2965                 :            :             }
    2966                 :            :         }
    2967                 :            : 
    2968                 :            :       /* Since it is not clear how cselib is going to be used, be
    2969                 :            :          conservative here and treat looping pure or const functions
    2970                 :            :          as if they were regular functions.  */
    2971                 :   23339600 :       if (RTL_LOOPING_CONST_OR_PURE_CALL_P (insn)
    2972                 :   23339600 :           || !(RTL_CONST_OR_PURE_CALL_P (insn)))
    2973                 :   22023500 :         cselib_invalidate_mem (callmem);
    2974                 :            :       else
    2975                 :            :         /* For const/pure calls, invalidate any argument slots because
    2976                 :            :            they are owned by the callee.  */
    2977                 :    3505790 :         for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
    2978                 :    2189680 :           if (GET_CODE (XEXP (x, 0)) == USE
    2979                 :    2189640 :               && MEM_P (XEXP (XEXP (x, 0), 0)))
    2980                 :      25356 :             cselib_invalidate_mem (XEXP (XEXP (x, 0), 0));
    2981                 :            :     }
    2982                 :            : 
    2983                 :  540178000 :   cselib_record_sets (insn);
    2984                 :            : 
    2985                 :            :   /* Look for any CLOBBERs in CALL_INSN_FUNCTION_USAGE, but only
    2986                 :            :      after we have processed the insn.  */
    2987                 :  540178000 :   if (CALL_P (insn))
    2988                 :            :     {
    2989                 :   60940700 :       for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
    2990                 :   37601200 :         if (GET_CODE (XEXP (x, 0)) == CLOBBER)
    2991                 :     600066 :           cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0));
    2992                 :            : 
    2993                 :            :       /* Flush everything on setjmp.  */
    2994                 :   23339600 :       if (cselib_preserve_constants
    2995                 :   23339600 :           && find_reg_note (insn, REG_SETJMP, NULL))
    2996                 :            :         {
    2997                 :        116 :           cselib_preserve_only_values ();
    2998                 :        116 :           cselib_reset_table (next_uid);
    2999                 :            :         }
    3000                 :            :     }
    3001                 :            : 
    3002                 :            :   /* On setter of the hard frame pointer if frame_pointer_needed,
    3003                 :            :      invalidate stack_pointer_rtx, so that sp and {,h}fp based
    3004                 :            :      VALUEs are distinct.  */
    3005                 :  540178000 :   if (reload_completed
    3006                 :  248565000 :       && frame_pointer_needed
    3007                 :  568061000 :       && fp_setter_insn (insn))
    3008                 :      66108 :     cselib_invalidate_rtx (stack_pointer_rtx);
    3009                 :            : 
    3010                 :  540178000 :   cselib_current_insn = NULL;
    3011                 :            : 
    3012                 :  540178000 :   if (n_useless_values > MAX_USELESS_VALUES
    3013                 :            :       /* remove_useless_values is linear in the hash table size.  Avoid
    3014                 :            :          quadratic behavior for very large hashtables with very few
    3015                 :            :          useless elements.  */
    3016                 :  540178000 :       && ((unsigned int)n_useless_values
    3017                 :    1642870 :           > (cselib_hash_table->elements () - n_debug_values) / 4))
    3018                 :      19894 :     remove_useless_values ();
    3019                 :            : }
    3020                 :            : 
    3021                 :            : /* Initialize cselib for one pass.  The caller must also call
    3022                 :            :    init_alias_analysis.  */
    3023                 :            : 
    3024                 :            : void
    3025                 :    6460860 : cselib_init (int record_what)
    3026                 :            : {
    3027                 :    6460860 :   cselib_record_memory = record_what & CSELIB_RECORD_MEMORY;
    3028                 :    6460860 :   cselib_preserve_constants = record_what & CSELIB_PRESERVE_CONSTANTS;
    3029                 :    6460860 :   cselib_any_perm_equivs = false;
    3030                 :            : 
    3031                 :            :   /* (mem:BLK (scratch)) is a special mechanism to conflict with everything,
    3032                 :            :      see canon_true_dependence.  This is only created once.  */
    3033                 :    6460860 :   if (! callmem)
    3034                 :     106270 :     callmem = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
    3035                 :            : 
    3036                 :    6460860 :   cselib_nregs = max_reg_num ();
    3037                 :            : 
    3038                 :            :   /* We preserve reg_values to allow expensive clearing of the whole thing.
    3039                 :            :      Reallocate it however if it happens to be too large.  */
    3040                 :    6460860 :   if (!reg_values || reg_values_size < cselib_nregs
    3041                 :    6240250 :       || (reg_values_size > 10 && reg_values_size > cselib_nregs * 4))
    3042                 :            :     {
    3043                 :     232739 :       free (reg_values);
    3044                 :            :       /* Some space for newly emit instructions so we don't end up
    3045                 :            :          reallocating in between passes.  */
    3046                 :     232739 :       reg_values_size = cselib_nregs + (63 + cselib_nregs) / 16;
    3047                 :     232739 :       reg_values = XCNEWVEC (struct elt_list *, reg_values_size);
    3048                 :            :     }
    3049                 :    6460860 :   used_regs = XNEWVEC (unsigned int, cselib_nregs);
    3050                 :    6460860 :   n_used_regs = 0;
    3051                 :            :   /* FIXME: enable sanitization (PR87845) */
    3052                 :    6460860 :   cselib_hash_table
    3053                 :    6460860 :     = new hash_table<cselib_hasher> (31, /* ggc */ false,
    3054                 :    6460860 :                                      /* sanitize_eq_and_hash */ false);
    3055                 :    6460860 :   if (cselib_preserve_constants)
    3056                 :     338880 :     cselib_preserved_hash_table
    3057                 :     338880 :       = new hash_table<cselib_hasher> (31, /* ggc */ false,
    3058                 :     338880 :                                        /* sanitize_eq_and_hash */ false);
    3059                 :    6460860 :   next_uid = 1;
    3060                 :    6460860 : }
    3061                 :            : 
    3062                 :            : /* Called when the current user is done with cselib.  */
    3063                 :            : 
    3064                 :            : void
    3065                 :    6460860 : cselib_finish (void)
    3066                 :            : {
    3067                 :    6460860 :   bool preserved = cselib_preserve_constants;
    3068                 :    6460860 :   cselib_discard_hook = NULL;
    3069                 :    6460860 :   cselib_preserve_constants = false;
    3070                 :    6460860 :   cselib_any_perm_equivs = false;
    3071                 :    6460860 :   cfa_base_preserved_val = NULL;
    3072                 :    6460860 :   cfa_base_preserved_regno = INVALID_REGNUM;
    3073                 :    6460860 :   elt_list_pool.release ();
    3074                 :    6460860 :   elt_loc_list_pool.release ();
    3075                 :    6460860 :   cselib_val_pool.release ();
    3076                 :    6460860 :   value_pool.release ();
    3077                 :    6460860 :   cselib_clear_table ();
    3078                 :    6460860 :   delete cselib_hash_table;
    3079                 :    6460860 :   cselib_hash_table = NULL;
    3080                 :    6460860 :   if (preserved)
    3081                 :     338880 :     delete cselib_preserved_hash_table;
    3082                 :    6460860 :   cselib_preserved_hash_table = NULL;
    3083                 :    6460860 :   free (used_regs);
    3084                 :    6460860 :   used_regs = 0;
    3085                 :    6460860 :   n_useless_values = 0;
    3086                 :    6460860 :   n_useless_debug_values = 0;
    3087                 :    6460860 :   n_debug_values = 0;
    3088                 :    6460860 :   next_uid = 0;
    3089                 :    6460860 : }
    3090                 :            : 
    3091                 :            : /* Dump the cselib_val *X to FILE *OUT.  */
    3092                 :            : 
    3093                 :            : int
    3094                 :        120 : dump_cselib_val (cselib_val **x, FILE *out)
    3095                 :            : {
    3096                 :        120 :   cselib_val *v = *x;
    3097                 :        120 :   bool need_lf = true;
    3098                 :            : 
    3099                 :        120 :   print_inline_rtx (out, v->val_rtx, 0);
    3100                 :            : 
    3101                 :        120 :   if (v->locs)
    3102                 :            :     {
    3103                 :        113 :       struct elt_loc_list *l = v->locs;
    3104                 :        113 :       if (need_lf)
    3105                 :            :         {
    3106                 :        113 :           fputc ('\n', out);
    3107                 :        113 :           need_lf = false;
    3108                 :            :         }
    3109                 :        113 :       fputs (" locs:", out);
    3110                 :        200 :       do
    3111                 :            :         {
    3112                 :        200 :           if (l->setting_insn)
    3113                 :        400 :             fprintf (out, "\n  from insn %i ",
    3114                 :        200 :                      INSN_UID (l->setting_insn));
    3115                 :            :           else
    3116                 :          0 :             fprintf (out, "\n   ");
    3117                 :        200 :           print_inline_rtx (out, l->loc, 4);
    3118                 :            :         }
    3119                 :        200 :       while ((l = l->next));
    3120                 :        113 :       fputc ('\n', out);
    3121                 :            :     }
    3122                 :            :   else
    3123                 :            :     {
    3124                 :          7 :       fputs (" no locs", out);
    3125                 :          7 :       need_lf = true;
    3126                 :            :     }
    3127                 :            : 
    3128                 :        120 :   if (v->addr_list)
    3129                 :            :     {
    3130                 :          7 :       struct elt_list *e = v->addr_list;
    3131                 :          7 :       if (need_lf)
    3132                 :            :         {
    3133                 :          0 :           fputc ('\n', out);
    3134                 :          0 :           need_lf = false;
    3135                 :            :         }
    3136                 :          7 :       fputs (" addr list:", out);
    3137                 :          7 :       do
    3138                 :            :         {
    3139                 :          7 :           fputs ("\n  ", out);
    3140                 :          7 :           print_inline_rtx (out, e->elt->val_rtx, 2);
    3141                 :            :         }
    3142                 :          7 :       while ((e = e->next));
    3143                 :          7 :       fputc ('\n', out);
    3144                 :            :     }
    3145                 :            :   else
    3146                 :            :     {
    3147                 :        113 :       fputs (" no addrs", out);
    3148                 :        113 :       need_lf = true;
    3149                 :            :     }
    3150                 :            : 
    3151                 :        120 :   if (v->next_containing_mem == &dummy_val)
    3152                 :          7 :     fputs (" last mem\n", out);
    3153                 :        113 :   else if (v->next_containing_mem)
    3154                 :            :     {
    3155                 :          0 :       fputs (" next mem ", out);
    3156                 :          0 :       print_inline_rtx (out, v->next_containing_mem->val_rtx, 2);
    3157                 :          0 :       fputc ('\n', out);
    3158                 :            :     }
    3159                 :        113 :   else if (need_lf)
    3160                 :        106 :     fputc ('\n', out);
    3161                 :            : 
    3162                 :        120 :   return 1;
    3163                 :            : }
    3164                 :            : 
    3165                 :            : /* Dump to OUT everything in the CSELIB table.  */
    3166                 :            : 
    3167                 :            : void
    3168                 :         12 : dump_cselib_table (FILE *out)
    3169                 :            : {
    3170                 :         12 :   fprintf (out, "cselib hash table:\n");
    3171                 :         12 :   cselib_hash_table->traverse <FILE *, dump_cselib_val> (out);
    3172                 :         12 :   fprintf (out, "cselib preserved hash table:\n");
    3173                 :         12 :   cselib_preserved_hash_table->traverse <FILE *, dump_cselib_val> (out);
    3174                 :         12 :   if (first_containing_mem != &dummy_val)
    3175                 :            :     {
    3176                 :          7 :       fputs ("first mem ", out);
    3177                 :          7 :       print_inline_rtx (out, first_containing_mem->val_rtx, 2);
    3178                 :          7 :       fputc ('\n', out);
    3179                 :            :     }
    3180                 :         12 :   fprintf (out, "next uid %i\n", next_uid);
    3181                 :         12 : }
    3182                 :            : 
    3183                 :            : #include "gt-cselib.h"

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.