LCOV - code coverage report
Current view: top level - gcc - tree-ssa-sccvn.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 3668 3835 95.6 %
Date: 2020-04-04 11:58:09 Functions: 107 113 94.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SCC value numbering for trees
       2                 :            :    Copyright (C) 2006-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Daniel Berlin <dan@dberlin.org>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "splay-tree.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "ssa.h"
      30                 :            : #include "expmed.h"
      31                 :            : #include "insn-config.h"
      32                 :            : #include "memmodel.h"
      33                 :            : #include "emit-rtl.h"
      34                 :            : #include "cgraph.h"
      35                 :            : #include "gimple-pretty-print.h"
      36                 :            : #include "alias.h"
      37                 :            : #include "fold-const.h"
      38                 :            : #include "stor-layout.h"
      39                 :            : #include "cfganal.h"
      40                 :            : #include "tree-inline.h"
      41                 :            : #include "internal-fn.h"
      42                 :            : #include "gimple-fold.h"
      43                 :            : #include "tree-eh.h"
      44                 :            : #include "gimplify.h"
      45                 :            : #include "flags.h"
      46                 :            : #include "dojump.h"
      47                 :            : #include "explow.h"
      48                 :            : #include "calls.h"
      49                 :            : #include "varasm.h"
      50                 :            : #include "stmt.h"
      51                 :            : #include "expr.h"
      52                 :            : #include "tree-dfa.h"
      53                 :            : #include "tree-ssa.h"
      54                 :            : #include "dumpfile.h"
      55                 :            : #include "cfgloop.h"
      56                 :            : #include "tree-ssa-propagate.h"
      57                 :            : #include "tree-cfg.h"
      58                 :            : #include "domwalk.h"
      59                 :            : #include "gimple-iterator.h"
      60                 :            : #include "gimple-match.h"
      61                 :            : #include "stringpool.h"
      62                 :            : #include "attribs.h"
      63                 :            : #include "tree-pass.h"
      64                 :            : #include "statistics.h"
      65                 :            : #include "langhooks.h"
      66                 :            : #include "ipa-utils.h"
      67                 :            : #include "dbgcnt.h"
      68                 :            : #include "tree-cfgcleanup.h"
      69                 :            : #include "tree-ssa-loop.h"
      70                 :            : #include "tree-scalar-evolution.h"
      71                 :            : #include "tree-ssa-loop-niter.h"
      72                 :            : #include "builtins.h"
      73                 :            : #include "tree-ssa-sccvn.h"
      74                 :            : 
      75                 :            : /* This algorithm is based on the SCC algorithm presented by Keith
      76                 :            :    Cooper and L. Taylor Simpson in "SCC-Based Value numbering"
      77                 :            :    (http://citeseer.ist.psu.edu/41805.html).  In
      78                 :            :    straight line code, it is equivalent to a regular hash based value
      79                 :            :    numbering that is performed in reverse postorder.
      80                 :            : 
      81                 :            :    For code with cycles, there are two alternatives, both of which
      82                 :            :    require keeping the hashtables separate from the actual list of
      83                 :            :    value numbers for SSA names.
      84                 :            : 
      85                 :            :    1. Iterate value numbering in an RPO walk of the blocks, removing
      86                 :            :    all the entries from the hashtable after each iteration (but
      87                 :            :    keeping the SSA name->value number mapping between iterations).
      88                 :            :    Iterate until it does not change.
      89                 :            : 
      90                 :            :    2. Perform value numbering as part of an SCC walk on the SSA graph,
      91                 :            :    iterating only the cycles in the SSA graph until they do not change
      92                 :            :    (using a separate, optimistic hashtable for value numbering the SCC
      93                 :            :    operands).
      94                 :            : 
      95                 :            :    The second is not just faster in practice (because most SSA graph
      96                 :            :    cycles do not involve all the variables in the graph), it also has
      97                 :            :    some nice properties.
      98                 :            : 
      99                 :            :    One of these nice properties is that when we pop an SCC off the
     100                 :            :    stack, we are guaranteed to have processed all the operands coming from
     101                 :            :    *outside of that SCC*, so we do not need to do anything special to
     102                 :            :    ensure they have value numbers.
     103                 :            : 
     104                 :            :    Another nice property is that the SCC walk is done as part of a DFS
     105                 :            :    of the SSA graph, which makes it easy to perform combining and
     106                 :            :    simplifying operations at the same time.
     107                 :            : 
     108                 :            :    The code below is deliberately written in a way that makes it easy
     109                 :            :    to separate the SCC walk from the other work it does.
     110                 :            : 
     111                 :            :    In order to propagate constants through the code, we track which
     112                 :            :    expressions contain constants, and use those while folding.  In
     113                 :            :    theory, we could also track expressions whose value numbers are
     114                 :            :    replaced, in case we end up folding based on expression
     115                 :            :    identities.
     116                 :            : 
     117                 :            :    In order to value number memory, we assign value numbers to vuses.
     118                 :            :    This enables us to note that, for example, stores to the same
     119                 :            :    address of the same value from the same starting memory states are
     120                 :            :    equivalent.
     121                 :            :    TODO:
     122                 :            : 
     123                 :            :    1. We can iterate only the changing portions of the SCC's, but
     124                 :            :    I have not seen an SCC big enough for this to be a win.
     125                 :            :    2. If you differentiate between phi nodes for loops and phi nodes
     126                 :            :    for if-then-else, you can properly consider phi nodes in different
     127                 :            :    blocks for equivalence.
     128                 :            :    3. We could value number vuses in more cases, particularly, whole
     129                 :            :    structure copies.
     130                 :            : */
     131                 :            : 
     132                 :            : /* There's no BB_EXECUTABLE but we can use BB_VISITED.  */
     133                 :            : #define BB_EXECUTABLE BB_VISITED
     134                 :            : 
     135                 :            : static vn_lookup_kind default_vn_walk_kind;
     136                 :            : 
     137                 :            : /* vn_nary_op hashtable helpers.  */
     138                 :            : 
     139                 :            : struct vn_nary_op_hasher : nofree_ptr_hash <vn_nary_op_s>
     140                 :            : {
     141                 :            :   typedef vn_nary_op_s *compare_type;
     142                 :            :   static inline hashval_t hash (const vn_nary_op_s *);
     143                 :            :   static inline bool equal (const vn_nary_op_s *, const vn_nary_op_s *);
     144                 :            : };
     145                 :            : 
     146                 :            : /* Return the computed hashcode for nary operation P1.  */
     147                 :            : 
     148                 :            : inline hashval_t
     149                 :  436513000 : vn_nary_op_hasher::hash (const vn_nary_op_s *vno1)
     150                 :            : {
     151                 :  436513000 :   return vno1->hashcode;
     152                 :            : }
     153                 :            : 
     154                 :            : /* Compare nary operations P1 and P2 and return true if they are
     155                 :            :    equivalent.  */
     156                 :            : 
     157                 :            : inline bool
     158                 :  555439000 : vn_nary_op_hasher::equal (const vn_nary_op_s *vno1, const vn_nary_op_s *vno2)
     159                 :            : {
     160                 :  555439000 :   return vno1 == vno2 || vn_nary_op_eq (vno1, vno2);
     161                 :            : }
     162                 :            : 
     163                 :            : typedef hash_table<vn_nary_op_hasher> vn_nary_op_table_type;
     164                 :            : typedef vn_nary_op_table_type::iterator vn_nary_op_iterator_type;
     165                 :            : 
     166                 :            : 
     167                 :            : /* vn_phi hashtable helpers.  */
     168                 :            : 
     169                 :            : static int
     170                 :            : vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2);
     171                 :            : 
     172                 :            : struct vn_phi_hasher : nofree_ptr_hash <vn_phi_s>
     173                 :            : { 
     174                 :            :   static inline hashval_t hash (const vn_phi_s *);
     175                 :            :   static inline bool equal (const vn_phi_s *, const vn_phi_s *);
     176                 :            : };
     177                 :            : 
     178                 :            : /* Return the computed hashcode for phi operation P1.  */
     179                 :            : 
     180                 :            : inline hashval_t
     181                 :   14312000 : vn_phi_hasher::hash (const vn_phi_s *vp1)
     182                 :            : {
     183                 :   14312000 :   return vp1->hashcode;
     184                 :            : }
     185                 :            : 
     186                 :            : /* Compare two phi entries for equality, ignoring VN_TOP arguments.  */
     187                 :            : 
     188                 :            : inline bool
     189                 :   89866400 : vn_phi_hasher::equal (const vn_phi_s *vp1, const vn_phi_s *vp2)
     190                 :            : {
     191                 :   89866400 :   return vp1 == vp2 || vn_phi_eq (vp1, vp2);
     192                 :            : }
     193                 :            : 
     194                 :            : typedef hash_table<vn_phi_hasher> vn_phi_table_type;
     195                 :            : typedef vn_phi_table_type::iterator vn_phi_iterator_type;
     196                 :            : 
     197                 :            : 
     198                 :            : /* Compare two reference operands P1 and P2 for equality.  Return true if
     199                 :            :    they are equal, and false otherwise.  */
     200                 :            : 
     201                 :            : static int
     202                 :   13142800 : vn_reference_op_eq (const void *p1, const void *p2)
     203                 :            : {
     204                 :   13142800 :   const_vn_reference_op_t const vro1 = (const_vn_reference_op_t) p1;
     205                 :   13142800 :   const_vn_reference_op_t const vro2 = (const_vn_reference_op_t) p2;
     206                 :            : 
     207                 :   13142800 :   return (vro1->opcode == vro2->opcode
     208                 :            :           /* We do not care for differences in type qualification.  */
     209                 :   13140300 :           && (vro1->type == vro2->type
     210                 :     502436 :               || (vro1->type && vro2->type
     211                 :     502436 :                   && types_compatible_p (TYPE_MAIN_VARIANT (vro1->type),
     212                 :     502436 :                                          TYPE_MAIN_VARIANT (vro2->type))))
     213                 :   12710700 :           && expressions_equal_p (vro1->op0, vro2->op0)
     214                 :   12699800 :           && expressions_equal_p (vro1->op1, vro2->op1)
     215                 :   25842600 :           && expressions_equal_p (vro1->op2, vro2->op2));
     216                 :            : }
     217                 :            : 
     218                 :            : /* Free a reference operation structure VP.  */
     219                 :            : 
     220                 :            : static inline void
     221                 :          0 : free_reference (vn_reference_s *vr)
     222                 :            : {
     223                 :          0 :   vr->operands.release ();
     224                 :            : }
     225                 :            : 
     226                 :            : 
     227                 :            : /* vn_reference hashtable helpers.  */
     228                 :            : 
     229                 :            : struct vn_reference_hasher : nofree_ptr_hash <vn_reference_s>
     230                 :            : {
     231                 :            :   static inline hashval_t hash (const vn_reference_s *);
     232                 :            :   static inline bool equal (const vn_reference_s *, const vn_reference_s *);
     233                 :            : };
     234                 :            : 
     235                 :            : /* Return the hashcode for a given reference operation P1.  */
     236                 :            : 
     237                 :            : inline hashval_t
     238                 : 2946260000 : vn_reference_hasher::hash (const vn_reference_s *vr1)
     239                 :            : {
     240                 : 2946260000 :   return vr1->hashcode;
     241                 :            : }
     242                 :            : 
     243                 :            : inline bool
     244                 : 3485870000 : vn_reference_hasher::equal (const vn_reference_s *v, const vn_reference_s *c)
     245                 :            : {
     246                 : 3485870000 :   return v == c || vn_reference_eq (v, c);
     247                 :            : }
     248                 :            : 
     249                 :            : typedef hash_table<vn_reference_hasher> vn_reference_table_type;
     250                 :            : typedef vn_reference_table_type::iterator vn_reference_iterator_type;
     251                 :            : 
     252                 :            : 
     253                 :            : /* The set of VN hashtables.  */
     254                 :            : 
     255                 :            : typedef struct vn_tables_s
     256                 :            : {
     257                 :            :   vn_nary_op_table_type *nary;
     258                 :            :   vn_phi_table_type *phis;
     259                 :            :   vn_reference_table_type *references;
     260                 :            : } *vn_tables_t;
     261                 :            : 
     262                 :            : 
     263                 :            : /* vn_constant hashtable helpers.  */
     264                 :            : 
     265                 :            : struct vn_constant_hasher : free_ptr_hash <vn_constant_s>
     266                 :            : { 
     267                 :            :   static inline hashval_t hash (const vn_constant_s *);
     268                 :            :   static inline bool equal (const vn_constant_s *, const vn_constant_s *);
     269                 :            : };
     270                 :            : 
     271                 :            : /* Hash table hash function for vn_constant_t.  */
     272                 :            : 
     273                 :            : inline hashval_t
     274                 :   28146300 : vn_constant_hasher::hash (const vn_constant_s *vc1)
     275                 :            : {
     276                 :   28146300 :   return vc1->hashcode;
     277                 :            : }
     278                 :            : 
     279                 :            : /* Hash table equality function for vn_constant_t.  */
     280                 :            : 
     281                 :            : inline bool
     282                 :   26617600 : vn_constant_hasher::equal (const vn_constant_s *vc1, const vn_constant_s *vc2)
     283                 :            : {
     284                 :   26617600 :   if (vc1->hashcode != vc2->hashcode)
     285                 :            :     return false;
     286                 :            : 
     287                 :    5996990 :   return vn_constant_eq_with_type (vc1->constant, vc2->constant);
     288                 :            : }
     289                 :            : 
     290                 :            : static hash_table<vn_constant_hasher> *constant_to_value_id;
     291                 :            : static bitmap constant_value_ids;
     292                 :            : 
     293                 :            : 
     294                 :            : /* Obstack we allocate the vn-tables elements from.  */
     295                 :            : static obstack vn_tables_obstack;
     296                 :            : /* Special obstack we never unwind.  */
     297                 :            : static obstack vn_tables_insert_obstack;
     298                 :            : 
     299                 :            : static vn_reference_t last_inserted_ref;
     300                 :            : static vn_phi_t last_inserted_phi;
     301                 :            : static vn_nary_op_t last_inserted_nary;
     302                 :            : 
     303                 :            : /* Valid hashtables storing information we have proven to be
     304                 :            :    correct.  */
     305                 :            : static vn_tables_t valid_info;
     306                 :            : 
     307                 :            : 
     308                 :            : /* Valueization hook.  Valueize NAME if it is an SSA name, otherwise
     309                 :            :    just return it.  */
     310                 :            : tree (*vn_valueize) (tree);
     311                 :       2843 : tree vn_valueize_wrapper (tree t, void* context ATTRIBUTE_UNUSED)
     312                 :            : {
     313                 :       2843 :   return vn_valueize (t);
     314                 :            : }
     315                 :            : 
     316                 :            : 
     317                 :            : /* This represents the top of the VN lattice, which is the universal
     318                 :            :    value.  */
     319                 :            : 
     320                 :            : tree VN_TOP;
     321                 :            : 
     322                 :            : /* Unique counter for our value ids.  */
     323                 :            : 
     324                 :            : static unsigned int next_value_id;
     325                 :            : 
     326                 :            : 
     327                 :            : /* Table of vn_ssa_aux_t's, one per ssa_name.  The vn_ssa_aux_t objects
     328                 :            :    are allocated on an obstack for locality reasons, and to free them
     329                 :            :    without looping over the vec.  */
     330                 :            : 
     331                 :            : struct vn_ssa_aux_hasher : typed_noop_remove <vn_ssa_aux_t>
     332                 :            : {
     333                 :            :   typedef vn_ssa_aux_t value_type;
     334                 :            :   typedef tree compare_type;
     335                 :            :   static inline hashval_t hash (const value_type &);
     336                 :            :   static inline bool equal (const value_type &, const compare_type &);
     337                 :            :   static inline void mark_deleted (value_type &) {}
     338                 :            :   static const bool empty_zero_p = true;
     339                 :            :   static inline void mark_empty (value_type &e) { e = NULL; }
     340                 :13617200000 :   static inline bool is_deleted (value_type &) { return false; }
     341                 :25240700000 :   static inline bool is_empty (value_type &e) { return e == NULL; }
     342                 :            : };
     343                 :            : 
     344                 :            : hashval_t
     345                 :            : vn_ssa_aux_hasher::hash (const value_type &entry)
     346                 :            : {
     347                 :            :   return SSA_NAME_VERSION (entry->name);
     348                 :            : }
     349                 :            : 
     350                 :            : bool
     351                 :15566200000 : vn_ssa_aux_hasher::equal (const value_type &entry, const compare_type &name)
     352                 :            : {
     353                 :15566200000 :   return name == entry->name;
     354                 :            : }
     355                 :            : 
     356                 :            : static hash_table<vn_ssa_aux_hasher> *vn_ssa_aux_hash;
     357                 :            : typedef hash_table<vn_ssa_aux_hasher>::iterator vn_ssa_aux_iterator_type;
     358                 :            : static struct obstack vn_ssa_aux_obstack;
     359                 :            : 
     360                 :            : static vn_nary_op_t vn_nary_op_insert_stmt (gimple *, tree);
     361                 :            : static unsigned int vn_nary_length_from_stmt (gimple *);
     362                 :            : static vn_nary_op_t alloc_vn_nary_op_noinit (unsigned int, obstack *);
     363                 :            : static vn_nary_op_t vn_nary_op_insert_into (vn_nary_op_t,
     364                 :            :                                             vn_nary_op_table_type *, bool);
     365                 :            : static void init_vn_nary_op_from_stmt (vn_nary_op_t, gimple *);
     366                 :            : static void init_vn_nary_op_from_pieces (vn_nary_op_t, unsigned int,
     367                 :            :                                          enum tree_code, tree, tree *);
     368                 :            : static tree vn_lookup_simplify_result (gimple_match_op *);
     369                 :            : static vn_reference_t vn_reference_lookup_or_insert_for_pieces
     370                 :            :           (tree, alias_set_type, alias_set_type, tree,
     371                 :            :            vec<vn_reference_op_s, va_heap>, tree);
     372                 :            : 
     373                 :            : /* Return whether there is value numbering information for a given SSA name.  */
     374                 :            : 
     375                 :            : bool
     376                 :    2868470 : has_VN_INFO (tree name)
     377                 :            : {
     378                 :    2868470 :   return vn_ssa_aux_hash->find_with_hash (name, SSA_NAME_VERSION (name));
     379                 :            : }
     380                 :            : 
     381                 :            : vn_ssa_aux_t
     382                 : 1837620000 : VN_INFO (tree name)
     383                 :            : {
     384                 : 1837620000 :   vn_ssa_aux_t *res
     385                 : 1837620000 :     = vn_ssa_aux_hash->find_slot_with_hash (name, SSA_NAME_VERSION (name),
     386                 :            :                                             INSERT);
     387                 : 1837620000 :   if (*res != NULL)
     388                 :            :     return *res;
     389                 :            : 
     390                 :  107649000 :   vn_ssa_aux_t newinfo = *res = XOBNEW (&vn_ssa_aux_obstack, struct vn_ssa_aux);
     391                 :  107649000 :   memset (newinfo, 0, sizeof (struct vn_ssa_aux));
     392                 :  107649000 :   newinfo->name = name;
     393                 :  107649000 :   newinfo->valnum = VN_TOP;
     394                 :            :   /* We are using the visited flag to handle uses with defs not within the
     395                 :            :      region being value-numbered.  */
     396                 :  107649000 :   newinfo->visited = false;
     397                 :            : 
     398                 :            :   /* Given we create the VN_INFOs on-demand now we have to do initialization
     399                 :            :      different than VN_TOP here.  */
     400                 :  107649000 :   if (SSA_NAME_IS_DEFAULT_DEF (name))
     401                 :   11251400 :     switch (TREE_CODE (SSA_NAME_VAR (name)))
     402                 :            :       {
     403                 :    1080910 :       case VAR_DECL:
     404                 :            :         /* All undefined vars are VARYING.  */
     405                 :    1080910 :         newinfo->valnum = name;
     406                 :    1080910 :         newinfo->visited = true;
     407                 :    1080910 :         break;
     408                 :            : 
     409                 :    4508880 :       case PARM_DECL:
     410                 :            :         /* Parameters are VARYING but we can record a condition
     411                 :            :            if we know it is a non-NULL pointer.  */
     412                 :    4508880 :         newinfo->visited = true;
     413                 :    4508880 :         newinfo->valnum = name;
     414                 :    6869750 :         if (POINTER_TYPE_P (TREE_TYPE (name))
     415                 :    8059010 :             && nonnull_arg_p (SSA_NAME_VAR (name)))
     416                 :            :           {
     417                 :    1489670 :             tree ops[2];
     418                 :    1489670 :             ops[0] = name;
     419                 :    1489670 :             ops[1] = build_int_cst (TREE_TYPE (name), 0);
     420                 :    1489670 :             vn_nary_op_t nary;
     421                 :            :             /* Allocate from non-unwinding stack.  */
     422                 :    1489670 :             nary = alloc_vn_nary_op_noinit (2, &vn_tables_insert_obstack);
     423                 :    1489670 :             init_vn_nary_op_from_pieces (nary, 2, NE_EXPR,
     424                 :            :                                          boolean_type_node, ops);
     425                 :    1489670 :             nary->predicated_values = 0;
     426                 :    1489670 :             nary->u.result = boolean_true_node;
     427                 :    1489670 :             vn_nary_op_insert_into (nary, valid_info->nary, true);
     428                 :    1489670 :             gcc_assert (nary->unwind_to == NULL);
     429                 :            :             /* Also do not link it into the undo chain.  */
     430                 :    1489670 :             last_inserted_nary = nary->next;
     431                 :    1489670 :             nary->next = (vn_nary_op_t)(void *)-1;
     432                 :    1489670 :             nary = alloc_vn_nary_op_noinit (2, &vn_tables_insert_obstack);
     433                 :    1489670 :             init_vn_nary_op_from_pieces (nary, 2, EQ_EXPR,
     434                 :            :                                          boolean_type_node, ops);
     435                 :    1489670 :             nary->predicated_values = 0;
     436                 :    1489670 :             nary->u.result = boolean_false_node;
     437                 :    1489670 :             vn_nary_op_insert_into (nary, valid_info->nary, true);
     438                 :    1489670 :             gcc_assert (nary->unwind_to == NULL);
     439                 :    1489670 :             last_inserted_nary = nary->next;
     440                 :    1489670 :             nary->next = (vn_nary_op_t)(void *)-1;
     441                 :    1489670 :             if (dump_file && (dump_flags & TDF_DETAILS))
     442                 :            :               {
     443                 :         27 :                 fprintf (dump_file, "Recording ");
     444                 :         27 :                 print_generic_expr (dump_file, name, TDF_SLIM);
     445                 :         27 :                 fprintf (dump_file, " != 0\n");
     446                 :            :               }
     447                 :            :           }
     448                 :            :         break;
     449                 :            : 
     450                 :      35887 :       case RESULT_DECL:
     451                 :            :         /* If the result is passed by invisible reference the default
     452                 :            :            def is initialized, otherwise it's uninitialized.  Still
     453                 :            :            undefined is varying.  */
     454                 :      35887 :         newinfo->visited = true;
     455                 :      35887 :         newinfo->valnum = name;
     456                 :      35887 :         break;
     457                 :            : 
     458                 :          0 :       default:
     459                 :          0 :         gcc_unreachable ();
     460                 :            :       }
     461                 :            :   return newinfo;
     462                 :            : }
     463                 :            : 
     464                 :            : /* Return the SSA value of X.  */
     465                 :            : 
     466                 :            : inline tree
     467                 : 2241790000 : SSA_VAL (tree x, bool *visited = NULL)
     468                 :            : {
     469                 : 2241790000 :   vn_ssa_aux_t tem = vn_ssa_aux_hash->find_with_hash (x, SSA_NAME_VERSION (x));
     470                 : 2241790000 :   if (visited)
     471                 :  918759000 :     *visited = tem && tem->visited;
     472                 : 2241790000 :   return tem && tem->visited ? tem->valnum : x;
     473                 :            : }
     474                 :            : 
     475                 :            : /* Return the SSA value of the VUSE x, supporting released VDEFs
     476                 :            :    during elimination which will value-number the VDEF to the
     477                 :            :    associated VUSE (but not substitute in the whole lattice).  */
     478                 :            : 
     479                 :            : static inline tree
     480                 :  897491000 : vuse_ssa_val (tree x)
     481                 :            : {
     482                 :  897491000 :   if (!x)
     483                 :            :     return NULL_TREE;
     484                 :            : 
     485                 :  894439000 :   do
     486                 :            :     {
     487                 :  894439000 :       x = SSA_VAL (x);
     488                 :  894439000 :       gcc_assert (x != VN_TOP);
     489                 :            :     }
     490                 :  894439000 :   while (SSA_NAME_IN_FREE_LIST (x));
     491                 :            : 
     492                 :            :   return x;
     493                 :            : }
     494                 :            : 
     495                 :            : /* Similar to the above but used as callback for walk_non_aliases_vuses
     496                 :            :    and thus should stop at unvisited VUSE to not walk across region
     497                 :            :    boundaries.  */
     498                 :            : 
     499                 :            : static tree
     500                 :  772885000 : vuse_valueize (tree vuse)
     501                 :            : {
     502                 :  772885000 :   do
     503                 :            :     {
     504                 :  772885000 :       bool visited;
     505                 :  772885000 :       vuse = SSA_VAL (vuse, &visited);
     506                 :  772885000 :       if (!visited)
     507                 :    8705430 :         return NULL_TREE;
     508                 :  764180000 :       gcc_assert (vuse != VN_TOP);
     509                 :            :     }
     510                 :  764180000 :   while (SSA_NAME_IN_FREE_LIST (vuse));
     511                 :            :   return vuse;
     512                 :            : }
     513                 :            : 
     514                 :            : 
     515                 :            : /* Return the vn_kind the expression computed by the stmt should be
     516                 :            :    associated with.  */
     517                 :            : 
     518                 :            : enum vn_kind
     519                 :   62186000 : vn_get_stmt_kind (gimple *stmt)
     520                 :            : {
     521                 :   62186000 :   switch (gimple_code (stmt))
     522                 :            :     {
     523                 :            :     case GIMPLE_CALL:
     524                 :            :       return VN_REFERENCE;
     525                 :          0 :     case GIMPLE_PHI:
     526                 :          0 :       return VN_PHI;
     527                 :   62186000 :     case GIMPLE_ASSIGN:
     528                 :   62186000 :       {
     529                 :   62186000 :         enum tree_code code = gimple_assign_rhs_code (stmt);
     530                 :   62186000 :         tree rhs1 = gimple_assign_rhs1 (stmt);
     531                 :   62186000 :         switch (get_gimple_rhs_class (code))
     532                 :            :           {
     533                 :            :           case GIMPLE_UNARY_RHS:
     534                 :            :           case GIMPLE_BINARY_RHS:
     535                 :            :           case GIMPLE_TERNARY_RHS:
     536                 :            :             return VN_NARY;
     537                 :   29740200 :           case GIMPLE_SINGLE_RHS:
     538                 :   29740200 :             switch (TREE_CODE_CLASS (code))
     539                 :            :               {
     540                 :   22042000 :               case tcc_reference:
     541                 :            :                 /* VOP-less references can go through unary case.  */
     542                 :   22042000 :                 if ((code == REALPART_EXPR
     543                 :            :                      || code == IMAGPART_EXPR
     544                 :   22042000 :                      || code == VIEW_CONVERT_EXPR
     545                 :   22042000 :                      || code == BIT_FIELD_REF)
     546                 :   22042000 :                     && TREE_CODE (TREE_OPERAND (rhs1, 0)) == SSA_NAME)
     547                 :    1259060 :                   return VN_NARY;
     548                 :            : 
     549                 :            :                 /* Fallthrough.  */
     550                 :            :               case tcc_declaration:
     551                 :            :                 return VN_REFERENCE;
     552                 :            : 
     553                 :            :               case tcc_constant:
     554                 :            :                 return VN_CONSTANT;
     555                 :            : 
     556                 :    4048610 :               default:
     557                 :    4048610 :                 if (code == ADDR_EXPR)
     558                 :    2327720 :                   return (is_gimple_min_invariant (rhs1)
     559                 :    2327720 :                           ? VN_CONSTANT : VN_REFERENCE);
     560                 :    1720890 :                 else if (code == CONSTRUCTOR)
     561                 :      91387 :                   return VN_NARY;
     562                 :            :                 return VN_NONE;
     563                 :            :               }
     564                 :          0 :           default:
     565                 :          0 :             return VN_NONE;
     566                 :            :           }
     567                 :            :       }
     568                 :          0 :     default:
     569                 :          0 :       return VN_NONE;
     570                 :            :     }
     571                 :            : }
     572                 :            : 
     573                 :            : /* Lookup a value id for CONSTANT and return it.  If it does not
     574                 :            :    exist returns 0.  */
     575                 :            : 
     576                 :            : unsigned int
     577                 :    4495620 : get_constant_value_id (tree constant)
     578                 :            : {
     579                 :    4495620 :   vn_constant_s **slot;
     580                 :    4495620 :   struct vn_constant_s vc;
     581                 :            : 
     582                 :    4495620 :   vc.hashcode = vn_hash_constant_with_type (constant);
     583                 :    4495620 :   vc.constant = constant;
     584                 :    4495620 :   slot = constant_to_value_id->find_slot (&vc, NO_INSERT);
     585                 :    4495620 :   if (slot)
     586                 :    4495620 :     return (*slot)->value_id;
     587                 :            :   return 0;
     588                 :            : }
     589                 :            : 
     590                 :            : /* Lookup a value id for CONSTANT, and if it does not exist, create a
     591                 :            :    new one and return it.  If it does exist, return it.  */
     592                 :            : 
     593                 :            : unsigned int
     594                 :   19725200 : get_or_alloc_constant_value_id (tree constant)
     595                 :            : {
     596                 :   19725200 :   vn_constant_s **slot;
     597                 :   19725200 :   struct vn_constant_s vc;
     598                 :   19725200 :   vn_constant_t vcp;
     599                 :            : 
     600                 :            :   /* If the hashtable isn't initialized we're not running from PRE and thus
     601                 :            :      do not need value-ids.  */
     602                 :   19725200 :   if (!constant_to_value_id)
     603                 :            :     return 0;
     604                 :            : 
     605                 :    3274910 :   vc.hashcode = vn_hash_constant_with_type (constant);
     606                 :    3274910 :   vc.constant = constant;
     607                 :    3274910 :   slot = constant_to_value_id->find_slot (&vc, INSERT);
     608                 :    3274910 :   if (*slot)
     609                 :    1458430 :     return (*slot)->value_id;
     610                 :            : 
     611                 :    1816480 :   vcp = XNEW (struct vn_constant_s);
     612                 :    1816480 :   vcp->hashcode = vc.hashcode;
     613                 :    1816480 :   vcp->constant = constant;
     614                 :    1816480 :   vcp->value_id = get_next_value_id ();
     615                 :    1816480 :   *slot = vcp;
     616                 :    1816480 :   bitmap_set_bit (constant_value_ids, vcp->value_id);
     617                 :    1816480 :   return vcp->value_id;
     618                 :            : }
     619                 :            : 
     620                 :            : /* Return true if V is a value id for a constant.  */
     621                 :            : 
     622                 :            : bool
     623                 :  352698000 : value_id_constant_p (unsigned int v)
     624                 :            : {
     625                 :  352698000 :   return bitmap_bit_p (constant_value_ids, v);
     626                 :            : }
     627                 :            : 
     628                 :            : /* Compute the hash for a reference operand VRO1.  */
     629                 :            : 
     630                 :            : static void
     631                 :   79768100 : vn_reference_op_compute_hash (const vn_reference_op_t vro1, inchash::hash &hstate)
     632                 :            : {
     633                 :   79768100 :   hstate.add_int (vro1->opcode);
     634                 :   79768100 :   if (vro1->op0)
     635                 :   75133300 :     inchash::add_expr (vro1->op0, hstate);
     636                 :   79768100 :   if (vro1->op1)
     637                 :    6419200 :     inchash::add_expr (vro1->op1, hstate);
     638                 :   79768100 :   if (vro1->op2)
     639                 :    7731610 :     inchash::add_expr (vro1->op2, hstate);
     640                 :   79768100 : }
     641                 :            : 
     642                 :            : /* Compute a hash for the reference operation VR1 and return it.  */
     643                 :            : 
     644                 :            : static hashval_t
     645                 :  123899000 : vn_reference_compute_hash (const vn_reference_t vr1)
     646                 :            : {
     647                 :  123899000 :   inchash::hash hstate;
     648                 :  123899000 :   hashval_t result;
     649                 :  123899000 :   int i;
     650                 :  123899000 :   vn_reference_op_t vro;
     651                 :  123899000 :   poly_int64 off = -1;
     652                 :  123899000 :   bool deref = false;
     653                 :            : 
     654                 :  516558000 :   FOR_EACH_VEC_ELT (vr1->operands, i, vro)
     655                 :            :     {
     656                 :  392659000 :       if (vro->opcode == MEM_REF)
     657                 :            :         deref = true;
     658                 :  274453000 :       else if (vro->opcode != ADDR_EXPR)
     659                 :  191168000 :         deref = false;
     660                 :  392659000 :       if (maybe_ne (vro->off, -1))
     661                 :            :         {
     662                 :  235651000 :           if (known_eq (off, -1))
     663                 :  119465000 :             off = 0;
     664                 :  392659000 :           off += vro->off;
     665                 :            :         }
     666                 :            :       else
     667                 :            :         {
     668                 :  157007000 :           if (maybe_ne (off, -1)
     669                 :  157007000 :               && maybe_ne (off, 0))
     670                 :   65782400 :             hstate.add_poly_int (off);
     671                 :  157007000 :           off = -1;
     672                 :  157007000 :           if (deref
     673                 :   77313100 :               && vro->opcode == ADDR_EXPR)
     674                 :            :             {
     675                 :   77239400 :               if (vro->op0)
     676                 :            :                 {
     677                 :   77239400 :                   tree op = TREE_OPERAND (vro->op0, 0);
     678                 :   77239400 :                   hstate.add_int (TREE_CODE (op));
     679                 :   77239400 :                   inchash::add_expr (op, hstate);
     680                 :            :                 }
     681                 :            :             }
     682                 :            :           else
     683                 :   79768100 :             vn_reference_op_compute_hash (vro, hstate);
     684                 :            :         }
     685                 :            :     }
     686                 :  123899000 :   result = hstate.end ();
     687                 :            :   /* ??? We would ICE later if we hash instead of adding that in. */
     688                 :  123899000 :   if (vr1->vuse)
     689                 :  120076000 :     result += SSA_NAME_VERSION (vr1->vuse);
     690                 :            : 
     691                 :  123899000 :   return result;
     692                 :            : }
     693                 :            : 
     694                 :            : /* Return true if reference operations VR1 and VR2 are equivalent.  This
     695                 :            :    means they have the same set of operands and vuses.  */
     696                 :            : 
     697                 :            : bool
     698                 : 3511570000 : vn_reference_eq (const_vn_reference_t const vr1, const_vn_reference_t const vr2)
     699                 :            : {
     700                 : 3511570000 :   unsigned i, j;
     701                 :            : 
     702                 :            :   /* Early out if this is not a hash collision.  */
     703                 : 3511570000 :   if (vr1->hashcode != vr2->hashcode)
     704                 :            :     return false;
     705                 :            : 
     706                 :            :   /* The VOP needs to be the same.  */
     707                 :   28488400 :   if (vr1->vuse != vr2->vuse)
     708                 :            :     return false;
     709                 :            : 
     710                 :            :   /* If the operands are the same we are done.  */
     711                 :   56976000 :   if (vr1->operands == vr2->operands)
     712                 :            :     return true;
     713                 :            : 
     714                 :    9035970 :   if (!expressions_equal_p (TYPE_SIZE (vr1->type), TYPE_SIZE (vr2->type)))
     715                 :            :     return false;
     716                 :            : 
     717                 :    8670230 :   if (INTEGRAL_TYPE_P (vr1->type)
     718                 :    4369600 :       && INTEGRAL_TYPE_P (vr2->type))
     719                 :            :     {
     720                 :    4364000 :       if (TYPE_PRECISION (vr1->type) != TYPE_PRECISION (vr2->type))
     721                 :            :         return false;
     722                 :            :     }
     723                 :    4306230 :   else if (INTEGRAL_TYPE_P (vr1->type)
     724                 :    4306230 :            && (TYPE_PRECISION (vr1->type)
     725                 :       5605 :                != TREE_INT_CST_LOW (TYPE_SIZE (vr1->type))))
     726                 :            :     return false;
     727                 :    4306100 :   else if (INTEGRAL_TYPE_P (vr2->type)
     728                 :    4306100 :            && (TYPE_PRECISION (vr2->type)
     729                 :       2629 :                != TREE_INT_CST_LOW (TYPE_SIZE (vr2->type))))
     730                 :            :     return false;
     731                 :            : 
     732                 :            :   i = 0;
     733                 :            :   j = 0;
     734                 :   10661200 :   do
     735                 :            :     {
     736                 :   10661200 :       poly_int64 off1 = 0, off2 = 0;
     737                 :   10661200 :       vn_reference_op_t vro1, vro2;
     738                 :   10661200 :       vn_reference_op_s tem1, tem2;
     739                 :   10661200 :       bool deref1 = false, deref2 = false;
     740                 :   36986100 :       for (; vr1->operands.iterate (i, &vro1); i++)
     741                 :            :         {
     742                 :   26324900 :           if (vro1->opcode == MEM_REF)
     743                 :            :             deref1 = true;
     744                 :            :           /* Do not look through a storage order barrier.  */
     745                 :   18085200 :           else if (vro1->opcode == VIEW_CONVERT_EXPR && vro1->reverse)
     746                 :       3497 :             return false;
     747                 :   26324900 :           if (known_eq (vro1->off, -1))
     748                 :            :             break;
     749                 :   15663700 :           off1 += vro1->off;
     750                 :            :         }
     751                 :   26305800 :       for (; vr2->operands.iterate (j, &vro2); j++)
     752                 :            :         {
     753                 :   26305800 :           if (vro2->opcode == MEM_REF)
     754                 :            :             deref2 = true;
     755                 :            :           /* Do not look through a storage order barrier.  */
     756                 :   18066100 :           else if (vro2->opcode == VIEW_CONVERT_EXPR && vro2->reverse)
     757                 :            :             return false;
     758                 :   26305800 :           if (known_eq (vro2->off, -1))
     759                 :            :             break;
     760                 :   15644600 :           off2 += vro2->off;
     761                 :            :         }
     762                 :   10661200 :       if (maybe_ne (off1, off2))
     763                 :            :         return false;
     764                 :   10661100 :       if (deref1 && vro1->opcode == ADDR_EXPR)
     765                 :            :         {
     766                 :    4291310 :           memset (&tem1, 0, sizeof (tem1));
     767                 :    4291310 :           tem1.op0 = TREE_OPERAND (vro1->op0, 0);
     768                 :    4291310 :           tem1.type = TREE_TYPE (tem1.op0);
     769                 :    4291310 :           tem1.opcode = TREE_CODE (tem1.op0);
     770                 :    4291310 :           vro1 = &tem1;
     771                 :    4291310 :           deref1 = false;
     772                 :            :         }
     773                 :   10661100 :       if (deref2 && vro2->opcode == ADDR_EXPR)
     774                 :            :         {
     775                 :    4291310 :           memset (&tem2, 0, sizeof (tem2));
     776                 :    4291310 :           tem2.op0 = TREE_OPERAND (vro2->op0, 0);
     777                 :    4291310 :           tem2.type = TREE_TYPE (tem2.op0);
     778                 :    4291310 :           tem2.opcode = TREE_CODE (tem2.op0);
     779                 :    4291310 :           vro2 = &tem2;
     780                 :    4291310 :           deref2 = false;
     781                 :            :         }
     782                 :   10661100 :       if (deref1 != deref2)
     783                 :            :         return false;
     784                 :   10661100 :       if (!vn_reference_op_eq (vro1, vro2))
     785                 :            :         return false;
     786                 :   10657700 :       ++j;
     787                 :   10657700 :       ++i;
     788                 :            :     }
     789                 :   10657700 :   while (vr1->operands.length () != i
     790                 :   29943900 :          || vr2->operands.length () != j);
     791                 :            : 
     792                 :            :   return true;
     793                 :            : }
     794                 :            : 
     795                 :            : /* Copy the operations present in load/store REF into RESULT, a vector of
     796                 :            :    vn_reference_op_s's.  */
     797                 :            : 
     798                 :            : static void
     799                 :  130867000 : copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
     800                 :            : {
     801                 :            :   /* For non-calls, store the information that makes up the address.  */
     802                 :  130867000 :   tree orig = ref;
     803                 :  458487000 :   while (ref)
     804                 :            :     {
     805                 :  327620000 :       vn_reference_op_s temp;
     806                 :            : 
     807                 :  327620000 :       memset (&temp, 0, sizeof (temp));
     808                 :  327620000 :       temp.type = TREE_TYPE (ref);
     809                 :  327620000 :       temp.opcode = TREE_CODE (ref);
     810                 :  327620000 :       temp.off = -1;
     811                 :            : 
     812                 :  327620000 :       switch (temp.opcode)
     813                 :            :         {
     814                 :   10655100 :         case MODIFY_EXPR:
     815                 :   10655100 :           temp.op0 = TREE_OPERAND (ref, 1);
     816                 :   10655100 :           break;
     817                 :        136 :         case WITH_SIZE_EXPR:
     818                 :        136 :           temp.op0 = TREE_OPERAND (ref, 1);
     819                 :        136 :           temp.off = 0;
     820                 :        136 :           break;
     821                 :   61170800 :         case MEM_REF:
     822                 :            :           /* The base address gets its own vn_reference_op_s structure.  */
     823                 :   61170800 :           temp.op0 = TREE_OPERAND (ref, 1);
     824                 :  122342000 :           if (!mem_ref_offset (ref).to_shwi (&temp.off))
     825                 :          0 :             temp.off = -1;
     826                 :   61170800 :           temp.clique = MR_DEPENDENCE_CLIQUE (ref);
     827                 :   61170800 :           temp.base = MR_DEPENDENCE_BASE (ref);
     828                 :   61170800 :           temp.reverse = REF_REVERSE_STORAGE_ORDER (ref);
     829                 :   61170800 :           break;
     830                 :    1243280 :         case TARGET_MEM_REF:
     831                 :            :           /* The base address gets its own vn_reference_op_s structure.  */
     832                 :    1243280 :           temp.op0 = TMR_INDEX (ref);
     833                 :    1243280 :           temp.op1 = TMR_STEP (ref);
     834                 :    1243280 :           temp.op2 = TMR_OFFSET (ref);
     835                 :    1243280 :           temp.clique = MR_DEPENDENCE_CLIQUE (ref);
     836                 :    1243280 :           temp.base = MR_DEPENDENCE_BASE (ref);
     837                 :    1243280 :           result->safe_push (temp);
     838                 :    1243280 :           memset (&temp, 0, sizeof (temp));
     839                 :    1243280 :           temp.type = NULL_TREE;
     840                 :    1243280 :           temp.opcode = ERROR_MARK;
     841                 :    1243280 :           temp.op0 = TMR_INDEX2 (ref);
     842                 :    1243280 :           temp.off = -1;
     843                 :    1243280 :           break;
     844                 :     349959 :         case BIT_FIELD_REF:
     845                 :            :           /* Record bits, position and storage order.  */
     846                 :     349959 :           temp.op0 = TREE_OPERAND (ref, 1);
     847                 :     349959 :           temp.op1 = TREE_OPERAND (ref, 2);
     848                 :     349959 :           if (!multiple_p (bit_field_offset (ref), BITS_PER_UNIT, &temp.off))
     849                 :     349959 :             temp.off = -1;
     850                 :     349959 :           temp.reverse = REF_REVERSE_STORAGE_ORDER (ref);
     851                 :     349959 :           break;
     852                 :   95983900 :         case COMPONENT_REF:
     853                 :            :           /* The field decl is enough to unambiguously specify the field,
     854                 :            :              a matching type is not necessary and a mismatching type
     855                 :            :              is always a spurious difference.  */
     856                 :   95983900 :           temp.type = NULL_TREE;
     857                 :   95983900 :           temp.op0 = TREE_OPERAND (ref, 1);
     858                 :   95983900 :           temp.op1 = TREE_OPERAND (ref, 2);
     859                 :   95983900 :           {
     860                 :   95983900 :             tree this_offset = component_ref_field_offset (ref);
     861                 :   95983900 :             if (this_offset
     862                 :   95983900 :                 && poly_int_tree_p (this_offset))
     863                 :            :               {
     864                 :   95981500 :                 tree bit_offset = DECL_FIELD_BIT_OFFSET (TREE_OPERAND (ref, 1));
     865                 :   95981500 :                 if (TREE_INT_CST_LOW (bit_offset) % BITS_PER_UNIT == 0)
     866                 :            :                   {
     867                 :   95790000 :                     poly_offset_int off
     868                 :   95790000 :                       = (wi::to_poly_offset (this_offset)
     869                 :   95790000 :                          + (wi::to_offset (bit_offset) >> LOG2_BITS_PER_UNIT));
     870                 :            :                     /* Probibit value-numbering zero offset components
     871                 :            :                        of addresses the same before the pass folding
     872                 :            :                        __builtin_object_size had a chance to run
     873                 :            :                        (checking cfun->after_inlining does the
     874                 :            :                        trick here).  */
     875                 :   95790000 :                     if (TREE_CODE (orig) != ADDR_EXPR
     876                 :    3247380 :                         || maybe_ne (off, 0)
     877                 :   97764100 :                         || cfun->after_inlining)
     878                 :   95790000 :                       off.to_shwi (&temp.off);
     879                 :            :                   }
     880                 :            :               }
     881                 :            :           }
     882                 :            :           break;
     883                 :   22729000 :         case ARRAY_RANGE_REF:
     884                 :   22729000 :         case ARRAY_REF:
     885                 :   22729000 :           {
     886                 :   22729000 :             tree eltype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (ref, 0)));
     887                 :            :             /* Record index as operand.  */
     888                 :   22729000 :             temp.op0 = TREE_OPERAND (ref, 1);
     889                 :            :             /* Always record lower bounds and element size.  */
     890                 :   22729000 :             temp.op1 = array_ref_low_bound (ref);
     891                 :            :             /* But record element size in units of the type alignment.  */
     892                 :   22729000 :             temp.op2 = TREE_OPERAND (ref, 3);
     893                 :   22729000 :             temp.align = eltype->type_common.align;
     894                 :   22729000 :             if (! temp.op2)
     895                 :   22571500 :               temp.op2 = size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (eltype),
     896                 :            :                                      size_int (TYPE_ALIGN_UNIT (eltype)));
     897                 :   22729000 :             if (poly_int_tree_p (temp.op0)
     898                 :   14587700 :                 && poly_int_tree_p (temp.op1)
     899                 :   37316800 :                 && TREE_CODE (temp.op2) == INTEGER_CST)
     900                 :            :               {
     901                 :   29083200 :                 poly_offset_int off = ((wi::to_poly_offset (temp.op0)
     902                 :   29083200 :                                         - wi::to_poly_offset (temp.op1))
     903                 :   29083200 :                                        * wi::to_offset (temp.op2)
     904                 :   14541600 :                                        * vn_ref_op_align_unit (&temp));
     905                 :   29082200 :                 off.to_shwi (&temp.off);
     906                 :            :               }
     907                 :            :           }
     908                 :            :           break;
     909                 :   56227300 :         case VAR_DECL:
     910                 :   56227300 :           if (DECL_HARD_REGISTER (ref))
     911                 :            :             {
     912                 :      13915 :               temp.op0 = ref;
     913                 :      13915 :               break;
     914                 :            :             }
     915                 :            :           /* Fallthru.  */
     916                 :   59541800 :         case PARM_DECL:
     917                 :   59541800 :         case CONST_DECL:
     918                 :   59541800 :         case RESULT_DECL:
     919                 :            :           /* Canonicalize decls to MEM[&decl] which is what we end up with
     920                 :            :              when valueizing MEM[ptr] with ptr = &decl.  */
     921                 :   59541800 :           temp.opcode = MEM_REF;
     922                 :   59541800 :           temp.op0 = build_int_cst (build_pointer_type (TREE_TYPE (ref)), 0);
     923                 :   59541800 :           temp.off = 0;
     924                 :   59541800 :           result->safe_push (temp);
     925                 :   59541800 :           temp.opcode = ADDR_EXPR;
     926                 :   59541800 :           temp.op0 = build1 (ADDR_EXPR, TREE_TYPE (temp.op0), ref);
     927                 :   59541800 :           temp.type = TREE_TYPE (temp.op0);
     928                 :   59541800 :           temp.off = -1;
     929                 :   59541800 :           break;
     930                 :   50123900 :         case STRING_CST:
     931                 :   50123900 :         case INTEGER_CST:
     932                 :   50123900 :         case POLY_INT_CST:
     933                 :   50123900 :         case COMPLEX_CST:
     934                 :   50123900 :         case VECTOR_CST:
     935                 :   50123900 :         case REAL_CST:
     936                 :   50123900 :         case FIXED_CST:
     937                 :   50123900 :         case CONSTRUCTOR:
     938                 :   50123900 :         case SSA_NAME:
     939                 :   50123900 :           temp.op0 = ref;
     940                 :   50123900 :           break;
     941                 :   24122700 :         case ADDR_EXPR:
     942                 :   24122700 :           if (is_gimple_min_invariant (ref))
     943                 :            :             {
     944                 :   21187000 :               temp.op0 = ref;
     945                 :   21187000 :               break;
     946                 :            :             }
     947                 :            :           break;
     948                 :            :           /* These are only interesting for their operands, their
     949                 :            :              existence, and their type.  They will never be the last
     950                 :            :              ref in the chain of references (IE they require an
     951                 :            :              operand), so we don't have to put anything
     952                 :            :              for op* as it will be handled by the iteration  */
     953                 :     311981 :         case REALPART_EXPR:
     954                 :     311981 :           temp.off = 0;
     955                 :     311981 :           break;
     956                 :    1052870 :         case VIEW_CONVERT_EXPR:
     957                 :    1052870 :           temp.off = 0;
     958                 :    1052870 :           temp.reverse = storage_order_barrier_p (ref);
     959                 :    1052870 :           break;
     960                 :     321178 :         case IMAGPART_EXPR:
     961                 :            :           /* This is only interesting for its constant offset.  */
     962                 :     321178 :           temp.off = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (ref)));
     963                 :     321178 :           break;
     964                 :          0 :         default:
     965                 :          0 :           gcc_unreachable ();
     966                 :            :         }
     967                 :  327620000 :       result->safe_push (temp);
     968                 :            : 
     969                 :  327620000 :       if (REFERENCE_CLASS_P (ref)
     970                 :  144458000 :           || TREE_CODE (ref) == MODIFY_EXPR
     971                 :  133802000 :           || TREE_CODE (ref) == WITH_SIZE_EXPR
     972                 :  461423000 :           || (TREE_CODE (ref) == ADDR_EXPR
     973                 :   24122700 :               && !is_gimple_min_invariant (ref)))
     974                 :  196754000 :         ref = TREE_OPERAND (ref, 0);
     975                 :            :       else
     976                 :            :         ref = NULL_TREE;
     977                 :            :     }
     978                 :  130867000 : }
     979                 :            : 
     980                 :            : /* Build a alias-oracle reference abstraction in *REF from the vn_reference
     981                 :            :    operands in *OPS, the reference alias set SET and the reference type TYPE.
     982                 :            :    Return true if something useful was produced.  */
     983                 :            : 
     984                 :            : bool
     985                 :    9678200 : ao_ref_init_from_vn_reference (ao_ref *ref,
     986                 :            :                                alias_set_type set, alias_set_type base_set,
     987                 :            :                                tree type, vec<vn_reference_op_s> ops)
     988                 :            : {
     989                 :    9678200 :   vn_reference_op_t op;
     990                 :    9678200 :   unsigned i;
     991                 :    9678200 :   tree base = NULL_TREE;
     992                 :    9678200 :   tree *op0_p = &base;
     993                 :    9678200 :   poly_offset_int offset = 0;
     994                 :    9678200 :   poly_offset_int max_size;
     995                 :    9678200 :   poly_offset_int size = -1;
     996                 :    9678200 :   tree size_tree = NULL_TREE;
     997                 :            : 
     998                 :            :   /* First get the final access size from just the outermost expression.  */
     999                 :    9678200 :   op = &ops[0];
    1000                 :    9678200 :   if (op->opcode == COMPONENT_REF)
    1001                 :    3795030 :     size_tree = DECL_SIZE (op->op0);
    1002                 :    5883170 :   else if (op->opcode == BIT_FIELD_REF)
    1003                 :      24072 :     size_tree = op->op0;
    1004                 :            :   else
    1005                 :            :     {
    1006                 :    5859100 :       machine_mode mode = TYPE_MODE (type);
    1007                 :    5859100 :       if (mode == BLKmode)
    1008                 :     173137 :         size_tree = TYPE_SIZE (type);
    1009                 :            :       else
    1010                 :   11371900 :         size = GET_MODE_BITSIZE (mode);
    1011                 :            :     }
    1012                 :    5685960 :   if (size_tree != NULL_TREE
    1013                 :    3992240 :       && poly_int_tree_p (size_tree))
    1014                 :    3992240 :     size = wi::to_poly_offset (size_tree);
    1015                 :            : 
    1016                 :            :   /* Initially, maxsize is the same as the accessed element size.
    1017                 :            :      In the following it will only grow (or become -1).  */
    1018                 :    9678200 :   max_size = size;
    1019                 :            : 
    1020                 :            :   /* Compute cumulative bit-offset for nested component-refs and array-refs,
    1021                 :            :      and find the ultimate containing object.  */
    1022                 :   38233900 :   FOR_EACH_VEC_ELT (ops, i, op)
    1023                 :            :     {
    1024                 :   28849700 :       switch (op->opcode)
    1025                 :            :         {
    1026                 :            :         /* These may be in the reference ops, but we cannot do anything
    1027                 :            :            sensible with them here.  */
    1028                 :    4902970 :         case ADDR_EXPR:
    1029                 :            :           /* Apart from ADDR_EXPR arguments to MEM_REF.  */
    1030                 :    4902970 :           if (base != NULL_TREE
    1031                 :    4902970 :               && TREE_CODE (base) == MEM_REF
    1032                 :    4902970 :               && op->op0
    1033                 :    9805930 :               && DECL_P (TREE_OPERAND (op->op0, 0)))
    1034                 :            :             {
    1035                 :    4899350 :               vn_reference_op_t pop = &ops[i-1];
    1036                 :    4899350 :               base = TREE_OPERAND (op->op0, 0);
    1037                 :    4899350 :               if (known_eq (pop->off, -1))
    1038                 :            :                 {
    1039                 :         22 :                   max_size = -1;
    1040                 :         22 :                   offset = 0;
    1041                 :            :                 }
    1042                 :            :               else
    1043                 :    4899330 :                 offset += pop->off * BITS_PER_UNIT;
    1044                 :            :               op0_p = NULL;
    1045                 :            :               break;
    1046                 :            :             }
    1047                 :            :           /* Fallthru.  */
    1048                 :            :         case CALL_EXPR:
    1049                 :            :           return false;
    1050                 :            : 
    1051                 :            :         /* Record the base objects.  */
    1052                 :    9389150 :         case MEM_REF:
    1053                 :    9389150 :           *op0_p = build2 (MEM_REF, op->type,
    1054                 :            :                            NULL_TREE, op->op0);
    1055                 :    9389150 :           MR_DEPENDENCE_CLIQUE (*op0_p) = op->clique;
    1056                 :    9389150 :           MR_DEPENDENCE_BASE (*op0_p) = op->base;
    1057                 :    9389150 :           op0_p = &TREE_OPERAND (*op0_p, 0);
    1058                 :    9389150 :           break;
    1059                 :            : 
    1060                 :    4484870 :         case VAR_DECL:
    1061                 :    4484870 :         case PARM_DECL:
    1062                 :    4484870 :         case RESULT_DECL:
    1063                 :    4484870 :         case SSA_NAME:
    1064                 :    4484870 :           *op0_p = op->op0;
    1065                 :    4484870 :           op0_p = NULL;
    1066                 :    4484870 :           break;
    1067                 :            : 
    1068                 :            :         /* And now the usual component-reference style ops.  */
    1069                 :      24072 :         case BIT_FIELD_REF:
    1070                 :      24072 :           offset += wi::to_poly_offset (op->op1);
    1071                 :      24072 :           break;
    1072                 :            : 
    1073                 :    6482340 :         case COMPONENT_REF:
    1074                 :    6482340 :           {
    1075                 :    6482340 :             tree field = op->op0;
    1076                 :            :             /* We do not have a complete COMPONENT_REF tree here so we
    1077                 :            :                cannot use component_ref_field_offset.  Do the interesting
    1078                 :            :                parts manually.  */
    1079                 :    6482340 :             tree this_offset = DECL_FIELD_OFFSET (field);
    1080                 :            : 
    1081                 :    6482340 :             if (op->op1 || !poly_int_tree_p (this_offset))
    1082                 :   28555700 :               max_size = -1;
    1083                 :            :             else
    1084                 :            :               {
    1085                 :    6481890 :                 poly_offset_int woffset = (wi::to_poly_offset (this_offset)
    1086                 :    6481890 :                                            << LOG2_BITS_PER_UNIT);
    1087                 :    6481890 :                 woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
    1088                 :    6481890 :                 offset += woffset;
    1089                 :            :               }
    1090                 :            :             break;
    1091                 :            :           }
    1092                 :            : 
    1093                 :    2259100 :         case ARRAY_RANGE_REF:
    1094                 :    2259100 :         case ARRAY_REF:
    1095                 :            :           /* We recorded the lower bound and the element size.  */
    1096                 :    2259100 :           if (!poly_int_tree_p (op->op0)
    1097                 :    1426200 :               || !poly_int_tree_p (op->op1)
    1098                 :    3685300 :               || TREE_CODE (op->op2) != INTEGER_CST)
    1099                 :   28555700 :             max_size = -1;
    1100                 :            :           else
    1101                 :            :             {
    1102                 :    1361500 :               poly_offset_int woffset
    1103                 :    1361500 :                 = wi::sext (wi::to_poly_offset (op->op0)
    1104                 :    2723000 :                             - wi::to_poly_offset (op->op1),
    1105                 :    1361500 :                             TYPE_PRECISION (TREE_TYPE (op->op0)));
    1106                 :    2723000 :               woffset *= wi::to_offset (op->op2) * vn_ref_op_align_unit (op);
    1107                 :    1361500 :               woffset <<= LOG2_BITS_PER_UNIT;
    1108                 :    1361500 :               offset += woffset;
    1109                 :            :             }
    1110                 :            :           break;
    1111                 :            : 
    1112                 :            :         case REALPART_EXPR:
    1113                 :            :           break;
    1114                 :            : 
    1115                 :      45006 :         case IMAGPART_EXPR:
    1116                 :      45006 :           offset += size;
    1117                 :      45006 :           break;
    1118                 :            : 
    1119                 :            :         case VIEW_CONVERT_EXPR:
    1120                 :            :           break;
    1121                 :            : 
    1122                 :            :         case STRING_CST:
    1123                 :            :         case INTEGER_CST:
    1124                 :            :         case COMPLEX_CST:
    1125                 :            :         case VECTOR_CST:
    1126                 :            :         case REAL_CST:
    1127                 :            :         case CONSTRUCTOR:
    1128                 :            :         case CONST_DECL:
    1129                 :            :           return false;
    1130                 :            : 
    1131                 :            :         default:
    1132                 :            :           return false;
    1133                 :            :         }
    1134                 :            :     }
    1135                 :            : 
    1136                 :    9384220 :   if (base == NULL_TREE)
    1137                 :            :     return false;
    1138                 :            : 
    1139                 :    9384220 :   ref->ref = NULL_TREE;
    1140                 :    9384220 :   ref->base = base;
    1141                 :    9384220 :   ref->ref_alias_set = set;
    1142                 :    9384220 :   ref->base_alias_set = base_set;
    1143                 :            :   /* We discount volatiles from value-numbering elsewhere.  */
    1144                 :    9384220 :   ref->volatile_p = false;
    1145                 :            : 
    1146                 :   18768400 :   if (!size.to_shwi (&ref->size) || maybe_lt (ref->size, 0))
    1147                 :            :     {
    1148                 :          0 :       ref->offset = 0;
    1149                 :          0 :       ref->size = -1;
    1150                 :          0 :       ref->max_size = -1;
    1151                 :          0 :       return true;
    1152                 :            :     }
    1153                 :            : 
    1154                 :   18768400 :   if (!offset.to_shwi (&ref->offset))
    1155                 :            :     {
    1156                 :         74 :       ref->offset = 0;
    1157                 :         74 :       ref->max_size = -1;
    1158                 :         74 :       return true;
    1159                 :            :     }
    1160                 :            : 
    1161                 :   18768300 :   if (!max_size.to_shwi (&ref->max_size) || maybe_lt (ref->max_size, 0))
    1162                 :     735758 :     ref->max_size = -1;
    1163                 :            : 
    1164                 :            :   return true;
    1165                 :            : }
    1166                 :            : 
    1167                 :            : /* Copy the operations present in load/store/call REF into RESULT, a vector of
    1168                 :            :    vn_reference_op_s's.  */
    1169                 :            : 
    1170                 :            : static void
    1171                 :    5005980 : copy_reference_ops_from_call (gcall *call,
    1172                 :            :                               vec<vn_reference_op_s> *result)
    1173                 :            : {
    1174                 :    5005980 :   vn_reference_op_s temp;
    1175                 :    5005980 :   unsigned i;
    1176                 :    5005980 :   tree lhs = gimple_call_lhs (call);
    1177                 :    5005980 :   int lr;
    1178                 :            : 
    1179                 :            :   /* If 2 calls have a different non-ssa lhs, vdef value numbers should be
    1180                 :            :      different.  By adding the lhs here in the vector, we ensure that the
    1181                 :            :      hashcode is different, guaranteeing a different value number.  */
    1182                 :    5005980 :   if (lhs && TREE_CODE (lhs) != SSA_NAME)
    1183                 :            :     {
    1184                 :     316844 :       memset (&temp, 0, sizeof (temp));
    1185                 :     316844 :       temp.opcode = MODIFY_EXPR;
    1186                 :     316844 :       temp.type = TREE_TYPE (lhs);
    1187                 :     316844 :       temp.op0 = lhs;
    1188                 :     316844 :       temp.off = -1;
    1189                 :     316844 :       result->safe_push (temp);
    1190                 :            :     }
    1191                 :            : 
    1192                 :            :   /* Copy the type, opcode, function, static chain and EH region, if any.  */
    1193                 :    5005980 :   memset (&temp, 0, sizeof (temp));
    1194                 :    5005980 :   temp.type = gimple_call_fntype (call);
    1195                 :    5005980 :   temp.opcode = CALL_EXPR;
    1196                 :    5005980 :   temp.op0 = gimple_call_fn (call);
    1197                 :    5005980 :   temp.op1 = gimple_call_chain (call);
    1198                 :    5005980 :   if (stmt_could_throw_p (cfun, call) && (lr = lookup_stmt_eh_lp (call)) > 0)
    1199                 :     532133 :     temp.op2 = size_int (lr);
    1200                 :    5005980 :   temp.off = -1;
    1201                 :    5005980 :   result->safe_push (temp);
    1202                 :            : 
    1203                 :            :   /* Copy the call arguments.  As they can be references as well,
    1204                 :            :      just chain them together.  */
    1205                 :   14438300 :   for (i = 0; i < gimple_call_num_args (call); ++i)
    1206                 :            :     {
    1207                 :    9432310 :       tree callarg = gimple_call_arg (call, i);
    1208                 :    9432310 :       copy_reference_ops_from_ref (callarg, result);
    1209                 :            :     }
    1210                 :    5005980 : }
    1211                 :            : 
    1212                 :            : /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS.  Updates
    1213                 :            :    *I_P to point to the last element of the replacement.  */
    1214                 :            : static bool
    1215                 :   82597400 : vn_reference_fold_indirect (vec<vn_reference_op_s> *ops,
    1216                 :            :                             unsigned int *i_p)
    1217                 :            : {
    1218                 :   82597400 :   unsigned int i = *i_p;
    1219                 :   82597400 :   vn_reference_op_t op = &(*ops)[i];
    1220                 :   82597400 :   vn_reference_op_t mem_op = &(*ops)[i - 1];
    1221                 :   82597400 :   tree addr_base;
    1222                 :   82597400 :   poly_int64 addr_offset = 0;
    1223                 :            : 
    1224                 :            :   /* The only thing we have to do is from &OBJ.foo.bar add the offset
    1225                 :            :      from .foo.bar to the preceding MEM_REF offset and replace the
    1226                 :            :      address with &OBJ.  */
    1227                 :   82597400 :   addr_base = get_addr_base_and_unit_offset (TREE_OPERAND (op->op0, 0),
    1228                 :            :                                              &addr_offset);
    1229                 :   82597400 :   gcc_checking_assert (addr_base && TREE_CODE (addr_base) != MEM_REF);
    1230                 :   82597400 :   if (addr_base != TREE_OPERAND (op->op0, 0))
    1231                 :            :     {
    1232                 :     239686 :       poly_offset_int off
    1233                 :     239686 :         = (poly_offset_int::from (wi::to_poly_wide (mem_op->op0),
    1234                 :     239686 :                                   SIGNED)
    1235                 :     239686 :            + addr_offset);
    1236                 :     239686 :       mem_op->op0 = wide_int_to_tree (TREE_TYPE (mem_op->op0), off);
    1237                 :     239686 :       op->op0 = build_fold_addr_expr (addr_base);
    1238                 :     239686 :       if (tree_fits_shwi_p (mem_op->op0))
    1239                 :     239655 :         mem_op->off = tree_to_shwi (mem_op->op0);
    1240                 :            :       else
    1241                 :         31 :         mem_op->off = -1;
    1242                 :     239686 :       return true;
    1243                 :            :     }
    1244                 :            :   return false;
    1245                 :            : }
    1246                 :            : 
    1247                 :            : /* Fold *& at position *I_P in a vn_reference_op_s vector *OPS.  Updates
    1248                 :            :    *I_P to point to the last element of the replacement.  */
    1249                 :            : static bool
    1250                 :   45745300 : vn_reference_maybe_forwprop_address (vec<vn_reference_op_s> *ops,
    1251                 :            :                                      unsigned int *i_p)
    1252                 :            : {
    1253                 :   45745300 :   bool changed = false;
    1254                 :   52549700 :   vn_reference_op_t op;
    1255                 :            : 
    1256                 :   52549700 :   do
    1257                 :            :     {
    1258                 :   52549700 :       unsigned int i = *i_p;
    1259                 :   52549700 :       op = &(*ops)[i];
    1260                 :   52549700 :       vn_reference_op_t mem_op = &(*ops)[i - 1];
    1261                 :   52549700 :       gimple *def_stmt;
    1262                 :   52549700 :       enum tree_code code;
    1263                 :   52549700 :       poly_offset_int off;
    1264                 :            : 
    1265                 :   52549700 :       def_stmt = SSA_NAME_DEF_STMT (op->op0);
    1266                 :   52549700 :       if (!is_gimple_assign (def_stmt))
    1267                 :   45745000 :         return changed;
    1268                 :            : 
    1269                 :   22257100 :       code = gimple_assign_rhs_code (def_stmt);
    1270                 :   22257100 :       if (code != ADDR_EXPR
    1271                 :   22257100 :           && code != POINTER_PLUS_EXPR)
    1272                 :    9102070 :         return changed;
    1273                 :            : 
    1274                 :   13155000 :       off = poly_offset_int::from (wi::to_poly_wide (mem_op->op0), SIGNED);
    1275                 :            : 
    1276                 :            :       /* The only thing we have to do is from &OBJ.foo.bar add the offset
    1277                 :            :          from .foo.bar to the preceding MEM_REF offset and replace the
    1278                 :            :          address with &OBJ.  */
    1279                 :   13155000 :       if (code == ADDR_EXPR)
    1280                 :            :         {
    1281                 :     345850 :           tree addr, addr_base;
    1282                 :     345850 :           poly_int64 addr_offset;
    1283                 :            : 
    1284                 :     345850 :           addr = gimple_assign_rhs1 (def_stmt);
    1285                 :     345850 :           addr_base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0),
    1286                 :            :                                                      &addr_offset);
    1287                 :            :           /* If that didn't work because the address isn't invariant propagate
    1288                 :            :              the reference tree from the address operation in case the current
    1289                 :            :              dereference isn't offsetted.  */
    1290                 :     345850 :           if (!addr_base
    1291                 :      90386 :               && *i_p == ops->length () - 1
    1292                 :      45193 :               && known_eq (off, 0)
    1293                 :            :               /* This makes us disable this transform for PRE where the
    1294                 :            :                  reference ops might be also used for code insertion which
    1295                 :            :                  is invalid.  */
    1296                 :     376267 :               && default_vn_walk_kind == VN_WALKREWRITE)
    1297                 :            :             {
    1298                 :      60834 :               auto_vec<vn_reference_op_s, 32> tem;
    1299                 :      30417 :               copy_reference_ops_from_ref (TREE_OPERAND (addr, 0), &tem);
    1300                 :            :               /* Make sure to preserve TBAA info.  The only objects not
    1301                 :            :                  wrapped in MEM_REFs that can have their address taken are
    1302                 :            :                  STRING_CSTs.  */
    1303                 :      30417 :               if (tem.length () >= 2
    1304                 :      30417 :                   && tem[tem.length () - 2].opcode == MEM_REF)
    1305                 :            :                 {
    1306                 :      30407 :                   vn_reference_op_t new_mem_op = &tem[tem.length () - 2];
    1307                 :      30407 :                   new_mem_op->op0
    1308                 :      30407 :                       = wide_int_to_tree (TREE_TYPE (mem_op->op0),
    1309                 :      60814 :                                           wi::to_poly_wide (new_mem_op->op0));
    1310                 :            :                 }
    1311                 :            :               else
    1312                 :         10 :                 gcc_assert (tem.last ().opcode == STRING_CST);
    1313                 :      30417 :               ops->pop ();
    1314                 :      30417 :               ops->pop ();
    1315                 :      30417 :               ops->safe_splice (tem);
    1316                 :      30417 :               --*i_p;
    1317                 :      30417 :               return true;
    1318                 :            :             }
    1319                 :     315433 :           if (!addr_base
    1320                 :     300657 :               || TREE_CODE (addr_base) != MEM_REF
    1321                 :     615864 :               || (TREE_CODE (TREE_OPERAND (addr_base, 0)) == SSA_NAME
    1322                 :     300407 :                   && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (addr_base,
    1323                 :            :                                                                     0))))
    1324                 :      15002 :             return changed;
    1325                 :            : 
    1326                 :     300431 :           off += addr_offset;
    1327                 :     300431 :           off += mem_ref_offset (addr_base);
    1328                 :     300431 :           op->op0 = TREE_OPERAND (addr_base, 0);
    1329                 :            :         }
    1330                 :            :       else
    1331                 :            :         {
    1332                 :   12809200 :           tree ptr, ptroff;
    1333                 :   12809200 :           ptr = gimple_assign_rhs1 (def_stmt);
    1334                 :   12809200 :           ptroff = gimple_assign_rhs2 (def_stmt);
    1335                 :   12809200 :           if (TREE_CODE (ptr) != SSA_NAME
    1336                 :   12497800 :               || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ptr)
    1337                 :            :               /* Make sure to not endlessly recurse.
    1338                 :            :                  See gcc.dg/tree-ssa/20040408-1.c for an example.  Can easily
    1339                 :            :                  happen when we value-number a PHI to its backedge value.  */
    1340                 :   12496200 :               || SSA_VAL (ptr) == op->op0
    1341                 :   25305400 :               || !poly_int_tree_p (ptroff))
    1342                 :    6304940 :             return changed;
    1343                 :            : 
    1344                 :    6504250 :           off += wi::to_poly_offset (ptroff);
    1345                 :    6504250 :           op->op0 = ptr;
    1346                 :            :         }
    1347                 :            : 
    1348                 :    6804680 :       mem_op->op0 = wide_int_to_tree (TREE_TYPE (mem_op->op0), off);
    1349                 :    6804680 :       if (tree_fits_shwi_p (mem_op->op0))
    1350                 :    6736540 :         mem_op->off = tree_to_shwi (mem_op->op0);
    1351                 :            :       else
    1352                 :      68135 :         mem_op->off = -1;
    1353                 :            :       /* ???  Can end up with endless recursion here!?
    1354                 :            :          gcc.c-torture/execute/strcmp-1.c  */
    1355                 :    6804680 :       if (TREE_CODE (op->op0) == SSA_NAME)
    1356                 :    6804650 :         op->op0 = SSA_VAL (op->op0);
    1357                 :    6804680 :       if (TREE_CODE (op->op0) != SSA_NAME)
    1358                 :        212 :         op->opcode = TREE_CODE (op->op0);
    1359                 :            : 
    1360                 :    6804680 :       changed = true;
    1361                 :            :     }
    1362                 :            :   /* Tail-recurse.  */
    1363                 :    6804680 :   while (TREE_CODE (op->op0) == SSA_NAME);
    1364                 :            : 
    1365                 :            :   /* Fold a remaining *&.  */
    1366                 :        212 :   if (TREE_CODE (op->op0) == ADDR_EXPR)
    1367                 :        188 :     vn_reference_fold_indirect (ops, i_p);
    1368                 :            : 
    1369                 :            :   return changed;
    1370                 :            : }
    1371                 :            : 
    1372                 :            : /* Optimize the reference REF to a constant if possible or return
    1373                 :            :    NULL_TREE if not.  */
    1374                 :            : 
    1375                 :            : tree
    1376                 :   72241200 : fully_constant_vn_reference_p (vn_reference_t ref)
    1377                 :            : {
    1378                 :   72241200 :   vec<vn_reference_op_s> operands = ref->operands;
    1379                 :   72241200 :   vn_reference_op_t op;
    1380                 :            : 
    1381                 :            :   /* Try to simplify the translated expression if it is
    1382                 :            :      a call to a builtin function with at most two arguments.  */
    1383                 :   72241200 :   op = &operands[0];
    1384                 :   72241200 :   if (op->opcode == CALL_EXPR
    1385                 :      55742 :       && TREE_CODE (op->op0) == ADDR_EXPR
    1386                 :      55742 :       && TREE_CODE (TREE_OPERAND (op->op0, 0)) == FUNCTION_DECL
    1387                 :      55742 :       && fndecl_built_in_p (TREE_OPERAND (op->op0, 0))
    1388                 :      40302 :       && operands.length () >= 2
    1389                 :   72281500 :       && operands.length () <= 3)
    1390                 :            :     {
    1391                 :      30046 :       vn_reference_op_t arg0, arg1 = NULL;
    1392                 :      30046 :       bool anyconst = false;
    1393                 :      30046 :       arg0 = &operands[1];
    1394                 :      30046 :       if (operands.length () > 2)
    1395                 :       3225 :         arg1 = &operands[2];
    1396                 :      30046 :       if (TREE_CODE_CLASS (arg0->opcode) == tcc_constant
    1397                 :      30046 :           || (arg0->opcode == ADDR_EXPR
    1398                 :      13434 :               && is_gimple_min_invariant (arg0->op0)))
    1399                 :            :         anyconst = true;
    1400                 :      30046 :       if (arg1
    1401                 :      30046 :           && (TREE_CODE_CLASS (arg1->opcode) == tcc_constant
    1402                 :       2337 :               || (arg1->opcode == ADDR_EXPR
    1403                 :        324 :                   && is_gimple_min_invariant (arg1->op0))))
    1404                 :            :         anyconst = true;
    1405                 :      28834 :       if (anyconst)
    1406                 :            :         {
    1407                 :      44476 :           tree folded = build_call_expr (TREE_OPERAND (op->op0, 0),
    1408                 :            :                                          arg1 ? 2 : 1,
    1409                 :            :                                          arg0->op0,
    1410                 :            :                                          arg1 ? arg1->op0 : NULL);
    1411                 :      23063 :           if (folded
    1412                 :      23063 :               && TREE_CODE (folded) == NOP_EXPR)
    1413                 :        312 :             folded = TREE_OPERAND (folded, 0);
    1414                 :      23063 :           if (folded
    1415                 :      23063 :               && is_gimple_min_invariant (folded))
    1416                 :        340 :             return folded;
    1417                 :            :         }
    1418                 :            :     }
    1419                 :            : 
    1420                 :            :   /* Simplify reads from constants or constant initializers.  */
    1421                 :   72211200 :   else if (BITS_PER_UNIT == 8
    1422                 :   72211200 :            && COMPLETE_TYPE_P (ref->type)
    1423                 :   72211200 :            && is_gimple_reg_type (ref->type))
    1424                 :            :     {
    1425                 :   68789600 :       poly_int64 off = 0;
    1426                 :   68789600 :       HOST_WIDE_INT size;
    1427                 :   68789600 :       if (INTEGRAL_TYPE_P (ref->type))
    1428                 :   34053100 :         size = TYPE_PRECISION (ref->type);
    1429                 :   34736500 :       else if (tree_fits_shwi_p (TYPE_SIZE (ref->type)))
    1430                 :   34736500 :         size = tree_to_shwi (TYPE_SIZE (ref->type));
    1431                 :            :       else
    1432                 :   72241200 :         return NULL_TREE;
    1433                 :   68789600 :       if (size % BITS_PER_UNIT != 0
    1434                 :   67725400 :           || size > MAX_BITSIZE_MODE_ANY_MODE)
    1435                 :            :         return NULL_TREE;
    1436                 :   67724700 :       size /= BITS_PER_UNIT;
    1437                 :   67724700 :       unsigned i;
    1438                 :  130403000 :       for (i = 0; i < operands.length (); ++i)
    1439                 :            :         {
    1440                 :  130403000 :           if (TREE_CODE_CLASS (operands[i].opcode) == tcc_constant)
    1441                 :            :             {
    1442                 :        364 :               ++i;
    1443                 :        364 :               break;
    1444                 :            :             }
    1445                 :  130403000 :           if (known_eq (operands[i].off, -1))
    1446                 :            :             return NULL_TREE;
    1447                 :  120482000 :           off += operands[i].off;
    1448                 :  120482000 :           if (operands[i].opcode == MEM_REF)
    1449                 :            :             {
    1450                 :   57803500 :               ++i;
    1451                 :   57803500 :               break;
    1452                 :            :             }
    1453                 :            :         }
    1454                 :   57803900 :       vn_reference_op_t base = &operands[--i];
    1455                 :   57803900 :       tree ctor = error_mark_node;
    1456                 :   57803900 :       tree decl = NULL_TREE;
    1457                 :   57803900 :       if (TREE_CODE_CLASS (base->opcode) == tcc_constant)
    1458                 :        364 :         ctor = base->op0;
    1459                 :   57803500 :       else if (base->opcode == MEM_REF
    1460                 :   57803500 :                && base[1].opcode == ADDR_EXPR
    1461                 :   96471400 :                && (TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == VAR_DECL
    1462                 :    3061000 :                    || TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == CONST_DECL
    1463                 :    3060940 :                    || TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == STRING_CST))
    1464                 :            :         {
    1465                 :   35610700 :           decl = TREE_OPERAND (base[1].op0, 0);
    1466                 :   35610700 :           if (TREE_CODE (decl) == STRING_CST)
    1467                 :            :             ctor = decl;
    1468                 :            :           else
    1469                 :   35606900 :             ctor = ctor_for_folding (decl);
    1470                 :            :         }
    1471                 :   57803900 :       if (ctor == NULL_TREE)
    1472                 :        147 :         return build_zero_cst (ref->type);
    1473                 :   57803700 :       else if (ctor != error_mark_node)
    1474                 :            :         {
    1475                 :      59079 :           HOST_WIDE_INT const_off;
    1476                 :      59079 :           if (decl)
    1477                 :            :             {
    1478                 :     117430 :               tree res = fold_ctor_reference (ref->type, ctor,
    1479                 :      58715 :                                               off * BITS_PER_UNIT,
    1480                 :      58715 :                                               size * BITS_PER_UNIT, decl);
    1481                 :      58715 :               if (res)
    1482                 :            :                 {
    1483                 :      32836 :                   STRIP_USELESS_TYPE_CONVERSION (res);
    1484                 :      32836 :                   if (is_gimple_min_invariant (res))
    1485                 :      32443 :                     return res;
    1486                 :            :                 }
    1487                 :            :             }
    1488                 :        364 :           else if (off.is_constant (&const_off))
    1489                 :            :             {
    1490                 :        364 :               unsigned char buf[MAX_BITSIZE_MODE_ANY_MODE / BITS_PER_UNIT];
    1491                 :        364 :               int len = native_encode_expr (ctor, buf, size, const_off);
    1492                 :        364 :               if (len > 0)
    1493                 :        121 :                 return native_interpret_expr (ref->type, buf, len);
    1494                 :            :             }
    1495                 :            :         }
    1496                 :            :     }
    1497                 :            : 
    1498                 :            :   return NULL_TREE;
    1499                 :            : }
    1500                 :            : 
    1501                 :            : /* Return true if OPS contain a storage order barrier.  */
    1502                 :            : 
    1503                 :            : static bool
    1504                 :   28867200 : contains_storage_order_barrier_p (vec<vn_reference_op_s> ops)
    1505                 :            : {
    1506                 :   28867200 :   vn_reference_op_t op;
    1507                 :   28867200 :   unsigned i;
    1508                 :            : 
    1509                 :  117183000 :   FOR_EACH_VEC_ELT (ops, i, op)
    1510                 :   88315500 :     if (op->opcode == VIEW_CONVERT_EXPR && op->reverse)
    1511                 :            :       return true;
    1512                 :            : 
    1513                 :            :   return false;
    1514                 :            : }
    1515                 :            : 
    1516                 :            : /* Transform any SSA_NAME's in a vector of vn_reference_op_s
    1517                 :            :    structures into their value numbers.  This is done in-place, and
    1518                 :            :    the vector passed in is returned.  *VALUEIZED_ANYTHING will specify
    1519                 :            :    whether any operands were valueized.  */
    1520                 :            : 
    1521                 :            : static vec<vn_reference_op_s> 
    1522                 :  134180000 : valueize_refs_1 (vec<vn_reference_op_s> orig, bool *valueized_anything,
    1523                 :            :                  bool with_avail = false)
    1524                 :            : {
    1525                 :  134180000 :   vn_reference_op_t vro;
    1526                 :  134180000 :   unsigned int i;
    1527                 :            : 
    1528                 :  134180000 :   *valueized_anything = false;
    1529                 :            : 
    1530                 :  552663000 :   FOR_EACH_VEC_ELT (orig, i, vro)
    1531                 :            :     {
    1532                 :  418483000 :       if (vro->opcode == SSA_NAME
    1533                 :  367317000 :           || (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
    1534                 :            :         {
    1535                 :   65142600 :           tree tem = with_avail ? vn_valueize (vro->op0) : SSA_VAL (vro->op0);
    1536                 :   65142600 :           if (tem != vro->op0)
    1537                 :            :             {
    1538                 :    7492680 :               *valueized_anything = true;
    1539                 :    7492680 :               vro->op0 = tem;
    1540                 :            :             }
    1541                 :            :           /* If it transforms from an SSA_NAME to a constant, update
    1542                 :            :              the opcode.  */
    1543                 :   65142600 :           if (TREE_CODE (vro->op0) != SSA_NAME && vro->opcode == SSA_NAME)
    1544                 :     478568 :             vro->opcode = TREE_CODE (vro->op0);
    1545                 :            :         }
    1546                 :  418483000 :       if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
    1547                 :            :         {
    1548                 :      20879 :           tree tem = with_avail ? vn_valueize (vro->op1) : SSA_VAL (vro->op1);
    1549                 :      20879 :           if (tem != vro->op1)
    1550                 :            :             {
    1551                 :        364 :               *valueized_anything = true;
    1552                 :        364 :               vro->op1 = tem;
    1553                 :            :             }
    1554                 :            :         }
    1555                 :  418483000 :       if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
    1556                 :            :         {
    1557                 :     154283 :           tree tem = with_avail ? vn_valueize (vro->op2) : SSA_VAL (vro->op2);
    1558                 :     154283 :           if (tem != vro->op2)
    1559                 :            :             {
    1560                 :      81420 :               *valueized_anything = true;
    1561                 :      81420 :               vro->op2 = tem;
    1562                 :            :             }
    1563                 :            :         }
    1564                 :            :       /* If it transforms from an SSA_NAME to an address, fold with
    1565                 :            :          a preceding indirect reference.  */
    1566                 :  418483000 :       if (i > 0
    1567                 :  284303000 :           && vro->op0
    1568                 :  282297000 :           && TREE_CODE (vro->op0) == ADDR_EXPR
    1569                 :  504473000 :           && orig[i - 1].opcode == MEM_REF)
    1570                 :            :         {
    1571                 :   82597200 :           if (vn_reference_fold_indirect (&orig, &i))
    1572                 :     239498 :             *valueized_anything = true;
    1573                 :            :         }
    1574                 :  335886000 :       else if (i > 0
    1575                 :  201706000 :                && vro->opcode == SSA_NAME
    1576                 :  386573000 :                && orig[i - 1].opcode == MEM_REF)
    1577                 :            :         {
    1578                 :   45745300 :           if (vn_reference_maybe_forwprop_address (&orig, &i))
    1579                 :    1025510 :             *valueized_anything = true;
    1580                 :            :         }
    1581                 :            :       /* If it transforms a non-constant ARRAY_REF into a constant
    1582                 :            :          one, adjust the constant offset.  */
    1583                 :  290141000 :       else if (vro->opcode == ARRAY_REF
    1584                 :   24143900 :                && known_eq (vro->off, -1)
    1585                 :    9125690 :                && poly_int_tree_p (vro->op0)
    1586                 :    2419330 :                && poly_int_tree_p (vro->op1)
    1587                 :  292560000 :                && TREE_CODE (vro->op2) == INTEGER_CST)
    1588                 :            :         {
    1589                 :    2322670 :           poly_offset_int off = ((wi::to_poly_offset (vro->op0)
    1590                 :    4645330 :                                   - wi::to_poly_offset (vro->op1))
    1591                 :    4645330 :                                  * wi::to_offset (vro->op2)
    1592                 :    4645330 :                                  * vn_ref_op_align_unit (vro));
    1593                 :    4644160 :           off.to_shwi (&vro->off);
    1594                 :            :         }
    1595                 :            :     }
    1596                 :            : 
    1597                 :  134180000 :   return orig;
    1598                 :            : }
    1599                 :            : 
    1600                 :            : static vec<vn_reference_op_s> 
    1601                 :   13989500 : valueize_refs (vec<vn_reference_op_s> orig)
    1602                 :            : {
    1603                 :   13989500 :   bool tem;
    1604                 :          0 :   return valueize_refs_1 (orig, &tem);
    1605                 :            : }
    1606                 :            : 
    1607                 :            : static vec<vn_reference_op_s> shared_lookup_references;
    1608                 :            : 
    1609                 :            : /* Create a vector of vn_reference_op_s structures from REF, a
    1610                 :            :    REFERENCE_CLASS_P tree.  The vector is shared among all callers of
    1611                 :            :    this function.  *VALUEIZED_ANYTHING will specify whether any
    1612                 :            :    operands were valueized.  */
    1613                 :            : 
    1614                 :            : static vec<vn_reference_op_s> 
    1615                 :  112439000 : valueize_shared_reference_ops_from_ref (tree ref, bool *valueized_anything)
    1616                 :            : {
    1617                 :  112439000 :   if (!ref)
    1618                 :          0 :     return vNULL;
    1619                 :  112439000 :   shared_lookup_references.truncate (0);
    1620                 :  112439000 :   copy_reference_ops_from_ref (ref, &shared_lookup_references);
    1621                 :  112439000 :   shared_lookup_references = valueize_refs_1 (shared_lookup_references,
    1622                 :  112439000 :                                               valueized_anything);
    1623                 :  112439000 :   return shared_lookup_references;
    1624                 :            : }
    1625                 :            : 
    1626                 :            : /* Create a vector of vn_reference_op_s structures from CALL, a
    1627                 :            :    call statement.  The vector is shared among all callers of
    1628                 :            :    this function.  */
    1629                 :            : 
    1630                 :            : static vec<vn_reference_op_s> 
    1631                 :    5005980 : valueize_shared_reference_ops_from_call (gcall *call)
    1632                 :            : {
    1633                 :    5005980 :   if (!call)
    1634                 :          0 :     return vNULL;
    1635                 :    5005980 :   shared_lookup_references.truncate (0);
    1636                 :    5005980 :   copy_reference_ops_from_call (call, &shared_lookup_references);
    1637                 :    5005980 :   shared_lookup_references = valueize_refs (shared_lookup_references);
    1638                 :    5005980 :   return shared_lookup_references;
    1639                 :            : }
    1640                 :            : 
    1641                 :            : /* Lookup a SCCVN reference operation VR in the current hash table.
    1642                 :            :    Returns the resulting value number if it exists in the hash table,
    1643                 :            :    NULL_TREE otherwise.  VNRESULT will be filled in with the actual
    1644                 :            :    vn_reference_t stored in the hashtable if something is found.  */
    1645                 :            : 
    1646                 :            : static tree
    1647                 :   40206800 : vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult)
    1648                 :            : {
    1649                 :   40206800 :   vn_reference_s **slot;
    1650                 :   40206800 :   hashval_t hash;
    1651                 :            : 
    1652                 :   40206800 :   hash = vr->hashcode;
    1653                 :   40206800 :   slot = valid_info->references->find_slot_with_hash (vr, hash, NO_INSERT);
    1654                 :   40206800 :   if (slot)
    1655                 :            :     {
    1656                 :    3685120 :       if (vnresult)
    1657                 :    3452170 :         *vnresult = (vn_reference_t)*slot;
    1658                 :    3685120 :       return ((vn_reference_t)*slot)->result;
    1659                 :            :     }
    1660                 :            : 
    1661                 :            :   return NULL_TREE;
    1662                 :            : }
    1663                 :            : 
    1664                 :            : 
    1665                 :            : /* Partial definition tracking support.  */
    1666                 :            : 
    1667                 :            : struct pd_range
    1668                 :            : {
    1669                 :            :   HOST_WIDE_INT offset;
    1670                 :            :   HOST_WIDE_INT size;
    1671                 :            : };
    1672                 :            : 
    1673                 :            : struct pd_data
    1674                 :            : {
    1675                 :            :   tree rhs;
    1676                 :            :   HOST_WIDE_INT offset;
    1677                 :            :   HOST_WIDE_INT size;
    1678                 :            : };
    1679                 :            : 
    1680                 :            : /* Context for alias walking.  */
    1681                 :            : 
    1682                 :            : struct vn_walk_cb_data
    1683                 :            : {
    1684                 :   39733100 :   vn_walk_cb_data (vn_reference_t vr_, tree orig_ref_, tree *last_vuse_ptr_,
    1685                 :            :                    vn_lookup_kind vn_walk_kind_, bool tbaa_p_, tree mask_)
    1686                 :   39733100 :     : vr (vr_), last_vuse_ptr (last_vuse_ptr_), last_vuse (NULL_TREE),
    1687                 :            :       mask (mask_), masked_result (NULL_TREE), vn_walk_kind (vn_walk_kind_),
    1688                 :            :       tbaa_p (tbaa_p_), saved_operands (vNULL), first_set (-2),
    1689                 :   39733100 :       first_base_set (-2), known_ranges (NULL)
    1690                 :            :   {
    1691                 :   39733100 :     if (!last_vuse_ptr)
    1692                 :   19999100 :       last_vuse_ptr = &last_vuse;
    1693                 :   39733100 :     ao_ref_init (&orig_ref, orig_ref_);
    1694                 :   39733100 :     if (mask)
    1695                 :            :       {
    1696                 :     168682 :         wide_int w = wi::to_wide (mask);
    1697                 :     168682 :         unsigned int pos = 0, prec = w.get_precision ();
    1698                 :     168682 :         pd_data pd;
    1699                 :     168682 :         pd.rhs = build_constructor (NULL_TREE, NULL);
    1700                 :            :         /* When bitwise and with a constant is done on a memory load,
    1701                 :            :            we don't really need all the bits to be defined or defined
    1702                 :            :            to constants, we don't really care what is in the position
    1703                 :            :            corresponding to 0 bits in the mask.
    1704                 :            :            So, push the ranges of those 0 bits in the mask as artificial
    1705                 :            :            zero stores and let the partial def handling code do the
    1706                 :            :            rest.  */
    1707                 :     371785 :         while (pos < prec)
    1708                 :            :           {
    1709                 :     357602 :             int tz = wi::ctz (w);
    1710                 :     357602 :             if (pos + tz > prec)
    1711                 :     154499 :               tz = prec - pos;
    1712                 :     357602 :             if (tz)
    1713                 :            :               {
    1714                 :     274350 :                 if (BYTES_BIG_ENDIAN)
    1715                 :            :                   pd.offset = prec - pos - tz;
    1716                 :            :                 else
    1717                 :     274350 :                   pd.offset = pos;
    1718                 :     274350 :                 pd.size = tz;
    1719                 :     274350 :                 void *r = push_partial_def (pd, 0, 0, 0, prec);
    1720                 :     274350 :                 gcc_assert (r == NULL_TREE);
    1721                 :            :               }
    1722                 :     357602 :             pos += tz;
    1723                 :     357602 :             if (pos == prec)
    1724                 :            :               break;
    1725                 :     203103 :             w = wi::lrshift (w, tz);
    1726                 :     203103 :             tz = wi::ctz (wi::bit_not (w));
    1727                 :     203103 :             if (pos + tz > prec)
    1728                 :          0 :               tz = prec - pos;
    1729                 :     203103 :             pos += tz;
    1730                 :     203103 :             w = wi::lrshift (w, tz);
    1731                 :            :           }
    1732                 :            :       }
    1733                 :   39733100 :   }
    1734                 :            :   ~vn_walk_cb_data ();
    1735                 :            :   void *finish (alias_set_type, alias_set_type, tree);
    1736                 :            :   void *push_partial_def (pd_data pd,
    1737                 :            :                           alias_set_type, alias_set_type, HOST_WIDE_INT,
    1738                 :            :                           HOST_WIDE_INT);
    1739                 :            : 
    1740                 :            :   vn_reference_t vr;
    1741                 :            :   ao_ref orig_ref;
    1742                 :            :   tree *last_vuse_ptr;
    1743                 :            :   tree last_vuse;
    1744                 :            :   tree mask;
    1745                 :            :   tree masked_result;
    1746                 :            :   vn_lookup_kind vn_walk_kind;
    1747                 :            :   bool tbaa_p;
    1748                 :            :   vec<vn_reference_op_s> saved_operands;
    1749                 :            : 
    1750                 :            :   /* The VDEFs of partial defs we come along.  */
    1751                 :            :   auto_vec<pd_data, 2> partial_defs;
    1752                 :            :   /* The first defs range to avoid splay tree setup in most cases.  */
    1753                 :            :   pd_range first_range;
    1754                 :            :   alias_set_type first_set;
    1755                 :            :   alias_set_type first_base_set;
    1756                 :            :   splay_tree known_ranges;
    1757                 :            :   obstack ranges_obstack;
    1758                 :            : };
    1759                 :            : 
    1760                 :  119199000 : vn_walk_cb_data::~vn_walk_cb_data ()
    1761                 :            : {
    1762                 :   39733100 :   if (known_ranges)
    1763                 :            :     {
    1764                 :      94241 :       splay_tree_delete (known_ranges);
    1765                 :      94241 :       obstack_free (&ranges_obstack, NULL);
    1766                 :            :     }
    1767                 :   40890700 :   saved_operands.release ();
    1768                 :   39733100 : }
    1769                 :            : 
    1770                 :            : void *
    1771                 :     755107 : vn_walk_cb_data::finish (alias_set_type set, alias_set_type base_set, tree val)
    1772                 :            : {
    1773                 :     755107 :   if (first_set != -2)
    1774                 :            :     {
    1775                 :     151076 :       set = first_set;
    1776                 :     151076 :       base_set = first_base_set;
    1777                 :            :     }
    1778                 :     755107 :   if (mask)
    1779                 :            :     {
    1780                 :        130 :       masked_result = val;
    1781                 :        130 :       return (void *) -1;
    1782                 :            :     }
    1783                 :     754977 :   vec<vn_reference_op_s> &operands
    1784                 :     754977 :     = saved_operands.exists () ? saved_operands : vr->operands;
    1785                 :     754977 :   return vn_reference_lookup_or_insert_for_pieces (last_vuse, set, base_set,
    1786                 :     754977 :                                                    vr->type, operands, val);
    1787                 :            : }
    1788                 :            : 
    1789                 :            : /* pd_range splay-tree helpers.  */
    1790                 :            : 
    1791                 :            : static int
    1792                 :     767582 : pd_range_compare (splay_tree_key offset1p, splay_tree_key offset2p)
    1793                 :            : {
    1794                 :     767582 :   HOST_WIDE_INT offset1 = *(HOST_WIDE_INT *)offset1p;
    1795                 :     767582 :   HOST_WIDE_INT offset2 = *(HOST_WIDE_INT *)offset2p;
    1796                 :     767582 :   if (offset1 < offset2)
    1797                 :            :     return -1;
    1798                 :     531533 :   else if (offset1 > offset2)
    1799                 :     246603 :     return 1;
    1800                 :            :   return 0;
    1801                 :            : }
    1802                 :            : 
    1803                 :            : static void *
    1804                 :     304874 : pd_tree_alloc (int size, void *data_)
    1805                 :            : {
    1806                 :     304874 :   vn_walk_cb_data *data = (vn_walk_cb_data *)data_;
    1807                 :     304874 :   return obstack_alloc (&data->ranges_obstack, size);
    1808                 :            : }
    1809                 :            : 
    1810                 :            : static void
    1811                 :     304874 : pd_tree_dealloc (void *, void *)
    1812                 :            : {
    1813                 :     304874 : }
    1814                 :            : 
    1815                 :            : /* Push PD to the vector of partial definitions returning a
    1816                 :            :    value when we are ready to combine things with VUSE, SET and MAXSIZEI,
    1817                 :            :    NULL when we want to continue looking for partial defs or -1
    1818                 :            :    on failure.  */
    1819                 :            : 
    1820                 :            : void *
    1821                 :     311703 : vn_walk_cb_data::push_partial_def (pd_data pd,
    1822                 :            :                                    alias_set_type set, alias_set_type base_set,
    1823                 :            :                                    HOST_WIDE_INT offseti,
    1824                 :            :                                    HOST_WIDE_INT maxsizei)
    1825                 :            : {
    1826                 :     311703 :   const HOST_WIDE_INT bufsize = 64;
    1827                 :            :   /* We're using a fixed buffer for encoding so fail early if the object
    1828                 :            :      we want to interpret is bigger.  */
    1829                 :     311703 :   if (maxsizei > bufsize * BITS_PER_UNIT
    1830                 :            :       || CHAR_BIT != 8
    1831                 :            :       || BITS_PER_UNIT != 8
    1832                 :            :       /* Not prepared to handle PDP endian.  */
    1833                 :            :       || BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN)
    1834                 :            :     return (void *)-1;
    1835                 :            : 
    1836                 :            :   /* Turn too large constant stores into non-constant stores.  */
    1837                 :     311703 :   if (CONSTANT_CLASS_P (pd.rhs) && pd.size > bufsize * BITS_PER_UNIT)
    1838                 :          0 :     pd.rhs = error_mark_node;
    1839                 :            : 
    1840                 :            :   /* And for non-constant or CONSTRUCTOR stores shrink them to only keep at
    1841                 :            :      most a partial byte before and/or after the region.  */
    1842                 :     311703 :   if (!CONSTANT_CLASS_P (pd.rhs))
    1843                 :            :     {
    1844                 :     296890 :       if (pd.offset < offseti)
    1845                 :            :         {
    1846                 :       2211 :           HOST_WIDE_INT o = ROUND_DOWN (offseti - pd.offset, BITS_PER_UNIT);
    1847                 :       2211 :           gcc_assert (pd.size > o);
    1848                 :       2211 :           pd.size -= o;
    1849                 :       2211 :           pd.offset += o;
    1850                 :            :         }
    1851                 :     296890 :       if (pd.size > maxsizei)
    1852                 :       2862 :         pd.size = maxsizei + ((pd.size - maxsizei) % BITS_PER_UNIT);
    1853                 :            :     }
    1854                 :            : 
    1855                 :     311703 :   pd.offset -= offseti;
    1856                 :            : 
    1857                 :     623406 :   bool pd_constant_p = (TREE_CODE (pd.rhs) == CONSTRUCTOR
    1858                 :     311703 :                         || CONSTANT_CLASS_P (pd.rhs));
    1859                 :     311703 :   if (partial_defs.is_empty ())
    1860                 :            :     {
    1861                 :            :       /* If we get a clobber upfront, fail.  */
    1862                 :     192739 :       if (TREE_CLOBBER_P (pd.rhs))
    1863                 :            :         return (void *)-1;
    1864                 :     192728 :       if (!pd_constant_p)
    1865                 :            :         return (void *)-1;
    1866                 :     174356 :       partial_defs.safe_push (pd);
    1867                 :     174356 :       first_range.offset = pd.offset;
    1868                 :     174356 :       first_range.size = pd.size;
    1869                 :     174356 :       first_set = set;
    1870                 :     174356 :       first_base_set = base_set;
    1871                 :     174356 :       last_vuse_ptr = NULL;
    1872                 :            :       /* Continue looking for partial defs.  */
    1873                 :     174356 :       return NULL;
    1874                 :            :     }
    1875                 :            : 
    1876                 :     118964 :   if (!known_ranges)
    1877                 :            :     {
    1878                 :            :       /* ???  Optimize the case where the 2nd partial def completes things.  */
    1879                 :      94241 :       gcc_obstack_init (&ranges_obstack);
    1880                 :      94241 :       known_ranges = splay_tree_new_with_allocator (pd_range_compare, 0, 0,
    1881                 :            :                                                     pd_tree_alloc,
    1882                 :            :                                                     pd_tree_dealloc, this);
    1883                 :      94241 :       splay_tree_insert (known_ranges,
    1884                 :      94241 :                          (splay_tree_key)&first_range.offset,
    1885                 :      94241 :                          (splay_tree_value)&first_range);
    1886                 :            :     }
    1887                 :            : 
    1888                 :     118964 :   pd_range newr = { pd.offset, pd.size };
    1889                 :     118964 :   splay_tree_node n;
    1890                 :     118964 :   pd_range *r;
    1891                 :            :   /* Lookup the predecessor of offset + 1 and see if we need to merge.  */
    1892                 :     118964 :   HOST_WIDE_INT loffset = newr.offset + 1;
    1893                 :     118964 :   if ((n = splay_tree_predecessor (known_ranges, (splay_tree_key)&loffset))
    1894                 :     108298 :       && ((r = (pd_range *)n->value), true)
    1895                 :     118964 :       && ranges_known_overlap_p (r->offset, r->size + 1,
    1896                 :            :                                  newr.offset, newr.size))
    1897                 :            :     {
    1898                 :            :       /* Ignore partial defs already covered.  Here we also drop shadowed
    1899                 :            :          clobbers arriving here at the floor.  */
    1900                 :       2572 :       if (known_subrange_p (newr.offset, newr.size, r->offset, r->size))
    1901                 :            :         return NULL;
    1902                 :       2093 :       r->size = MAX (r->offset + r->size, newr.offset + newr.size) - r->offset;
    1903                 :            :     }
    1904                 :            :   else
    1905                 :            :     {
    1906                 :            :       /* newr.offset wasn't covered yet, insert the range.  */
    1907                 :     116392 :       r = XOBNEW (&ranges_obstack, pd_range);
    1908                 :     116392 :       *r = newr;
    1909                 :     116392 :       splay_tree_insert (known_ranges, (splay_tree_key)&r->offset,
    1910                 :            :                          (splay_tree_value)r);
    1911                 :            :     }
    1912                 :            :   /* Merge r which now contains newr and is a member of the splay tree with
    1913                 :            :      adjacent overlapping ranges.  */
    1914                 :     130196 :   pd_range *rafter;
    1915                 :     260392 :   while ((n = splay_tree_successor (known_ranges, (splay_tree_key)&r->offset))
    1916                 :      11840 :          && ((rafter = (pd_range *)n->value), true)
    1917                 :     130196 :          && ranges_known_overlap_p (r->offset, r->size + 1,
    1918                 :      11840 :                                     rafter->offset, rafter->size))
    1919                 :            :     {
    1920                 :      11711 :       r->size = MAX (r->offset + r->size,
    1921                 :      11711 :                      rafter->offset + rafter->size) - r->offset;
    1922                 :      11711 :       splay_tree_remove (known_ranges, (splay_tree_key)&rafter->offset);
    1923                 :            :     }
    1924                 :            :   /* If we get a clobber, fail.  */
    1925                 :     118485 :   if (TREE_CLOBBER_P (pd.rhs))
    1926                 :            :     return (void *)-1;
    1927                 :            :   /* Non-constants are OK as long as they are shadowed by a constant.  */
    1928                 :     118395 :   if (!pd_constant_p)
    1929                 :            :     return (void *)-1;
    1930                 :     114458 :   partial_defs.safe_push (pd);
    1931                 :            : 
    1932                 :            :   /* Now we have merged newr into the range tree.  When we have covered
    1933                 :            :      [offseti, sizei] then the tree will contain exactly one node which has
    1934                 :            :      the desired properties and it will be 'r'.  */
    1935                 :     114458 :   if (!known_subrange_p (0, maxsizei, r->offset, r->size))
    1936                 :            :     /* Continue looking for partial defs.  */
    1937                 :            :     return NULL;
    1938                 :            : 
    1939                 :            :   /* Now simply native encode all partial defs in reverse order.  */
    1940                 :       3664 :   unsigned ndefs = partial_defs.length ();
    1941                 :            :   /* We support up to 512-bit values (for V8DFmode).  */
    1942                 :       3664 :   unsigned char buffer[bufsize + 1];
    1943                 :       3664 :   unsigned char this_buffer[bufsize + 1];
    1944                 :       3664 :   int len;
    1945                 :            : 
    1946                 :       3664 :   memset (buffer, 0, bufsize + 1);
    1947                 :       3664 :   unsigned needed_len = ROUND_UP (maxsizei, BITS_PER_UNIT) / BITS_PER_UNIT;
    1948                 :      15607 :   while (!partial_defs.is_empty ())
    1949                 :            :     {
    1950                 :      11943 :       pd_data pd = partial_defs.pop ();
    1951                 :      11943 :       unsigned int amnt;
    1952                 :      11943 :       if (TREE_CODE (pd.rhs) == CONSTRUCTOR)
    1953                 :            :         {
    1954                 :            :           /* Empty CONSTRUCTOR.  */
    1955                 :        230 :           if (pd.size >= needed_len * BITS_PER_UNIT)
    1956                 :         31 :             len = needed_len;
    1957                 :            :           else
    1958                 :        199 :             len = ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT;
    1959                 :        230 :           memset (this_buffer, 0, len);
    1960                 :            :         }
    1961                 :            :       else
    1962                 :            :         {
    1963                 :      15570 :           len = native_encode_expr (pd.rhs, this_buffer, bufsize,
    1964                 :       3857 :                                     MAX (0, -pd.offset) / BITS_PER_UNIT);
    1965                 :      11713 :           if (len <= 0
    1966                 :      23426 :               || len < (ROUND_UP (pd.size, BITS_PER_UNIT) / BITS_PER_UNIT
    1967                 :      11713 :                         - MAX (0, -pd.offset) / BITS_PER_UNIT))
    1968                 :            :             {
    1969                 :          0 :               if (dump_file && (dump_flags & TDF_DETAILS))
    1970                 :          0 :                 fprintf (dump_file, "Failed to encode %u "
    1971                 :            :                          "partial definitions\n", ndefs);
    1972                 :          0 :               return (void *)-1;
    1973                 :            :             }
    1974                 :            :         }
    1975                 :            : 
    1976                 :      11943 :       unsigned char *p = buffer;
    1977                 :      11943 :       HOST_WIDE_INT size = pd.size;
    1978                 :      11943 :       if (pd.offset < 0)
    1979                 :        178 :         size -= ROUND_DOWN (-pd.offset, BITS_PER_UNIT);
    1980                 :      11943 :       this_buffer[len] = 0;
    1981                 :      11943 :       if (BYTES_BIG_ENDIAN)
    1982                 :            :         {
    1983                 :            :           /* LSB of this_buffer[len - 1] byte should be at
    1984                 :            :              pd.offset + pd.size - 1 bits in buffer.  */
    1985                 :            :           amnt = ((unsigned HOST_WIDE_INT) pd.offset
    1986                 :            :                   + pd.size) % BITS_PER_UNIT;
    1987                 :            :           if (amnt)
    1988                 :            :             shift_bytes_in_array_right (this_buffer, len + 1, amnt);
    1989                 :            :           unsigned char *q = this_buffer;
    1990                 :            :           unsigned int off = 0;
    1991                 :            :           if (pd.offset >= 0)
    1992                 :            :             {
    1993                 :            :               unsigned int msk;
    1994                 :            :               off = pd.offset / BITS_PER_UNIT;
    1995                 :            :               gcc_assert (off < needed_len);
    1996                 :            :               p = buffer + off;
    1997                 :            :               if (size <= amnt)
    1998                 :            :                 {
    1999                 :            :                   msk = ((1 << size) - 1) << (BITS_PER_UNIT - amnt);
    2000                 :            :                   *p = (*p & ~msk) | (this_buffer[len] & msk);
    2001                 :            :                   size = 0;
    2002                 :            :                 }
    2003                 :            :               else
    2004                 :            :                 {
    2005                 :            :                   if (TREE_CODE (pd.rhs) != CONSTRUCTOR)
    2006                 :            :                     q = (this_buffer + len
    2007                 :            :                          - (ROUND_UP (size - amnt, BITS_PER_UNIT)
    2008                 :            :                             / BITS_PER_UNIT));
    2009                 :            :                   if (pd.offset % BITS_PER_UNIT)
    2010                 :            :                     {
    2011                 :            :                       msk = -1U << (BITS_PER_UNIT
    2012                 :            :                                     - (pd.offset % BITS_PER_UNIT));
    2013                 :            :                       *p = (*p & msk) | (*q & ~msk);
    2014                 :            :                       p++;
    2015                 :            :                       q++;
    2016                 :            :                       off++;
    2017                 :            :                       size -= BITS_PER_UNIT - (pd.offset % BITS_PER_UNIT);
    2018                 :            :                       gcc_assert (size >= 0);
    2019                 :            :                     }
    2020                 :            :                 }
    2021                 :            :             }
    2022                 :            :           else if (TREE_CODE (pd.rhs) != CONSTRUCTOR)
    2023                 :            :             {
    2024                 :            :               q = (this_buffer + len
    2025                 :            :                    - (ROUND_UP (size - amnt, BITS_PER_UNIT)
    2026                 :            :                       / BITS_PER_UNIT));
    2027                 :            :               if (pd.offset % BITS_PER_UNIT)
    2028                 :            :                 {
    2029                 :            :                   q++;
    2030                 :            :                   size -= BITS_PER_UNIT - ((unsigned HOST_WIDE_INT) pd.offset
    2031                 :            :                                            % BITS_PER_UNIT);
    2032                 :            :                   gcc_assert (size >= 0);
    2033                 :            :                 }
    2034                 :            :             }
    2035                 :            :           if ((unsigned HOST_WIDE_INT) size / BITS_PER_UNIT + off
    2036                 :            :               > needed_len)
    2037                 :            :             size = (needed_len - off) * BITS_PER_UNIT;
    2038                 :            :           memcpy (p, q, size / BITS_PER_UNIT);
    2039                 :            :           if (size % BITS_PER_UNIT)
    2040                 :            :             {
    2041                 :            :               unsigned int msk
    2042                 :            :                 = -1U << (BITS_PER_UNIT - (size % BITS_PER_UNIT));
    2043                 :            :               p += size / BITS_PER_UNIT;
    2044                 :            :               q += size / BITS_PER_UNIT;
    2045                 :            :               *p = (*q & msk) | (*p & ~msk);
    2046                 :            :             }
    2047                 :            :         }
    2048                 :            :       else
    2049                 :            :         {
    2050                 :      11943 :           size = MIN (size, (HOST_WIDE_INT) needed_len * BITS_PER_UNIT);
    2051                 :      11943 :           if (pd.offset >= 0)
    2052                 :            :             {
    2053                 :            :               /* LSB of this_buffer[0] byte should be at pd.offset bits
    2054                 :            :                  in buffer.  */
    2055                 :      11765 :               unsigned int msk;
    2056                 :      11765 :               amnt = pd.offset % BITS_PER_UNIT;
    2057                 :      11765 :               if (amnt)
    2058                 :        292 :                 shift_bytes_in_array_left (this_buffer, len + 1, amnt);
    2059                 :      11765 :               unsigned int off = pd.offset / BITS_PER_UNIT;
    2060                 :      11765 :               gcc_assert (off < needed_len);
    2061                 :      11765 :               size = MIN (size,
    2062                 :            :                           (HOST_WIDE_INT) (needed_len - off) * BITS_PER_UNIT);
    2063                 :      11765 :               p = buffer + off;
    2064                 :      11765 :               if (amnt + size < BITS_PER_UNIT)
    2065                 :            :                 {
    2066                 :            :                   /* Low amnt bits come from *p, then size bits
    2067                 :            :                      from this_buffer[0] and the remaining again from
    2068                 :            :                      *p.  */
    2069                 :        211 :                   msk = ((1 << size) - 1) << amnt;
    2070                 :        211 :                   *p = (*p & ~msk) | (this_buffer[0] & msk);
    2071                 :        211 :                   size = 0;
    2072                 :            :                 }
    2073                 :      11554 :               else if (amnt)
    2074                 :            :                 {
    2075                 :        236 :                   msk = -1U << amnt;
    2076                 :        236 :                   *p = (*p & ~msk) | (this_buffer[0] & msk);
    2077                 :        236 :                   p++;
    2078                 :        236 :                   size -= (BITS_PER_UNIT - amnt);
    2079                 :            :                 }
    2080                 :            :             }
    2081                 :            :           else
    2082                 :            :             {
    2083                 :        178 :               amnt = (unsigned HOST_WIDE_INT) pd.offset % BITS_PER_UNIT;
    2084                 :        178 :               if (amnt)
    2085                 :          7 :                 shift_bytes_in_array_left (this_buffer, len + 1, amnt);
    2086                 :            :             }
    2087                 :      11943 :           memcpy (p, this_buffer + (amnt != 0), size / BITS_PER_UNIT);
    2088                 :      11943 :           p += size / BITS_PER_UNIT;
    2089                 :      11943 :           if (size % BITS_PER_UNIT)
    2090                 :            :             {
    2091                 :        148 :               unsigned int msk = -1U << (size % BITS_PER_UNIT);
    2092                 :        148 :               *p = (this_buffer[(amnt != 0) + size / BITS_PER_UNIT]
    2093                 :        148 :                     & ~msk) | (*p & msk);
    2094                 :            :             }
    2095                 :            :         }
    2096                 :            :     }
    2097                 :            : 
    2098                 :       3664 :   tree type = vr->type;
    2099                 :            :   /* Make sure to interpret in a type that has a range covering the whole
    2100                 :            :      access size.  */
    2101                 :       3664 :   if (INTEGRAL_TYPE_P (vr->type) && maxsizei != TYPE_PRECISION (vr->type))
    2102                 :          0 :     type = build_nonstandard_integer_type (maxsizei, TYPE_UNSIGNED (type));
    2103                 :       3664 :   tree val;
    2104                 :       3664 :   if (BYTES_BIG_ENDIAN)
    2105                 :            :     {
    2106                 :            :       unsigned sz = needed_len;
    2107                 :            :       if (maxsizei % BITS_PER_UNIT)
    2108                 :            :         shift_bytes_in_array_right (buffer, needed_len,
    2109                 :            :                                     BITS_PER_UNIT
    2110                 :            :                                     - (maxsizei % BITS_PER_UNIT));
    2111                 :            :       if (INTEGRAL_TYPE_P (type))
    2112                 :            :         sz = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type));
    2113                 :            :       if (sz > needed_len)
    2114                 :            :         {
    2115                 :            :           memcpy (this_buffer + (sz - needed_len), buffer, needed_len);
    2116                 :            :           val = native_interpret_expr (type, this_buffer, sz);
    2117                 :            :         }
    2118                 :            :       else
    2119                 :            :         val = native_interpret_expr (type, buffer, needed_len);
    2120                 :            :     }
    2121                 :            :   else
    2122                 :       3664 :     val = native_interpret_expr (type, buffer, bufsize);
    2123                 :            :   /* If we chop off bits because the types precision doesn't match the memory
    2124                 :            :      access size this is ok when optimizing reads but not when called from
    2125                 :            :      the DSE code during elimination.  */
    2126                 :       3664 :   if (val && type != vr->type)
    2127                 :            :     {
    2128                 :          0 :       if (! int_fits_type_p (val, vr->type))
    2129                 :            :         val = NULL_TREE;
    2130                 :            :       else
    2131                 :          0 :         val = fold_convert (vr->type, val);
    2132                 :            :     }
    2133                 :            : 
    2134                 :       3664 :   if (val)
    2135                 :            :     {
    2136                 :       3664 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2137                 :          0 :         fprintf (dump_file,
    2138                 :            :                  "Successfully combined %u partial definitions\n", ndefs);
    2139                 :            :       /* We are using the alias-set of the first store we encounter which
    2140                 :            :          should be appropriate here.  */
    2141                 :       3664 :       return finish (first_set, first_base_set, val);
    2142                 :            :     }
    2143                 :            :   else
    2144                 :            :     {
    2145                 :          0 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2146                 :          0 :         fprintf (dump_file,
    2147                 :            :                  "Failed to interpret %u encoded partial definitions\n", ndefs);
    2148                 :          0 :       return (void *)-1;
    2149                 :            :     }
    2150                 :            : }
    2151                 :            : 
    2152                 :            : /* Callback for walk_non_aliased_vuses.  Adjusts the vn_reference_t VR_
    2153                 :            :    with the current VUSE and performs the expression lookup.  */
    2154                 :            : 
    2155                 :            : static void *
    2156                 :  780903000 : vn_reference_lookup_2 (ao_ref *op ATTRIBUTE_UNUSED, tree vuse, void *data_)
    2157                 :            : {
    2158                 :  780903000 :   vn_walk_cb_data *data = (vn_walk_cb_data *)data_;
    2159                 :  780903000 :   vn_reference_t vr = data->vr;
    2160                 :  780903000 :   vn_reference_s **slot;
    2161                 :  780903000 :   hashval_t hash;
    2162                 :            : 
    2163                 :            :   /* If we have partial definitions recorded we have to go through
    2164                 :            :      vn_reference_lookup_3.  */
    2165                 :  780903000 :   if (!data->partial_defs.is_empty ())
    2166                 :            :     return NULL;
    2167                 :            : 
    2168                 :  780571000 :   if (data->last_vuse_ptr)
    2169                 :            :     {
    2170                 :  774611000 :       *data->last_vuse_ptr = vuse;
    2171                 :  774611000 :       data->last_vuse = vuse;
    2172                 :            :     }
    2173                 :            : 
    2174                 :            :   /* Fixup vuse and hash.  */
    2175                 :  780571000 :   if (vr->vuse)
    2176                 :  780571000 :     vr->hashcode = vr->hashcode - SSA_NAME_VERSION (vr->vuse);
    2177                 :  780571000 :   vr->vuse = vuse_ssa_val (vuse);
    2178                 :  780571000 :   if (vr->vuse)
    2179                 :  780571000 :     vr->hashcode = vr->hashcode + SSA_NAME_VERSION (vr->vuse);
    2180                 :            : 
    2181                 :  780571000 :   hash = vr->hashcode;
    2182                 :  780571000 :   slot = valid_info->references->find_slot_with_hash (vr, hash, NO_INSERT);
    2183                 :  780571000 :   if (slot)
    2184                 :            :     {
    2185                 :    4943420 :       if ((*slot)->result && data->saved_operands.exists ())
    2186                 :     146302 :         return data->finish (vr->set, vr->base_set, (*slot)->result);
    2187                 :            :       return *slot;
    2188                 :            :     }
    2189                 :            : 
    2190                 :            :   return NULL;
    2191                 :            : }
    2192                 :            : 
    2193                 :            : /* Lookup an existing or insert a new vn_reference entry into the
    2194                 :            :    value table for the VUSE, SET, TYPE, OPERANDS reference which
    2195                 :            :    has the value VALUE which is either a constant or an SSA name.  */
    2196                 :            : 
    2197                 :            : static vn_reference_t
    2198                 :     754977 : vn_reference_lookup_or_insert_for_pieces (tree vuse,
    2199                 :            :                                           alias_set_type set,
    2200                 :            :                                           alias_set_type base_set,
    2201                 :            :                                           tree type,
    2202                 :            :                                           vec<vn_reference_op_s,
    2203                 :            :                                                 va_heap> operands,
    2204                 :            :                                           tree value)
    2205                 :            : {
    2206                 :     754977 :   vn_reference_s vr1;
    2207                 :     754977 :   vn_reference_t result;
    2208                 :     754977 :   unsigned value_id;
    2209                 :     754977 :   vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
    2210                 :     754977 :   vr1.operands = operands;
    2211                 :     754977 :   vr1.type = type;
    2212                 :     754977 :   vr1.set = set;
    2213                 :     754977 :   vr1.base_set = base_set;
    2214                 :     754977 :   vr1.hashcode = vn_reference_compute_hash (&vr1);
    2215                 :     754977 :   if (vn_reference_lookup_1 (&vr1, &result))
    2216                 :          0 :     return result;
    2217                 :     754977 :   if (TREE_CODE (value) == SSA_NAME)
    2218                 :     148077 :     value_id = VN_INFO (value)->value_id;
    2219                 :            :   else
    2220                 :     606900 :     value_id = get_or_alloc_constant_value_id (value);
    2221                 :    1509950 :   return vn_reference_insert_pieces (vuse, set, base_set, type,
    2222                 :     754977 :                                      operands.copy (), value, value_id);
    2223                 :            : }
    2224                 :            : 
    2225                 :            : /* Return a value-number for RCODE OPS... either by looking up an existing
    2226                 :            :    value-number for the simplified result or by inserting the operation if
    2227                 :            :    INSERT is true.  */
    2228                 :            : 
    2229                 :            : static tree
    2230                 :    3790260 : vn_nary_build_or_lookup_1 (gimple_match_op *res_op, bool insert)
    2231                 :            : {
    2232                 :    3790260 :   tree result = NULL_TREE;
    2233                 :            :   /* We will be creating a value number for
    2234                 :            :        RCODE (OPS...).
    2235                 :            :      So first simplify and lookup this expression to see if it
    2236                 :            :      is already available.  */
    2237                 :            :   /* For simplification valueize.  */
    2238                 :    3790260 :   unsigned i;
    2239                 :   10542200 :   for (i = 0; i < res_op->num_ops; ++i)
    2240                 :    6751980 :     if (TREE_CODE (res_op->ops[i]) == SSA_NAME)
    2241                 :            :       {
    2242                 :    4270520 :         tree tem = vn_valueize (res_op->ops[i]);
    2243                 :    4270520 :         if (!tem)
    2244                 :            :           break;
    2245                 :    4270520 :         res_op->ops[i] = tem;
    2246                 :            :       }
    2247                 :            :   /* If valueization of an operand fails (it is not available), skip
    2248                 :            :      simplification.  */
    2249                 :    3790260 :   bool res = false;
    2250                 :    3790260 :   if (i == res_op->num_ops)
    2251                 :            :     {
    2252                 :    3790260 :       mprts_hook = vn_lookup_simplify_result;
    2253                 :    3790260 :       res = res_op->resimplify (NULL, vn_valueize);
    2254                 :    3790260 :       mprts_hook = NULL;
    2255                 :            :     }
    2256                 :    6813790 :   gimple *new_stmt = NULL;
    2257                 :    3790260 :   if (res
    2258                 :    3790260 :       && gimple_simplified_result_is_gimple_val (res_op))
    2259                 :            :     {
    2260                 :            :       /* The expression is already available.  */
    2261                 :     766738 :       result = res_op->ops[0];
    2262                 :            :       /* Valueize it, simplification returns sth in AVAIL only.  */
    2263                 :     766738 :       if (TREE_CODE (result) == SSA_NAME)
    2264                 :     166636 :         result = SSA_VAL (result);
    2265                 :            :     }
    2266                 :            :   else
    2267                 :            :     {
    2268                 :    3023520 :       tree val = vn_lookup_simplify_result (res_op);
    2269                 :    3023520 :       if (!val && insert)
    2270                 :            :         {
    2271                 :      28577 :           gimple_seq stmts = NULL;
    2272                 :      28577 :           result = maybe_push_res_to_seq (res_op, &stmts);
    2273                 :      28577 :           if (result)
    2274                 :            :             {
    2275                 :      28577 :               gcc_assert (gimple_seq_singleton_p (stmts));
    2276                 :      28577 :               new_stmt = gimple_seq_first_stmt (stmts);
    2277                 :            :             }
    2278                 :            :         }
    2279                 :            :       else
    2280                 :            :         /* The expression is already available.  */
    2281                 :            :         result = val;
    2282                 :            :     }
    2283                 :     166636 :   if (new_stmt)
    2284                 :            :     {
    2285                 :            :       /* The expression is not yet available, value-number lhs to
    2286                 :            :          the new SSA_NAME we created.  */
    2287                 :            :       /* Initialize value-number information properly.  */
    2288                 :      28577 :       vn_ssa_aux_t result_info = VN_INFO (result);
    2289                 :      28577 :       result_info->valnum = result;
    2290                 :      28577 :       result_info->value_id = get_next_value_id ();
    2291                 :      28577 :       result_info->visited = 1;
    2292                 :      28577 :       gimple_seq_add_stmt_without_update (&VN_INFO (result)->expr,
    2293                 :            :                                           new_stmt);
    2294                 :      28577 :       result_info->needs_insertion = true;
    2295                 :            :       /* ???  PRE phi-translation inserts NARYs without corresponding
    2296                 :            :          SSA name result.  Re-use those but set their result according
    2297                 :            :          to the stmt we just built.  */
    2298                 :      28577 :       vn_nary_op_t nary = NULL;
    2299                 :      28577 :       vn_nary_op_lookup_stmt (new_stmt, &nary);
    2300                 :      28577 :       if (nary)
    2301                 :            :         {
    2302                 :          0 :           gcc_assert (! nary->predicated_values && nary->u.result == NULL_TREE);
    2303                 :          0 :           nary->u.result = gimple_assign_lhs (new_stmt);
    2304                 :            :         }
    2305                 :            :       /* As all "inserted" statements are singleton SCCs, insert
    2306                 :            :          to the valid table.  This is strictly needed to
    2307                 :            :          avoid re-generating new value SSA_NAMEs for the same
    2308                 :            :          expression during SCC iteration over and over (the
    2309                 :            :          optimistic table gets cleared after each iteration).
    2310                 :            :          We do not need to insert into the optimistic table, as
    2311                 :            :          lookups there will fall back to the valid table.  */
    2312                 :            :       else
    2313                 :            :         {
    2314                 :      28577 :           unsigned int length = vn_nary_length_from_stmt (new_stmt);
    2315                 :      28577 :           vn_nary_op_t vno1
    2316                 :      28577 :             = alloc_vn_nary_op_noinit (length, &vn_tables_insert_obstack);
    2317                 :      28577 :           vno1->value_id = result_info->value_id;
    2318                 :      28577 :           vno1->length = length;
    2319                 :      28577 :           vno1->predicated_values = 0;
    2320                 :      28577 :           vno1->u.result = result;
    2321                 :      28577 :           init_vn_nary_op_from_stmt (vno1, new_stmt);
    2322                 :      28577 :           vn_nary_op_insert_into (vno1, valid_info->nary, true);
    2323                 :            :           /* Also do not link it into the undo chain.  */
    2324                 :      28577 :           last_inserted_nary = vno1->next;
    2325                 :      28577 :           vno1->next = (vn_nary_op_t)(void *)-1;
    2326                 :            :         }
    2327                 :      28577 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2328                 :            :         {
    2329                 :          7 :           fprintf (dump_file, "Inserting name ");
    2330                 :          7 :           print_generic_expr (dump_file, result);
    2331                 :          7 :           fprintf (dump_file, " for expression ");
    2332                 :          7 :           print_gimple_expr (dump_file, new_stmt, 0, TDF_SLIM);
    2333                 :          7 :           fprintf (dump_file, "\n");
    2334                 :            :         }
    2335                 :            :     }
    2336                 :    3790260 :   return result;
    2337                 :            : }
    2338                 :            : 
    2339                 :            : /* Return a value-number for RCODE OPS... either by looking up an existing
    2340                 :            :    value-number for the simplified result or by inserting the operation.  */
    2341                 :            : 
    2342                 :            : static tree
    2343                 :      52847 : vn_nary_build_or_lookup (gimple_match_op *res_op)
    2344                 :            : {
    2345                 :          0 :   return vn_nary_build_or_lookup_1 (res_op, true);
    2346                 :            : }
    2347                 :            : 
    2348                 :            : /* Try to simplify the expression RCODE OPS... of type TYPE and return
    2349                 :            :    its value if present.  */
    2350                 :            : 
    2351                 :            : tree
    2352                 :    3737440 : vn_nary_simplify (vn_nary_op_t nary)
    2353                 :            : {
    2354                 :    3737440 :   if (nary->length > gimple_match_op::MAX_NUM_OPS)
    2355                 :            :     return NULL_TREE;
    2356                 :    3737420 :   gimple_match_op op (gimple_match_cond::UNCOND, nary->opcode,
    2357                 :    3737420 :                       nary->type, nary->length);
    2358                 :    3737420 :   memcpy (op.ops, nary->op, sizeof (tree) * nary->length);
    2359                 :    3737420 :   return vn_nary_build_or_lookup_1 (&op, false);
    2360                 :            : }
    2361                 :            : 
    2362                 :            : /* Elimination engine.  */
    2363                 :            : 
    2364                 :            : class eliminate_dom_walker : public dom_walker
    2365                 :            : {
    2366                 :            : public:
    2367                 :            :   eliminate_dom_walker (cdi_direction, bitmap);
    2368                 :            :   ~eliminate_dom_walker ();
    2369                 :            : 
    2370                 :            :   virtual edge before_dom_children (basic_block);
    2371                 :            :   virtual void after_dom_children (basic_block);
    2372                 :            : 
    2373                 :            :   virtual tree eliminate_avail (basic_block, tree op);
    2374                 :            :   virtual void eliminate_push_avail (basic_block, tree op);
    2375                 :            :   tree eliminate_insert (basic_block, gimple_stmt_iterator *gsi, tree val);
    2376                 :            : 
    2377                 :            :   void eliminate_stmt (basic_block, gimple_stmt_iterator *);
    2378                 :            : 
    2379                 :            :   unsigned eliminate_cleanup (bool region_p = false);
    2380                 :            : 
    2381                 :            :   bool do_pre;
    2382                 :            :   unsigned int el_todo;
    2383                 :            :   unsigned int eliminations;
    2384                 :            :   unsigned int insertions;
    2385                 :            : 
    2386                 :            :   /* SSA names that had their defs inserted by PRE if do_pre.  */
    2387                 :            :   bitmap inserted_exprs;
    2388                 :            : 
    2389                 :            :   /* Blocks with statements that have had their EH properties changed.  */
    2390                 :            :   bitmap need_eh_cleanup;
    2391                 :            : 
    2392                 :            :   /* Blocks with statements that have had their AB properties changed.  */
    2393                 :            :   bitmap need_ab_cleanup;
    2394                 :            : 
    2395                 :            :   /* Local state for the eliminate domwalk.  */
    2396                 :            :   auto_vec<gimple *> to_remove;
    2397                 :            :   auto_vec<gimple *> to_fixup;
    2398                 :            :   auto_vec<tree> avail;
    2399                 :            :   auto_vec<tree> avail_stack;
    2400                 :            : };
    2401                 :            : 
    2402                 :            : /* Adaptor to the elimination engine using RPO availability.  */
    2403                 :            : 
    2404                 :    3767280 : class rpo_elim : public eliminate_dom_walker
    2405                 :            : {
    2406                 :            : public:
    2407                 :    3767280 :   rpo_elim(basic_block entry_)
    2408                 :    3767280 :     : eliminate_dom_walker (CDI_DOMINATORS, NULL), entry (entry_),
    2409                 :    7534550 :       m_avail_freelist (NULL) {}
    2410                 :            : 
    2411                 :            :   virtual tree eliminate_avail (basic_block, tree op);
    2412                 :            : 
    2413                 :            :   virtual void eliminate_push_avail (basic_block, tree);
    2414                 :            : 
    2415                 :            :   basic_block entry;
    2416                 :            :   /* Freelist of avail entries which are allocated from the vn_ssa_aux
    2417                 :            :      obstack.  */
    2418                 :            :   vn_avail *m_avail_freelist;
    2419                 :            : };
    2420                 :            : 
    2421                 :            : /* Global RPO state for access from hooks.  */
    2422                 :            : static rpo_elim *rpo_avail;
    2423                 :            : basic_block vn_context_bb;
    2424                 :            : 
    2425                 :            : /* Return true if BASE1 and BASE2 can be adjusted so they have the
    2426                 :            :    same address and adjust *OFFSET1 and *OFFSET2 accordingly.
    2427                 :            :    Otherwise return false.  */
    2428                 :            : 
    2429                 :            : static bool
    2430                 :    3307030 : adjust_offsets_for_equal_base_address (tree base1, poly_int64 *offset1,
    2431                 :            :                                        tree base2, poly_int64 *offset2)
    2432                 :            : {
    2433                 :    3307030 :   poly_int64 soff;
    2434                 :    3307030 :   if (TREE_CODE (base1) == MEM_REF
    2435                 :    1508170 :       && TREE_CODE (base2) == MEM_REF)
    2436                 :            :     {
    2437                 :    2541180 :       if (mem_ref_offset (base1).to_shwi (&soff))
    2438                 :            :         {
    2439                 :    1270590 :           base1 = TREE_OPERAND (base1, 0);
    2440                 :    1270590 :           *offset1 += soff * BITS_PER_UNIT;
    2441                 :            :         }
    2442                 :    2541180 :       if (mem_ref_offset (base2).to_shwi (&soff))
    2443                 :            :         {
    2444                 :    1270590 :           base2 = TREE_OPERAND (base2, 0);
    2445                 :    1270590 :           *offset2 += soff * BITS_PER_UNIT;
    2446                 :            :         }
    2447                 :    1270590 :       return operand_equal_p (base1, base2, 0);
    2448                 :            :     }
    2449                 :    2036440 :   return operand_equal_p (base1, base2, OEP_ADDRESS_OF);
    2450                 :            : }
    2451                 :            : 
    2452                 :            : /* Callback for walk_non_aliased_vuses.  Tries to perform a lookup
    2453                 :            :    from the statement defining VUSE and if not successful tries to
    2454                 :            :    translate *REFP and VR_ through an aggregate copy at the definition
    2455                 :            :    of VUSE.  If *DISAMBIGUATE_ONLY is true then do not perform translation
    2456                 :            :    of *REF and *VR.  If only disambiguation was performed then
    2457                 :            :    *DISAMBIGUATE_ONLY is set to true.  */
    2458                 :            : 
    2459                 :            : static void *
    2460                 :   26039000 : vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *data_,
    2461                 :            :                        translate_flags *disambiguate_only)
    2462                 :            : {
    2463                 :   26039000 :   vn_walk_cb_data *data = (vn_walk_cb_data *)data_;
    2464                 :   26039000 :   vn_reference_t vr = data->vr;
    2465                 :   26039000 :   gimple *def_stmt = SSA_NAME_DEF_STMT (vuse);
    2466                 :   26039000 :   tree base = ao_ref_base (ref);
    2467                 :   26039000 :   HOST_WIDE_INT offseti = 0, maxsizei, sizei = 0;
    2468                 :   26039000 :   static vec<vn_reference_op_s> lhs_ops;
    2469                 :   26039000 :   ao_ref lhs_ref;
    2470                 :   26039000 :   bool lhs_ref_ok = false;
    2471                 :   26039000 :   poly_int64 copy_size;
    2472                 :            : 
    2473                 :            :   /* First try to disambiguate after value-replacing in the definitions LHS.  */
    2474                 :   26039000 :   if (is_gimple_assign (def_stmt))
    2475                 :            :     {
    2476                 :   10573400 :       tree lhs = gimple_assign_lhs (def_stmt);
    2477                 :   10573400 :       bool valueized_anything = false;
    2478                 :            :       /* Avoid re-allocation overhead.  */
    2479                 :   10573400 :       lhs_ops.truncate (0);
    2480                 :   10573400 :       basic_block saved_rpo_bb = vn_context_bb;
    2481                 :   10573400 :       vn_context_bb = gimple_bb (def_stmt);
    2482                 :   10573400 :       if (*disambiguate_only <= TR_VALUEIZE_AND_DISAMBIGUATE)
    2483                 :            :         {
    2484                 :    7751850 :           copy_reference_ops_from_ref (lhs, &lhs_ops);
    2485                 :    7751850 :           lhs_ops = valueize_refs_1 (lhs_ops, &valueized_anything, true);
    2486                 :            :         }
    2487                 :   10573400 :       vn_context_bb = saved_rpo_bb;
    2488                 :   10573400 :       ao_ref_init (&lhs_ref, lhs);
    2489                 :   10573400 :       lhs_ref_ok = true;
    2490                 :   10573400 :       if (valueized_anything
    2491                 :     692635 :           && ao_ref_init_from_vn_reference
    2492                 :     692635 :                (&lhs_ref, ao_ref_alias_set (&lhs_ref),
    2493                 :     692635 :                 ao_ref_base_alias_set (&lhs_ref), TREE_TYPE (lhs), lhs_ops)
    2494                 :   11265900 :           && !refs_may_alias_p_1 (ref, &lhs_ref, data->tbaa_p))
    2495                 :            :         {
    2496                 :     583249 :           *disambiguate_only = TR_VALUEIZE_AND_DISAMBIGUATE;
    2497                 :     583249 :           return NULL;
    2498                 :            :         }
    2499                 :            : 
    2500                 :            :       /* Besides valueizing the LHS we can also use access-path based
    2501                 :            :          disambiguation on the original non-valueized ref.  */
    2502                 :    9990120 :       if (!ref->ref
    2503                 :            :           && lhs_ref_ok
    2504                 :    1433150 :           && data->orig_ref.ref)
    2505                 :            :         {
    2506                 :            :           /* We want to use the non-valueized LHS for this, but avoid redundant
    2507                 :            :              work.  */
    2508                 :     730269 :           ao_ref *lref = &lhs_ref;
    2509                 :     730269 :           ao_ref lref_alt;
    2510                 :     730269 :           if (valueized_anything)
    2511                 :            :             {
    2512                 :      61340 :               ao_ref_init (&lref_alt, lhs);
    2513                 :      61340 :               lref = &lref_alt;
    2514                 :            :             }
    2515                 :     730269 :           if (!refs_may_alias_p_1 (&data->orig_ref, lref, data->tbaa_p))
    2516                 :            :             {
    2517                 :     308656 :               *disambiguate_only = (valueized_anything
    2518                 :     154328 :                                     ? TR_VALUEIZE_AND_DISAMBIGUATE
    2519                 :            :                                     : TR_DISAMBIGUATE);
    2520                 :     154328 :               return NULL;
    2521                 :            :             }
    2522                 :            :         }
    2523                 :            : 
    2524                 :            :       /* If we reach a clobbering statement try to skip it and see if
    2525                 :            :          we find a VN result with exactly the same value as the
    2526                 :            :          possible clobber.  In this case we can ignore the clobber
    2527                 :            :          and return the found value.  */
    2528                 :    9835790 :       if (is_gimple_reg_type (TREE_TYPE (lhs))
    2529                 :    5188030 :           && types_compatible_p (TREE_TYPE (lhs), vr->type)
    2530                 :   13762300 :           && ref->ref)
    2531                 :            :         {
    2532                 :    3207770 :           tree *saved_last_vuse_ptr = data->last_vuse_ptr;
    2533                 :            :           /* Do not update last_vuse_ptr in vn_reference_lookup_2.  */
    2534                 :    3207770 :           data->last_vuse_ptr = NULL;
    2535                 :    3207770 :           tree saved_vuse = vr->vuse;
    2536                 :    3207770 :           hashval_t saved_hashcode = vr->hashcode;
    2537                 :    6415540 :           void *res = vn_reference_lookup_2 (ref, gimple_vuse (def_stmt), data);
    2538                 :            :           /* Need to restore vr->vuse and vr->hashcode.  */
    2539                 :    3207770 :           vr->vuse = saved_vuse;
    2540                 :    3207770 :           vr->hashcode = saved_hashcode;
    2541                 :    3207770 :           data->last_vuse_ptr = saved_last_vuse_ptr;
    2542                 :    3207770 :           if (res && res != (void *)-1)
    2543                 :            :             {
    2544                 :     133326 :               vn_reference_t vnresult = (vn_reference_t) res;
    2545                 :     133326 :               tree rhs = gimple_assign_rhs1 (def_stmt);
    2546                 :     133326 :               if (TREE_CODE (rhs) == SSA_NAME)
    2547                 :     106592 :                 rhs = SSA_VAL (rhs);
    2548                 :     133326 :               if (vnresult->result
    2549                 :     133287 :                   && operand_equal_p (vnresult->result, rhs, 0)
    2550                 :            :                   /* We have to honor our promise about union type punning
    2551                 :            :                      and also support arbitrary overlaps with
    2552                 :            :                      -fno-strict-aliasing.  So simply resort to alignment to
    2553                 :            :                      rule out overlaps.  Do this check last because it is
    2554                 :            :                      quite expensive compared to the hash-lookup above.  */
    2555                 :      30741 :                   && multiple_p (get_object_alignment (ref->ref), ref->size)
    2556                 :   10706700 :                   && multiple_p (get_object_alignment (lhs), ref->size))
    2557                 :            :                 return res;
    2558                 :            :             }
    2559                 :            :         }
    2560                 :            :     }
    2561                 :   15465600 :   else if (*disambiguate_only <= TR_VALUEIZE_AND_DISAMBIGUATE
    2562                 :   14513800 :            && gimple_call_builtin_p (def_stmt, BUILT_IN_NORMAL)
    2563                 :   16846200 :            && gimple_call_num_args (def_stmt) <= 4)
    2564                 :            :     {
    2565                 :            :       /* For builtin calls valueize its arguments and call the
    2566                 :            :          alias oracle again.  Valueization may improve points-to
    2567                 :            :          info of pointers and constify size and position arguments.
    2568                 :            :          Originally this was motivated by PR61034 which has
    2569                 :            :          conditional calls to free falsely clobbering ref because
    2570                 :            :          of imprecise points-to info of the argument.  */
    2571                 :            :       tree oldargs[4];
    2572                 :            :       bool valueized_anything = false;
    2573                 :    3503790 :       for (unsigned i = 0; i < gimple_call_num_args (def_stmt); ++i)
    2574                 :            :         {
    2575                 :    2425920 :           oldargs[i] = gimple_call_arg (def_stmt, i);
    2576                 :    2425920 :           tree val = vn_valueize (oldargs[i]);
    2577                 :    2425920 :           if (val != oldargs[i])
    2578                 :            :             {
    2579                 :     109870 :               gimple_call_set_arg (def_stmt, i, val);
    2580                 :     109870 :               valueized_anything = true;
    2581                 :            :             }
    2582                 :            :         }
    2583                 :    1077870 :       if (valueized_anything)
    2584                 :            :         {
    2585                 :      75173 :           bool res = call_may_clobber_ref_p_1 (as_a <gcall *> (def_stmt),
    2586                 :            :                                                ref);
    2587                 :     281259 :           for (unsigned i = 0; i < gimple_call_num_args (def_stmt); ++i)
    2588                 :     206086 :             gimple_call_set_arg (def_stmt, i, oldargs[i]);
    2589                 :      75173 :           if (!res)
    2590                 :            :             {
    2591                 :      13517 :               *disambiguate_only = TR_VALUEIZE_AND_DISAMBIGUATE;
    2592                 :      13517 :               return NULL;
    2593                 :            :             }
    2594                 :            :         }
    2595                 :            :     }
    2596                 :            : 
    2597                 :   25258900 :   if (*disambiguate_only > TR_TRANSLATE)
    2598                 :            :     return (void *)-1;
    2599                 :            : 
    2600                 :            :   /* If we cannot constrain the size of the reference we cannot
    2601                 :            :      test if anything kills it.  */
    2602                 :   17568700 :   if (!ref->max_size_known_p ())
    2603                 :            :     return (void *)-1;
    2604                 :            : 
    2605                 :   17286900 :   poly_int64 offset = ref->offset;
    2606                 :   17286900 :   poly_int64 maxsize = ref->max_size;
    2607                 :            : 
    2608                 :            :   /* def_stmt may-defs *ref.  See if we can derive a value for *ref
    2609                 :            :      from that definition.
    2610                 :            :      1) Memset.  */
    2611                 :   17286900 :   if (is_gimple_reg_type (vr->type)
    2612                 :   17036400 :       && (gimple_call_builtin_p (def_stmt, BUILT_IN_MEMSET)
    2613                 :   16982800 :           || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMSET_CHK))
    2614                 :      53976 :       && (integer_zerop (gimple_call_arg (def_stmt, 1))
    2615                 :      22783 :           || ((TREE_CODE (gimple_call_arg (def_stmt, 1)) == INTEGER_CST
    2616                 :       8009 :                || (INTEGRAL_TYPE_P (vr->type) && known_eq (ref->size, 8)))
    2617                 :            :               && CHAR_BIT == 8
    2618                 :            :               && BITS_PER_UNIT == 8
    2619                 :            :               && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
    2620                 :      22512 :               && offset.is_constant (&offseti)
    2621                 :      22512 :               && ref->size.is_constant (&sizei)
    2622                 :      22512 :               && (offseti % BITS_PER_UNIT == 0
    2623                 :         39 :                   || TREE_CODE (gimple_call_arg (def_stmt, 1)) == INTEGER_CST)))
    2624                 :      53705 :       && (poly_int_tree_p (gimple_call_arg (def_stmt, 2))
    2625                 :      21552 :           || (TREE_CODE (gimple_call_arg (def_stmt, 2)) == SSA_NAME
    2626                 :      21552 :               && poly_int_tree_p (SSA_VAL (gimple_call_arg (def_stmt, 2)))))
    2627                 :   17319400 :       && (TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR
    2628                 :      21960 :           || TREE_CODE (gimple_call_arg (def_stmt, 0)) == SSA_NAME))
    2629                 :            :     {
    2630                 :      32530 :       tree base2;
    2631                 :      32530 :       poly_int64 offset2, size2, maxsize2;
    2632                 :      32530 :       bool reverse;
    2633                 :      32530 :       tree ref2 = gimple_call_arg (def_stmt, 0);
    2634                 :      32530 :       if (TREE_CODE (ref2) == SSA_NAME)
    2635                 :            :         {
    2636                 :      21960 :           ref2 = SSA_VAL (ref2);
    2637                 :      21960 :           if (TREE_CODE (ref2) == SSA_NAME
    2638                 :      21960 :               && (TREE_CODE (base) != MEM_REF
    2639                 :      12915 :                   || TREE_OPERAND (base, 0) != ref2))
    2640                 :            :             {
    2641                 :      17973 :               gimple *def_stmt = SSA_NAME_DEF_STMT (ref2);
    2642                 :      17973 :               if (gimple_assign_single_p (def_stmt)
    2643                 :        819 :                   && gimple_assign_rhs_code (def_stmt) == ADDR_EXPR)
    2644                 :        538 :                 ref2 = gimple_assign_rhs1 (def_stmt);
    2645                 :            :             }
    2646                 :            :         }
    2647                 :      32530 :       if (TREE_CODE (ref2) == ADDR_EXPR)
    2648                 :            :         {
    2649                 :      14078 :           ref2 = TREE_OPERAND (ref2, 0);
    2650                 :      14078 :           base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2,
    2651                 :            :                                            &reverse);
    2652                 :      14078 :           if (!known_size_p (maxsize2)
    2653                 :      14029 :               || !known_eq (maxsize2, size2)
    2654                 :      28033 :               || !operand_equal_p (base, base2, OEP_ADDRESS_OF))
    2655                 :       3139 :             return (void *)-1;
    2656                 :            :         }
    2657                 :      18452 :       else if (TREE_CODE (ref2) == SSA_NAME)
    2658                 :            :         {
    2659                 :      18452 :           poly_int64 soff;
    2660                 :      18452 :           if (TREE_CODE (base) != MEM_REF
    2661                 :      18452 :               || !(mem_ref_offset (base)
    2662                 :      12449 :                    << LOG2_BITS_PER_UNIT).to_shwi (&soff))
    2663                 :      32349 :             return (void *)-1;
    2664                 :      12448 :           offset += soff;
    2665                 :      12448 :           offset2 = 0;
    2666                 :      12448 :           if (TREE_OPERAND (base, 0) != ref2)
    2667                 :            :             {
    2668                 :      11432 :               gimple *def = SSA_NAME_DEF_STMT (ref2);
    2669                 :      11432 :               if (is_gimple_assign (def)
    2670                 :      10614 :                   && gimple_assign_rhs_code (def) == POINTER_PLUS_EXPR
    2671                 :       8955 :                   && gimple_assign_rhs1 (def) == TREE_OPERAND (base, 0)
    2672                 :      11491 :                   && poly_int_tree_p (gimple_assign_rhs2 (def)))
    2673                 :            :                 {
    2674                 :         26 :                   tree rhs2 = gimple_assign_rhs2 (def);
    2675                 :         26 :                   if (!(poly_offset_int::from (wi::to_poly_wide (rhs2),
    2676                 :         26 :                                                SIGNED)
    2677                 :         26 :                         << LOG2_BITS_PER_UNIT).to_shwi (&offset2))
    2678                 :            :                     return (void *)-1;
    2679                 :         26 :                   ref2 = gimple_assign_rhs1 (def);
    2680                 :         26 :                   if (TREE_CODE (ref2) == SSA_NAME)
    2681                 :         26 :                     ref2 = SSA_VAL (ref2);
    2682                 :            :                 }
    2683                 :            :               else
    2684                 :            :                 return (void *)-1;
    2685                 :            :             }
    2686                 :            :         }
    2687                 :            :       else
    2688                 :            :         return (void *)-1;
    2689                 :      11981 :       tree len = gimple_call_arg (def_stmt, 2);
    2690                 :      11981 :       HOST_WIDE_INT leni, offset2i;
    2691                 :      11981 :       if (TREE_CODE (len) == SSA_NAME)
    2692                 :        135 :         len = SSA_VAL (len);
    2693                 :            :       /* Sometimes the above trickery is smarter than alias analysis.  Take
    2694                 :            :          advantage of that.  */
    2695                 :      11981 :       if (!ranges_maybe_overlap_p (offset, maxsize, offset2,
    2696                 :      23962 :                                    (wi::to_poly_offset (len)
    2697                 :      11981 :                                     << LOG2_BITS_PER_UNIT)))
    2698                 :            :         return NULL;
    2699                 :      11981 :       if (data->partial_defs.is_empty ()
    2700                 :      11970 :           && known_subrange_p (offset, maxsize, offset2,
    2701                 :      11970 :                                wi::to_poly_offset (len) << LOG2_BITS_PER_UNIT))
    2702                 :            :         {
    2703                 :      11772 :           tree val;
    2704                 :      11772 :           if (integer_zerop (gimple_call_arg (def_stmt, 1)))
    2705                 :       9048 :             val = build_zero_cst (vr->type);
    2706                 :       2724 :           else if (INTEGRAL_TYPE_P (vr->type)
    2707                 :       2516 :                    && known_eq (ref->size, 8)
    2708                 :       4768 :                    && offseti % BITS_PER_UNIT == 0)
    2709                 :            :             {
    2710                 :       2044 :               gimple_match_op res_op (gimple_match_cond::UNCOND, NOP_EXPR,
    2711                 :       2044 :                                       vr->type, gimple_call_arg (def_stmt, 1));
    2712                 :       2044 :               val = vn_nary_build_or_lookup (&res_op);
    2713                 :       2044 :               if (!val
    2714                 :       2044 :                   || (TREE_CODE (val) == SSA_NAME
    2715                 :        628 :                       && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val)))
    2716                 :          0 :                 return (void *)-1;
    2717                 :            :             }
    2718                 :            :           else
    2719                 :            :             {
    2720                 :        680 :               unsigned buflen = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (vr->type)) + 1;
    2721                 :        680 :               if (INTEGRAL_TYPE_P (vr->type))
    2722                 :        944 :                 buflen = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (vr->type)) + 1;
    2723                 :        680 :               unsigned char *buf = XALLOCAVEC (unsigned char, buflen);
    2724                 :        680 :               memset (buf, TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 1)),
    2725                 :            :                       buflen);
    2726                 :        680 :               if (BYTES_BIG_ENDIAN)
    2727                 :            :                 {
    2728                 :            :                   unsigned int amnt
    2729                 :            :                     = (((unsigned HOST_WIDE_INT) offseti + sizei)
    2730                 :            :                        % BITS_PER_UNIT);
    2731                 :            :                   if (amnt)
    2732                 :            :                     {
    2733                 :            :                       shift_bytes_in_array_right (buf, buflen,
    2734                 :            :                                                   BITS_PER_UNIT - amnt);
    2735                 :            :                       buf++;
    2736                 :            :                       buflen--;
    2737                 :            :                     }
    2738                 :            :                 }
    2739                 :        680 :               else if (offseti % BITS_PER_UNIT != 0)
    2740                 :            :                 {
    2741                 :          7 :                   unsigned int amnt
    2742                 :            :                     = BITS_PER_UNIT - ((unsigned HOST_WIDE_INT) offseti
    2743                 :          7 :                                        % BITS_PER_UNIT);
    2744                 :          7 :                   shift_bytes_in_array_left (buf, buflen, amnt);
    2745                 :          7 :                   buf++;
    2746                 :          7 :                   buflen--;
    2747                 :            :                 }
    2748                 :        680 :               val = native_interpret_expr (vr->type, buf, buflen);
    2749                 :        680 :               if (!val)
    2750                 :            :                 return (void *)-1;
    2751                 :            :             }
    2752                 :      11772 :           return data->finish (0, 0, val);
    2753                 :            :         }
    2754                 :            :       /* For now handle clearing memory with partial defs.  */
    2755                 :        209 :       else if (known_eq (ref->size, maxsize)
    2756                 :        138 :                && integer_zerop (gimple_call_arg (def_stmt, 1))
    2757                 :         32 :                && tree_fits_poly_int64_p (len)
    2758                 :         28 :                && tree_to_poly_int64 (len).is_constant (&leni)
    2759                 :         28 :                && leni <= INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT
    2760                 :         28 :                && offset.is_constant (&offseti)
    2761                 :         28 :                && offset2.is_constant (&offset2i)
    2762                 :         28 :                && maxsize.is_constant (&maxsizei)
    2763                 :        347 :                && ranges_known_overlap_p (offseti, maxsizei, offset2i,
    2764                 :         28 :                                           leni << LOG2_BITS_PER_UNIT))
    2765                 :            :         {
    2766                 :         28 :           pd_data pd;
    2767                 :         28 :           pd.rhs = build_constructor (NULL_TREE, NULL);
    2768                 :         28 :           pd.offset = offset2i;
    2769                 :         28 :           pd.size = leni << LOG2_BITS_PER_UNIT;
    2770                 :         28 :           return data->push_partial_def (pd, 0, 0, offseti, maxsizei);
    2771                 :            :         }
    2772                 :            :     }
    2773                 :            : 
    2774                 :            :   /* 2) Assignment from an empty CONSTRUCTOR.  */
    2775                 :   17254300 :   else if (is_gimple_reg_type (vr->type)
    2776                 :   20616900 :            && gimple_assign_single_p (def_stmt)
    2777                 :    5391340 :            && gimple_assign_rhs_code (def_stmt) == CONSTRUCTOR
    2778                 :   19283100 :            && CONSTRUCTOR_NELTS (gimple_assign_rhs1 (def_stmt)) == 0)
    2779                 :            :     {
    2780                 :    2028780 :       tree base2;
    2781                 :    2028780 :       poly_int64 offset2, size2, maxsize2;
    2782                 :    2028780 :       HOST_WIDE_INT offset2i, size2i;
    2783                 :    2028780 :       gcc_assert (lhs_ref_ok);
    2784                 :    2028780 :       base2 = ao_ref_base (&lhs_ref);
    2785                 :    2028780 :       offset2 = lhs_ref.offset;
    2786                 :    2028780 :       size2 = lhs_ref.size;
    2787                 :    2028780 :       maxsize2 = lhs_ref.max_size;
    2788                 :    2028780 :       if (known_size_p (maxsize2)
    2789                 :    2028480 :           && known_eq (maxsize2, size2)
    2790                 :    4056560 :           && adjust_offsets_for_equal_base_address (base, &offset,
    2791                 :            :                                                     base2, &offset2))
    2792                 :            :         {
    2793                 :    1873400 :           if (data->partial_defs.is_empty ()
    2794                 :    1873400 :               && known_subrange_p (offset, maxsize, offset2, size2))
    2795                 :            :             {
    2796                 :            :               /* While technically undefined behavior do not optimize
    2797                 :            :                  a full read from a clobber.  */
    2798                 :    1873230 :               if (gimple_clobber_p (def_stmt))
    2799                 :    1873380 :                 return (void *)-1;
    2800                 :     521309 :               tree val = build_zero_cst (vr->type);
    2801                 :     521309 :               return data->finish (ao_ref_alias_set (&lhs_ref),
    2802                 :     521309 :                                    ao_ref_base_alias_set (&lhs_ref), val);
    2803                 :            :             }
    2804                 :        174 :           else if (known_eq (ref->size, maxsize)
    2805                 :        152 :                    && maxsize.is_constant (&maxsizei)
    2806                 :        152 :                    && offset.is_constant (&offseti)
    2807                 :        152 :                    && offset2.is_constant (&offset2i)
    2808                 :        152 :                    && size2.is_constant (&size2i)
    2809                 :        326 :                    && ranges_known_overlap_p (offseti, maxsizei,
    2810                 :            :                                               offset2i, size2i))
    2811                 :            :             {
    2812                 :            :               /* Let clobbers be consumed by the partial-def tracker
    2813                 :            :                  which can choose to ignore them if they are shadowed
    2814                 :            :                  by a later def.  */
    2815                 :        152 :               pd_data pd;
    2816                 :        152 :               pd.rhs = gimple_assign_rhs1 (def_stmt);
    2817                 :        152 :               pd.offset = offset2i;
    2818                 :        152 :               pd.size = size2i;
    2819                 :        152 :               return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
    2820                 :            :                                              ao_ref_base_alias_set (&lhs_ref),
    2821                 :            :                                              offseti, maxsizei);
    2822                 :            :             }
    2823                 :            :         }
    2824                 :            :     }
    2825                 :            : 
    2826                 :            :   /* 3) Assignment from a constant.  We can use folds native encode/interpret
    2827                 :            :      routines to extract the assigned bits.  */
    2828                 :   15225600 :   else if (known_eq (ref->size, maxsize)
    2829                 :   14880800 :            && is_gimple_reg_type (vr->type)
    2830                 :   14630300 :            && !contains_storage_order_barrier_p (vr->operands)
    2831                 :   15225600 :            && gimple_assign_single_p (def_stmt)
    2832                 :            :            && CHAR_BIT == 8
    2833                 :            :            && BITS_PER_UNIT == 8
    2834                 :            :            && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
    2835                 :            :            /* native_encode and native_decode operate on arrays of bytes
    2836                 :            :               and so fundamentally need a compile-time size and offset.  */
    2837                 :    3160990 :            && maxsize.is_constant (&maxsizei)
    2838                 :    3160990 :            && offset.is_constant (&offseti)
    2839                 :   18386500 :            && (is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt))
    2840                 :    2774820 :                || (TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
    2841                 :     981113 :                    && is_gimple_min_invariant (SSA_VAL (gimple_assign_rhs1 (def_stmt))))))
    2842                 :            :     {
    2843                 :     393367 :       tree lhs = gimple_assign_lhs (def_stmt);
    2844                 :     393367 :       tree base2;
    2845                 :     393367 :       poly_int64 offset2, size2, maxsize2;
    2846                 :     393367 :       HOST_WIDE_INT offset2i, size2i;
    2847                 :     393367 :       bool reverse;
    2848                 :     393367 :       gcc_assert (lhs_ref_ok);
    2849                 :     393367 :       base2 = ao_ref_base (&lhs_ref);
    2850                 :     393367 :       offset2 = lhs_ref.offset;
    2851                 :     393367 :       size2 = lhs_ref.size;
    2852                 :     393367 :       maxsize2 = lhs_ref.max_size;
    2853                 :     393367 :       reverse = reverse_storage_order_for_component_p (lhs);
    2854                 :     393367 :       if (base2
    2855                 :     393367 :           && !reverse
    2856                 :     393317 :           && !storage_order_barrier_p (lhs)
    2857                 :     393317 :           && known_eq (maxsize2, size2)
    2858                 :     375164 :           && adjust_offsets_for_equal_base_address (base, &offset,
    2859                 :            :                                                     base2, &offset2)
    2860                 :      40426 :           && offset.is_constant (&offseti)
    2861                 :      40426 :           && offset2.is_constant (&offset2i)
    2862                 :     433793 :           && size2.is_constant (&size2i))
    2863                 :            :         {
    2864                 :      40426 :           if (data->partial_defs.is_empty ()
    2865                 :      40426 :               && known_subrange_p (offseti, maxsizei, offset2, size2))
    2866                 :            :             {
    2867                 :            :               /* We support up to 512-bit values (for V8DFmode).  */
    2868                 :      25587 :               unsigned char buffer[65];
    2869                 :      25587 :               int len;
    2870                 :            : 
    2871                 :      25587 :               tree rhs = gimple_assign_rhs1 (def_stmt);
    2872                 :      25587 :               if (TREE_CODE (rhs) == SSA_NAME)
    2873                 :        620 :                 rhs = SSA_VAL (rhs);
    2874                 :      51174 :               len = native_encode_expr (rhs,
    2875                 :            :                                         buffer, sizeof (buffer) - 1,
    2876                 :      25587 :                                         (offseti - offset2i) / BITS_PER_UNIT);
    2877                 :      25587 :               if (len > 0 && len * BITS_PER_UNIT >= maxsizei)
    2878                 :            :                 {
    2879                 :      22616 :                   tree type = vr->type;
    2880                 :      22616 :                   unsigned char *buf = buffer;
    2881                 :      22616 :                   unsigned int amnt = 0;
    2882                 :            :                   /* Make sure to interpret in a type that has a range
    2883                 :            :                      covering the whole access size.  */
    2884                 :      22616 :                   if (INTEGRAL_TYPE_P (vr->type)
    2885                 :      22616 :                       && maxsizei != TYPE_PRECISION (vr->type))
    2886                 :       1399 :                     type = build_nonstandard_integer_type (maxsizei,
    2887                 :       1399 :                                                            TYPE_UNSIGNED (type));
    2888                 :      22616 :                   if (BYTES_BIG_ENDIAN)
    2889                 :            :                     {
    2890                 :            :                       /* For big-endian native_encode_expr stored the rhs
    2891                 :            :                          such that the LSB of it is the LSB of buffer[len - 1].
    2892                 :            :                          That bit is stored into memory at position
    2893                 :            :                          offset2 + size2 - 1, i.e. in byte
    2894                 :            :                          base + (offset2 + size2 - 1) / BITS_PER_UNIT.
    2895                 :            :                          E.g. for offset2 1 and size2 14, rhs -1 and memory
    2896                 :            :                          previously cleared that is:
    2897                 :            :                          0        1
    2898                 :            :                          01111111|11111110
    2899                 :            :                          Now, if we want to extract offset 2 and size 12 from
    2900                 :            :                          it using native_interpret_expr (which actually works
    2901                 :            :                          for integral bitfield types in terms of byte size of
    2902                 :            :                          the mode), the native_encode_expr stored the value
    2903                 :            :                          into buffer as
    2904                 :            :                          XX111111|11111111
    2905                 :            :                          and returned len 2 (the X bits are outside of
    2906                 :            :                          precision).
    2907                 :            :                          Let sz be maxsize / BITS_PER_UNIT if not extracting
    2908                 :            :                          a bitfield, and GET_MODE_SIZE otherwise.
    2909                 :            :                          We need to align the LSB of the value we want to
    2910                 :            :                          extract as the LSB of buf[sz - 1].
    2911                 :            :                          The LSB from memory we need to read is at position
    2912                 :            :                          offset + maxsize - 1.  */
    2913                 :            :                       HOST_WIDE_INT sz = maxsizei / BITS_PER_UNIT;
    2914                 :            :                       if (INTEGRAL_TYPE_P (type))
    2915                 :            :                         sz = GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type));
    2916                 :            :                       amnt = ((unsigned HOST_WIDE_INT) offset2i + size2i
    2917                 :            :                               - offseti - maxsizei) % BITS_PER_UNIT;
    2918                 :            :                       if (amnt)
    2919                 :            :                         shift_bytes_in_array_right (buffer, len, amnt);
    2920                 :            :                       amnt = ((unsigned HOST_WIDE_INT) offset2i + size2i
    2921                 :            :                               - offseti - maxsizei - amnt) / BITS_PER_UNIT;
    2922                 :            :                       if ((unsigned HOST_WIDE_INT) sz + amnt > (unsigned) len)
    2923                 :            :                         len = 0;
    2924                 :            :                       else
    2925                 :            :                         {
    2926                 :            :                           buf = buffer + len - sz - amnt;
    2927                 :            :                           len -= (buf - buffer);
    2928                 :            :                         }
    2929                 :            :                     }
    2930                 :            :                   else
    2931                 :            :                     {
    2932                 :      22616 :                       amnt = ((unsigned HOST_WIDE_INT) offset2i
    2933                 :      22616 :                               - offseti) % BITS_PER_UNIT;
    2934                 :      22616 :                       if (amnt)
    2935                 :            :                         {
    2936                 :        314 :                           buffer[len] = 0;
    2937                 :        314 :                           shift_bytes_in_array_left (buffer, len + 1, amnt);
    2938                 :        314 :                           buf = buffer + 1;
    2939                 :            :                         }
    2940                 :            :                     }
    2941                 :      22616 :                   tree val = native_interpret_expr (type, buf, len);
    2942                 :            :                   /* If we chop off bits because the types precision doesn't
    2943                 :            :                      match the memory access size this is ok when optimizing
    2944                 :            :                      reads but not when called from the DSE code during
    2945                 :            :                      elimination.  */
    2946                 :      22616 :                   if (val
    2947                 :      22616 :                       && type != vr->type)
    2948                 :            :                     {
    2949                 :       1399 :                       if (! int_fits_type_p (val, vr->type))
    2950                 :            :                         val = NULL_TREE;
    2951                 :            :                       else
    2952                 :       1399 :                         val = fold_convert (vr->type, val);
    2953                 :            :                     }
    2954                 :            : 
    2955                 :      22616 :                   if (val)
    2956                 :      22616 :                     return data->finish (ao_ref_alias_set (&lhs_ref),
    2957                 :      22616 :                                          ao_ref_base_alias_set (&lhs_ref), val);
    2958                 :            :                 }
    2959                 :            :             }
    2960                 :     370751 :           else if (ranges_known_overlap_p (offseti, maxsizei, offset2i,
    2961                 :            :                                            size2i))
    2962                 :            :             {
    2963                 :      14839 :               pd_data pd;
    2964                 :      14839 :               tree rhs = gimple_assign_rhs1 (def_stmt);
    2965                 :      14839 :               if (TREE_CODE (rhs) == SSA_NAME)
    2966                 :       1679 :                 rhs = SSA_VAL (rhs);
    2967                 :      14839 :               pd.rhs = rhs;
    2968                 :      14839 :               pd.offset = offset2i;
    2969                 :      14839 :               pd.size = size2i;
    2970                 :      14839 :               return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
    2971                 :            :                                              ao_ref_base_alias_set (&lhs_ref),
    2972                 :            :                                              offseti, maxsizei);
    2973                 :            :             }
    2974                 :            :         }
    2975                 :            :     }
    2976                 :            : 
    2977                 :            :   /* 4) Assignment from an SSA name which definition we may be able
    2978                 :            :      to access pieces from or we can combine to a larger entity.  */
    2979                 :   14832200 :   else if (known_eq (ref->size, maxsize)
    2980                 :   14487400 :            && is_gimple_reg_type (vr->type)
    2981                 :   14236900 :            && !contains_storage_order_barrier_p (vr->operands)
    2982                 :    2767630 :            && gimple_assign_single_p (def_stmt)
    2983                 :   17599800 :            && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
    2984                 :            :     {
    2985                 :     973919 :       tree lhs = gimple_assign_lhs (def_stmt);
    2986                 :     973919 :       tree base2;
    2987                 :     973919 :       poly_int64 offset2, size2, maxsize2;
    2988                 :     973919 :       HOST_WIDE_INT offset2i, size2i, offseti;
    2989                 :     973919 :       bool reverse;
    2990                 :     973919 :       gcc_assert (lhs_ref_ok);
    2991                 :     973919 :       base2 = ao_ref_base (&lhs_ref);
    2992                 :     973919 :       offset2 = lhs_ref.offset;
    2993                 :     973919 :       size2 = lhs_ref.size;
    2994                 :     973919 :       maxsize2 = lhs_ref.max_size;
    2995                 :     973919 :       reverse = reverse_storage_order_for_component_p (lhs);
    2996                 :     973919 :       tree def_rhs = gimple_assign_rhs1 (def_stmt);
    2997                 :     973919 :       if (!reverse
    2998                 :     973895 :           && !storage_order_barrier_p (lhs)
    2999                 :     973895 :           && known_size_p (maxsize2)
    3000                 :     961498 :           && known_eq (maxsize2, size2)
    3001                 :    1878000 :           && adjust_offsets_for_equal_base_address (base, &offset,
    3002                 :            :                                                     base2, &offset2))
    3003                 :            :         {
    3004                 :      56979 :           if (data->partial_defs.is_empty ()
    3005                 :      58692 :               && known_subrange_p (offset, maxsize, offset2, size2)
    3006                 :            :               /* ???  We can't handle bitfield precision extracts without
    3007                 :            :                  either using an alternate type for the BIT_FIELD_REF and
    3008                 :            :                  then doing a conversion or possibly adjusting the offset
    3009                 :            :                  according to endianness.  */
    3010                 :      36337 :               && (! INTEGRAL_TYPE_P (vr->type)
    3011                 :      26257 :                   || known_eq (ref->size, TYPE_PRECISION (vr->type)))
    3012                 :      70487 :               && multiple_p (ref->size, BITS_PER_UNIT))
    3013                 :            :             {
    3014                 :      34624 :               tree val = NULL_TREE;
    3015                 :      69248 :               if (! INTEGRAL_TYPE_P (TREE_TYPE (def_rhs))
    3016                 :      38042 :                   || type_has_mode_precision_p (TREE_TYPE (def_rhs)))
    3017                 :            :                 {
    3018                 :            :                   gimple_match_op op (gimple_match_cond::UNCOND,
    3019                 :            :                                       BIT_FIELD_REF, vr->type,
    3020                 :            :                                       SSA_VAL (def_rhs),
    3021                 :            :                                       bitsize_int (ref->size),
    3022                 :      33837 :                                       bitsize_int (offset - offset2));
    3023                 :      33837 :                   val = vn_nary_build_or_lookup (&op);
    3024                 :            :                 }
    3025                 :        787 :               else if (known_eq (ref->size, size2))
    3026                 :            :                 {
    3027                 :        765 :                   gimple_match_op op (gimple_match_cond::UNCOND,
    3028                 :            :                                       VIEW_CONVERT_EXPR, vr->type,
    3029                 :        765 :                                       SSA_VAL (def_rhs));
    3030                 :        765 :                   val = vn_nary_build_or_lookup (&op);
    3031                 :            :                 }
    3032                 :      34602 :               if (val
    3033                 :      34602 :                   && (TREE_CODE (val) != SSA_NAME
    3034                 :      34218 :                       || ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val)))
    3035                 :      34583 :                 return data->finish (ao_ref_alias_set (&lhs_ref),
    3036                 :      56914 :                                      ao_ref_base_alias_set (&lhs_ref), val);
    3037                 :            :             }
    3038                 :      44710 :           else if (maxsize.is_constant (&maxsizei)
    3039                 :      22355 :                    && offset.is_constant (&offseti)
    3040                 :      22355 :                    && offset2.is_constant (&offset2i)
    3041                 :      22355 :                    && size2.is_constant (&size2i)
    3042                 :      22355 :                    && ranges_known_overlap_p (offset, maxsize, offset2, size2))
    3043                 :            :             {
    3044                 :      22331 :               pd_data pd;
    3045                 :      22331 :               pd.rhs = SSA_VAL (def_rhs);
    3046                 :      22331 :               pd.offset = offset2i;
    3047                 :      22331 :               pd.size = size2i;
    3048                 :      22331 :               return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
    3049                 :            :                                              ao_ref_base_alias_set (&lhs_ref),
    3050                 :            :                                              offseti, maxsizei);
    3051                 :            :             }
    3052                 :            :         }
    3053                 :            :     }
    3054                 :            : 
    3055                 :            :   /* 5) For aggregate copies translate the reference through them if
    3056                 :            :      the copy kills ref.  */
    3057                 :   13858300 :   else if (data->vn_walk_kind == VN_WALKREWRITE
    3058                 :    1594940 :            && gimple_assign_single_p (def_stmt)
    3059                 :   15453200 :            && (DECL_P (gimple_assign_rhs1 (def_stmt))
    3060                 :    1325930 :                || TREE_CODE (gimple_assign_rhs1 (def_stmt)) == MEM_REF
    3061                 :    1206530 :                || handled_component_p (gimple_assign_rhs1 (def_stmt))))
    3062                 :            :     {
    3063                 :    1464850 :       tree base2;
    3064                 :    1464850 :       int i, j, k;
    3065                 :    2929710 :       auto_vec<vn_reference_op_s> rhs;
    3066                 :    1464850 :       vn_reference_op_t vro;
    3067                 :    1464850 :       ao_ref r;
    3068                 :            : 
    3069                 :    1464850 :       gcc_assert (lhs_ref_ok);
    3070                 :            : 
    3071                 :            :       /* See if the assignment kills REF.  */
    3072                 :    1464850 :       base2 = ao_ref_base (&lhs_ref);
    3073                 :    1464850 :       if (!lhs_ref.max_size_known_p ()
    3074                 :    1464560 :           || (base != base2
    3075                 :      53216 :               && (TREE_CODE (base) != MEM_REF
    3076                 :      39612 :                   || TREE_CODE (base2) != MEM_REF
    3077                 :      32686 :                   || TREE_OPERAND (base, 0) != TREE_OPERAND (base2, 0)
    3078                 :      10776 :                   || !tree_int_cst_equal (TREE_OPERAND (base, 1),
    3079                 :      10776 :                                           TREE_OPERAND (base2, 1))))
    3080                 :    2886260 :           || !stmt_kills_ref_p (def_stmt, ref))
    3081                 :     231680 :         return (void *)-1;
    3082                 :            : 
    3083                 :            :       /* Find the common base of ref and the lhs.  lhs_ops already
    3084                 :            :          contains valueized operands for the lhs.  */
    3085                 :    1233170 :       i = vr->operands.length () - 1;
    3086                 :    2466350 :       j = lhs_ops.length () - 1;
    3087                 :    3275230 :       while (j >= 0 && i >= 0
    3088                 :    3275230 :              && vn_reference_op_eq (&vr->operands[i], &lhs_ops[j]))
    3089                 :            :         {
    3090                 :    2042060 :           i--;
    3091                 :    2042060 :           j--;
    3092                 :            :         }
    3093                 :            : 
    3094                 :            :       /* ???  The innermost op should always be a MEM_REF and we already
    3095                 :            :          checked that the assignment to the lhs kills vr.  Thus for
    3096                 :            :          aggregate copies using char[] types the vn_reference_op_eq
    3097                 :            :          may fail when comparing types for compatibility.  But we really
    3098                 :            :          don't care here - further lookups with the rewritten operands
    3099                 :            :          will simply fail if we messed up types too badly.  */
    3100                 :    1233170 :       poly_int64 extra_off = 0;
    3101                 :    1233170 :       if (j == 0 && i >= 0
    3102                 :     424339 :           && lhs_ops[0].opcode == MEM_REF
    3103                 :    1655570 :           && maybe_ne (lhs_ops[0].off, -1))
    3104                 :            :         {
    3105                 :     422395 :           if (known_eq (lhs_ops[0].off, vr->operands[i].off))
    3106                 :     104654 :             i--, j--;
    3107                 :     317741 :           else if (vr->operands[i].opcode == MEM_REF
    3108                 :     317741 :                    && maybe_ne (vr->operands[i].off, -1))
    3109                 :            :             {
    3110                 :     315207 :               extra_off = vr->operands[i].off - lhs_ops[0].off;
    3111                 :     315207 :               i--, j--;
    3112                 :            :             }
    3113                 :            :         }
    3114                 :            : 
    3115                 :            :       /* i now points to the first additional op.
    3116                 :            :          ???  LHS may not be completely contained in VR, one or more
    3117                 :            :          VIEW_CONVERT_EXPRs could be in its way.  We could at least
    3118                 :            :          try handling outermost VIEW_CONVERT_EXPRs.  */
    3119                 :    1233170 :       if (j != -1)
    3120                 :            :         return (void *)-1;
    3121                 :            : 
    3122                 :            :       /* Punt if the additional ops contain a storage order barrier.  */
    3123                 :    2338020 :       for (k = i; k >= 0; k--)
    3124                 :            :         {
    3125                 :    1124650 :           vro = &vr->operands[k];
    3126                 :    1124650 :           if (vro->opcode == VIEW_CONVERT_EXPR && vro->reverse)
    3127                 :            :             return (void *)-1;
    3128                 :            :         }
    3129                 :            : 
    3130                 :            :       /* Now re-write REF to be based on the rhs of the assignment.  */
    3131                 :    1213380 :       tree rhs1 = gimple_assign_rhs1 (def_stmt);
    3132                 :    1213380 :       copy_reference_ops_from_ref (rhs1, &rhs);
    3133                 :            : 
    3134                 :            :       /* Apply an extra offset to the inner MEM_REF of the RHS.  */
    3135                 :    1213380 :       if (maybe_ne (extra_off, 0))
    3136                 :            :         {
    3137                 :     315207 :           if (rhs.length () < 2)
    3138                 :            :             return (void *)-1;
    3139                 :     315207 :           int ix = rhs.length () - 2;
    3140                 :     315207 :           if (rhs[ix].opcode != MEM_REF
    3141                 :     315207 :               || known_eq (rhs[ix].off, -1))
    3142                 :            :             return (void *)-1;
    3143                 :     315207 :           rhs[ix].off += extra_off;
    3144                 :     315207 :           rhs[ix].op0 = int_const_binop (PLUS_EXPR, rhs[ix].op0,
    3145                 :     315207 :                                          build_int_cst (TREE_TYPE (rhs[ix].op0),
    3146                 :            :                                                         extra_off));
    3147                 :            :         }
    3148                 :            : 
    3149                 :            :       /* Save the operands since we need to use the original ones for
    3150                 :            :          the hash entry we use.  */
    3151                 :    1213380 :       if (!data->saved_operands.exists ())
    3152                 :    2305800 :         data->saved_operands = vr->operands.copy ();
    3153                 :            : 
    3154                 :            :       /* We need to pre-pend vr->operands[0..i] to rhs.  */
    3155                 :    1213380 :       vec<vn_reference_op_s> old = vr->operands;
    3156                 :    3640130 :       if (i + 1 + rhs.length () > vr->operands.length ())
    3157                 :     909967 :         vr->operands.safe_grow (i + 1 + rhs.length ());
    3158                 :            :       else
    3159                 :     303409 :         vr->operands.truncate (i + 1 + rhs.length ());
    3160                 :    4567000 :       FOR_EACH_VEC_ELT (rhs, j, vro)
    3161                 :    3353620 :         vr->operands[i + 1 + j] = *vro;
    3162                 :    1213380 :       vr->operands = valueize_refs (vr->operands);
    3163                 :    2426750 :       if (old == shared_lookup_references)
    3164                 :    1213380 :         shared_lookup_references = vr->operands;
    3165                 :    1213380 :       vr->hashcode = vn_reference_compute_hash (vr);
    3166                 :            : 
    3167                 :            :       /* Try folding the new reference to a constant.  */
    3168                 :    1213380 :       tree val = fully_constant_vn_reference_p (vr);
    3169                 :    1213380 :       if (val)
    3170                 :            :         {
    3171                 :      13584 :           if (data->partial_defs.is_empty ())
    3172                 :      13581 :             return data->finish (ao_ref_alias_set (&lhs_ref),
    3173                 :      13581 :                                  ao_ref_base_alias_set (&lhs_ref), val);
    3174                 :            :           /* This is the only interesting case for partial-def handling
    3175                 :            :              coming from targets that like to gimplify init-ctors as
    3176                 :            :              aggregate copies from constant data like aarch64 for
    3177                 :            :              PR83518.  */
    3178                 :          3 :           if (maxsize.is_constant (&maxsizei) && known_eq (ref->size, maxsize))
    3179                 :            :             {
    3180                 :          3 :               pd_data pd;
    3181                 :          3 :               pd.rhs = val;
    3182                 :          3 :               pd.offset = 0;
    3183                 :          3 :               pd.size = maxsizei;
    3184                 :          3 :               return data->push_partial_def (pd, ao_ref_alias_set (&lhs_ref),
    3185                 :            :                                              ao_ref_base_alias_set (&lhs_ref),
    3186                 :            :                                              0, maxsizei);
    3187                 :            :             }
    3188                 :            :         }
    3189                 :            : 
    3190                 :            :       /* Continuing with partial defs isn't easily possible here, we
    3191                 :            :          have to find a full def from further lookups from here.  Probably
    3192                 :            :          not worth the special-casing everywhere.  */
    3193                 :    1199790 :       if (!data->partial_defs.is_empty ())
    3194                 :            :         return (void *)-1;
    3195                 :            : 
    3196                 :            :       /* Adjust *ref from the new operands.  */
    3197                 :    1197760 :       ao_ref rhs1_ref;
    3198                 :    1197760 :       ao_ref_init (&rhs1_ref, rhs1);
    3199                 :    1197760 :       if (!ao_ref_init_from_vn_reference (&r, ao_ref_alias_set (&rhs1_ref),
    3200                 :            :                                           ao_ref_base_alias_set (&rhs1_ref),
    3201                 :            :                                           vr->type, vr->operands))
    3202                 :            :         return (void *)-1;
    3203                 :            :       /* This can happen with bitfields.  */
    3204                 :    1197660 :       if (maybe_ne (ref->size, r.size))
    3205                 :            :         return (void *)-1;
    3206                 :    1184040 :       *ref = r;
    3207                 :            : 
    3208                 :            :       /* Do not update last seen VUSE after translating.  */
    3209                 :    1184040 :       data->last_vuse_ptr = NULL;
    3210                 :            :       /* Invalidate the original access path since it now contains
    3211                 :            :          the wrong base.  */
    3212                 :    1184040 :       data->orig_ref.ref = NULL_TREE;
    3213                 :            :       /* Use the alias-set of this LHS for recording an eventual result.  */
    3214                 :    1184040 :       if (data->first_set == -2)
    3215                 :            :         {
    3216                 :    1124200 :           data->first_set = ao_ref_alias_set (&lhs_ref);
    3217                 :    1124200 :           data->first_base_set = ao_ref_base_alias_set (&lhs_ref);
    3218                 :            :         }
    3219                 :            : 
    3220                 :            :       /* Keep looking for the adjusted *REF / VR pair.  */
    3221                 :    1184040 :       return NULL;
    3222                 :            :     }
    3223                 :            : 
    3224                 :            :   /* 6) For memcpy copies translate the reference through them if
    3225                 :            :      the copy kills ref.  */
    3226                 :   12393400 :   else if (data->vn_walk_kind == VN_WALKREWRITE
    3227                 :    9531930 :            && is_gimple_reg_type (vr->type)
    3228                 :            :            /* ???  Handle BCOPY as well.  */
    3229                 :    9523360 :            && (gimple_call_builtin_p (def_stmt, BUILT_IN_MEMCPY)
    3230                 :    9484650 :                || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMCPY_CHK)
    3231                 :    9484280 :                || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMPCPY)
    3232                 :    9483420 :                || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMPCPY_CHK)
    3233                 :    9483180 :                || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMMOVE)
    3234                 :    9463000 :                || gimple_call_builtin_p (def_stmt, BUILT_IN_MEMMOVE_CHK))
    3235                 :      60672 :            && (TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR
    3236                 :      56857 :                || TREE_CODE (gimple_call_arg (def_stmt, 0)) == SSA_NAME)
    3237                 :      60646 :            && (TREE_CODE (gimple_call_arg (def_stmt, 1)) == ADDR_EXPR
    3238                 :      42133 :                || TREE_CODE (gimple_call_arg (def_stmt, 1)) == SSA_NAME)
    3239                 :      60631 :            && (poly_int_tree_p (gimple_call_arg (def_stmt, 2), &copy_size)
    3240                 :      39461 :                || (TREE_CODE (gimple_call_arg (def_stmt, 2)) == SSA_NAME
    3241                 :      39461 :                    && poly_int_tree_p (SSA_VAL (gimple_call_arg (def_stmt, 2)),
    3242                 :            :                                        &copy_size)))
    3243                 :            :            /* Handling this is more complicated, give up for now.  */
    3244                 :   12415700 :            && data->partial_defs.is_empty ())
    3245                 :            :     {
    3246                 :      22078 :       tree lhs, rhs;
    3247                 :      22078 :       ao_ref r;
    3248                 :      22078 :       poly_int64 rhs_offset, lhs_offset;
    3249                 :      22078 :       vn_reference_op_s op;
    3250                 :      22078 :       poly_uint64 mem_offset;
    3251                 :      22078 :       poly_int64 at, byte_maxsize;
    3252                 :            : 
    3253                 :            :       /* Only handle non-variable, addressable refs.  */
    3254                 :      22078 :       if (maybe_ne (ref->size, maxsize)
    3255                 :      21979 :           || !multiple_p (offset, BITS_PER_UNIT, &at)
    3256                 :      44041 :           || !multiple_p (maxsize, BITS_PER_UNIT, &byte_maxsize))
    3257                 :        115 :         return (void *)-1;
    3258                 :            : 
    3259                 :            :       /* Extract a pointer base and an offset for the destination.  */
    3260                 :      21963 :       lhs = gimple_call_arg (def_stmt, 0);
    3261                 :      21963 :       lhs_offset = 0;
    3262                 :      21963 :       if (TREE_CODE (lhs) == SSA_NAME)
    3263                 :            :         {
    3264                 :      18627 :           lhs = vn_valueize (lhs);
    3265                 :      18627 :           if (TREE_CODE (lhs) == SSA_NAME)
    3266                 :            :             {
    3267                 :      18359 :               gimple *def_stmt = SSA_NAME_DEF_STMT (lhs);
    3268                 :      18359 :               if (gimple_assign_single_p (def_stmt)
    3269                 :       5218 :                   && gimple_assign_rhs_code (def_stmt) == ADDR_EXPR)
    3270                 :       2873 :                 lhs = gimple_assign_rhs1 (def_stmt);
    3271                 :            :             }
    3272                 :            :         }
    3273                 :      21963 :       if (TREE_CODE (lhs) == ADDR_EXPR)
    3274                 :            :         {
    3275                 :       6477 :           tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (lhs, 0),
    3276                 :            :                                                     &lhs_offset);
    3277                 :       6477 :           if (!tem)
    3278                 :            :             return (void *)-1;
    3279                 :       5666 :           if (TREE_CODE (tem) == MEM_REF
    3280                 :       5666 :               && poly_int_tree_p (TREE_OPERAND (tem, 1), &mem_offset))
    3281                 :            :             {
    3282                 :       2062 :               lhs = TREE_OPERAND (tem, 0);
    3283                 :       2062 :               if (TREE_CODE (lhs) == SSA_NAME)
    3284                 :       2062 :                 lhs = vn_valueize (lhs);
    3285                 :       2062 :               lhs_offset += mem_offset;
    3286                 :            :             }
    3287                 :       3604 :           else if (DECL_P (tem))
    3288                 :       3604 :             lhs = build_fold_addr_expr (tem);
    3289                 :            :           else
    3290                 :            :             return (void *)-1;
    3291                 :            :         }
    3292                 :      21152 :       if (TREE_CODE (lhs) != SSA_NAME
    3293                 :       3604 :           && TREE_CODE (lhs) != ADDR_EXPR)
    3294                 :            :         return (void *)-1;
    3295                 :            : 
    3296                 :            :       /* Extract a pointer base and an offset for the source.  */
    3297                 :      21152 :       rhs = gimple_call_arg (def_stmt, 1);
    3298                 :      21152 :       rhs_offset = 0;
    3299                 :      21152 :       if (TREE_CODE (rhs) == SSA_NAME)
    3300                 :       7018 :         rhs = vn_valueize (rhs);
    3301                 :      21152 :       if (TREE_CODE (rhs) == ADDR_EXPR)
    3302                 :            :         {
    3303                 :      14707 :           tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (rhs, 0),
    3304                 :            :                                                     &rhs_offset);
    3305                 :      14707 :           if (!tem)
    3306                 :            :             return (void *)-1;
    3307                 :      14707 :           if (TREE_CODE (tem) == MEM_REF
    3308                 :      14707 :               && poly_int_tree_p (TREE_OPERAND (tem, 1), &mem_offset))
    3309                 :            :             {
    3310                 :          0 :               rhs = TREE_OPERAND (tem, 0);
    3311                 :          0 :               rhs_offset += mem_offset;
    3312                 :            :             }
    3313                 :      14707 :           else if (DECL_P (tem)
    3314                 :      12445 :                    || TREE_CODE (tem) == STRING_CST)
    3315                 :      14707 :             rhs = build_fold_addr_expr (tem);
    3316                 :            :           else
    3317                 :            :             return (void *)-1;
    3318                 :            :         }
    3319                 :      21152 :       if (TREE_CODE (rhs) == SSA_NAME)
    3320                 :       6445 :         rhs = SSA_VAL (rhs);
    3321                 :      14707 :       else if (TREE_CODE (rhs) != ADDR_EXPR)
    3322                 :            :         return (void *)-1;
    3323                 :            : 
    3324                 :            :       /* The bases of the destination and the references have to agree.  */
    3325                 :      21152 :       if (TREE_CODE (base) == MEM_REF)
    3326                 :            :         {
    3327                 :       6963 :           if (TREE_OPERAND (base, 0) != lhs
    3328                 :       6963 :               || !poly_int_tree_p (TREE_OPERAND (base, 1), &mem_offset))
    3329                 :       4903 :             return (void *) -1;
    3330                 :       2060 :           at += mem_offset;
    3331                 :            :         }
    3332                 :      14189 :       else if (!DECL_P (base)
    3333                 :      13831 :                || TREE_CODE (lhs) != ADDR_EXPR
    3334                 :      17223 :                || TREE_OPERAND (lhs, 0) != base)
    3335                 :            :         return (void *)-1;
    3336                 :            : 
    3337                 :            :       /* If the access is completely outside of the memcpy destination
    3338                 :            :          area there is no aliasing.  */
    3339                 :       5094 :       if (!ranges_maybe_overlap_p (lhs_offset, copy_size, at, byte_maxsize))
    3340                 :            :         return NULL;
    3341                 :            :       /* And the access has to be contained within the memcpy destination.  */
    3342                 :      27164 :       if (!known_subrange_p (at, byte_maxsize, lhs_offset, copy_size))
    3343                 :            :         return (void *)-1;
    3344                 :            : 
    3345                 :            :       /* Save the operands since we need to use the original ones for
    3346                 :            :          the hash entry we use.  */
    3347                 :       4878 :       if (!data->saved_operands.exists ())
    3348                 :       9384 :         data->saved_operands = vr->operands.copy ();
    3349                 :            : 
    3350                 :            :       /* Make room for 2 operands in the new reference.  */
    3351                 :       4878 :       if (vr->operands.length () < 2)
    3352                 :            :         {
    3353                 :          0 :           vec<vn_reference_op_s> old = vr->operands;
    3354                 :          0 :           vr->operands.safe_grow_cleared (2);
    3355                 :          0 :           if (old == shared_lookup_references)
    3356                 :          0 :             shared_lookup_references = vr->operands;
    3357                 :            :         }
    3358                 :            :       else
    3359                 :       4878 :         vr->operands.truncate (2);
    3360                 :            : 
    3361                 :            :       /* The looked-through reference is a simple MEM_REF.  */
    3362                 :       4878 :       memset (&op, 0, sizeof (op));
    3363                 :       4878 :       op.type = vr->type;
    3364                 :       4878 :       op.opcode = MEM_REF;
    3365                 :       4878 :       op.op0 = build_int_cst (ptr_type_node, at - lhs_offset + rhs_offset);
    3366                 :       4878 :       op.off = at - lhs_offset + rhs_offset;
    3367                 :       4878 :       vr->operands[0] = op;
    3368                 :       4878 :       op.type = TREE_TYPE (rhs);
    3369                 :       4878 :       op.opcode = TREE_CODE (rhs);
    3370                 :       4878 :       op.op0 = rhs;
    3371                 :       4878 :       op.off = -1;
    3372                 :       4878 :       vr->operands[1] = op;
    3373                 :       4878 :       vr->hashcode = vn_reference_compute_hash (vr);
    3374                 :            : 
    3375                 :            :       /* Try folding the new reference to a constant.  */
    3376                 :       4878 :       tree val = fully_constant_vn_reference_p (vr);
    3377                 :       4878 :       if (val)
    3378                 :       1280 :         return data->finish (0, 0, val);
    3379                 :            : 
    3380                 :            :       /* Adjust *ref from the new operands.  */
    3381                 :       3598 :       if (!ao_ref_init_from_vn_reference (&r, 0, 0, vr->type, vr->operands))
    3382                 :            :         return (void *)-1;
    3383                 :            :       /* This can happen with bitfields.  */
    3384                 :       3598 :       if (maybe_ne (ref->size, r.size))
    3385                 :            :         return (void *)-1;
    3386                 :       3598 :       *ref = r;
    3387                 :            : 
    3388                 :            :       /* Do not update last seen VUSE after translating.  */
    3389                 :       3598 :       data->last_vuse_ptr = NULL;
    3390                 :            :       /* Invalidate the original access path since it now contains
    3391                 :            :          the wrong base.  */
    3392                 :       3598 :       data->orig_ref.ref = NULL_TREE;
    3393                 :            :       /* Use the alias-set of this stmt for recording an eventual result.  */
    3394                 :       3598 :       if (data->first_set == -2)
    3395                 :            :         {
    3396                 :       3450 :           data->first_set = 0;
    3397                 :       3450 :           data->first_base_set = 0;
    3398                 :            :         }
    3399                 :            : 
    3400                 :            :       /* Keep looking for the adjusted *REF / VR pair.  */
    3401                 :       3598 :       return NULL;
    3402                 :            :     }
    3403                 :            : 
    3404                 :            :   /* Bail out and stop walking.  */
    3405                 :            :   return (void *)-1;
    3406                 :            : }
    3407                 :            : 
    3408                 :            : /* Return a reference op vector from OP that can be used for
    3409                 :            :    vn_reference_lookup_pieces.  The caller is responsible for releasing
    3410                 :            :    the vector.  */
    3411                 :            : 
    3412                 :            : vec<vn_reference_op_s>
    3413                 :    3288540 : vn_reference_operands_for_lookup (tree op)
    3414                 :            : {
    3415                 :    3288540 :   bool valueized;
    3416                 :    3288540 :   return valueize_shared_reference_ops_from_ref (op, &valueized).copy ();
    3417                 :            : }
    3418                 :            : 
    3419                 :            : /* Lookup a reference operation by it's parts, in the current hash table.
    3420                 :            :    Returns the resulting value number if it exists in the hash table,
    3421                 :            :    NULL_TREE otherwise.  VNRESULT will be filled in with the actual
    3422                 :            :    vn_reference_t stored in the hashtable if something is found.  */
    3423                 :            : 
    3424                 :            : tree
    3425                 :    5308010 : vn_reference_lookup_pieces (tree vuse, alias_set_type set,
    3426                 :            :                             alias_set_type base_set, tree type,
    3427                 :            :                             vec<vn_reference_op_s> operands,
    3428                 :            :                             vn_reference_t *vnresult, vn_lookup_kind kind)
    3429                 :            : {
    3430                 :    5308010 :   struct vn_reference_s vr1;
    3431                 :    5308010 :   vn_reference_t tmp;
    3432                 :    5308010 :   tree cst;
    3433                 :            : 
    3434                 :    5308010 :   if (!vnresult)
    3435                 :          0 :     vnresult = &tmp;
    3436                 :    5308010 :   *vnresult = NULL;
    3437                 :            : 
    3438                 :    5308010 :   vr1.vuse = vuse_ssa_val (vuse);
    3439                 :    5308010 :   shared_lookup_references.truncate (0);
    3440                 :   10616000 :   shared_lookup_references.safe_grow (operands.length ());
    3441                 :    5308010 :   memcpy (shared_lookup_references.address (),
    3442                 :    5308010 :           operands.address (),
    3443                 :            :           sizeof (vn_reference_op_s)
    3444                 :   10616000 :           * operands.length ());
    3445                 :    5308010 :   vr1.operands = operands = shared_lookup_references
    3446                 :    5308010 :     = valueize_refs (shared_lookup_references);
    3447                 :    5308010 :   vr1.type = type;
    3448                 :    5308010 :   vr1.set = set;
    3449                 :    5308010 :   vr1.set = base_set;
    3450                 :    5308010 :   vr1.hashcode = vn_reference_compute_hash (&vr1);
    3451                 :    5308010 :   if ((cst = fully_constant_vn_reference_p (&vr1)))
    3452                 :            :     return cst;
    3453                 :            : 
    3454                 :    5296480 :   vn_reference_lookup_1 (&vr1, vnresult);
    3455                 :    5296480 :   if (!*vnresult
    3456                 :    3048900 :       && kind != VN_NOWALK
    3457                 :    3048900 :       && vr1.vuse)
    3458                 :            :     {
    3459                 :    3005480 :       ao_ref r;
    3460                 :    3005480 :       unsigned limit = param_sccvn_max_alias_queries_per_access;
    3461                 :    6010960 :       vn_walk_cb_data data (&vr1, NULL_TREE, NULL, kind, true, NULL_TREE);
    3462                 :    3005480 :       if (ao_ref_init_from_vn_reference (&r, set, base_set, type,
    3463                 :            :                                          vr1.operands))
    3464                 :    2954080 :         *vnresult
    3465                 :    2954080 :           = ((vn_reference_t)
    3466                 :    2954080 :              walk_non_aliased_vuses (&r, vr1.vuse, true, vn_reference_lookup_2,
    3467                 :            :                                      vn_reference_lookup_3, vuse_valueize,
    3468                 :            :                                      limit, &data));
    3469                 :    6010960 :       gcc_checking_assert (vr1.operands == shared_lookup_references);
    3470                 :            :     }
    3471                 :            : 
    3472                 :    5296480 :   if (*vnresult)
    3473                 :    3288700 :      return (*vnresult)->result;
    3474                 :            : 
    3475                 :            :   return NULL_TREE;
    3476                 :            : }
    3477                 :            : 
    3478                 :            : /* Lookup OP in the current hash table, and return the resulting value
    3479                 :            :    number if it exists in the hash table.  Return NULL_TREE if it does
    3480                 :            :    not exist in the hash table or if the result field of the structure
    3481                 :            :    was NULL..  VNRESULT will be filled in with the vn_reference_t
    3482                 :            :    stored in the hashtable if one exists.  When TBAA_P is false assume
    3483                 :            :    we are looking up a store and treat it as having alias-set zero.
    3484                 :            :    *LAST_VUSE_PTR will be updated with the VUSE the value lookup succeeded.
    3485                 :            :    MASK is either NULL_TREE, or can be an INTEGER_CST if the result of the
    3486                 :            :    load is bitwise anded with MASK and so we are only interested in a subset
    3487                 :            :    of the bits and can ignore if the other bits are uninitialized or
    3488                 :            :    not initialized with constants.  */
    3489                 :            : 
    3490                 :            : tree
    3491                 :   65883700 : vn_reference_lookup (tree op, tree vuse, vn_lookup_kind kind,
    3492                 :            :                      vn_reference_t *vnresult, bool tbaa_p,
    3493                 :            :                      tree *last_vuse_ptr, tree mask)
    3494                 :            : {
    3495                 :   65883700 :   vec<vn_reference_op_s> operands;
    3496                 :   65883700 :   struct vn_reference_s vr1;
    3497                 :   65883700 :   bool valuezied_anything;
    3498                 :            : 
    3499                 :   65883700 :   if (vnresult)
    3500                 :   44648200 :     *vnresult = NULL;
    3501                 :            : 
    3502                 :   65883700 :   vr1.vuse = vuse_ssa_val (vuse);
    3503                 :  131767000 :   vr1.operands = operands
    3504                 :   65883700 :     = valueize_shared_reference_ops_from_ref (op, &valuezied_anything);
    3505                 :   65883700 :   vr1.type = TREE_TYPE (op);
    3506                 :   65883700 :   ao_ref op_ref;
    3507                 :   65883700 :   ao_ref_init (&op_ref, op);
    3508                 :   65883700 :   vr1.set = ao_ref_alias_set (&op_ref);
    3509                 :   65883700 :   vr1.base_set = ao_ref_base_alias_set (&op_ref);
    3510                 :   65883700 :   vr1.hashcode = vn_reference_compute_hash (&vr1);
    3511                 :   65883700 :   if (mask == NULL_TREE)
    3512                 :   65715000 :     if (tree cst = fully_constant_vn_reference_p (&vr1))
    3513                 :            :       return cst;
    3514                 :            : 
    3515                 :   65877000 :   if (kind != VN_NOWALK && vr1.vuse)
    3516                 :            :     {
    3517                 :   36727600 :       vn_reference_t wvnresult;
    3518                 :   36727600 :       ao_ref r;
    3519                 :   36727600 :       unsigned limit = param_sccvn_max_alias_queries_per_access;
    3520                 :            :       /* Make sure to use a valueized reference if we valueized anything.
    3521                 :            :          Otherwise preserve the full reference for advanced TBAA.  */
    3522                 :   36727600 :       if (!valuezied_anything
    3523                 :   36727600 :           || !ao_ref_init_from_vn_reference (&r, vr1.set, vr1.base_set,
    3524                 :            :                                              vr1.type, vr1.operands))
    3525                 :   34324800 :         ao_ref_init (&r, op);
    3526                 :   36727600 :       vn_walk_cb_data data (&vr1, r.ref ? NULL_TREE : op,
    3527                 :  107780000 :                             last_vuse_ptr, kind, tbaa_p, mask);
    3528                 :            : 
    3529                 :   36727600 :       wvnresult
    3530                 :            :         = ((vn_reference_t)
    3531                 :   36727600 :            walk_non_aliased_vuses (&r, vr1.vuse, tbaa_p, vn_reference_lookup_2,
    3532                 :            :                                    vn_reference_lookup_3, vuse_valueize, limit,
    3533                 :            :                                    &data));
    3534                 :   73455300 :       gcc_checking_assert (vr1.operands == shared_lookup_references);
    3535                 :   36727600 :       if (wvnresult)
    3536                 :            :         {
    3537                 :    4402990 :           gcc_assert (mask == NULL_TREE);
    3538                 :    4402990 :           if (vnresult)
    3539                 :    1842920 :             *vnresult = wvnresult;
    3540                 :    4402990 :           return wvnresult->result;
    3541                 :            :         }
    3542                 :   32324700 :       else if (mask)
    3543                 :     168682 :         return data.masked_result;
    3544                 :            : 
    3545                 :            :       return NULL_TREE;
    3546                 :            :     }
    3547                 :            : 
    3548                 :   29149400 :   if (last_vuse_ptr)
    3549                 :    1494950 :     *last_vuse_ptr = vr1.vuse;
    3550                 :   29149400 :   if (mask)
    3551                 :            :     return NULL_TREE;
    3552                 :   29149400 :   return vn_reference_lookup_1 (&vr1, vnresult);
    3553                 :            : }
    3554                 :            : 
    3555                 :            : /* Lookup CALL in the current hash table and return the entry in
    3556                 :            :    *VNRESULT if found.  Populates *VR for the hashtable lookup.  */
    3557                 :            : 
    3558                 :            : void
    3559                 :    5005980 : vn_reference_lookup_call (gcall *call, vn_reference_t *vnresult,
    3560                 :            :                           vn_reference_t vr)
    3561                 :            : {
    3562                 :    5005980 :   if (vnresult)
    3563                 :    5005980 :     *vnresult = NULL;
    3564                 :            : 
    3565                 :    5005980 :   tree vuse = gimple_vuse (call);
    3566                 :            : 
    3567                 :    5005980 :   vr->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
    3568                 :    5005980 :   vr->operands = valueize_shared_reference_ops_from_call (call);
    3569                 :    5005980 :   vr->type = gimple_expr_type (call);
    3570                 :    5005980 :   vr->set = 0;
    3571                 :    5005980 :   vr->base_set = 0;
    3572                 :    5005980 :   vr->hashcode = vn_reference_compute_hash (vr);
    3573                 :    5005980 :   vn_reference_lookup_1 (vr, vnresult);
    3574                 :    5005980 : }
    3575                 :            : 
    3576                 :            : /* Insert OP into the current hash table with a value number of RESULT.  */
    3577                 :            : 
    3578                 :            : static void 
    3579                 :   43266500 : vn_reference_insert (tree op, tree result, tree vuse, tree vdef)
    3580                 :            : {
    3581                 :   43266500 :   vn_reference_s **slot;
    3582                 :   43266500 :   vn_reference_t vr1;
    3583                 :   43266500 :   bool tem;
    3584                 :            : 
    3585                 :   43266500 :   vr1 = XOBNEW (&vn_tables_obstack, vn_reference_s);
    3586                 :   43266500 :   if (TREE_CODE (result) == SSA_NAME)
    3587                 :   27332700 :     vr1->value_id = VN_INFO (result)->value_id;
    3588                 :            :   else
    3589                 :   15933800 :     vr1->value_id = get_or_alloc_constant_value_id (result);
    3590                 :   43266500 :   vr1->vuse = vuse_ssa_val (vuse);
    3591                 :   43266500 :   vr1->operands = valueize_shared_reference_ops_from_ref (op, &tem).copy ();
    3592                 :   43266500 :   vr1->type = TREE_TYPE (op);
    3593                 :   43266500 :   ao_ref op_ref;
    3594                 :   43266500 :   ao_ref_init (&op_ref, op);
    3595                 :   43266500 :   vr1->set = ao_ref_alias_set (&op_ref);
    3596                 :   43266500 :   vr1->base_set = ao_ref_base_alias_set (&op_ref);
    3597                 :   43266500 :   vr1->hashcode = vn_reference_compute_hash (vr1);
    3598                 :   43266500 :   vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result;
    3599                 :   43266500 :   vr1->result_vdef = vdef;
    3600                 :            : 
    3601                 :   43266500 :   slot = valid_info->references->find_slot_with_hash (vr1, vr1->hashcode,
    3602                 :            :                                                       INSERT);
    3603                 :            : 
    3604                 :            :   /* Because IL walking on reference lookup can end up visiting
    3605                 :            :      a def that is only to be visited later in iteration order
    3606                 :            :      when we are about to make an irreducible region reducible
    3607                 :            :      the def can be effectively processed and its ref being inserted
    3608                 :            :      by vn_reference_lookup_3 already.  So we cannot assert (!*slot)
    3609                 :            :      but save a lookup if we deal with already inserted refs here.  */
    3610                 :   43266500 :   if (*slot)
    3611                 :            :     {
    3612                 :            :       /* We cannot assert that we have the same value either because
    3613                 :            :          when disentangling an irreducible region we may end up visiting
    3614                 :            :          a use before the corresponding def.  That's a missed optimization
    3615                 :            :          only though.  See gcc.dg/tree-ssa/pr87126.c for example.  */
    3616                 :          0 :       if (dump_file && (dump_flags & TDF_DETAILS)
    3617                 :          0 :           && !operand_equal_p ((*slot)->result, vr1->result, 0))
    3618                 :            :         {
    3619                 :          0 :           fprintf (dump_file, "Keeping old value ");
    3620                 :          0 :           print_generic_expr (dump_file, (*slot)->result);
    3621                 :          0 :           fprintf (dump_file, " because of collision\n");
    3622                 :            :         }
    3623                 :          0 :       free_reference (vr1);
    3624                 :          0 :       obstack_free (&vn_tables_obstack, vr1);
    3625                 :          0 :       return;
    3626                 :            :     }
    3627                 :            : 
    3628                 :   43266500 :   *slot = vr1;
    3629                 :   43266500 :   vr1->next = last_inserted_ref;
    3630                 :   43266500 :   last_inserted_ref = vr1;
    3631                 :            : }
    3632                 :            : 
    3633                 :            : /* Insert a reference by it's pieces into the current hash table with
    3634                 :            :    a value number of RESULT.  Return the resulting reference
    3635                 :            :    structure we created.  */
    3636                 :            : 
    3637                 :            : vn_reference_t
    3638                 :    2462130 : vn_reference_insert_pieces (tree vuse, alias_set_type set,
    3639                 :            :                             alias_set_type base_set, tree type,
    3640                 :            :                             vec<vn_reference_op_s> operands,
    3641                 :            :                             tree result, unsigned int value_id)
    3642                 :            : 
    3643                 :            : {
    3644                 :    2462130 :   vn_reference_s **slot;
    3645                 :    2462130 :   vn_reference_t vr1;
    3646                 :            : 
    3647                 :    2462130 :   vr1 = XOBNEW (&vn_tables_obstack, vn_reference_s);
    3648                 :    2462130 :   vr1->value_id = value_id;
    3649                 :    2462130 :   vr1->vuse = vuse_ssa_val (vuse);
    3650                 :    2462130 :   vr1->operands = valueize_refs (operands);
    3651                 :    2462130 :   vr1->type = type;
    3652                 :    2462130 :   vr1->set = set;
    3653                 :    2462130 :   vr1->base_set = base_set;
    3654                 :    2462130 :   vr1->hashcode = vn_reference_compute_hash (vr1);
    3655                 :    2462130 :   if (result && TREE_CODE (result) == SSA_NAME)
    3656                 :     148077 :     result = SSA_VAL (result);
    3657                 :    2462130 :   vr1->result = result;
    3658                 :            : 
    3659                 :    2462130 :   slot = valid_info->references->find_slot_with_hash (vr1, vr1->hashcode,
    3660                 :            :                                                       INSERT);
    3661                 :            : 
    3662                 :            :   /* At this point we should have all the things inserted that we have
    3663                 :            :      seen before, and we should never try inserting something that
    3664                 :            :      already exists.  */
    3665                 :    2462130 :   gcc_assert (!*slot);
    3666                 :            : 
    3667                 :    2462130 :   *slot = vr1;
    3668                 :    2462130 :   vr1->next = last_inserted_ref;
    3669                 :    2462130 :   last_inserted_ref = vr1;
    3670                 :    2462130 :   return vr1;
    3671                 :            : }
    3672                 :            : 
    3673                 :            : /* Compute and return the hash value for nary operation VBO1.  */
    3674                 :            : 
    3675                 :            : static hashval_t
    3676                 :  157468000 : vn_nary_op_compute_hash (const vn_nary_op_t vno1)
    3677                 :            : {
    3678                 :  157468000 :   inchash::hash hstate;
    3679                 :  157468000 :   unsigned i;
    3680                 :            : 
    3681                 :  449528000 :   for (i = 0; i < vno1->length; ++i)
    3682                 :  292059000 :     if (TREE_CODE (vno1->op[i]) == SSA_NAME)
    3683                 :  200899000 :       vno1->op[i] = SSA_VAL (vno1->op[i]);
    3684                 :            : 
    3685                 :  157468000 :   if (((vno1->length == 2
    3686                 :  133203000 :         && commutative_tree_code (vno1->opcode))
    3687                 :   74094400 :        || (vno1->length == 3
    3688                 :     595797 :            && commutative_ternary_tree_code (vno1->opcode)))
    3689                 :  240843000 :       && tree_swap_operands_p (vno1->op[0], vno1->op[1]))
    3690                 :    3131150 :     std::swap (vno1->op[0], vno1->op[1]);
    3691                 :  154337000 :   else if (TREE_CODE_CLASS (vno1->opcode) == tcc_comparison
    3692                 :  154337000 :            && tree_swap_operands_p (vno1->op[0], vno1->op[1]))
    3693                 :            :     {
    3694                 :    2022990 :       std::swap (vno1->op[0], vno1->op[1]);
    3695                 :    2022990 :       vno1->opcode = swap_tree_comparison  (vno1->opcode);
    3696                 :            :     }
    3697                 :            : 
    3698                 :  157468000 :   hstate.add_int (vno1->opcode);
    3699                 :  449528000 :   for (i = 0; i < vno1->length; ++i)
    3700                 :  292059000 :     inchash::add_expr (vno1->op[i], hstate);
    3701                 :            : 
    3702                 :  157468000 :   return hstate.end ();
    3703                 :            : }
    3704                 :            : 
    3705                 :            : /* Compare nary operations VNO1 and VNO2 and return true if they are
    3706                 :            :    equivalent.  */
    3707                 :            : 
    3708                 :            : bool
    3709                 :  620080000 : vn_nary_op_eq (const_vn_nary_op_t const vno1, const_vn_nary_op_t const vno2)
    3710                 :            : {
    3711                 :  620080000 :   unsigned i;
    3712                 :            : 
    3713                 :  620080000 :   if (vno1->hashcode != vno2->hashcode)
    3714                 :            :     return false;
    3715                 :            : 
    3716                 :   81745200 :   if (vno1->length != vno2->length)
    3717                 :            :     return false;
    3718                 :            : 
    3719                 :   81745200 :   if (vno1->opcode != vno2->opcode
    3720                 :   81745200 :       || !types_compatible_p (vno1->type, vno2->type))
    3721                 :    1177020 :     return false;
    3722                 :            : 
    3723                 :  226330000 :   for (i = 0; i < vno1->length; ++i)
    3724                 :  145872000 :     if (!expressions_equal_p (vno1->op[i], vno2->op[i]))
    3725                 :            :       return false;
    3726                 :            : 
    3727                 :            :   /* BIT_INSERT_EXPR has an implict operand as the type precision
    3728                 :            :      of op1.  Need to check to make sure they are the same.  */
    3729                 :   80458000 :   if (vno1->opcode == BIT_INSERT_EXPR
    3730                 :        960 :       && TREE_CODE (vno1->op[1]) == INTEGER_CST
    3731                 :   80458300 :       && TYPE_PRECISION (TREE_TYPE (vno1->op[1]))
    3732                 :        219 :          != TYPE_PRECISION (TREE_TYPE (vno2->op[1])))
    3733                 :          0 :     return false;
    3734                 :            : 
    3735                 :            :   return true;
    3736                 :            : }
    3737                 :            : 
    3738                 :            : /* Initialize VNO from the pieces provided.  */
    3739                 :            : 
    3740                 :            : static void
    3741                 :   97138800 : init_vn_nary_op_from_pieces (vn_nary_op_t vno, unsigned int length,
    3742                 :            :                              enum tree_code code, tree type, tree *ops)
    3743                 :            : {
    3744                 :   97138800 :   vno->opcode = code;
    3745                 :   97138800 :   vno->length = length;
    3746                 :   97138800 :   vno->type = type;
    3747                 :    2979330 :   memcpy (&vno->op[0], ops, sizeof (tree) * length);
    3748                 :          0 : }
    3749                 :            : 
    3750                 :            : /* Return the number of operands for a vn_nary ops structure from STMT.  */
    3751                 :            : 
    3752                 :            : static unsigned int
    3753                 :   60329600 : vn_nary_length_from_stmt (gimple *stmt)
    3754                 :            : {
    3755                 :   60329600 :   switch (gimple_assign_rhs_code (stmt))
    3756                 :            :     {
    3757                 :            :     case REALPART_EXPR:
    3758                 :            :     case IMAGPART_EXPR:
    3759                 :            :     case VIEW_CONVERT_EXPR:
    3760                 :            :       return 1;
    3761                 :            : 
    3762                 :     237549 :     case BIT_FIELD_REF:
    3763                 :     237549 :       return 3;
    3764                 :            : 
    3765                 :     119387 :     case CONSTRUCTOR:
    3766                 :     119387 :       return CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt));
    3767                 :            : 
    3768                 :   57897400 :     default:
    3769                 :   57897400 :       return gimple_num_ops (stmt) - 1;
    3770                 :            :     }
    3771                 :            : }
    3772                 :            : 
    3773                 :            : /* Initialize VNO from STMT.  */
    3774                 :            : 
    3775                 :            : static void
    3776                 :   60329600 : init_vn_nary_op_from_stmt (vn_nary_op_t vno, gimple *stmt)
    3777                 :            : {
    3778                 :   60329600 :   unsigned i;
    3779                 :            : 
    3780                 :   60329600 :   vno->opcode = gimple_assign_rhs_code (stmt);
    3781                 :   60329600 :   vno->type = gimple_expr_type (stmt);
    3782                 :   60329600 :   switch (vno->opcode)
    3783                 :            :     {
    3784                 :    2075250 :     case REALPART_EXPR:
    3785                 :    2075250 :     case IMAGPART_EXPR:
    3786                 :    2075250 :     case VIEW_CONVERT_EXPR:
    3787                 :    2075250 :       vno->length = 1;
    3788                 :    2075250 :       vno->op[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
    3789                 :    2075250 :       break;
    3790                 :            : 
    3791                 :     237549 :     case BIT_FIELD_REF:
    3792                 :     237549 :       vno->length = 3;
    3793                 :     237549 :       vno->op[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
    3794                 :     237549 :       vno->op[1] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 1);
    3795                 :     237549 :       vno->op[2] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 2);
    3796                 :     237549 :       break;
    3797                 :            : 
    3798                 :     119387 :     case CONSTRUCTOR:
    3799                 :     119387 :       vno->length = CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt));
    3800                 :     463204 :       for (i = 0; i < vno->length; ++i)
    3801                 :     343817 :         vno->op[i] = CONSTRUCTOR_ELT (gimple_assign_rhs1 (stmt), i)->value;
    3802                 :            :       break;
    3803                 :            : 
    3804                 :   57897400 :     default:
    3805                 :   57897400 :       gcc_checking_assert (!gimple_assign_single_p (stmt));
    3806                 :   57897400 :       vno->length = gimple_num_ops (stmt) - 1;
    3807                 :  156786000 :       for (i = 0; i < vno->length; ++i)
    3808                 :   98888300 :         vno->op[i] = gimple_op (stmt, i + 1);
    3809                 :            :     }
    3810                 :   60329600 : }
    3811                 :            : 
    3812                 :            : /* Compute the hashcode for VNO and look for it in the hash table;
    3813                 :            :    return the resulting value number if it exists in the hash table.
    3814                 :            :    Return NULL_TREE if it does not exist in the hash table or if the
    3815                 :            :    result field of the operation is NULL.  VNRESULT will contain the
    3816                 :            :    vn_nary_op_t from the hashtable if it exists.  */
    3817                 :            : 
    3818                 :            : static tree
    3819                 :   61422300 : vn_nary_op_lookup_1 (vn_nary_op_t vno, vn_nary_op_t *vnresult)
    3820                 :            : {
    3821                 :   61422300 :   vn_nary_op_s **slot;
    3822                 :            : 
    3823                 :   61422300 :   if (vnresult)
    3824                 :   59616900 :     *vnresult = NULL;
    3825                 :            : 
    3826                 :   61422300 :   vno->hashcode = vn_nary_op_compute_hash (vno);
    3827                 :   61422300 :   slot = valid_info->nary->find_slot_with_hash (vno, vno->hashcode, NO_INSERT);
    3828                 :   61422300 :   if (!slot)
    3829                 :            :     return NULL_TREE;
    3830                 :   10025500 :   if (vnresult)
    3831                 :    9827530 :     *vnresult = *slot;
    3832                 :   10025500 :   return (*slot)->predicated_values ? NULL_TREE : (*slot)->u.result;
    3833                 :            : }
    3834                 :            : 
    3835                 :            : /* Lookup a n-ary operation by its pieces and return the resulting value
    3836                 :            :    number if it exists in the hash table.  Return NULL_TREE if it does
    3837                 :            :    not exist in the hash table or if the result field of the operation
    3838                 :            :    is NULL. VNRESULT will contain the vn_nary_op_t from the hashtable
    3839                 :            :    if it exists.  */
    3840                 :            : 
    3841                 :            : tree
    3842                 :   27833400 : vn_nary_op_lookup_pieces (unsigned int length, enum tree_code code,
    3843                 :            :                           tree type, tree *ops, vn_nary_op_t *vnresult)
    3844                 :            : {
    3845                 :   27833400 :   vn_nary_op_t vno1 = XALLOCAVAR (struct vn_nary_op_s,
    3846                 :            :                                   sizeof_vn_nary_op (length));
    3847                 :   27833400 :   init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
    3848                 :   27833400 :   return vn_nary_op_lookup_1 (vno1, vnresult);
    3849                 :            : }
    3850                 :            : 
    3851                 :            : /* Lookup the rhs of STMT in the current hash table, and return the resulting
    3852                 :            :    value number if it exists in the hash table.  Return NULL_TREE if
    3853                 :            :    it does not exist in the hash table.  VNRESULT will contain the
    3854                 :            :    vn_nary_op_t from the hashtable if it exists.  */
    3855                 :            : 
    3856                 :            : tree
    3857                 :   33588900 : vn_nary_op_lookup_stmt (gimple *stmt, vn_nary_op_t *vnresult)
    3858                 :            : {
    3859                 :   33588900 :   vn_nary_op_t vno1
    3860                 :   33588900 :     = XALLOCAVAR (struct vn_nary_op_s,
    3861                 :            :                   sizeof_vn_nary_op (vn_nary_length_from_stmt (stmt)));
    3862                 :   33588900 :   init_vn_nary_op_from_stmt (vno1, stmt);
    3863                 :   33588900 :   return vn_nary_op_lookup_1 (vno1, vnresult);
    3864                 :            : }
    3865                 :            : 
    3866                 :            : /* Allocate a vn_nary_op_t with LENGTH operands on STACK.  */
    3867                 :            : 
    3868                 :            : static vn_nary_op_t
    3869                 :   96046100 : alloc_vn_nary_op_noinit (unsigned int length, struct obstack *stack)
    3870                 :            : {
    3871                 :   96046100 :   return (vn_nary_op_t) obstack_alloc (stack, sizeof_vn_nary_op (length));
    3872                 :            : }
    3873                 :            : 
    3874                 :            : /* Allocate and initialize a vn_nary_op_t on CURRENT_INFO's
    3875                 :            :    obstack.  */
    3876                 :            : 
    3877                 :            : static vn_nary_op_t
    3878                 :   93038200 : alloc_vn_nary_op (unsigned int length, tree result, unsigned int value_id)
    3879                 :            : {
    3880                 :          0 :   vn_nary_op_t vno1 = alloc_vn_nary_op_noinit (length, &vn_tables_obstack);
    3881                 :            : 
    3882                 :   93038200 :   vno1->value_id = value_id;
    3883                 :   93038200 :   vno1->length = length;
    3884                 :   93038200 :   vno1->predicated_values = 0;
    3885                 :   93038200 :   vno1->u.result = result;
    3886                 :            : 
    3887                 :   93038200 :   return vno1;
    3888                 :            : }
    3889                 :            : 
    3890                 :            : /* Insert VNO into TABLE.  If COMPUTE_HASH is true, then compute
    3891                 :            :    VNO->HASHCODE first.  */
    3892                 :            : 
    3893                 :            : static vn_nary_op_t
    3894                 :   96046100 : vn_nary_op_insert_into (vn_nary_op_t vno, vn_nary_op_table_type *table,
    3895                 :            :                         bool compute_hash)
    3896                 :            : {
    3897                 :   96046100 :   vn_nary_op_s **slot;
    3898                 :            : 
    3899                 :   96046100 :   if (compute_hash)
    3900                 :            :     {
    3901                 :   96046100 :       vno->hashcode = vn_nary_op_compute_hash (vno);
    3902                 :   96046100 :       gcc_assert (! vno->predicated_values
    3903                 :            :                   || (! vno->u.values->next
    3904                 :            :                       && vno->u.values->n == 1));
    3905                 :            :     }
    3906                 :            : 
    3907                 :   96046100 :   slot = table->find_slot_with_hash (vno, vno->hashcode, INSERT);
    3908                 :   96046100 :   vno->unwind_to = *slot;
    3909                 :   96046100 :   if (*slot)
    3910                 :            :     {
    3911                 :            :       /* Prefer non-predicated values.
    3912                 :            :          ???  Only if those are constant, otherwise, with constant predicated
    3913                 :            :          value, turn them into predicated values with entry-block validity
    3914                 :            :          (???  but we always find the first valid result currently).  */
    3915                 :   18049700 :       if ((*slot)->predicated_values
    3916                 :   18049700 :           && ! vno->predicated_values)
    3917                 :            :         {
    3918                 :            :           /* ???  We cannot remove *slot from the unwind stack list.
    3919                 :            :              For the moment we deal with this by skipping not found
    3920                 :            :              entries but this isn't ideal ...  */
    3921                 :      56725 :           *slot = vno;
    3922                 :            :           /* ???  Maintain a stack of states we can unwind in
    3923                 :            :              vn_nary_op_s?  But how far do we unwind?  In reality
    3924                 :            :              we need to push change records somewhere...  Or not
    3925                 :            :              unwind vn_nary_op_s and linking them but instead
    3926                 :            :              unwind the results "list", linking that, which also
    3927                 :            :              doesn't move on hashtable resize.  */
    3928                 :            :           /* We can also have a ->unwind_to recording *slot there.
    3929                 :            :              That way we can make u.values a fixed size array with
    3930                 :            :              recording the number of entries but of course we then
    3931                 :            :              have always N copies for each unwind_to-state.  Or we
    3932                 :            :              make sure to only ever append and each unwinding will
    3933                 :            :              pop off one entry (but how to deal with predicated
    3934                 :            :              replaced with non-predicated here?)  */
    3935                 :      56725 :           vno->next = last_inserted_nary;
    3936                 :      56725 :           last_inserted_nary = vno;
    3937                 :      56725 :           return vno;
    3938                 :            :         }
    3939                 :   17993000 :       else if (vno->predicated_values
    3940                 :   17993000 :                && ! (*slot)->predicated_values)
    3941                 :            :         return *slot;
    3942                 :   17573700 :       else if (vno->predicated_values
    3943                 :   17573300 :                && (*slot)->predicated_values)
    3944                 :            :         {
    3945                 :            :           /* ???  Factor this all into a insert_single_predicated_value
    3946                 :            :              routine.  */
    3947                 :   17573300 :           gcc_assert (!vno->u.values->next && vno->u.values->n == 1);
    3948                 :   17573300 :           basic_block vno_bb
    3949                 :   17573300 :             = BASIC_BLOCK_FOR_FN (cfun, vno->u.values->valid_dominated_by_p[0]);
    3950                 :   17573300 :           vn_pval *nval = vno->u.values;
    3951                 :   17573300 :           vn_pval **next = &vno->u.values;
    3952                 :   17573300 :           bool found = false;
    3953                 :   37639800 :           for (vn_pval *val = (*slot)->u.values; val; val = val->next)
    3954                 :            :             {
    3955                 :   20111200 :               if (expressions_equal_p (val->result, vno->u.values->result))
    3956                 :            :                 {
    3957                 :    7743250 :                   found = true;
    3958                 :    7743250 :                   for (unsigned i = 0; i < val->n; ++i)
    3959                 :            :                     {
    3960                 :    5899280 :                       basic_block val_bb
    3961                 :    5899280 :                         = BASIC_BLOCK_FOR_FN (cfun,
    3962                 :            :                                               val->valid_dominated_by_p[i]);
    3963                 :    5899280 :                       if (dominated_by_p (CDI_DOMINATORS, vno_bb, val_bb))
    3964                 :            :                         /* Value registered with more generic predicate.  */
    3965                 :      44810 :                         return *slot;
    3966                 :    5854470 :                       else if (dominated_by_p (CDI_DOMINATORS, val_bb, vno_bb))
    3967                 :            :                         /* Shouldn't happen, we insert in RPO order.  */
    3968                 :          0 :                         gcc_unreachable ();
    3969                 :            :                     }
    3970                 :            :                   /* Append value.  */
    3971                 :    1843960 :                   *next = (vn_pval *) obstack_alloc (&vn_tables_obstack,
    3972                 :            :                                                      sizeof (vn_pval)
    3973                 :            :                                                      + val->n * sizeof (int));
    3974                 :    1843960 :                   (*next)->next = NULL;
    3975                 :    1843960 :                   (*next)->result = val->result;
    3976                 :    1843960 :                   (*next)->n = val->n + 1;
    3977                 :    1843960 :                   memcpy ((*next)->valid_dominated_by_p,
    3978                 :    1843960 :                           val->valid_dominated_by_p,
    3979                 :    1843960 :                           val->n * sizeof (int));
    3980                 :    1843960 :                   (*next)->valid_dominated_by_p[val->n] = vno_bb->index;
    3981                 :    1843960 :                   next = &(*next)->next;
    3982                 :    1843960 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    3983                 :          8 :                     fprintf (dump_file, "Appending predicate to value.\n");
    3984                 :    1843960 :                   continue;
    3985                 :            :                 }
    3986                 :            :               /* Copy other predicated values.  */
    3987                 :   18222400 :               *next = (vn_pval *) obstack_alloc (&vn_tables_obstack,
    3988                 :            :                                                  sizeof (vn_pval)
    3989                 :            :                                                  + (val->n-1) * sizeof (int));
    3990                 :   18222400 :               memcpy (*next, val, sizeof (vn_pval) + (val->n-1) * sizeof (int));
    3991                 :   18222400 :               (*next)->next = NULL;
    3992                 :   18222400 :               next = &(*next)->next;
    3993                 :            :             }
    3994                 :   17528500 :           if (!found)
    3995                 :   15684600 :             *next = nval;
    3996                 :            : 
    3997                 :   17528500 :           *slot = vno;
    3998                 :   17528500 :           vno->next = last_inserted_nary;
    3999                 :   17528500 :           last_inserted_nary = vno;
    4000                 :   17528500 :           return vno;
    4001                 :            :         }
    4002                 :            : 
    4003                 :            :       /* While we do not want to insert things twice it's awkward to
    4004                 :            :          avoid it in the case where visit_nary_op pattern-matches stuff
    4005                 :            :          and ends up simplifying the replacement to itself.  We then
    4006                 :            :          get two inserts, one from visit_nary_op and one from
    4007                 :            :          vn_nary_build_or_lookup.
    4008                 :            :          So allow inserts with the same value number.  */
    4009                 :        352 :       if ((*slot)->u.result == vno->u.result)
    4010                 :            :         return *slot;
    4011                 :            :     }
    4012                 :            : 
    4013                 :            :   /* ???  There's also optimistic vs. previous commited state merging
    4014                 :            :      that is problematic for the case of unwinding.  */
    4015                 :            : 
    4016                 :            :   /* ???  We should return NULL if we do not use 'vno' and have the
    4017                 :            :      caller release it.  */
    4018                 :   77996400 :   gcc_assert (!*slot);
    4019                 :            : 
    4020                 :   77996400 :   *slot = vno;
    4021                 :   77996400 :   vno->next = last_inserted_nary;
    4022                 :   77996400 :   last_inserted_nary = vno;
    4023                 :   77996400 :   return vno;
    4024                 :            : }
    4025                 :            : 
    4026                 :            : /* Insert a n-ary operation into the current hash table using it's
    4027                 :            :    pieces.  Return the vn_nary_op_t structure we created and put in
    4028                 :            :    the hashtable.  */
    4029                 :            : 
    4030                 :            : vn_nary_op_t
    4031                 :    2754000 : vn_nary_op_insert_pieces (unsigned int length, enum tree_code code,
    4032                 :            :                           tree type, tree *ops,
    4033                 :            :                           tree result, unsigned int value_id)
    4034                 :            : {
    4035                 :    2754000 :   vn_nary_op_t vno1 = alloc_vn_nary_op (length, result, value_id);
    4036                 :    2754000 :   init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
    4037                 :    2754000 :   return vn_nary_op_insert_into (vno1, valid_info->nary, true);
    4038                 :            : }
    4039                 :            : 
    4040                 :            : static vn_nary_op_t
    4041                 :   80517500 : vn_nary_op_insert_pieces_predicated (unsigned int length, enum tree_code code,
    4042                 :            :                                      tree type, tree *ops,
    4043                 :            :                                      tree result, unsigned int value_id,
    4044                 :            :                                      edge pred_e)
    4045                 :            : {
    4046                 :            :   /* ???  Currently tracking BBs.  */
    4047                 :   80517500 :   if (! single_pred_p (pred_e->dest))
    4048                 :            :     {
    4049                 :            :       /* Never record for backedges.  */
    4050                 :   17691800 :       if (pred_e->flags & EDGE_DFS_BACK)
    4051                 :   16945400 :         return NULL;
    4052                 :   16588800 :       edge_iterator ei;
    4053                 :   16588800 :       edge e;
    4054                 :   16588800 :       int cnt = 0;
    4055                 :            :       /* Ignore backedges.  */
    4056                 : 3829090000 :       FOR_EACH_EDGE (e, ei, pred_e->dest->preds)
    4057                 : 3812500000 :         if (! dominated_by_p (CDI_DOMINATORS, e->src, e->dest))
    4058                 : 3811740000 :           cnt++;
    4059                 :   16588800 :       if (cnt != 1)
    4060                 :            :         return NULL;
    4061                 :            :     }
    4062                 :       4172 :   if (dump_file && (dump_flags & TDF_DETAILS)
    4063                 :            :       /* ???  Fix dumping, but currently we only get comparisons.  */
    4064                 :   63572800 :       && TREE_CODE_CLASS (code) == tcc_comparison)
    4065                 :            :     {
    4066                 :        738 :       fprintf (dump_file, "Recording on edge %d->%d ", pred_e->src->index,
    4067                 :        738 :                pred_e->dest->index);
    4068                 :        738 :       print_generic_expr (dump_file, ops[0], TDF_SLIM);
    4069                 :        738 :       fprintf (dump_file, " %s ", get_tree_code_name (code));
    4070                 :        738 :       print_generic_expr (dump_file, ops[1], TDF_SLIM);
    4071                 :       1043 :       fprintf (dump_file, " == %s\n",
    4072                 :        738 :                integer_zerop (result) ? "false" : "true");
    4073                 :            :     }
    4074                 :   63572100 :   vn_nary_op_t vno1 = alloc_vn_nary_op (length, NULL_TREE, value_id);
    4075                 :   63572100 :   init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
    4076                 :   63572100 :   vno1->predicated_values = 1;
    4077                 :   63572100 :   vno1->u.values = (vn_pval *) obstack_alloc (&vn_tables_obstack,
    4078                 :            :                                               sizeof (vn_pval));
    4079                 :   63572100 :   vno1->u.values->next = NULL;
    4080                 :   63572100 :   vno1->u.values->result = result;
    4081                 :   63572100 :   vno1->u.values->n = 1;
    4082                 :   63572100 :   vno1->u.values->valid_dominated_by_p[0] = pred_e->dest->index;
    4083                 :   63572100 :   return vn_nary_op_insert_into (vno1, valid_info->nary, true);
    4084                 :            : }
    4085                 :            : 
    4086                 :            : static bool
    4087                 :            : dominated_by_p_w_unex (basic_block bb1, basic_block bb2);
    4088                 :            : 
    4089                 :            : static tree
    4090                 :     858934 : vn_nary_op_get_predicated_value (vn_nary_op_t vno, basic_block bb)
    4091                 :            : {
    4092                 :     858934 :   if (! vno->predicated_values)
    4093                 :          0 :     return vno->u.result;
    4094                 :    2238990 :   for (vn_pval *val = vno->u.values; val; val = val->next)
    4095                 :    4396230 :     for (unsigned i = 0; i < val->n; ++i)
    4096                 :    3016180 :       if (dominated_by_p_w_unex (bb,
    4097                 :    3016180 :                           BASIC_BLOCK_FOR_FN
    4098                 :            :                             (cfun, val->valid_dominated_by_p[i])))
    4099                 :     246850 :         return val->result;
    4100                 :            :   return NULL_TREE;
    4101                 :            : }
    4102                 :            : 
    4103                 :            : /* Insert the rhs of STMT into the current hash table with a value number of
    4104                 :            :    RESULT.  */
    4105                 :            : 
    4106                 :            : static vn_nary_op_t
    4107                 :   26712100 : vn_nary_op_insert_stmt (gimple *stmt, tree result)
    4108                 :            : {
    4109                 :   26712100 :   vn_nary_op_t vno1
    4110                 :   26712100 :     = alloc_vn_nary_op (vn_nary_length_from_stmt (stmt),
    4111                 :   26712100 :                         result, VN_INFO (result)->value_id);
    4112                 :   26712100 :   init_vn_nary_op_from_stmt (vno1, stmt);
    4113                 :   26712100 :   return vn_nary_op_insert_into (vno1, valid_info->nary, true);
    4114                 :            : }
    4115                 :            : 
    4116                 :            : /* Compute a hashcode for PHI operation VP1 and return it.  */
    4117                 :            : 
    4118                 :            : static inline hashval_t
    4119                 :   30785300 : vn_phi_compute_hash (vn_phi_t vp1)
    4120                 :            : {
    4121                 :   30785300 :   inchash::hash hstate (EDGE_COUNT (vp1->block->preds) > 2
    4122                 :   57523600 :                         ? vp1->block->index : EDGE_COUNT (vp1->block->preds));
    4123                 :   30785300 :   tree phi1op;
    4124                 :   30785300 :   tree type;
    4125                 :   30785300 :   edge e;
    4126                 :   30785300 :   edge_iterator ei;
    4127                 :            : 
    4128                 :            :   /* If all PHI arguments are constants we need to distinguish
    4129                 :            :      the PHI node via its type.  */
    4130                 :   30785300 :   type = vp1->type;
    4131                 :   30785300 :   hstate.merge_hash (vn_hash_type (type));
    4132                 :            : 
    4133                 :  105571000 :   FOR_EACH_EDGE (e, ei, vp1->block->preds)
    4134                 :            :     {
    4135                 :            :       /* Don't hash backedge values they need to be handled as VN_TOP
    4136                 :            :          for optimistic value-numbering.  */
    4137                 :   74785300 :       if (e->flags & EDGE_DFS_BACK)
    4138                 :   16018300 :         continue;
    4139                 :            : 
    4140                 :   58767000 :       phi1op = vp1->phiargs[e->dest_idx];
    4141                 :   58767000 :       if (phi1op == VN_TOP)
    4142                 :          0 :         continue;
    4143                 :   58767000 :       inchash::add_expr (phi1op, hstate);
    4144                 :            :     }
    4145                 :            : 
    4146                 :   30785300 :   return hstate.end ();
    4147                 :            : }
    4148                 :            : 
    4149                 :            : 
    4150                 :            : /* Return true if COND1 and COND2 represent the same condition, set
    4151                 :            :    *INVERTED_P if one needs to be inverted to make it the same as
    4152                 :            :    the other.  */
    4153                 :            : 
    4154                 :            : static bool
    4155                 :     947312 : cond_stmts_equal_p (gcond *cond1, tree lhs1, tree rhs1,
    4156                 :            :                     gcond *cond2, tree lhs2, tree rhs2, bool *inverted_p)
    4157                 :            : {
    4158                 :     947312 :   enum tree_code code1 = gimple_cond_code (cond1);
    4159                 :     947312 :   enum tree_code code2 = gimple_cond_code (cond2);
    4160                 :            : 
    4161                 :     947312 :   *inverted_p = false;
    4162                 :     947312 :   if (code1 == code2)
    4163                 :            :     ;
    4164                 :     170832 :   else if (code1 == swap_tree_comparison (code2))
    4165                 :     854623 :     std::swap (lhs2, rhs2);
    4166                 :     146124 :   else if (code1 == invert_tree_comparison (code2, HONOR_NANS (lhs2)))
    4167                 :      42413 :     *inverted_p = true;
    4168                 :     103711 :   else if (code1 == invert_tree_comparison
    4169                 :     103711 :                       (swap_tree_comparison (code2), HONOR_NANS (lhs2)))
    4170                 :            :     {
    4171                 :      11022 :       std::swap (lhs2, rhs2);
    4172                 :      11022 :       *inverted_p = true;
    4173                 :            :     }
    4174                 :            :   else
    4175                 :            :     return false;
    4176                 :            : 
    4177                 :     854623 :   return ((expressions_equal_p (lhs1, lhs2)
    4178                 :      68548 :            && expressions_equal_p (rhs1, rhs2))
    4179                 :     881630 :           || (commutative_tree_code (code1)
    4180                 :     356624 :               && expressions_equal_p (lhs1, rhs2)
    4181                 :       1686 :               && expressions_equal_p (rhs1, lhs2)));
    4182                 :            : }
    4183                 :            : 
    4184                 :            : /* Compare two phi entries for equality, ignoring VN_TOP arguments.  */
    4185                 :            : 
    4186                 :            : static int
    4187                 :   86276900 : vn_phi_eq (const_vn_phi_t const vp1, const_vn_phi_t const vp2)
    4188                 :            : {
    4189                 :   86276900 :   if (vp1->hashcode != vp2->hashcode)
    4190                 :            :     return false;
    4191                 :            : 
    4192                 :   70357000 :   if (vp1->block != vp2->block)
    4193                 :            :     {
    4194                 :  195153000 :       if (EDGE_COUNT (vp1->block->preds) != EDGE_COUNT (vp2->block->preds))
    4195                 :            :         return false;
    4196                 :            : 
    4197                 :   65050800 :       switch (EDGE_COUNT (vp1->block->preds))
    4198                 :            :         {
    4199                 :            :         case 1:
    4200                 :            :           /* Single-arg PHIs are just copies.  */
    4201                 :            :           break;
    4202                 :            : 
    4203                 :   65050800 :         case 2:
    4204                 :   65050800 :           {
    4205                 :            :             /* Rule out backedges into the PHI.  */
    4206                 :   65050800 :             if (vp1->block->loop_father->header == vp1->block
    4207                 :     959653 :                 || vp2->block->loop_father->header == vp2->block)
    4208                 :            :               return false;
    4209                 :            : 
    4210                 :            :             /* If the PHI nodes do not have compatible types
    4211                 :            :                they are not the same.  */
    4212                 :     954835 :             if (!types_compatible_p (vp1->type, vp2->type))
    4213                 :            :               return false;
    4214                 :            : 
    4215                 :     952410 :             basic_block idom1
    4216                 :     952410 :               = get_immediate_dominator (CDI_DOMINATORS, vp1->block);
    4217                 :     952410 :             basic_block idom2
    4218                 :     952410 :               = get_immediate_dominator (CDI_DOMINATORS, vp2->block);
    4219                 :            :             /* If the immediate dominator end in switch stmts multiple
    4220                 :            :                values may end up in the same PHI arg via intermediate
    4221                 :            :                CFG merges.  */
    4222                 :     952410 :             if (EDGE_COUNT (idom1->succs) != 2
    4223                 :   66001500 :                 || EDGE_COUNT (idom2->succs) != 2)
    4224                 :            :               return false;
    4225                 :            : 
    4226                 :            :             /* Verify the controlling stmt is the same.  */
    4227                 :     950662 :             gcond *last1 = safe_dyn_cast <gcond *> (last_stmt (idom1));
    4228                 :     950662 :             gcond *last2 = safe_dyn_cast <gcond *> (last_stmt (idom2));
    4229                 :     950662 :             if (! last1 || ! last2)
    4230                 :            :               return false;
    4231                 :     947312 :             bool inverted_p;
    4232                 :     947312 :             if (! cond_stmts_equal_p (last1, vp1->cclhs, vp1->ccrhs,
    4233                 :     947312 :                                       last2, vp2->cclhs, vp2->ccrhs,
    4234                 :            :                                       &inverted_p))
    4235                 :            :               return false;
    4236                 :            : 
    4237                 :            :             /* Get at true/false controlled edges into the PHI.  */
    4238                 :      41678 :             edge te1, te2, fe1, fe2;
    4239                 :      41678 :             if (! extract_true_false_controlled_edges (idom1, vp1->block,
    4240                 :            :                                                        &te1, &fe1)
    4241                 :      41678 :                 || ! extract_true_false_controlled_edges (idom2, vp2->block,
    4242                 :            :                                                           &te2, &fe2))
    4243                 :      16402 :               return false;
    4244                 :            : 
    4245                 :            :             /* Swap edges if the second condition is the inverted of the
    4246                 :            :                first.  */
    4247                 :      25276 :             if (inverted_p)
    4248                 :       1680 :               std::swap (te2, fe2);
    4249                 :            : 
    4250                 :            :             /* ???  Handle VN_TOP specially.  */
    4251                 :      25276 :             if (! expressions_equal_p (vp1->phiargs[te1->dest_idx],
    4252                 :      25276 :                                        vp2->phiargs[te2->dest_idx])
    4253                 :      48836 :                 || ! expressions_equal_p (vp1->phiargs[fe1->dest_idx],
    4254                 :      23560 :                                           vp2->phiargs[fe2->dest_idx]))
    4255                 :       1716 :               return false;
    4256                 :            : 
    4257                 :            :             return true;
    4258                 :            :           }
    4259                 :            : 
    4260                 :            :         default:
    4261                 :            :           return false;
    4262                 :            :         }
    4263                 :            :     }
    4264                 :            : 
    4265                 :            :   /* If the PHI nodes do not have compatible types
    4266                 :            :      they are not the same.  */
    4267                 :    5306080 :   if (!types_compatible_p (vp1->type, vp2->type))
    4268                 :            :     return false;
    4269                 :            : 
    4270                 :            :   /* Any phi in the same block will have it's arguments in the
    4271                 :            :      same edge order, because of how we store phi nodes.  */
    4272                 :   26310300 :   for (unsigned i = 0; i < EDGE_COUNT (vp1->block->preds); ++i)
    4273                 :            :     {
    4274                 :   10537000 :       tree phi1op = vp1->phiargs[i];
    4275                 :   10537000 :       tree phi2op = vp2->phiargs[i];
    4276                 :   10537000 :       if (phi1op == VN_TOP || phi2op == VN_TOP)
    4277                 :          0 :         continue;
    4278                 :   10537000 :       if (!expressions_equal_p (phi1op, phi2op))
    4279                 :            :         return false;
    4280                 :            :     }
    4281                 :            : 
    4282                 :            :   return true;
    4283                 :            : }
    4284                 :            : 
    4285                 :            : /* Lookup PHI in the current hash table, and return the resulting
    4286                 :            :    value number if it exists in the hash table.  Return NULL_TREE if
    4287                 :            :    it does not exist in the hash table. */
    4288                 :            : 
    4289                 :            : static tree
    4290                 :   16902800 : vn_phi_lookup (gimple *phi, bool backedges_varying_p)
    4291                 :            : {
    4292                 :   16902800 :   vn_phi_s **slot;
    4293                 :   16902800 :   struct vn_phi_s *vp1;
    4294                 :   16902800 :   edge e;
    4295                 :   16902800 :   edge_iterator ei;
    4296                 :            : 
    4297                 :   16902800 :   vp1 = XALLOCAVAR (struct vn_phi_s,
    4298                 :            :                     sizeof (struct vn_phi_s)
    4299                 :            :                     + (gimple_phi_num_args (phi) - 1) * sizeof (tree));
    4300                 :            : 
    4301                 :            :   /* Canonicalize the SSA_NAME's to their value number.  */
    4302                 :   57582300 :   FOR_EACH_EDGE (e, ei, gimple_bb (phi)->preds)
    4303                 :            :     {
    4304                 :   40679500 :       tree def = PHI_ARG_DEF_FROM_EDGE (phi, e);
    4305                 :   40679500 :       if (TREE_CODE (def) == SSA_NAME
    4306                 :   34953700 :           && (!backedges_varying_p || !(e->flags & EDGE_DFS_BACK)))
    4307                 :   33912600 :         def = SSA_VAL (def);
    4308                 :   40679500 :       vp1->phiargs[e->dest_idx] = def;
    4309                 :            :     }
    4310                 :   16902800 :   vp1->type = TREE_TYPE (gimple_phi_result (phi));
    4311                 :   16902800 :   vp1->block = gimple_bb (phi);
    4312                 :            :   /* Extract values of the controlling condition.  */
    4313                 :   16902800 :   vp1->cclhs = NULL_TREE;
    4314                 :   16902800 :   vp1->ccrhs = NULL_TREE;
    4315                 :   16902800 :   basic_block idom1 = get_immediate_dominator (CDI_DOMINATORS, vp1->block);
    4316                 :   16902800 :   if (EDGE_COUNT (idom1->succs) == 2)
    4317                 :    8794360 :     if (gcond *last1 = safe_dyn_cast <gcond *> (last_stmt (idom1)))
    4318                 :            :       {
    4319                 :            :         /* ???  We want to use SSA_VAL here.  But possibly not
    4320                 :            :            allow VN_TOP.  */
    4321                 :    8404830 :         vp1->cclhs = vn_valueize (gimple_cond_lhs (last1));
    4322                 :    8404830 :         vp1->ccrhs = vn_valueize (gimple_cond_rhs (last1));
    4323                 :            :       }
    4324                 :   16902800 :   vp1->hashcode = vn_phi_compute_hash (vp1);
    4325                 :   16902800 :   slot = valid_info->phis->find_slot_with_hash (vp1, vp1->hashcode, NO_INSERT);
    4326                 :   16902800 :   if (!slot)
    4327                 :            :     return NULL_TREE;
    4328                 :    2641660 :   return (*slot)->result;
    4329                 :            : }
    4330                 :            : 
    4331                 :            : /* Insert PHI into the current hash table with a value number of
    4332                 :            :    RESULT.  */
    4333                 :            : 
    4334                 :            : static vn_phi_t
    4335                 :   13882500 : vn_phi_insert (gimple *phi, tree result, bool backedges_varying_p)
    4336                 :            : {
    4337                 :   13882500 :   vn_phi_s **slot;
    4338                 :   13882500 :   vn_phi_t vp1 = (vn_phi_t) obstack_alloc (&vn_tables_obstack,
    4339                 :            :                                            sizeof (vn_phi_s)
    4340                 :            :                                            + ((gimple_phi_num_args (phi) - 1)
    4341                 :            :                                               * sizeof (tree)));
    4342                 :   13882500 :   edge e;
    4343                 :   13882500 :   edge_iterator ei;
    4344                 :            : 
    4345                 :            :   /* Canonicalize the SSA_NAME's to their value number.  */
    4346                 :   47988300 :   FOR_EACH_EDGE (e, ei, gimple_bb (phi)->preds)
    4347                 :            :     {
    4348                 :   34105800 :       tree def = PHI_ARG_DEF_FROM_EDGE (phi, e);
    4349                 :   34105800 :       if (TREE_CODE (def) == SSA_NAME
    4350                 :   28939300 :           && (!backedges_varying_p || !(e->flags & EDGE_DFS_BACK)))
    4351                 :   27898500 :         def = SSA_VAL (def);
    4352                 :   34105800 :       vp1->phiargs[e->dest_idx] = def;
    4353                 :            :     }
    4354                 :   13882500 :   vp1->value_id = VN_INFO (result)->value_id;
    4355                 :   13882500 :   vp1->type = TREE_TYPE (gimple_phi_result (phi));
    4356                 :   13882500 :   vp1->block = gimple_bb (phi);
    4357                 :            :   /* Extract values of the controlling condition.  */
    4358                 :   13882500 :   vp1->cclhs = NULL_TREE;
    4359                 :   13882500 :   vp1->ccrhs = NULL_TREE;
    4360                 :   13882500 :   basic_block idom1 = get_immediate_dominator (CDI_DOMINATORS, vp1->block);
    4361                 :   13882500 :   if (EDGE_COUNT (idom1->succs) == 2)
    4362                 :    8304950 :     if (gcond *last1 = safe_dyn_cast <gcond *> (last_stmt (idom1)))
    4363                 :            :       {
    4364                 :            :         /* ???  We want to use SSA_VAL here.  But possibly not
    4365                 :            :            allow VN_TOP.  */
    4366                 :    7940170 :         vp1->cclhs = vn_valueize (gimple_cond_lhs (last1));
    4367                 :    7940170 :         vp1->ccrhs = vn_valueize (gimple_cond_rhs (last1));
    4368                 :            :       }
    4369                 :   13882500 :   vp1->result = result;
    4370                 :   13882500 :   vp1->hashcode = vn_phi_compute_hash (vp1);
    4371                 :            : 
    4372                 :   13882500 :   slot = valid_info->phis->find_slot_with_hash (vp1, vp1->hashcode, INSERT);
    4373                 :   13882500 :   gcc_assert (!*slot);
    4374                 :            : 
    4375                 :   13882500 :   *slot = vp1;
    4376                 :   13882500 :   vp1->next = last_inserted_phi;
    4377                 :   13882500 :   last_inserted_phi = vp1;
    4378                 :   13882500 :   return vp1;
    4379                 :            : }
    4380                 :            : 
    4381                 :            : 
    4382                 :            : /* Return true if BB1 is dominated by BB2 taking into account edges
    4383                 :            :    that are not executable.  */
    4384                 :            : 
    4385                 :            : static bool
    4386                 :   31478800 : dominated_by_p_w_unex (basic_block bb1, basic_block bb2)
    4387                 :            : {
    4388                 :   31478800 :   edge_iterator ei;
    4389                 :   31478800 :   edge e;
    4390                 :            : 
    4391                 :   31478800 :   if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
    4392                 :            :     return true;
    4393                 :            : 
    4394                 :            :   /* Before iterating we'd like to know if there exists a
    4395                 :            :      (executable) path from bb2 to bb1 at all, if not we can
    4396                 :            :      directly return false.  For now simply iterate once.  */
    4397                 :            : 
    4398                 :            :   /* Iterate to the single executable bb1 predecessor.  */
    4399                 :    8883840 :   if (EDGE_COUNT (bb1->preds) > 1)
    4400                 :            :     {
    4401                 :    2272570 :       edge prede = NULL;
    4402                 :    4889580 :       FOR_EACH_EDGE (e, ei, bb1->preds)
    4403                 :    4605610 :         if (e->flags & EDGE_EXECUTABLE)
    4404                 :            :           {
    4405                 :    4261170 :             if (prede)
    4406                 :            :               {
    4407                 :            :                 prede = NULL;
    4408                 :            :                 break;
    4409                 :            :               }
    4410                 :            :             prede = e;
    4411                 :            :           }
    4412                 :    2272570 :       if (prede)
    4413                 :            :         {
    4414                 :     283968 :           bb1 = prede->src;
    4415                 :            : 
    4416                 :            :           /* Re-do the dominance check with changed bb1.  */
    4417                 :     283968 :           if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
    4418                 :            :             return true;
    4419                 :            :         }
    4420                 :            :     }
    4421                 :            : 
    4422                 :            :   /* Iterate to the single executable bb2 successor.  */
    4423                 :    8739050 :   edge succe = NULL;
    4424                 :   17496500 :   FOR_EACH_EDGE (e, ei, bb2->succs)
    4425                 :   12443100 :     if (e->flags & EDGE_EXECUTABLE)
    4426                 :            :       {
    4427                 :   11964500 :         if (succe)
    4428                 :            :           {
    4429                 :            :             succe = NULL;
    4430                 :            :             break;
    4431                 :            :           }
    4432                 :            :         succe = e;
    4433                 :            :       }
    4434                 :    8739050 :   if (succe)
    4435                 :            :     {
    4436                 :            :       /* Verify the reached block is only reached through succe.
    4437                 :            :          If there is only one edge we can spare us the dominator
    4438                 :            :          check and iterate directly.  */
    4439                 :    4593220 :       if (EDGE_COUNT (succe->dest->preds) > 1)
    4440                 :            :         {
    4441                 :   10088300 :           FOR_EACH_EDGE (e, ei, succe->dest->preds)
    4442                 :    9591880 :             if (e != succe
    4443                 :    7013460 :                 && (e->flags & EDGE_EXECUTABLE))
    4444                 :            :               {
    4445                 :            :                 succe = NULL;
    4446                 :            :                 break;
    4447                 :            :               }
    4448                 :            :         }
    4449                 :    4593220 :       if (succe)
    4450                 :            :         {
    4451                 :     580782 :           bb2 = succe->dest;
    4452                 :            : 
    4453                 :            :           /* Re-do the dominance check with changed bb2.  */
    4454                 :     580782 :           if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
    4455                 :      71217 :             return true;
    4456                 :            :         }
    4457                 :            :     }
    4458                 :            : 
    4459                 :            :   /* We could now iterate updating bb1 / bb2.  */
    4460                 :            :   return false;
    4461                 :            : }
    4462                 :            : 
    4463                 :            : /* Set the value number of FROM to TO, return true if it has changed
    4464                 :            :    as a result.  */
    4465                 :            : 
    4466                 :            : static inline bool
    4467                 :  130480000 : set_ssa_val_to (tree from, tree to)
    4468                 :            : {
    4469                 :  130480000 :   vn_ssa_aux_t from_info = VN_INFO (from);
    4470                 :  130480000 :   tree currval = from_info->valnum; // SSA_VAL (from)
    4471                 :  130480000 :   poly_int64 toff, coff;
    4472                 :            : 
    4473                 :            :   /* The only thing we allow as value numbers are ssa_names
    4474                 :            :      and invariants.  So assert that here.  We don't allow VN_TOP
    4475                 :            :      as visiting a stmt should produce a value-number other than
    4476                 :            :      that.
    4477                 :            :      ???  Still VN_TOP can happen for unreachable code, so force
    4478                 :            :      it to varying in that case.  Not all code is prepared to
    4479                 :            :      get VN_TOP on valueization.  */
    4480                 :  130480000 :   if (to == VN_TOP)
    4481                 :            :     {
    4482                 :            :       /* ???  When iterating and visiting PHI <undef, backedge-value>
    4483                 :            :          for the first time we rightfully get VN_TOP and we need to
    4484                 :            :          preserve that to optimize for example gcc.dg/tree-ssa/ssa-sccvn-2.c.
    4485                 :            :          With SCCVN we were simply lucky we iterated the other PHI
    4486                 :            :          cycles first and thus visited the backedge-value DEF.  */
    4487                 :          0 :       if (currval == VN_TOP)
    4488                 :          0 :         goto set_and_exit;
    4489                 :          0 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4490                 :          0 :         fprintf (dump_file, "Forcing value number to varying on "
    4491                 :            :                  "receiving VN_TOP\n");
    4492                 :            :       to = from;
    4493                 :            :     }
    4494                 :            : 
    4495                 :  130480000 :   gcc_checking_assert (to != NULL_TREE
    4496                 :            :                        && ((TREE_CODE (to) == SSA_NAME
    4497                 :            :                             && (to == from || SSA_VAL (to) == to))
    4498                 :            :                            || is_gimple_min_invariant (to)));
    4499                 :            : 
    4500                 :  130480000 :   if (from != to)
    4501                 :            :     {
    4502                 :   20013100 :       if (currval == from)
    4503                 :            :         {
    4504                 :       6795 :           if (dump_file && (dump_flags & TDF_DETAILS))
    4505                 :            :             {
    4506                 :          0 :               fprintf (dump_file, "Not changing value number of ");
    4507                 :          0 :               print_generic_expr (dump_file, from);
    4508                 :          0 :               fprintf (dump_file, " from VARYING to ");
    4509                 :          0 :               print_generic_expr (dump_file, to);
    4510                 :          0 :               fprintf (dump_file, "\n");
    4511                 :            :             }
    4512                 :       6795 :           return false;
    4513                 :            :         }
    4514                 :   20006300 :       bool curr_invariant = is_gimple_min_invariant (currval);
    4515                 :   20006300 :       bool curr_undefined = (TREE_CODE (currval) == SSA_NAME
    4516                 :   20006300 :                              && ssa_undefined_value_p (currval, false));
    4517                 :   20006300 :       if (currval != VN_TOP
    4518                 :            :           && !curr_invariant
    4519                 :    4083920 :           && !curr_undefined
    4520                 :   23058400 :           && is_gimple_min_invariant (to))
    4521                 :            :         {
    4522                 :        304 :           if (dump_file && (dump_flags & TDF_DETAILS))
    4523                 :            :             {
    4524                 :          0 :               fprintf (dump_file, "Forcing VARYING instead of changing "
    4525                 :            :                        "value number of ");
    4526                 :          0 :               print_generic_expr (dump_file, from);
    4527                 :          0 :               fprintf (dump_file, " from ");
    4528                 :          0 :               print_generic_expr (dump_file, currval);
    4529                 :          0 :               fprintf (dump_file, " (non-constant) to ");
    4530                 :          0 :               print_generic_expr (dump_file, to);
    4531                 :          0 :               fprintf (dump_file, " (constant)\n");
    4532                 :            :             }
    4533                 :            :           to = from;
    4534                 :            :         }
    4535                 :   20006000 :       else if (currval != VN_TOP
    4536                 :    4083620 :                && !curr_undefined
    4537                 :    4025260 :                && TREE_CODE (to) == SSA_NAME
    4538                 :   23509000 :                && ssa_undefined_value_p (to, false))
    4539                 :            :         {
    4540                 :          6 :           if (dump_file && (dump_flags & TDF_DETAILS))
    4541                 :            :             {
    4542                 :          0 :               fprintf (dump_file, "Forcing VARYING instead of changing "
    4543                 :            :                        "value number of ");
    4544                 :          0 :               print_generic_expr (dump_file, from);
    4545                 :          0 :               fprintf (dump_file, " from ");
    4546                 :          0 :               print_generic_expr (dump_file, currval);
    4547                 :          0 :               fprintf (dump_file, " (non-undefined) to ");
    4548                 :          0 :               print_generic_expr (dump_file, to);
    4549                 :          0 :               fprintf (dump_file, " (undefined)\n");
    4550                 :            :             }
    4551                 :            :           to = from;
    4552                 :            :         }
    4553                 :   20006000 :       else if (TREE_CODE (to) == SSA_NAME
    4554                 :   20006000 :                && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (to))
    4555                 :            :         to = from;
    4556                 :            :     }
    4557                 :            : 
    4558                 :  110467000 : set_and_exit:
    4559                 :  130474000 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4560                 :            :     {
    4561                 :       2283 :       fprintf (dump_file, "Setting value number of ");
    4562                 :       2283 :       print_generic_expr (dump_file, from);
    4563                 :       2283 :       fprintf (dump_file, " to ");
    4564                 :       2283 :       print_generic_expr (dump_file, to);
    4565                 :            :     }
    4566                 :            : 
    4567                 :  130474000 :   if (currval != to
    4568                 :  104037000 :       && !operand_equal_p (currval, to, 0)
    4569                 :            :       /* Different undefined SSA names are not actually different.  See
    4570                 :            :          PR82320 for a testcase were we'd otherwise not terminate iteration.  */
    4571                 :  104181000 :       && !(TREE_CODE (currval) == SSA_NAME
    4572                 :    2328250 :            && TREE_CODE (to) == SSA_NAME
    4573                 :    2327570 :            && ssa_undefined_value_p (currval, false)
    4574                 :     213545 :            && ssa_undefined_value_p (to, false))
    4575                 :            :       /* ???  For addresses involving volatile objects or types operand_equal_p
    4576                 :            :          does not reliably detect ADDR_EXPRs as equal.  We know we are only
    4577                 :            :          getting invariant gimple addresses here, so can use
    4578                 :            :          get_addr_base_and_unit_offset to do this comparison.  */
    4579                 :  234441000 :       && !(TREE_CODE (currval) == ADDR_EXPR
    4580                 :     127172 :            && TREE_CODE (to) == ADDR_EXPR
    4581                 :         12 :            && (get_addr_base_and_unit_offset (TREE_OPERAND (currval, 0), &coff)
    4582                 :          6 :                == get_addr_base_and_unit_offset (TREE_OPERAND (to, 0), &toff))
    4583                 :          6 :            && known_eq (coff, toff)))
    4584                 :            :     {
    4585                 :  103968000 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4586                 :       1819 :         fprintf (dump_file, " (changed)\n");
    4587                 :  103968000 :       from_info->valnum = to;
    4588                 :  103968000 :       return true;
    4589                 :            :     }
    4590                 :   26506100 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4591                 :        464 :     fprintf (dump_file, "\n");
    4592                 :            :   return false;
    4593                 :            : }
    4594                 :            : 
    4595                 :            : /* Set all definitions in STMT to value number to themselves.
    4596                 :            :    Return true if a value number changed. */
    4597                 :            : 
    4598                 :            : static bool
    4599                 :  179380000 : defs_to_varying (gimple *stmt)
    4600                 :            : {
    4601                 :  179380000 :   bool changed = false;
    4602                 :  179380000 :   ssa_op_iter iter;
    4603                 :  179380000 :   def_operand_p defp;
    4604                 :            : 
    4605                 :  200556000 :   FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_ALL_DEFS)
    4606                 :            :     {
    4607                 :   21176400 :       tree def = DEF_FROM_PTR (defp);
    4608                 :   21176400 :       changed |= set_ssa_val_to (def, def);
    4609                 :            :     }
    4610                 :  179380000 :   return changed;
    4611                 :            : }
    4612                 :            : 
    4613                 :            : /* Visit a copy between LHS and RHS, return true if the value number
    4614                 :            :    changed.  */
    4615                 :            : 
    4616                 :            : static bool
    4617                 :    6065020 : visit_copy (tree lhs, tree rhs)
    4618                 :            : {
    4619                 :            :   /* Valueize.  */
    4620                 :          0 :   rhs = SSA_VAL (rhs);
    4621                 :            : 
    4622                 :    6065020 :   return set_ssa_val_to (lhs, rhs);
    4623                 :            : }
    4624                 :            : 
    4625                 :            : /* Lookup a value for OP in type WIDE_TYPE where the value in type of OP
    4626                 :            :    is the same.  */
    4627                 :            : 
    4628                 :            : static tree
    4629                 :    1594150 : valueized_wider_op (tree wide_type, tree op)
    4630                 :            : {
    4631                 :    1594150 :   if (TREE_CODE (op) == SSA_NAME)
    4632                 :    1413160 :     op = vn_valueize (op);
    4633                 :            : 
    4634                 :            :   /* Either we have the op widened available.  */
    4635                 :    1594150 :   tree ops[3] = {};
    4636                 :    1594150 :   ops[0] = op;
    4637                 :    1594150 :   tree tem = vn_nary_op_lookup_pieces (1, NOP_EXPR,
    4638                 :            :                                        wide_type, ops, NULL);
    4639                 :    1594150 :   if (tem)
    4640                 :            :     return tem;
    4641                 :            : 
    4642                 :            :   /* Or the op is truncated from some existing value.  */
    4643                 :    1402750 :   if (TREE_CODE (op) == SSA_NAME)
    4644                 :            :     {
    4645                 :    1196020 :       gimple *def = SSA_NAME_DEF_STMT (op);
    4646                 :    1196020 :       if (is_gimple_assign (def)
    4647                 :    1196020 :           && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
    4648                 :            :         {
    4649                 :     237885 :           tem = gimple_assign_rhs1 (def);
    4650                 :     237885 :           if (useless_type_conversion_p (wide_type, TREE_TYPE (tem)))
    4651                 :            :             {
    4652                 :     150164 :               if (TREE_CODE (tem) == SSA_NAME)
    4653                 :     150164 :                 tem = vn_valueize (tem);
    4654                 :     150164 :               return tem;
    4655                 :            :             }
    4656                 :            :         }
    4657                 :            :     }
    4658                 :            : 
    4659                 :            :   /* For constants simply extend it.  */
    4660                 :    1252580 :   if (TREE_CODE (op) == INTEGER_CST)
    4661                 :     206725 :     return wide_int_to_tree (wide_type, wi::to_wide (op));
    4662                 :            : 
    4663                 :            :   return NULL_TREE;
    4664                 :            : }
    4665                 :            : 
    4666                 :            : /* Visit a nary operator RHS, value number it, and return true if the
    4667                 :            :    value number of LHS has changed as a result.  */
    4668                 :            : 
    4669                 :            : static bool
    4670                 :   29077500 : visit_nary_op (tree lhs, gassign *stmt)
    4671                 :            : {
    4672                 :   29077500 :   vn_nary_op_t vnresult;
    4673                 :   29077500 :   tree result = vn_nary_op_lookup_stmt (stmt, &vnresult);
    4674                 :   29077500 :   if (! result && vnresult)
    4675                 :     117138 :     result = vn_nary_op_get_predicated_value (vnresult, gimple_bb (stmt));
    4676                 :   29077500 :   if (result)
    4677                 :    2365230 :     return set_ssa_val_to (lhs, result);
    4678                 :            : 
    4679                 :            :   /* Do some special pattern matching for redundancies of operations
    4680                 :            :      in different types.  */
    4681                 :   26712200 :   enum tree_code code = gimple_assign_rhs_code (stmt);
    4682                 :   26712200 :   tree type = TREE_TYPE (lhs);
    4683                 :   26712200 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    4684                 :   26712200 :   switch (code)
    4685                 :            :     {
    4686                 :    6574140 :     CASE_CONVERT:
    4687                 :            :       /* Match arithmetic done in a different type where we can easily
    4688                 :            :          substitute the result from some earlier sign-changed or widened
    4689                 :            :          operation.  */
    4690                 :    6574140 :       if (INTEGRAL_TYPE_P (type)
    4691                 :    6104410 :           && TREE_CODE (rhs1) == SSA_NAME
    4692                 :            :           /* We only handle sign-changes, zero-extension -> & mask or
    4693                 :            :              sign-extension if we know the inner operation doesn't
    4694                 :            :              overflow.  */
    4695                 :   12493600 :           && (((TYPE_UNSIGNED (TREE_TYPE (rhs1))
    4696                 :    3442030 :                 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
    4697                 :    9360800 :                     && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1))))
    4698                 :    5304110 :                && TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (rhs1)))
    4699                 :    4086080 :               || TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (rhs1))))
    4700                 :            :         {
    4701                 :   30458800 :           gassign *def = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (rhs1));
    4702                 :    3752870 :           if (def
    4703                 :    3752870 :               && (gimple_assign_rhs_code (def) == PLUS_EXPR
    4704                 :    2860790 :                   || gimple_assign_rhs_code (def) == MINUS_EXPR
    4705                 :    2784570 :                   || gimple_assign_rhs_code (def) == MULT_EXPR))
    4706                 :            :             {
    4707                 :    1257110 :               tree ops[3] = {};
    4708                 :            :               /* Either we have the op widened available.  */
    4709                 :    1257110 :               ops[0] = valueized_wider_op (type,
    4710                 :            :                                            gimple_assign_rhs1 (def));
    4711                 :    1257110 :               if (ops[0])
    4712                 :     674078 :                 ops[1] = valueized_wider_op (type,
    4713                 :            :                                              gimple_assign_rhs2 (def));
    4714                 :    1257110 :               if (ops[0] && ops[1])
    4715                 :            :                 {
    4716                 :     211249 :                   ops[0] = vn_nary_op_lookup_pieces
    4717                 :     211249 :                       (2, gimple_assign_rhs_code (def), type, ops, NULL);
    4718                 :            :                   /* We have wider operation available.  */
    4719                 :     211249 :                   if (ops[0]
    4720                 :            :                       /* If the leader is a wrapping operation we can
    4721                 :            :                          insert it for code hoisting w/o introducing
    4722                 :            :                          undefined overflow.  If it is not it has to
    4723                 :            :                          be available.  See PR86554.  */
    4724                 :     213502 :                       && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (ops[0]))
    4725                 :       2253 :                           || (rpo_avail && vn_context_bb
    4726                 :       2253 :                               && rpo_avail->eliminate_avail (vn_context_bb,
    4727                 :       2253 :                                                              ops[0]))))
    4728                 :            :                     {
    4729                 :       6153 :                       unsigned lhs_prec = TYPE_PRECISION (type);
    4730                 :       6153 :                       unsigned rhs_prec = TYPE_PRECISION (TREE_TYPE (rhs1));
    4731                 :       6153 :                       if (lhs_prec == rhs_prec
    4732                 :       6153 :                           || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
    4733                 :        710 :                               && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (rhs1))))
    4734                 :            :                         {
    4735                 :       5613 :                           gimple_match_op match_op (gimple_match_cond::UNCOND,
    4736                 :       5613 :                                                     NOP_EXPR, type, ops[0]);
    4737                 :       5613 :                           result = vn_nary_build_or_lookup (&match_op);
    4738                 :       5613 :                           if (result)
    4739                 :            :                             {
    4740                 :       5613 :                               bool changed = set_ssa_val_to (lhs, result);
    4741                 :       5613 :                               vn_nary_op_insert_stmt (stmt, result);
    4742                 :       5613 :                               return changed;
    4743                 :            :                             }
    4744                 :            :                         }
    4745                 :            :                       else
    4746                 :            :                         {
    4747                 :        540 :                           tree mask = wide_int_to_tree
    4748                 :        540 :                             (type, wi::mask (rhs_prec, false, lhs_prec));
    4749                 :        540 :                           gimple_match_op match_op (gimple_match_cond::UNCOND,
    4750                 :            :                                                     BIT_AND_EXPR,
    4751                 :        540 :                                                     TREE_TYPE (lhs),
    4752                 :        540 :                                                     ops[0], mask);
    4753                 :        540 :                           result = vn_nary_build_or_lookup (&match_op);
    4754                 :        540 :                           if (result)
    4755                 :            :                             {
    4756                 :        540 :                               bool changed = set_ssa_val_to (lhs, result);
    4757                 :        540 :                               vn_nary_op_insert_stmt (stmt, result);
    4758                 :        540 :                               return changed;
    4759                 :            :                             }
    4760                 :            :                         }
    4761                 :            :                     }
    4762                 :            :                 }
    4763                 :            :             }
    4764                 :            :         }
    4765                 :            :       break;
    4766                 :     900363 :     case BIT_AND_EXPR:
    4767                 :     900363 :       if (INTEGRAL_TYPE_P (type)
    4768                 :     896396 :           && TREE_CODE (rhs1) == SSA_NAME
    4769                 :     896396 :           && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST
    4770                 :     554625 :           && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)
    4771                 :     554625 :           && default_vn_walk_kind != VN_NOWALK
    4772                 :            :           && CHAR_BIT == 8
    4773                 :            :           && BITS_PER_UNIT == 8
    4774                 :            :           && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
    4775                 :     554625 :           && !integer_all_onesp (gimple_assign_rhs2 (stmt))
    4776                 :    1454990 :           && !integer_zerop (gimple_assign_rhs2 (stmt)))
    4777                 :            :         {
    4778                 :     554625 :           gassign *ass = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (rhs1));
    4779                 :     407794 :           if (ass
    4780                 :     407794 :               && !gimple_has_volatile_ops (ass)
    4781                 :     404203 :               && vn_get_stmt_kind (ass) == VN_REFERENCE)
    4782                 :            :             {
    4783                 :     168682 :               tree last_vuse = gimple_vuse (ass);
    4784                 :     168682 :               tree op = gimple_assign_rhs1 (ass);
    4785                 :     506046 :               tree result = vn_reference_lookup (op, gimple_vuse (ass),
    4786                 :            :                                                  default_vn_walk_kind,
    4787                 :            :                                                  NULL, true, &last_vuse,
    4788                 :            :                                                  gimple_assign_rhs2 (stmt));
    4789                 :     168682 :               if (result
    4790                 :     168812 :                   && useless_type_conversion_p (TREE_TYPE (result),
    4791                 :        130 :                                                 TREE_TYPE (op)))
    4792                 :        130 :                 return set_ssa_val_to (lhs, result);
    4793                 :            :             }
    4794                 :            :         }
    4795                 :            :       break;
    4796                 :            :     default:
    4797                 :            :       break;
    4798                 :            :     }
    4799                 :            : 
    4800                 :   26705900 :   bool changed = set_ssa_val_to (lhs, lhs);
    4801                 :   26705900 :   vn_nary_op_insert_stmt (stmt, lhs);
    4802                 :   26705900 :   return changed;
    4803                 :            : }
    4804                 :            : 
    4805                 :            : /* Visit a call STMT storing into LHS.  Return true if the value number
    4806                 :            :    of the LHS has changed as a result.  */
    4807                 :            : 
    4808                 :            : static bool
    4809                 :    4790550 : visit_reference_op_call (tree lhs, gcall *stmt)
    4810                 :            : {
    4811                 :    4790550 :   bool changed = false;
    4812                 :    4790550 :   struct vn_reference_s vr1;
    4813                 :    4790550 :   vn_reference_t vnresult = NULL;
    4814                 :    4790550 :   tree vdef = gimple_vdef (stmt);
    4815                 :            : 
    4816                 :            :   /* Non-ssa lhs is handled in copy_reference_ops_from_call.  */
    4817                 :    4790550 :   if (lhs && TREE_CODE (lhs) != SSA_NAME)
    4818                 :     314234 :     lhs = NULL_TREE;
    4819                 :            : 
    4820                 :    4790550 :   vn_reference_lookup_call (stmt, &vnresult, &vr1);
    4821                 :    4790550 :   if (vnresult)
    4822                 :            :     {
    4823                 :     112920 :       if (vnresult->result_vdef && vdef)
    4824                 :      68237 :         changed |= set_ssa_val_to (vdef, vnresult->result_vdef);
    4825                 :      44683 :       else if (vdef)
    4826                 :            :         /* If the call was discovered to be pure or const reflect
    4827                 :            :            that as far as possible.  */
    4828                 :          0 :         changed |= set_ssa_val_to (vdef, vuse_ssa_val (gimple_vuse (stmt)));
    4829                 :            : 
    4830                 :     112920 :       if (!vnresult->result && lhs)
    4831                 :        240 :         vnresult->result = lhs;
    4832                 :            : 
    4833                 :     112920 :       if (vnresult->result && lhs)
    4834                 :      48061 :         changed |= set_ssa_val_to (lhs, vnresult->result);
    4835                 :            :     }
    4836                 :            :   else
    4837                 :            :     {
    4838                 :    4677630 :       vn_reference_t vr2;
    4839                 :    4677630 :       vn_reference_s **slot;
    4840                 :    4677630 :       tree vdef_val = vdef;
    4841                 :    4677630 :       if (vdef)
    4842                 :            :         {
    4843                 :            :           /* If we value numbered an indirect functions function to
    4844                 :            :              one not clobbering memory value number its VDEF to its
    4845                 :            :              VUSE.  */
    4846                 :    3483250 :           tree fn = gimple_call_fn (stmt);
    4847                 :    3483250 :           if (fn && TREE_CODE (fn) == SSA_NAME)
    4848                 :            :             {
    4849                 :     105691 :               fn = SSA_VAL (fn);
    4850                 :     105691 :               if (TREE_CODE (fn) == ADDR_EXPR
    4851                 :        792 :                   && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
    4852                 :     106483 :                   && (flags_from_decl_or_type (TREE_OPERAND (fn, 0))
    4853                 :        792 :                       & (ECF_CONST | ECF_PURE)))
    4854                 :        868 :                 vdef_val = vuse_ssa_val (gimple_vuse (stmt));
    4855                 :            :             }
    4856                 :    3483250 :           changed |= set_ssa_val_to (vdef, vdef_val);
    4857                 :            :         }
    4858                 :    4677630 :       if (lhs)
    4859                 :    1971120 :         changed |= set_ssa_val_to (lhs, lhs);
    4860                 :    4677630 :       vr2 = XOBNEW (&vn_tables_obstack, vn_reference_s);
    4861                 :    4677630 :       vr2->vuse = vr1.vuse;
    4862                 :            :       /* As we are not walking the virtual operand chain we know the
    4863                 :            :          shared_lookup_references are still original so we can re-use
    4864                 :            :          them here.  */
    4865                 :    4677630 :       vr2->operands = vr1.operands.copy ();
    4866                 :    4677630 :       vr2->type = vr1.type;
    4867                 :    4677630 :       vr2->set = vr1.set;
    4868                 :    4677630 :       vr2->base_set = vr1.base_set;
    4869                 :    4677630 :       vr2->hashcode = vr1.hashcode;
    4870                 :    4677630 :       vr2->result = lhs;
    4871                 :    4677630 :       vr2->result_vdef = vdef_val;
    4872                 :    4677630 :       vr2->value_id = 0;
    4873                 :    4677630 :       slot = valid_info->references->find_slot_with_hash (vr2, vr2->hashcode,
    4874                 :            :                                                           INSERT);
    4875                 :    4677630 :       gcc_assert (!*slot);
    4876                 :    4677630 :       *slot = vr2;
    4877                 :    4677630 :       vr2->next = last_inserted_ref;
    4878                 :    4677630 :       last_inserted_ref = vr2;
    4879                 :            :     }
    4880                 :            : 
    4881                 :    4790550 :   return changed;
    4882                 :            : }
    4883                 :            : 
    4884                 :            : /* Visit a load from a reference operator RHS, part of STMT, value number it,
    4885                 :            :    and return true if the value number of the LHS has changed as a result.  */
    4886                 :            : 
    4887                 :            : static bool
    4888                 :   21066800 : visit_reference_op_load (tree lhs, tree op, gimple *stmt)
    4889                 :            : {
    4890                 :   21066800 :   bool changed = false;
    4891                 :   21066800 :   tree last_vuse;
    4892                 :   21066800 :   tree result;
    4893                 :            : 
    4894                 :   21066800 :   last_vuse = gimple_vuse (stmt);
    4895                 :   42133500 :   result = vn_reference_lookup (op, gimple_vuse (stmt),
    4896                 :            :                                 default_vn_walk_kind, NULL, true, &last_vuse);
    4897                 :            : 
    4898                 :            :   /* We handle type-punning through unions by value-numbering based
    4899                 :            :      on offset and size of the access.  Be prepared to handle a
    4900                 :            :      type-mismatch here via creating a VIEW_CONVERT_EXPR.  */
    4901                 :   21066800 :   if (result
    4902                 :   23866300 :       && !useless_type_conversion_p (TREE_TYPE (result), TREE_TYPE (op)))
    4903                 :            :     {
    4904                 :            :       /* Avoid the type punning in case the result mode has padding where
    4905                 :            :          the op we lookup has not.  */
    4906                 :      20434 :       if (maybe_lt (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (result))),
    4907                 :      10217 :                     GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (op)))))
    4908                 :            :         result = NULL_TREE;
    4909                 :            :       else
    4910                 :            :         {
    4911                 :            :           /* We will be setting the value number of lhs to the value number
    4912                 :            :              of VIEW_CONVERT_EXPR <TREE_TYPE (result)> (result).
    4913                 :            :              So first simplify and lookup this expression to see if it
    4914                 :            :              is already available.  */
    4915                 :      10048 :           gimple_match_op res_op (gimple_match_cond::UNCOND,
    4916                 :      10048 :                                   VIEW_CONVERT_EXPR, TREE_TYPE (op), result);
    4917                 :      10048 :           result = vn_nary_build_or_lookup (&res_op);
    4918                 :            :         }
    4919                 :            : 
    4920                 :            :       /* When building the conversion fails avoid inserting the reference
    4921                 :            :          again.  */
    4922                 :      10048 :       if (!result)
    4923                 :        169 :         return set_ssa_val_to (lhs, lhs);
    4924                 :            :     }
    4925                 :            : 
    4926                 :   21066600 :   if (result)
    4927                 :    2799330 :     changed = set_ssa_val_to (lhs, result);
    4928                 :            :   else
    4929                 :            :     {
    4930                 :   18267300 :       changed = set_ssa_val_to (lhs, lhs);
    4931                 :   18267300 :       vn_reference_insert (op, lhs, last_vuse, NULL_TREE);
    4932                 :            :     }
    4933                 :            : 
    4934                 :            :   return changed;
    4935                 :            : }
    4936                 :            : 
    4937                 :            : 
    4938                 :            : /* Visit a store to a reference operator LHS, part of STMT, value number it,
    4939                 :            :    and return true if the value number of the LHS has changed as a result.  */
    4940                 :            : 
    4941                 :            : static bool
    4942                 :   22309500 : visit_reference_op_store (tree lhs, tree op, gimple *stmt)
    4943                 :            : {
    4944                 :   22309500 :   bool changed = false;
    4945                 :   22309500 :   vn_reference_t vnresult = NULL;
    4946                 :   22309500 :   tree assign;
    4947                 :   22309500 :   bool resultsame = false;
    4948                 :   22309500 :   tree vuse = gimple_vuse (stmt);
    4949                 :   22309500 :   tree vdef = gimple_vdef (stmt);
    4950                 :            : 
    4951                 :   22309500 :   if (TREE_CODE (op) == SSA_NAME)
    4952                 :    9977860 :     op = SSA_VAL (op);
    4953                 :            : 
    4954                 :            :   /* First we want to lookup using the *vuses* from the store and see
    4955                 :            :      if there the last store to this location with the same address
    4956                 :            :      had the same value.
    4957                 :            : 
    4958                 :            :      The vuses represent the memory state before the store.  If the
    4959                 :            :      memory state, address, and value of the store is the same as the
    4960                 :            :      last store to this location, then this store will produce the
    4961                 :            :      same memory state as that store.
    4962                 :            : 
    4963                 :            :      In this case the vdef versions for this store are value numbered to those
    4964                 :            :      vuse versions, since they represent the same memory state after
    4965                 :            :      this store.
    4966                 :            : 
    4967                 :            :      Otherwise, the vdefs for the store are used when inserting into
    4968                 :            :      the table, since the store generates a new memory state.  */
    4969                 :            : 
    4970                 :   22309500 :   vn_reference_lookup (lhs, vuse, VN_NOWALK, &vnresult, false);
    4971                 :   22309500 :   if (vnresult
    4972                 :   22309500 :       && vnresult->result)
    4973                 :            :     {
    4974                 :     841485 :       tree result = vnresult->result;
    4975                 :     841485 :       gcc_checking_assert (TREE_CODE (result) != SSA_NAME
    4976                 :            :                            || result == SSA_VAL (result));
    4977                 :     841485 :       resultsame = expressions_equal_p (result, op);
    4978                 :     841485 :       if (resultsame)
    4979                 :            :         {
    4980                 :            :           /* If the TBAA state isn't compatible for downstream reads
    4981                 :            :              we cannot value-number the VDEFs the same.  */
    4982                 :      34672 :           ao_ref lhs_ref;
    4983                 :      34672 :           ao_ref_init (&lhs_ref, lhs);
    4984                 :      34672 :           alias_set_type set = ao_ref_alias_set (&lhs_ref);
    4985                 :      34672 :           alias_set_type base_set = ao_ref_base_alias_set (&lhs_ref);
    4986                 :      34672 :           if ((vnresult->set != set
    4987                 :       2054 :                && ! alias_set_subset_of (set, vnresult->set))
    4988                 :      35296 :               || (vnresult->base_set != base_set
    4989                 :       5856 :                   && ! alias_set_subset_of (base_set, vnresult->base_set)))
    4990                 :       1544 :             resultsame = false;
    4991                 :            :         }
    4992                 :            :     }
    4993                 :            : 
    4994                 :     841485 :   if (!resultsame)
    4995                 :            :     {
    4996                 :            :       /* Only perform the following when being called from PRE
    4997                 :            :          which embeds tail merging.  */
    4998                 :   22276400 :       if (default_vn_walk_kind == VN_WALK)
    4999                 :            :         {
    5000                 :    5344980 :           assign = build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, op);
    5001                 :    5344980 :           vn_reference_lookup (assign, vuse, VN_NOWALK, &vnresult, false);
    5002                 :    5344980 :           if (vnresult)
    5003                 :            :             {
    5004                 :      34824 :               VN_INFO (vdef)->visited = true;
    5005                 :      34824 :               return set_ssa_val_to (vdef, vnresult->result_vdef);
    5006                 :            :             }
    5007                 :            :         }
    5008                 :            : 
    5009                 :   22241600 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5010                 :            :         {
    5011                 :        281 :           fprintf (dump_file, "No store match\n");
    5012                 :        281 :           fprintf (dump_file, "Value numbering store ");
    5013                 :        281 :           print_generic_expr (dump_file, lhs);
    5014                 :        281 :           fprintf (dump_file, " to ");
    5015                 :        281 :           print_generic_expr (dump_file, op);
    5016                 :        281 :           fprintf (dump_file, "\n");
    5017                 :            :         }
    5018                 :            :       /* Have to set value numbers before insert, since insert is
    5019                 :            :          going to valueize the references in-place.  */
    5020                 :   22241600 :       if (vdef)
    5021                 :   22241600 :         changed |= set_ssa_val_to (vdef, vdef);
    5022                 :            : 
    5023                 :            :       /* Do not insert structure copies into the tables.  */
    5024                 :   22241600 :       if (is_gimple_min_invariant (op)
    5025                 :   22241600 :           || is_gimple_reg (op))
    5026                 :   19689100 :         vn_reference_insert (lhs, op, vdef, NULL);
    5027                 :            : 
    5028                 :            :       /* Only perform the following when being called from PRE
    5029                 :            :          which embeds tail merging.  */
    5030                 :   22241600 :       if (default_vn_walk_kind == VN_WALK)
    5031                 :            :         {
    5032                 :    5310150 :           assign = build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, op);
    5033                 :    5310150 :           vn_reference_insert (assign, lhs, vuse, vdef);
    5034                 :            :         }
    5035                 :            :     }
    5036                 :            :   else
    5037                 :            :     {
    5038                 :            :       /* We had a match, so value number the vdef to have the value
    5039                 :            :          number of the vuse it came from.  */
    5040                 :            : 
    5041                 :      33128 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5042                 :          8 :         fprintf (dump_file, "Store matched earlier value, "
    5043                 :            :                  "value numbering store vdefs to matching vuses.\n");
    5044                 :            : 
    5045                 :      33128 :       changed |= set_ssa_val_to (vdef, SSA_VAL (vuse));
    5046                 :            :     }
    5047                 :            : 
    5048                 :            :   return changed;
    5049                 :            : }
    5050                 :            : 
    5051                 :            : /* Visit and value number PHI, return true if the value number
    5052                 :            :    changed.  When BACKEDGES_VARYING_P is true then assume all
    5053                 :            :    backedge values are varying.  When INSERTED is not NULL then
    5054                 :            :    this is just a ahead query for a possible iteration, set INSERTED
    5055                 :            :    to true if we'd insert into the hashtable.  */
    5056                 :            : 
    5057                 :            : static bool
    5058                 :   20759100 : visit_phi (gimple *phi, bool *inserted, bool backedges_varying_p)
    5059                 :            : {
    5060                 :   20759100 :   tree result, sameval = VN_TOP, seen_undef = NULL_TREE;
    5061                 :   20759100 :   tree backedge_val = NULL_TREE;
    5062                 :   20759100 :   bool seen_non_backedge = false;
    5063                 :   20759100 :   tree sameval_base = NULL_TREE;
    5064                 :   20759100 :   poly_int64 soff, doff;
    5065                 :   20759100 :   unsigned n_executable = 0;
    5066                 :   20759100 :   edge_iterator ei;
    5067                 :   20759100 :   edge e;
    5068                 :            : 
    5069                 :            :   /* TODO: We could check for this in initialization, and replace this
    5070                 :            :      with a gcc_assert.  */
    5071                 :   20759100 :   if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi)))
    5072                 :      20020 :     return set_ssa_val_to (PHI_RESULT (phi), PHI_RESULT (phi));
    5073                 :            : 
    5074                 :            :   /* We track whether a PHI was CSEd to to avoid excessive iterations
    5075                 :            :      that would be necessary only because the PHI changed arguments
    5076                 :            :      but not value.  */
    5077                 :   20739100 :   if (!inserted)
    5078                 :   16167400 :     gimple_set_plf (phi, GF_PLF_1, false);
    5079                 :            : 
    5080                 :            :   /* See if all non-TOP arguments have the same value.  TOP is
    5081                 :            :      equivalent to everything, so we can ignore it.  */
    5082                 :   45487300 :   FOR_EACH_EDGE (e, ei, gimple_bb (phi)->preds)
    5083                 :   41176200 :     if (e->flags & EDGE_EXECUTABLE)
    5084                 :            :       {
    5085                 :   38245500 :         tree def = PHI_ARG_DEF_FROM_EDGE (phi, e);
    5086                 :            : 
    5087                 :   38245500 :         ++n_executable;
    5088                 :   38245500 :         if (TREE_CODE (def) == SSA_NAME)
    5089                 :            :           {
    5090                 :   31984400 :             if (!backedges_varying_p || !(e->flags & EDGE_DFS_BACK))
    5091                 :   30952300 :               def = SSA_VAL (def);
    5092                 :   31984400 :             if (e->flags & EDGE_DFS_BACK)
    5093                 :    8959460 :               backedge_val = def;
    5094                 :            :           }
    5095                 :   38245500 :         if (!(e->flags & EDGE_DFS_BACK))
    5096                 :   29224000 :           seen_non_backedge = true;
    5097                 :   38245500 :         if (def == VN_TOP)
    5098                 :            :           ;
    5099                 :            :         /* Ignore undefined defs for sameval but record one.  */
    5100                 :   38245500 :         else if (TREE_CODE (def) == SSA_NAME
    5101                 :   30080700 :                  && ! virtual_operand_p (def)
    5102                 :   52320900 :                  && ssa_undefined_value_p (def, false))
    5103                 :            :           seen_undef = def;
    5104                 :   38094800 :         else if (sameval == VN_TOP)
    5105                 :            :           sameval = def;
    5106                 :   17384700 :         else if (!expressions_equal_p (def, sameval))
    5107                 :            :           {
    5108                 :            :             /* We know we're arriving only with invariant addresses here,
    5109                 :            :                try harder comparing them.  We can do some caching here
    5110                 :            :                which we cannot do in expressions_equal_p.  */
    5111                 :   16428000 :             if (TREE_CODE (def) == ADDR_EXPR
    5112                 :     114033 :                 && TREE_CODE (sameval) == ADDR_EXPR
    5113                 :      70826 :                 && sameval_base != (void *)-1)
    5114                 :            :               {
    5115                 :      70826 :                 if (!sameval_base)
    5116                 :      70824 :                   sameval_base = get_addr_base_and_unit_offset
    5117                 :      70824 :                                    (TREE_OPERAND (sameval, 0), &soff);
    5118                 :      70826 :                 if (!sameval_base)
    5119                 :   20739100 :                   sameval_base = (tree)(void *)-1;
    5120                 :      70857 :                 else if ((get_addr_base_and_unit_offset
    5121                 :      70826 :                             (TREE_OPERAND (def, 0), &doff) == sameval_base)
    5122                 :      70826 :                          && known_eq (soff, doff))
    5123                 :         31 :                   continue;
    5124                 :            :               }
    5125                 :            :             sameval = NULL_TREE;
    5126                 :            :             break;
    5127                 :            :           }
    5128                 :            :       }
    5129                 :            : 
    5130                 :            :   /* If the value we want to use is flowing over the backedge and we
    5131                 :            :      should take it as VARYING but it has a non-VARYING value drop to
    5132                 :            :      VARYING.
    5133                 :            :      If we value-number a virtual operand never value-number to the
    5134                 :            :      value from the backedge as that confuses the alias-walking code.
    5135                 :            :      See gcc.dg/torture/pr87176.c.  If the value is the same on a
    5136                 :            :      non-backedge everything is OK though.  */
    5137                 :   20739100 :   bool visited_p;
    5138                 :   20739100 :   if ((backedge_val
    5139                 :   20739100 :        && !seen_non_backedge
    5140                 :      11521 :        && TREE_CODE (backedge_val) == SSA_NAME
    5141                 :      11175 :        && sameval == backedge_val
    5142                 :       1869 :        && (SSA_NAME_IS_VIRTUAL_OPERAND (backedge_val)
    5143                 :       1869 :            || SSA_VAL (backedge_val) != backedge_val))
    5144                 :            :       /* Do not value-number a virtual operand to sth not visited though
    5145                 :            :          given that allows us to escape a region in alias walking.  */
    5146                 :   20749600 :       || (sameval
    5147                 :    4310100 :           && TREE_CODE (sameval) == SSA_NAME
    5148                 :    2834720 :           && !SSA_NAME_IS_DEFAULT_DEF (sameval)
    5149                 :    2402740 :           && SSA_NAME_IS_VIRTUAL_OPERAND (sameval)
    5150                 :    1060520 :           && (SSA_VAL (sameval, &visited_p), !visited_p)))
    5151                 :            :     /* Note this just drops to VARYING without inserting the PHI into
    5152                 :            :        the hashes.  */
    5153                 :     118134 :     result = PHI_RESULT (phi);
    5154                 :            :   /* If none of the edges was executable keep the value-number at VN_TOP,
    5155                 :            :      if only a single edge is exectuable use its value.  */
    5156                 :   20621000 :   else if (n_executable <= 1)
    5157                 :    3714420 :     result = seen_undef ? seen_undef : sameval;
    5158                 :            :   /* If we saw only undefined values and VN_TOP use one of the
    5159                 :            :      undefined values.  */
    5160                 :   16906500 :   else if (sameval == VN_TOP)
    5161                 :       3719 :     result = seen_undef ? seen_undef : sameval;
    5162                 :            :   /* First see if it is equivalent to a phi node in this block.  We prefer
    5163                 :            :      this as it allows IV elimination - see PRs 66502 and 67167.  */
    5164                 :   16902800 :   else if ((result = vn_phi_lookup (phi, backedges_varying_p)))
    5165                 :            :     {
    5166                 :    2641660 :       if (!inserted
    5167                 :      35401 :           && TREE_CODE (result) == SSA_NAME
    5168                 :    2677060 :           && gimple_code (SSA_NAME_DEF_STMT (result)) == GIMPLE_PHI)
    5169                 :            :         {
    5170                 :      35401 :           gimple_set_plf (SSA_NAME_DEF_STMT (result), GF_PLF_1, true);
    5171                 :      35401 :           if (dump_file && (dump_flags & TDF_DETAILS))
    5172                 :            :             {
    5173                 :          1 :               fprintf (dump_file, "Marking CSEd to PHI node ");
    5174                 :          1 :               print_gimple_expr (dump_file, SSA_NAME_DEF_STMT (result),
    5175                 :            :                                  0, TDF_SLIM);
    5176                 :          1 :               fprintf (dump_file, "\n");
    5177                 :            :             }
    5178                 :            :         }
    5179                 :            :     }
    5180                 :            :   /* If all values are the same use that, unless we've seen undefined
    5181                 :            :      values as well and the value isn't constant.
    5182                 :            :      CCP/copyprop have the same restriction to not remove uninit warnings.  */
    5183                 :   14261200 :   else if (sameval
    5184                 :   14261200 :            && (! seen_undef || is_gimple_min_invariant (sameval)))
    5185                 :            :     result = sameval;
    5186                 :            :   else
    5187                 :            :     {
    5188                 :   13882500 :       result = PHI_RESULT (phi);
    5189                 :            :       /* Only insert PHIs that are varying, for constant value numbers
    5190                 :            :          we mess up equivalences otherwise as we are only comparing
    5191                 :            :          the immediate controlling predicates.  */
    5192                 :   13882500 :       vn_phi_insert (phi, result, backedges_varying_p);
    5193                 :   13882500 :       if (inserted)
    5194                 :    1876560 :         *inserted = true;
    5195                 :            :     }
    5196                 :            : 
    5197                 :   20739100 :   return set_ssa_val_to (PHI_RESULT (phi), result);
    5198                 :            : }
    5199                 :            : 
    5200                 :            : /* Try to simplify RHS using equivalences and constant folding.  */
    5201                 :            : 
    5202                 :            : static tree
    5203                 :   78990000 : try_to_simplify (gassign *stmt)
    5204                 :            : {
    5205                 :   78990000 :   enum tree_code code = gimple_assign_rhs_code (stmt);
    5206                 :   78990000 :   tree tem;
    5207                 :            : 
    5208                 :            :   /* For stores we can end up simplifying a SSA_NAME rhs.  Just return
    5209                 :            :      in this case, there is no point in doing extra work.  */
    5210                 :   78990000 :   if (code == SSA_NAME)
    5211                 :            :     return NULL_TREE;
    5212                 :            : 
    5213                 :            :   /* First try constant folding based on our current lattice.  */
    5214                 :   69011900 :   mprts_hook = vn_lookup_simplify_result;
    5215                 :   69011900 :   tem = gimple_fold_stmt_to_constant_1 (stmt, vn_valueize, vn_valueize);
    5216                 :   69011900 :   mprts_hook = NULL;
    5217                 :   69011900 :   if (tem
    5218                 :   69011900 :       && (TREE_CODE (tem) == SSA_NAME
    5219                 :   16058300 :           || is_gimple_min_invariant (tem)))
    5220                 :   16281800 :     return tem;
    5221                 :            : 
    5222                 :            :   return NULL_TREE;
    5223                 :            : }
    5224                 :            : 
    5225                 :            : /* Visit and value number STMT, return true if the value number
    5226                 :            :    changed.  */
    5227                 :            : 
    5228                 :            : static bool
    5229                 :  283325000 : visit_stmt (gimple *stmt, bool backedges_varying_p = false)
    5230                 :            : {
    5231                 :  283325000 :   bool changed = false;
    5232                 :            : 
    5233                 :  283325000 :   if (dump_file && (dump_flags & TDF_DETAILS))
    5234                 :            :     {
    5235                 :       2509 :       fprintf (dump_file, "Value numbering stmt = ");
    5236                 :       2509 :       print_gimple_stmt (dump_file, stmt, 0);
    5237                 :            :     }
    5238                 :            : 
    5239                 :  283325000 :   if (gimple_code (stmt) == GIMPLE_PHI)
    5240                 :   16181600 :     changed = visit_phi (stmt, NULL, backedges_varying_p);
    5241                 :  376474000 :   else if (gimple_has_volatile_ops (stmt))
    5242                 :    6564880 :     changed = defs_to_varying (stmt);
    5243                 :  260579000 :   else if (gassign *ass = dyn_cast <gassign *> (stmt))
    5244                 :            :     {
    5245                 :   82990100 :       enum tree_code code = gimple_assign_rhs_code (ass);
    5246                 :   82990100 :       tree lhs = gimple_assign_lhs (ass);
    5247                 :   82990100 :       tree rhs1 = gimple_assign_rhs1 (ass);
    5248                 :   82990100 :       tree simplified;
    5249                 :            : 
    5250                 :            :       /* Shortcut for copies. Simplifying copies is pointless,
    5251                 :            :          since we copy the expression and value they represent.  */
    5252                 :   82990100 :       if (code == SSA_NAME
    5253                 :   13978200 :           && TREE_CODE (lhs) == SSA_NAME)
    5254                 :            :         {
    5255                 :    4000160 :           changed = visit_copy (lhs, rhs1);
    5256                 :    4000160 :           goto done;
    5257                 :            :         }
    5258                 :   78990000 :       simplified = try_to_simplify (ass);
    5259                 :   78990000 :       if (simplified)
    5260                 :            :         {
    5261                 :   16281800 :           if (dump_file && (dump_flags & TDF_DETAILS))
    5262                 :            :             {
    5263                 :        371 :               fprintf (dump_file, "RHS ");
    5264                 :        371 :               print_gimple_expr (dump_file, ass, 0);
    5265                 :        371 :               fprintf (dump_file, " simplified to ");
    5266                 :        371 :               print_generic_expr (dump_file, simplified);
    5267                 :        371 :               fprintf (dump_file, "\n");
    5268                 :            :             }
    5269                 :            :         }
    5270                 :            :       /* Setting value numbers to constants will occasionally
    5271                 :            :          screw up phi congruence because constants are not
    5272                 :            :          uniquely associated with a single ssa name that can be
    5273                 :            :          looked up.  */
    5274                 :   78990000 :       if (simplified
    5275                 :   16281800 :           && is_gimple_min_invariant (simplified)
    5276                 :   93207200 :           && TREE_CODE (lhs) == SSA_NAME)
    5277                 :            :         {
    5278                 :    4438550 :           changed = set_ssa_val_to (lhs, simplified);
    5279                 :    4438550 :           goto done;
    5280                 :            :         }
    5281                 :   74551400 :       else if (simplified
    5282                 :   11843300 :                && TREE_CODE (simplified) == SSA_NAME
    5283                 :    2064540 :                && TREE_CODE (lhs) == SSA_NAME)
    5284                 :            :         {
    5285                 :    2064540 :           changed = visit_copy (lhs, simplified);
    5286                 :    2064540 :           goto done;
    5287                 :            :         }
    5288                 :            : 
    5289                 :   72486900 :       if ((TREE_CODE (lhs) == SSA_NAME
    5290                 :            :            /* We can substitute SSA_NAMEs that are live over
    5291                 :            :               abnormal edges with their constant value.  */
    5292                 :   50177200 :            && !(gimple_assign_copy_p (ass)
    5293                 :          0 :                 && is_gimple_min_invariant (rhs1))
    5294                 :   50177200 :            && !(simplified
    5295                 :          0 :                 && is_gimple_min_invariant (simplified))
    5296                 :   50177200 :            && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
    5297                 :            :           /* Stores or copies from SSA_NAMEs that are live over
    5298                 :            :              abnormal edges are a problem.  */
    5299                 :  122663000 :           || (code == SSA_NAME
    5300                 :    9978050 :               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)))
    5301                 :       1256 :         changed = defs_to_varying (ass);
    5302                 :   72485600 :       else if (REFERENCE_CLASS_P (lhs)
    5303                 :   72485600 :                || DECL_P (lhs))
    5304                 :   22309500 :         changed = visit_reference_op_store (lhs, rhs1, ass);
    5305                 :   50176100 :       else if (TREE_CODE (lhs) == SSA_NAME)
    5306                 :            :         {
    5307                 :   50176100 :           if ((gimple_assign_copy_p (ass)
    5308                 :          0 :                && is_gimple_min_invariant (rhs1))
    5309                 :   50176100 :               || (simplified
    5310                 :          0 :                   && is_gimple_min_invariant (simplified)))
    5311                 :            :             {
    5312                 :          0 :               if (simplified)
    5313                 :          0 :                 changed = set_ssa_val_to (lhs, simplified);
    5314                 :            :               else
    5315                 :          0 :                 changed = set_ssa_val_to (lhs, rhs1);
    5316                 :            :             }
    5317                 :            :           else
    5318                 :            :             {
    5319                 :            :               /* Visit the original statement.  */
    5320                 :   50176100 :               switch (vn_get_stmt_kind (ass))
    5321                 :            :                 {
    5322                 :   29077500 :                 case VN_NARY:
    5323                 :   29077500 :                   changed = visit_nary_op (lhs, ass);
    5324                 :   29077500 :                   break;
    5325                 :   21066800 :                 case VN_REFERENCE:
    5326                 :   21066800 :                   changed = visit_reference_op_load (lhs, rhs1, ass);
    5327                 :   21066800 :                   break;
    5328                 :      31900 :                 default:
    5329                 :      31900 :                   changed = defs_to_varying (ass);
    5330                 :      31900 :                   break;
    5331                 :            :                 }
    5332                 :            :             }
    5333                 :            :         }
    5334                 :            :       else
    5335                 :          0 :         changed = defs_to_varying (ass);
    5336                 :            :     }
    5337                 :  177588000 :   else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
    5338                 :            :     {
    5339                 :   15994500 :       tree lhs = gimple_call_lhs (call_stmt);
    5340                 :   15994500 :       if (lhs && TREE_CODE (lhs) == SSA_NAME)
    5341                 :            :         {
    5342                 :            :           /* Try constant folding based on our current lattice.  */
    5343                 :    5351080 :           tree simplified = gimple_fold_stmt_to_constant_1 (call_stmt,
    5344                 :            :                                                             vn_valueize);
    5345                 :    5351080 :           if (simplified)
    5346                 :            :             {
    5347                 :      19193 :               if (dump_file && (dump_flags & TDF_DETAILS))
    5348                 :            :                 {
    5349                 :          1 :                   fprintf (dump_file, "call ");
    5350                 :          1 :                   print_gimple_expr (dump_file, call_stmt, 0);
    5351                 :          1 :                   fprintf (dump_file, " simplified to ");
    5352                 :          1 :                   print_generic_expr (dump_file, simplified);
    5353                 :          1 :                   fprintf (dump_file, "\n");
    5354                 :            :                 }
    5355                 :            :             }
    5356                 :            :           /* Setting value numbers to constants will occasionally
    5357                 :            :              screw up phi congruence because constants are not
    5358                 :            :              uniquely associated with a single ssa name that can be
    5359                 :            :              looked up.  */
    5360                 :    5351080 :           if (simplified
    5361                 :    5351080 :               && is_gimple_min_invariant (simplified))
    5362                 :            :             {
    5363                 :      15744 :               changed = set_ssa_val_to (lhs, simplified);
    5364                 :      31488 :               if (gimple_vdef (call_stmt))
    5365                 :       2412 :                 changed |= set_ssa_val_to (gimple_vdef (call_stmt),
    5366                 :            :                                            SSA_VAL (gimple_vuse (call_stmt)));
    5367                 :      15744 :               goto done;
    5368                 :            :             }
    5369                 :    5335340 :           else if (simplified
    5370                 :       3449 :                    && TREE_CODE (simplified) == SSA_NAME)
    5371                 :            :             {
    5372                 :        318 :               changed = visit_copy (lhs, simplified);
    5373                 :        636 :               if (gimple_vdef (call_stmt))
    5374                 :          0 :                 changed |= set_ssa_val_to (gimple_vdef (call_stmt),
    5375                 :            :                                            SSA_VAL (gimple_vuse (call_stmt)));
    5376                 :        318 :               goto done;
    5377                 :            :             }
    5378                 :    5335020 :           else if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
    5379                 :            :             {
    5380                 :        380 :               changed = defs_to_varying (call_stmt);
    5381                 :        380 :               goto done;
    5382                 :            :             }
    5383                 :            :         }
    5384                 :            : 
    5385                 :            :       /* Pick up flags from a devirtualization target.  */
    5386                 :   15978100 :       tree fn = gimple_call_fn (stmt);
    5387                 :   15978100 :       int extra_fnflags = 0;
    5388                 :   15978100 :       if (fn && TREE_CODE (fn) == SSA_NAME)
    5389                 :            :         {
    5390                 :     419672 :           fn = SSA_VAL (fn);
    5391                 :     419672 :           if (TREE_CODE (fn) == ADDR_EXPR
    5392                 :     419672 :               && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL)
    5393                 :       2530 :             extra_fnflags = flags_from_decl_or_type (TREE_OPERAND (fn, 0));
    5394                 :            :         }
    5395                 :   15978100 :       if (!gimple_call_internal_p (call_stmt)
    5396                 :   15978100 :           && (/* Calls to the same function with the same vuse
    5397                 :            :                  and the same operands do not necessarily return the same
    5398                 :            :                  value, unless they're pure or const.  */
    5399                 :   15495100 :               ((gimple_call_flags (call_stmt) | extra_fnflags)
    5400                 :   15495100 :                & (ECF_PURE | ECF_CONST))
    5401                 :            :               /* If calls have a vdef, subsequent calls won't have
    5402                 :            :                  the same incoming vuse.  So, if 2 calls with vdef have the
    5403                 :            :                  same vuse, we know they're not subsequent.
    5404                 :            :                  We can value number 2 calls to the same function with the
    5405                 :            :                  same vuse and the same operands which are not subsequent
    5406                 :            :                  the same, because there is no code in the program that can
    5407                 :            :                  compare the 2 values...  */
    5408                 :   14239100 :               || (gimple_vdef (call_stmt)
    5409                 :            :                   /* ... unless the call returns a pointer which does
    5410                 :            :                      not alias with anything else.  In which case the
    5411                 :            :                      information that the values are distinct are encoded
    5412                 :            :                      in the IL.  */
    5413                 :   14232500 :                   && !(gimple_call_return_flags (call_stmt) & ERF_NOALIAS)
    5414                 :            :                   /* Only perform the following when being called from PRE
    5415                 :            :                      which embeds tail merging.  */
    5416                 :   13951500 :                   && default_vn_walk_kind == VN_WALK)))
    5417                 :    4790550 :         changed = visit_reference_op_call (lhs, call_stmt);
    5418                 :            :       else
    5419                 :   11187500 :         changed = defs_to_varying (call_stmt);
    5420                 :            :     }
    5421                 :            :   else
    5422                 :  161594000 :     changed = defs_to_varying (stmt);
    5423                 :  283325000 :  done:
    5424                 :  283325000 :   return changed;
    5425                 :            : }
    5426                 :            : 
    5427                 :            : 
    5428                 :            : /* Allocate a value number table.  */
    5429                 :            : 
    5430                 :            : static void
    5431                 :    3767280 : allocate_vn_table (vn_tables_t table, unsigned size)
    5432                 :            : {
    5433                 :    3767280 :   table->phis = new vn_phi_table_type (size);
    5434                 :    3767280 :   table->nary = new vn_nary_op_table_type (size);
    5435                 :    3767280 :   table->references = new vn_reference_table_type (size);
    5436                 :    3767280 : }
    5437                 :            : 
    5438                 :            : /* Free a value number table.  */
    5439                 :            : 
    5440                 :            : static void
    5441                 :    3767280 : free_vn_table (vn_tables_t table)
    5442                 :            : {
    5443                 :            :   /* Walk over elements and release vectors.  */
    5444                 :    3767280 :   vn_reference_iterator_type hir;
    5445                 :    3767280 :   vn_reference_t vr;
    5446                 :   50005800 :   FOR_EACH_HASH_TABLE_ELEMENT (*table->references, vr, vn_reference_t, hir)
    5447                 :   84942600 :     vr->operands.release ();
    5448                 :    3767280 :   delete table->phis;
    5449                 :    3767280 :   table->phis = NULL;
    5450                 :    3767280 :   delete table->nary;
    5451                 :    3767280 :   table->nary = NULL;
    5452                 :    3767280 :   delete table->references;
    5453                 :    3767280 :   table->references = NULL;
    5454                 :    3767280 : }
    5455                 :            : 
    5456                 :            : /* Set *ID according to RESULT.  */
    5457                 :            : 
    5458                 :            : static void
    5459                 :   21741600 : set_value_id_for_result (tree result, unsigned int *id)
    5460                 :            : {
    5461                 :   21741600 :   if (result && TREE_CODE (result) == SSA_NAME)
    5462                 :   12613800 :     *id = VN_INFO (result)->value_id;
    5463                 :    9127810 :   else if (result && is_gimple_min_invariant (result))
    5464                 :    2577320 :     *id = get_or_alloc_constant_value_id (result);
    5465                 :            :   else
    5466                 :    6550490 :     *id = get_next_value_id ();
    5467                 :   21741600 : }
    5468                 :            : 
    5469                 :            : /* Set the value ids in the valid hash tables.  */
    5470                 :            : 
    5471                 :            : static void
    5472                 :     645456 : set_hashtable_value_ids (void)
    5473                 :            : {
    5474                 :     645456 :   vn_nary_op_iterator_type hin;
    5475                 :     645456 :   vn_phi_iterator_type hip;
    5476                 :     645456 :   vn_reference_iterator_type hir;
    5477                 :     645456 :   vn_nary_op_t vno;
    5478                 :     645456 :   vn_reference_t vr;
    5479                 :     645456 :   vn_phi_t vp;
    5480                 :            : 
    5481                 :            :   /* Now set the value ids of the things we had put in the hash
    5482                 :            :      table.  */
    5483                 :            : 
    5484                 :   19792200 :   FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->nary, vno, vn_nary_op_t, hin)
    5485                 :   13908300 :     if (! vno->predicated_values)
    5486                 :    4592990 :       set_value_id_for_result (vno->u.result, &vno->value_id);
    5487                 :            : 
    5488                 :    3718950 :   FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->phis, vp, vn_phi_t, hip)
    5489                 :    2428040 :     set_value_id_for_result (vp->result, &vp->value_id);
    5490                 :            : 
    5491                 :   16011500 :   FOR_EACH_HASH_TABLE_ELEMENT (*valid_info->references, vr, vn_reference_t,
    5492                 :            :                                hir)
    5493                 :   14720600 :     set_value_id_for_result (vr->result, &vr->value_id);
    5494                 :     645456 : }
    5495                 :            : 
    5496                 :            : /* Return the maximum value id we have ever seen.  */
    5497                 :            : 
    5498                 :            : unsigned int
    5499                 :    5736820 : get_max_value_id (void)
    5500                 :            : {
    5501                 :    5736820 :   return next_value_id;
    5502                 :            : }
    5503                 :            : 
    5504                 :            : /* Return the next unique value id.  */
    5505                 :            : 
    5506                 :            : unsigned int
    5507                 :   34389000 : get_next_value_id (void)
    5508                 :            : {
    5509                 :   34389000 :   return next_value_id++;
    5510                 :            : }
    5511                 :            : 
    5512                 :            : 
    5513                 :            : /* Compare two expressions E1 and E2 and return true if they are equal.  */
    5514                 :            : 
    5515                 :            : bool
    5516                 :  252852000 : expressions_equal_p (tree e1, tree e2)
    5517                 :            : {
    5518                 :            :   /* The obvious case.  */
    5519                 :  252852000 :   if (e1 == e2)
    5520                 :            :     return true;
    5521                 :            : 
    5522                 :            :   /* If either one is VN_TOP consider them equal.  */
    5523                 :   42915000 :   if (e1 == VN_TOP || e2 == VN_TOP)
    5524                 :            :     return true;
    5525                 :            : 
    5526                 :            :   /* If only one of them is null, they cannot be equal.  */
    5527                 :   42915000 :   if (!e1 || !e2)
    5528                 :            :     return false;
    5529                 :            : 
    5530                 :            :   /* Now perform the actual comparison.  */
    5531                 :   42915000 :   if (TREE_CODE (e1) == TREE_CODE (e2)
    5532                 :   42915000 :       && operand_equal_p (e1, e2, OEP_PURE_SAME))
    5533                 :    2620570 :     return true;
    5534                 :            : 
    5535                 :            :   return false;
    5536                 :            : }
    5537                 :            : 
    5538                 :            : 
    5539                 :            : /* Return true if the nary operation NARY may trap.  This is a copy
    5540                 :            :    of stmt_could_throw_1_p adjusted to the SCCVN IL.  */
    5541                 :            : 
    5542                 :            : bool
    5543                 :    1625380 : vn_nary_may_trap (vn_nary_op_t nary)
    5544                 :            : {
    5545                 :    1625380 :   tree type;
    5546                 :    1625380 :   tree rhs2 = NULL_TREE;
    5547                 :    1625380 :   bool honor_nans = false;
    5548                 :    1625380 :   bool honor_snans = false;
    5549                 :    1625380 :   bool fp_operation = false;
    5550                 :    1625380 :   bool honor_trapv = false;
    5551                 :    1625380 :   bool handled, ret;
    5552                 :    1625380 :   unsigned i;
    5553                 :            : 
    5554                 :    1625380 :   if (TREE_CODE_CLASS (nary->opcode) == tcc_comparison
    5555                 :            :       || TREE_CODE_CLASS (nary->opcode) == tcc_unary
    5556                 :    1625380 :       || TREE_CODE_CLASS (nary->opcode) == tcc_binary)
    5557                 :            :     {
    5558                 :    1577490 :       type = nary->type;
    5559                 :    1580980 :       fp_operation = FLOAT_TYPE_P (type);
    5560                 :    1577490 :       if (fp_operation)
    5561                 :            :         {
    5562                 :      74805 :           honor_nans = flag_trapping_math && !flag_finite_math_only;
    5563                 :      74805 :           honor_snans = flag_signaling_nans != 0;
    5564                 :            :         }
    5565                 :    1502680 :       else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type))
    5566                 :            :         honor_trapv = true;
    5567                 :            :     }
    5568                 :    1625380 :   if (nary->length >= 2)
    5569                 :    1134940 :     rhs2 = nary->op[1];
    5570                 :    1625380 :   ret = operation_could_trap_helper_p (nary->opcode, fp_operation,
    5571                 :            :                                        honor_trapv, honor_nans, honor_snans,
    5572                 :            :                                        rhs2, &handled);
    5573                 :    1625380 :   if (handled && ret)
    5574                 :            :     return true;
    5575                 :            : 
    5576                 :    4197590 :   for (i = 0; i < nary->length; ++i)
    5577                 :    2639160 :     if (tree_could_trap_p (nary->op[i]))
    5578                 :            :       return true;
    5579                 :            : 
    5580                 :            :   return false;
    5581                 :            : }
    5582                 :            : 
    5583                 :            : /* Return true if the reference operation REF may trap.  */
    5584                 :            : 
    5585                 :            : bool
    5586                 :     746831 : vn_reference_may_trap (vn_reference_t ref)
    5587                 :            : {
    5588                 :     746831 :   switch (ref->operands[0].opcode)
    5589                 :            :     {
    5590                 :            :     case MODIFY_EXPR:
    5591                 :            :     case CALL_EXPR:
    5592                 :            :       /* We do not handle calls.  */
    5593                 :            :     case ADDR_EXPR:
    5594                 :            :       /* And toplevel address computations never trap.  */
    5595                 :            :       return false;
    5596                 :            :     default:;
    5597                 :            :     }
    5598                 :            : 
    5599                 :            :   vn_reference_op_t op;
    5600                 :            :   unsigned i;
    5601                 :    1982400 :   FOR_EACH_VEC_ELT (ref->operands, i, op)
    5602                 :            :     {
    5603                 :    1982400 :       switch (op->opcode)
    5604                 :            :         {
    5605                 :            :         case WITH_SIZE_EXPR:
    5606                 :            :         case TARGET_MEM_REF:
    5607                 :            :           /* Always variable.  */
    5608                 :            :           return true;
    5609                 :     531511 :         case COMPONENT_REF:
    5610                 :     531511 :           if (op->op1 && TREE_CODE (op->op1) == SSA_NAME)
    5611                 :            :             return true;
    5612                 :            :           break;
    5613                 :      26187 :         case ARRAY_RANGE_REF:
    5614                 :      26187 :         case ARRAY_REF:
    5615                 :      26187 :           if (TREE_CODE (op->op0) == SSA_NAME)
    5616                 :            :             return true;
    5617                 :            :           break;
    5618                 :            :         case MEM_REF:
    5619                 :            :           /* Nothing interesting in itself, the base is separate.  */
    5620                 :            :           break;
    5621                 :            :         /* The following are the address bases.  */
    5622                 :            :         case SSA_NAME:
    5623                 :            :           return true;
    5624                 :     582608 :         case ADDR_EXPR:
    5625                 :     582608 :           if (op->op0)
    5626                 :     582608 :             return tree_could_trap_p (TREE_OPERAND (op->op0, 0));
    5627                 :            :           return false;
    5628                 :    1268210 :         default:;
    5629                 :            :         }
    5630                 :            :     }
    5631                 :            :   return false;
    5632                 :            : }
    5633                 :            : 
    5634                 :    6591480 : eliminate_dom_walker::eliminate_dom_walker (cdi_direction direction,
    5635                 :    6591480 :                                             bitmap inserted_exprs_)
    5636                 :    6591480 :   : dom_walker (direction), do_pre (inserted_exprs_ != NULL),
    5637                 :            :     el_todo (0), eliminations (0), insertions (0),
    5638                 :    6591480 :     inserted_exprs (inserted_exprs_)
    5639                 :            : {
    5640                 :    6591480 :   need_eh_cleanup = BITMAP_ALLOC (NULL);
    5641                 :    6591480 :   need_ab_cleanup = BITMAP_ALLOC (NULL);
    5642                 :    6591480 : }
    5643                 :            : 
    5644                 :    9532960 : eliminate_dom_walker::~eliminate_dom_walker ()
    5645                 :            : {
    5646                 :    6591480 :   BITMAP_FREE (need_eh_cleanup);
    5647                 :    6591480 :   BITMAP_FREE (need_ab_cleanup);
    5648                 :    6591480 : }
    5649                 :            : 
    5650                 :            : /* Return a leader for OP that is available at the current point of the
    5651                 :            :    eliminate domwalk.  */
    5652                 :            : 
    5653                 :            : tree
    5654                 :  114994000 : eliminate_dom_walker::eliminate_avail (basic_block, tree op)
    5655                 :            : {
    5656                 :  114994000 :   tree valnum = VN_INFO (op)->valnum;
    5657                 :  114994000 :   if (TREE_CODE (valnum) == SSA_NAME)
    5658                 :            :     {
    5659                 :  111749000 :       if (SSA_NAME_IS_DEFAULT_DEF (valnum))
    5660                 :            :         return valnum;
    5661                 :  194793000 :       if (avail.length () > SSA_NAME_VERSION (valnum))
    5662                 :   86716100 :         return avail[SSA_NAME_VERSION (valnum)];
    5663                 :            :     }
    5664                 :    3244630 :   else if (is_gimple_min_invariant (valnum))
    5665                 :    3244630 :     return valnum;
    5666                 :            :   return NULL_TREE;
    5667                 :            : }
    5668                 :            : 
    5669                 :            : /* At the current point of the eliminate domwalk make OP available.  */
    5670                 :            : 
    5671                 :            : void
    5672                 :   33037700 : eliminate_dom_walker::eliminate_push_avail (basic_block, tree op)
    5673                 :            : {
    5674                 :   33037700 :   tree valnum = VN_INFO (op)->valnum;
    5675                 :   33037700 :   if (TREE_CODE (valnum) == SSA_NAME)
    5676                 :            :     {
    5677                 :   63888700 :       if (avail.length () <= SSA_NAME_VERSION (valnum))
    5678                 :   12390700 :         avail.safe_grow_cleared (SSA_NAME_VERSION (valnum) + 1);
    5679                 :   33037700 :       tree pushop = op;
    5680                 :   33037700 :       if (avail[SSA_NAME_VERSION (valnum)])
    5681                 :       6906 :         pushop = avail[SSA_NAME_VERSION (valnum)];
    5682                 :   33037700 :       avail_stack.safe_push (pushop);
    5683                 :   33037700 :       avail[SSA_NAME_VERSION (valnum)] = op;
    5684                 :            :     }
    5685                 :   33037700 : }
    5686                 :            : 
    5687                 :            : /* Insert the expression recorded by SCCVN for VAL at *GSI.  Returns
    5688                 :            :    the leader for the expression if insertion was successful.  */
    5689                 :            : 
    5690                 :            : tree
    5691                 :      18256 : eliminate_dom_walker::eliminate_insert (basic_block bb,
    5692                 :            :                                         gimple_stmt_iterator *gsi, tree val)
    5693                 :            : {
    5694                 :            :   /* We can insert a sequence with a single assignment only.  */
    5695                 :      18256 :   gimple_seq stmts = VN_INFO (val)->expr;
    5696                 :      18256 :   if (!gimple_seq_singleton_p (stmts))
    5697                 :            :     return NULL_TREE;
    5698                 :      18256 :   gassign *stmt = dyn_cast <gassign *> (gimple_seq_first_stmt (stmts));
    5699                 :      18256 :   if (!stmt
    5700                 :      18256 :       || (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
    5701                 :      12440 :           && gimple_assign_rhs_code (stmt) != VIEW_CONVERT_EXPR
    5702                 :      11466 :           && gimple_assign_rhs_code (stmt) != BIT_FIELD_REF
    5703                 :          7 :           && (gimple_assign_rhs_code (stmt) != BIT_AND_EXPR
    5704                 :          7 :               || TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST)))
    5705                 :            :     return NULL_TREE;
    5706                 :            : 
    5707                 :      18256 :   tree op = gimple_assign_rhs1 (stmt);
    5708                 :      18256 :   if (gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR
    5709                 :      18256 :       || gimple_assign_rhs_code (stmt) == BIT_FIELD_REF)
    5710                 :      12433 :     op = TREE_OPERAND (op, 0);
    5711                 :      18256 :   tree leader = TREE_CODE (op) == SSA_NAME ? eliminate_avail (bb, op) : op;
    5712                 :      18256 :   if (!leader)
    5713                 :            :     return NULL_TREE;
    5714                 :            : 
    5715                 :      13000 :   tree res;
    5716                 :      13000 :   stmts = NULL;
    5717                 :      24948 :   if (gimple_assign_rhs_code (stmt) == BIT_FIELD_REF)
    5718                 :      11447 :     res = gimple_build (&stmts, BIT_FIELD_REF,
    5719                 :      11447 :                         TREE_TYPE (val), leader,
    5720                 :      11447 :                         TREE_OPERAND (gimple_assign_rhs1 (stmt), 1),
    5721                 :      11447 :                         TREE_OPERAND (gimple_assign_rhs1 (stmt), 2));
    5722                 :       1553 :   else if (gimple_assign_rhs_code (stmt) == BIT_AND_EXPR)
    5723                 :         14 :     res = gimple_build (&stmts, BIT_AND_EXPR,
    5724                 :          7 :                         TREE_TYPE (val), leader, gimple_assign_rhs2 (stmt));
    5725                 :            :   else
    5726                 :       1546 :     res = gimple_build (&stmts, gimple_assign_rhs_code (stmt),
    5727                 :       1546 :                         TREE_TYPE (val), leader);
    5728                 :      13000 :   if (TREE_CODE (res) != SSA_NAME
    5729                 :      13000 :       || SSA_NAME_IS_DEFAULT_DEF (res)
    5730                 :      26000 :       || gimple_bb (SSA_NAME_DEF_STMT (res)))
    5731                 :            :     {
    5732                 :          0 :       gimple_seq_discard (stmts);
    5733                 :            : 
    5734                 :            :       /* During propagation we have to treat SSA info conservatively
    5735                 :            :          and thus we can end up simplifying the inserted expression
    5736                 :            :          at elimination time to sth not defined in stmts.  */
    5737                 :            :       /* But then this is a redundancy we failed to detect.  Which means
    5738                 :            :          res now has two values.  That doesn't play well with how
    5739                 :            :          we track availability here, so give up.  */
    5740                 :          0 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5741                 :            :         {
    5742                 :          0 :           if (TREE_CODE (res) == SSA_NAME)
    5743                 :          0 :             res = eliminate_avail (bb, res);
    5744                 :          0 :           if (res)
    5745                 :            :             {
    5746                 :          0 :               fprintf (dump_file, "Failed to insert expression for value ");
    5747                 :          0 :               print_generic_expr (dump_file, val);
    5748                 :          0 :               fprintf (dump_file, " which is really fully redundant to ");
    5749                 :          0 :               print_generic_expr (dump_file, res);
    5750                 :          0 :               fprintf (dump_file, "\n");
    5751                 :            :             }
    5752                 :            :         }
    5753                 :            : 
    5754                 :          0 :       return NULL_TREE;
    5755                 :            :     }
    5756                 :            :   else
    5757                 :            :     {
    5758                 :      13000 :       gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
    5759                 :      13000 :       VN_INFO (res)->valnum = val;
    5760                 :      13000 :       VN_INFO (res)->visited = true;
    5761                 :            :     }
    5762                 :            : 
    5763                 :      13000 :   insertions++;
    5764                 :      13000 :   if (dump_file && (dump_flags & TDF_DETAILS))
    5765                 :            :     {
    5766                 :          7 :       fprintf (dump_file, "Inserted ");
    5767                 :          7 :       print_gimple_stmt (dump_file, SSA_NAME_DEF_STMT (res), 0);
    5768                 :            :     }
    5769                 :            : 
    5770                 :            :   return res;
    5771                 :            : }
    5772                 :            : 
    5773                 :            : void
    5774                 :  218295000 : eliminate_dom_walker::eliminate_stmt (basic_block b, gimple_stmt_iterator *gsi)
    5775                 :            : {
    5776                 :  218295000 :   tree sprime = NULL_TREE;
    5777                 :  218295000 :   gimple *stmt = gsi_stmt (*gsi);
    5778                 :  218295000 :   tree lhs = gimple_get_lhs (stmt);
    5779                 :   75570600 :   if (lhs && TREE_CODE (lhs) == SSA_NAME
    5780                 :  100417000 :       && !gimple_has_volatile_ops (stmt)
    5781                 :            :       /* See PR43491.  Do not replace a global register variable when
    5782                 :            :          it is a the RHS of an assignment.  Do replace local register
    5783                 :            :          variables since gcc does not guarantee a local variable will
    5784                 :            :          be allocated in register.
    5785                 :            :          ???  The fix isn't effective here.  This should instead
    5786                 :            :          be ensured by not value-numbering them the same but treating
    5787                 :            :          them like volatiles?  */
    5788                 :  267522000 :       && !(gimple_assign_single_p (stmt)
    5789                 :   22133900 :            && (TREE_CODE (gimple_assign_rhs1 (stmt)) == VAR_DECL
    5790                 :    1378880 :                && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt))
    5791                 :       1974 :                && is_global_var (gimple_assign_rhs1 (stmt)))))
    5792                 :            :     {
    5793                 :   49226700 :       sprime = eliminate_avail (b, lhs);
    5794                 :   49226700 :       if (!sprime)
    5795                 :            :         {
    5796                 :            :           /* If there is no existing usable leader but SCCVN thinks
    5797                 :            :              it has an expression it wants to use as replacement,
    5798                 :            :              insert that.  */
    5799                 :   40897400 :           tree val = VN_INFO (lhs)->valnum;
    5800                 :   40897400 :           if (val != VN_TOP
    5801                 :   40897400 :               && TREE_CODE (val) == SSA_NAME
    5802                 :   40897400 :               && VN_INFO (val)->needs_insertion
    5803                 :     385106 :               && VN_INFO (val)->expr != NULL
    5804                 :   40915700 :               && (sprime = eliminate_insert (b, gsi, val)) != NULL_TREE)
    5805                 :      13000 :             eliminate_push_avail (b, sprime);
    5806                 :            :         }
    5807                 :            : 
    5808                 :            :       /* If this now constitutes a copy duplicate points-to
    5809                 :            :          and range info appropriately.  This is especially
    5810                 :            :          important for inserted code.  See tree-ssa-copy.c
    5811                 :            :          for similar code.  */
    5812                 :   49226700 :       if (sprime
    5813                 :    8342270 :           && TREE_CODE (sprime) == SSA_NAME)
    5814                 :            :         {
    5815                 :    5788360 :           basic_block sprime_b = gimple_bb (SSA_NAME_DEF_STMT (sprime));
    5816                 :    9118610 :           if (POINTER_TYPE_P (TREE_TYPE (lhs))
    5817                 :    2514840 :               && SSA_NAME_PTR_INFO (lhs)
    5818                 :    8264070 :               && ! SSA_NAME_PTR_INFO (sprime))
    5819                 :            :             {
    5820                 :     105100 :               duplicate_ssa_name_ptr_info (sprime,
    5821                 :     105100 :                                            SSA_NAME_PTR_INFO (lhs));
    5822                 :     105100 :               if (b != sprime_b)
    5823                 :      31895 :                 mark_ptr_info_alignment_unknown
    5824                 :      31895 :                     (SSA_NAME_PTR_INFO (sprime));
    5825                 :            :             }
    5826                 :    5683260 :           else if (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    5827                 :    3103060 :                    && SSA_NAME_RANGE_INFO (lhs)
    5828                 :     393751 :                    && ! SSA_NAME_RANGE_INFO (sprime)
    5829                 :    5823160 :                    && b == sprime_b)
    5830                 :     118476 :             duplicate_ssa_name_range_info (sprime,
    5831                 :      61356 :                                            SSA_NAME_RANGE_TYPE (lhs),
    5832                 :      61356 :                                            SSA_NAME_RANGE_INFO (lhs));
    5833                 :            :         }
    5834                 :            : 
    5835                 :            :       /* Inhibit the use of an inserted PHI on a loop header when
    5836                 :            :          the address of the memory reference is a simple induction
    5837                 :            :          variable.  In other cases the vectorizer won't do anything
    5838                 :            :          anyway (either it's loop invariant or a complicated
    5839                 :            :          expression).  */
    5840                 :   49226700 :       if (sprime
    5841                 :    8342270 :           && TREE_CODE (sprime) == SSA_NAME
    5842                 :    5788360 :           && do_pre
    5843                 :     553314 :           && (flag_tree_loop_vectorize || flag_tree_parallelize_loops > 1)
    5844                 :     186667 :           && loop_outer (b->loop_father)
    5845                 :      77583 :           && has_zero_uses (sprime)
    5846                 :      32181 :           && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (sprime))
    5847                 :   49258400 :           && gimple_assign_load_p (stmt))
    5848                 :            :         {
    5849                 :      12852 :           gimple *def_stmt = SSA_NAME_DEF_STMT (sprime);
    5850                 :      12852 :           basic_block def_bb = gimple_bb (def_stmt);
    5851                 :      12852 :           if (gimple_code (def_stmt) == GIMPLE_PHI
    5852                 :      12852 :               && def_bb->loop_father->header == def_bb)
    5853                 :            :             {
    5854                 :       9403 :               loop_p loop = def_bb->loop_father;
    5855                 :       9403 :               ssa_op_iter iter;
    5856                 :       9403 :               tree op;
    5857                 :       9403 :               bool found = false;
    5858                 :      12134 :               FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
    5859                 :            :                 {
    5860                 :       9626 :                   affine_iv iv;
    5861                 :       9626 :                   def_bb = gimple_bb (SSA_NAME_DEF_STMT (op));
    5862                 :       9626 :                   if (def_bb
    5863                 :       9071 :                       && flow_bb_inside_loop_p (loop, def_bb)
    5864                 :      17688 :                       && simple_iv (loop, loop, op, &iv, true))
    5865                 :            :                     {
    5866                 :       6895 :                       found = true;
    5867                 :       6895 :                       break;
    5868                 :            :                     }
    5869                 :            :                 }
    5870                 :       2508 :               if (found)
    5871                 :            :                 {
    5872                 :       6895 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    5873                 :            :                     {
    5874                 :          0 :                       fprintf (dump_file, "Not replacing ");
    5875                 :          0 :                       print_gimple_expr (dump_file, stmt, 0);
    5876                 :          0 :                       fprintf (dump_file, " with ");
    5877                 :          0 :                       print_generic_expr (dump_file, sprime);
    5878                 :          0 :                       fprintf (dump_file, " which would add a loop"
    5879                 :            :                                " carried dependence to loop %d\n",
    5880                 :            :                                loop->num);
    5881                 :            :                     }
    5882                 :            :                   /* Don't keep sprime available.  */
    5883                 :       6895 :                   sprime = NULL_TREE;
    5884                 :            :                 }
    5885                 :            :             }
    5886                 :            :         }
    5887                 :            : 
    5888                 :   49226700 :       if (sprime)
    5889                 :            :         {
    5890                 :            :           /* If we can propagate the value computed for LHS into
    5891                 :            :              all uses don't bother doing anything with this stmt.  */
    5892                 :    8335380 :           if (may_propagate_copy (lhs, sprime))
    5893                 :            :             {
    5894                 :            :               /* Mark it for removal.  */
    5895                 :    8333610 :               to_remove.safe_push (stmt);
    5896                 :            : 
    5897                 :            :               /* ???  Don't count copy/constant propagations.  */
    5898                 :    8333610 :               if (gimple_assign_single_p (stmt)
    5899                 :    5837650 :                   && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
    5900                 :    2673450 :                       || gimple_assign_rhs1 (stmt) == sprime))
    5901                 :    8687360 :                 return;
    5902                 :            : 
    5903                 :    4234000 :               if (dump_file && (dump_flags & TDF_DETAILS))
    5904                 :            :                 {
    5905                 :        444 :                   fprintf (dump_file, "Replaced ");
    5906                 :        444 :                   print_gimple_expr (dump_file, stmt, 0);
    5907                 :        444 :                   fprintf (dump_file, " with ");
    5908                 :        444 :                   print_generic_expr (dump_file, sprime);
    5909                 :        444 :                   fprintf (dump_file, " in all uses of ");
    5910                 :        444 :                   print_gimple_stmt (dump_file, stmt, 0);
    5911                 :            :                 }
    5912                 :            : 
    5913                 :    4234000 :               eliminations++;
    5914                 :    4234000 :               return;
    5915                 :            :             }
    5916                 :            : 
    5917                 :            :           /* If this is an assignment from our leader (which
    5918                 :            :              happens in the case the value-number is a constant)
    5919                 :            :              then there is nothing to do.  Likewise if we run into
    5920                 :            :              inserted code that needed a conversion because of
    5921                 :            :              our type-agnostic value-numbering of loads.  */
    5922                 :       1761 :           if ((gimple_assign_single_p (stmt)
    5923                 :          0 :                || (is_gimple_assign (stmt)
    5924                 :          0 :                    && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
    5925                 :          0 :                        || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)))
    5926                 :       1761 :               && sprime == gimple_assign_rhs1 (stmt))
    5927                 :            :             return;
    5928                 :            : 
    5929                 :            :           /* Else replace its RHS.  */
    5930                 :        560 :           if (dump_file && (dump_flags & TDF_DETAILS))
    5931                 :            :             {
    5932                 :          0 :               fprintf (dump_file, "Replaced ");
    5933                 :          0 :               print_gimple_expr (dump_file, stmt, 0);
    5934                 :          0 :               fprintf (dump_file, " with ");
    5935                 :          0 :               print_generic_expr (dump_file, sprime);
    5936                 :          0 :               fprintf (dump_file, " in ");
    5937                 :          0 :               print_gimple_stmt (dump_file, stmt, 0);
    5938                 :            :             }
    5939                 :        560 :           eliminations++;
    5940                 :            : 
    5941                 :        560 :           bool can_make_abnormal_goto = (is_gimple_call (stmt)
    5942                 :        560 :                                          && stmt_can_make_abnormal_goto (stmt));
    5943                 :        560 :           gimple *orig_stmt = stmt;
    5944                 :       1120 :           if (!useless_type_conversion_p (TREE_TYPE (lhs),
    5945                 :        560 :                                           TREE_TYPE (sprime)))
    5946                 :            :             {
    5947                 :            :               /* We preserve conversions to but not from function or method
    5948                 :            :                  types.  This asymmetry makes it necessary to re-instantiate
    5949                 :            :                  conversions here.  */
    5950                 :        560 :               if (POINTER_TYPE_P (TREE_TYPE (lhs))
    5951                 :        560 :                   && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (lhs))))
    5952                 :        560 :                 sprime = fold_convert (TREE_TYPE (lhs), sprime);
    5953                 :            :               else
    5954                 :          0 :                 gcc_unreachable ();
    5955                 :            :             }
    5956                 :        560 :           tree vdef = gimple_vdef (stmt);
    5957                 :        560 :           tree vuse = gimple_vuse (stmt);
    5958                 :        560 :           propagate_tree_value_into_stmt (gsi, sprime);
    5959                 :        560 :           stmt = gsi_stmt (*gsi);
    5960                 :        560 :           update_stmt (stmt);
    5961                 :            :           /* In case the VDEF on the original stmt was released, value-number
    5962                 :            :              it to the VUSE.  This is to make vuse_ssa_val able to skip
    5963                 :            :              released virtual operands.  */
    5964                 :       1120 :           if (vdef != gimple_vdef (stmt))
    5965                 :            :             {
    5966                 :          0 :               gcc_assert (SSA_NAME_IN_FREE_LIST (vdef));
    5967                 :          0 :               VN_INFO (vdef)->valnum = vuse;
    5968                 :            :             }
    5969                 :            : 
    5970                 :            :           /* If we removed EH side-effects from the statement, clean
    5971                 :            :              its EH information.  */
    5972                 :        560 :           if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
    5973                 :            :             {
    5974                 :          0 :               bitmap_set_bit (need_eh_cleanup,
    5975                 :          0 :                               gimple_bb (stmt)->index);
    5976                 :          0 :               if (dump_file && (dump_flags & TDF_DETAILS))
    5977                 :          0 :                 fprintf (dump_file, "  Removed EH side-effects.\n");
    5978                 :            :             }
    5979                 :            : 
    5980                 :            :           /* Likewise for AB side-effects.  */
    5981                 :        560 :           if (can_make_abnormal_goto
    5982                 :        560 :               && !stmt_can_make_abnormal_goto (stmt))
    5983                 :            :             {
    5984                 :          0 :               bitmap_set_bit (need_ab_cleanup,
    5985                 :          0 :                               gimple_bb (stmt)->index);
    5986                 :          0 :               if (dump_file && (dump_flags & TDF_DETAILS))
    5987                 :          0 :                 fprintf (dump_file, "  Removed AB side-effects.\n");
    5988                 :            :             }
    5989                 :            : 
    5990                 :        560 :           return;
    5991                 :            :         }
    5992                 :            :     }
    5993                 :            : 
    5994                 :            :   /* If the statement is a scalar store, see if the expression
    5995                 :            :      has the same value number as its rhs.  If so, the store is
    5996                 :            :      dead.  */
    5997                 :  209959000 :   if (gimple_assign_single_p (stmt)
    5998                 :   41642500 :       && !gimple_has_volatile_ops (stmt)
    5999                 :   35529300 :       && !is_gimple_reg (gimple_assign_lhs (stmt))
    6000                 :   19234700 :       && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
    6001                 :   11102400 :           || is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
    6002                 :            :     {
    6003                 :   17086300 :       tree rhs = gimple_assign_rhs1 (stmt);
    6004                 :   17086300 :       vn_reference_t vnresult;
    6005                 :            :       /* ???  gcc.dg/torture/pr91445.c shows that we lookup a boolean
    6006                 :            :          typed load of a byte known to be 0x11 as 1 so a store of
    6007                 :            :          a boolean 1 is detected as redundant.  Because of this we
    6008                 :            :          have to make sure to lookup with a ref where its size
    6009                 :            :          matches the precision.  */
    6010                 :   17086300 :       tree lookup_lhs = lhs;
    6011                 :   34053800 :       if (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    6012                 :    8735200 :           && (TREE_CODE (lhs) != COMPONENT_REF
    6013                 :    5642860 :               || !DECL_BIT_FIELD_TYPE (TREE_OPERAND (lhs, 1)))
    6014                 :   25740400 :           && !type_has_mode_precision_p (TREE_TYPE (lhs)))
    6015                 :            :         {
    6016                 :     297108 :           if (TREE_CODE (lhs) == COMPONENT_REF
    6017                 :     297108 :               || TREE_CODE (lhs) == MEM_REF)
    6018                 :            :             {
    6019                 :     204492 :               tree ltype = build_nonstandard_integer_type
    6020                 :     204492 :                                 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (lhs))),
    6021                 :     204492 :                                  TYPE_UNSIGNED (TREE_TYPE (lhs)));
    6022                 :     204492 :               if (TREE_CODE (lhs) == COMPONENT_REF)
    6023                 :            :                 {
    6024                 :     173726 :                   tree foff = component_ref_field_offset (lhs);
    6025                 :     173726 :                   tree f = TREE_OPERAND (lhs, 1);
    6026                 :     173726 :                   if (!poly_int_tree_p (foff))
    6027                 :            :                     lookup_lhs = NULL_TREE;
    6028                 :            :                   else
    6029                 :     521178 :                     lookup_lhs = build3 (BIT_FIELD_REF, ltype,
    6030                 :     173726 :                                          TREE_OPERAND (lhs, 0),
    6031                 :     173726 :                                          TYPE_SIZE (TREE_TYPE (lhs)),
    6032                 :            :                                          bit_from_pos
    6033                 :     173726 :                                            (foff, DECL_FIELD_BIT_OFFSET (f)));
    6034                 :            :                 }
    6035                 :            :               else
    6036                 :      30766 :                 lookup_lhs = build2 (MEM_REF, ltype,
    6037                 :      30766 :                                      TREE_OPERAND (lhs, 0),
    6038                 :      30766 :                                      TREE_OPERAND (lhs, 1));
    6039                 :            :             }
    6040                 :            :           else
    6041                 :            :             lookup_lhs = NULL_TREE;
    6042                 :            :         }
    6043                 :   16993700 :       tree val = NULL_TREE;
    6044                 :   16993700 :       if (lookup_lhs)
    6045                 :   33987500 :         val = vn_reference_lookup (lookup_lhs, gimple_vuse (stmt),
    6046                 :            :                                    VN_WALKREWRITE, &vnresult, false);
    6047                 :   17086300 :       if (TREE_CODE (rhs) == SSA_NAME)
    6048                 :    8132290 :         rhs = VN_INFO (rhs)->valnum;
    6049                 :   17086300 :       if (val
    6050                 :   17086300 :           && (operand_equal_p (val, rhs, 0)
    6051                 :            :               /* Due to the bitfield lookups above we can get bit
    6052                 :            :                  interpretations of the same RHS as values here.  Those
    6053                 :            :                  are redundant as well.  */
    6054                 :    1730140 :               || (TREE_CODE (val) == SSA_NAME
    6055                 :   19070300 :                   && gimple_assign_single_p (SSA_NAME_DEF_STMT (val))
    6056                 :    1007040 :                   && (val = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (val)))
    6057                 :    1007040 :                   && TREE_CODE (val) == VIEW_CONVERT_EXPR
    6058                 :       1428 :                   && TREE_OPERAND (val, 0) == rhs)))
    6059                 :            :         {
    6060                 :            :           /* We can only remove the later store if the former aliases
    6061                 :            :              at least all accesses the later one does or if the store
    6062                 :            :              was to readonly memory storing the same value.  */
    6063                 :     108530 :           ao_ref lhs_ref;
    6064                 :     108530 :           ao_ref_init (&lhs_ref, lhs);
    6065                 :     108530 :           alias_set_type set = ao_ref_alias_set (&lhs_ref);
    6066                 :     108530 :           alias_set_type base_set = ao_ref_base_alias_set (&lhs_ref);
    6067                 :     108530 :           if (! vnresult
    6068                 :     108530 :               || ((vnresult->set == set
    6069                 :      20870 :                    || alias_set_subset_of (set, vnresult->set))
    6070                 :     101730 :                   && (vnresult->base_set == base_set
    6071                 :       6712 :                       || alias_set_subset_of (base_set, vnresult->base_set))))
    6072                 :            :             {
    6073                 :     100307 :               if (dump_file && (dump_flags & TDF_DETAILS))
    6074                 :            :                 {
    6075                 :         15 :                   fprintf (dump_file, "Deleted redundant store ");
    6076                 :         15 :                   print_gimple_stmt (dump_file, stmt, 0);
    6077                 :            :                 }
    6078                 :            : 
    6079                 :            :               /* Queue stmt for removal.  */
    6080                 :     100307 :               to_remove.safe_push (stmt);
    6081                 :     100307 :               return;
    6082                 :            :             }
    6083                 :            :         }
    6084                 :            :     }
    6085                 :            : 
    6086                 :            :   /* If this is a control statement value numbering left edges
    6087                 :            :      unexecuted on force the condition in a way consistent with
    6088                 :            :      that.  */
    6089                 :  209859000 :   if (gcond *cond = dyn_cast <gcond *> (stmt))
    6090                 :            :     {
    6091                 :   10967000 :       if ((EDGE_SUCC (b, 0)->flags & EDGE_EXECUTABLE)
    6092                 :   10967000 :           ^ (EDGE_SUCC (b, 1)->flags & EDGE_EXECUTABLE))
    6093                 :            :         {
    6094                 :     251683 :           if (dump_file && (dump_flags & TDF_DETAILS))
    6095                 :            :             {
    6096                 :         18 :               fprintf (dump_file, "Removing unexecutable edge from ");
    6097                 :         18 :               print_gimple_stmt (dump_file, stmt, 0);
    6098                 :            :             }
    6099                 :     251683 :           if (((EDGE_SUCC (b, 0)->flags & EDGE_TRUE_VALUE) != 0)
    6100                 :     251683 :               == ((EDGE_SUCC (b, 0)->flags & EDGE_EXECUTABLE) != 0))
    6101                 :      78618 :             gimple_cond_make_true (cond);
    6102                 :            :           else
    6103                 :     173065 :             gimple_cond_make_false (cond);
    6104                 :     251683 :           update_stmt (cond);
    6105                 :     251683 :           el_todo |= TODO_cleanup_cfg;
    6106                 :     251683 :           return;
    6107                 :            :         }
    6108                 :            :     }
    6109                 :            : 
    6110                 :  209608000 :   bool can_make_abnormal_goto = stmt_can_make_abnormal_goto (stmt);
    6111                 :  209608000 :   bool was_noreturn = (is_gimple_call (stmt)
    6112                 :  209608000 :                        && gimple_call_noreturn_p (stmt));
    6113                 :  209608000 :   tree vdef = gimple_vdef (stmt);
    6114                 :  209608000 :   tree vuse = gimple_vuse (stmt);
    6115                 :            : 
    6116                 :            :   /* If we didn't replace the whole stmt (or propagate the result
    6117                 :            :      into all uses), replace all uses on this stmt with their
    6118                 :            :      leaders.  */
    6119                 :  209608000 :   bool modified = false;
    6120                 :  209608000 :   use_operand_p use_p;
    6121                 :  209608000 :   ssa_op_iter iter;
    6122                 :  307297000 :   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
    6123                 :            :     {
    6124                 :   97689400 :       tree use = USE_FROM_PTR (use_p);
    6125                 :            :       /* ???  The call code above leaves stmt operands un-updated.  */
    6126                 :   97689400 :       if (TREE_CODE (use) != SSA_NAME)
    6127                 :          0 :         continue;
    6128                 :   97689400 :       tree sprime;
    6129                 :   97689400 :       if (SSA_NAME_IS_DEFAULT_DEF (use))
    6130                 :            :         /* ???  For default defs BB shouldn't matter, but we have to
    6131                 :            :            solve the inconsistency between rpo eliminate and
    6132                 :            :            dom eliminate avail valueization first.  */
    6133                 :   16505100 :         sprime = eliminate_avail (b, use);
    6134                 :            :       else
    6135                 :            :         /* Look for sth available at the definition block of the argument.
    6136                 :            :            This avoids inconsistencies between availability there which
    6137                 :            :            decides if the stmt can be removed and availability at the
    6138                 :            :            use site.  The SSA property ensures that things available
    6139                 :            :            at the definition are also available at uses.  */
    6140                 :   81184300 :         sprime = eliminate_avail (gimple_bb (SSA_NAME_DEF_STMT (use)), use);
    6141                 :   97689400 :       if (sprime && sprime != use
    6142                 :    7571760 :           && may_propagate_copy (use, sprime)
    6143                 :            :           /* We substitute into debug stmts to avoid excessive
    6144                 :            :              debug temporaries created by removed stmts, but we need
    6145                 :            :              to avoid doing so for inserted sprimes as we never want
    6146                 :            :              to create debug temporaries for them.  */
    6147                 :  105260000 :           && (!inserted_exprs
    6148                 :     741227 :               || TREE_CODE (sprime) != SSA_NAME
    6149                 :     735150 :               || !is_gimple_debug (stmt)
    6150                 :     204264 :               || !bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (sprime))))
    6151                 :            :         {
    6152                 :    7376160 :           propagate_value (use_p, sprime);
    6153                 :    7376160 :           modified = true;
    6154                 :            :         }
    6155                 :            :     }
    6156                 :            : 
    6157                 :            :   /* Fold the stmt if modified, this canonicalizes MEM_REFs we propagated
    6158                 :            :      into which is a requirement for the IPA devirt machinery.  */
    6159                 :  209608000 :   gimple *old_stmt = stmt;
    6160                 :  209608000 :   if (modified)
    6161                 :            :     {
    6162                 :            :       /* If a formerly non-invariant ADDR_EXPR is turned into an
    6163                 :            :          invariant one it was on a separate stmt.  */
    6164                 :    6867310 :       if (gimple_assign_single_p (stmt)
    6165                 :    2437460 :           && TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR)
    6166                 :     268874 :         recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
    6167                 :    6867310 :       gimple_stmt_iterator prev = *gsi;
    6168                 :    6867310 :       gsi_prev (&prev);
    6169                 :    6867310 :       if (fold_stmt (gsi))
    6170                 :            :         {
    6171                 :            :           /* fold_stmt may have created new stmts inbetween
    6172                 :            :              the previous stmt and the folded stmt.  Mark
    6173                 :            :              all defs created there as varying to not confuse
    6174                 :            :              the SCCVN machinery as we're using that even during
    6175                 :            :              elimination.  */
    6176                 :     542361 :           if (gsi_end_p (prev))
    6177                 :     175600 :             prev = gsi_start_bb (b);
    6178                 :            :           else
    6179                 :     454561 :             gsi_next (&prev);
    6180                 :     542361 :           if (gsi_stmt (prev) != gsi_stmt (*gsi))
    6181                 :       5624 :             do
    6182                 :            :               {
    6183                 :       7629 :                 tree def;
    6184                 :       7629 :                 ssa_op_iter dit;
    6185                 :      15253 :                 FOR_EACH_SSA_TREE_OPERAND (def, gsi_stmt (prev),
    6186                 :            :                                            dit, SSA_OP_ALL_DEFS)
    6187                 :            :                     /* As existing DEFs may move between stmts
    6188                 :            :                        only process new ones.  */
    6189                 :       7624 :                     if (! has_VN_INFO (def))
    6190                 :            :                       {
    6191                 :       5516 :                         VN_INFO (def)->valnum = def;
    6192                 :       5516 :                         VN_INFO (def)->visited = true;
    6193                 :            :                       }
    6194                 :       7629 :                 if (gsi_stmt (prev) == gsi_stmt (*gsi))
    6195                 :            :                   break;
    6196                 :       5624 :                 gsi_next (&prev);
    6197                 :            :               }
    6198                 :            :             while (1);
    6199                 :            :         }
    6200                 :    6867310 :       stmt = gsi_stmt (*gsi);
    6201                 :            :       /* In case we folded the stmt away schedule the NOP for removal.  */
    6202                 :    6867310 :       if (gimple_nop_p (stmt))
    6203                 :        267 :         to_remove.safe_push (stmt);
    6204                 :            :     }
    6205                 :            : 
    6206                 :            :   /* Visit indirect calls and turn them into direct calls if
    6207                 :            :      possible using the devirtualization machinery.  Do this before
    6208                 :            :      checking for required EH/abnormal/noreturn cleanup as devird
    6209                 :            :      may expose more of those.  */
    6210                 :  209608000 :   if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
    6211                 :            :     {
    6212                 :   14261600 :       tree fn = gimple_call_fn (call_stmt);
    6213                 :   14261600 :       if (fn
    6214                 :   13844300 :           && flag_devirtualize
    6215                 :   27669600 :           && virtual_method_call_p (fn))
    6216                 :            :         {
    6217                 :     118724 :           tree otr_type = obj_type_ref_class (fn);
    6218                 :     118724 :           unsigned HOST_WIDE_INT otr_tok
    6219                 :     118724 :               = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (fn));
    6220                 :     118724 :           tree instance;
    6221                 :     118724 :           ipa_polymorphic_call_context context (current_function_decl,
    6222                 :     118724 :                                                 fn, stmt, &instance);
    6223                 :     118724 :           context.get_dynamic_type (instance, OBJ_TYPE_REF_OBJECT (fn),
    6224                 :            :                                     otr_type, stmt, NULL);
    6225                 :     118724 :           bool final;
    6226                 :     118724 :           vec <cgraph_node *> targets
    6227                 :            :               = possible_polymorphic_call_targets (obj_type_ref_class (fn),
    6228                 :     118724 :                                                    otr_tok, context, &final);
    6229                 :     118724 :           if (dump_file)
    6230                 :         27 :             dump_possible_polymorphic_call_targets (dump_file,
    6231                 :            :                                                     obj_type_ref_class (fn),
    6232                 :            :                                                     otr_tok, context);
    6233                 :     118724 :           if (final && targets.length () <= 1 && dbg_cnt (devirt))
    6234                 :            :             {
    6235                 :         30 :               tree fn;
    6236                 :         30 :               if (targets.length () == 1)
    6237                 :         30 :                 fn = targets[0]->decl;
    6238                 :            :               else
    6239                 :          0 :                 fn = builtin_decl_implicit (BUILT_IN_UNREACHABLE);
    6240                 :         30 :               if (dump_enabled_p ())
    6241                 :            :                 {
    6242                 :         12 :                   dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
    6243                 :            :                                    "converting indirect call to "
    6244                 :            :                                    "function %s\n",
    6245                 :         12 :                                    lang_hooks.decl_printable_name (fn, 2));
    6246                 :            :                 }
    6247                 :         30 :               gimple_call_set_fndecl (call_stmt, fn);
    6248                 :            :               /* If changing the call to __builtin_unreachable
    6249                 :            :                  or similar noreturn function, adjust gimple_call_fntype
    6250                 :            :                  too.  */
    6251                 :         30 :               if (gimple_call_noreturn_p (call_stmt)
    6252                 :          0 :                   && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fn)))
    6253                 :          0 :                   && TYPE_ARG_TYPES (TREE_TYPE (fn))
    6254                 :         30 :                   && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fn)))
    6255                 :          0 :                       == void_type_node))
    6256                 :          0 :                 gimple_call_set_fntype (call_stmt, TREE_TYPE (fn));
    6257                 :         30 :               maybe_remove_unused_call_args (cfun, call_stmt);
    6258                 :         30 :               modified = true;
    6259                 :            :             }
    6260                 :            :         }
    6261                 :            :     }
    6262                 :            : 
    6263                 :  209608000 :   if (modified)
    6264                 :            :     {
    6265                 :            :       /* When changing a call into a noreturn call, cfg cleanup
    6266                 :            :          is needed to fix up the noreturn call.  */
    6267                 :    6867330 :       if (!was_noreturn
    6268                 :    6867330 :           && is_gimple_call (stmt) && gimple_call_noreturn_p (stmt))
    6269                 :         60 :         to_fixup.safe_push  (stmt);
    6270                 :            :       /* When changing a condition or switch into one we know what
    6271                 :            :          edge will be executed, schedule a cfg cleanup.  */
    6272                 :    6867330 :       if ((gimple_code (stmt) == GIMPLE_COND
    6273                 :     861733 :            && (gimple_cond_true_p (as_a <gcond *> (stmt))
    6274                 :     852291 :                || gimple_cond_false_p (as_a <gcond *> (stmt))))
    6275                 :    7702080 :           || (gimple_code (stmt) == GIMPLE_SWITCH
    6276                 :       4365 :               && TREE_CODE (gimple_switch_index
    6277                 :            :                             (as_a <gswitch *> (stmt))) == INTEGER_CST))
    6278                 :      27588 :         el_todo |= TODO_cleanup_cfg;
    6279                 :            :       /* If we removed EH side-effects from the statement, clean
    6280                 :            :          its EH information.  */
    6281                 :    6867330 :       if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
    6282                 :            :         {
    6283                 :       1576 :           bitmap_set_bit (need_eh_cleanup,
    6284                 :       1576 :                           gimple_bb (stmt)->index);
    6285                 :       1576 :           if (dump_file && (dump_flags & TDF_DETAILS))
    6286                 :          0 :             fprintf (dump_file, "  Removed EH side-effects.\n");
    6287                 :            :         }
    6288                 :            :       /* Likewise for AB side-effects.  */
    6289                 :    6867330 :       if (can_make_abnormal_goto
    6290                 :    6867330 :           && !stmt_can_make_abnormal_goto (stmt))
    6291                 :            :         {
    6292                 :          0 :           bitmap_set_bit (need_ab_cleanup,
    6293                 :          0 :                           gimple_bb (stmt)->index);
    6294                 :          0 :           if (dump_file && (dump_flags & TDF_DETAILS))
    6295                 :          0 :             fprintf (dump_file, "  Removed AB side-effects.\n");
    6296                 :            :         }
    6297                 :    6867330 :       update_stmt (stmt);
    6298                 :            :       /* In case the VDEF on the original stmt was released, value-number
    6299                 :            :          it to the VUSE.  This is to make vuse_ssa_val able to skip
    6300                 :            :          released virtual operands.  */
    6301                 :    9238590 :       if (vdef && SSA_NAME_IN_FREE_LIST (vdef))
    6302                 :       1610 :         VN_INFO (vdef)->valnum = vuse;
    6303                 :            :     }
    6304                 :            : 
    6305                 :            :   /* Make new values available - for fully redundant LHS we
    6306                 :            :      continue with the next stmt above and skip this.  */
    6307                 :  209608000 :   def_operand_p defp;
    6308                 :  251771000 :   FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_DEF)
    6309                 :   42163600 :     eliminate_push_avail (b, DEF_FROM_PTR (defp));
    6310                 :            : }
    6311                 :            : 
    6312                 :            : /* Perform elimination for the basic-block B during the domwalk.  */
    6313                 :            : 
    6314                 :            : edge
    6315                 :   26280600 : eliminate_dom_walker::before_dom_children (basic_block b)
    6316                 :            : {
    6317                 :            :   /* Mark new bb.  */
    6318                 :   26280600 :   avail_stack.safe_push (NULL_TREE);
    6319                 :            : 
    6320                 :            :   /* Skip unreachable blocks marked unreachable during the SCCVN domwalk.  */
    6321                 :   26280600 :   if (!(b->flags & BB_EXECUTABLE))
    6322                 :            :     return NULL;
    6323                 :            : 
    6324                 :   24492700 :   vn_context_bb = b;
    6325                 :            : 
    6326                 :   32073800 :   for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
    6327                 :            :     {
    6328                 :    7581140 :       gphi *phi = gsi.phi ();
    6329                 :    7581140 :       tree res = PHI_RESULT (phi);
    6330                 :            : 
    6331                 :   15162300 :       if (virtual_operand_p (res))
    6332                 :            :         {
    6333                 :    3842110 :           gsi_next (&gsi);
    6334                 :    3842110 :           continue;
    6335                 :            :         }
    6336                 :            : 
    6337                 :    3739030 :       tree sprime = eliminate_avail (b, res);
    6338                 :    3739030 :       if (sprime
    6339                 :    3739030 :           && sprime != res)
    6340                 :            :         {
    6341                 :     264494 :           if (dump_file && (dump_flags & TDF_DETAILS))
    6342                 :            :             {
    6343                 :         31 :               fprintf (dump_file, "Replaced redundant PHI node defining ");
    6344                 :         31 :               print_generic_expr (dump_file, res);
    6345                 :         31 :               fprintf (dump_file, " with ");
    6346                 :         31 :               print_generic_expr (dump_file, sprime);
    6347                 :         31 :               fprintf (dump_file, "\n");
    6348                 :            :             }
    6349                 :            : 
    6350                 :            :           /* If we inserted this PHI node ourself, it's not an elimination.  */
    6351                 :     264494 :           if (! inserted_exprs
    6352                 :     341223 :               || ! bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
    6353                 :     247910 :             eliminations++;
    6354                 :            : 
    6355                 :            :           /* If we will propagate into all uses don't bother to do
    6356                 :            :              anything.  */
    6357                 :     264494 :           if (may_propagate_copy (res, sprime))
    6358                 :            :             {
    6359                 :            :               /* Mark the PHI for removal.  */
    6360                 :     264494 :               to_remove.safe_push (phi);
    6361                 :     264494 :               gsi_next (&gsi);
    6362                 :     264494 :               continue;
    6363                 :            :             }
    6364                 :            : 
    6365                 :          0 :           remove_phi_node (&gsi, false);
    6366                 :            : 
    6367                 :          0 :           if (!useless_type_conversion_p (TREE_TYPE (res), TREE_TYPE (sprime)))
    6368                 :          0 :             sprime = fold_convert (TREE_TYPE (res), sprime);
    6369                 :          0 :           gimple *stmt = gimple_build_assign (res, sprime);
    6370                 :          0 :           gimple_stmt_iterator gsi2 = gsi_after_labels (b);
    6371                 :          0 :           gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
    6372                 :          0 :           continue;
    6373                 :            :         }
    6374                 :            : 
    6375                 :    3474540 :       eliminate_push_avail (b, res);
    6376                 :    3474540 :       gsi_next (&gsi);
    6377                 :            :     }
    6378                 :            : 
    6379                 :   24492700 :   for (gimple_stmt_iterator gsi = gsi_start_bb (b);
    6380                 :  182252000 :        !gsi_end_p (gsi);
    6381                 :  157760000 :        gsi_next (&gsi))
    6382                 :  157760000 :     eliminate_stmt (b, &gsi);
    6383                 :            : 
    6384                 :            :   /* Replace destination PHI arguments.  */
    6385                 :   24492700 :   edge_iterator ei;
    6386                 :   24492700 :   edge e;
    6387                 :   57543900 :   FOR_EACH_EDGE (e, ei, b->succs)
    6388                 :   33051200 :     if (e->flags & EDGE_EXECUTABLE)
    6389                 :   32831800 :       for (gphi_iterator gsi = gsi_start_phis (e->dest);
    6390                 :   51788400 :            !gsi_end_p (gsi);
    6391                 :   18956600 :            gsi_next (&gsi))
    6392                 :            :         {
    6393                 :   18956600 :           gphi *phi = gsi.phi ();
    6394                 :   18956600 :           use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
    6395                 :   18956600 :           tree arg = USE_FROM_PTR (use_p);
    6396                 :   31973400 :           if (TREE_CODE (arg) != SSA_NAME
    6397                 :   18956600 :               || virtual_operand_p (arg))
    6398                 :   13016800 :             continue;
    6399                 :    5939850 :           tree sprime = eliminate_avail (b, arg);
    6400                 :    5939850 :           if (sprime && may_propagate_copy (arg, sprime))
    6401                 :    5933260 :             propagate_value (use_p, sprime);
    6402                 :            :         }
    6403                 :            : 
    6404                 :   24492700 :   vn_context_bb = NULL;
    6405                 :            : 
    6406                 :   24492700 :   return NULL;
    6407                 :            : }
    6408                 :            : 
    6409                 :            : /* Make no longer available leaders no longer available.  */
    6410                 :            : 
    6411                 :            : void
    6412                 :   26280600 : eliminate_dom_walker::after_dom_children (basic_block)
    6413                 :            : {
    6414                 :   59318300 :   tree entry;
    6415                 :   59318300 :   while ((entry = avail_stack.pop ()) != NULL_TREE)
    6416                 :            :     {
    6417                 :   33037700 :       tree valnum = VN_INFO (entry)->valnum;
    6418                 :   33037700 :       tree old = avail[SSA_NAME_VERSION (valnum)];
    6419                 :   33037700 :       if (old == entry)
    6420                 :   33030800 :         avail[SSA_NAME_VERSION (valnum)] = NULL_TREE;
    6421                 :            :       else
    6422                 :       6906 :         avail[SSA_NAME_VERSION (valnum)] = entry;
    6423                 :            :     }
    6424                 :   26280600 : }
    6425                 :            : 
    6426                 :            : /* Remove queued stmts and perform delayed cleanups.  */
    6427                 :            : 
    6428                 :            : unsigned
    6429                 :    3767280 : eliminate_dom_walker::eliminate_cleanup (bool region_p)
    6430                 :            : {
    6431                 :    3767280 :   statistics_counter_event (cfun, "Eliminated", eliminations);
    6432                 :    3767280 :   statistics_counter_event (cfun, "Insertions", insertions);
    6433                 :            : 
    6434                 :            :   /* We cannot remove stmts during BB walk, especially not release SSA
    6435                 :            :      names there as this confuses the VN machinery.  The stmts ending
    6436                 :            :      up in to_remove are either stores or simple copies.
    6437                 :            :      Remove stmts in reverse order to make debug stmt creation possible.  */
    6438                 :   13080500 :   while (!to_remove.is_empty ())
    6439                 :            :     {
    6440                 :    9313180 :       bool do_release_defs = true;
    6441                 :    9313180 :       gimple *stmt = to_remove.pop ();
    6442                 :            : 
    6443                 :            :       /* When we are value-numbering a region we do not require exit PHIs to
    6444                 :            :          be present so we have to make sure to deal with uses outside of the
    6445                 :            :          region of stmts that we thought are eliminated.
    6446                 :            :          ??? Note we may be confused by uses in dead regions we didn't run
    6447                 :            :          elimination on.  Rather than checking individual uses we accept
    6448                 :            :          dead copies to be generated here (gcc.c-torture/execute/20060905-1.c
    6449                 :            :          contains such example).  */
    6450                 :    9313180 :       if (region_p)
    6451                 :            :         {
    6452                 :     525906 :           if (gphi *phi = dyn_cast <gphi *> (stmt))
    6453                 :            :             {
    6454                 :     281993 :               tree lhs = gimple_phi_result (phi);
    6455                 :     281993 :               if (!has_zero_uses (lhs))
    6456                 :            :                 {
    6457                 :      12396 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    6458                 :          0 :                     fprintf (dump_file, "Keeping eliminated stmt live "
    6459                 :            :                              "as copy because of out-of-region uses\n");
    6460                 :      12396 :                   tree sprime = eliminate_avail (gimple_bb (stmt), lhs);
    6461                 :      12396 :                   gimple *copy = gimple_build_assign (lhs, sprime);
    6462                 :      12396 :                   gimple_stmt_iterator gsi
    6463                 :      12396 :                     = gsi_after_labels (gimple_bb (stmt));
    6464                 :      12396 :                   gsi_insert_before (&gsi, copy, GSI_SAME_STMT);
    6465                 :      12396 :                   do_release_defs = false;
    6466                 :            :                 }
    6467                 :            :             }
    6468                 :     243913 :           else if (tree lhs = gimple_get_lhs (stmt))
    6469                 :     243913 :             if (TREE_CODE (lhs) == SSA_NAME
    6470                 :     243913 :                 && !has_zero_uses (lhs))
    6471                 :            :               {
    6472                 :        209 :                 if (dump_file && (dump_flags & TDF_DETAILS))
    6473                 :          0 :                   fprintf (dump_file, "Keeping eliminated stmt live "
    6474                 :            :                            "as copy because of out-of-region uses\n");
    6475                 :        209 :                 tree sprime = eliminate_avail (gimple_bb (stmt), lhs);
    6476                 :        209 :                 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    6477                 :        209 :                 if (is_gimple_assign (stmt))
    6478                 :            :                   {
    6479                 :        209 :                     gimple_assign_set_rhs_from_tree (&gsi, sprime);
    6480                 :        209 :                     stmt = gsi_stmt (gsi);
    6481                 :        209 :                     update_stmt (stmt);
    6482                 :        209 :                     if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
    6483                 :          0 :                       bitmap_set_bit (need_eh_cleanup, gimple_bb (stmt)->index);
    6484                 :        209 :                     continue;
    6485                 :            :                   }
    6486                 :            :                 else
    6487                 :            :                   {
    6488                 :          0 :                     gimple *copy = gimple_build_assign (lhs, sprime);
    6489                 :          0 :                     gsi_insert_before (&gsi, copy, GSI_SAME_STMT);
    6490                 :          0 :                     do_release_defs = false;
    6491                 :            :                   }
    6492                 :            :               }
    6493                 :            :         }
    6494                 :            : 
    6495                 :    9312970 :       if (dump_file && (dump_flags & TDF_DETAILS))
    6496                 :            :         {
    6497                 :        542 :           fprintf (dump_file, "Removing dead stmt ");
    6498                 :        542 :           print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);
    6499                 :            :         }
    6500                 :            : 
    6501                 :    9312970 :       gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    6502                 :    9312970 :       if (gimple_code (stmt) == GIMPLE_PHI)
    6503                 :     878993 :         remove_phi_node (&gsi, do_release_defs);
    6504                 :            :       else
    6505                 :            :         {
    6506                 :    8433980 :           basic_block bb = gimple_bb (stmt);
    6507                 :    8433980 :           unlink_stmt_vdef (stmt);
    6508                 :    8433980 :           if (gsi_remove (&gsi, true))
    6509                 :      21816 :             bitmap_set_bit (need_eh_cleanup, bb->index);
    6510                 :    8433980 :           if (is_gimple_call (stmt) && stmt_can_make_abnormal_goto (stmt))
    6511                 :          2 :             bitmap_set_bit (need_ab_cleanup, bb->index);
    6512                 :    8433980 :           if (do_release_defs)
    6513                 :    8433980 :             release_defs (stmt);
    6514                 :            :         }
    6515                 :            : 
    6516                 :            :       /* Removing a stmt may expose a forwarder block.  */
    6517                 :    9312970 :       el_todo |= TODO_cleanup_cfg;
    6518                 :            :     }
    6519                 :            : 
    6520                 :            :   /* Fixup stmts that became noreturn calls.  This may require splitting
    6521                 :            :      blocks and thus isn't possible during the dominator walk.  Do this
    6522                 :            :      in reverse order so we don't inadvertedly remove a stmt we want to
    6523                 :            :      fixup by visiting a dominating now noreturn call first.  */
    6524                 :    3767340 :   while (!to_fixup.is_empty ())
    6525                 :            :     {
    6526                 :         60 :       gimple *stmt = to_fixup.pop ();
    6527                 :            : 
    6528                 :         60 :       if (dump_file && (dump_flags & TDF_DETAILS))
    6529                 :            :         {
    6530                 :          0 :           fprintf (dump_file, "Fixing up noreturn call ");
    6531                 :          0 :           print_gimple_stmt (dump_file, stmt, 0);
    6532                 :            :         }
    6533                 :            : 
    6534                 :         60 :       if (fixup_noreturn_call (stmt))
    6535                 :         60 :         el_todo |= TODO_cleanup_cfg;
    6536                 :            :     }
    6537                 :            : 
    6538                 :    3767280 :   bool do_eh_cleanup = !bitmap_empty_p (need_eh_cleanup);
    6539                 :    3767280 :   bool do_ab_cleanup = !bitmap_empty_p (need_ab_cleanup);
    6540                 :            : 
    6541                 :    3767280 :   if (do_eh_cleanup)
    6542                 :       8322 :     gimple_purge_all_dead_eh_edges (need_eh_cleanup);
    6543                 :            : 
    6544                 :    3767280 :   if (do_ab_cleanup)
    6545                 :          2 :     gimple_purge_all_dead_abnormal_call_edges (need_ab_cleanup);
    6546                 :            : 
    6547                 :    3767280 :   if (do_eh_cleanup || do_ab_cleanup)
    6548                 :       8324 :     el_todo |= TODO_cleanup_cfg;
    6549                 :            : 
    6550                 :    3767280 :   return el_todo;
    6551                 :            : }
    6552                 :            : 
    6553                 :            : /* Eliminate fully redundant computations.  */
    6554                 :            : 
    6555                 :            : unsigned
    6556                 :    2824200 : eliminate_with_rpo_vn (bitmap inserted_exprs)
    6557                 :            : {
    6558                 :    5648410 :   eliminate_dom_walker walker (CDI_DOMINATORS, inserted_exprs);
    6559                 :            : 
    6560                 :    2824200 :   walker.walk (cfun->cfg->x_entry_block_ptr);
    6561                 :    2824200 :   return walker.eliminate_cleanup ();
    6562                 :            : }
    6563                 :            : 
    6564                 :            : static unsigned
    6565                 :            : do_rpo_vn (function *fn, edge entry, bitmap exit_bbs,
    6566                 :            :            bool iterate, bool eliminate);
    6567                 :            : 
    6568                 :            : void
    6569                 :     645456 : run_rpo_vn (vn_lookup_kind kind)
    6570                 :            : {
    6571                 :     645456 :   default_vn_walk_kind = kind;
    6572                 :     645456 :   do_rpo_vn (cfun, NULL, NULL, true, false);
    6573                 :            : 
    6574                 :            :   /* ???  Prune requirement of these.  */
    6575                 :     645456 :   constant_to_value_id = new hash_table<vn_constant_hasher> (23);
    6576                 :     645456 :   constant_value_ids = BITMAP_ALLOC (NULL);
    6577                 :            : 
    6578                 :            :   /* Initialize the value ids and prune out remaining VN_TOPs
    6579                 :            :      from dead code.  */
    6580                 :     645456 :   tree name;
    6581                 :     645456 :   unsigned i;
    6582                 :   29891900 :   FOR_EACH_SSA_NAME (i, name, cfun)
    6583                 :            :     {
    6584                 :   22148000 :       vn_ssa_aux_t info = VN_INFO (name);
    6585                 :   22148000 :       if (!info->visited
    6586                 :   22089300 :           || info->valnum == VN_TOP)
    6587                 :      58695 :         info->valnum = name;
    6588                 :   22148000 :       if (info->valnum == name)
    6589                 :   21547400 :         info->value_id = get_next_value_id ();
    6590                 :     600612 :       else if (is_gimple_min_invariant (info->valnum))
    6591                 :      32410 :         info->value_id = get_or_alloc_constant_value_id (info->valnum);
    6592                 :            :     }
    6593                 :            : 
    6594                 :            :   /* Propagate.  */
    6595                 :   29891900 :   FOR_EACH_SSA_NAME (i, name, cfun)
    6596                 :            :     {
    6597                 :   22148000 :       vn_ssa_aux_t info = VN_INFO (name);
    6598                 :   22148000 :       if (TREE_CODE (info->valnum) == SSA_NAME
    6599                 :   22115600 :           && info->valnum != name
    6600                 :   22716200 :           && info->value_id != VN_INFO (info->valnum)->value_id)
    6601                 :     568202 :         info->value_id = VN_INFO (info->valnum)->value_id;
    6602                 :            :     }
    6603                 :            : 
    6604                 :     645456 :   set_hashtable_value_ids ();
    6605                 :            : 
    6606                 :     645456 :   if (dump_file && (dump_flags & TDF_DETAILS))
    6607                 :            :     {
    6608                 :         16 :       fprintf (dump_file, "Value numbers:\n");
    6609                 :        511 :       FOR_EACH_SSA_NAME (i, name, cfun)
    6610                 :            :         {
    6611                 :        334 :           if (VN_INFO (name)->visited
    6612                 :        334 :               && SSA_VAL (name) != name)
    6613                 :            :             {
    6614                 :          9 :               print_generic_expr (dump_file, name);
    6615                 :          9 :               fprintf (dump_file, " = ");
    6616                 :          9 :               print_generic_expr (dump_file, SSA_VAL (name));
    6617                 :          9 :               fprintf (dump_file, " (%04d)\n", VN_INFO (name)->value_id);
    6618                 :            :             }
    6619                 :            :         }
    6620                 :            :     }
    6621                 :     645456 : }
    6622                 :            : 
    6623                 :            : /* Free VN associated data structures.  */
    6624                 :            : 
    6625                 :            : void
    6626                 :    3767280 : free_rpo_vn (void)
    6627                 :            : {
    6628                 :    3767280 :   free_vn_table (valid_info);
    6629                 :    3767280 :   XDELETE (valid_info);
    6630                 :    3767280 :   obstack_free (&vn_tables_obstack, NULL);
    6631                 :    3767280 :   obstack_free (&vn_tables_insert_obstack, NULL);
    6632                 :            : 
    6633                 :    3767280 :   vn_ssa_aux_iterator_type it;
    6634                 :    3767280 :   vn_ssa_aux_t info;
    6635                 :  115184000 :   FOR_EACH_HASH_TABLE_ELEMENT (*vn_ssa_aux_hash, info, vn_ssa_aux_t, it)
    6636                 :  107649000 :     if (info->needs_insertion)
    6637                 :  109855000 :       release_ssa_name (info->name);
    6638                 :    3767280 :   obstack_free (&vn_ssa_aux_obstack, NULL);
    6639                 :    3767280 :   delete vn_ssa_aux_hash;
    6640                 :            : 
    6641                 :    3767280 :   delete constant_to_value_id;
    6642                 :    3767280 :   constant_to_value_id = NULL;
    6643                 :    3767280 :   BITMAP_FREE (constant_value_ids);
    6644                 :    3767280 : }
    6645                 :            : 
    6646                 :            : /* Hook for maybe_push_res_to_seq, lookup the expression in the VN tables.  */
    6647                 :            : 
    6648                 :            : static tree
    6649                 :    9343430 : vn_lookup_simplify_result (gimple_match_op *res_op)
    6650                 :            : {
    6651                 :    9343430 :   if (!res_op->code.is_tree_code ())
    6652                 :            :     return NULL_TREE;
    6653                 :    9343420 :   tree *ops = res_op->ops;
    6654                 :    9343420 :   unsigned int length = res_op->num_ops;
    6655                 :    9343420 :   if (res_op->code == CONSTRUCTOR
    6656                 :            :       /* ???  We're arriving here with SCCVNs view, decomposed CONSTRUCTOR
    6657                 :            :          and GIMPLEs / match-and-simplifies, CONSTRUCTOR as GENERIC tree.  */
    6658                 :    9343420 :       && TREE_CODE (res_op->ops[0]) == CONSTRUCTOR)
    6659                 :            :     {
    6660                 :         84 :       length = CONSTRUCTOR_NELTS (res_op->ops[0]);
    6661                 :         84 :       ops = XALLOCAVEC (tree, length);
    6662                 :        317 :       for (unsigned i = 0; i < length; ++i)
    6663                 :        233 :         ops[i] = CONSTRUCTOR_ELT (res_op->ops[0], i)->value;
    6664                 :            :     }
    6665                 :    9343420 :   vn_nary_op_t vnresult = NULL;
    6666                 :    9343420 :   tree res = vn_nary_op_lookup_pieces (length, (tree_code) res_op->code,
    6667                 :            :                                        res_op->type, ops, &vnresult);
    6668                 :            :   /* If this is used from expression simplification make sure to
    6669                 :            :      return an available expression.  */
    6670                 :    9343420 :   if (res && TREE_CODE (res) == SSA_NAME && mprts_hook && rpo_avail)
    6671                 :    1537940 :     res = rpo_avail->eliminate_avail (vn_context_bb, res);
    6672                 :            :   return res;
    6673                 :            : }
    6674                 :            : 
    6675                 :            : /* Return a leader for OPs value that is valid at BB.  */
    6676                 :            : 
    6677                 :            : tree
    6678                 :  134816000 : rpo_elim::eliminate_avail (basic_block bb, tree op)
    6679                 :            : {
    6680                 :  134816000 :   bool visited;
    6681                 :  134816000 :   tree valnum = SSA_VAL (op, &visited);
    6682                 :            :   /* If we didn't visit OP then it must be defined outside of the
    6683                 :            :      region we process and also dominate it.  So it is available.  */
    6684                 :  134816000 :   if (!visited)
    6685                 :            :     return op;
    6686                 :  133640000 :   if (TREE_CODE (valnum) == SSA_NAME)
    6687                 :            :     {
    6688                 :  125777000 :       if (SSA_NAME_IS_DEFAULT_DEF (valnum))
    6689                 :            :         return valnum;
    6690                 :  122180000 :       vn_avail *av = VN_INFO (valnum)->avail;
    6691                 :  122180000 :       if (!av)
    6692                 :            :         return NULL_TREE;
    6693                 :   70654600 :       if (av->location == bb->index)
    6694                 :            :         /* On tramp3d 90% of the cases are here.  */
    6695                 :   45763600 :         return ssa_name (av->leader);
    6696                 :   28462700 :       do
    6697                 :            :         {
    6698                 :   28462700 :           basic_block abb = BASIC_BLOCK_FOR_FN (cfun, av->location);
    6699                 :            :           /* ???  During elimination we have to use availability at the
    6700                 :            :              definition site of a use we try to replace.  This
    6701                 :            :              is required to not run into inconsistencies because
    6702                 :            :              of dominated_by_p_w_unex behavior and removing a definition
    6703                 :            :              while not replacing all uses.
    6704                 :            :              ???  We could try to consistently walk dominators
    6705                 :            :              ignoring non-executable regions.  The nearest common
    6706                 :            :              dominator of bb and abb is where we can stop walking.  We
    6707                 :            :              may also be able to "pre-compute" (bits of) the next immediate
    6708                 :            :              (non-)dominator during the RPO walk when marking edges as
    6709                 :            :              executable.  */
    6710                 :   28462700 :           if (dominated_by_p_w_unex (bb, abb))
    6711                 :            :             {
    6712                 :   22564200 :               tree leader = ssa_name (av->leader);
    6713                 :            :               /* Prevent eliminations that break loop-closed SSA.  */
    6714                 :   22564200 :               if (loops_state_satisfies_p (LOOP_CLOSED_SSA)
    6715                 :     609394 :                   && ! SSA_NAME_IS_DEFAULT_DEF (leader)
    6716                 :   23173600 :                   && ! flow_bb_inside_loop_p (gimple_bb (SSA_NAME_DEF_STMT
    6717                 :     609394 :                                                          (leader))->loop_father,
    6718                 :            :                                               bb))
    6719                 :            :                 return NULL_TREE;
    6720                 :   22551900 :               if (dump_file && (dump_flags & TDF_DETAILS))
    6721                 :            :                 {
    6722                 :         64 :                   print_generic_expr (dump_file, leader);
    6723                 :         64 :                   fprintf (dump_file, " is available for ");
    6724                 :         64 :                   print_generic_expr (dump_file, valnum);
    6725                 :         64 :                   fprintf (dump_file, "\n");
    6726                 :            :                 }
    6727                 :            :               /* On tramp3d 99% of the _remaining_ cases succeed at
    6728                 :            :                  the first enty.  */
    6729                 :   22551900 :               return leader;
    6730                 :            :             }
    6731                 :            :           /* ???  Can we somehow skip to the immediate dominator
    6732                 :            :              RPO index (bb_to_rpo)?  Again, maybe not worth, on
    6733                 :            :              tramp3d the worst number of elements in the vector is 9.  */
    6734                 :    5898510 :           av = av->next;
    6735                 :            :         }
    6736                 :    5898510 :       while (av);
    6737                 :            :     }
    6738                 :    7863430 :   else if (valnum != VN_TOP)
    6739                 :            :     /* valnum is is_gimple_min_invariant.  */
    6740                 :    7863430 :     return valnum;
    6741                 :            :   return NULL_TREE;
    6742                 :            : }
    6743                 :            : 
    6744                 :            : /* Make LEADER a leader for its value at BB.  */
    6745                 :            : 
    6746                 :            : void
    6747                 :   59796700 : rpo_elim::eliminate_push_avail (basic_block bb, tree leader)
    6748                 :            : {
    6749                 :   59796700 :   tree valnum = VN_INFO (leader)->valnum;
    6750                 :   59796700 :   if (valnum == VN_TOP
    6751                 :   59796700 :       || is_gimple_min_invariant (valnum))
    6752                 :          0 :     return;
    6753                 :   59796700 :   if (dump_file && (dump_flags & TDF_DETAILS))
    6754                 :            :     {
    6755                 :       1023 :       fprintf (dump_file, "Making available beyond BB%d ", bb->index);
    6756                 :       1023 :       print_generic_expr (dump_file, leader);
    6757                 :       1023 :       fprintf (dump_file, " for value ");
    6758                 :       1023 :       print_generic_expr (dump_file, valnum);
    6759                 :       1023 :       fprintf (dump_file, "\n");
    6760                 :            :     }
    6761                 :   59796700 :   vn_ssa_aux_t value = VN_INFO (valnum);
    6762                 :   59796700 :   vn_avail *av;
    6763                 :   59796700 :   if (m_avail_freelist)
    6764                 :            :     {
    6765                 :   13209800 :       av = m_avail_freelist;
    6766                 :   13209800 :       m_avail_freelist = m_avail_freelist->next;
    6767                 :            :     }
    6768                 :            :   else
    6769                 :   46587000 :     av = XOBNEW (&vn_ssa_aux_obstack, vn_avail);
    6770                 :   59796700 :   av->location = bb->index;
    6771                 :   59796700 :   av->leader = SSA_NAME_VERSION (leader);
    6772                 :   59796700 :   av->next = value->avail;
    6773                 :   59796700 :   value->avail = av;
    6774                 :            : }
    6775                 :            : 
    6776                 :            : /* Valueization hook for RPO VN plus required state.  */
    6777                 :            : 
    6778                 :            : tree
    6779                 :  731569000 : rpo_vn_valueize (tree name)
    6780                 :            : {
    6781                 :  731569000 :   if (TREE_CODE (name) == SSA_NAME)
    6782                 :            :     {
    6783                 :  699380000 :       vn_ssa_aux_t val = VN_INFO (name);
    6784                 :  699380000 :       if (val)
    6785                 :            :         {
    6786                 :  699380000 :           tree tem = val->valnum;
    6787                 :  699380000 :           if (tem != VN_TOP && tem != name)
    6788                 :            :             {
    6789                 :   40558500 :               if (TREE_CODE (tem) != SSA_NAME)
    6790                 :            :                 return tem;
    6791                 :            :               /* For all values we only valueize to an available leader
    6792                 :            :                  which means we can use SSA name info without restriction.  */
    6793                 :   32007000 :               tem = rpo_avail->eliminate_avail (vn_context_bb, tem);
    6794                 :   32007000 :               if (tem)
    6795                 :   31784700 :                 return tem;
    6796                 :            :             }
    6797                 :            :         }
    6798                 :            :     }
    6799                 :            :   return name;
    6800                 :            : }
    6801                 :            : 
    6802                 :            : /* Insert on PRED_E predicates derived from CODE OPS being true besides the
    6803                 :            :    inverted condition.  */
    6804                 :            : 
    6805                 :            : static void
    6806                 :   20591400 : insert_related_predicates_on_edge (enum tree_code code, tree *ops, edge pred_e)
    6807                 :            : {
    6808                 :   20591400 :   switch (code)
    6809                 :            :     {
    6810                 :    1142720 :     case LT_EXPR:
    6811                 :            :       /* a < b -> a {!,<}= b */
    6812                 :    1142720 :       vn_nary_op_insert_pieces_predicated (2, NE_EXPR, boolean_type_node,
    6813                 :            :                                            ops, boolean_true_node, 0, pred_e);
    6814                 :    1142720 :       vn_nary_op_insert_pieces_predicated (2, LE_EXPR, boolean_type_node,
    6815                 :            :                                            ops, boolean_true_node, 0, pred_e);
    6816                 :            :       /* a < b -> ! a {>,=} b */
    6817                 :    1142720 :       vn_nary_op_insert_pieces_predicated (2, GT_EXPR, boolean_type_node,
    6818                 :            :                                            ops, boolean_false_node, 0, pred_e);
    6819                 :    1142720 :       vn_nary_op_insert_pieces_predicated (2, EQ_EXPR, boolean_type_node,
    6820                 :            :                                            ops, boolean_false_node, 0, pred_e);
    6821                 :    1142720 :       break;
    6822                 :    2083190 :     case GT_EXPR:
    6823                 :            :       /* a > b -> a {!,>}= b */
    6824                 :    2083190 :       vn_nary_op_insert_pieces_predicated (2, NE_EXPR, boolean_type_node,
    6825                 :            :                                            ops, boolean_true_node, 0, pred_e);
    6826                 :    2083190 :       vn_nary_op_insert_pieces_predicated (2, GE_EXPR, boolean_type_node,
    6827                 :            :                                            ops, boolean_true_node, 0, pred_e);
    6828                 :            :       /* a > b -> ! a {<,=} b */
    6829                 :    2083190 :       vn_nary_op_insert_pieces_predicated (2, LT_EXPR, boolean_type_node,
    6830                 :            :                                            ops, boolean_false_node, 0, pred_e);
    6831                 :    2083190 :       vn_nary_op_insert_pieces_predicated (2, EQ_EXPR, boolean_type_node,
    6832                 :            :                                            ops, boolean_false_node, 0, pred_e);
    6833                 :    2083190 :       break;
    6834                 :    7086880 :     case EQ_EXPR:
    6835                 :            :       /* a == b -> ! a {<,>} b */
    6836                 :    7086880 :       vn_nary_op_insert_pieces_predicated (2, LT_EXPR, boolean_type_node,
    6837                 :            :                                            ops, boolean_false_node, 0, pred_e);
    6838                 :    7086880 :       vn_nary_op_insert_pieces_predicated (2, GT_EXPR, boolean_type_node,
    6839                 :            :                                            ops, boolean_false_node, 0, pred_e);
    6840                 :    7086880 :       break;
    6841                 :            :     case LE_EXPR:
    6842                 :            :     case GE_EXPR:
    6843                 :            :     case NE_EXPR:
    6844                 :            :       /* Nothing besides inverted condition.  */
    6845                 :            :       break;
    6846                 :   20591400 :     default:;
    6847                 :            :     }
    6848                 :   20591400 : }
    6849                 :            : 
    6850                 :            : /* Main stmt worker for RPO VN, process BB.  */
    6851                 :            : 
    6852                 :            : static unsigned
    6853                 :   38751200 : process_bb (rpo_elim &avail, basic_block bb,
    6854                 :            :             bool bb_visited, bool iterate_phis, bool iterate, bool eliminate,
    6855                 :            :             bool do_region, bitmap exit_bbs, bool skip_phis)
    6856                 :            : {
    6857                 :   38751200 :   unsigned todo = 0;
    6858                 :   38751200 :   edge_iterator ei;
    6859                 :   38751200 :   edge e;
    6860                 :            : 
    6861                 :   38751200 :   vn_context_bb = bb;
    6862                 :            : 
    6863                 :            :   /* If we are in loop-closed SSA preserve this state.  This is
    6864                 :            :      relevant when called on regions from outside of FRE/PRE.  */
    6865                 :   38751200 :   bool lc_phi_nodes = false;
    6866                 :   38751200 :   if (!skip_phis
    6867                 :   38751200 :       && loops_state_satisfies_p (LOOP_CLOSED_SSA))
    6868                 :     338689 :     FOR_EACH_EDGE (e, ei, bb->preds)
    6869                 :     198009 :       if (e->src->loop_father != e->dest->loop_father
    6870                 :     198009 :           && flow_loop_nested_p (e->dest->loop_father,
    6871                 :            :                                  e->src->loop_father))
    6872                 :            :         {
    6873                 :            :           lc_phi_nodes = true;
    6874                 :            :           break;
    6875                 :            :         }
    6876                 :            : 
    6877                 :            :   /* When we visit a loop header substitute into loop info.  */
    6878                 :   38751200 :   if (!iterate && eliminate && bb->loop_father->header == bb)
    6879                 :            :     {
    6880                 :            :       /* Keep fields in sync with substitute_in_loop_info.  */
    6881                 :     420587 :       if (bb->loop_father->nb_iterations)
    6882                 :       4864 :         bb->loop_father->nb_iterations
    6883                 :       4864 :           = simplify_replace_tree (bb->loop_father->nb_iterations,
    6884                 :            :                                    NULL_TREE, NULL_TREE, &vn_valueize_wrapper);
    6885                 :            :     }
    6886                 :            : 
    6887                 :            :   /* Value-number all defs in the basic-block.  */
    6888                 :   38751200 :   if (!skip_phis)
    6889                 :   54929600 :     for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
    6890                 :   16181600 :          gsi_next (&gsi))
    6891                 :            :       {
    6892                 :   16181600 :         gphi *phi = gsi.phi ();
    6893                 :   16181600 :         tree res = PHI_RESULT (phi);
    6894                 :   16181600 :         vn_ssa_aux_t res_info = VN_INFO (res);
    6895                 :   16181600 :         if (!bb_visited)
    6896                 :            :           {
    6897                 :   11234500 :             gcc_assert (!res_info->visited);
    6898                 :   11234500 :             res_info->valnum = VN_TOP;
    6899                 :   11234500 :             res_info->visited = true;
    6900                 :            :           }
    6901                 :            : 
    6902                 :            :         /* When not iterating force backedge values to varying.  */
    6903                 :   16181600 :         visit_stmt (phi, !iterate_phis);
    6904                 :   32363100 :         if (virtual_operand_p (res))
    6905                 :    7271470 :           continue;
    6906                 :            : 
    6907                 :            :         /* Eliminate */
    6908                 :            :         /* The interesting case is gcc.dg/tree-ssa/pr22230.c for correctness
    6909                 :            :            how we handle backedges and availability.
    6910                 :            :            And gcc.dg/tree-ssa/ssa-sccvn-2.c for optimization.  */
    6911                 :    8910090 :         tree val = res_info->valnum;
    6912                 :    8910090 :         if (res != val && !iterate && eliminate)
    6913                 :            :           {
    6914                 :     775165 :             if (tree leader = avail.eliminate_avail (bb, res))
    6915                 :            :               {
    6916                 :     614534 :                 if (leader != res
    6917                 :            :                     /* Preserve loop-closed SSA form.  */
    6918                 :     614534 :                     && (! lc_phi_nodes
    6919                 :        183 :                         || is_gimple_min_invariant (leader)))
    6920                 :            :                   {
    6921                 :     614499 :                     if (dump_file && (dump_flags & TDF_DETAILS))
    6922                 :            :                       {
    6923                 :         38 :                         fprintf (dump_file, "Replaced redundant PHI node "
    6924                 :            :                                  "defining ");
    6925                 :         38 :                         print_generic_expr (dump_file, res);
    6926                 :         38 :                         fprintf (dump_file, " with ");
    6927                 :         38 :                         print_generic_expr (dump_file, leader);
    6928                 :         38 :                         fprintf (dump_file, "\n");
    6929                 :            :                       }
    6930                 :     614499 :                     avail.eliminations++;
    6931                 :            : 
    6932                 :     614499 :                     if (may_propagate_copy (res, leader))
    6933                 :            :                       {
    6934                 :            :                         /* Schedule for removal.  */
    6935                 :     614499 :                         avail.to_remove.safe_push (phi);
    6936                 :     614499 :                         continue;
    6937                 :            :                       }
    6938                 :            :                     /* ???  Else generate a copy stmt.  */
    6939                 :            :                   }
    6940                 :            :               }
    6941                 :            :           }
    6942                 :            :         /* Only make defs available that not already are.  But make
    6943                 :            :            sure loop-closed SSA PHI node defs are picked up for
    6944                 :            :            downstream uses.  */
    6945                 :    8295600 :         if (lc_phi_nodes
    6946                 :    8295600 :             || res == val
    6947                 :    8295600 :             || ! avail.eliminate_avail (bb, res))
    6948                 :    6304310 :           avail.eliminate_push_avail (bb, res);
    6949                 :            :       }
    6950                 :            : 
    6951                 :            :   /* For empty BBs mark outgoing edges executable.  For non-empty BBs
    6952                 :            :      we do this when processing the last stmt as we have to do this
    6953                 :            :      before elimination which otherwise forces GIMPLE_CONDs to
    6954                 :            :      if (1 != 0) style when seeing non-executable edges.  */
    6955                 :   77502500 :   if (gsi_end_p (gsi_start_bb (bb)))
    6956                 :            :     {
    6957                 :    9251850 :       FOR_EACH_EDGE (e, ei, bb->succs)
    6958                 :            :         {
    6959                 :    4625960 :           if (!(e->flags & EDGE_EXECUTABLE))
    6960                 :            :             {
    6961                 :    3254600 :               if (dump_file && (dump_flags & TDF_DETAILS))
    6962                 :         96 :                 fprintf (dump_file,
    6963                 :            :                          "marking outgoing edge %d -> %d executable\n",
    6964                 :         96 :                          e->src->index, e->dest->index);
    6965                 :    3254600 :               e->flags |= EDGE_EXECUTABLE;
    6966                 :    3254600 :               e->dest->flags |= BB_EXECUTABLE;
    6967                 :            :             }
    6968                 :    1371360 :           else if (!(e->dest->flags & BB_EXECUTABLE))
    6969                 :            :             {
    6970                 :          0 :               if (dump_file && (dump_flags & TDF_DETAILS))
    6971                 :          0 :                 fprintf (dump_file,
    6972                 :            :                          "marking destination block %d reachable\n",
    6973                 :            :                          e->dest->index);
    6974                 :          0 :               e->dest->flags |= BB_EXECUTABLE;
    6975                 :            :             }
    6976                 :            :         }
    6977                 :            :     }
    6978                 :   38751200 :   for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
    6979                 :  305895000 :        !gsi_end_p (gsi); gsi_next (&gsi))
    6980                 :            :     {
    6981                 :  267143000 :       ssa_op_iter i;
    6982                 :  267143000 :       tree op;
    6983                 :  267143000 :       if (!bb_visited)
    6984                 :            :         {
    6985                 :  304247000 :           FOR_EACH_SSA_TREE_OPERAND (op, gsi_stmt (gsi), i, SSA_OP_ALL_DEFS)
    6986                 :            :             {
    6987                 :   86882200 :               vn_ssa_aux_t op_info = VN_INFO (op);
    6988                 :   86882200 :               gcc_assert (!op_info->visited);
    6989                 :   86882200 :               op_info->valnum = VN_TOP;
    6990                 :   86882200 :               op_info->visited = true;
    6991                 :            :             }
    6992                 :            : 
    6993                 :            :           /* We somehow have to deal with uses that are not defined
    6994                 :            :              in the processed region.  Forcing unvisited uses to
    6995                 :            :              varying here doesn't play well with def-use following during
    6996                 :            :              expression simplification, so we deal with this by checking
    6997                 :            :              the visited flag in SSA_VAL.  */
    6998                 :            :         }
    6999                 :            : 
    7000                 :  267143000 :       visit_stmt (gsi_stmt (gsi));
    7001                 :            : 
    7002                 :  267143000 :       gimple *last = gsi_stmt (gsi);
    7003                 :  267143000 :       e = NULL;
    7004                 :  267143000 :       switch (gimple_code (last))
    7005                 :            :         {
    7006                 :      70724 :         case GIMPLE_SWITCH:
    7007                 :     141448 :           e = find_taken_edge (bb, vn_valueize (gimple_switch_index
    7008                 :      70724 :                                                 (as_a <gswitch *> (last))));
    7009                 :      70724 :           break;
    7010                 :   14471100 :         case GIMPLE_COND:
    7011                 :   14471100 :           {
    7012                 :   14471100 :             tree lhs = vn_valueize (gimple_cond_lhs (last));
    7013                 :   14471100 :             tree rhs = vn_valueize (gimple_cond_rhs (last));
    7014                 :   14471100 :             tree val = gimple_simplify (gimple_cond_code (last),
    7015                 :            :                                         boolean_type_node, lhs, rhs,
    7016                 :            :                                         NULL, vn_valueize);
    7017                 :            :             /* If the condition didn't simplfy see if we have recorded
    7018                 :            :                an expression from sofar taken edges.  */
    7019                 :   14471100 :             if (! val || TREE_CODE (val) != INTEGER_CST)
    7020                 :            :               {
    7021                 :   13727000 :                 vn_nary_op_t vnresult;
    7022                 :   13727000 :                 tree ops[2];
    7023                 :   13727000 :                 ops[0] = lhs;
    7024                 :   13727000 :                 ops[1] = rhs;
    7025                 :   13727000 :                 val = vn_nary_op_lookup_pieces (2, gimple_cond_code (last),
    7026                 :            :                                                 boolean_type_node, ops,
    7027                 :            :                                                 &vnresult);
    7028                 :            :                 /* Did we get a predicated value?  */
    7029                 :   13727000 :                 if (! val && vnresult && vnresult->predicated_values)
    7030                 :            :                   {
    7031                 :     741796 :                     val = vn_nary_op_get_predicated_value (vnresult, bb);
    7032                 :     741796 :                     if (val && dump_file && (dump_flags & TDF_DETAILS))
    7033                 :            :                       {
    7034                 :          2 :                         fprintf (dump_file, "Got predicated value ");
    7035                 :          2 :                         print_generic_expr (dump_file, val, TDF_NONE);
    7036                 :          2 :                         fprintf (dump_file, " for ");
    7037                 :          2 :                         print_gimple_stmt (dump_file, last, TDF_SLIM);
    7038                 :            :                       }
    7039                 :            :                   }
    7040                 :            :               }
    7041                 :   14471100 :             if (val)
    7042                 :    1133330 :               e = find_taken_edge (bb, val);
    7043                 :   14471100 :             if (! e)
    7044                 :            :               {
    7045                 :            :                 /* If we didn't manage to compute the taken edge then
    7046                 :            :                    push predicated expressions for the condition itself
    7047                 :            :                    and related conditions to the hashtables.  This allows
    7048                 :            :                    simplification of redundant conditions which is
    7049                 :            :                    important as early cleanup.  */
    7050                 :   13542100 :                 edge true_e, false_e;
    7051                 :   13542100 :                 extract_true_false_edges_from_block (bb, &true_e, &false_e);
    7052                 :   13542100 :                 enum tree_code code = gimple_cond_code (last);
    7053                 :   13542100 :                 enum tree_code icode
    7054                 :   13542100 :                   = invert_tree_comparison (code, HONOR_NANS (lhs));
    7055                 :   13542100 :                 tree ops[2];
    7056                 :   13542100 :                 ops[0] = lhs;
    7057                 :   13542100 :                 ops[1] = rhs;
    7058                 :   13542100 :                 if (do_region
    7059                 :   13542100 :                     && bitmap_bit_p (exit_bbs, true_e->dest->index))
    7060                 :      95791 :                   true_e = NULL;
    7061                 :   13542100 :                 if (do_region
    7062                 :   13542100 :                     && bitmap_bit_p (exit_bbs, false_e->dest->index))
    7063                 :     114550 :                   false_e = NULL;
    7064                 :   13542100 :                 if (true_e)
    7065                 :   13446300 :                   vn_nary_op_insert_pieces_predicated
    7066                 :   13446300 :                     (2, code, boolean_type_node, ops,
    7067                 :            :                      boolean_true_node, 0, true_e);
    7068                 :   13542100 :                 if (false_e)
    7069                 :   13427600 :                   vn_nary_op_insert_pieces_predicated
    7070                 :   13427600 :                     (2, code, boolean_type_node, ops,
    7071                 :            :                      boolean_false_node, 0, false_e);
    7072                 :   13542100 :                 if (icode != ERROR_MARK)
    7073                 :            :                   {
    7074                 :   13388100 :                     if (true_e)
    7075                 :   13292600 :                       vn_nary_op_insert_pieces_predicated
    7076                 :   13292600 :                         (2, icode, boolean_type_node, ops,
    7077                 :            :                          boolean_false_node, 0, true_e);
    7078                 :   13388100 :                     if (false_e)
    7079                 :   13273600 :                       vn_nary_op_insert_pieces_predicated
    7080                 :   13273600 :                         (2, icode, boolean_type_node, ops,
    7081                 :            :                          boolean_true_node, 0, false_e);
    7082                 :            :                   }
    7083                 :            :                 /* Relax for non-integers, inverted condition handled
    7084                 :            :                    above.  */
    7085                 :   13542100 :                 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
    7086                 :            :                   {
    7087                 :   10379300 :                     if (true_e)
    7088                 :   10313800 :                       insert_related_predicates_on_edge (code, ops, true_e);
    7089                 :   10379300 :                     if (false_e)
    7090                 :   10277600 :                       insert_related_predicates_on_edge (icode, ops, false_e);
    7091                 :            :                   }
    7092                 :            :               }
    7093                 :            :             break;
    7094                 :            :           }
    7095                 :       1238 :         case GIMPLE_GOTO:
    7096                 :       1238 :           e = find_taken_edge (bb, vn_valueize (gimple_goto_dest (last)));
    7097                 :       1238 :           break;
    7098                 :            :         default:
    7099                 :            :           e = NULL;
    7100                 :            :         }
    7101                 :  267143000 :       if (e)
    7102                 :            :         {
    7103                 :     931529 :           todo = TODO_cleanup_cfg;
    7104                 :     931529 :           if (!(e->flags & EDGE_EXECUTABLE))
    7105                 :            :             {
    7106                 :     848621 :               if (dump_file && (dump_flags & TDF_DETAILS))
    7107                 :         36 :                 fprintf (dump_file,
    7108                 :            :                          "marking known outgoing %sedge %d -> %d executable\n",
    7109                 :         36 :                          e->flags & EDGE_DFS_BACK ? "back-" : "",
    7110                 :         36 :                          e->src->index, e->dest->index);
    7111                 :     848621 :               e->flags |= EDGE_EXECUTABLE;
    7112                 :     848621 :               e->dest->flags |= BB_EXECUTABLE;
    7113                 :            :             }
    7114                 :      82908 :           else if (!(e->dest->flags & BB_EXECUTABLE))
    7115                 :            :             {
    7116                 :          0 :               if (dump_file && (dump_flags & TDF_DETAILS))
    7117                 :          0 :                 fprintf (dump_file,
    7118                 :            :                          "marking destination block %d reachable\n",
    7119                 :            :                          e->dest->index);
    7120                 :          0 :               e->dest->flags |= BB_EXECUTABLE;
    7121                 :            :             }
    7122                 :            :         }
    7123                 :  266212000 :       else if (gsi_one_before_end_p (gsi))
    7124                 :            :         {
    7125                 :   81477200 :           FOR_EACH_EDGE (e, ei, bb->succs)
    7126                 :            :             {
    7127                 :   48283400 :               if (!(e->flags & EDGE_EXECUTABLE))
    7128                 :            :                 {
    7129                 :   37377100 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    7130                 :        398 :                     fprintf (dump_file,
    7131                 :            :                              "marking outgoing edge %d -> %d executable\n",
    7132                 :        398 :                              e->src->index, e->dest->index);
    7133                 :   37377100 :                   e->flags |= EDGE_EXECUTABLE;
    7134                 :   37377100 :                   e->dest->flags |= BB_EXECUTABLE;
    7135                 :            :                 }
    7136                 :   10906300 :               else if (!(e->dest->flags & BB_EXECUTABLE))
    7137                 :            :                 {
    7138                 :      13526 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    7139                 :          0 :                     fprintf (dump_file,
    7140                 :            :                              "marking destination block %d reachable\n",
    7141                 :            :                              e->dest->index);
    7142                 :      13526 :                   e->dest->flags |= BB_EXECUTABLE;
    7143                 :            :                 }
    7144                 :            :             }
    7145                 :            :         }
    7146                 :            : 
    7147                 :            :       /* Eliminate.  That also pushes to avail.  */
    7148                 :  267143000 :       if (eliminate && ! iterate)
    7149                 :   60535100 :         avail.eliminate_stmt (bb, &gsi);
    7150                 :            :       else
    7151                 :            :         /* If not eliminating, make all not already available defs
    7152                 :            :            available.  */
    7153                 :  259596000 :         FOR_EACH_SSA_TREE_OPERAND (op, gsi_stmt (gsi), i, SSA_OP_DEF)
    7154                 :   52988000 :           if (! avail.eliminate_avail (bb, op))
    7155                 :   40879000 :             avail.eliminate_push_avail (bb, op);
    7156                 :            :     }
    7157                 :            : 
    7158                 :            :   /* Eliminate in destination PHI arguments.  Always substitute in dest
    7159                 :            :      PHIs, even for non-executable edges.  This handles region
    7160                 :            :      exits PHIs.  */
    7161                 :   38751200 :   if (!iterate && eliminate)
    7162                 :   18888900 :     FOR_EACH_EDGE (e, ei, bb->succs)
    7163                 :   11103500 :       for (gphi_iterator gsi = gsi_start_phis (e->dest);
    7164                 :   19950500 :            !gsi_end_p (gsi); gsi_next (&gsi))
    7165                 :            :         {
    7166                 :    8847040 :           gphi *phi = gsi.phi ();
    7167                 :    8847040 :           use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
    7168                 :    8847040 :           tree arg = USE_FROM_PTR (use_p);
    7169                 :   13953300 :           if (TREE_CODE (arg) != SSA_NAME
    7170                 :    8847040 :               || virtual_operand_p (arg))
    7171                 :    5106290 :             continue;
    7172                 :    3740750 :           tree sprime;
    7173                 :    3740750 :           if (SSA_NAME_IS_DEFAULT_DEF (arg))
    7174                 :            :             {
    7175                 :      48436 :               sprime = SSA_VAL (arg);
    7176                 :      48436 :               gcc_assert (TREE_CODE (sprime) != SSA_NAME
    7177                 :            :                           || SSA_NAME_IS_DEFAULT_DEF (sprime));
    7178                 :            :             }
    7179                 :            :           else
    7180                 :            :             /* Look for sth available at the definition block of the argument.
    7181                 :            :                This avoids inconsistencies between availability there which
    7182                 :            :                decides if the stmt can be removed and availability at the
    7183                 :            :                use site.  The SSA property ensures that things available
    7184                 :            :                at the definition are also available at uses.  */
    7185                 :    3692320 :             sprime = avail.eliminate_avail (gimple_bb (SSA_NAME_DEF_STMT (arg)),
    7186                 :    3692320 :                                             arg);
    7187                 :    3740750 :           if (sprime
    7188                 :    3740750 :               && sprime != arg
    7189                 :    3740750 :               && may_propagate_copy (arg, sprime))
    7190                 :     542998 :             propagate_value (use_p, sprime);
    7191                 :            :         }
    7192                 :            : 
    7193                 :   38751200 :   vn_context_bb = NULL;
    7194                 :   38751200 :   return todo;
    7195                 :            : }
    7196                 :            : 
    7197                 :            : /* Unwind state per basic-block.  */
    7198                 :            : 
    7199                 :            : struct unwind_state
    7200                 :            : {
    7201                 :            :   /* Times this block has been visited.  */
    7202                 :            :   unsigned visited;
    7203                 :            :   /* Whether to handle this as iteration point or whether to treat
    7204                 :            :      incoming backedge PHI values as varying.  */
    7205                 :            :   bool iterate;
    7206                 :            :   /* Maximum RPO index this block is reachable from.  */
    7207                 :            :   int max_rpo;
    7208                 :            :   /* Unwind state.  */
    7209                 :            :   void *ob_top;
    7210                 :            :   vn_reference_t ref_top;
    7211                 :            :   vn_phi_t phi_top;
    7212                 :            :   vn_nary_op_t nary_top;
    7213                 :            : };
    7214                 :            : 
    7215                 :            : /* Unwind the RPO VN state for iteration.  */
    7216                 :            : 
    7217                 :            : static void
    7218                 :    1098560 : do_unwind (unwind_state *to, int rpo_idx, rpo_elim &avail, int *bb_to_rpo)
    7219                 :            : {
    7220                 :    1098560 :   gcc_assert (to->iterate);
    7221                 :   23103200 :   for (; last_inserted_nary != to->nary_top;
    7222                 :   22004600 :        last_inserted_nary = last_inserted_nary->next)
    7223                 :            :     {
    7224                 :   22004600 :       vn_nary_op_t *slot;
    7225                 :   22004600 :       slot = valid_info->nary->find_slot_with_hash
    7226                 :   22004600 :         (last_inserted_nary, last_inserted_nary->hashcode, NO_INSERT);
    7227                 :            :       /* Predication causes the need to restore previous state.  */
    7228                 :   22004600 :       if ((*slot)->unwind_to)
    7229                 :    4433900 :         *slot = (*slot)->unwind_to;
    7230                 :            :       else
    7231                 :   17570700 :         valid_info->nary->clear_slot (slot);
    7232                 :            :     }
    7233                 :    4688010 :   for (; last_inserted_phi != to->phi_top;
    7234                 :    3589450 :        last_inserted_phi = last_inserted_phi->next)
    7235                 :            :     {
    7236                 :    3589450 :       vn_phi_t *slot;
    7237                 :    3589450 :       slot = valid_info->phis->find_slot_with_hash
    7238                 :    3589450 :         (last_inserted_phi, last_inserted_phi->hashcode, NO_INSERT);
    7239                 :    3589450 :       valid_info->phis->clear_slot (slot);
    7240                 :            :     }
    7241                 :    9033520 :   for (; last_inserted_ref != to->ref_top;
    7242                 :    7934960 :        last_inserted_ref = last_inserted_ref->next)
    7243                 :            :     {
    7244                 :    7934960 :       vn_reference_t *slot;
    7245                 :    7934960 :       slot = valid_info->references->find_slot_with_hash
    7246                 :    7934960 :         (last_inserted_ref, last_inserted_ref->hashcode, NO_INSERT);
    7247                 :    7934960 :       (*slot)->operands.release ();
    7248                 :    7934960 :       valid_info->references->clear_slot (slot);
    7249                 :            :     }
    7250                 :    1098560 :   obstack_free (&vn_tables_obstack, to->ob_top);
    7251                 :            : 
    7252                 :            :   /* Prune [rpo_idx, ] from avail.  */
    7253                 :            :   /* ???  This is O(number-of-values-in-region) which is
    7254                 :            :      O(region-size) rather than O(iteration-piece).  */
    7255                 :  214725000 :   for (hash_table<vn_ssa_aux_hasher>::iterator i = vn_ssa_aux_hash->begin ();
    7256                 :  214725000 :        i != vn_ssa_aux_hash->end (); ++i)
    7257                 :            :     {
    7258                 :  226836000 :       while ((*i)->avail)
    7259                 :            :         {
    7260                 :  107490000 :           if (bb_to_rpo[(*i)->avail->location] < rpo_idx)
    7261                 :            :             break;
    7262                 :   13209800 :           vn_avail *av = (*i)->avail;
    7263                 :   13209800 :           (*i)->avail = (*i)->avail->next;
    7264                 :   13209800 :           av->next = avail.m_avail_freelist;
    7265                 :   13209800 :           avail.m_avail_freelist = av;
    7266                 :            :         }
    7267                 :            :     }
    7268                 :    1098560 : }
    7269                 :            : 
    7270                 :            : /* Do VN on a SEME region specified by ENTRY and EXIT_BBS in FN.
    7271                 :            :    If ITERATE is true then treat backedges optimistically as not
    7272                 :            :    executed and iterate.  If ELIMINATE is true then perform
    7273                 :            :    elimination, otherwise leave that to the caller.  */
    7274                 :            : 
    7275                 :            : static unsigned
    7276                 :    3767280 : do_rpo_vn (function *fn, edge entry, bitmap exit_bbs,
    7277                 :            :            bool iterate, bool eliminate)
    7278                 :            : {
    7279                 :    3767280 :   unsigned todo = 0;
    7280                 :            : 
    7281                 :            :   /* We currently do not support region-based iteration when
    7282                 :            :      elimination is requested.  */
    7283                 :    3767280 :   gcc_assert (!entry || !iterate || !eliminate);
    7284                 :            :   /* When iterating we need loop info up-to-date.  */
    7285                 :    3767280 :   gcc_assert (!iterate || !loops_state_satisfies_p (LOOPS_NEED_FIXUP));
    7286                 :            : 
    7287                 :    3767280 :   bool do_region = entry != NULL;
    7288                 :    3767280 :   if (!do_region)
    7289                 :            :     {
    7290                 :    3568540 :       entry = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (fn));
    7291                 :    3568540 :       exit_bbs = BITMAP_ALLOC (NULL);
    7292                 :    3568540 :       bitmap_set_bit (exit_bbs, EXIT_BLOCK);
    7293                 :            :     }
    7294                 :            : 
    7295                 :            :   /* Clear EDGE_DFS_BACK on "all" entry edges, RPO order compute will
    7296                 :            :      re-mark those that are contained in the region.  */
    7297                 :    3767280 :   edge_iterator ei;
    7298                 :    3767280 :   edge e;
    7299                 :    7560780 :   FOR_EACH_EDGE (e, ei, entry->dest->preds)
    7300                 :    3793510 :     e->flags &= ~EDGE_DFS_BACK;
    7301                 :            : 
    7302                 :    3767280 :   int *rpo = XNEWVEC (int, n_basic_blocks_for_fn (fn) - NUM_FIXED_BLOCKS);
    7303                 :    3767280 :   int n = rev_post_order_and_mark_dfs_back_seme
    7304                 :    3767280 :     (fn, entry, exit_bbs, !loops_state_satisfies_p (LOOPS_NEED_FIXUP), rpo);
    7305                 :            :   /* rev_post_order_and_mark_dfs_back_seme fills RPO in reverse order.  */
    7306                 :   17974400 :   for (int i = 0; i < n / 2; ++i)
    7307                 :   14207100 :     std::swap (rpo[i], rpo[n-i-1]);
    7308                 :            : 
    7309                 :    3767280 :   if (!do_region)
    7310                 :    3568540 :     BITMAP_FREE (exit_bbs);
    7311                 :            : 
    7312                 :            :   /* If there are any non-DFS_BACK edges into entry->dest skip
    7313                 :            :      processing PHI nodes for that block.  This supports
    7314                 :            :      value-numbering loop bodies w/o the actual loop.  */
    7315                 :    7554530 :   FOR_EACH_EDGE (e, ei, entry->dest->preds)
    7316                 :    3790430 :     if (e != entry
    7317                 :      26230 :         && !(e->flags & EDGE_DFS_BACK))
    7318                 :            :       break;
    7319                 :    3767280 :   bool skip_entry_phis = e != NULL;
    7320                 :    3767280 :   if (skip_entry_phis && dump_file && (dump_flags & TDF_DETAILS))
    7321                 :         14 :     fprintf (dump_file, "Region does not contain all edges into "
    7322                 :            :              "the entry block, skipping its PHIs.\n");
    7323                 :            : 
    7324                 :    3767280 :   int *bb_to_rpo = XNEWVEC (int, last_basic_block_for_fn (fn));
    7325                 :   35035300 :   for (int i = 0; i < n; ++i)
    7326                 :   31268000 :     bb_to_rpo[rpo[i]] = i;
    7327                 :            : 
    7328                 :    3767280 :   unwind_state *rpo_state = XNEWVEC (unwind_state, n);
    7329                 :            : 
    7330                 :    3767280 :   rpo_elim avail (entry->dest);
    7331                 :    3767280 :   rpo_avail = &avail;
    7332                 :            : 
    7333                 :            :   /* Verify we have no extra entries into the region.  */
    7334                 :    3767280 :   if (flag_checking && do_region)
    7335                 :            :     {
    7336                 :     397456 :       auto_bb_flag bb_in_region (fn);
    7337                 :     863228 :       for (int i = 0; i < n; ++i)
    7338                 :            :         {
    7339                 :     664500 :           basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
    7340                 :     664500 :           bb->flags |= bb_in_region;
    7341                 :            :         }
    7342                 :            :       /* We can't merge the first two loops because we cannot rely
    7343                 :            :          on EDGE_DFS_BACK for edges not within the region.  But if
    7344                 :            :          we decide to always have the bb_in_region flag we can
    7345                 :            :          do the checking during the RPO walk itself (but then it's
    7346                 :            :          also easy to handle MEME conservatively).  */
    7347                 :     863228 :       for (int i = 0; i < n; ++i)
    7348                 :            :         {
    7349                 :     664500 :           basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
    7350                 :     664500 :           edge e;
    7351                 :     664500 :           edge_iterator ei;
    7352                 :    1406460 :           FOR_EACH_EDGE (e, ei, bb->preds)
    7353                 :     741965 :             gcc_assert (e == entry
    7354                 :            :                         || (skip_entry_phis && bb == entry->dest)
    7355                 :            :                         || (e->src->flags & bb_in_region));
    7356                 :            :         }
    7357                 :     863228 :       for (int i = 0; i < n; ++i)
    7358                 :            :         {
    7359                 :     664500 :           basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
    7360                 :     664500 :           bb->flags &= ~bb_in_region;
    7361                 :            :         }
    7362                 :            :     }
    7363                 :            : 
    7364                 :            :   /* Create the VN state.  For the initial size of the various hashtables
    7365                 :            :      use a heuristic based on region size and number of SSA names.  */
    7366                 :    3767280 :   unsigned region_size = (((unsigned HOST_WIDE_INT)n * num_ssa_names)
    7367                 :    3767280 :                           / (n_basic_blocks_for_fn (fn) - NUM_FIXED_BLOCKS));
    7368                 :    3767280 :   VN_TOP = create_tmp_var_raw (void_type_node, "vn_top");
    7369                 :    3767280 :   next_value_id = 1;
    7370                 :            : 
    7371                 :    3767280 :   vn_ssa_aux_hash = new hash_table <vn_ssa_aux_hasher> (region_size * 2);
    7372                 :    3767280 :   gcc_obstack_init (&vn_ssa_aux_obstack);
    7373                 :            : 
    7374                 :    3767280 :   gcc_obstack_init (&vn_tables_obstack);
    7375                 :    3767280 :   gcc_obstack_init (&vn_tables_insert_obstack);
    7376                 :    3767280 :   valid_info = XCNEW (struct vn_tables_s);
    7377                 :    3767280 :   allocate_vn_table (valid_info, region_size);
    7378                 :    3767280 :   last_inserted_ref = NULL;
    7379                 :    3767280 :   last_inserted_phi = NULL;
    7380                 :    3767280 :   last_inserted_nary = NULL;
    7381                 :            : 
    7382                 :    3767280 :   vn_valueize = rpo_vn_valueize;
    7383                 :            : 
    7384                 :            :   /* Initialize the unwind state and edge/BB executable state.  */
    7385                 :    3767280 :   bool need_max_rpo_iterate = false;
    7386                 :   35035300 :   for (int i = 0; i < n; ++i)
    7387                 :            :     {
    7388                 :   31268000 :       basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
    7389                 :   31268000 :       rpo_state[i].visited = 0;
    7390                 :   31268000 :       rpo_state[i].max_rpo = i;
    7391                 :   31268000 :       bb->flags &= ~BB_EXECUTABLE;
    7392                 :   31268000 :       bool has_backedges = false;
    7393                 :   31268000 :       edge e;
    7394                 :   31268000 :       edge_iterator ei;
    7395                 :   74205100 :       FOR_EACH_EDGE (e, ei, bb->preds)
    7396                 :            :         {
    7397                 :   42937100 :           if (e->flags & EDGE_DFS_BACK)
    7398                 :    1521790 :             has_backedges = true;
    7399                 :   42937100 :           e->flags &= ~EDGE_EXECUTABLE;
    7400                 :   42937100 :           if (iterate || e == entry || (skip_entry_phis && bb == entry->dest))
    7401                 :   32972400 :             continue;
    7402                 :    9964630 :           if (bb_to_rpo[e->src->index] > i)
    7403                 :            :             {
    7404                 :     338868 :               rpo_state[i].max_rpo = MAX (rpo_state[i].max_rpo,
    7405                 :            :                                           bb_to_rpo[e->src->index]);
    7406                 :     338868 :               need_max_rpo_iterate = true;
    7407                 :            :             }
    7408                 :            :           else
    7409                 :    9625760 :             rpo_state[i].max_rpo
    7410                 :    9625760 :               = MAX (rpo_state[i].max_rpo,
    7411                 :            :                      rpo_state[bb_to_rpo[e->src->index]].max_rpo);
    7412                 :            :         }
    7413                 :   31268000 :       rpo_state[i].iterate = iterate && has_backedges;
    7414                 :            :     }
    7415                 :    3767280 :   entry->flags |= EDGE_EXECUTABLE;
    7416                 :    3767280 :   entry->dest->flags |= BB_EXECUTABLE;
    7417                 :            : 
    7418                 :            :   /* When there are irreducible regions the simplistic max_rpo computation
    7419                 :            :      above for the case of backedges doesn't work and we need to iterate
    7420                 :            :      until there are no more changes.  */
    7421                 :    3767280 :   unsigned nit = 0;
    7422                 :    3898810 :   while (need_max_rpo_iterate)
    7423                 :            :     {
    7424                 :     131535 :       nit++;
    7425                 :     131535 :       need_max_rpo_iterate = false;
    7426                 :    4378170 :       for (int i = 0; i < n; ++i)
    7427                 :            :         {
    7428                 :    4246640 :           basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[i]);
    7429                 :    4246640 :           edge e;
    7430                 :    4246640 :           edge_iterator ei;
    7431                 :   10422700 :           FOR_EACH_EDGE (e, ei, bb->preds)
    7432                 :            :             {
    7433                 :    6176050 :               if (e == entry || (skip_entry_phis && bb == entry->dest))
    7434                 :     131535 :                 continue;
    7435                 :    6044520 :               int max_rpo = MAX (rpo_state[i].max_rpo,
    7436                 :            :                                  rpo_state[bb_to_rpo[e->src->index]].max_rpo);
    7437                 :    6044520 :               if (rpo_state[i].max_rpo != max_rpo)
    7438                 :            :                 {
    7439                 :       7531 :                   rpo_state[i].max_rpo = max_rpo;
    7440                 :       7531 :                   need_max_rpo_iterate = true;
    7441                 :            :                 }
    7442                 :            :             }
    7443                 :            :         }
    7444                 :            :     }
    7445                 :    3767280 :   statistics_histogram_event (cfun, "RPO max_rpo iterations", nit);
    7446                 :            : 
    7447                 :            :   /* As heuristic to improve compile-time we handle only the N innermost
    7448                 :            :      loops and the outermost one optimistically.  */
    7449                 :    3767280 :   if (iterate)
    7450                 :            :     {
    7451                 :    2824200 :       loop_p loop;
    7452                 :    2824200 :       unsigned max_depth = param_rpo_vn_max_loop_depth;
    7453                 :    6525970 :       FOR_EACH_LOOP (loop, LI_ONLY_INNERMOST)
    7454                 :    1755130 :         if (loop_depth (loop) > max_depth)
    7455                 :       1015 :           for (unsigned i = 2;
    7456                 :       5480 :                i < loop_depth (loop) - max_depth; ++i)
    7457                 :            :             {
    7458                 :       1015 :               basic_block header = superloop_at_depth (loop, i)->header;
    7459                 :       1015 :               bool non_latch_backedge = false;
    7460                 :       1015 :               edge e;
    7461                 :       1015 :               edge_iterator ei;
    7462                 :       3078 :               FOR_EACH_EDGE (e, ei, header->preds)
    7463                 :       2063 :                 if (e->flags & EDGE_DFS_BACK)
    7464                 :            :                   {
    7465                 :            :                     /* There can be a non-latch backedge into the header
    7466                 :            :                        which is part of an outer irreducible region.  We
    7467                 :            :                        cannot avoid iterating this block then.  */
    7468                 :       1048 :                     if (!dominated_by_p (CDI_DOMINATORS,
    7469                 :       1048 :                                          e->src, e->dest))
    7470                 :            :                       {
    7471                 :         12 :                         if (dump_file && (dump_flags & TDF_DETAILS))
    7472                 :          0 :                           fprintf (dump_file, "non-latch backedge %d -> %d "
    7473                 :            :                                    "forces iteration of loop %d\n",
    7474                 :          0 :                                    e->src->index, e->dest->index, loop->num);
    7475                 :            :                         non_latch_backedge = true;
    7476                 :            :                       }
    7477                 :            :                     else
    7478                 :       1036 :                       e->flags |= EDGE_EXECUTABLE;
    7479                 :            :                   }
    7480                 :       1015 :               rpo_state[bb_to_rpo[header->index]].iterate = non_latch_backedge;
    7481                 :            :             }
    7482                 :            :     }
    7483                 :            : 
    7484                 :    3767280 :   uint64_t nblk = 0;
    7485                 :    3767280 :   int idx = 0;
    7486                 :    3767280 :   if (iterate)
    7487                 :            :     /* Go and process all blocks, iterating as necessary.  */
    7488                 :   31550300 :     do
    7489                 :            :       {
    7490                 :   31550300 :         basic_block bb = BASIC_BLOCK_FOR_FN (fn, rpo[idx]);
    7491                 :            : 
    7492                 :            :         /* If the block has incoming backedges remember unwind state.  This
    7493                 :            :            is required even for non-executable blocks since in irreducible
    7494                 :            :            regions we might reach them via the backedge and re-start iterating
    7495                 :            :            from there.
    7496                 :            :            Note we can individually mark blocks with incoming backedges to
    7497                 :            :            not iterate where we then handle PHIs conservatively.  We do that
    7498                 :            :            heuristically to reduce compile-time for degenerate cases.  */
    7499                 :   31550300 :         if (rpo_state[idx].iterate)
    7500                 :            :           {
    7501                 :    2601160 :             rpo_state[idx].ob_top = obstack_alloc (&vn_tables_obstack, 0);
    7502                 :    2601160 :             rpo_state[idx].ref_top = last_inserted_ref;
    7503                 :    2601160 :             rpo_state[idx].phi_top = last_inserted_phi;
    7504                 :    2601160 :             rpo_state[idx].nary_top = last_inserted_nary;
    7505                 :            :           }
    7506                 :            : 
    7507                 :   31550300 :         if (!(bb->flags & BB_EXECUTABLE