LCOV - code coverage report
Current view: top level - gcc - tree-ssa-forwprop.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1544 1638 94.3 %
Date: 2020-03-28 11:57:23 Functions: 34 34 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Forward propagation of expressions for single use variables.
       2                 :            :    Copyright (C) 2004-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "rtl.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "gimple.h"
      27                 :            : #include "cfghooks.h"
      28                 :            : #include "tree-pass.h"
      29                 :            : #include "ssa.h"
      30                 :            : #include "expmed.h"
      31                 :            : #include "optabs-query.h"
      32                 :            : #include "gimple-pretty-print.h"
      33                 :            : #include "fold-const.h"
      34                 :            : #include "stor-layout.h"
      35                 :            : #include "gimple-fold.h"
      36                 :            : #include "tree-eh.h"
      37                 :            : #include "gimplify.h"
      38                 :            : #include "gimple-iterator.h"
      39                 :            : #include "gimplify-me.h"
      40                 :            : #include "tree-cfg.h"
      41                 :            : #include "expr.h"
      42                 :            : #include "tree-dfa.h"
      43                 :            : #include "tree-ssa-propagate.h"
      44                 :            : #include "tree-ssa-dom.h"
      45                 :            : #include "builtins.h"
      46                 :            : #include "tree-cfgcleanup.h"
      47                 :            : #include "cfganal.h"
      48                 :            : #include "optabs-tree.h"
      49                 :            : #include "tree-vector-builder.h"
      50                 :            : #include "vec-perm-indices.h"
      51                 :            : #include "internal-fn.h"
      52                 :            : #include "cgraph.h"
      53                 :            : #include "tree-ssa.h"
      54                 :            : 
      55                 :            : /* This pass propagates the RHS of assignment statements into use
      56                 :            :    sites of the LHS of the assignment.  It's basically a specialized
      57                 :            :    form of tree combination.   It is hoped all of this can disappear
      58                 :            :    when we have a generalized tree combiner.
      59                 :            : 
      60                 :            :    One class of common cases we handle is forward propagating a single use
      61                 :            :    variable into a COND_EXPR.
      62                 :            : 
      63                 :            :      bb0:
      64                 :            :        x = a COND b;
      65                 :            :        if (x) goto ... else goto ...
      66                 :            : 
      67                 :            :    Will be transformed into:
      68                 :            : 
      69                 :            :      bb0:
      70                 :            :        if (a COND b) goto ... else goto ...
      71                 :            : 
      72                 :            :    Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
      73                 :            : 
      74                 :            :    Or (assuming c1 and c2 are constants):
      75                 :            : 
      76                 :            :      bb0:
      77                 :            :        x = a + c1;
      78                 :            :        if (x EQ/NEQ c2) goto ... else goto ...
      79                 :            : 
      80                 :            :    Will be transformed into:
      81                 :            : 
      82                 :            :      bb0:
      83                 :            :         if (a EQ/NEQ (c2 - c1)) goto ... else goto ...
      84                 :            : 
      85                 :            :    Similarly for x = a - c1.
      86                 :            : 
      87                 :            :    Or
      88                 :            : 
      89                 :            :      bb0:
      90                 :            :        x = !a
      91                 :            :        if (x) goto ... else goto ...
      92                 :            : 
      93                 :            :    Will be transformed into:
      94                 :            : 
      95                 :            :      bb0:
      96                 :            :         if (a == 0) goto ... else goto ...
      97                 :            : 
      98                 :            :    Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
      99                 :            :    For these cases, we propagate A into all, possibly more than one,
     100                 :            :    COND_EXPRs that use X.
     101                 :            : 
     102                 :            :    Or
     103                 :            : 
     104                 :            :      bb0:
     105                 :            :        x = (typecast) a
     106                 :            :        if (x) goto ... else goto ...
     107                 :            : 
     108                 :            :    Will be transformed into:
     109                 :            : 
     110                 :            :      bb0:
     111                 :            :         if (a != 0) goto ... else goto ...
     112                 :            : 
     113                 :            :    (Assuming a is an integral type and x is a boolean or x is an
     114                 :            :     integral and a is a boolean.)
     115                 :            : 
     116                 :            :    Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
     117                 :            :    For these cases, we propagate A into all, possibly more than one,
     118                 :            :    COND_EXPRs that use X.
     119                 :            : 
     120                 :            :    In addition to eliminating the variable and the statement which assigns
     121                 :            :    a value to the variable, we may be able to later thread the jump without
     122                 :            :    adding insane complexity in the dominator optimizer.
     123                 :            : 
     124                 :            :    Also note these transformations can cascade.  We handle this by having
     125                 :            :    a worklist of COND_EXPR statements to examine.  As we make a change to
     126                 :            :    a statement, we put it back on the worklist to examine on the next
     127                 :            :    iteration of the main loop.
     128                 :            : 
     129                 :            :    A second class of propagation opportunities arises for ADDR_EXPR
     130                 :            :    nodes.
     131                 :            : 
     132                 :            :      ptr = &x->y->z;
     133                 :            :      res = *ptr;
     134                 :            : 
     135                 :            :    Will get turned into
     136                 :            : 
     137                 :            :      res = x->y->z;
     138                 :            : 
     139                 :            :    Or
     140                 :            :      ptr = (type1*)&type2var;
     141                 :            :      res = *ptr
     142                 :            : 
     143                 :            :    Will get turned into (if type1 and type2 are the same size
     144                 :            :    and neither have volatile on them):
     145                 :            :      res = VIEW_CONVERT_EXPR<type1>(type2var)
     146                 :            : 
     147                 :            :    Or
     148                 :            : 
     149                 :            :      ptr = &x[0];
     150                 :            :      ptr2 = ptr + <constant>;
     151                 :            : 
     152                 :            :    Will get turned into
     153                 :            : 
     154                 :            :      ptr2 = &x[constant/elementsize];
     155                 :            : 
     156                 :            :   Or
     157                 :            : 
     158                 :            :      ptr = &x[0];
     159                 :            :      offset = index * element_size;
     160                 :            :      offset_p = (pointer) offset;
     161                 :            :      ptr2 = ptr + offset_p
     162                 :            : 
     163                 :            :   Will get turned into:
     164                 :            : 
     165                 :            :      ptr2 = &x[index];
     166                 :            : 
     167                 :            :   Or
     168                 :            :     ssa = (int) decl
     169                 :            :     res = ssa & 1
     170                 :            : 
     171                 :            :   Provided that decl has known alignment >= 2, will get turned into
     172                 :            : 
     173                 :            :     res = 0
     174                 :            : 
     175                 :            :   We also propagate casts into SWITCH_EXPR and COND_EXPR conditions to
     176                 :            :   allow us to remove the cast and {NOT_EXPR,NEG_EXPR} into a subsequent
     177                 :            :   {NOT_EXPR,NEG_EXPR}.
     178                 :            : 
     179                 :            :    This will (of course) be extended as other needs arise.  */
     180                 :            : 
     181                 :            : static bool forward_propagate_addr_expr (tree, tree, bool);
     182                 :            : 
     183                 :            : /* Set to true if we delete dead edges during the optimization.  */
     184                 :            : static bool cfg_changed;
     185                 :            : 
     186                 :            : static tree rhs_to_tree (tree type, gimple *stmt);
     187                 :            : 
     188                 :            : static bitmap to_purge;
     189                 :            : 
     190                 :            : /* Const-and-copy lattice.  */
     191                 :            : static vec<tree> lattice;
     192                 :            : 
     193                 :            : /* Set the lattice entry for NAME to VAL.  */
     194                 :            : static void
     195                 :   20557800 : fwprop_set_lattice_val (tree name, tree val)
     196                 :            : {
     197                 :   20557800 :   if (TREE_CODE (name) == SSA_NAME)
     198                 :            :     {
     199                 :   41115500 :       if (SSA_NAME_VERSION (name) >= lattice.length ())
     200                 :            :         {
     201                 :        228 :           lattice.reserve (num_ssa_names - lattice.length ());
     202                 :        228 :           lattice.quick_grow_cleared (num_ssa_names);
     203                 :            :         }
     204                 :   20557800 :       lattice[SSA_NAME_VERSION (name)] = val;
     205                 :            :     }
     206                 :   20557800 : }
     207                 :            : 
     208                 :            : /* Invalidate the lattice entry for NAME, done when releasing SSA names.  */
     209                 :            : static void
     210                 :     764206 : fwprop_invalidate_lattice (tree name)
     211                 :            : {
     212                 :     764206 :   if (name
     213                 :     762092 :       && TREE_CODE (name) == SSA_NAME
     214                 :    2288150 :       && SSA_NAME_VERSION (name) < lattice.length ())
     215                 :     761640 :     lattice[SSA_NAME_VERSION (name)] = NULL_TREE;
     216                 :     764206 : }
     217                 :            : 
     218                 :            : 
     219                 :            : /* Get the statement we can propagate from into NAME skipping
     220                 :            :    trivial copies.  Returns the statement which defines the
     221                 :            :    propagation source or NULL_TREE if there is no such one.
     222                 :            :    If SINGLE_USE_ONLY is set considers only sources which have
     223                 :            :    a single use chain up to NAME.  If SINGLE_USE_P is non-null,
     224                 :            :    it is set to whether the chain to NAME is a single use chain
     225                 :            :    or not.  SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set.  */
     226                 :            : 
     227                 :            : static gimple *
     228                 :   16563300 : get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
     229                 :            : {
     230                 :   16563300 :   bool single_use = true;
     231                 :            : 
     232                 :   16564100 :   do {
     233                 :   16563700 :     gimple *def_stmt = SSA_NAME_DEF_STMT (name);
     234                 :            : 
     235                 :   16563700 :     if (!has_single_use (name))
     236                 :            :       {
     237                 :    8261880 :         single_use = false;
     238                 :    8261880 :         if (single_use_only)
     239                 :            :           return NULL;
     240                 :            :       }
     241                 :            : 
     242                 :            :     /* If name is defined by a PHI node or is the default def, bail out.  */
     243                 :   16562200 :     if (!is_gimple_assign (def_stmt))
     244                 :            :       return NULL;
     245                 :            : 
     246                 :            :     /* If def_stmt is a simple copy, continue looking.  */
     247                 :   11917000 :     if (gimple_assign_rhs_code (def_stmt) == SSA_NAME)
     248                 :        409 :       name = gimple_assign_rhs1 (def_stmt);
     249                 :            :     else
     250                 :            :       {
     251                 :   11916600 :         if (!single_use_only && single_use_p)
     252                 :   11813800 :           *single_use_p = single_use;
     253                 :            : 
     254                 :   11916600 :         return def_stmt;
     255                 :        409 :       }
     256                 :            :   } while (1);
     257                 :            : }
     258                 :            : 
     259                 :            : /* Checks if the destination ssa name in DEF_STMT can be used as
     260                 :            :    propagation source.  Returns true if so, otherwise false.  */
     261                 :            : 
     262                 :            : static bool
     263                 :   16668100 : can_propagate_from (gimple *def_stmt)
     264                 :            : {
     265                 :   16668100 :   gcc_assert (is_gimple_assign (def_stmt));
     266                 :            : 
     267                 :            :   /* If the rhs has side-effects we cannot propagate from it.  */
     268                 :   16668100 :   if (gimple_has_volatile_ops (def_stmt))
     269                 :            :     return false;
     270                 :            : 
     271                 :            :   /* If the rhs is a load we cannot propagate from it.  */
     272                 :   16132800 :   if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_reference
     273                 :   16132800 :       || TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_declaration)
     274                 :            :     return false;
     275                 :            : 
     276                 :            :   /* Constants can be always propagated.  */
     277                 :    8088710 :   if (gimple_assign_single_p (def_stmt)
     278                 :     115310 :       && is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
     279                 :            :     return true;
     280                 :            : 
     281                 :            :   /* We cannot propagate ssa names that occur in abnormal phi nodes.  */
     282                 :    8088710 :   if (stmt_references_abnormal_ssa_name (def_stmt))
     283                 :            :     return false;
     284                 :            : 
     285                 :            :   /* If the definition is a conversion of a pointer to a function type,
     286                 :            :      then we cannot apply optimizations as some targets require
     287                 :            :      function pointers to be canonicalized and in this case this
     288                 :            :      optimization could eliminate a necessary canonicalization.  */
     289                 :    8088280 :   if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
     290                 :            :     {
     291                 :    1935000 :       tree rhs = gimple_assign_rhs1 (def_stmt);
     292                 :    3689450 :       if (POINTER_TYPE_P (TREE_TYPE (rhs))
     293                 :    1935590 :           && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs))) == FUNCTION_TYPE)
     294                 :        458 :         return false;
     295                 :            :     }
     296                 :            : 
     297                 :            :   return true;
     298                 :            : }
     299                 :            : 
     300                 :            : /* Remove a chain of dead statements starting at the definition of
     301                 :            :    NAME.  The chain is linked via the first operand of the defining statements.
     302                 :            :    If NAME was replaced in its only use then this function can be used
     303                 :            :    to clean up dead stmts.  The function handles already released SSA
     304                 :            :    names gracefully.
     305                 :            :    Returns true if cleanup-cfg has to run.  */
     306                 :            : 
     307                 :            : static bool
     308                 :     472551 : remove_prop_source_from_use (tree name)
     309                 :            : {
     310                 :     472551 :   gimple_stmt_iterator gsi;
     311                 :     472551 :   gimple *stmt;
     312                 :     472551 :   bool cfg_changed = false;
     313                 :            : 
     314                 :     778110 :   do {
     315                 :     778110 :     basic_block bb;
     316                 :            : 
     317                 :     778110 :     if (SSA_NAME_IN_FREE_LIST (name)
     318                 :     778110 :         || SSA_NAME_IS_DEFAULT_DEF (name)
     319                 :    1535610 :         || !has_zero_uses (name))
     320                 :            :       return cfg_changed;
     321                 :            : 
     322                 :     307215 :     stmt = SSA_NAME_DEF_STMT (name);
     323                 :     307215 :     if (gimple_code (stmt) == GIMPLE_PHI
     324                 :     307215 :         || gimple_has_side_effects (stmt))
     325                 :          0 :       return cfg_changed;
     326                 :            : 
     327                 :     307215 :     bb = gimple_bb (stmt);
     328                 :     307215 :     gsi = gsi_for_stmt (stmt);
     329                 :     307215 :     unlink_stmt_vdef (stmt);
     330                 :     307215 :     if (gsi_remove (&gsi, true))
     331                 :          6 :       bitmap_set_bit (to_purge, bb->index);
     332                 :     307215 :     fwprop_invalidate_lattice (gimple_get_lhs (stmt));
     333                 :     307215 :     release_defs (stmt);
     334                 :            : 
     335                 :     307215 :     name = is_gimple_assign (stmt) ? gimple_assign_rhs1 (stmt) : NULL_TREE;
     336                 :     307215 :   } while (name && TREE_CODE (name) == SSA_NAME);
     337                 :            : 
     338                 :            :   return cfg_changed;
     339                 :            : }
     340                 :            : 
     341                 :            : /* Return the rhs of a gassign *STMT in a form of a single tree,
     342                 :            :    converted to type TYPE.
     343                 :            : 
     344                 :            :    This should disappear, but is needed so we can combine expressions and use
     345                 :            :    the fold() interfaces. Long term, we need to develop folding and combine
     346                 :            :    routines that deal with gimple exclusively . */
     347                 :            : 
     348                 :            : static tree
     349                 :    4476250 : rhs_to_tree (tree type, gimple *stmt)
     350                 :            : {
     351                 :    4476250 :   location_t loc = gimple_location (stmt);
     352                 :    4476250 :   enum tree_code code = gimple_assign_rhs_code (stmt);
     353                 :    4476250 :   switch (get_gimple_rhs_class (code))
     354                 :            :     {
     355                 :       2394 :     case GIMPLE_TERNARY_RHS:
     356                 :       2394 :       return fold_build3_loc (loc, code, type, gimple_assign_rhs1 (stmt),
     357                 :            :                               gimple_assign_rhs2 (stmt),
     358                 :       2394 :                               gimple_assign_rhs3 (stmt));
     359                 :    3159400 :     case GIMPLE_BINARY_RHS:
     360                 :    3159400 :       return fold_build2_loc (loc, code, type, gimple_assign_rhs1 (stmt),
     361                 :    3159400 :                               gimple_assign_rhs2 (stmt));
     362                 :    1199720 :     case GIMPLE_UNARY_RHS:
     363                 :    1199720 :       return build1 (code, type, gimple_assign_rhs1 (stmt));
     364                 :     114747 :     case GIMPLE_SINGLE_RHS:
     365                 :     114747 :       return gimple_assign_rhs1 (stmt);
     366                 :          0 :     default:
     367                 :          0 :       gcc_unreachable ();
     368                 :            :     }
     369                 :            : }
     370                 :            : 
     371                 :            : /* Combine OP0 CODE OP1 in the context of a COND_EXPR.  Returns
     372                 :            :    the folded result in a form suitable for COND_EXPR_COND or
     373                 :            :    NULL_TREE, if there is no suitable simplified form.  If
     374                 :            :    INVARIANT_ONLY is true only gimple_min_invariant results are
     375                 :            :    considered simplified.  */
     376                 :            : 
     377                 :            : static tree
     378                 :    4990480 : combine_cond_expr_cond (gimple *stmt, enum tree_code code, tree type,
     379                 :            :                         tree op0, tree op1, bool invariant_only)
     380                 :            : {
     381                 :    4990480 :   tree t;
     382                 :            : 
     383                 :    4990480 :   gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
     384                 :            : 
     385                 :    4990480 :   fold_defer_overflow_warnings ();
     386                 :    4990480 :   t = fold_binary_loc (gimple_location (stmt), code, type, op0, op1);
     387                 :    4990480 :   if (!t)
     388                 :            :     {
     389                 :    2489320 :       fold_undefer_overflow_warnings (false, NULL, 0);
     390                 :    2489320 :       return NULL_TREE;
     391                 :            :     }
     392                 :            : 
     393                 :            :   /* Require that we got a boolean type out if we put one in.  */
     394                 :    2501160 :   gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type));
     395                 :            : 
     396                 :            :   /* Canonicalize the combined condition for use in a COND_EXPR.  */
     397                 :    2501160 :   t = canonicalize_cond_expr_cond (t);
     398                 :            : 
     399                 :            :   /* Bail out if we required an invariant but didn't get one.  */
     400                 :    2501160 :   if (!t || (invariant_only && !is_gimple_min_invariant (t)))
     401                 :            :     {
     402                 :    2029420 :       fold_undefer_overflow_warnings (false, NULL, 0);
     403                 :    2029420 :       return NULL_TREE;
     404                 :            :     }
     405                 :            : 
     406                 :     471745 :   fold_undefer_overflow_warnings (!gimple_no_warning_p (stmt), stmt, 0);
     407                 :            : 
     408                 :     471745 :   return t;
     409                 :            : }
     410                 :            : 
     411                 :            : /* Combine the comparison OP0 CODE OP1 at LOC with the defining statements
     412                 :            :    of its operand.  Return a new comparison tree or NULL_TREE if there
     413                 :            :    were no simplifying combines.  */
     414                 :            : 
     415                 :            : static tree
     416                 :   13256100 : forward_propagate_into_comparison_1 (gimple *stmt,
     417                 :            :                                      enum tree_code code, tree type,
     418                 :            :                                      tree op0, tree op1)
     419                 :            : {
     420                 :   13256100 :   tree tmp = NULL_TREE;
     421                 :   13256100 :   tree rhs0 = NULL_TREE, rhs1 = NULL_TREE;
     422                 :   13256100 :   bool single_use0_p = false, single_use1_p = false;
     423                 :            : 
     424                 :            :   /* For comparisons use the first operand, that is likely to
     425                 :            :      simplify comparisons against constants.  */
     426                 :   13256100 :   if (TREE_CODE (op0) == SSA_NAME)
     427                 :            :     {
     428                 :   13071700 :       gimple *def_stmt = get_prop_source_stmt (op0, false, &single_use0_p);
     429                 :   13071700 :       if (def_stmt && can_propagate_from (def_stmt))
     430                 :            :         {
     431                 :    3434540 :           enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
     432                 :    3434540 :           bool invariant_only_p = !single_use0_p;
     433                 :            : 
     434                 :    3434540 :           rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt);
     435                 :            : 
     436                 :            :           /* Always combine comparisons or conversions from booleans.  */
     437                 :    3434540 :           if (TREE_CODE (op1) == INTEGER_CST
     438                 :    3434540 :               && ((CONVERT_EXPR_CODE_P (def_code)
     439                 :     525361 :                    && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs0, 0)))
     440                 :            :                       == BOOLEAN_TYPE)
     441                 :    2333330 :                   || TREE_CODE_CLASS (def_code) == tcc_comparison))
     442                 :            :             invariant_only_p = false;
     443                 :            : 
     444                 :    3434540 :           tmp = combine_cond_expr_cond (stmt, code, type,
     445                 :            :                                         rhs0, op1, invariant_only_p);
     446                 :    3434540 :           if (tmp)
     447                 :            :             return tmp;
     448                 :            :         }
     449                 :            :     }
     450                 :            : 
     451                 :            :   /* If that wasn't successful, try the second operand.  */
     452                 :   12788500 :   if (TREE_CODE (op1) == SSA_NAME)
     453                 :            :     {
     454                 :    3250750 :       gimple *def_stmt = get_prop_source_stmt (op1, false, &single_use1_p);
     455                 :    3250750 :       if (def_stmt && can_propagate_from (def_stmt))
     456                 :            :         {
     457                 :    1041720 :           rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt);
     458                 :    2083430 :           tmp = combine_cond_expr_cond (stmt, code, type,
     459                 :    1041720 :                                         op0, rhs1, !single_use1_p);
     460                 :    1041720 :           if (tmp)
     461                 :            :             return tmp;
     462                 :            :         }
     463                 :            :     }
     464                 :            : 
     465                 :            :   /* If that wasn't successful either, try both operands.  */
     466                 :   12785800 :   if (rhs0 != NULL_TREE
     467                 :   12785800 :       && rhs1 != NULL_TREE)
     468                 :     514232 :     tmp = combine_cond_expr_cond (stmt, code, type,
     469                 :            :                                   rhs0, rhs1,
     470                 :     514232 :                                   !(single_use0_p && single_use1_p));
     471                 :            : 
     472                 :            :   return tmp;
     473                 :            : }
     474                 :            : 
     475                 :            : /* Propagate from the ssa name definition statements of the assignment
     476                 :            :    from a comparison at *GSI into the conditional if that simplifies it.
     477                 :            :    Returns 1 if the stmt was modified and 2 if the CFG needs cleanup,
     478                 :            :    otherwise returns 0.  */
     479                 :            : 
     480                 :            : static int 
     481                 :    1688120 : forward_propagate_into_comparison (gimple_stmt_iterator *gsi)
     482                 :            : {
     483                 :    1688120 :   gimple *stmt = gsi_stmt (*gsi);
     484                 :    1688120 :   tree tmp;
     485                 :    1688120 :   bool cfg_changed = false;
     486                 :    1688120 :   tree type = TREE_TYPE (gimple_assign_lhs (stmt));
     487                 :    1688120 :   tree rhs1 = gimple_assign_rhs1 (stmt);
     488                 :    1688120 :   tree rhs2 = gimple_assign_rhs2 (stmt);
     489                 :            : 
     490                 :            :   /* Combine the comparison with defining statements.  */
     491                 :    1688120 :   tmp = forward_propagate_into_comparison_1 (stmt,
     492                 :            :                                              gimple_assign_rhs_code (stmt),
     493                 :            :                                              type, rhs1, rhs2);
     494                 :    1696670 :   if (tmp && useless_type_conversion_p (type, TREE_TYPE (tmp)))
     495                 :            :     {
     496                 :       8545 :       gimple_assign_set_rhs_from_tree (gsi, tmp);
     497                 :       8545 :       fold_stmt (gsi);
     498                 :       8545 :       update_stmt (gsi_stmt (*gsi));
     499                 :            : 
     500                 :       8545 :       if (TREE_CODE (rhs1) == SSA_NAME)
     501                 :       8541 :         cfg_changed |= remove_prop_source_from_use (rhs1);
     502                 :       8545 :       if (TREE_CODE (rhs2) == SSA_NAME)
     503                 :       2139 :         cfg_changed |= remove_prop_source_from_use (rhs2);
     504                 :      17090 :       return cfg_changed ? 2 : 1;
     505                 :            :     }
     506                 :            : 
     507                 :            :   return 0;
     508                 :            : }
     509                 :            : 
     510                 :            : /* Propagate from the ssa name definition statements of COND_EXPR
     511                 :            :    in GIMPLE_COND statement STMT into the conditional if that simplifies it.
     512                 :            :    Returns zero if no statement was changed, one if there were
     513                 :            :    changes and two if cfg_cleanup needs to run.
     514                 :            : 
     515                 :            :    This must be kept in sync with forward_propagate_into_cond.  */
     516                 :            : 
     517                 :            : static int
     518                 :   11523500 : forward_propagate_into_gimple_cond (gcond *stmt)
     519                 :            : {
     520                 :   11523500 :   tree tmp;
     521                 :   11523500 :   enum tree_code code = gimple_cond_code (stmt);
     522                 :   11523500 :   bool cfg_changed = false;
     523                 :   11523500 :   tree rhs1 = gimple_cond_lhs (stmt);
     524                 :   11523500 :   tree rhs2 = gimple_cond_rhs (stmt);
     525                 :            : 
     526                 :            :   /* We can do tree combining on SSA_NAME and comparison expressions.  */
     527                 :   11523500 :   if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
     528                 :            :     return 0;
     529                 :            : 
     530                 :   11523500 :   tmp = forward_propagate_into_comparison_1 (stmt, code,
     531                 :            :                                              boolean_type_node,
     532                 :            :                                              rhs1, rhs2);
     533                 :   11523500 :   if (tmp
     534                 :   11523500 :       && is_gimple_condexpr_for_cond (tmp))
     535                 :            :     {
     536                 :     458813 :       if (dump_file)
     537                 :            :         {
     538                 :         12 :           fprintf (dump_file, "  Replaced '");
     539                 :         12 :           print_gimple_expr (dump_file, stmt, 0);
     540                 :         12 :           fprintf (dump_file, "' with '");
     541                 :         12 :           print_generic_expr (dump_file, tmp);
     542                 :         12 :           fprintf (dump_file, "'\n");
     543                 :            :         }
     544                 :            : 
     545                 :     458813 :       gimple_cond_set_condition_from_tree (stmt, unshare_expr (tmp));
     546                 :     458813 :       update_stmt (stmt);
     547                 :            : 
     548                 :     458813 :       if (TREE_CODE (rhs1) == SSA_NAME)
     549                 :     458785 :         cfg_changed |= remove_prop_source_from_use (rhs1);
     550                 :     458813 :       if (TREE_CODE (rhs2) == SSA_NAME)
     551                 :       3049 :         cfg_changed |= remove_prop_source_from_use (rhs2);
     552                 :     458813 :       return (cfg_changed || is_gimple_min_invariant (tmp)) ? 2 : 1;
     553                 :            :     }
     554                 :            : 
     555                 :            :   /* Canonicalize _Bool == 0 and _Bool != 1 to _Bool != 0 by swapping edges.  */
     556                 :   11064700 :   if ((TREE_CODE (TREE_TYPE (rhs1)) == BOOLEAN_TYPE
     557                 :    9509070 :        || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
     558                 :    6869710 :            && TYPE_PRECISION (TREE_TYPE (rhs1)) == 1))
     559                 :   11066400 :       && ((code == EQ_EXPR
     560                 :       7192 :            && integer_zerop (rhs2))
     561                 :    1557070 :           || (code == NE_EXPR
     562                 :    1549850 :               && integer_onep (rhs2))))
     563                 :            :     {
     564                 :      86161 :       basic_block bb = gimple_bb (stmt);
     565                 :      86161 :       gimple_cond_set_code (stmt, NE_EXPR);
     566                 :      86161 :       gimple_cond_set_rhs (stmt, build_zero_cst (TREE_TYPE (rhs1)));
     567                 :      86161 :       EDGE_SUCC (bb, 0)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
     568                 :      86161 :       EDGE_SUCC (bb, 1)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
     569                 :      86161 :       return 1;
     570                 :            :     }
     571                 :            : 
     572                 :            :   return 0;
     573                 :            : }
     574                 :            : 
     575                 :            : 
     576                 :            : /* Propagate from the ssa name definition statements of COND_EXPR
     577                 :            :    in the rhs of statement STMT into the conditional if that simplifies it.
     578                 :            :    Returns true zero if the stmt was changed.  */
     579                 :            : 
     580                 :            : static bool
     581                 :      47608 : forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
     582                 :            : {
     583                 :      47608 :   gimple *stmt = gsi_stmt (*gsi_p);
     584                 :      47608 :   tree tmp = NULL_TREE;
     585                 :      47608 :   tree cond = gimple_assign_rhs1 (stmt);
     586                 :      47608 :   enum tree_code code = gimple_assign_rhs_code (stmt);
     587                 :            : 
     588                 :            :   /* We can do tree combining on SSA_NAME and comparison expressions.  */
     589                 :      47608 :   if (COMPARISON_CLASS_P (cond))
     590                 :      44448 :     tmp = forward_propagate_into_comparison_1 (stmt, TREE_CODE (cond),
     591                 :      44448 :                                                TREE_TYPE (cond),
     592                 :      44448 :                                                TREE_OPERAND (cond, 0),
     593                 :      44448 :                                                TREE_OPERAND (cond, 1));
     594                 :       3160 :   else if (TREE_CODE (cond) == SSA_NAME)
     595                 :            :     {
     596                 :       3137 :       enum tree_code def_code;
     597                 :       3137 :       tree name = cond;
     598                 :       3137 :       gimple *def_stmt = get_prop_source_stmt (name, true, NULL);
     599                 :       3137 :       if (!def_stmt || !can_propagate_from (def_stmt))
     600                 :        418 :         return 0;
     601                 :            : 
     602                 :       2719 :       def_code = gimple_assign_rhs_code (def_stmt);
     603                 :       2719 :       if (TREE_CODE_CLASS (def_code) == tcc_comparison)
     604                 :        506 :         tmp = fold_build2_loc (gimple_location (def_stmt),
     605                 :            :                                def_code,
     606                 :        506 :                                TREE_TYPE (cond),
     607                 :            :                                gimple_assign_rhs1 (def_stmt),
     608                 :            :                                gimple_assign_rhs2 (def_stmt));
     609                 :            :     }
     610                 :            : 
     611                 :      44954 :   if (tmp
     612                 :      44954 :       && is_gimple_condexpr (tmp))
     613                 :            :     {
     614                 :        537 :       if (dump_file)
     615                 :            :         {
     616                 :          0 :           fprintf (dump_file, "  Replaced '");
     617                 :          0 :           print_generic_expr (dump_file, cond);
     618                 :          0 :           fprintf (dump_file, "' with '");
     619                 :          0 :           print_generic_expr (dump_file, tmp);
     620                 :          0 :           fprintf (dump_file, "'\n");
     621                 :            :         }
     622                 :            : 
     623                 :        744 :       if ((code == VEC_COND_EXPR) ? integer_all_onesp (tmp)
     624                 :        207 :                                   : integer_onep (tmp))
     625                 :         11 :         gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs2 (stmt));
     626                 :        526 :       else if (integer_zerop (tmp))
     627                 :          5 :         gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs3 (stmt));
     628                 :            :       else
     629                 :        521 :         gimple_assign_set_rhs1 (stmt, unshare_expr (tmp));
     630                 :        537 :       stmt = gsi_stmt (*gsi_p);
     631                 :        537 :       update_stmt (stmt);
     632                 :            : 
     633                 :        537 :       return true;
     634                 :            :     }
     635                 :            : 
     636                 :            :   return 0;
     637                 :            : }
     638                 :            : 
     639                 :            : /* We've just substituted an ADDR_EXPR into stmt.  Update all the
     640                 :            :    relevant data structures to match.  */
     641                 :            : 
     642                 :            : static void
     643                 :    1266690 : tidy_after_forward_propagate_addr (gimple *stmt)
     644                 :            : {
     645                 :            :   /* We may have turned a trapping insn into a non-trapping insn.  */
     646                 :    1266690 :   if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
     647                 :          8 :     bitmap_set_bit (to_purge, gimple_bb (stmt)->index);
     648                 :            : 
     649                 :    1266690 :   if (TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR)
     650                 :     173822 :      recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
     651                 :    1266690 : }
     652                 :            : 
     653                 :            : /* NAME is a SSA_NAME representing DEF_RHS which is of the form
     654                 :            :    ADDR_EXPR <whatever>.
     655                 :            : 
     656                 :            :    Try to forward propagate the ADDR_EXPR into the use USE_STMT.
     657                 :            :    Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
     658                 :            :    node or for recovery of array indexing from pointer arithmetic.
     659                 :            : 
     660                 :            :    Return true if the propagation was successful (the propagation can
     661                 :            :    be not totally successful, yet things may have been changed).  */
     662                 :            : 
     663                 :            : static bool
     664                 :    1725390 : forward_propagate_addr_expr_1 (tree name, tree def_rhs,
     665                 :            :                                gimple_stmt_iterator *use_stmt_gsi,
     666                 :            :                                bool single_use_p)
     667                 :            : {
     668                 :    1725390 :   tree lhs, rhs, rhs2, array_ref;
     669                 :    1725390 :   gimple *use_stmt = gsi_stmt (*use_stmt_gsi);
     670                 :    1725390 :   enum tree_code rhs_code;
     671                 :    1725390 :   bool res = true;
     672                 :            : 
     673                 :    1725390 :   gcc_assert (TREE_CODE (def_rhs) == ADDR_EXPR);
     674                 :            : 
     675                 :    1725390 :   lhs = gimple_assign_lhs (use_stmt);
     676                 :    1725390 :   rhs_code = gimple_assign_rhs_code (use_stmt);
     677                 :    1725390 :   rhs = gimple_assign_rhs1 (use_stmt);
     678                 :            : 
     679                 :            :   /* Do not perform copy-propagation but recurse through copy chains.  */
     680                 :    1725390 :   if (TREE_CODE (lhs) == SSA_NAME
     681                 :     817396 :       && rhs_code == SSA_NAME)
     682                 :       2630 :     return forward_propagate_addr_expr (lhs, def_rhs, single_use_p);
     683                 :            : 
     684                 :            :   /* The use statement could be a conversion.  Recurse to the uses of the
     685                 :            :      lhs as copyprop does not copy through pointer to integer to pointer
     686                 :            :      conversions and FRE does not catch all cases either.
     687                 :            :      Treat the case of a single-use name and
     688                 :            :      a conversion to def_rhs type separate, though.  */
     689                 :    1722760 :   if (TREE_CODE (lhs) == SSA_NAME
     690                 :     814766 :       && CONVERT_EXPR_CODE_P (rhs_code))
     691                 :            :     {
     692                 :            :       /* If there is a point in a conversion chain where the types match
     693                 :            :          so we can remove a conversion re-materialize the address here
     694                 :            :          and stop.  */
     695                 :      35611 :       if (single_use_p
     696                 :      60234 :           && useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
     697                 :            :         {
     698                 :          0 :           gimple_assign_set_rhs1 (use_stmt, unshare_expr (def_rhs));
     699                 :          0 :           gimple_assign_set_rhs_code (use_stmt, TREE_CODE (def_rhs));
     700                 :          0 :           return true;
     701                 :            :         }
     702                 :            : 
     703                 :            :       /* Else recurse if the conversion preserves the address value.  */
     704                 :      71222 :       if ((INTEGRAL_TYPE_P (TREE_TYPE (lhs))
     705                 :          0 :            || POINTER_TYPE_P (TREE_TYPE (lhs)))
     706                 :      71222 :           && (TYPE_PRECISION (TREE_TYPE (lhs))
     707                 :      35611 :               >= TYPE_PRECISION (TREE_TYPE (def_rhs))))
     708                 :      35024 :         return forward_propagate_addr_expr (lhs, def_rhs, single_use_p);
     709                 :            : 
     710                 :            :       return false;
     711                 :            :     }
     712                 :            : 
     713                 :            :   /* If this isn't a conversion chain from this on we only can propagate
     714                 :            :      into compatible pointer contexts.  */
     715                 :    1687150 :   if (!types_compatible_p (TREE_TYPE (name), TREE_TYPE (def_rhs)))
     716                 :            :     return false;
     717                 :            : 
     718                 :            :   /* Propagate through constant pointer adjustments.  */
     719                 :    1667590 :   if (TREE_CODE (lhs) == SSA_NAME
     720                 :     760557 :       && rhs_code == POINTER_PLUS_EXPR
     721                 :     760557 :       && rhs == name
     722                 :    1735030 :       && TREE_CODE (gimple_assign_rhs2 (use_stmt)) == INTEGER_CST)
     723                 :            :     {
     724                 :      44311 :       tree new_def_rhs;
     725                 :            :       /* As we come here with non-invariant addresses in def_rhs we need
     726                 :            :          to make sure we can build a valid constant offsetted address
     727                 :            :          for further propagation.  Simply rely on fold building that
     728                 :            :          and check after the fact.  */
     729                 :      44311 :       new_def_rhs = fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (rhs)),
     730                 :            :                                  def_rhs,
     731                 :            :                                  fold_convert (ptr_type_node,
     732                 :            :                                                gimple_assign_rhs2 (use_stmt)));
     733                 :      44311 :       if (TREE_CODE (new_def_rhs) == MEM_REF
     734                 :      44311 :           && !is_gimple_mem_ref_addr (TREE_OPERAND (new_def_rhs, 0)))
     735                 :            :         return false;
     736                 :      41193 :       new_def_rhs = build1 (ADDR_EXPR, TREE_TYPE (rhs), new_def_rhs);
     737                 :            : 
     738                 :            :       /* Recurse.  If we could propagate into all uses of lhs do not
     739                 :            :          bother to replace into the current use but just pretend we did.  */
     740                 :      41193 :       if (forward_propagate_addr_expr (lhs, new_def_rhs, single_use_p))
     741                 :            :         return true;
     742                 :            : 
     743                 :      56508 :       if (useless_type_conversion_p (TREE_TYPE (lhs),
     744                 :      28254 :                                      TREE_TYPE (new_def_rhs)))
     745                 :      28254 :         gimple_assign_set_rhs_with_ops (use_stmt_gsi, TREE_CODE (new_def_rhs),
     746                 :            :                                         new_def_rhs);
     747                 :          0 :       else if (is_gimple_min_invariant (new_def_rhs))
     748                 :          0 :         gimple_assign_set_rhs_with_ops (use_stmt_gsi, NOP_EXPR, new_def_rhs);
     749                 :            :       else
     750                 :            :         return false;
     751                 :      28254 :       gcc_assert (gsi_stmt (*use_stmt_gsi) == use_stmt);
     752                 :      28254 :       update_stmt (use_stmt);
     753                 :      28254 :       return true;
     754                 :            :     }
     755                 :            : 
     756                 :            :   /* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS.
     757                 :            :      ADDR_EXPR will not appear on the LHS.  */
     758                 :    1623280 :   tree *lhsp = gimple_assign_lhs_ptr (use_stmt);
     759                 :    2487630 :   while (handled_component_p (*lhsp))
     760                 :     864347 :     lhsp = &TREE_OPERAND (*lhsp, 0);
     761                 :    1623280 :   lhs = *lhsp;
     762                 :            : 
     763                 :            :   /* Now see if the LHS node is a MEM_REF using NAME.  If so,
     764                 :            :      propagate the ADDR_EXPR into the use of NAME and fold the result.  */
     765                 :    1623280 :   if (TREE_CODE (lhs) == MEM_REF
     766                 :    1623280 :       && TREE_OPERAND (lhs, 0) == name)
     767                 :            :     {
     768                 :     612628 :       tree def_rhs_base;
     769                 :     612628 :       poly_int64 def_rhs_offset;
     770                 :            :       /* If the address is invariant we can always fold it.  */
     771                 :     612628 :       if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0),
     772                 :            :                                                          &def_rhs_offset)))
     773                 :            :         {
     774                 :     601527 :           poly_offset_int off = mem_ref_offset (lhs);
     775                 :     601527 :           tree new_ptr;
     776                 :     601527 :           off += def_rhs_offset;
     777                 :     601527 :           if (TREE_CODE (def_rhs_base) == MEM_REF)
     778                 :            :             {
     779                 :     584855 :               off += mem_ref_offset (def_rhs_base);
     780                 :     584855 :               new_ptr = TREE_OPERAND (def_rhs_base, 0);
     781                 :            :             }
     782                 :            :           else
     783                 :      16672 :             new_ptr = build_fold_addr_expr (def_rhs_base);
     784                 :     601527 :           TREE_OPERAND (lhs, 0) = new_ptr;
     785                 :     601527 :           TREE_OPERAND (lhs, 1)
     786                 :     601527 :             = wide_int_to_tree (TREE_TYPE (TREE_OPERAND (lhs, 1)), off);
     787                 :     601527 :           tidy_after_forward_propagate_addr (use_stmt);
     788                 :            :           /* Continue propagating into the RHS if this was not the only use.  */
     789                 :     601527 :           if (single_use_p)
     790                 :      77950 :             return true;
     791                 :            :         }
     792                 :            :       /* If the LHS is a plain dereference and the value type is the same as
     793                 :            :          that of the pointed-to type of the address we can put the
     794                 :            :          dereferenced address on the LHS preserving the original alias-type.  */
     795                 :      11101 :       else if (integer_zerop (TREE_OPERAND (lhs, 1))
     796                 :       9006 :                && ((gimple_assign_lhs (use_stmt) == lhs
     797                 :       6505 :                     && useless_type_conversion_p
     798                 :       6505 :                          (TREE_TYPE (TREE_OPERAND (def_rhs, 0)),
     799                 :       6505 :                           TREE_TYPE (gimple_assign_rhs1 (use_stmt))))
     800                 :       6829 :                    || types_compatible_p (TREE_TYPE (lhs),
     801                 :       6829 :                                           TREE_TYPE (TREE_OPERAND (def_rhs, 0))))
     802                 :            :                /* Don't forward anything into clobber stmts if it would result
     803                 :            :                   in the lhs no longer being a MEM_REF.  */
     804                 :      15368 :                && (!gimple_clobber_p (use_stmt)
     805                 :        347 :                    || TREE_CODE (TREE_OPERAND (def_rhs, 0)) == MEM_REF))
     806                 :            :         {
     807                 :       3920 :           tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0);
     808                 :      10234 :           tree new_offset, new_base, saved, new_lhs;
     809                 :      10234 :           while (handled_component_p (*def_rhs_basep))
     810                 :       6314 :             def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0);
     811                 :       3920 :           saved = *def_rhs_basep;
     812                 :       3920 :           if (TREE_CODE (*def_rhs_basep) == MEM_REF)
     813                 :            :             {
     814                 :       2434 :               new_base = TREE_OPERAND (*def_rhs_basep, 0);
     815                 :       2434 :               new_offset = fold_convert (TREE_TYPE (TREE_OPERAND (lhs, 1)),
     816                 :            :                                          TREE_OPERAND (*def_rhs_basep, 1));
     817                 :            :             }
     818                 :            :           else
     819                 :            :             {
     820                 :       1486 :               new_base = build_fold_addr_expr (*def_rhs_basep);
     821                 :       1486 :               new_offset = TREE_OPERAND (lhs, 1);
     822                 :            :             }
     823                 :       3920 :           *def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep),
     824                 :            :                                    new_base, new_offset);
     825                 :       3920 :           TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (lhs);
     826                 :       3920 :           TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (lhs);
     827                 :       3920 :           TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (lhs);
     828                 :       3920 :           new_lhs = unshare_expr (TREE_OPERAND (def_rhs, 0));
     829                 :       3920 :           *lhsp = new_lhs;
     830                 :       3920 :           TREE_THIS_VOLATILE (new_lhs) = TREE_THIS_VOLATILE (lhs);
     831                 :       3920 :           TREE_SIDE_EFFECTS (new_lhs) = TREE_SIDE_EFFECTS (lhs);
     832                 :       3920 :           *def_rhs_basep = saved;
     833                 :       3920 :           tidy_after_forward_propagate_addr (use_stmt);
     834                 :            :           /* Continue propagating into the RHS if this was not the
     835                 :            :              only use.  */
     836                 :       3920 :           if (single_use_p)
     837                 :            :             return true;
     838                 :            :         }
     839                 :            :       else
     840                 :            :         /* We can have a struct assignment dereferencing our name twice.
     841                 :            :            Note that we didn't propagate into the lhs to not falsely
     842                 :            :            claim we did when propagating into the rhs.  */
     843                 :            :         res = false;
     844                 :            :     }
     845                 :            : 
     846                 :            :   /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
     847                 :            :      nodes from the RHS.  */
     848                 :    1544240 :   tree *rhsp = gimple_assign_rhs1_ptr (use_stmt);
     849                 :    1544240 :   if (TREE_CODE (*rhsp) == ADDR_EXPR)
     850                 :     160210 :     rhsp = &TREE_OPERAND (*rhsp, 0);
     851                 :    2168090 :   while (handled_component_p (*rhsp))
     852                 :     623848 :     rhsp = &TREE_OPERAND (*rhsp, 0);
     853                 :    1544240 :   rhs = *rhsp;
     854                 :            : 
     855                 :            :   /* Now see if the RHS node is a MEM_REF using NAME.  If so,
     856                 :            :      propagate the ADDR_EXPR into the use of NAME and fold the result.  */
     857                 :    1544240 :   if (TREE_CODE (rhs) == MEM_REF
     858                 :    1544240 :       && TREE_OPERAND (rhs, 0) == name)
     859                 :            :     {
     860                 :     668480 :       tree def_rhs_base;
     861                 :     668480 :       poly_int64 def_rhs_offset;
     862                 :     668480 :       if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0),
     863                 :            :                                                          &def_rhs_offset)))
     864                 :            :         {
     865                 :     653881 :           poly_offset_int off = mem_ref_offset (rhs);
     866                 :     653881 :           tree new_ptr;
     867                 :     653881 :           off += def_rhs_offset;
     868                 :     653881 :           if (TREE_CODE (def_rhs_base) == MEM_REF)
     869                 :            :             {
     870                 :     636828 :               off += mem_ref_offset (def_rhs_base);
     871                 :     636828 :               new_ptr = TREE_OPERAND (def_rhs_base, 0);
     872                 :            :             }
     873                 :            :           else
     874                 :      17053 :             new_ptr = build_fold_addr_expr (def_rhs_base);
     875                 :     653881 :           TREE_OPERAND (rhs, 0) = new_ptr;
     876                 :     653881 :           TREE_OPERAND (rhs, 1)
     877                 :     653881 :             = wide_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs, 1)), off);
     878                 :     653881 :           fold_stmt_inplace (use_stmt_gsi);
     879                 :     653881 :           tidy_after_forward_propagate_addr (use_stmt);
     880                 :     653881 :           return res;
     881                 :            :         }
     882                 :            :       /* If the RHS is a plain dereference and the value type is the same as
     883                 :            :          that of the pointed-to type of the address we can put the
     884                 :            :          dereferenced address on the RHS preserving the original alias-type.  */
     885                 :      14599 :       else if (integer_zerop (TREE_OPERAND (rhs, 1))
     886                 :      26517 :                && ((gimple_assign_rhs1 (use_stmt) == rhs
     887                 :       6844 :                     && useless_type_conversion_p
     888                 :       6844 :                          (TREE_TYPE (gimple_assign_lhs (use_stmt)),
     889                 :       6844 :                           TREE_TYPE (TREE_OPERAND (def_rhs, 0))))
     890                 :       8959 :                    || types_compatible_p (TREE_TYPE (rhs),
     891                 :       8959 :                                           TREE_TYPE (TREE_OPERAND (def_rhs, 0)))))
     892                 :            :         {
     893                 :       7360 :           tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0);
     894                 :      18838 :           tree new_offset, new_base, saved, new_rhs;
     895                 :      18838 :           while (handled_component_p (*def_rhs_basep))
     896                 :      11478 :             def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0);
     897                 :       7360 :           saved = *def_rhs_basep;
     898                 :       7360 :           if (TREE_CODE (*def_rhs_basep) == MEM_REF)
     899                 :            :             {
     900                 :       4278 :               new_base = TREE_OPERAND (*def_rhs_basep, 0);
     901                 :       4278 :               new_offset = fold_convert (TREE_TYPE (TREE_OPERAND (rhs, 1)),
     902                 :            :                                          TREE_OPERAND (*def_rhs_basep, 1));
     903                 :            :             }
     904                 :            :           else
     905                 :            :             {
     906                 :       3082 :               new_base = build_fold_addr_expr (*def_rhs_basep);
     907                 :       3082 :               new_offset = TREE_OPERAND (rhs, 1);
     908                 :            :             }
     909                 :       7360 :           *def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep),
     910                 :            :                                    new_base, new_offset);
     911                 :       7360 :           TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (rhs);
     912                 :       7360 :           TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (rhs);
     913                 :       7360 :           TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (rhs);
     914                 :       7360 :           new_rhs = unshare_expr (TREE_OPERAND (def_rhs, 0));
     915                 :       7360 :           *rhsp = new_rhs;
     916                 :       7360 :           TREE_THIS_VOLATILE (new_rhs) = TREE_THIS_VOLATILE (rhs);
     917                 :       7360 :           TREE_SIDE_EFFECTS (new_rhs) = TREE_SIDE_EFFECTS (rhs);
     918                 :       7360 :           *def_rhs_basep = saved;
     919                 :       7360 :           fold_stmt_inplace (use_stmt_gsi);
     920                 :       7360 :           tidy_after_forward_propagate_addr (use_stmt);
     921                 :       7360 :           return res;
     922                 :            :         }
     923                 :            :     }
     924                 :            : 
     925                 :            :   /* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
     926                 :            :      is nothing to do. */
     927                 :     883002 :   if (gimple_assign_rhs_code (use_stmt) != POINTER_PLUS_EXPR
     928                 :     906125 :       || gimple_assign_rhs1 (use_stmt) != name)
     929                 :            :     return false;
     930                 :            : 
     931                 :            :   /* The remaining cases are all for turning pointer arithmetic into
     932                 :            :      array indexing.  They only apply when we have the address of
     933                 :            :      element zero in an array.  If that is not the case then there
     934                 :            :      is nothing to do.  */
     935                 :      23123 :   array_ref = TREE_OPERAND (def_rhs, 0);
     936                 :      23123 :   if ((TREE_CODE (array_ref) != ARRAY_REF
     937                 :       3075 :        || TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref, 0))) != ARRAY_TYPE
     938                 :       3075 :        || TREE_CODE (TREE_OPERAND (array_ref, 1)) != INTEGER_CST)
     939                 :      44555 :       && TREE_CODE (TREE_TYPE (array_ref)) != ARRAY_TYPE)
     940                 :            :     return false;
     941                 :            : 
     942                 :       7503 :   rhs2 = gimple_assign_rhs2 (use_stmt);
     943                 :            :   /* Optimize &x[C1] p+ C2 to  &x p+ C3 with C3 = C1 * element_size + C2.  */
     944                 :       7503 :   if (TREE_CODE (rhs2) == INTEGER_CST)
     945                 :            :     {
     946                 :          0 :       tree new_rhs = build1_loc (gimple_location (use_stmt),
     947                 :          0 :                                  ADDR_EXPR, TREE_TYPE (def_rhs),
     948                 :          0 :                                  fold_build2 (MEM_REF,
     949                 :            :                                               TREE_TYPE (TREE_TYPE (def_rhs)),
     950                 :            :                                               unshare_expr (def_rhs),
     951                 :            :                                               fold_convert (ptr_type_node,
     952                 :            :                                                             rhs2)));
     953                 :          0 :       gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs);
     954                 :          0 :       use_stmt = gsi_stmt (*use_stmt_gsi);
     955                 :          0 :       update_stmt (use_stmt);
     956                 :          0 :       tidy_after_forward_propagate_addr (use_stmt);
     957                 :          0 :       return true;
     958                 :            :     }
     959                 :            : 
     960                 :            :   return false;
     961                 :            : }
     962                 :            : 
     963                 :            : /* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
     964                 :            : 
     965                 :            :    Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME.
     966                 :            :    Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
     967                 :            :    node or for recovery of array indexing from pointer arithmetic.
     968                 :            : 
     969                 :            :    PARENT_SINGLE_USE_P tells if, when in a recursive invocation, NAME was
     970                 :            :    the single use in the previous invocation.  Pass true when calling
     971                 :            :    this as toplevel.
     972                 :            : 
     973                 :            :    Returns true, if all uses have been propagated into.  */
     974                 :            : 
     975                 :            : static bool
     976                 :    2040100 : forward_propagate_addr_expr (tree name, tree rhs, bool parent_single_use_p)
     977                 :            : {
     978                 :    2040100 :   imm_use_iterator iter;
     979                 :    2040100 :   gimple *use_stmt;
     980                 :    2040100 :   bool all = true;
     981                 :    2040100 :   bool single_use_p = parent_single_use_p && has_single_use (name);
     982                 :            : 
     983                 :    6957420 :   FOR_EACH_IMM_USE_STMT (use_stmt, iter, name)
     984                 :            :     {
     985                 :    4917320 :       bool result;
     986                 :    4917320 :       tree use_rhs;
     987                 :            : 
     988                 :            :       /* If the use is not in a simple assignment statement, then
     989                 :            :          there is nothing we can do.  */
     990                 :    4917320 :       if (!is_gimple_assign (use_stmt))
     991                 :            :         {
     992                 :    3191930 :           if (!is_gimple_debug (use_stmt))
     993                 :    1211600 :             all = false;
     994                 :    3191930 :           continue;
     995                 :            :         }
     996                 :            : 
     997                 :    1725390 :       gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
     998                 :    1725390 :       result = forward_propagate_addr_expr_1 (name, rhs, &gsi,
     999                 :            :                                               single_use_p);
    1000                 :            :       /* If the use has moved to a different statement adjust
    1001                 :            :          the update machinery for the old statement too.  */
    1002                 :    1725390 :       if (use_stmt != gsi_stmt (gsi))
    1003                 :            :         {
    1004                 :          0 :           update_stmt (use_stmt);
    1005                 :          0 :           use_stmt = gsi_stmt (gsi);
    1006                 :            :         }
    1007                 :    1725390 :       update_stmt (use_stmt);
    1008                 :    1725390 :       all &= result;
    1009                 :            : 
    1010                 :            :       /* Remove intermediate now unused copy and conversion chains.  */
    1011                 :    1725390 :       use_rhs = gimple_assign_rhs1 (use_stmt);
    1012                 :    1725390 :       if (result
    1013                 :     782991 :           && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
    1014                 :     697693 :           && TREE_CODE (use_rhs) == SSA_NAME
    1015                 :    1739850 :           && has_zero_uses (gimple_assign_lhs (use_stmt)))
    1016                 :            :         {
    1017                 :      14457 :           gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
    1018                 :      14457 :           fwprop_invalidate_lattice (gimple_get_lhs (use_stmt));
    1019                 :      14457 :           release_defs (use_stmt);
    1020                 :      14457 :           gsi_remove (&gsi, true);
    1021                 :            :         }
    1022                 :            :     }
    1023                 :            : 
    1024                 :    2040100 :   return all && has_zero_uses (name);
    1025                 :            : }
    1026                 :            : 
    1027                 :            : 
    1028                 :            : /* Helper function for simplify_gimple_switch.  Remove case labels that
    1029                 :            :    have values outside the range of the new type.  */
    1030                 :            : 
    1031                 :            : static void
    1032                 :       7520 : simplify_gimple_switch_label_vec (gswitch *stmt, tree index_type)
    1033                 :            : {
    1034                 :       7520 :   unsigned int branch_num = gimple_switch_num_labels (stmt);
    1035                 :       7520 :   auto_vec<tree> labels (branch_num);
    1036                 :            :   unsigned int i, len;
    1037                 :            : 
    1038                 :            :   /* Collect the existing case labels in a VEC, and preprocess it as if
    1039                 :            :      we are gimplifying a GENERIC SWITCH_EXPR.  */
    1040                 :      34433 :   for (i = 1; i < branch_num; i++)
    1041                 :      26913 :     labels.quick_push (gimple_switch_label (stmt, i));
    1042                 :       7520 :   preprocess_case_label_vec_for_gimple (labels, index_type, NULL);
    1043                 :            : 
    1044                 :            :   /* If any labels were removed, replace the existing case labels
    1045                 :            :      in the GIMPLE_SWITCH statement with the correct ones.
    1046                 :            :      Note that the type updates were done in-place on the case labels,
    1047                 :            :      so we only have to replace the case labels in the GIMPLE_SWITCH
    1048                 :            :      if the number of labels changed.  */
    1049                 :       7520 :   len = labels.length ();
    1050                 :       7520 :   if (len < branch_num - 1)
    1051                 :            :     {
    1052                 :          0 :       bitmap target_blocks;
    1053                 :          0 :       edge_iterator ei;
    1054                 :          0 :       edge e;
    1055                 :            : 
    1056                 :            :       /* Corner case: *all* case labels have been removed as being
    1057                 :            :          out-of-range for INDEX_TYPE.  Push one label and let the
    1058                 :            :          CFG cleanups deal with this further.  */
    1059                 :          0 :       if (len == 0)
    1060                 :            :         {
    1061                 :          0 :           tree label, elt;
    1062                 :            : 
    1063                 :          0 :           label = CASE_LABEL (gimple_switch_default_label (stmt));
    1064                 :          0 :           elt = build_case_label (build_int_cst (index_type, 0), NULL, label);
    1065                 :          0 :           labels.quick_push (elt);
    1066                 :          0 :           len = 1;
    1067                 :            :         }
    1068                 :            : 
    1069                 :          0 :       for (i = 0; i < labels.length (); i++)
    1070                 :          0 :         gimple_switch_set_label (stmt, i + 1, labels[i]);
    1071                 :          0 :       for (i++ ; i < branch_num; i++)
    1072                 :          0 :         gimple_switch_set_label (stmt, i, NULL_TREE);
    1073                 :          0 :       gimple_switch_set_num_labels (stmt, len + 1);
    1074                 :            : 
    1075                 :            :       /* Cleanup any edges that are now dead.  */
    1076                 :          0 :       target_blocks = BITMAP_ALLOC (NULL);
    1077                 :          0 :       for (i = 0; i < gimple_switch_num_labels (stmt); i++)
    1078                 :            :         {
    1079                 :          0 :           tree elt = gimple_switch_label (stmt, i);
    1080                 :          0 :           basic_block target = label_to_block (cfun, CASE_LABEL (elt));
    1081                 :          0 :           bitmap_set_bit (target_blocks, target->index);
    1082                 :            :         }
    1083                 :          0 :       for (ei = ei_start (gimple_bb (stmt)->succs); (e = ei_safe_edge (ei)); )
    1084                 :            :         {
    1085                 :          0 :           if (! bitmap_bit_p (target_blocks, e->dest->index))
    1086                 :            :             {
    1087                 :          0 :               remove_edge (e);
    1088                 :          0 :               cfg_changed = true;
    1089                 :          0 :               free_dominance_info (CDI_DOMINATORS);
    1090                 :            :             }
    1091                 :            :           else
    1092                 :          0 :             ei_next (&ei);
    1093                 :            :         } 
    1094                 :          0 :       BITMAP_FREE (target_blocks);
    1095                 :            :     }
    1096                 :       7520 : }
    1097                 :            : 
    1098                 :            : /* STMT is a SWITCH_EXPR for which we attempt to find equivalent forms of
    1099                 :            :    the condition which we may be able to optimize better.  */
    1100                 :            : 
    1101                 :            : static bool
    1102                 :      66056 : simplify_gimple_switch (gswitch *stmt)
    1103                 :            : {
    1104                 :            :   /* The optimization that we really care about is removing unnecessary
    1105                 :            :      casts.  That will let us do much better in propagating the inferred
    1106                 :            :      constant at the switch target.  */
    1107                 :      66056 :   tree cond = gimple_switch_index (stmt);
    1108                 :      66056 :   if (TREE_CODE (cond) == SSA_NAME)
    1109                 :            :     {
    1110                 :      66015 :       gimple *def_stmt = SSA_NAME_DEF_STMT (cond);
    1111                 :      66015 :       if (gimple_assign_cast_p (def_stmt))
    1112                 :            :         {
    1113                 :       7825 :           tree def = gimple_assign_rhs1 (def_stmt);
    1114                 :       7825 :           if (TREE_CODE (def) != SSA_NAME)
    1115                 :            :             return false;
    1116                 :            : 
    1117                 :            :           /* If we have an extension or sign-change that preserves the
    1118                 :            :              values we check against then we can copy the source value into
    1119                 :            :              the switch.  */
    1120                 :       7825 :           tree ti = TREE_TYPE (def);
    1121                 :       7825 :           if (INTEGRAL_TYPE_P (ti)
    1122                 :      15527 :               && TYPE_PRECISION (ti) <= TYPE_PRECISION (TREE_TYPE (cond)))
    1123                 :            :             {
    1124                 :       7532 :               size_t n = gimple_switch_num_labels (stmt);
    1125                 :       7532 :               tree min = NULL_TREE, max = NULL_TREE;
    1126                 :       7532 :               if (n > 1)
    1127                 :            :                 {
    1128                 :       7532 :                   min = CASE_LOW (gimple_switch_label (stmt, 1));
    1129                 :       7532 :                   if (CASE_HIGH (gimple_switch_label (stmt, n - 1)))
    1130                 :        157 :                     max = CASE_HIGH (gimple_switch_label (stmt, n - 1));
    1131                 :            :                   else
    1132                 :       7375 :                     max = CASE_LOW (gimple_switch_label (stmt, n - 1));
    1133                 :            :                 }
    1134                 :       7532 :               if ((!min || int_fits_type_p (min, ti))
    1135                 :       7529 :                   && (!max || int_fits_type_p (max, ti)))
    1136                 :            :                 {
    1137                 :       7520 :                   gimple_switch_set_index (stmt, def);
    1138                 :       7520 :                   simplify_gimple_switch_label_vec (stmt, ti);
    1139                 :       7520 :                   update_stmt (stmt);
    1140                 :       7520 :                   return true;
    1141                 :            :                 }
    1142                 :            :             }
    1143                 :            :         }
    1144                 :            :     }
    1145                 :            : 
    1146                 :            :   return false;
    1147                 :            : }
    1148                 :            : 
    1149                 :            : /* For pointers p2 and p1 return p2 - p1 if the
    1150                 :            :    difference is known and constant, otherwise return NULL.  */
    1151                 :            : 
    1152                 :            : static tree
    1153                 :       5023 : constant_pointer_difference (tree p1, tree p2)
    1154                 :            : {
    1155                 :       5023 :   int i, j;
    1156                 :            : #define CPD_ITERATIONS 5
    1157                 :       5023 :   tree exps[2][CPD_ITERATIONS];
    1158                 :       5023 :   tree offs[2][CPD_ITERATIONS];
    1159                 :       5023 :   int cnt[2];
    1160                 :            : 
    1161                 :      15069 :   for (i = 0; i < 2; i++)
    1162                 :            :     {
    1163                 :      10046 :       tree p = i ? p1 : p2;
    1164                 :      10046 :       tree off = size_zero_node;
    1165                 :      10046 :       gimple *stmt;
    1166                 :      10046 :       enum tree_code code;
    1167                 :            : 
    1168                 :            :       /* For each of p1 and p2 we need to iterate at least
    1169                 :            :          twice, to handle ADDR_EXPR directly in p1/p2,
    1170                 :            :          SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc.
    1171                 :            :          on definition's stmt RHS.  Iterate a few extra times.  */
    1172                 :      10046 :       j = 0;
    1173                 :      11937 :       do
    1174                 :            :         {
    1175                 :      11937 :           if (!POINTER_TYPE_P (TREE_TYPE (p)))
    1176                 :            :             break;
    1177                 :      11919 :           if (TREE_CODE (p) == ADDR_EXPR)
    1178                 :            :             {
    1179                 :       8862 :               tree q = TREE_OPERAND (p, 0);
    1180                 :       8862 :               poly_int64 offset;
    1181                 :       8862 :               tree base = get_addr_base_and_unit_offset (q, &offset);
    1182                 :       8862 :               if (base)
    1183                 :            :                 {
    1184                 :       8148 :                   q = base;
    1185                 :       8148 :                   if (maybe_ne (offset, 0))
    1186                 :       3433 :                     off = size_binop (PLUS_EXPR, off, size_int (offset));
    1187                 :            :                 }
    1188                 :       8862 :               if (TREE_CODE (q) == MEM_REF
    1189                 :       8862 :                   && TREE_CODE (TREE_OPERAND (q, 0)) == SSA_NAME)
    1190                 :            :                 {
    1191                 :        432 :                   p = TREE_OPERAND (q, 0);
    1192                 :        432 :                   off = size_binop (PLUS_EXPR, off,
    1193                 :            :                                     wide_int_to_tree (sizetype,
    1194                 :            :                                                       mem_ref_offset (q)));
    1195                 :            :                 }
    1196                 :            :               else
    1197                 :            :                 {
    1198                 :       8430 :                   exps[i][j] = q;
    1199                 :       8430 :                   offs[i][j++] = off;
    1200                 :       8430 :                   break;
    1201                 :            :                 }
    1202                 :            :             }
    1203                 :       3489 :           if (TREE_CODE (p) != SSA_NAME)
    1204                 :            :             break;
    1205                 :       3489 :           exps[i][j] = p;
    1206                 :       3489 :           offs[i][j++] = off;
    1207                 :       3489 :           if (j == CPD_ITERATIONS)
    1208                 :            :             break;
    1209                 :       3489 :           stmt = SSA_NAME_DEF_STMT (p);
    1210                 :       3489 :           if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != p)
    1211                 :            :             break;
    1212                 :       2608 :           code = gimple_assign_rhs_code (stmt);
    1213                 :       2608 :           if (code == POINTER_PLUS_EXPR)
    1214                 :            :             {
    1215                 :       1182 :               if (TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST)
    1216                 :            :                 break;
    1217                 :        767 :               off = size_binop (PLUS_EXPR, off, gimple_assign_rhs2 (stmt));
    1218                 :        767 :               p = gimple_assign_rhs1 (stmt);
    1219                 :            :             }
    1220                 :       1426 :           else if (code == ADDR_EXPR || CONVERT_EXPR_CODE_P (code))
    1221                 :       1124 :             p = gimple_assign_rhs1 (stmt);
    1222                 :            :           else
    1223                 :            :             break;
    1224                 :            :         }
    1225                 :            :       while (1);
    1226                 :      10046 :       cnt[i] = j;
    1227                 :            :     }
    1228                 :            : 
    1229                 :       6944 :   for (i = 0; i < cnt[0]; i++)
    1230                 :       9340 :     for (j = 0; j < cnt[1]; j++)
    1231                 :       7419 :       if (exps[0][i] == exps[1][j])
    1232                 :       4232 :         return size_binop (MINUS_EXPR, offs[0][i], offs[1][j]);
    1233                 :            : 
    1234                 :            :   return NULL_TREE;
    1235                 :            : }
    1236                 :            : 
    1237                 :            : /* *GSI_P is a GIMPLE_CALL to a builtin function.
    1238                 :            :    Optimize
    1239                 :            :    memcpy (p, "abcd", 4);
    1240                 :            :    memset (p + 4, ' ', 3);
    1241                 :            :    into
    1242                 :            :    memcpy (p, "abcd   ", 7);
    1243                 :            :    call if the latter can be stored by pieces during expansion.  */
    1244                 :            : 
    1245                 :            : static bool
    1246                 :    3257680 : simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2)
    1247                 :            : {
    1248                 :    3257680 :   gimple *stmt1, *stmt2 = gsi_stmt (*gsi_p);
    1249                 :    3257680 :   tree vuse = gimple_vuse (stmt2);
    1250                 :    3257680 :   if (vuse == NULL)
    1251                 :            :     return false;
    1252                 :    2914830 :   stmt1 = SSA_NAME_DEF_STMT (vuse);
    1253                 :            : 
    1254                 :    2914830 :   switch (DECL_FUNCTION_CODE (callee2))
    1255                 :            :     {
    1256                 :      68258 :     case BUILT_IN_MEMSET:
    1257                 :      68258 :       if (gimple_call_num_args (stmt2) != 3
    1258                 :      68258 :           || gimple_call_lhs (stmt2)
    1259                 :            :           || CHAR_BIT != 8
    1260                 :     136516 :           || BITS_PER_UNIT != 8)
    1261                 :            :         break;
    1262                 :            :       else
    1263                 :            :         {
    1264                 :      64435 :           tree callee1;
    1265                 :      64435 :           tree ptr1, src1, str1, off1, len1, lhs1;
    1266                 :      64435 :           tree ptr2 = gimple_call_arg (stmt2, 0);
    1267                 :      64435 :           tree val2 = gimple_call_arg (stmt2, 1);
    1268                 :      64435 :           tree len2 = gimple_call_arg (stmt2, 2);
    1269                 :      64435 :           tree diff, vdef, new_str_cst;
    1270                 :      64435 :           gimple *use_stmt;
    1271                 :      64435 :           unsigned int ptr1_align;
    1272                 :      64435 :           unsigned HOST_WIDE_INT src_len;
    1273                 :      64435 :           char *src_buf;
    1274                 :      64435 :           use_operand_p use_p;
    1275                 :            : 
    1276                 :      64435 :           if (!tree_fits_shwi_p (val2)
    1277                 :      62566 :               || !tree_fits_uhwi_p (len2)
    1278                 :     103922 :               || compare_tree_int (len2, 1024) == 1)
    1279                 :            :             break;
    1280                 :      37131 :           if (is_gimple_call (stmt1))
    1281                 :            :             {
    1282                 :            :               /* If first stmt is a call, it needs to be memcpy
    1283                 :            :                  or mempcpy, with string literal as second argument and
    1284                 :            :                  constant length.  */
    1285                 :      20463 :               callee1 = gimple_call_fndecl (stmt1);
    1286                 :      20463 :               if (callee1 == NULL_TREE
    1287                 :      20352 :                   || !fndecl_built_in_p (callee1, BUILT_IN_NORMAL)
    1288                 :      38296 :                   || gimple_call_num_args (stmt1) != 3)
    1289                 :            :                 break;
    1290                 :      16971 :               if (DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMCPY
    1291                 :      16971 :                   && DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMPCPY)
    1292                 :            :                 break;
    1293                 :      10509 :               ptr1 = gimple_call_arg (stmt1, 0);
    1294                 :      10509 :               src1 = gimple_call_arg (stmt1, 1);
    1295                 :      10509 :               len1 = gimple_call_arg (stmt1, 2);
    1296                 :      10509 :               lhs1 = gimple_call_lhs (stmt1);
    1297                 :      10509 :               if (!tree_fits_uhwi_p (len1))
    1298                 :            :                 break;
    1299                 :      10425 :               str1 = string_constant (src1, &off1, NULL, NULL);
    1300                 :      10425 :               if (str1 == NULL_TREE)
    1301                 :            :                 break;
    1302                 :       4731 :               if (!tree_fits_uhwi_p (off1)
    1303                 :       4731 :                   || compare_tree_int (off1, TREE_STRING_LENGTH (str1) - 1) > 0
    1304                 :       4731 :                   || compare_tree_int (len1, TREE_STRING_LENGTH (str1)
    1305                 :       4731 :                                              - tree_to_uhwi (off1)) > 0
    1306                 :       4731 :                   || TREE_CODE (TREE_TYPE (str1)) != ARRAY_TYPE
    1307                 :      14193 :                   || TYPE_MODE (TREE_TYPE (TREE_TYPE (str1)))
    1308                 :       4731 :                      != TYPE_MODE (char_type_node))
    1309                 :            :                 break;
    1310                 :            :             }
    1311                 :      72069 :           else if (gimple_assign_single_p (stmt1))
    1312                 :            :             {
    1313                 :            :               /* Otherwise look for length 1 memcpy optimized into
    1314                 :            :                  assignment.  */
    1315                 :       9866 :               ptr1 = gimple_assign_lhs (stmt1);
    1316                 :       9866 :               src1 = gimple_assign_rhs1 (stmt1);
    1317                 :       9866 :               if (TREE_CODE (ptr1) != MEM_REF
    1318                 :       1950 :                   || TYPE_MODE (TREE_TYPE (ptr1)) != TYPE_MODE (char_type_node)
    1319                 :      10421 :                   || !tree_fits_shwi_p (src1))
    1320                 :            :                 break;
    1321                 :        282 :               ptr1 = build_fold_addr_expr (ptr1);
    1322                 :        282 :               STRIP_USELESS_TYPE_CONVERSION (ptr1);
    1323                 :        282 :               callee1 = NULL_TREE;
    1324                 :        282 :               len1 = size_one_node;
    1325                 :        282 :               lhs1 = NULL_TREE;
    1326                 :        282 :               off1 = size_zero_node;
    1327                 :        282 :               str1 = NULL_TREE;
    1328                 :            :             }
    1329                 :            :           else
    1330                 :            :             break;
    1331                 :            : 
    1332                 :       5013 :           diff = constant_pointer_difference (ptr1, ptr2);
    1333                 :       5013 :           if (diff == NULL && lhs1 != NULL)
    1334                 :            :             {
    1335                 :         10 :               diff = constant_pointer_difference (lhs1, ptr2);
    1336                 :         10 :               if (DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY
    1337                 :         10 :                   && diff != NULL)
    1338                 :         10 :                 diff = size_binop (PLUS_EXPR, diff,
    1339                 :            :                                    fold_convert (sizetype, len1));
    1340                 :            :             }
    1341                 :            :           /* If the difference between the second and first destination pointer
    1342                 :            :              is not constant, or is bigger than memcpy length, bail out.  */
    1343                 :       5013 :           if (diff == NULL
    1344                 :       4232 :               || !tree_fits_uhwi_p (diff)
    1345                 :       4232 :               || tree_int_cst_lt (len1, diff)
    1346                 :       8975 :               || compare_tree_int (diff, 1024) == 1)
    1347                 :            :             break;
    1348                 :            : 
    1349                 :            :           /* Use maximum of difference plus memset length and memcpy length
    1350                 :            :              as the new memcpy length, if it is too big, bail out.  */
    1351                 :       3962 :           src_len = tree_to_uhwi (diff);
    1352                 :       3962 :           src_len += tree_to_uhwi (len2);
    1353                 :       3962 :           if (src_len < tree_to_uhwi (len1))
    1354                 :            :             src_len = tree_to_uhwi (len1);
    1355                 :       3962 :           if (src_len > 1024)
    1356                 :            :             break;
    1357                 :            : 
    1358                 :            :           /* If mempcpy value is used elsewhere, bail out, as mempcpy
    1359                 :            :              with bigger length will return different result.  */
    1360                 :       3962 :           if (lhs1 != NULL_TREE
    1361                 :        190 :               && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY
    1362                 :       3972 :               && (TREE_CODE (lhs1) != SSA_NAME
    1363                 :         10 :                   || !single_imm_use (lhs1, &use_p, &use_stmt)
    1364                 :         10 :                   || use_stmt != stmt2))
    1365                 :            :             break;
    1366                 :            : 
    1367                 :            :           /* If anything reads memory in between memcpy and memset
    1368                 :            :              call, the modified memcpy call might change it.  */
    1369                 :       3962 :           vdef = gimple_vdef (stmt1);
    1370                 :       3962 :           if (vdef != NULL
    1371                 :       3962 :               && (!single_imm_use (vdef, &use_p, &use_stmt)
    1372                 :       3281 :                   || use_stmt != stmt2))
    1373                 :            :             break;
    1374                 :            : 
    1375                 :       3281 :           ptr1_align = get_pointer_alignment (ptr1);
    1376                 :            :           /* Construct the new source string literal.  */
    1377                 :       3281 :           src_buf = XALLOCAVEC (char, src_len + 1);
    1378                 :       3281 :           if (callee1)
    1379                 :       3138 :             memcpy (src_buf,
    1380                 :       3138 :                     TREE_STRING_POINTER (str1) + tree_to_uhwi (off1),
    1381                 :            :                     tree_to_uhwi (len1));
    1382                 :            :           else
    1383                 :        143 :             src_buf[0] = tree_to_shwi (src1);
    1384                 :       3281 :           memset (src_buf + tree_to_uhwi (diff),
    1385                 :       3281 :                   tree_to_shwi (val2), tree_to_uhwi (len2));
    1386                 :       3281 :           src_buf[src_len] = '\0';
    1387                 :            :           /* Neither builtin_strncpy_read_str nor builtin_memcpy_read_str
    1388                 :            :              handle embedded '\0's.  */
    1389                 :       3281 :           if (strlen (src_buf) != src_len)
    1390                 :            :             break;
    1391                 :       3208 :           rtl_profile_for_bb (gimple_bb (stmt2));
    1392                 :            :           /* If the new memcpy wouldn't be emitted by storing the literal
    1393                 :            :              by pieces, this optimization might enlarge .rodata too much,
    1394                 :            :              as commonly used string literals couldn't be shared any
    1395                 :            :              longer.  */
    1396                 :       3208 :           if (!can_store_by_pieces (src_len,
    1397                 :            :                                     builtin_strncpy_read_str,
    1398                 :            :                                     src_buf, ptr1_align, false))
    1399                 :            :             break;
    1400                 :            : 
    1401                 :       2232 :           new_str_cst = build_string_literal (src_len, src_buf);
    1402                 :       2232 :           if (callee1)
    1403                 :            :             {
    1404                 :            :               /* If STMT1 is a mem{,p}cpy call, adjust it and remove
    1405                 :            :                  memset call.  */
    1406                 :       2114 :               if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY)
    1407                 :          6 :                 gimple_call_set_lhs (stmt1, NULL_TREE);
    1408                 :       2114 :               gimple_call_set_arg (stmt1, 1, new_str_cst);
    1409                 :       4228 :               gimple_call_set_arg (stmt1, 2,
    1410                 :       2114 :                                    build_int_cst (TREE_TYPE (len1), src_len));
    1411                 :       2114 :               update_stmt (stmt1);
    1412                 :       2114 :               unlink_stmt_vdef (stmt2);
    1413                 :       2114 :               gsi_replace (gsi_p, gimple_build_nop (), false);
    1414                 :       2114 :               fwprop_invalidate_lattice (gimple_get_lhs (stmt2));
    1415                 :       2114 :               release_defs (stmt2);
    1416                 :       2114 :               if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY)
    1417                 :            :                 {
    1418                 :          6 :                   fwprop_invalidate_lattice (lhs1);
    1419                 :          6 :                   release_ssa_name (lhs1);
    1420                 :            :                 }
    1421                 :       2232 :               return true;
    1422                 :            :             }
    1423                 :            :           else
    1424                 :            :             {
    1425                 :            :               /* Otherwise, if STMT1 is length 1 memcpy optimized into
    1426                 :            :                  assignment, remove STMT1 and change memset call into
    1427                 :            :                  memcpy call.  */
    1428                 :        118 :               gimple_stmt_iterator gsi = gsi_for_stmt (stmt1);
    1429                 :            : 
    1430                 :        118 :               if (!is_gimple_val (ptr1))
    1431                 :          6 :                 ptr1 = force_gimple_operand_gsi (gsi_p, ptr1, true, NULL_TREE,
    1432                 :            :                                                  true, GSI_SAME_STMT);
    1433                 :        118 :               tree fndecl = builtin_decl_explicit (BUILT_IN_MEMCPY);
    1434                 :        118 :               gimple_call_set_fndecl (stmt2, fndecl);
    1435                 :        236 :               gimple_call_set_fntype (as_a <gcall *> (stmt2),
    1436                 :        118 :                                       TREE_TYPE (fndecl));
    1437                 :        118 :               gimple_call_set_arg (stmt2, 0, ptr1);
    1438                 :        118 :               gimple_call_set_arg (stmt2, 1, new_str_cst);
    1439                 :        236 :               gimple_call_set_arg (stmt2, 2,
    1440                 :        118 :                                    build_int_cst (TREE_TYPE (len2), src_len));
    1441                 :        118 :               unlink_stmt_vdef (stmt1);
    1442                 :        118 :               gsi_remove (&gsi, true);
    1443                 :        118 :               fwprop_invalidate_lattice (gimple_get_lhs (stmt1));
    1444                 :        118 :               release_defs (stmt1);
    1445                 :        118 :               update_stmt (stmt2);
    1446                 :        118 :               return false;
    1447                 :            :             }
    1448                 :            :         }
    1449                 :            :       break;
    1450                 :            :     default:
    1451                 :            :       break;
    1452                 :            :     }
    1453                 :            :   return false;
    1454                 :            : }
    1455                 :            : 
    1456                 :            : /* Given a ssa_name in NAME see if it was defined by an assignment and
    1457                 :            :    set CODE to be the code and ARG1 to the first operand on the rhs and ARG2
    1458                 :            :    to the second operand on the rhs. */
    1459                 :            : 
    1460                 :            : static inline void
    1461                 :   10038600 : defcodefor_name (tree name, enum tree_code *code, tree *arg1, tree *arg2)
    1462                 :            : {
    1463                 :   10038600 :   gimple *def;
    1464                 :   10038600 :   enum tree_code code1;
    1465                 :   10038600 :   tree arg11;
    1466                 :   10038600 :   tree arg21;
    1467                 :   10038600 :   tree arg31;
    1468                 :   10038600 :   enum gimple_rhs_class grhs_class;
    1469                 :            : 
    1470                 :   10038600 :   code1 = TREE_CODE (name);
    1471                 :   10038600 :   arg11 = name;
    1472                 :   10038600 :   arg21 = NULL_TREE;
    1473                 :   10038600 :   arg31 = NULL_TREE;
    1474                 :   10038600 :   grhs_class = get_gimple_rhs_class (code1);
    1475                 :            : 
    1476                 :   10038600 :   if (code1 == SSA_NAME)
    1477                 :            :     {
    1478                 :    6710730 :       def = SSA_NAME_DEF_STMT (name);
    1479                 :            :       
    1480                 :    6710730 :       if (def && is_gimple_assign (def)
    1481                 :   10888000 :           && can_propagate_from (def))
    1482                 :            :         {
    1483                 :    2943340 :           code1 = gimple_assign_rhs_code (def);
    1484                 :    2943340 :           arg11 = gimple_assign_rhs1 (def);
    1485                 :    2943340 :           arg21 = gimple_assign_rhs2 (def);
    1486                 :    2943340 :           arg31 = gimple_assign_rhs3 (def);
    1487                 :            :         }
    1488                 :            :     }
    1489                 :    3327830 :   else if (grhs_class != GIMPLE_SINGLE_RHS)
    1490                 :          0 :     code1 = ERROR_MARK;
    1491                 :            : 
    1492                 :   10038600 :   *code = code1;
    1493                 :   10038600 :   *arg1 = arg11;
    1494                 :   10038600 :   if (arg2)
    1495                 :   10017500 :     *arg2 = arg21;
    1496                 :   10038600 :   if (arg31)
    1497                 :      11767 :     *code = ERROR_MARK;
    1498                 :   10038600 : }
    1499                 :            : 
    1500                 :            : 
    1501                 :            : /* Recognize rotation patterns.  Return true if a transformation
    1502                 :            :    applied, otherwise return false.
    1503                 :            : 
    1504                 :            :    We are looking for X with unsigned type T with bitsize B, OP being
    1505                 :            :    +, | or ^, some type T2 wider than T.  For:
    1506                 :            :    (X << CNT1) OP (X >> CNT2)                               iff CNT1 + CNT2 == B
    1507                 :            :    ((T) ((T2) X << CNT1)) OP ((T) ((T2) X >> CNT2)) iff CNT1 + CNT2 == B
    1508                 :            : 
    1509                 :            :    transform these into:
    1510                 :            :    X r<< CNT1
    1511                 :            : 
    1512                 :            :    Or for:
    1513                 :            :    (X << Y) OP (X >> (B - Y))
    1514                 :            :    (X << (int) Y) OP (X >> (int) (B - Y))
    1515                 :            :    ((T) ((T2) X << Y)) OP ((T) ((T2) X >> (B - Y)))
    1516                 :            :    ((T) ((T2) X << (int) Y)) OP ((T) ((T2) X >> (int) (B - Y)))
    1517                 :            :    (X << Y) | (X >> ((-Y) & (B - 1)))
    1518                 :            :    (X << (int) Y) | (X >> (int) ((-Y) & (B - 1)))
    1519                 :            :    ((T) ((T2) X << Y)) | ((T) ((T2) X >> ((-Y) & (B - 1))))
    1520                 :            :    ((T) ((T2) X << (int) Y)) | ((T) ((T2) X >> (int) ((-Y) & (B - 1))))
    1521                 :            : 
    1522                 :            :    transform these into:
    1523                 :            :    X r<< Y
    1524                 :            : 
    1525                 :            :    Or for:
    1526                 :            :    (X << (Y & (B - 1))) | (X >> ((-Y) & (B - 1)))
    1527                 :            :    (X << (int) (Y & (B - 1))) | (X >> (int) ((-Y) & (B - 1)))
    1528                 :            :    ((T) ((T2) X << (Y & (B - 1)))) | ((T) ((T2) X >> ((-Y) & (B - 1))))
    1529                 :            :    ((T) ((T2) X << (int) (Y & (B - 1)))) \
    1530                 :            :      | ((T) ((T2) X >> (int) ((-Y) & (B - 1))))
    1531                 :            : 
    1532                 :            :    transform these into:
    1533                 :            :    X r<< (Y & (B - 1))
    1534                 :            : 
    1535                 :            :    Note, in the patterns with T2 type, the type of OP operands
    1536                 :            :    might be even a signed type, but should have precision B.
    1537                 :            :    Expressions with & (B - 1) should be recognized only if B is
    1538                 :            :    a power of 2.  */
    1539                 :            : 
    1540                 :            : static bool
    1541                 :    5596470 : simplify_rotate (gimple_stmt_iterator *gsi)
    1542                 :            : {
    1543                 :    5596470 :   gimple *stmt = gsi_stmt (*gsi);
    1544                 :    5596470 :   tree arg[2], rtype, rotcnt = NULL_TREE;
    1545                 :    5596470 :   tree def_arg1[2], def_arg2[2];
    1546                 :    5596470 :   enum tree_code def_code[2];
    1547                 :    5596470 :   tree lhs;
    1548                 :    5596470 :   int i;
    1549                 :    5596470 :   bool swapped_p = false;
    1550                 :    5596470 :   gimple *g;
    1551                 :            : 
    1552                 :    5596470 :   arg[0] = gimple_assign_rhs1 (stmt);
    1553                 :    5596470 :   arg[1] = gimple_assign_rhs2 (stmt);
    1554                 :    5596470 :   rtype = TREE_TYPE (arg[0]);
    1555                 :            : 
    1556                 :            :   /* Only create rotates in complete modes.  Other cases are not
    1557                 :            :      expanded properly.  */
    1558                 :    5596470 :   if (!INTEGRAL_TYPE_P (rtype)
    1559                 :    5596470 :       || !type_has_mode_precision_p (rtype))
    1560                 :     614488 :     return false;
    1561                 :            : 
    1562                 :   14945900 :   for (i = 0; i < 2; i++)
    1563                 :    9963970 :     defcodefor_name (arg[i], &def_code[i], &def_arg1[i], &def_arg2[i]);
    1564                 :            : 
    1565                 :            :   /* Look through narrowing conversions.  */
    1566                 :    4981980 :   if (CONVERT_EXPR_CODE_P (def_code[0])
    1567                 :     552476 :       && CONVERT_EXPR_CODE_P (def_code[1])
    1568                 :      99151 :       && INTEGRAL_TYPE_P (TREE_TYPE (def_arg1[0]))
    1569                 :      95789 :       && INTEGRAL_TYPE_P (TREE_TYPE (def_arg1[1]))
    1570                 :      94427 :       && TYPE_PRECISION (TREE_TYPE (def_arg1[0]))
    1571                 :      94427 :          == TYPE_PRECISION (TREE_TYPE (def_arg1[1]))
    1572                 :      44695 :       && TYPE_PRECISION (TREE_TYPE (def_arg1[0])) > TYPE_PRECISION (rtype)
    1573                 :      13992 :       && has_single_use (arg[0])
    1574                 :    4995310 :       && has_single_use (arg[1]))
    1575                 :            :     {
    1576                 :      39711 :       for (i = 0; i < 2; i++)
    1577                 :            :         {
    1578                 :      26474 :           arg[i] = def_arg1[i];
    1579                 :      26474 :           defcodefor_name (arg[i], &def_code[i], &def_arg1[i], &def_arg2[i]);
    1580                 :            :         }
    1581                 :            :     }
    1582                 :            : 
    1583                 :            :   /* One operand has to be LSHIFT_EXPR and one RSHIFT_EXPR.  */
    1584                 :    5131320 :   for (i = 0; i < 2; i++)
    1585                 :    5105980 :     if (def_code[i] != LSHIFT_EXPR && def_code[i] != RSHIFT_EXPR)
    1586                 :            :       return false;
    1587                 :     165424 :     else if (!has_single_use (arg[i]))
    1588                 :            :       return false;
    1589                 :      25345 :   if (def_code[0] == def_code[1])
    1590                 :            :     return false;
    1591                 :            : 
    1592                 :            :   /* If we've looked through narrowing conversions before, look through
    1593                 :            :      widening conversions from unsigned type with the same precision
    1594                 :            :      as rtype here.  */
    1595                 :      21250 :   if (TYPE_PRECISION (TREE_TYPE (def_arg1[0])) != TYPE_PRECISION (rtype))
    1596                 :      25039 :     for (i = 0; i < 2; i++)
    1597                 :            :       {
    1598                 :      17034 :         tree tem;
    1599                 :      17034 :         enum tree_code code;
    1600                 :      17034 :         defcodefor_name (def_arg1[i], &code, &tem, NULL);
    1601                 :      17034 :         if (!CONVERT_EXPR_CODE_P (code)
    1602                 :      16028 :             || !INTEGRAL_TYPE_P (TREE_TYPE (tem))
    1603                 :      33062 :             || TYPE_PRECISION (TREE_TYPE (tem)) != TYPE_PRECISION (rtype))
    1604                 :       1024 :           return false;
    1605                 :      16010 :         def_arg1[i] = tem;
    1606                 :            :       }
    1607                 :            :   /* Both shifts have to use the same first operand.  */
    1608                 :      20226 :   if (!operand_equal_for_phi_arg_p (def_arg1[0], def_arg1[1])
    1609                 :      34858 :       || !types_compatible_p (TREE_TYPE (def_arg1[0]),
    1610                 :      14632 :                               TREE_TYPE (def_arg1[1])))
    1611                 :       5594 :     return false;
    1612                 :      14632 :   if (!TYPE_UNSIGNED (TREE_TYPE (def_arg1[0])))
    1613                 :            :     return false;
    1614                 :            : 
    1615                 :            :   /* CNT1 + CNT2 == B case above.  */
    1616                 :      12907 :   if (tree_fits_uhwi_p (def_arg2[0])
    1617                 :        983 :       && tree_fits_uhwi_p (def_arg2[1])
    1618                 :      12907 :       && tree_to_uhwi (def_arg2[0])
    1619                 :        983 :          + tree_to_uhwi (def_arg2[1]) == TYPE_PRECISION (rtype))
    1620                 :            :     rotcnt = def_arg2[0];
    1621                 :      12255 :   else if (TREE_CODE (def_arg2[0]) != SSA_NAME
    1622                 :      11924 :            || TREE_CODE (def_arg2[1]) != SSA_NAME)
    1623                 :            :     return false;
    1624                 :            :   else
    1625                 :            :     {
    1626                 :            :       tree cdef_arg1[2], cdef_arg2[2], def_arg2_alt[2];
    1627                 :            :       enum tree_code cdef_code[2];
    1628                 :            :       /* Look through conversion of the shift count argument.
    1629                 :            :          The C/C++ FE cast any shift count argument to integer_type_node.
    1630                 :            :          The only problem might be if the shift count type maximum value
    1631                 :            :          is equal or smaller than number of bits in rtype.  */
    1632                 :      35772 :       for (i = 0; i < 2; i++)
    1633                 :            :         {
    1634                 :      23848 :           def_arg2_alt[i] = def_arg2[i];
    1635                 :      23848 :           defcodefor_name (def_arg2[i], &cdef_code[i],
    1636                 :            :                            &cdef_arg1[i], &cdef_arg2[i]);
    1637                 :      23848 :           if (CONVERT_EXPR_CODE_P (cdef_code[i])
    1638                 :       3170 :               && INTEGRAL_TYPE_P (TREE_TYPE (cdef_arg1[i]))
    1639                 :       3170 :               && TYPE_PRECISION (TREE_TYPE (cdef_arg1[i]))
    1640                 :       6340 :                  > floor_log2 (TYPE_PRECISION (rtype))
    1641                 :      27018 :               && type_has_mode_precision_p (TREE_TYPE (cdef_arg1[i])))
    1642                 :            :             {
    1643                 :       3170 :               def_arg2_alt[i] = cdef_arg1[i];
    1644                 :       3170 :               defcodefor_name (def_arg2_alt[i], &cdef_code[i],
    1645                 :            :                                &cdef_arg1[i], &cdef_arg2[i]);
    1646                 :            :             }
    1647                 :            :         }
    1648                 :      33352 :       for (i = 0; i < 2; i++)
    1649                 :            :         /* Check for one shift count being Y and the other B - Y,
    1650                 :            :            with optional casts.  */
    1651                 :      23432 :         if (cdef_code[i] == MINUS_EXPR
    1652                 :        978 :             && tree_fits_shwi_p (cdef_arg1[i])
    1653                 :        978 :             && tree_to_shwi (cdef_arg1[i]) == TYPE_PRECISION (rtype)
    1654                 :      24344 :             && TREE_CODE (cdef_arg2[i]) == SSA_NAME)
    1655                 :            :           {
    1656                 :        912 :             tree tem;
    1657                 :        912 :             enum tree_code code;
    1658                 :            : 
    1659                 :        912 :             if (cdef_arg2[i] == def_arg2[1 - i]
    1660                 :        546 :                 || cdef_arg2[i] == def_arg2_alt[1 - i])
    1661                 :            :               {
    1662                 :            :                 rotcnt = cdef_arg2[i];
    1663                 :        912 :                 break;
    1664                 :            :               }
    1665                 :        546 :             defcodefor_name (cdef_arg2[i], &code, &tem, NULL);
    1666                 :        546 :             if (CONVERT_EXPR_CODE_P (code)
    1667                 :        546 :                 && INTEGRAL_TYPE_P (TREE_TYPE (tem))
    1668                 :        546 :                 && TYPE_PRECISION (TREE_TYPE (tem))
    1669                 :       1092 :                  > floor_log2 (TYPE_PRECISION (rtype))
    1670                 :        546 :                 && type_has_mode_precision_p (TREE_TYPE (tem))
    1671                 :       1092 :                 && (tem == def_arg2[1 - i]
    1672                 :        360 :                     || tem == def_arg2_alt[1 - i]))
    1673                 :            :               {
    1674                 :            :                 rotcnt = tem;
    1675                 :            :                 break;
    1676                 :            :               }
    1677                 :            :           }
    1678                 :            :         /* The above sequence isn't safe for Y being 0,
    1679                 :            :            because then one of the shifts triggers undefined behavior.
    1680                 :            :            This alternative is safe even for rotation count of 0.
    1681                 :            :            One shift count is Y and the other (-Y) & (B - 1).
    1682                 :            :            Or one shift count is Y & (B - 1) and the other (-Y) & (B - 1).  */
    1683                 :      22520 :         else if (cdef_code[i] == BIT_AND_EXPR
    1684                 :      37464 :                  && pow2p_hwi (TYPE_PRECISION (rtype))
    1685                 :      16036 :                  && tree_fits_shwi_p (cdef_arg2[i])
    1686                 :      16036 :                  && tree_to_shwi (cdef_arg2[i])
    1687                 :      16036 :                     == TYPE_PRECISION (rtype) - 1
    1688                 :      15955 :                  && TREE_CODE (cdef_arg1[i]) == SSA_NAME
    1689                 :      38475 :                  && gimple_assign_rhs_code (stmt) == BIT_IOR_EXPR)
    1690                 :            :           {
    1691                 :       2025 :             tree tem;
    1692                 :       2025 :             enum tree_code code;
    1693                 :            : 
    1694                 :       2025 :             defcodefor_name (cdef_arg1[i], &code, &tem, NULL);
    1695                 :       2025 :             if (CONVERT_EXPR_CODE_P (code)
    1696                 :        470 :                 && INTEGRAL_TYPE_P (TREE_TYPE (tem))
    1697                 :        470 :                 && TYPE_PRECISION (TREE_TYPE (tem))
    1698                 :        940 :                  > floor_log2 (TYPE_PRECISION (rtype))
    1699                 :       2495 :                 && type_has_mode_precision_p (TREE_TYPE (tem)))
    1700                 :        470 :               defcodefor_name (tem, &code, &tem, NULL);
    1701                 :            : 
    1702                 :       2025 :             if (code == NEGATE_EXPR)
    1703                 :            :               {
    1704                 :       1097 :                 if (tem == def_arg2[1 - i] || tem == def_arg2_alt[1 - i])
    1705                 :            :                   {
    1706                 :            :                     rotcnt = tem;
    1707                 :       1092 :                     break;
    1708                 :            :                   }
    1709                 :        727 :                 tree tem2;
    1710                 :        727 :                 defcodefor_name (tem, &code, &tem2, NULL);
    1711                 :        727 :                 if (CONVERT_EXPR_CODE_P (code)
    1712                 :        466 :                     && INTEGRAL_TYPE_P (TREE_TYPE (tem2))
    1713                 :        466 :                     && TYPE_PRECISION (TREE_TYPE (tem2))
    1714                 :        932 :                        > floor_log2 (TYPE_PRECISION (rtype))
    1715                 :       1193 :                     && type_has_mode_precision_p (TREE_TYPE (tem2)))
    1716                 :            :                   {
    1717                 :        466 :                     if (tem2 == def_arg2[1 - i]
    1718                 :        466 :                         || tem2 == def_arg2_alt[1 - i])
    1719                 :            :                       {
    1720                 :            :                         rotcnt = tem2;
    1721                 :            :                         break;
    1722                 :            :                       }
    1723                 :            :                   }
    1724                 :            :                 else
    1725                 :        261 :                   tem2 = NULL_TREE;
    1726                 :            : 
    1727                 :        522 :                 if (cdef_code[1 - i] == BIT_AND_EXPR
    1728                 :        518 :                     && tree_fits_shwi_p (cdef_arg2[1 - i])
    1729                 :        518 :                     && tree_to_shwi (cdef_arg2[1 - i])
    1730                 :        518 :                        == TYPE_PRECISION (rtype) - 1
    1731                 :       1040 :                     && TREE_CODE (cdef_arg1[1 - i]) == SSA_NAME)
    1732                 :            :                   {
    1733                 :        518 :                     if (tem == cdef_arg1[1 - i]
    1734                 :        317 :                         || tem2 == cdef_arg1[1 - i])
    1735                 :            :                       {
    1736                 :        217 :                         rotcnt = def_arg2[1 - i];
    1737                 :        517 :                         break;
    1738                 :            :                       }
    1739                 :        301 :                     tree tem3;
    1740                 :        301 :                     defcodefor_name (cdef_arg1[1 - i], &code, &tem3, NULL);
    1741                 :        301 :                     if (CONVERT_EXPR_CODE_P (code)
    1742                 :        300 :                         && INTEGRAL_TYPE_P (TREE_TYPE (tem3))
    1743                 :        300 :                         && TYPE_PRECISION (TREE_TYPE (tem3))
    1744                 :        600 :                            > floor_log2 (TYPE_PRECISION (rtype))
    1745                 :        601 :                         && type_has_mode_precision_p (TREE_TYPE (tem3)))
    1746                 :            :                       {
    1747                 :        300 :                         if (tem == tem3 || tem2 == tem3)
    1748                 :            :                           {
    1749                 :        300 :                             rotcnt = def_arg2[1 - i];
    1750                 :        300 :                             break;
    1751                 :            :                           }
    1752                 :            :                       }
    1753                 :            :                   }
    1754                 :            :               }
    1755                 :            :           }
    1756                 :      11924 :       if (rotcnt == NULL_TREE)
    1757                 :       9920 :         return false;
    1758                 :       2004 :       swapped_p = i != 1;
    1759                 :            :     }
    1760                 :            : 
    1761                 :       5312 :   if (!useless_type_conversion_p (TREE_TYPE (def_arg2[0]),
    1762                 :       2656 :                                   TREE_TYPE (rotcnt)))
    1763                 :            :     {
    1764                 :        620 :       g = gimple_build_assign (make_ssa_name (TREE_TYPE (def_arg2[0])),
    1765                 :            :                                NOP_EXPR, rotcnt);
    1766                 :        620 :       gsi_insert_before (gsi, g, GSI_SAME_STMT);
    1767                 :        620 :       rotcnt = gimple_assign_lhs (g);
    1768                 :            :     }
    1769                 :       2656 :   lhs = gimple_assign_lhs (stmt);
    1770                 :       2656 :   if (!useless_type_conversion_p (rtype, TREE_TYPE (def_arg1[0])))
    1771                 :       1208 :     lhs = make_ssa_name (TREE_TYPE (def_arg1[0]));
    1772                 :       2656 :   g = gimple_build_assign (lhs,
    1773                 :       2656 :                            ((def_code[0] == LSHIFT_EXPR) ^ swapped_p)
    1774                 :            :                            ? LROTATE_EXPR : RROTATE_EXPR, def_arg1[0], rotcnt);
    1775                 :       2656 :   if (!useless_type_conversion_p (rtype, TREE_TYPE (def_arg1[0])))
    1776                 :            :     {
    1777                 :       1208 :       gsi_insert_before (gsi, g, GSI_SAME_STMT);
    1778                 :       1208 :       g = gimple_build_assign (gimple_assign_lhs (stmt), NOP_EXPR, lhs);
    1779                 :            :     }
    1780                 :       2656 :   gsi_replace (gsi, g, false);
    1781                 :       2656 :   return true;
    1782                 :            : }
    1783                 :            : 
    1784                 :            : 
    1785                 :            : /* Check whether an array contains a valid ctz table.  */
    1786                 :            : static bool
    1787                 :          6 : check_ctz_array (tree ctor, unsigned HOST_WIDE_INT mulc,
    1788                 :            :                  HOST_WIDE_INT &zero_val, unsigned shift, unsigned bits)
    1789                 :            : {
    1790                 :          6 :   tree elt, idx;
    1791                 :          6 :   unsigned HOST_WIDE_INT i, mask;
    1792                 :          6 :   unsigned matched = 0;
    1793                 :            : 
    1794                 :          6 :   mask = ((HOST_WIDE_INT_1U << (bits - shift)) - 1) << shift;
    1795                 :            : 
    1796                 :          6 :   zero_val = 0;
    1797                 :            : 
    1798                 :        570 :   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), i, idx, elt)
    1799                 :            :     {
    1800                 :        285 :       if (TREE_CODE (idx) != INTEGER_CST || TREE_CODE (elt) != INTEGER_CST)
    1801                 :            :         return false;
    1802                 :        285 :       if (i > bits * 2)
    1803                 :            :         return false;
    1804                 :            : 
    1805                 :        285 :       unsigned HOST_WIDE_INT index = tree_to_shwi (idx);
    1806                 :        285 :       HOST_WIDE_INT val = tree_to_shwi (elt);
    1807                 :            : 
    1808                 :        285 :       if (index == 0)
    1809                 :            :         {
    1810                 :          6 :           zero_val = val;
    1811                 :          6 :           matched++;
    1812                 :            :         }
    1813                 :            : 
    1814                 :        285 :       if (val >= 0 && val < bits && (((mulc << val) & mask) >> shift) == index)
    1815                 :        192 :         matched++;
    1816                 :            : 
    1817                 :        285 :       if (matched > bits)
    1818                 :            :         return true;
    1819                 :            :     }
    1820                 :            : 
    1821                 :            :   return false;
    1822                 :            : }
    1823                 :            : 
    1824                 :            : /* Check whether a string contains a valid ctz table.  */
    1825                 :            : static bool
    1826                 :          8 : check_ctz_string (tree string, unsigned HOST_WIDE_INT mulc,
    1827                 :            :                   HOST_WIDE_INT &zero_val, unsigned shift, unsigned bits)
    1828                 :            : {
    1829                 :          8 :   unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (string);
    1830                 :          8 :   unsigned HOST_WIDE_INT mask;
    1831                 :          8 :   unsigned matched = 0;
    1832                 :          8 :   const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (string);
    1833                 :            : 
    1834                 :          8 :   if (len < bits || len > bits * 2)
    1835                 :            :     return false;
    1836                 :            : 
    1837                 :          8 :   mask = ((HOST_WIDE_INT_1U << (bits - shift)) - 1) << shift;
    1838                 :            : 
    1839                 :          8 :   zero_val = p[0];
    1840                 :            : 
    1841                 :        392 :   for (unsigned i = 0; i < len; i++)
    1842                 :        384 :     if (p[i] < bits && (((mulc << p[i]) & mask) >> shift) == i)
    1843                 :        384 :       matched++;
    1844                 :            : 
    1845                 :          8 :   return matched == bits;
    1846                 :            : }
    1847                 :            : 
    1848                 :            : /* Recognize count trailing zeroes idiom.
    1849                 :            :    The canonical form is array[((x & -x) * C) >> SHIFT] where C is a magic
    1850                 :            :    constant which when multiplied by a power of 2 creates a unique value
    1851                 :            :    in the top 5 or 6 bits.  This is then indexed into a table which maps it
    1852                 :            :    to the number of trailing zeroes.  Array[0] is returned so the caller can
    1853                 :            :    emit an appropriate sequence depending on whether ctz (0) is defined on
    1854                 :            :    the target.  */
    1855                 :            : static bool
    1856                 :         28 : optimize_count_trailing_zeroes (tree array_ref, tree x, tree mulc,
    1857                 :            :                                 tree tshift, HOST_WIDE_INT &zero_val)
    1858                 :            : {
    1859                 :         28 :   tree type = TREE_TYPE (array_ref);
    1860                 :         28 :   tree array = TREE_OPERAND (array_ref, 0);
    1861                 :            : 
    1862                 :         28 :   gcc_assert (TREE_CODE (mulc) == INTEGER_CST);
    1863                 :         28 :   gcc_assert (TREE_CODE (tshift) == INTEGER_CST);
    1864                 :            : 
    1865                 :         28 :   tree input_type = TREE_TYPE (x);
    1866                 :         28 :   unsigned input_bits = tree_to_shwi (TYPE_SIZE (input_type));
    1867                 :            : 
    1868                 :            :   /* Check the array element type is not wider than 32 bits and the input is
    1869                 :            :      an unsigned 32-bit or 64-bit type.  */
    1870                 :         28 :   if (TYPE_PRECISION (type) > 32 || !TYPE_UNSIGNED (input_type))
    1871                 :            :     return false;
    1872                 :         24 :   if (input_bits != 32 && input_bits != 64)
    1873                 :            :     return false;
    1874                 :            : 
    1875                 :         24 :   if (!direct_internal_fn_supported_p (IFN_CTZ, input_type, OPTIMIZE_FOR_BOTH))
    1876                 :            :     return false;
    1877                 :            : 
    1878                 :            :   /* Check the lower bound of the array is zero.  */
    1879                 :         24 :   tree low = array_ref_low_bound (array_ref);
    1880                 :         24 :   if (!low || !integer_zerop (low))
    1881                 :          0 :     return false;
    1882                 :            : 
    1883                 :         24 :   unsigned shiftval = tree_to_shwi (tshift);
    1884                 :            : 
    1885                 :            :   /* Check the shift extracts the top 5..7 bits.  */
    1886                 :         24 :   if (shiftval < input_bits - 7 || shiftval > input_bits - 5)
    1887                 :            :     return false;
    1888                 :            : 
    1889                 :         20 :   tree ctor = ctor_for_folding (array);
    1890                 :         20 :   if (!ctor)
    1891                 :            :     return false;
    1892                 :            : 
    1893                 :         20 :   unsigned HOST_WIDE_INT val = tree_to_uhwi (mulc);
    1894                 :            : 
    1895                 :         20 :   if (TREE_CODE (ctor) == CONSTRUCTOR)
    1896                 :          6 :     return check_ctz_array (ctor, val, zero_val, shiftval, input_bits);
    1897                 :            : 
    1898                 :         14 :   if (TREE_CODE (ctor) == STRING_CST
    1899                 :         26 :       && TYPE_PRECISION (type) == CHAR_TYPE_SIZE)
    1900                 :          8 :     return check_ctz_string (ctor, val, zero_val, shiftval, input_bits);
    1901                 :            : 
    1902                 :            :   return false;
    1903                 :            : }
    1904                 :            : 
    1905                 :            : /* Match.pd function to match the ctz expression.  */
    1906                 :            : extern bool gimple_ctz_table_index (tree, tree *, tree (*)(tree));
    1907                 :            : 
    1908                 :            : static bool
    1909                 :    1333730 : simplify_count_trailing_zeroes (gimple_stmt_iterator *gsi)
    1910                 :            : {
    1911                 :    1333730 :   gimple *stmt = gsi_stmt (*gsi);
    1912                 :    1333730 :   tree array_ref = gimple_assign_rhs1 (stmt);
    1913                 :    1333730 :   tree res_ops[3];
    1914                 :    1333730 :   HOST_WIDE_INT zero_val;
    1915                 :            : 
    1916                 :    1333730 :   gcc_checking_assert (TREE_CODE (array_ref) == ARRAY_REF);
    1917                 :            : 
    1918                 :    1333730 :   if (!gimple_ctz_table_index (TREE_OPERAND (array_ref, 1), &res_ops[0], NULL))
    1919                 :            :     return false;
    1920                 :            : 
    1921                 :         28 :   if (optimize_count_trailing_zeroes (array_ref, res_ops[0],
    1922                 :            :                                       res_ops[1], res_ops[2], zero_val))
    1923                 :            :     {
    1924                 :         14 :       tree type = TREE_TYPE (res_ops[0]);
    1925                 :         14 :       HOST_WIDE_INT ctz_val = 0;
    1926                 :         14 :       HOST_WIDE_INT type_size = tree_to_shwi (TYPE_SIZE (type));
    1927                 :         14 :       bool zero_ok
    1928                 :         14 :         = CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (type), ctz_val) == 2;
    1929                 :            : 
    1930                 :            :       /* If the input value can't be zero, don't special case ctz (0).  */
    1931                 :         14 :       if (tree_expr_nonzero_p (res_ops[0]))
    1932                 :            :         {
    1933                 :          0 :           zero_ok = true;
    1934                 :          0 :           zero_val = 0;
    1935                 :          0 :           ctz_val = 0;
    1936                 :            :         }
    1937                 :            : 
    1938                 :            :       /* Skip if there is no value defined at zero, or if we can't easily
    1939                 :            :          return the correct value for zero.  */
    1940                 :         14 :       if (!zero_ok)
    1941                 :            :         return false;
    1942                 :          0 :       if (zero_val != ctz_val && !(zero_val == 0 && ctz_val == type_size))
    1943                 :            :         return false;
    1944                 :            : 
    1945                 :          0 :       gimple_seq seq = NULL;
    1946                 :          0 :       gimple *g;
    1947                 :          0 :       gcall *call = gimple_build_call_internal (IFN_CTZ, 1, res_ops[0]);
    1948                 :          0 :       gimple_set_location (call, gimple_location (stmt));
    1949                 :          0 :       gimple_set_lhs (call, make_ssa_name (integer_type_node));
    1950                 :          0 :       gimple_seq_add_stmt (&seq, call);
    1951                 :            : 
    1952                 :          0 :       tree prev_lhs = gimple_call_lhs (call);
    1953                 :            : 
    1954                 :            :       /* Emit ctz (x) & 31 if ctz (0) is 32 but we need to return 0.  */
    1955                 :          0 :       if (zero_val == 0 && ctz_val == type_size)
    1956                 :            :         {
    1957                 :          0 :           g = gimple_build_assign (make_ssa_name (integer_type_node),
    1958                 :            :                                    BIT_AND_EXPR, prev_lhs,
    1959                 :            :                                    build_int_cst (integer_type_node,
    1960                 :          0 :                                                   type_size - 1));
    1961                 :          0 :           gimple_set_location (g, gimple_location (stmt));
    1962                 :          0 :           gimple_seq_add_stmt (&seq, g);
    1963                 :          0 :           prev_lhs = gimple_assign_lhs (g);
    1964                 :            :         }
    1965                 :            : 
    1966                 :          0 :       g = gimple_build_assign (gimple_assign_lhs (stmt), NOP_EXPR, prev_lhs);
    1967                 :          0 :       gimple_seq_add_stmt (&seq, g);
    1968                 :          0 :       gsi_replace_with_seq (gsi, seq, true);
    1969                 :          0 :       return true;
    1970                 :            :     }
    1971                 :            : 
    1972                 :            :   return false;
    1973                 :            : }
    1974                 :            : 
    1975                 :            : 
    1976                 :            : /* Combine an element access with a shuffle.  Returns true if there were
    1977                 :            :    any changes made, else it returns false.  */
    1978                 :            :  
    1979                 :            : static bool
    1980                 :     140877 : simplify_bitfield_ref (gimple_stmt_iterator *gsi)
    1981                 :            : {
    1982                 :     140877 :   gimple *stmt = gsi_stmt (*gsi);
    1983                 :     140877 :   gimple *def_stmt;
    1984                 :     140877 :   tree op, op0, op1;
    1985                 :     140877 :   tree elem_type;
    1986                 :     140877 :   unsigned idx, size;
    1987                 :     140877 :   enum tree_code code;
    1988                 :            : 
    1989                 :     140877 :   op = gimple_assign_rhs1 (stmt);
    1990                 :     140877 :   gcc_checking_assert (TREE_CODE (op) == BIT_FIELD_REF);
    1991                 :            : 
    1992                 :     140877 :   op0 = TREE_OPERAND (op, 0);
    1993                 :     140877 :   if (TREE_CODE (op0) != SSA_NAME
    1994                 :     213300 :       || TREE_CODE (TREE_TYPE (op0)) != VECTOR_TYPE)
    1995                 :            :     return false;
    1996                 :            : 
    1997                 :      66367 :   def_stmt = get_prop_source_stmt (op0, false, NULL);
    1998                 :      66367 :   if (!def_stmt || !can_propagate_from (def_stmt))
    1999                 :      31970 :     return false;
    2000                 :            : 
    2001                 :      34397 :   op1 = TREE_OPERAND (op, 1);
    2002                 :      34397 :   code = gimple_assign_rhs_code (def_stmt);
    2003                 :      34397 :   elem_type = TREE_TYPE (TREE_TYPE (op0));
    2004                 :      34397 :   if (TREE_TYPE (op) != elem_type)
    2005                 :            :     return false;
    2006                 :            : 
    2007                 :      25097 :   size = TREE_INT_CST_LOW (TYPE_SIZE (elem_type));
    2008                 :      25097 :   if (maybe_ne (bit_field_size (op), size))
    2009                 :            :     return false;
    2010                 :            : 
    2011                 :      25097 :   if (code == VEC_PERM_EXPR
    2012                 :      25097 :       && constant_multiple_p (bit_field_offset (op), size, &idx))
    2013                 :            :     {
    2014                 :       9842 :       tree p, m, tem;
    2015                 :       9842 :       unsigned HOST_WIDE_INT nelts;
    2016                 :       9842 :       m = gimple_assign_rhs3 (def_stmt);
    2017                 :       9842 :       if (TREE_CODE (m) != VECTOR_CST
    2018                 :      19684 :           || !VECTOR_CST_NELTS (m).is_constant (&nelts))
    2019                 :          0 :         return false;
    2020                 :       9842 :       idx = TREE_INT_CST_LOW (VECTOR_CST_ELT (m, idx));
    2021                 :       9842 :       idx %= 2 * nelts;
    2022                 :       9842 :       if (idx < nelts)
    2023                 :            :         {
    2024                 :       5076 :           p = gimple_assign_rhs1 (def_stmt);
    2025                 :            :         }
    2026                 :            :       else
    2027                 :            :         {
    2028                 :       4766 :           p = gimple_assign_rhs2 (def_stmt);
    2029                 :       4766 :           idx -= nelts;
    2030                 :            :         }
    2031                 :       9842 :       tem = build3 (BIT_FIELD_REF, TREE_TYPE (op),
    2032                 :       9842 :                     unshare_expr (p), op1, bitsize_int (idx * size));
    2033                 :       9842 :       gimple_assign_set_rhs1 (stmt, tem);
    2034                 :       9842 :       fold_stmt (gsi);
    2035                 :       9842 :       update_stmt (gsi_stmt (*gsi));
    2036                 :       9842 :       return true;
    2037                 :            :     }
    2038                 :            : 
    2039                 :            :   return false;
    2040                 :            : }
    2041                 :            : 
    2042                 :            : /* Determine whether applying the 2 permutations (mask1 then mask2)
    2043                 :            :    gives back one of the input.  */
    2044                 :            : 
    2045                 :            : static int
    2046                 :         55 : is_combined_permutation_identity (tree mask1, tree mask2)
    2047                 :            : {
    2048                 :         55 :   tree mask;
    2049                 :         55 :   unsigned HOST_WIDE_INT nelts, i, j;
    2050                 :         55 :   bool maybe_identity1 = true;
    2051                 :         55 :   bool maybe_identity2 = true;
    2052                 :            : 
    2053                 :         55 :   gcc_checking_assert (TREE_CODE (mask1) == VECTOR_CST
    2054                 :            :                        && TREE_CODE (mask2) == VECTOR_CST);
    2055                 :         55 :   mask = fold_ternary (VEC_PERM_EXPR, TREE_TYPE (mask1), mask1, mask1, mask2);
    2056                 :         55 :   if (mask == NULL_TREE || TREE_CODE (mask) != VECTOR_CST)
    2057                 :            :     return 0;
    2058                 :            : 
    2059                 :         55 :   if (!VECTOR_CST_NELTS (mask).is_constant (&nelts))
    2060                 :            :     return 0;
    2061                 :        167 :   for (i = 0; i < nelts; i++)
    2062                 :            :     {
    2063                 :        143 :       tree val = VECTOR_CST_ELT (mask, i);
    2064                 :        143 :       gcc_assert (TREE_CODE (val) == INTEGER_CST);
    2065                 :        143 :       j = TREE_INT_CST_LOW (val) & (2 * nelts - 1);
    2066                 :        143 :       if (j == i)
    2067                 :            :         maybe_identity2 = false;
    2068                 :         48 :       else if (j == i + nelts)
    2069                 :            :         maybe_identity1 = false;
    2070                 :            :       else
    2071                 :            :         return 0;
    2072                 :            :     }
    2073                 :         24 :   return maybe_identity1 ? 1 : maybe_identity2 ? 2 : 0;
    2074                 :            : }
    2075                 :            : 
    2076                 :            : /* Combine a shuffle with its arguments.  Returns 1 if there were any
    2077                 :            :    changes made, 2 if cfg-cleanup needs to run.  Else it returns 0.  */
    2078                 :            :  
    2079                 :            : static int
    2080                 :      96575 : simplify_permutation (gimple_stmt_iterator *gsi)
    2081                 :            : {
    2082                 :      96575 :   gimple *stmt = gsi_stmt (*gsi);
    2083                 :      96575 :   gimple *def_stmt;
    2084                 :      96575 :   tree op0, op1, op2, op3, arg0, arg1;
    2085                 :      96575 :   enum tree_code code;
    2086                 :      96575 :   bool single_use_op0 = false;
    2087                 :            : 
    2088                 :      96575 :   gcc_checking_assert (gimple_assign_rhs_code (stmt) == VEC_PERM_EXPR);
    2089                 :            : 
    2090                 :      96575 :   op0 = gimple_assign_rhs1 (stmt);
    2091                 :      96575 :   op1 = gimple_assign_rhs2 (stmt);
    2092                 :      96575 :   op2 = gimple_assign_rhs3 (stmt);
    2093                 :            : 
    2094                 :      96575 :   if (TREE_CODE (op2) != VECTOR_CST)
    2095                 :            :     return 0;
    2096                 :            : 
    2097                 :      94050 :   if (TREE_CODE (op0) == VECTOR_CST)
    2098                 :            :     {
    2099                 :            :       code = VECTOR_CST;
    2100                 :            :       arg0 = op0;
    2101                 :            :     }
    2102                 :      92614 :   else if (TREE_CODE (op0) == SSA_NAME)
    2103                 :            :     {
    2104                 :      92614 :       def_stmt = get_prop_source_stmt (op0, false, &single_use_op0);
    2105                 :      92614 :       if (!def_stmt || !can_propagate_from (def_stmt))
    2106                 :      80312 :         return 0;
    2107                 :            : 
    2108                 :      12302 :       code = gimple_assign_rhs_code (def_stmt);
    2109                 :      12302 :       arg0 = gimple_assign_rhs1 (def_stmt);
    2110                 :            :     }
    2111                 :            :   else
    2112                 :            :     return 0;
    2113                 :            : 
    2114                 :            :   /* Two consecutive shuffles.  */
    2115                 :      13738 :   if (code == VEC_PERM_EXPR)
    2116                 :            :     {
    2117                 :       2504 :       tree orig;
    2118                 :       2504 :       int ident;
    2119                 :            : 
    2120                 :       2504 :       if (op0 != op1)
    2121                 :            :         return 0;
    2122                 :         55 :       op3 = gimple_assign_rhs3 (def_stmt);
    2123                 :         55 :       if (TREE_CODE (op3) != VECTOR_CST)
    2124                 :            :         return 0;
    2125                 :         55 :       ident = is_combined_permutation_identity (op3, op2);
    2126                 :         55 :       if (!ident)
    2127                 :            :         return 0;
    2128                 :         46 :       orig = (ident == 1) ? gimple_assign_rhs1 (def_stmt)
    2129                 :          0 :                           : gimple_assign_rhs2 (def_stmt);
    2130                 :         23 :       gimple_assign_set_rhs1 (stmt, unshare_expr (orig));
    2131                 :         23 :       gimple_assign_set_rhs_code (stmt, TREE_CODE (orig));
    2132                 :         23 :       gimple_set_num_ops (stmt, 2);
    2133                 :         23 :       update_stmt (stmt);
    2134                 :         23 :       return remove_prop_source_from_use (op0) ? 2 : 1;
    2135                 :            :     }
    2136                 :            : 
    2137                 :            :   /* Shuffle of a constructor.  */
    2138                 :      11234 :   else if (code == CONSTRUCTOR || code == VECTOR_CST)
    2139                 :            :     {
    2140                 :       1573 :       tree opt;
    2141                 :       1573 :       bool ret = false;
    2142                 :       1573 :       if (op0 != op1)
    2143                 :            :         {
    2144                 :       1483 :           if (TREE_CODE (op0) == SSA_NAME && !single_use_op0)
    2145                 :            :             return 0;
    2146                 :            : 
    2147                 :       1473 :           if (TREE_CODE (op1) == VECTOR_CST)
    2148                 :            :             arg1 = op1;
    2149                 :       1332 :           else if (TREE_CODE (op1) == SSA_NAME)
    2150                 :            :             {
    2151                 :       1332 :               enum tree_code code2;
    2152                 :            : 
    2153                 :       1332 :               gimple *def_stmt2 = get_prop_source_stmt (op1, true, NULL);
    2154                 :       1332 :               if (!def_stmt2 || !can_propagate_from (def_stmt2))
    2155                 :       1220 :                 return 0;
    2156                 :            : 
    2157                 :        112 :               code2 = gimple_assign_rhs_code (def_stmt2);
    2158                 :        112 :               if (code2 != CONSTRUCTOR && code2 != VECTOR_CST)
    2159                 :            :                 return 0;
    2160                 :         37 :               arg1 = gimple_assign_rhs1 (def_stmt2);
    2161                 :            :             }
    2162                 :            :           else
    2163                 :            :             return 0;
    2164                 :            :         }
    2165                 :            :       else
    2166                 :            :         {
    2167                 :            :           /* Already used twice in this statement.  */
    2168                 :         90 :           if (TREE_CODE (op0) == SSA_NAME && num_imm_uses (op0) > 2)
    2169                 :            :             return 0;
    2170                 :            :           arg1 = arg0;
    2171                 :            :         }
    2172                 :        194 :       opt = fold_ternary (VEC_PERM_EXPR, TREE_TYPE (op0), arg0, arg1, op2);
    2173                 :        194 :       if (!opt
    2174                 :         14 :           || (TREE_CODE (opt) != CONSTRUCTOR && TREE_CODE (opt) != VECTOR_CST))
    2175                 :            :         return 0;
    2176                 :         14 :       gimple_assign_set_rhs_from_tree (gsi, opt);
    2177                 :         14 :       update_stmt (gsi_stmt (*gsi));
    2178                 :         14 :       if (TREE_CODE (op0) == SSA_NAME)
    2179                 :         14 :         ret = remove_prop_source_from_use (op0);
    2180                 :         14 :       if (op0 != op1 && TREE_CODE (op1) == SSA_NAME)
    2181                 :          0 :         ret |= remove_prop_source_from_use (op1);
    2182                 :         28 :       return ret ? 2 : 1;
    2183                 :            :     }
    2184                 :            : 
    2185                 :            :   return 0;
    2186                 :            : }
    2187                 :            : 
    2188                 :            : /* Get the BIT_FIELD_REF definition of VAL, if any, looking through
    2189                 :            :    conversions with code CONV_CODE or update it if still ERROR_MARK.
    2190                 :            :    Return NULL_TREE if no such matching def was found.  */
    2191                 :            : 
    2192                 :            : static tree
    2193                 :      88957 : get_bit_field_ref_def (tree val, enum tree_code &conv_code)
    2194                 :            : {
    2195                 :      88957 :   if (TREE_CODE (val) != SSA_NAME)
    2196                 :            :     return NULL_TREE ;
    2197                 :      77363 :   gimple *def_stmt = get_prop_source_stmt (val, false, NULL);
    2198                 :      77363 :   if (!def_stmt)
    2199                 :            :     return NULL_TREE;
    2200                 :      44738 :   enum tree_code code = gimple_assign_rhs_code (def_stmt);
    2201                 :      44738 :   if (code == FLOAT_EXPR
    2202                 :      44738 :       || code == FIX_TRUNC_EXPR
    2203                 :      44103 :       || CONVERT_EXPR_CODE_P (code))
    2204                 :            :     {
    2205                 :      15090 :       tree op1 = gimple_assign_rhs1 (def_stmt);
    2206                 :      15090 :       if (conv_code == ERROR_MARK)
    2207                 :       6369 :         conv_code = code;
    2208                 :       8721 :       else if (conv_code != code)
    2209                 :            :         return NULL_TREE;
    2210                 :      15090 :       if (TREE_CODE (op1) != SSA_NAME)
    2211                 :            :         return NULL_TREE;
    2212                 :       9748 :       def_stmt = SSA_NAME_DEF_STMT (op1);
    2213                 :       9748 :       if (! is_gimple_assign (def_stmt))
    2214                 :            :         return NULL_TREE;
    2215                 :       4619 :       code = gimple_assign_rhs_code (def_stmt);
    2216                 :            :     }
    2217                 :      34267 :   if (code != BIT_FIELD_REF)
    2218                 :            :     return NULL_TREE;
    2219                 :       3347 :   return gimple_assign_rhs1 (def_stmt);
    2220                 :            : }
    2221                 :            : 
    2222                 :            : /* Recognize a VEC_PERM_EXPR.  Returns true if there were any changes.  */
    2223                 :            : 
    2224                 :            : static bool
    2225                 :      35539 : simplify_vector_constructor (gimple_stmt_iterator *gsi)
    2226                 :            : {
    2227                 :      35539 :   gimple *stmt = gsi_stmt (*gsi);
    2228                 :      35539 :   tree op, orig[2], type, elem_type;
    2229                 :      35539 :   unsigned elem_size, i;
    2230                 :      35539 :   unsigned HOST_WIDE_INT nelts;
    2231                 :      35539 :   unsigned HOST_WIDE_INT refnelts;
    2232                 :      35539 :   enum tree_code conv_code;
    2233                 :      35539 :   constructor_elt *elt;
    2234                 :            : 
    2235                 :      35539 :   op = gimple_assign_rhs1 (stmt);
    2236                 :      35539 :   type = TREE_TYPE (op);
    2237                 :      35539 :   gcc_checking_assert (TREE_CODE (op) == CONSTRUCTOR
    2238                 :            :                        && TREE_CODE (type) == VECTOR_TYPE);
    2239                 :            : 
    2240                 :      35539 :   if (!TYPE_VECTOR_SUBPARTS (type).is_constant (&nelts))
    2241                 :            :     return false;
    2242                 :      35539 :   elem_type = TREE_TYPE (type);
    2243                 :      35539 :   elem_size = TREE_INT_CST_LOW (TYPE_SIZE (elem_type));
    2244                 :            : 
    2245                 :      35539 :   orig[0] = NULL;
    2246                 :      35539 :   orig[1] = NULL;
    2247                 :      35539 :   conv_code = ERROR_MARK;
    2248                 :      35539 :   bool maybe_ident = true;
    2249                 :      35539 :   bool maybe_blend[2] = { true, true };
    2250                 :      35539 :   tree one_constant = NULL_TREE;
    2251                 :      35539 :   tree one_nonconstant = NULL_TREE;
    2252                 :      71078 :   auto_vec<tree> constants;
    2253                 :      35539 :   constants.safe_grow_cleared (nelts);
    2254                 :      35539 :   auto_vec<std::pair<unsigned, unsigned>, 64> elts;
    2255                 :     108332 :   FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (op), i, elt)
    2256                 :            :     {
    2257                 :      88957 :       tree ref, op1;
    2258                 :      88957 :       unsigned int elem;
    2259                 :            : 
    2260                 :      88957 :       if (i >= nelts)
    2261                 :      16164 :         return false;
    2262                 :            : 
    2263                 :            :       /* Look for elements extracted and possibly converted from
    2264                 :            :          another vector.  */
    2265                 :      88957 :       op1 = get_bit_field_ref_def (elt->value, conv_code);
    2266                 :      88957 :       if (op1
    2267                 :       3347 :           && TREE_CODE ((ref = TREE_OPERAND (op1, 0))) == SSA_NAME
    2268                 :       2533 :           && VECTOR_TYPE_P (TREE_TYPE (ref))
    2269                 :       2526 :           && useless_type_conversion_p (TREE_TYPE (op1),
    2270                 :       2526 :                                         TREE_TYPE (TREE_TYPE (ref)))
    2271                 :       2482 :           && constant_multiple_p (bit_field_offset (op1),
    2272                 :       4964 :                                   bit_field_size (op1), &elem)
    2273                 :      92304 :           && TYPE_VECTOR_SUBPARTS (TREE_TYPE (ref)).is_constant (&refnelts))
    2274                 :            :         {
    2275                 :            :           unsigned int j;
    2276                 :       2795 :           for (j = 0; j < 2; ++j)
    2277                 :            :             {
    2278                 :       2788 :               if (!orig[j])
    2279                 :            :                 {
    2280                 :        761 :                   if (j == 0
    2281                 :        868 :                       || useless_type_conversion_p (TREE_TYPE (orig[0]),
    2282                 :        107 :                                                     TREE_TYPE (ref)))
    2283                 :            :                     break;
    2284                 :            :                 }
    2285                 :       2027 :               else if (ref == orig[j])
    2286                 :            :                 break;
    2287                 :            :             }
    2288                 :            :           /* Found a suitable vector element.  */
    2289                 :       2482 :           if (j < 2)
    2290                 :            :             {
    2291                 :       2475 :               orig[j] = ref;
    2292                 :       2475 :               if (elem != i || j != 0)
    2293                 :       1945 :                 maybe_ident = false;
    2294                 :       2475 :               if (elem != i)
    2295                 :       1887 :                 maybe_blend[j] = false;
    2296                 :       2475 :               elts.safe_push (std::make_pair (j, elem));
    2297                 :       2475 :               continue;
    2298                 :            :             }
    2299                 :            :           /* Else fallthru.  */
    2300                 :            :         }
    2301                 :            :       /* Handle elements not extracted from a vector.
    2302                 :            :           1. constants by permuting with constant vector
    2303                 :            :           2. a unique non-constant element by permuting with a splat vector  */
    2304                 :      86482 :       if (orig[1]
    2305                 :      61932 :           && orig[1] != error_mark_node)
    2306                 :            :         return false;
    2307                 :      86478 :       orig[1] = error_mark_node;
    2308                 :      86478 :       if (CONSTANT_CLASS_P (elt->value))
    2309                 :            :         {
    2310                 :      11590 :           if (one_nonconstant)
    2311                 :            :             return false;
    2312                 :       9161 :           if (!one_constant)
    2313                 :       1164 :             one_constant = elt->value;
    2314                 :       9161 :           constants[i] = elt->value;
    2315                 :            :         }
    2316                 :            :       else
    2317                 :            :         {
    2318                 :      74888 :           if (one_constant)
    2319                 :            :             return false;
    2320                 :      73837 :           if (!one_nonconstant)
    2321                 :            :             one_nonconstant = elt->value;
    2322                 :      50451 :           else if (!operand_equal_p (one_nonconstant, elt->value, 0))
    2323                 :            :             return false;
    2324                 :            :         }
    2325                 :      70318 :       elts.safe_push (std::make_pair (1, i));
    2326                 :      70318 :       maybe_ident = false;
    2327                 :            :     }
    2328                 :      19375 :   if (i < nelts)
    2329                 :            :     return false;
    2330                 :            : 
    2331                 :       7894 :   if (! orig[0]
    2332                 :       7894 :       || ! VECTOR_TYPE_P (TREE_TYPE (orig[0])))
    2333                 :            :     return false;
    2334                 :        391 :   refnelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (orig[0])).to_constant ();
    2335                 :            :   /* We currently do not handle larger destination vectors.  */
    2336                 :        391 :   if (refnelts < nelts)
    2337                 :            :     return false;
    2338                 :            : 
    2339                 :        344 :   if (maybe_ident)
    2340                 :            :     {
    2341                 :         21 :       tree conv_src_type
    2342                 :            :         = (nelts != refnelts
    2343                 :         32 :            ? (conv_code != ERROR_MARK
    2344                 :         10 :               ? build_vector_type (TREE_TYPE (TREE_TYPE (orig[0])), nelts)
    2345                 :            :               : type)
    2346                 :         11 :            : TREE_TYPE (orig[0]));
    2347                 :         21 :       if (conv_code != ERROR_MARK
    2348                 :         21 :           && !supportable_convert_operation (conv_code, type, conv_src_type,
    2349                 :            :                                              &conv_code))
    2350                 :            :         {
    2351                 :            :           /* Only few targets implement direct conversion patterns so try
    2352                 :            :              some simple special cases via VEC_[UN]PACK[_FLOAT]_LO_EXPR.  */
    2353                 :          2 :           optab optab;
    2354                 :          2 :           tree halfvectype, dblvectype;
    2355                 :          0 :           if (CONVERT_EXPR_CODE_P (conv_code)
    2356                 :          2 :               && (2 * TYPE_PRECISION (TREE_TYPE (TREE_TYPE (orig[0])))
    2357                 :          2 :                   == TYPE_PRECISION (TREE_TYPE (type)))
    2358                 :          1 :               && mode_for_vector (as_a <scalar_mode>
    2359                 :          1 :                                   (TYPE_MODE (TREE_TYPE (TREE_TYPE (orig[0])))),
    2360                 :          2 :                                   nelts * 2).exists ()
    2361                 :          1 :               && (dblvectype
    2362                 :          1 :                   = build_vector_type (TREE_TYPE (TREE_TYPE (orig[0])),
    2363                 :          1 :                                        nelts * 2))
    2364                 :          1 :               && (optab = optab_for_tree_code (FLOAT_TYPE_P (TREE_TYPE (type))
    2365                 :            :                                                ? VEC_UNPACK_FLOAT_LO_EXPR
    2366                 :            :                                                : VEC_UNPACK_LO_EXPR,
    2367                 :            :                                                dblvectype,
    2368                 :            :                                                optab_default))
    2369                 :          3 :               && (optab_handler (optab, TYPE_MODE (dblvectype))
    2370                 :            :                   != CODE_FOR_nothing))
    2371                 :            :             {
    2372                 :          1 :               gimple_seq stmts = NULL;
    2373                 :          1 :               tree dbl;
    2374                 :          1 :               if (refnelts == nelts)
    2375                 :            :                 {
    2376                 :            :                   /* ???  Paradoxical subregs don't exist, so insert into
    2377                 :            :                      the lower half of a wider zero vector.  */
    2378                 :          1 :                   dbl = gimple_build (&stmts, BIT_INSERT_EXPR, dblvectype,
    2379                 :            :                                       build_zero_cst (dblvectype), orig[0],
    2380                 :            :                                       bitsize_zero_node);
    2381                 :            :                 }
    2382                 :          0 :               else if (refnelts == 2 * nelts)
    2383                 :            :                 dbl = orig[0];
    2384                 :            :               else
    2385                 :          0 :                 dbl = gimple_build (&stmts, BIT_FIELD_REF, dblvectype,
    2386                 :          0 :                                     orig[0], TYPE_SIZE (dblvectype),
    2387                 :            :                                     bitsize_zero_node);
    2388                 :          1 :               gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
    2389                 :          1 :               gimple_assign_set_rhs_with_ops (gsi,
    2390                 :          1 :                                               FLOAT_TYPE_P (TREE_TYPE (type))
    2391                 :            :                                               ? VEC_UNPACK_FLOAT_LO_EXPR
    2392                 :            :                                               : VEC_UNPACK_LO_EXPR,
    2393                 :            :                                               dbl);
    2394                 :            :             }
    2395                 :          0 :           else if (CONVERT_EXPR_CODE_P (conv_code)
    2396                 :          1 :                    && (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (orig[0])))
    2397                 :          1 :                        == 2 * TYPE_PRECISION (TREE_TYPE (type)))
    2398                 :          1 :                    && mode_for_vector (as_a <scalar_mode>
    2399                 :          1 :                                          (TYPE_MODE
    2400                 :            :                                            (TREE_TYPE (TREE_TYPE (orig[0])))),
    2401                 :          2 :                                        nelts / 2).exists ()
    2402                 :          1 :                    && (halfvectype
    2403                 :          1 :                          = build_vector_type (TREE_TYPE (TREE_TYPE (orig[0])),
    2404                 :          1 :                                               nelts / 2))
    2405                 :          1 :                    && (optab = optab_for_tree_code (VEC_PACK_TRUNC_EXPR,
    2406                 :            :                                                     halfvectype,
    2407                 :            :                                                     optab_default))
    2408                 :          2 :                    && (optab_handler (optab, TYPE_MODE (halfvectype))
    2409                 :            :                        != CODE_FOR_nothing))
    2410                 :            :             {
    2411                 :          1 :               gimple_seq stmts = NULL;
    2412                 :          1 :               tree low = gimple_build (&stmts, BIT_FIELD_REF, halfvectype,
    2413                 :          1 :                                        orig[0], TYPE_SIZE (halfvectype),
    2414                 :            :                                        bitsize_zero_node);
    2415                 :          1 :               tree hig = gimple_build (&stmts, BIT_FIELD_REF, halfvectype,
    2416                 :          1 :                                        orig[0], TYPE_SIZE (halfvectype),
    2417                 :          1 :                                        TYPE_SIZE (halfvectype));
    2418                 :          1 :               gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
    2419                 :          1 :               gimple_assign_set_rhs_with_ops (gsi, VEC_PACK_TRUNC_EXPR,
    2420                 :            :                                               low, hig);
    2421                 :            :             }
    2422                 :            :           else
    2423                 :          0 :             return false;
    2424                 :          2 :           update_stmt (gsi_stmt (*gsi));
    2425                 :          2 :           return true;
    2426                 :            :         }
    2427                 :         19 :       if (nelts != refnelts)
    2428                 :            :         {
    2429                 :         10 :           gassign *lowpart
    2430                 :         10 :             = gimple_build_assign (make_ssa_name (conv_src_type),
    2431                 :            :                                    build3 (BIT_FIELD_REF, conv_src_type,
    2432                 :         10 :                                            orig[0], TYPE_SIZE (conv_src_type),
    2433                 :            :                                            bitsize_zero_node));
    2434                 :         10 :           gsi_insert_before (gsi, lowpart, GSI_SAME_STMT);
    2435                 :         10 :           orig[0] = gimple_assign_lhs (lowpart);
    2436                 :            :         }
    2437                 :         19 :       if (conv_code == ERROR_MARK)
    2438                 :         17 :         gimple_assign_set_rhs_from_tree (gsi, orig[0]);
    2439                 :            :       else
    2440                 :          2 :         gimple_assign_set_rhs_with_ops (gsi, conv_code, orig[0],
    2441                 :            :                                         NULL_TREE, NULL_TREE);
    2442                 :            :     }
    2443                 :            :   else
    2444                 :            :     {
    2445                 :            :       /* If we combine a vector with a non-vector avoid cases where
    2446                 :            :          we'll obviously end up with more GIMPLE stmts which is when
    2447                 :            :          we'll later not fold this to a single insert into the vector
    2448                 :            :          and we had a single extract originally.  See PR92819.  */
    2449                 :        323 :       if (nelts == 2
    2450                 :         67 :           && refnelts > 2
    2451                 :         26 :           && orig[1] == error_mark_node
    2452                 :         15 :           && !maybe_blend[0])
    2453                 :        243 :         return false;
    2454                 :        310 :       tree mask_type, perm_type, conv_src_type;
    2455                 :        310 :       perm_type = TREE_TYPE (orig[0]);
    2456                 :        620 :       conv_src_type = (nelts == refnelts
    2457                 :        310 :                        ? perm_type
    2458                 :         17 :                        : build_vector_type (TREE_TYPE (perm_type), nelts));
    2459                 :        310 :       if (conv_code != ERROR_MARK
    2460                 :        310 :           && !supportable_convert_operation (conv_code, type, conv_src_type,
    2461                 :            :                                              &conv_code))
    2462                 :            :         return false;
    2463                 :            : 
    2464                 :            :       /* Now that we know the number of elements of the source build the
    2465                 :            :          permute vector.
    2466                 :            :          ???  When the second vector has constant values we can shuffle
    2467                 :            :          it and its source indexes to make the permutation supported.
    2468                 :            :          For now it mimics a blend.  */
    2469                 :        390 :       vec_perm_builder sel (refnelts, refnelts, 1);
    2470                 :        310 :       bool all_same_p = true;
    2471                 :       2250 :       for (i = 0; i < elts.length (); ++i)
    2472                 :            :         {
    2473                 :       1940 :           sel.quick_push (elts[i].second + elts[i].first * refnelts);
    2474                 :       1940 :           all_same_p &= known_eq (sel[i], sel[0]);
    2475                 :            :         }
    2476                 :            :       /* And fill the tail with "something".  It's really don't care,
    2477                 :            :          and ideally we'd allow VEC_PERM to have a smaller destination
    2478                 :            :          vector.  As a heuristic:
    2479                 :            : 
    2480                 :            :          (a) if what we have so far duplicates a single element, make the
    2481                 :            :              tail do the same
    2482                 :            : 
    2483                 :            :          (b) otherwise preserve a uniform orig[0].  This facilitates
    2484                 :            :              later pattern-matching of VEC_PERM_EXPR to a BIT_INSERT_EXPR.  */
    2485                 :        352 :       for (; i < refnelts; ++i)
    2486                 :         84 :         sel.quick_push (all_same_p
    2487                 :         84 :                         ? sel[0]
    2488                 :         52 :                         : (elts[0].second == 0 && elts[0].first == 0
    2489                 :         52 :                            ? 0 : refnelts) + i);
    2490                 :        558 :       vec_perm_indices indices (sel, orig[1] ? 2 : 1, refnelts);
    2491                 :        310 :       if (!can_vec_perm_const_p (TYPE_MODE (perm_type), indices))
    2492                 :        230 :         return false;
    2493                 :         80 :       mask_type
    2494                 :         80 :         = build_vector_type (build_nonstandard_integer_type (elem_size, 1),
    2495                 :            :                              refnelts);
    2496                 :         80 :       if (GET_MODE_CLASS (TYPE_MODE (mask_type)) != MODE_VECTOR_INT
    2497                 :        240 :           || maybe_ne (GET_MODE_SIZE (TYPE_MODE (mask_type)),
    2498                 :        160 :                        GET_MODE_SIZE (TYPE_MODE (perm_type))))
    2499                 :          0 :         return false;
    2500                 :         80 :       tree op2 = vec_perm_indices_to_tree (mask_type, indices);
    2501                 :         80 :       bool converted_orig1 = false;
    2502                 :         80 :       gimple_seq stmts = NULL;
    2503                 :         80 :       if (!orig[1])
    2504                 :         34 :         orig[1] = orig[0];
    2505                 :         46 :       else if (orig[1] == error_mark_node
    2506                 :         42 :                && one_nonconstant)
    2507                 :            :         {
    2508                 :            :           /* ???  We can see if we can safely convert to the original
    2509                 :            :              element type.  */
    2510                 :         17 :           converted_orig1 = conv_code != ERROR_MARK;
    2511                 :         33 :           orig[1] = gimple_build_vector_from_val (&stmts, UNKNOWN_LOCATION,
    2512                 :            :                                                   converted_orig1
    2513                 :            :                                                   ? type : perm_type,
    2514                 :            :                                                   one_nonconstant);
    2515                 :            :         }
    2516                 :         29 :       else if (orig[1] == error_mark_node)
    2517                 :            :         {
    2518                 :            :           /* ???  See if we can convert the vector to the original type.  */
    2519                 :         25 :           converted_orig1 = conv_code != ERROR_MARK;
    2520                 :         25 :           unsigned n = converted_orig1 ? nelts : refnelts;
    2521                 :         25 :           tree_vector_builder vec (converted_orig1
    2522                 :         25 :                                    ? type : perm_type, n, 1);
    2523                 :        129 :           for (unsigned i = 0; i < n; ++i)
    2524                 :        104 :             if (i < nelts && constants[i])
    2525                 :         41 :               vec.quick_push (constants[i]);
    2526                 :            :             else
    2527                 :            :               /* ??? Push a don't-care value.  */
    2528                 :         63 :               vec.quick_push (one_constant);
    2529                 :         25 :           orig[1] = vec.build ();
    2530                 :            :         }
    2531                 :         76 :       tree blend_op2 = NULL_TREE;
    2532                 :         76 :       if (converted_orig1)
    2533                 :            :         {
    2534                 :            :           /* Make sure we can do a blend in the target type.  */
    2535                 :         30 :           vec_perm_builder sel (nelts, nelts, 1);
    2536                 :         75 :           for (i = 0; i < elts.length (); ++i)
    2537                 :        120 :             sel.quick_push (elts[i].first
    2538                 :         60 :                             ? elts[i].second + nelts : i);
    2539                 :         15 :           vec_perm_indices indices (sel, 2, nelts);
    2540                 :         15 :           if (!can_vec_perm_const_p (TYPE_MODE (type), indices))
    2541                 :          0 :             return false;
    2542                 :         15 :           mask_type
    2543                 :         15 :             = build_vector_type (build_nonstandard_integer_type (elem_size, 1),
    2544                 :            :                                  nelts);
    2545                 :         15 :           if (GET_MODE_CLASS (TYPE_MODE (mask_type)) != MODE_VECTOR_INT
    2546                 :         45 :               || maybe_ne (GET_MODE_SIZE (TYPE_MODE (mask_type)),
    2547                 :         30 :                            GET_MODE_SIZE (TYPE_MODE (type))))
    2548                 :          0 :             return false;
    2549                 :         15 :           blend_op2 = vec_perm_indices_to_tree (mask_type, indices);
    2550                 :            :         }
    2551                 :         80 :       tree orig1_for_perm
    2552                 :         80 :         = converted_orig1 ? build_zero_cst (perm_type) : orig[1];
    2553                 :         80 :       tree res = gimple_build (&stmts, VEC_PERM_EXPR, perm_type,
    2554                 :            :                                orig[0], orig1_for_perm, op2);
    2555                 :         80 :       if (nelts != refnelts)
    2556                 :         17 :         res = gimple_build (&stmts, BIT_FIELD_REF,
    2557                 :         17 :                             conv_code != ERROR_MARK ? conv_src_type : type,
    2558                 :         17 :                             res, TYPE_SIZE (type), bitsize_zero_node);
    2559                 :         80 :       if (conv_code != ERROR_MARK)
    2560                 :         19 :         res = gimple_build (&stmts, conv_code, type, res);
    2561                 :            :       /* Blend in the actual constant.  */
    2562                 :         80 :       if (converted_orig1)
    2563                 :         15 :         res = gimple_build (&stmts, VEC_PERM_EXPR, type,
    2564                 :            :                             res, orig[1], blend_op2);
    2565                 :         80 :       gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT);
    2566                 :         80 :       gimple_assign_set_rhs_with_ops (gsi, SSA_NAME, res);
    2567                 :            :     }
    2568                 :         99 :   update_stmt (gsi_stmt (*gsi));
    2569                 :         99 :   return true;
    2570                 :            : }
    2571                 :            : 
    2572                 :            : 
    2573                 :            : /* Primitive "lattice" function for gimple_simplify.  */
    2574                 :            : 
    2575                 :            : static tree
    2576                 :  582089000 : fwprop_ssa_val (tree name)
    2577                 :            : {
    2578                 :            :   /* First valueize NAME.  */
    2579                 :  582089000 :   if (TREE_CODE (name) == SSA_NAME
    2580                 : 1164180000 :       && SSA_NAME_VERSION (name) < lattice.length ())
    2581                 :            :     {
    2582                 :  581862000 :       tree val = lattice[SSA_NAME_VERSION (name)];
    2583                 :  581862000 :       if (val)
    2584                 :  195312000 :         name = val;
    2585                 :            :     }
    2586                 :            :   /* We continue matching along SSA use-def edges for SSA names
    2587                 :            :      that are not single-use.  Currently there are no patterns
    2588                 :            :      that would cause any issues with that.  */
    2589                 :  582089000 :   return name;
    2590                 :            : }
    2591                 :            : 
    2592                 :            : /* Main entry point for the forward propagation and statement combine
    2593                 :            :    optimizer.  */
    2594                 :            : 
    2595                 :            : namespace {
    2596                 :            : 
    2597                 :            : const pass_data pass_data_forwprop =
    2598                 :            : {
    2599                 :            :   GIMPLE_PASS, /* type */
    2600                 :            :   "forwprop", /* name */
    2601                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    2602                 :            :   TV_TREE_FORWPROP, /* tv_id */
    2603                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
    2604                 :            :   0, /* properties_provided */
    2605                 :            :   0, /* properties_destroyed */
    2606                 :            :   0, /* todo_flags_start */
    2607                 :            :   TODO_update_ssa, /* todo_flags_finish */
    2608                 :            : };
    2609                 :            : 
    2610                 :            : class pass_forwprop : public gimple_opt_pass
    2611                 :            : {
    2612                 :            : public:
    2613                 :     802160 :   pass_forwprop (gcc::context *ctxt)
    2614                 :    1604320 :     : gimple_opt_pass (pass_data_forwprop, ctxt)
    2615                 :            :   {}
    2616                 :            : 
    2617                 :            :   /* opt_pass methods: */
    2618                 :     601620 :   opt_pass * clone () { return new pass_forwprop (m_ctxt); }
    2619                 :    3641120 :   virtual bool gate (function *) { return flag_tree_forwprop; }
    2620                 :            :   virtual unsigned int execute (function *);
    2621                 :            : 
    2622                 :            : }; // class pass_forwprop
    2623                 :            : 
    2624                 :            : unsigned int
    2625                 :    3639140 : pass_forwprop::execute (function *fun)
    2626                 :            : {
    2627                 :    3639140 :   unsigned int todoflags = 0;
    2628                 :            : 
    2629                 :    3639140 :   cfg_changed = false;
    2630                 :            : 
    2631                 :            :   /* Combine stmts with the stmts defining their operands.  Do that
    2632                 :            :      in an order that guarantees visiting SSA defs before SSA uses.  */
    2633                 :    3639140 :   lattice.create (num_ssa_names);
    2634                 :    7278290 :   lattice.quick_grow_cleared (num_ssa_names);
    2635                 :    3639140 :   int *postorder = XNEWVEC (int, n_basic_blocks_for_fn (fun));
    2636                 :    3639140 :   int postorder_num = pre_and_rev_post_order_compute_fn (cfun, NULL,
    2637                 :            :                                                          postorder, false);
    2638                 :    3639140 :   auto_vec<gimple *, 4> to_fixup;
    2639                 :    3639140 :   auto_vec<gimple *, 32> to_remove;
    2640                 :    3639140 :   to_purge = BITMAP_ALLOC (NULL);
    2641                 :   32134300 :   for (int i = 0; i < postorder_num; ++i)
    2642                 :            :     {
    2643                 :   28495200 :       gimple_stmt_iterator gsi;
    2644                 :   28495200 :       basic_block bb = BASIC_BLOCK_FOR_FN (fun, postorder[i]);
    2645                 :            : 
    2646                 :            :       /* Record degenerate PHIs in the lattice.  */
    2647                 :   38672000 :       for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
    2648                 :   10176800 :            gsi_next (&si))
    2649                 :            :         {
    2650                 :   10176800 :           gphi *phi = si.phi ();
    2651                 :   10176800 :           tree res = gimple_phi_result (phi);
    2652                 :   20353600 :           if (virtual_operand_p (res))
    2653                 :    5256300 :             continue;
    2654                 :            : 
    2655                 :    4920490 :           use_operand_p use_p;
    2656                 :    4920490 :           ssa_op_iter it;
    2657                 :    4920490 :           tree first = NULL_TREE;
    2658                 :    4920490 :           bool all_same = true;
    2659                 :   10168900 :           FOR_EACH_PHI_ARG (use_p, phi, it, SSA_OP_USE)
    2660                 :            :             {
    2661                 :   10003000 :               tree use = USE_FROM_PTR (use_p);
    2662                 :   10003000 :               if (! first)
    2663                 :            :                 first = use;
    2664                 :    5082490 :               else if (! operand_equal_p (first, use, 0))
    2665                 :            :                 {
    2666                 :            :                   all_same = false;
    2667                 :            :                   break;
    2668                 :            :                 }
    2669                 :            :             }
    2670                 :    4920490 :           if (all_same)
    2671                 :            :             {
    2672                 :     165924 :               if (may_propagate_copy (res, first))
    2673                 :     165580 :                 to_remove.safe_push (phi);
    2674                 :     165924 :               fwprop_set_lattice_val (res, first);
    2675                 :            :             }
    2676                 :            :         }
    2677                 :            : 
    2678                 :            :       /* Apply forward propagation to all stmts in the basic-block.
    2679                 :            :          Note we update GSI within the loop as necessary.  */
    2680                 :  270170000 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
    2681                 :            :         {
    2682                 :  213180000 :           gimple *stmt = gsi_stmt (gsi);
    2683                 :  213180000 :           tree lhs, rhs;
    2684                 :  213180000 :           enum tree_code code;
    2685                 :            : 
    2686                 :  213180000 :           if (!is_gimple_assign (stmt))
    2687                 :            :             {
    2688                 :  145630000 :               gsi_next (&gsi);
    2689                 :  145630000 :               continue;
    2690                 :            :             }
    2691                 :            : 
    2692                 :   67549800 :           lhs = gimple_assign_lhs (stmt);
    2693                 :   67549800 :           rhs = gimple_assign_rhs1 (stmt);
    2694                 :   67549800 :           code = gimple_assign_rhs_code (stmt);
    2695                 :   94511800 :           if (TREE_CODE (lhs) != SSA_NAME
    2696                 :   67549800 :               || has_zero_uses (lhs))
    2697                 :            :             {
    2698                 :   26962100 :               gsi_next (&gsi);
    2699                 :   26962100 :               continue;
    2700                 :            :             }
    2701                 :            : 
    2702                 :            :           /* If this statement sets an SSA_NAME to an address,
    2703                 :            :              try to propagate the address into the uses of the SSA_NAME.  */
    2704                 :   40587700 :           if (code == ADDR_EXPR
    2705                 :            :               /* Handle pointer conversions on invariant addresses
    2706                 :            :                  as well, as this is valid gimple.  */
    2707                 :   40587700 :               || (CONVERT_EXPR_CODE_P (code)
    2708                 :    5582490 :                   && TREE_CODE (rhs) == ADDR_EXPR
    2709                 :     203857 :                   && POINTER_TYPE_P (TREE_TYPE (lhs))))
    2710                 :            :             {
    2711                 :    1512870 :               tree base = get_base_address (TREE_OPERAND (rhs, 0));
    2712                 :    1512870 :               if ((!base
    2713                 :    1512870 :                    || !DECL_P (base)
    2714                 :      70662 :                    || decl_address_invariant_p (base))
    2715                 :    1512870 :                   && TREE_CODE (base) != TARGET_MEM_REF
    2716                 :    1512640 :                   && !stmt_references_abnormal_ssa_name (stmt)
    2717                 :    3025490 :                   && forward_propagate_addr_expr (lhs, rhs, true))
    2718                 :            :                 {
    2719                 :     247684 :                   fwprop_invalidate_lattice (gimple_get_lhs (stmt));
    2720                 :     247684 :                   release_defs (stmt);
    2721                 :     247684 :                   gsi_remove (&gsi, true);
    2722                 :            :                 }
    2723                 :            :               else
    2724                 :    1265180 :                 gsi_next (&gsi);
    2725                 :            :             }
    2726                 :   39074800 :           else if (code == POINTER_PLUS_EXPR)
    2727                 :            :             {
    2728                 :    1982460 :               tree off = gimple_assign_rhs2 (stmt);
    2729                 :    1982460 :               if (TREE_CODE (off) == INTEGER_CST
    2730                 :     618955 :                   && can_propagate_from (stmt)
    2731                 :     618698 :                   && !simple_iv_increment_p (stmt)
    2732                 :            :                   /* ???  Better adjust the interface to that function
    2733                 :            :                      instead of building new trees here.  */
    2734                 :    2431090 :                   && forward_propagate_addr_expr
    2735                 :    1345890 :                        (lhs,
    2736                 :            :                         build1_loc (gimple_location (stmt),
    2737                 :     448629 :                                     ADDR_EXPR, TREE_TYPE (rhs),
    2738                 :     448629 :                                     fold_build2 (MEM_REF,
    2739                 :            :                                                  TREE_TYPE (TREE_TYPE (rhs)),
    2740                 :            :                                                  rhs,
    2741                 :            :                                                  fold_convert (ptr_type_node,
    2742                 :            :                                                                off))), true))
    2743                 :            :                 {
    2744                 :     192612 :                   fwprop_invalidate_lattice (gimple_get_lhs (stmt));
    2745                 :     192612 :                   release_defs (stmt);
    2746                 :     192612 :                   gsi_remove (&gsi, true);
    2747                 :            :                 }
    2748                 :    1789850 :               else if (is_gimple_min_invariant (rhs))
    2749                 :            :                 {
    2750                 :            :                   /* Make sure to fold &a[0] + off_1 here.  */
    2751                 :     109585 :                   fold_stmt_inplace (&gsi);
    2752                 :     109585 :                   update_stmt (stmt);
    2753                 :     109585 :                   if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
    2754                 :     109571 :                     gsi_next (&gsi);
    2755                 :            :                 }
    2756                 :            :               else
    2757                 :    1680270 :                 gsi_next (&gsi);
    2758                 :            :             }
    2759                 :   37092400 :           else if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE
    2760                 :     208127 :                    && gimple_assign_load_p (stmt)
    2761                 :     129687 :                    && !gimple_has_volatile_ops (stmt)
    2762                 :      36567 :                    && (TREE_CODE (gimple_assign_rhs1 (stmt))
    2763                 :            :                        != TARGET_MEM_REF)
    2764                 :   37128800 :                    && !stmt_can_throw_internal (cfun, stmt))
    2765                 :            :             {
    2766                 :            :               /* Rewrite loads used only in real/imagpart extractions to
    2767                 :            :                  component-wise loads.  */
    2768                 :      36344 :               use_operand_p use_p;
    2769                 :      36344 :               imm_use_iterator iter;
    2770                 :      36344 :               bool rewrite = true;
    2771                 :      41695 :               FOR_EACH_IMM_USE_FAST (use_p, iter, lhs)
    2772                 :            :                 {
    2773                 :      39147 :                   gimple *use_stmt = USE_STMT (use_p);
    2774                 :      39147 :                   if (is_gimple_debug (use_stmt))
    2775                 :        313 :                     continue;
    2776                 :      38834 :                   if (!is_gimple_assign (use_stmt)
    2777                 :      38834 :                       || (gimple_assign_rhs_code (use_stmt) != REALPART_EXPR
    2778                 :      22950 :                           && gimple_assign_rhs_code (use_stmt) != IMAGPART_EXPR))
    2779                 :            :                     {
    2780                 :            :                       rewrite = false;
    2781                 :            :                       break;
    2782                 :            :                     }
    2783                 :            :                 }
    2784                 :      36344 :               if (rewrite)
    2785                 :            :                 {
    2786                 :       2548 :                   gimple *use_stmt;
    2787                 :       7524 :                   FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
    2788                 :            :                     {
    2789                 :       4976 :                       if (is_gimple_debug (use_stmt))
    2790                 :            :                         {
    2791                 :        207 :                           if (gimple_debug_bind_p (use_stmt))
    2792                 :            :                             {
    2793                 :        207 :                               gimple_debug_bind_reset_value (use_stmt);
    2794                 :        207 :                               update_stmt (use_stmt);
    2795                 :            :                             }
    2796                 :        207 :                           continue;
    2797                 :            :                         }
    2798                 :            : 
    2799                 :       9538 :                       tree new_rhs = build1 (gimple_assign_rhs_code (use_stmt),
    2800                 :       4769 :                                              TREE_TYPE (TREE_TYPE (rhs)),
    2801                 :            :                                              unshare_expr (rhs));
    2802                 :       4769 :                       gimple *new_stmt
    2803                 :       4769 :                         = gimple_build_assign (gimple_assign_lhs (use_stmt),
    2804                 :            :                                                new_rhs);
    2805                 :            : 
    2806                 :       4769 :                       location_t loc = gimple_location (use_stmt);
    2807                 :       4769 :                       gimple_set_location (new_stmt, loc);
    2808                 :       4769 :                       gimple_stmt_iterator gsi2 = gsi_for_stmt (use_stmt);
    2809                 :       4769 :                       unlink_stmt_vdef (use_stmt);
    2810                 :       4769 :                       gsi_remove (&gsi2, true);
    2811                 :            : 
    2812                 :       4769 :                       gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
    2813                 :            :                     }
    2814                 :            : 
    2815                 :       2548 :                   release_defs (stmt);
    2816                 :       2548 :                   gsi_remove (&gsi, true);
    2817                 :            :                 }
    2818                 :            :               else
    2819                 :      33796 :                 gsi_next (&gsi);
    2820                 :            :             }
    2821                 :   37056000 :           else if (TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE
    2822                 :     791668 :                    && TYPE_MODE (TREE_TYPE (lhs)) == BLKmode
    2823                 :      17729 :                    && gimple_assign_load_p (stmt)
    2824                 :      10264 :                    && !gimple_has_volatile_ops (stmt)
    2825                 :       8176 :                    && (TREE_CODE (gimple_assign_rhs1 (stmt))
    2826                 :            :                        != TARGET_MEM_REF)
    2827                 :   37063900 :                    && !stmt_can_throw_internal (cfun, stmt))
    2828                 :            :             {
    2829                 :            :               /* Rewrite loads used only in BIT_FIELD_REF extractions to
    2830                 :            :                  component-wise loads.  */
    2831                 :       7884 :               use_operand_p use_p;
    2832                 :       7884 :               imm_use_iterator iter;
    2833                 :       7884 :               bool rewrite = true;
    2834                 :      29452 :               FOR_EACH_IMM_USE_FAST (use_p, iter, lhs)
    2835                 :            :                 {
    2836                 :      28273 :                   gimple *use_stmt = USE_STMT (use_p);
    2837                 :      28273 :                   if (is_gimple_debug (use_stmt))
    2838                 :          1 :                     continue;
    2839                 :      28272 :                   if (!is_gimple_assign (use_stmt)
    2840                 :      28272 :                       || gimple_assign_rhs_code (use_stmt) != BIT_FIELD_REF)
    2841                 :            :                     {
    2842                 :            :                       rewrite = false;
    2843                 :            :                       break;
    2844                 :            :                     }
    2845                 :            :                 }
    2846                 :       7884 :               if (rewrite)
    2847                 :            :                 {
    2848                 :       1179 :                   gimple *use_stmt;
    2849                 :      22720 :                   FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
    2850                 :            :                     {
    2851                 :      21541 :                       if (is_gimple_debug (use_stmt))
    2852                 :            :                         {
    2853                 :          0 :                           if (gimple_debug_bind_p (use_stmt))
    2854                 :            :                             {
    2855                 :          0 :                               gimple_debug_bind_reset_value (use_stmt);
    2856                 :          0 :                               update_stmt (use_stmt);
    2857                 :            :                             }
    2858                 :          0 :                           continue;
    2859                 :            :                         }
    2860                 :            : 
    2861                 :      21541 :                       tree bfr = gimple_assign_rhs1 (use_stmt);
    2862                 :      21541 :                       tree new_rhs = fold_build3 (BIT_FIELD_REF,
    2863                 :            :                                                   TREE_TYPE (bfr),
    2864                 :            :                                                   unshare_expr (rhs),
    2865                 :            :                                                   TREE_OPERAND (bfr, 1),
    2866                 :            :                                                   TREE_OPERAND (bfr, 2));
    2867                 :      21541 :                       gimple *new_stmt
    2868                 :      21541 :                         = gimple_build_assign (gimple_assign_lhs (use_stmt),
    2869                 :            :                                                new_rhs);
    2870                 :            : 
    2871                 :      21541 :                       location_t loc = gimple_location (use_stmt);
    2872                 :      21541 :                       gimple_set_location (new_stmt, loc);
    2873                 :      21541 :                       gimple_stmt_iterator gsi2 = gsi_for_stmt (use_stmt);
    2874                 :      21541 :                       unlink_stmt_vdef (use_stmt);
    2875                 :      21541 :                       gsi_remove (&gsi2, true);
    2876                 :            : 
    2877                 :      21541 :                       gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
    2878                 :            :                     }
    2879                 :            : 
    2880                 :       1179 :                   release_defs (stmt);
    2881                 :       1179 :                   gsi_remove (&gsi, true);
    2882                 :            :                 }
    2883                 :            :               else
    2884                 :       6705 :                 gsi_next (&gsi);
    2885                 :            :             }
    2886                 :            : 
    2887                 :   37048100 :           else if (code == COMPLEX_EXPR)
    2888                 :            :             {
    2889                 :            :               /* Rewrite stores of a single-use complex build expression
    2890                 :            :                  to component-wise stores.  */
    2891                 :      30825 :               use_operand_p use_p;
    2892                 :      30825 :               gimple *use_stmt;
    2893                 :      30825 :               if (single_imm_use (lhs, &use_p, &use_stmt)
    2894                 :      28981 :                   && gimple_store_p (use_stmt)
    2895                 :      37698 :                   && !gimple_has_volatile_ops (use_stmt)
    2896                 :       1310 :                   && is_gimple_assign (use_stmt)
    2897                 :      32135 :                   && (TREE_CODE (gimple_assign_lhs (use_stmt))
    2898                 :            :                       != TARGET_MEM_REF))
    2899                 :            :                 {
    2900                 :       1307 :                   tree use_lhs = gimple_assign_lhs (use_stmt);
    2901                 :       1307 :                   tree new_lhs = build1 (REALPART_EXPR,
    2902                 :       1307 :                                          TREE_TYPE (TREE_TYPE (use_lhs)),
    2903                 :            :                                          unshare_expr (use_lhs));
    2904                 :       1307 :                   gimple *new_stmt = gimple_build_assign (new_lhs, rhs);
    2905                 :       1307 :                   location_t loc = gimple_location (use_stmt);
    2906                 :       1307 :                   gimple_set_location (new_stmt, loc);
    2907                 :       2614 :                   gimple_set_vuse (new_stmt, gimple_vuse (use_stmt));
    2908                 :       2614 :                   gimple_set_vdef (new_stmt, make_ssa_name (gimple_vop (cfun)));
    2909                 :       1307 :                   SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
    2910                 :       2614 :                   gimple_set_vuse (use_stmt, gimple_vdef (new_stmt));
    2911                 :       1307 :                   gimple_stmt_iterator gsi2 = gsi_for_stmt (use_stmt);
    2912                 :       1307 :                   gsi_insert_before (&gsi2, new_stmt, GSI_SAME_STMT);
    2913                 :            : 
    2914                 :       1307 :                   new_lhs = build1 (IMAGPART_EXPR,
    2915                 :       1307 :                                     TREE_TYPE (TREE_TYPE (use_lhs)),
    2916                 :            :                                     unshare_expr (use_lhs));
    2917                 :       1307 :                   gimple_assign_set_lhs (use_stmt, new_lhs);
    2918                 :       1307 :                   gimple_assign_set_rhs1 (use_stmt, gimple_assign_rhs2 (stmt));
    2919                 :       1307 :                   update_stmt (use_stmt);
    2920                 :            : 
    2921                 :       1307 :                   release_defs (stmt);
    2922                 :       1307 :                   gsi_remove (&gsi, true);
    2923                 :            :                 }
    2924                 :            :               else
    2925                 :      29518 :                 gsi_next (&gsi);
    2926                 :            :             }
    2927                 :   37017300 :           else if (code == CONSTRUCTOR
    2928                 :      26620 :                    && VECTOR_TYPE_P (TREE_TYPE (rhs))
    2929                 :      26620 :                    && TYPE_MODE (TREE_TYPE (rhs)) == BLKmode
    2930                 :       2022 :                    && CONSTRUCTOR_NELTS (rhs) > 0
    2931                 :   37019300 :                    && (!VECTOR_TYPE_P (TREE_TYPE (CONSTRUCTOR_ELT (rhs, 0)->value))
    2932                 :        201 :                        || (TYPE_MODE (TREE_TYPE (CONSTRUCTOR_ELT (rhs, 0)->value))
    2933                 :            :                            != BLKmode)))
    2934                 :            :             {
    2935                 :            :               /* Rewrite stores of a single-use vector constructors
    2936                 :            :                  to component-wise stores if the mode isn't supported.  */
    2937                 :       2022 :               use_operand_p use_p;
    2938                 :       2022 :               gimple *use_stmt;
    2939                 :       2022 :               if (single_imm_use (lhs, &use_p, &use_stmt)
    2940                 :       1881 :                   && gimple_store_p (use_stmt)
    2941                 :       2598 :                   && !gimple_has_volatile_ops (use_stmt)
    2942                 :       1293 :                   && !stmt_can_throw_internal (cfun, use_stmt)
    2943                 :       1287 :                   && is_gimple_assign (use_stmt)
    2944                 :       3309 :                   && (TREE_CODE (gimple_assign_lhs (use_stmt))
    2945                 :            :                       != TARGET_MEM_REF))
    2946                 :            :                 {
    2947                 :       1287 :                   tree elt_t = TREE_TYPE (CONSTRUCTOR_ELT (rhs, 0)->value);
    2948                 :       1287 :                   unsigned HOST_WIDE_INT elt_w
    2949                 :       1287 :                     = tree_to_uhwi (TYPE_SIZE (elt_t));
    2950                 :       1287 :                   unsigned HOST_WIDE_INT n
    2951                 :       1287 :                     = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (rhs)));
    2952                 :      27576 :                   for (unsigned HOST_WIDE_INT bi = 0; bi < n; bi += elt_w)
    2953                 :            :                     {
    2954                 :      26289 :                       unsigned HOST_WIDE_INT ci = bi / elt_w;
    2955                 :      26289 :                       tree new_rhs;
    2956                 :      52578 :                       if (ci < CONSTRUCTOR_NELTS (rhs))
    2957                 :      26239 :                         new_rhs = CONSTRUCTOR_ELT (rhs, ci)->value;
    2958                 :            :                       else
    2959                 :         50 :                         new_rhs = build_zero_cst (elt_t);
    2960                 :      26289 :                       tree use_lhs = gimple_assign_lhs (use_stmt);
    2961                 :      26289 :                       tree new_lhs = build3 (BIT_FIELD_REF,
    2962                 :            :                                              elt_t,
    2963                 :            :                                              unshare_expr (use_lhs),
    2964                 :            :                                              bitsize_int (elt_w),
    2965                 :            :                                              bitsize_int (bi));
    2966                 :      26289 :                       gimple *new_stmt = gimple_build_assign (new_lhs, new_rhs);
    2967                 :      26289 :                       location_t loc = gimple_location (use_stmt);
    2968                 :      26289 :                       gimple_set_location (new_stmt, loc);
    2969                 :      52578 :                       gimple_set_vuse (new_stmt, gimple_vuse (use_stmt));
    2970                 :      52578 :                       gimple_set_vdef (new_stmt,
    2971                 :            :                                        make_ssa_name (gimple_vop (cfun)));
    2972                 :      26289 :                       SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
    2973                 :      52578 :                       gimple_set_vuse (use_stmt, gimple_vdef (new_stmt));
    2974                 :      26289 :                       gimple_stmt_iterator gsi2 = gsi_for_stmt (use_stmt);
    2975                 :      26289 :                       gsi_insert_before (&gsi2, new_stmt, GSI_SAME_STMT);
    2976                 :            :                     }
    2977                 :       1287 :                   gimple_stmt_iterator gsi2 = gsi_for_stmt (use_stmt);
    2978                 :       1287 :                   unlink_stmt_vdef (use_stmt);
    2979                 :       1287 :                   release_defs (use_stmt);
    2980                 :       1287 :                   gsi_remove (&gsi2, true);
    2981                 :       1287 :                   release_defs (stmt);
    2982                 :       1287 :                   gsi_remove (&gsi, true);
    2983                 :            :                 }
    2984                 :            :               else
    2985                 :        735 :                 gsi_next (&gsi);
    2986                 :            :             }
    2987                 :            :           else
    2988                 :   37015300 :             gsi_next (&gsi);
    2989                 :            :         }
    2990                 :            : 
    2991                 :            :       /* Combine stmts with the stmts defining their operands.
    2992                 :            :          Note we update GSI within the loop as necessary.  */
    2993                 :  270023000 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    2994                 :            :         {
    2995                 :  213033000 :           gimple *stmt = gsi_stmt (gsi);
    2996                 :            : 
    2997                 :            :           /* Mark stmt as potentially needing revisiting.  */
    2998                 :  213033000 :           gimple_set_plf (stmt, GF_PLF_1, false);
    2999                 :            : 
    3000                 :            :           /* Substitute from our lattice.  We need to do so only once.  */
    3001                 :  213033000 :           bool substituted_p = false;
    3002                 :  213033000 :           use_operand_p usep;
    3003                 :  213033000 :           ssa_op_iter iter;
    3004                 :  311124000 :           FOR_EACH_SSA_USE_OPERAND (usep, stmt, iter, SSA_OP_USE)
    3005                 :            :             {
    3006                 :   98091300 :               tree use = USE_FROM_PTR (usep);
    3007                 :   98091300 :               tree val = fwprop_ssa_val (use);
    3008                 :   98091300 :               if (val && val != use && may_propagate_copy (use, val))
    3009                 :            :                 {
    3010                 :    1413900 :                   propagate_value (usep, val);
    3011                 :    1413900 :                   substituted_p = true;
    3012                 :            :                 }
    3013                 :            :             }
    3014                 :  213033000 :           if (substituted_p
    3015                 :    1365300 :               && is_gimple_assign (stmt)
    3016                 :  213884000 :               && gimple_assign_rhs_code (stmt) == ADDR_EXPR)
    3017                 :      16218 :             recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
    3018                 :            : 
    3019                 :  214671000 :           bool changed;
    3020                 :  214671000 :           do
    3021                 :            :             {
    3022                 :  214671000 :               gimple *orig_stmt = stmt = gsi_stmt (gsi);
    3023                 :  214671000 :               bool was_noreturn = (is_gimple_call (stmt)
    3024                 :  214671000 :                                    && gimple_call_noreturn_p (stmt));
    3025                 :  214671000 :               changed = false;
    3026                 :            : 
    3027                 :  214671000 :               if (fold_stmt (&gsi, fwprop_ssa_val))
    3028                 :            :                 {
    3029                 :    3248020 :                   changed = true;
    3030                 :    3248020 :                   stmt = gsi_stmt (gsi);
    3031                 :            :                   /* Cleanup the CFG if we simplified a condition to
    3032                 :            :                      true or false.  */
    3033                 :    3248020 :                   if (gcond *cond = dyn_cast <gcond *> (stmt))
    3034                 :    2089620 :                     if (gimple_cond_true_p (cond)
    3035                 :    2089620 :                         || gimple_cond_false_p (cond))
    3036                 :      32621 :                       cfg_changed = true;
    3037                 :            :                 }
    3038                 :            : 
    3039                 :  214671000 :               if (changed || substituted_p)
    3040                 :            :                 {
    3041                 :    4255420 :                   if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
    3042                 :         55 :                     bitmap_set_bit (to_purge, bb->index);
    3043                 :    4255420 :                   if (!was_noreturn
    3044                 :    4255420 :                       && is_gimple_call (stmt) && gimple_call_noreturn_p (stmt))
    3045                 :         12 :                     to_fixup.safe_push (stmt);
    3046                 :    4255420 :                   update_stmt (stmt);
    3047                 :            :                   substituted_p = false;
    3048                 :            :                 }
    3049                 :            : 
    3050                 :  214671000 :               switch (gimple_code (stmt))
    3051                 :            :                 {
    3052                 :   68305300 :                 case GIMPLE_ASSIGN:
    3053                 :   68305300 :                   {
    3054                 :   68305300 :                     tree rhs1 = gimple_assign_rhs1 (stmt);
    3055                 :   68305300 :                     enum tree_code code = gimple_assign_rhs_code (stmt);
    3056                 :            : 
    3057                 :   68305300 :                     if (code == COND_EXPR
    3058                 :   68305300 :                         || code == VEC_COND_EXPR)
    3059                 :            :                       {
    3060                 :            :                         /* In this case the entire COND_EXPR is in rhs1. */
    3061                 :      47608 :                         if (forward_propagate_into_cond (&gsi))
    3062                 :            :                           {
    3063                 :        537 :                             changed = true;
    3064                 :        537 :                             stmt = gsi_stmt (gsi);
    3065                 :            :                           }
    3066                 :            :                       }
    3067                 :   68257700 :                     else if (TREE_CODE_CLASS (code) == tcc_comparison)
    3068                 :            :                       {
    3069                 :    1688120 :                         int did_something;
    3070                 :    1688120 :                         did_something = forward_propagate_into_comparison (&gsi);
    3071                 :    1688120 :                         if (maybe_clean_or_replace_eh_stmt (stmt, gsi_stmt (gsi)))
    3072                 :          6 :                           bitmap_set_bit (to_purge, bb->index);
    3073                 :    1688120 :                         if (did_something == 2)
    3074                 :          0 :                           cfg_changed = true;
    3075                 :    1688120 :                         changed = did_something != 0;
    3076                 :            :                       }
    3077                 :   66569500 :                     else if ((code == PLUS_EXPR
    3078                 :   66569500 :                               || code == BIT_IOR_EXPR
    3079                 :   61069400 :                               || code == BIT_XOR_EXPR)
    3080                 :   66665900 :                              && simplify_rotate (&gsi))
    3081                 :            :                       changed = true;
    3082                 :   66566900 :                     else if (code == VEC_PERM_EXPR)
    3083                 :            :                       {
    3084                 :      96575 :                         int did_something = simplify_permutation (&gsi);
    3085                 :      96575 :                         if (did_something == 2)
    3086                 :          0 :                           cfg_changed = true;
    3087                 :      96575 :                         changed = did_something != 0;
    3088                 :            :                       }
    3089                 :   66470300 :                     else if (code == BIT_FIELD_REF)
    3090                 :     140877 :                       changed = simplify_bitfield_ref (&gsi);
    3091                 :   66329400 :                     else if (code == CONSTRUCTOR
    3092                 :   71735000 :                              && TREE_CODE (TREE_TYPE (rhs1)) == VECTOR_TYPE)
    3093                 :      35539 :                       changed = simplify_vector_constructor (&gsi);
    3094                 :   66293900 :                     else if (code == ARRAY_REF)
    3095                 :    1333730 :                       changed = simplify_count_trailing_zeroes (&gsi);
    3096                 :            :                     break;
    3097                 :            :                   }
    3098                 :            : 
    3099                 :      66056 :                 case GIMPLE_SWITCH:
    3100                 :      66056 :                   changed = simplify_gimple_switch (as_a <gswitch *> (stmt));
    3101                 :      66056 :                   break;
    3102                 :            : 
    3103                 :   11523500 :                 case GIMPLE_COND:
    3104                 :   11523500 :                   {
    3105                 :   11523500 :                     int did_something = forward_propagate_into_gimple_cond
    3106                 :   11523500 :                                                         (as_a <gcond *> (stmt));
    3107                 :   11523500 :                     if (did_something == 2)
    3108                 :       1669 :                       cfg_changed = true;
    3109                 :   11523500 :                     changed = did_something != 0;
    3110                 :   11523500 :                     break;
    3111                 :            :                   }
    3112                 :            : 
    3113                 :   14843300 :                 case GIMPLE_CALL:
    3114                 :   14843300 :                   {
    3115                 :   14843300 :                     tree callee = gimple_call_fndecl (stmt);
    3116                 :   14843300 :                     if (callee != NULL_TREE
    3117                 :   14843300 :                         && fndecl_built_in_p (callee, BUILT_IN_NORMAL))
    3118                 :    3257680 :                       changed = simplify_builtin_call (&gsi, callee);
    3119                 :            :                     break;
    3120                 :            :                   }
    3121                 :            : 
    3122                 :  214669000 :                 default:;
    3123                 :            :                 }
    3124                 :            : 
    3125                 :  214669000 :               if (changed)
    3126                 :            :                 {
    3127                 :            :                   /* If the stmt changed then re-visit it and the statements
    3128                 :            :                      inserted before it.  */
    3129                 :    5089070 :                   for (; !gsi_end_p (gsi); gsi_prev (&gsi))
    3130                 :    3194520 :                     if (gimple_plf (gsi_stmt (gsi), GF_PLF_1))
    3131                 :            :                       break;
    3132                 :    1638410 :                   if (gsi_end_p (gsi))
    3133                 :     338442 :                     gsi = gsi_start_bb (bb);
    3134                 :            :                   else
    3135                 :    1469180 :                     gsi_next (&gsi);
    3136                 :            :                 }
    3137                 :            :             }
    3138                 :            :           while (changed);
    3139                 :            : 
    3140                 :            :           /* Stmt no longer needs to be revisited.  */
    3141                 :  213033000 :           stmt = gsi_stmt (gsi);
    3142                 :  213033000 :           gcc_checking_assert (!gimple_plf (stmt, GF_PLF_1));
    3143                 :  213033000 :           gimple_set_plf (stmt, GF_PLF_1, true);
    3144                 :            : 
    3145                 :            :           /* Fill up the lattice.  */
    3146                 :  213033000 :           if (gimple_assign_single_p (stmt))
    3147                 :            :             {
    3148                 :   46870100 :               tree lhs = gimple_assign_lhs (stmt);
    3149                 :   46870100 :               tree rhs = gimple_assign_rhs1 (stmt);
    3150                 :   46870100 :               if (TREE_CODE (lhs) == SSA_NAME)
    3151                 :            :                 {
    3152                 :   20391800 :                   tree val = lhs;
    3153                 :   20391800 :                   if (TREE_CODE (rhs) == SSA_NAME)
    3154                 :     519906 :                     val = fwprop_ssa_val (rhs);
    3155                 :   19871900 :                   else if (is_gimple_min_invariant (rhs))
    3156                 :     363017 :                     val = rhs;
    3157                 :            :                   /* If we can propagate the lattice-value mark the
    3158                 :            :                      stmt for removal.  */
    3159                 :   20391800 :                   if (val != lhs
    3160                 :   20391800 :                       && may_propagate_copy (lhs, val))
    3161                 :     879813 :                     to_remove.safe_push (stmt);
    3162                 :   20391800 :                   fwprop_set_lattice_val (lhs, val);
    3163                 :            :                 }
    3164                 :            :             }
    3165                 :  166163000 :           else if (gimple_nop_p (stmt))
    3166                 :      67309 :             to_remove.safe_push (stmt);
    3167                 :            :         }
    3168                 :            : 
    3169                 :            :       /* Substitute in destination PHI arguments.  */
    3170                 :   28495200 :       edge_iterator ei;
    3171                 :   28495200 :       edge e;
    3172                 :   68702300 :       FOR_EACH_EDGE (e, ei, bb->succs)
    3173                 :   40207100 :         for (gphi_iterator gsi = gsi_start_phis (e->dest);
    3174                 :   65953700 :              !gsi_end_p (gsi); gsi_next (&gsi))
    3175                 :            :           {
    3176                 :   25746600 :             gphi *phi = gsi.phi ();
    3177                 :   25746600 :             use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
    3178                 :   25746600 :             tree arg = USE_FROM_PTR (use_p);
    3179                 :   43635000 :             if (TREE_CODE (arg) != SSA_NAME
    3180                 :   25746600 :                 || virtual_operand_p (arg))
    3181                 :   17888400 :               continue;
    3182                 :    7858140 :             tree val = fwprop_ssa_val (arg);
    3183                 :    7858140 :             if (val != arg
    3184                 :    7858140 :                 && may_propagate_copy (arg, val))
    3185                 :     128825 :               propagate_value (use_p, val);
    3186                 :            :           }
    3187                 :            :     }
    3188                 :    3639140 :   free (postorder);
    3189                 :    3639140 :   lattice.release ();
    3190                 :            : 
    3191                 :            :   /* Remove stmts in reverse order to make debug stmt creation possible.  */
    3192                 :    4751850 :   while (!to_remove.is_empty())
    3193                 :            :     {
    3194                 :    1112700 :       gimple *stmt = to_remove.pop ();
    3195                 :    1112700 :       if (dump_file && (dump_flags & TDF_DETAILS))
    3196                 :            :         {
    3197                 :          4 :           fprintf (dump_file, "Removing dead stmt ");
    3198                 :          4 :           print_gimple_stmt (dump_file, stmt, 0);
    3199                 :          4 :           fprintf (dump_file, "\n");
    3200                 :            :         }
    3201                 :    1112700 :       gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    3202                 :    1112700 :       if (gimple_code (stmt) == GIMPLE_PHI)
    3203                 :     165580 :         remove_phi_node (&gsi, true);
    3204                 :            :       else
    3205                 :            :         {
    3206                 :     947122 :           unlink_stmt_vdef (stmt);
    3207                 :     947122 :           gsi_remove (&gsi, true);
    3208                 :     947122 :           release_defs (stmt);
    3209                 :            :         }
    3210                 :            :     }
    3211                 :            : 
    3212                 :            :   /* Fixup stmts that became noreturn calls.  This may require splitting
    3213                 :            :      blocks and thus isn't possible during the walk.  Do this
    3214                 :            :      in reverse order so we don't inadvertedly remove a stmt we want to
    3215                 :            :      fixup by visiting a dominating now noreturn call first.  */
    3216                 :    3639160 :   while (!to_fixup.is_empty ())
    3217                 :            :     {
    3218                 :         12 :       gimple *stmt = to_fixup.pop ();
    3219                 :         12 :       if (dump_file && dump_flags & TDF_DETAILS)
    3220                 :            :         {
    3221                 :          0 :           fprintf (dump_file, "Fixing up noreturn call ");
    3222                 :          0 :           print_gimple_stmt (dump_file, stmt, 0);
    3223                 :          0 :           fprintf (dump_file, "\n");
    3224                 :            :         }
    3225                 :         12 :       cfg_changed |= fixup_noreturn_call (stmt);
    3226                 :            :     }
    3227                 :            : 
    3228                 :    3639140 :   cfg_changed |= gimple_purge_all_dead_eh_edges (to_purge);
    3229                 :    3639140 :   BITMAP_FREE (to_purge);
    3230                 :            : 
    3231                 :    3639140 :   if (cfg_changed)
    3232                 :      20709 :     todoflags |= TODO_cleanup_cfg;
    3233                 :            : 
    3234                 :    3639140 :   return todoflags;
    3235                 :            : }
    3236                 :            : 
    3237                 :            : } // anon namespace
    3238                 :            : 
    3239                 :            : gimple_opt_pass *
    3240                 :     200540 : make_pass_forwprop (gcc::context *ctxt)
    3241                 :            : {
    3242                 :     200540 :   return new pass_forwprop (ctxt);
    3243                 :            : }

Generated by: LCOV version 1.0

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