LCOV - code coverage report
Current view: top level - gcc - tree-ssa-reassoc.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2960 3218 92.0 %
Date: 2020-05-30 12:51:24 Functions: 93 96 96.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Reassociation for trees.
       2                 :            :    Copyright (C) 2005-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Daniel Berlin <dan@dberlin.org>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "backend.h"
      25                 :            : #include "target.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "cfghooks.h"
      30                 :            : #include "alloc-pool.h"
      31                 :            : #include "tree-pass.h"
      32                 :            : #include "memmodel.h"
      33                 :            : #include "tm_p.h"
      34                 :            : #include "ssa.h"
      35                 :            : #include "optabs-tree.h"
      36                 :            : #include "gimple-pretty-print.h"
      37                 :            : #include "diagnostic-core.h"
      38                 :            : #include "fold-const.h"
      39                 :            : #include "stor-layout.h"
      40                 :            : #include "cfganal.h"
      41                 :            : #include "gimple-fold.h"
      42                 :            : #include "tree-eh.h"
      43                 :            : #include "gimple-iterator.h"
      44                 :            : #include "gimplify-me.h"
      45                 :            : #include "tree-cfg.h"
      46                 :            : #include "tree-ssa-loop.h"
      47                 :            : #include "flags.h"
      48                 :            : #include "tree-ssa.h"
      49                 :            : #include "langhooks.h"
      50                 :            : #include "cfgloop.h"
      51                 :            : #include "builtins.h"
      52                 :            : #include "gimplify.h"
      53                 :            : #include "case-cfn-macros.h"
      54                 :            : 
      55                 :            : /*  This is a simple global reassociation pass.  It is, in part, based
      56                 :            :     on the LLVM pass of the same name (They do some things more/less
      57                 :            :     than we do, in different orders, etc).
      58                 :            : 
      59                 :            :     It consists of five steps:
      60                 :            : 
      61                 :            :     1. Breaking up subtract operations into addition + negate, where
      62                 :            :     it would promote the reassociation of adds.
      63                 :            : 
      64                 :            :     2. Left linearization of the expression trees, so that (A+B)+(C+D)
      65                 :            :     becomes (((A+B)+C)+D), which is easier for us to rewrite later.
      66                 :            :     During linearization, we place the operands of the binary
      67                 :            :     expressions into a vector of operand_entry_*
      68                 :            : 
      69                 :            :     3. Optimization of the operand lists, eliminating things like a +
      70                 :            :     -a, a & a, etc.
      71                 :            : 
      72                 :            :     3a. Combine repeated factors with the same occurrence counts
      73                 :            :     into a __builtin_powi call that will later be optimized into
      74                 :            :     an optimal number of multiplies.
      75                 :            : 
      76                 :            :     4. Rewrite the expression trees we linearized and optimized so
      77                 :            :     they are in proper rank order.
      78                 :            : 
      79                 :            :     5. Repropagate negates, as nothing else will clean it up ATM.
      80                 :            : 
      81                 :            :     A bit of theory on #4, since nobody seems to write anything down
      82                 :            :     about why it makes sense to do it the way they do it:
      83                 :            : 
      84                 :            :     We could do this much nicer theoretically, but don't (for reasons
      85                 :            :     explained after how to do it theoretically nice :P).
      86                 :            : 
      87                 :            :     In order to promote the most redundancy elimination, you want
      88                 :            :     binary expressions whose operands are the same rank (or
      89                 :            :     preferably, the same value) exposed to the redundancy eliminator,
      90                 :            :     for possible elimination.
      91                 :            : 
      92                 :            :     So the way to do this if we really cared, is to build the new op
      93                 :            :     tree from the leaves to the roots, merging as you go, and putting the
      94                 :            :     new op on the end of the worklist, until you are left with one
      95                 :            :     thing on the worklist.
      96                 :            : 
      97                 :            :     IE if you have to rewrite the following set of operands (listed with
      98                 :            :     rank in parentheses), with opcode PLUS_EXPR:
      99                 :            : 
     100                 :            :     a (1),  b (1),  c (1),  d (2), e (2)
     101                 :            : 
     102                 :            : 
     103                 :            :     We start with our merge worklist empty, and the ops list with all of
     104                 :            :     those on it.
     105                 :            : 
     106                 :            :     You want to first merge all leaves of the same rank, as much as
     107                 :            :     possible.
     108                 :            : 
     109                 :            :     So first build a binary op of
     110                 :            : 
     111                 :            :     mergetmp = a + b, and put "mergetmp" on the merge worklist.
     112                 :            : 
     113                 :            :     Because there is no three operand form of PLUS_EXPR, c is not going to
     114                 :            :     be exposed to redundancy elimination as a rank 1 operand.
     115                 :            : 
     116                 :            :     So you might as well throw it on the merge worklist (you could also
     117                 :            :     consider it to now be a rank two operand, and merge it with d and e,
     118                 :            :     but in this case, you then have evicted e from a binary op. So at
     119                 :            :     least in this situation, you can't win.)
     120                 :            : 
     121                 :            :     Then build a binary op of d + e
     122                 :            :     mergetmp2 = d + e
     123                 :            : 
     124                 :            :     and put mergetmp2 on the merge worklist.
     125                 :            : 
     126                 :            :     so merge worklist = {mergetmp, c, mergetmp2}
     127                 :            : 
     128                 :            :     Continue building binary ops of these operations until you have only
     129                 :            :     one operation left on the worklist.
     130                 :            : 
     131                 :            :     So we have
     132                 :            : 
     133                 :            :     build binary op
     134                 :            :     mergetmp3 = mergetmp + c
     135                 :            : 
     136                 :            :     worklist = {mergetmp2, mergetmp3}
     137                 :            : 
     138                 :            :     mergetmp4 = mergetmp2 + mergetmp3
     139                 :            : 
     140                 :            :     worklist = {mergetmp4}
     141                 :            : 
     142                 :            :     because we have one operation left, we can now just set the original
     143                 :            :     statement equal to the result of that operation.
     144                 :            : 
     145                 :            :     This will at least expose a + b  and d + e to redundancy elimination
     146                 :            :     as binary operations.
     147                 :            : 
     148                 :            :     For extra points, you can reuse the old statements to build the
     149                 :            :     mergetmps, since you shouldn't run out.
     150                 :            : 
     151                 :            :     So why don't we do this?
     152                 :            : 
     153                 :            :     Because it's expensive, and rarely will help.  Most trees we are
     154                 :            :     reassociating have 3 or less ops.  If they have 2 ops, they already
     155                 :            :     will be written into a nice single binary op.  If you have 3 ops, a
     156                 :            :     single simple check suffices to tell you whether the first two are of the
     157                 :            :     same rank.  If so, you know to order it
     158                 :            : 
     159                 :            :     mergetmp = op1 + op2
     160                 :            :     newstmt = mergetmp + op3
     161                 :            : 
     162                 :            :     instead of
     163                 :            :     mergetmp = op2 + op3
     164                 :            :     newstmt = mergetmp + op1
     165                 :            : 
     166                 :            :     If all three are of the same rank, you can't expose them all in a
     167                 :            :     single binary operator anyway, so the above is *still* the best you
     168                 :            :     can do.
     169                 :            : 
     170                 :            :     Thus, this is what we do.  When we have three ops left, we check to see
     171                 :            :     what order to put them in, and call it a day.  As a nod to vector sum
     172                 :            :     reduction, we check if any of the ops are really a phi node that is a
     173                 :            :     destructive update for the associating op, and keep the destructive
     174                 :            :     update together for vector sum reduction recognition.  */
     175                 :            : 
     176                 :            : /* Enable insertion of __builtin_powi calls during execute_reassoc.  See
     177                 :            :    point 3a in the pass header comment.  */
     178                 :            : static bool reassoc_insert_powi_p;
     179                 :            : 
     180                 :            : /* Statistics */
     181                 :            : static struct
     182                 :            : {
     183                 :            :   int linearized;
     184                 :            :   int constants_eliminated;
     185                 :            :   int ops_eliminated;
     186                 :            :   int rewritten;
     187                 :            :   int pows_encountered;
     188                 :            :   int pows_created;
     189                 :            : } reassociate_stats;
     190                 :            : 
     191                 :            : /* Operator, rank pair.  */
     192                 :            : struct operand_entry
     193                 :            : {
     194                 :            :   unsigned int rank;
     195                 :            :   unsigned int id;
     196                 :            :   tree op;
     197                 :            :   unsigned int count;
     198                 :            :   gimple *stmt_to_insert;
     199                 :            : };
     200                 :            : 
     201                 :            : static object_allocator<operand_entry> operand_entry_pool
     202                 :            :   ("operand entry pool");
     203                 :            : 
     204                 :            : /* This is used to assign a unique ID to each struct operand_entry
     205                 :            :    so that qsort results are identical on different hosts.  */
     206                 :            : static unsigned int next_operand_entry_id;
     207                 :            : 
     208                 :            : /* Starting rank number for a given basic block, so that we can rank
     209                 :            :    operations using unmovable instructions in that BB based on the bb
     210                 :            :    depth.  */
     211                 :            : static long *bb_rank;
     212                 :            : 
     213                 :            : /* Operand->rank hashtable.  */
     214                 :            : static hash_map<tree, long> *operand_rank;
     215                 :            : 
     216                 :            : /* Vector of SSA_NAMEs on which after reassociate_bb is done with
     217                 :            :    all basic blocks the CFG should be adjusted - basic blocks
     218                 :            :    split right after that SSA_NAME's definition statement and before
     219                 :            :    the only use, which must be a bit ior.  */
     220                 :            : static vec<tree> reassoc_branch_fixups;
     221                 :            : 
     222                 :            : /* Forward decls.  */
     223                 :            : static long get_rank (tree);
     224                 :            : static bool reassoc_stmt_dominates_stmt_p (gimple *, gimple *);
     225                 :            : 
     226                 :            : /* Wrapper around gsi_remove, which adjusts gimple_uid of debug stmts
     227                 :            :    possibly added by gsi_remove.  */
     228                 :            : 
     229                 :            : bool
     230                 :     118816 : reassoc_remove_stmt (gimple_stmt_iterator *gsi)
     231                 :            : {
     232                 :     118816 :   gimple *stmt = gsi_stmt (*gsi);
     233                 :            : 
     234                 :     118816 :   if (!MAY_HAVE_DEBUG_BIND_STMTS || gimple_code (stmt) == GIMPLE_PHI)
     235                 :      59325 :     return gsi_remove (gsi, true);
     236                 :            : 
     237                 :      59491 :   gimple_stmt_iterator prev = *gsi;
     238                 :      59491 :   gsi_prev (&prev);
     239                 :      59491 :   unsigned uid = gimple_uid (stmt);
     240                 :      59491 :   basic_block bb = gimple_bb (stmt);
     241                 :      59491 :   bool ret = gsi_remove (gsi, true);
     242                 :      59491 :   if (!gsi_end_p (prev))
     243                 :      58606 :     gsi_next (&prev);
     244                 :            :   else
     245                 :       1770 :     prev = gsi_start_bb (bb);
     246                 :      59491 :   gimple *end_stmt = gsi_stmt (*gsi);
     247                 :      61719 :   while ((stmt = gsi_stmt (prev)) != end_stmt)
     248                 :            :     {
     249                 :       2228 :       gcc_assert (stmt && is_gimple_debug (stmt) && gimple_uid (stmt) == 0);
     250                 :       2228 :       gimple_set_uid (stmt, uid);
     251                 :       2228 :       gsi_next (&prev);
     252                 :            :     }
     253                 :            :   return ret;
     254                 :            : }
     255                 :            : 
     256                 :            : /* Bias amount for loop-carried phis.  We want this to be larger than
     257                 :            :    the depth of any reassociation tree we can see, but not larger than
     258                 :            :    the rank difference between two blocks.  */
     259                 :            : #define PHI_LOOP_BIAS (1 << 15)
     260                 :            : 
     261                 :            : /* Rank assigned to a phi statement.  If STMT is a loop-carried phi of
     262                 :            :    an innermost loop, and the phi has only a single use which is inside
     263                 :            :    the loop, then the rank is the block rank of the loop latch plus an
     264                 :            :    extra bias for the loop-carried dependence.  This causes expressions
     265                 :            :    calculated into an accumulator variable to be independent for each
     266                 :            :    iteration of the loop.  If STMT is some other phi, the rank is the
     267                 :            :    block rank of its containing block.  */
     268                 :            : static long
     269                 :    2024220 : phi_rank (gimple *stmt)
     270                 :            : {
     271                 :    2024220 :   basic_block bb = gimple_bb (stmt);
     272                 :    2024220 :   class loop *father = bb->loop_father;
     273                 :    2024220 :   tree res;
     274                 :    2024220 :   unsigned i;
     275                 :    2024220 :   use_operand_p use;
     276                 :    2024220 :   gimple *use_stmt;
     277                 :            : 
     278                 :            :   /* We only care about real loops (those with a latch).  */
     279                 :    2024220 :   if (!father->latch)
     280                 :       1551 :     return bb_rank[bb->index];
     281                 :            : 
     282                 :            :   /* Interesting phis must be in headers of innermost loops.  */
     283                 :    2022670 :   if (bb != father->header
     284                 :    1423940 :       || father->inner)
     285                 :    1016090 :     return bb_rank[bb->index];
     286                 :            : 
     287                 :            :   /* Ignore virtual SSA_NAMEs.  */
     288                 :    1006580 :   res = gimple_phi_result (stmt);
     289                 :    2013160 :   if (virtual_operand_p (res))
     290                 :          0 :     return bb_rank[bb->index];
     291                 :            : 
     292                 :            :   /* The phi definition must have a single use, and that use must be
     293                 :            :      within the loop.  Otherwise this isn't an accumulator pattern.  */
     294                 :    1006580 :   if (!single_imm_use (res, &use, &use_stmt)
     295                 :    1006580 :       || gimple_bb (use_stmt)->loop_father != father)
     296                 :     910957 :     return bb_rank[bb->index];
     297                 :            : 
     298                 :            :   /* Look for phi arguments from within the loop.  If found, bias this phi.  */
     299                 :     176388 :   for (i = 0; i < gimple_phi_num_args (stmt); i++)
     300                 :            :     {
     301                 :     176090 :       tree arg = gimple_phi_arg_def (stmt, i);
     302                 :     176090 :       if (TREE_CODE (arg) == SSA_NAME
     303                 :     176090 :           && !SSA_NAME_IS_DEFAULT_DEF (arg))
     304                 :            :         {
     305                 :     132781 :           gimple *def_stmt = SSA_NAME_DEF_STMT (arg);
     306                 :     132781 :           if (gimple_bb (def_stmt)->loop_father == father)
     307                 :      95327 :             return bb_rank[father->latch->index] + PHI_LOOP_BIAS;
     308                 :            :         }
     309                 :            :     }
     310                 :            : 
     311                 :            :   /* Must be an uninteresting phi.  */
     312                 :        298 :   return bb_rank[bb->index];
     313                 :            : }
     314                 :            : 
     315                 :            : /* If EXP is an SSA_NAME defined by a PHI statement that represents a
     316                 :            :    loop-carried dependence of an innermost loop, return TRUE; else
     317                 :            :    return FALSE.  */
     318                 :            : static bool
     319                 :    4464950 : loop_carried_phi (tree exp)
     320                 :            : {
     321                 :    4464950 :   gimple *phi_stmt;
     322                 :    4464950 :   long block_rank;
     323                 :            : 
     324                 :    4464950 :   if (TREE_CODE (exp) != SSA_NAME
     325                 :    4464950 :       || SSA_NAME_IS_DEFAULT_DEF (exp))
     326                 :            :     return false;
     327                 :            : 
     328                 :    3977820 :   phi_stmt = SSA_NAME_DEF_STMT (exp);
     329                 :            : 
     330                 :    3977820 :   if (gimple_code (SSA_NAME_DEF_STMT (exp)) != GIMPLE_PHI)
     331                 :            :     return false;
     332                 :            : 
     333                 :            :   /* Non-loop-carried phis have block rank.  Loop-carried phis have
     334                 :            :      an additional bias added in.  If this phi doesn't have block rank,
     335                 :            :      it's biased and should not be propagated.  */
     336                 :     689582 :   block_rank = bb_rank[gimple_bb (phi_stmt)->index];
     337                 :            : 
     338                 :     689582 :   if (phi_rank (phi_stmt) != block_rank)
     339                 :      29395 :     return true;
     340                 :            : 
     341                 :            :   return false;
     342                 :            : }
     343                 :            : 
     344                 :            : /* Return the maximum of RANK and the rank that should be propagated
     345                 :            :    from expression OP.  For most operands, this is just the rank of OP.
     346                 :            :    For loop-carried phis, the value is zero to avoid undoing the bias
     347                 :            :    in favor of the phi.  */
     348                 :            : static long
     349                 :    4464950 : propagate_rank (long rank, tree op)
     350                 :            : {
     351                 :    4464950 :   long op_rank;
     352                 :            : 
     353                 :    4464950 :   if (loop_carried_phi (op))
     354                 :            :     return rank;
     355                 :            : 
     356                 :    4435550 :   op_rank = get_rank (op);
     357                 :            : 
     358                 :    4435550 :   return MAX (rank, op_rank);
     359                 :            : }
     360                 :            : 
     361                 :            : /* Look up the operand rank structure for expression E.  */
     362                 :            : 
     363                 :            : static inline long
     364                 :    6471730 : find_operand_rank (tree e)
     365                 :            : {
     366                 :    6471730 :   long *slot = operand_rank->get (e);
     367                 :    2387440 :   return slot ? *slot : -1;
     368                 :            : }
     369                 :            : 
     370                 :            : /* Insert {E,RANK} into the operand rank hashtable.  */
     371                 :            : 
     372                 :            : static inline void
     373                 :    7908000 : insert_operand_rank (tree e, long rank)
     374                 :            : {
     375                 :    7908000 :   gcc_assert (rank > 0);
     376                 :    7908000 :   gcc_assert (!operand_rank->put (e, rank));
     377                 :    7908000 : }
     378                 :            : 
     379                 :            : /* Given an expression E, return the rank of the expression.  */
     380                 :            : 
     381                 :            : static long
     382                 :    9960100 : get_rank (tree e)
     383                 :            : {
     384                 :            :   /* SSA_NAME's have the rank of the expression they are the result
     385                 :            :      of.
     386                 :            :      For globals and uninitialized values, the rank is 0.
     387                 :            :      For function arguments, use the pre-setup rank.
     388                 :            :      For PHI nodes, stores, asm statements, etc, we use the rank of
     389                 :            :      the BB.
     390                 :            :      For simple operations, the rank is the maximum rank of any of
     391                 :            :      its operands, or the bb_rank, whichever is less.
     392                 :            :      I make no claims that this is optimal, however, it gives good
     393                 :            :      results.  */
     394                 :            : 
     395                 :            :   /* We make an exception to the normal ranking system to break
     396                 :            :      dependences of accumulator variables in loops.  Suppose we
     397                 :            :      have a simple one-block loop containing:
     398                 :            : 
     399                 :            :        x_1 = phi(x_0, x_2)
     400                 :            :        b = a + x_1
     401                 :            :        c = b + d
     402                 :            :        x_2 = c + e
     403                 :            : 
     404                 :            :      As shown, each iteration of the calculation into x is fully
     405                 :            :      dependent upon the iteration before it.  We would prefer to
     406                 :            :      see this in the form:
     407                 :            : 
     408                 :            :        x_1 = phi(x_0, x_2)
     409                 :            :        b = a + d
     410                 :            :        c = b + e
     411                 :            :        x_2 = c + x_1
     412                 :            : 
     413                 :            :      If the loop is unrolled, the calculations of b and c from
     414                 :            :      different iterations can be interleaved.
     415                 :            : 
     416                 :            :      To obtain this result during reassociation, we bias the rank
     417                 :            :      of the phi definition x_1 upward, when it is recognized as an
     418                 :            :      accumulator pattern.  The artificial rank causes it to be 
     419                 :            :      added last, providing the desired independence.  */
     420                 :            : 
     421                 :    9960100 :   if (TREE_CODE (e) == SSA_NAME)
     422                 :            :     {
     423                 :    8049780 :       ssa_op_iter iter;
     424                 :    8049780 :       gimple *stmt;
     425                 :    8049780 :       long rank;
     426                 :    8049780 :       tree op;
     427                 :            : 
     428                 :    8049780 :       if (SSA_NAME_IS_DEFAULT_DEF (e))
     429                 :     575038 :         return find_operand_rank (e);
     430                 :            : 
     431                 :    7474740 :       stmt = SSA_NAME_DEF_STMT (e);
     432                 :    7474740 :       if (gimple_code (stmt) == GIMPLE_PHI)
     433                 :    1334640 :         return phi_rank (stmt);
     434                 :            : 
     435                 :    6140100 :       if (!is_gimple_assign (stmt))
     436                 :     243408 :         return bb_rank[gimple_bb (stmt)->index];
     437                 :            : 
     438                 :            :       /* If we already have a rank for this expression, use that.  */
     439                 :    5896690 :       rank = find_operand_rank (e);
     440                 :    5896690 :       if (rank != -1)
     441                 :            :         return rank;
     442                 :            : 
     443                 :            :       /* Otherwise, find the maximum rank for the operands.  As an
     444                 :            :          exception, remove the bias from loop-carried phis when propagating
     445                 :            :          the rank so that dependent operations are not also biased.  */
     446                 :            :       /* Simply walk over all SSA uses - this takes advatage of the
     447                 :            :          fact that non-SSA operands are is_gimple_min_invariant and
     448                 :            :          thus have rank 0.  */
     449                 :    4084290 :       rank = 0;
     450                 :    8549240 :       FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
     451                 :    4464950 :         rank = propagate_rank (rank, op);
     452                 :            : 
     453                 :    4084290 :       if (dump_file && (dump_flags & TDF_DETAILS))
     454                 :            :         {
     455                 :        161 :           fprintf (dump_file, "Rank for ");
     456                 :        161 :           print_generic_expr (dump_file, e);
     457                 :        161 :           fprintf (dump_file, " is %ld\n", (rank + 1));
     458                 :            :         }
     459                 :            : 
     460                 :            :       /* Note the rank in the hashtable so we don't recompute it.  */
     461                 :    4084290 :       insert_operand_rank (e, (rank + 1));
     462                 :    4084290 :       return (rank + 1);
     463                 :            :     }
     464                 :            : 
     465                 :            :   /* Constants, globals, etc., are rank 0 */
     466                 :            :   return 0;
     467                 :            : }
     468                 :            : 
     469                 :            : 
     470                 :            : /* We want integer ones to end up last no matter what, since they are
     471                 :            :    the ones we can do the most with.  */
     472                 :            : #define INTEGER_CONST_TYPE 1 << 4
     473                 :            : #define FLOAT_ONE_CONST_TYPE 1 << 3
     474                 :            : #define FLOAT_CONST_TYPE 1 << 2
     475                 :            : #define OTHER_CONST_TYPE 1 << 1
     476                 :            : 
     477                 :            : /* Classify an invariant tree into integer, float, or other, so that
     478                 :            :    we can sort them to be near other constants of the same type.  */
     479                 :            : static inline int
     480                 :     870590 : constant_type (tree t)
     481                 :            : {
     482                 :     870590 :   if (INTEGRAL_TYPE_P (TREE_TYPE (t)))
     483                 :            :     return INTEGER_CONST_TYPE;
     484                 :       6794 :   else if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (t)))
     485                 :            :     {
     486                 :            :       /* Sort -1.0 and 1.0 constants last, while in some cases
     487                 :            :          const_binop can't optimize some inexact operations, multiplication
     488                 :            :          by -1.0 or 1.0 can be always merged with others.  */
     489                 :       6666 :       if (real_onep (t) || real_minus_onep (t))
     490                 :        816 :         return FLOAT_ONE_CONST_TYPE;
     491                 :            :       return FLOAT_CONST_TYPE;
     492                 :            :     }
     493                 :            :   else
     494                 :            :     return OTHER_CONST_TYPE;
     495                 :            : }
     496                 :            : 
     497                 :            : /* qsort comparison function to sort operand entries PA and PB by rank
     498                 :            :    so that the sorted array is ordered by rank in decreasing order.  */
     499                 :            : static int
     500                 :   12596300 : sort_by_operand_rank (const void *pa, const void *pb)
     501                 :            : {
     502                 :   12596300 :   const operand_entry *oea = *(const operand_entry *const *)pa;
     503                 :   12596300 :   const operand_entry *oeb = *(const operand_entry *const *)pb;
     504                 :            : 
     505                 :   12596300 :   if (oeb->rank != oea->rank)
     506                 :   18011800 :     return oeb->rank > oea->rank ? 1 : -1;
     507                 :            : 
     508                 :            :   /* It's nicer for optimize_expression if constants that are likely
     509                 :            :      to fold when added/multiplied/whatever are put next to each
     510                 :            :      other.  Since all constants have rank 0, order them by type.  */
     511                 :    2006340 :   if (oea->rank == 0)
     512                 :            :     {
     513                 :     435237 :       if (constant_type (oeb->op) != constant_type (oea->op))
     514                 :         58 :         return constant_type (oea->op) - constant_type (oeb->op);
     515                 :            :       else
     516                 :            :         /* To make sorting result stable, we use unique IDs to determine
     517                 :            :            order.  */
     518                 :     704280 :         return oeb->id > oea->id ? 1 : -1;
     519                 :            :     }
     520                 :            : 
     521                 :    1571110 :   if (TREE_CODE (oea->op) != SSA_NAME)
     522                 :            :     {
     523                 :          0 :       if (TREE_CODE (oeb->op) != SSA_NAME)
     524                 :          0 :         return oeb->id > oea->id ? 1 : -1;
     525                 :            :       else
     526                 :            :         return 1;
     527                 :            :     }
     528                 :    1571110 :   else if (TREE_CODE (oeb->op) != SSA_NAME)
     529                 :            :     return -1;
     530                 :            : 
     531                 :            :   /* Lastly, make sure the versions that are the same go next to each
     532                 :            :      other.  */
     533                 :    1571110 :   if (SSA_NAME_VERSION (oeb->op) != SSA_NAME_VERSION (oea->op))
     534                 :            :     {
     535                 :            :       /* As SSA_NAME_VERSION is assigned pretty randomly, because we reuse
     536                 :            :          versions of removed SSA_NAMEs, so if possible, prefer to sort
     537                 :            :          based on basic block and gimple_uid of the SSA_NAME_DEF_STMT.
     538                 :            :          See PR60418.  */
     539                 :    1550150 :       gimple *stmta = SSA_NAME_DEF_STMT (oea->op);
     540                 :    1550150 :       gimple *stmtb = SSA_NAME_DEF_STMT (oeb->op);
     541                 :    1550150 :       basic_block bba = gimple_bb (stmta);
     542                 :    1550150 :       basic_block bbb = gimple_bb (stmtb);
     543                 :    1550150 :       if (bbb != bba)
     544                 :            :         {
     545                 :            :           /* One of the SSA_NAMEs can be defined in oeN->stmt_to_insert
     546                 :            :              but the other might not.  */
     547                 :      91085 :           if (!bba)
     548                 :            :             return 1;
     549                 :      88737 :           if (!bbb)
     550                 :            :             return -1;
     551                 :            :           /* If neither is, compare bb_rank.  */
     552                 :      85415 :           if (bb_rank[bbb->index] != bb_rank[bba->index])
     553                 :      85415 :             return (bb_rank[bbb->index] >> 16) - (bb_rank[bba->index] >> 16);
     554                 :            :         }
     555                 :            : 
     556                 :    1459060 :       bool da = reassoc_stmt_dominates_stmt_p (stmta, stmtb);
     557                 :    1459060 :       bool db = reassoc_stmt_dominates_stmt_p (stmtb, stmta);
     558                 :    1459060 :       if (da != db)
     559                 :    2221720 :         return da ? 1 : -1;
     560                 :            : 
     561                 :      31337 :       return SSA_NAME_VERSION (oeb->op) > SSA_NAME_VERSION (oea->op) ? 1 : -1;
     562                 :            :     }
     563                 :            : 
     564                 :      20956 :   return oeb->id > oea->id ? 1 : -1;
     565                 :            : }
     566                 :            : 
     567                 :            : /* Add an operand entry to *OPS for the tree operand OP.  */
     568                 :            : 
     569                 :            : static void
     570                 :    5524270 : add_to_ops_vec (vec<operand_entry *> *ops, tree op, gimple *stmt_to_insert = NULL)
     571                 :            : {
     572                 :    5524270 :   operand_entry *oe = operand_entry_pool.allocate ();
     573                 :            : 
     574                 :    5524270 :   oe->op = op;
     575                 :    5524270 :   oe->rank = get_rank (op);
     576                 :    5524270 :   oe->id = next_operand_entry_id++;
     577                 :    5524270 :   oe->count = 1;
     578                 :    5524270 :   oe->stmt_to_insert = stmt_to_insert;
     579                 :    5524270 :   ops->safe_push (oe);
     580                 :    5524270 : }
     581                 :            : 
     582                 :            : /* Add an operand entry to *OPS for the tree operand OP with repeat
     583                 :            :    count REPEAT.  */
     584                 :            : 
     585                 :            : static void
     586                 :         19 : add_repeat_to_ops_vec (vec<operand_entry *> *ops, tree op,
     587                 :            :                        HOST_WIDE_INT repeat)
     588                 :            : {
     589                 :         19 :   operand_entry *oe = operand_entry_pool.allocate ();
     590                 :            : 
     591                 :         19 :   oe->op = op;
     592                 :         19 :   oe->rank = get_rank (op);
     593                 :         19 :   oe->id = next_operand_entry_id++;
     594                 :         19 :   oe->count = repeat;
     595                 :         19 :   oe->stmt_to_insert = NULL;
     596                 :         19 :   ops->safe_push (oe);
     597                 :            : 
     598                 :         19 :   reassociate_stats.pows_encountered++;
     599                 :         19 : }
     600                 :            : 
     601                 :            : /* Return true if STMT is reassociable operation containing a binary
     602                 :            :    operation with tree code CODE, and is inside LOOP.  */
     603                 :            : 
     604                 :            : static bool
     605                 :    4552530 : is_reassociable_op (gimple *stmt, enum tree_code code, class loop *loop)
     606                 :            : {
     607                 :    4552530 :   basic_block bb = gimple_bb (stmt);
     608                 :            : 
     609                 :    4552530 :   if (gimple_bb (stmt) == NULL)
     610                 :            :     return false;
     611                 :            : 
     612                 :    4449030 :   if (!flow_bb_inside_loop_p (loop, bb))
     613                 :            :     return false;
     614                 :            : 
     615                 :    4296460 :   if (is_gimple_assign (stmt)
     616                 :    3462720 :       && gimple_assign_rhs_code (stmt) == code
     617                 :    4808390 :       && has_single_use (gimple_assign_lhs (stmt)))
     618                 :            :     {
     619                 :     383977 :       tree rhs1 = gimple_assign_rhs1 (stmt);
     620                 :     383977 :       tree rhs2 = gimple_assign_rhs2 (stmt);
     621                 :     383977 :       if (TREE_CODE (rhs1) == SSA_NAME
     622                 :     383977 :           && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1))
     623                 :            :         return false;
     624                 :     383947 :       if (rhs2
     625                 :     356865 :           && TREE_CODE (rhs2) == SSA_NAME
     626                 :     621071 :           && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs2))
     627                 :          0 :         return false;
     628                 :            :       return true;
     629                 :            :     }
     630                 :            : 
     631                 :            :   return false;
     632                 :            : }
     633                 :            : 
     634                 :            : 
     635                 :            : /* Return true if STMT is a nop-conversion.  */
     636                 :            : 
     637                 :            : static bool
     638                 :    4278240 : gimple_nop_conversion_p (gimple *stmt)
     639                 :            : {
     640                 :    4278240 :   if (gassign *ass = dyn_cast <gassign *> (stmt))
     641                 :            :     {
     642                 :    5167420 :       if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (ass))
     643                 :    3740710 :           && tree_nop_conversion_p (TREE_TYPE (gimple_assign_lhs (ass)),
     644                 :     771557 :                                     TREE_TYPE (gimple_assign_rhs1 (ass))))
     645                 :     537978 :         return true;
     646                 :            :     }
     647                 :            :   return false;
     648                 :            : }
     649                 :            : 
     650                 :            : /* Given NAME, if NAME is defined by a unary operation OPCODE, return the
     651                 :            :    operand of the negate operation.  Otherwise, return NULL.  */
     652                 :            : 
     653                 :            : static tree
     654                 :    4218770 : get_unary_op (tree name, enum tree_code opcode)
     655                 :            : {
     656                 :    4218770 :   gimple *stmt = SSA_NAME_DEF_STMT (name);
     657                 :            : 
     658                 :            :   /* Look through nop conversions (sign changes).  */
     659                 :    4218770 :   if (gimple_nop_conversion_p (stmt)
     660                 :    4737080 :       && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
     661                 :     462927 :     stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
     662                 :            : 
     663                 :    4218770 :   if (!is_gimple_assign (stmt))
     664                 :            :     return NULL_TREE;
     665                 :            : 
     666                 :    2711930 :   if (gimple_assign_rhs_code (stmt) == opcode)
     667                 :      66719 :     return gimple_assign_rhs1 (stmt);
     668                 :            :   return NULL_TREE;
     669                 :            : }
     670                 :            : 
     671                 :            : /* Return true if OP1 and OP2 have the same value if casted to either type.  */
     672                 :            : 
     673                 :            : static bool
     674                 :      31009 : ops_equal_values_p (tree op1, tree op2)
     675                 :            : {
     676                 :      31009 :   if (op1 == op2)
     677                 :            :     return true;
     678                 :            : 
     679                 :      30238 :   tree orig_op1 = op1;
     680                 :      30238 :   if (TREE_CODE (op1) == SSA_NAME)
     681                 :            :     {
     682                 :      30237 :       gimple *stmt = SSA_NAME_DEF_STMT (op1);
     683                 :      30237 :       if (gimple_nop_conversion_p (stmt))
     684                 :            :         {
     685                 :       9679 :           op1 = gimple_assign_rhs1 (stmt);
     686                 :       9679 :           if (op1 == op2)
     687                 :            :             return true;
     688                 :            :         }
     689                 :            :     }
     690                 :            : 
     691                 :      29224 :   if (TREE_CODE (op2) == SSA_NAME)
     692                 :            :     {
     693                 :      29224 :       gimple *stmt = SSA_NAME_DEF_STMT (op2);
     694                 :      29224 :       if (gimple_nop_conversion_p (stmt))
     695                 :            :         {
     696                 :       9992 :           op2 = gimple_assign_rhs1 (stmt);
     697                 :       9992 :           if (op1 == op2
     698                 :       9992 :               || orig_op1 == op2)
     699                 :        972 :             return true;
     700                 :            :         }
     701                 :            :     }
     702                 :            : 
     703                 :            :   return false;
     704                 :            : }
     705                 :            : 
     706                 :            : 
     707                 :            : /* If CURR and LAST are a pair of ops that OPCODE allows us to
     708                 :            :    eliminate through equivalences, do so, remove them from OPS, and
     709                 :            :    return true.  Otherwise, return false.  */
     710                 :            : 
     711                 :            : static bool
     712                 :    5386590 : eliminate_duplicate_pair (enum tree_code opcode,
     713                 :            :                           vec<operand_entry *> *ops,
     714                 :            :                           bool *all_done,
     715                 :            :                           unsigned int i,
     716                 :            :                           operand_entry *curr,
     717                 :            :                           operand_entry *last)
     718                 :            : {
     719                 :            : 
     720                 :            :   /* If we have two of the same op, and the opcode is & |, min, or max,
     721                 :            :      we can eliminate one of them.
     722                 :            :      If we have two of the same op, and the opcode is ^, we can
     723                 :            :      eliminate both of them.  */
     724                 :            : 
     725                 :    5386590 :   if (last && last->op == curr->op)
     726                 :            :     {
     727                 :       4046 :       switch (opcode)
     728                 :            :         {
     729                 :         42 :         case MAX_EXPR:
     730                 :         42 :         case MIN_EXPR:
     731                 :         42 :         case BIT_IOR_EXPR:
     732                 :         42 :         case BIT_AND_EXPR:
     733                 :         42 :           if (dump_file && (dump_flags & TDF_DETAILS))
     734                 :            :             {
     735                 :          1 :               fprintf (dump_file, "Equivalence: ");
     736                 :          1 :               print_generic_expr (dump_file, curr->op);
     737                 :          1 :               fprintf (dump_file, " [&|minmax] ");
     738                 :          1 :               print_generic_expr (dump_file, last->op);
     739                 :          1 :               fprintf (dump_file, " -> ");
     740                 :          1 :               print_generic_stmt (dump_file, last->op);
     741                 :            :             }
     742                 :            : 
     743                 :         42 :           ops->ordered_remove (i);
     744                 :         42 :           reassociate_stats.ops_eliminated ++;
     745                 :            : 
     746                 :         42 :           return true;
     747                 :            : 
     748                 :         16 :         case BIT_XOR_EXPR:
     749                 :         16 :           if (dump_file && (dump_flags & TDF_DETAILS))
     750                 :            :             {
     751                 :          0 :               fprintf (dump_file, "Equivalence: ");
     752                 :          0 :               print_generic_expr (dump_file, curr->op);
     753                 :          0 :               fprintf (dump_file, " ^ ");
     754                 :          0 :               print_generic_expr (dump_file, last->op);
     755                 :          0 :               fprintf (dump_file, " -> nothing\n");
     756                 :            :             }
     757                 :            : 
     758                 :         16 :           reassociate_stats.ops_eliminated += 2;
     759                 :            : 
     760                 :         16 :           if (ops->length () == 2)
     761                 :            :             {
     762                 :          1 :               ops->truncate (0);
     763                 :          1 :               add_to_ops_vec (ops, build_zero_cst (TREE_TYPE (last->op)));
     764                 :          1 :               *all_done = true;
     765                 :            :             }
     766                 :            :           else
     767                 :            :             {
     768                 :         15 :               ops->ordered_remove (i-1);
     769                 :         15 :               ops->ordered_remove (i-1);
     770                 :            :             }
     771                 :            : 
     772                 :         16 :           return true;
     773                 :            : 
     774                 :            :         default:
     775                 :            :           break;
     776                 :            :         }
     777                 :            :     }
     778                 :            :   return false;
     779                 :            : }
     780                 :            : 
     781                 :            : static vec<tree> plus_negates;
     782                 :            : 
     783                 :            : /* If OPCODE is PLUS_EXPR, CURR->OP is a negate expression or a bitwise not
     784                 :            :    expression, look in OPS for a corresponding positive operation to cancel
     785                 :            :    it out.  If we find one, remove the other from OPS, replace
     786                 :            :    OPS[CURRINDEX] with 0 or -1, respectively, and return true.  Otherwise,
     787                 :            :    return false. */
     788                 :            : 
     789                 :            : static bool
     790                 :    5386530 : eliminate_plus_minus_pair (enum tree_code opcode,
     791                 :            :                            vec<operand_entry *> *ops,
     792                 :            :                            unsigned int currindex,
     793                 :            :                            operand_entry *curr)
     794                 :            : {
     795                 :    5386530 :   tree negateop;
     796                 :    5386530 :   tree notop;
     797                 :    5386530 :   unsigned int i;
     798                 :    5386530 :   operand_entry *oe;
     799                 :            : 
     800                 :    5386530 :   if (opcode != PLUS_EXPR || TREE_CODE (curr->op) != SSA_NAME)
     801                 :            :     return false;
     802                 :            : 
     803                 :    1674860 :   negateop = get_unary_op (curr->op, NEGATE_EXPR);
     804                 :    1674860 :   notop = get_unary_op (curr->op, BIT_NOT_EXPR);
     805                 :    1674860 :   if (negateop == NULL_TREE && notop == NULL_TREE)
     806                 :            :     return false;
     807                 :            : 
     808                 :            :   /* Any non-negated version will have a rank that is one less than
     809                 :            :      the current rank.  So once we hit those ranks, if we don't find
     810                 :            :      one, we can stop.  */
     811                 :            : 
     812                 :      84439 :   for (i = currindex + 1;
     813                 :     201479 :        ops->iterate (i, &oe)
     814                 :     148049 :        && oe->rank >= curr->rank - 1 ;
     815                 :            :        i++)
     816                 :            :     {
     817                 :      31009 :       if (negateop
     818                 :      31009 :           && ops_equal_values_p (oe->op, negateop))
     819                 :            :         {
     820                 :       1746 :           if (dump_file && (dump_flags & TDF_DETAILS))
     821                 :            :             {
     822                 :          0 :               fprintf (dump_file, "Equivalence: ");
     823                 :          0 :               print_generic_expr (dump_file, negateop);
     824                 :          0 :               fprintf (dump_file, " + -");
     825                 :          0 :               print_generic_expr (dump_file, oe->op);
     826                 :          0 :               fprintf (dump_file, " -> 0\n");
     827                 :            :             }
     828                 :            : 
     829                 :       1746 :           ops->ordered_remove (i);
     830                 :       1746 :           add_to_ops_vec (ops, build_zero_cst (TREE_TYPE (oe->op)));
     831                 :       1746 :           ops->ordered_remove (currindex);
     832                 :       1746 :           reassociate_stats.ops_eliminated ++;
     833                 :            : 
     834                 :       1746 :           return true;
     835                 :            :         }
     836                 :      29263 :       else if (notop
     837                 :      29263 :                && ops_equal_values_p (oe->op, notop))
     838                 :            :         {
     839                 :       1011 :           tree op_type = TREE_TYPE (oe->op);
     840                 :            : 
     841                 :       1011 :           if (dump_file && (dump_flags & TDF_DETAILS))
     842                 :            :             {
     843                 :          0 :               fprintf (dump_file, "Equivalence: ");
     844                 :          0 :               print_generic_expr (dump_file, notop);
     845                 :          0 :               fprintf (dump_file, " + ~");
     846                 :          0 :               print_generic_expr (dump_file, oe->op);
     847                 :          0 :               fprintf (dump_file, " -> -1\n");
     848                 :            :             }
     849                 :            : 
     850                 :       1011 :           ops->ordered_remove (i);
     851                 :       1011 :           add_to_ops_vec (ops, build_all_ones_cst (op_type));
     852                 :       1011 :           ops->ordered_remove (currindex);
     853                 :       1011 :           reassociate_stats.ops_eliminated ++;
     854                 :            : 
     855                 :       1011 :           return true;
     856                 :            :         }
     857                 :            :     }
     858                 :            : 
     859                 :            :   /* If CURR->OP is a negate expr without nop conversion in a plus expr: 
     860                 :            :      save it for later inspection in repropagate_negates().  */
     861                 :      53430 :   if (negateop != NULL_TREE
     862                 :      53430 :       && gimple_assign_rhs_code (SSA_NAME_DEF_STMT (curr->op)) == NEGATE_EXPR)
     863                 :      52977 :     plus_negates.safe_push (curr->op);
     864                 :            : 
     865                 :            :   return false;
     866                 :            : }
     867                 :            : 
     868                 :            : /* If OPCODE is BIT_IOR_EXPR, BIT_AND_EXPR, and, CURR->OP is really a
     869                 :            :    bitwise not expression, look in OPS for a corresponding operand to
     870                 :            :    cancel it out.  If we find one, remove the other from OPS, replace
     871                 :            :    OPS[CURRINDEX] with 0, and return true.  Otherwise, return
     872                 :            :    false. */
     873                 :            : 
     874                 :            : static bool
     875                 :    5386590 : eliminate_not_pairs (enum tree_code opcode,
     876                 :            :                      vec<operand_entry *> *ops,
     877                 :            :                      unsigned int currindex,
     878                 :            :                      operand_entry *curr)
     879                 :            : {
     880                 :    5386590 :   tree notop;
     881                 :    5386590 :   unsigned int i;
     882                 :    5386590 :   operand_entry *oe;
     883                 :            : 
     884                 :    5386590 :   if ((opcode != BIT_IOR_EXPR && opcode != BIT_AND_EXPR)
     885                 :    1163560 :       || TREE_CODE (curr->op) != SSA_NAME)
     886                 :            :     return false;
     887                 :            : 
     888                 :     869060 :   notop = get_unary_op (curr->op, BIT_NOT_EXPR);
     889                 :     869060 :   if (notop == NULL_TREE)
     890                 :            :     return false;
     891                 :            : 
     892                 :            :   /* Any non-not version will have a rank that is one less than
     893                 :            :      the current rank.  So once we hit those ranks, if we don't find
     894                 :            :      one, we can stop.  */
     895                 :            : 
     896                 :      12458 :   for (i = currindex + 1;
     897                 :    5405900 :        ops->iterate (i, &oe)
     898                 :      19308 :        && oe->rank >= curr->rank - 1;
     899                 :            :        i++)
     900                 :            :     {
     901                 :       1927 :       if (oe->op == notop)
     902                 :            :         {
     903                 :          1 :           if (dump_file && (dump_flags & TDF_DETAILS))
     904                 :            :             {
     905                 :          0 :               fprintf (dump_file, "Equivalence: ");
     906                 :          0 :               print_generic_expr (dump_file, notop);
     907                 :          0 :               if (opcode == BIT_AND_EXPR)
     908                 :          0 :                 fprintf (dump_file, " & ~");
     909                 :          0 :               else if (opcode == BIT_IOR_EXPR)
     910                 :          0 :                 fprintf (dump_file, " | ~");
     911                 :          0 :               print_generic_expr (dump_file, oe->op);
     912                 :          0 :               if (opcode == BIT_AND_EXPR)
     913                 :          0 :                 fprintf (dump_file, " -> 0\n");
     914                 :          0 :               else if (opcode == BIT_IOR_EXPR)
     915                 :          0 :                 fprintf (dump_file, " -> -1\n");
     916                 :            :             }
     917                 :            : 
     918                 :          1 :           if (opcode == BIT_AND_EXPR)
     919                 :          1 :             oe->op = build_zero_cst (TREE_TYPE (oe->op));
     920                 :          0 :           else if (opcode == BIT_IOR_EXPR)
     921                 :          0 :             oe->op = build_all_ones_cst (TREE_TYPE (oe->op));
     922                 :            : 
     923                 :          1 :           reassociate_stats.ops_eliminated += ops->length () - 1;
     924                 :          1 :           ops->truncate (0);
     925                 :          1 :           ops->quick_push (oe);
     926                 :          1 :           return true;
     927                 :            :         }
     928                 :            :     }
     929                 :            : 
     930                 :            :   return false;
     931                 :            : }
     932                 :            : 
     933                 :            : /* Use constant value that may be present in OPS to try to eliminate
     934                 :            :    operands.  Note that this function is only really used when we've
     935                 :            :    eliminated ops for other reasons, or merged constants.  Across
     936                 :            :    single statements, fold already does all of this, plus more.  There
     937                 :            :    is little point in duplicating logic, so I've only included the
     938                 :            :    identities that I could ever construct testcases to trigger.  */
     939                 :            : 
     940                 :            : static void
     941                 :    2620790 : eliminate_using_constants (enum tree_code opcode,
     942                 :            :                            vec<operand_entry *> *ops)
     943                 :            : {
     944                 :    2620790 :   operand_entry *oelast = ops->last ();
     945                 :    2620790 :   tree type = TREE_TYPE (oelast->op);
     946                 :            : 
     947                 :    2620790 :   if (oelast->rank == 0
     948                 :    2622340 :       && (ANY_INTEGRAL_TYPE_P (type) || FLOAT_TYPE_P (type)))
     949                 :            :     {
     950                 :    1829750 :       switch (opcode)
     951                 :            :         {
     952                 :     259103 :         case BIT_AND_EXPR:
     953                 :     259103 :           if (integer_zerop (oelast->op))
     954                 :            :             {
     955                 :          0 :               if (ops->length () != 1)
     956                 :            :                 {
     957                 :          0 :                   if (dump_file && (dump_flags & TDF_DETAILS))
     958                 :          0 :                     fprintf (dump_file, "Found & 0, removing all other ops\n");
     959                 :            : 
     960                 :          0 :                   reassociate_stats.ops_eliminated += ops->length () - 1;
     961                 :            : 
     962                 :          0 :                   ops->truncate (0);
     963                 :          0 :                   ops->quick_push (oelast);
     964                 :          0 :                   return;
     965                 :            :                 }
     966                 :            :             }
     967                 :     259103 :           else if (integer_all_onesp (oelast->op))
     968                 :            :             {
     969                 :          2 :               if (ops->length () != 1)
     970                 :            :                 {
     971                 :          2 :                   if (dump_file && (dump_flags & TDF_DETAILS))
     972                 :          0 :                     fprintf (dump_file, "Found & -1, removing\n");
     973                 :          2 :                   ops->pop ();
     974                 :          2 :                   reassociate_stats.ops_eliminated++;
     975                 :            :                 }
     976                 :            :             }
     977                 :            :           break;
     978                 :      34873 :         case BIT_IOR_EXPR:
     979                 :      34873 :           if (integer_all_onesp (oelast->op))
     980                 :            :             {
     981                 :          0 :               if (ops->length () != 1)
     982                 :            :                 {
     983                 :          0 :                   if (dump_file && (dump_flags & TDF_DETAILS))
     984                 :          0 :                     fprintf (dump_file, "Found | -1, removing all other ops\n");
     985                 :            : 
     986                 :          0 :                   reassociate_stats.ops_eliminated += ops->length () - 1;
     987                 :            : 
     988                 :          0 :                   ops->truncate (0);
     989                 :          0 :                   ops->quick_push (oelast);
     990                 :          0 :                   return;
     991                 :            :                 }
     992                 :            :             }
     993                 :      34873 :           else if (integer_zerop (oelast->op))
     994                 :            :             {
     995                 :          2 :               if (ops->length () != 1)
     996                 :            :                 {
     997                 :          2 :                   if (dump_file && (dump_flags & TDF_DETAILS))
     998                 :          0 :                     fprintf (dump_file, "Found | 0, removing\n");
     999                 :          2 :                   ops->pop ();
    1000                 :          2 :                   reassociate_stats.ops_eliminated++;
    1001                 :            :                 }
    1002                 :            :             }
    1003                 :            :           break;
    1004                 :     547663 :         case MULT_EXPR:
    1005                 :     547663 :           if (integer_zerop (oelast->op)
    1006                 :     547990 :               || (FLOAT_TYPE_P (type)
    1007                 :       1110 :                   && !HONOR_NANS (type)
    1008                 :       1083 :                   && !HONOR_SIGNED_ZEROS (type)
    1009                 :       1083 :                   && real_zerop (oelast->op)))
    1010                 :            :             {
    1011                 :          0 :               if (ops->length () != 1)
    1012                 :            :                 {
    1013                 :          0 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    1014                 :          0 :                     fprintf (dump_file, "Found * 0, removing all other ops\n");
    1015                 :            : 
    1016                 :          0 :                   reassociate_stats.ops_eliminated += ops->length () - 1;
    1017                 :          0 :                   ops->truncate (0);
    1018                 :          0 :                   ops->quick_push (oelast);
    1019                 :          0 :                   return;
    1020                 :            :                 }
    1021                 :            :             }
    1022                 :     547663 :           else if (integer_onep (oelast->op)
    1023                 :     547989 :                    || (FLOAT_TYPE_P (type)
    1024                 :       1110 :                        && !HONOR_SNANS (type)
    1025                 :       1110 :                        && real_onep (oelast->op)))
    1026                 :            :             {
    1027                 :          4 :               if (ops->length () != 1)
    1028                 :            :                 {
    1029                 :          4 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    1030                 :          0 :                     fprintf (dump_file, "Found * 1, removing\n");
    1031                 :          4 :                   ops->pop ();
    1032                 :          4 :                   reassociate_stats.ops_eliminated++;
    1033                 :          4 :                   return;
    1034                 :            :                 }
    1035                 :            :             }
    1036                 :            :           break;
    1037                 :     923196 :         case BIT_XOR_EXPR:
    1038                 :     923196 :         case PLUS_EXPR:
    1039                 :     923196 :         case MINUS_EXPR:
    1040                 :     923196 :           if (integer_zerop (oelast->op)
    1041                 :     923596 :               || (FLOAT_TYPE_P (type)
    1042                 :        640 :                   && (opcode == PLUS_EXPR || opcode == MINUS_EXPR)
    1043                 :        640 :                   && fold_real_zero_addition_p (type, oelast->op,
    1044                 :            :                                                 opcode == MINUS_EXPR)))
    1045                 :            :             {
    1046                 :       1685 :               if (ops->length () != 1)
    1047                 :            :                 {
    1048                 :       1685 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    1049                 :          0 :                     fprintf (dump_file, "Found [|^+] 0, removing\n");
    1050                 :       1685 :                   ops->pop ();
    1051                 :       1685 :                   reassociate_stats.ops_eliminated++;
    1052                 :       1685 :                   return;
    1053                 :            :                 }
    1054                 :            :             }
    1055                 :            :           break;
    1056                 :            :         default:
    1057                 :            :           break;
    1058                 :            :         }
    1059                 :            :     }
    1060                 :            : }
    1061                 :            : 
    1062                 :            : 
    1063                 :            : static void linearize_expr_tree (vec<operand_entry *> *, gimple *,
    1064                 :            :                                  bool, bool);
    1065                 :            : 
    1066                 :            : /* Structure for tracking and counting operands.  */
    1067                 :            : struct oecount {
    1068                 :            :   unsigned int cnt;
    1069                 :            :   unsigned int id;
    1070                 :            :   enum tree_code oecode;
    1071                 :            :   tree op;
    1072                 :            : };
    1073                 :            : 
    1074                 :            : 
    1075                 :            : /* The heap for the oecount hashtable and the sorted list of operands.  */
    1076                 :            : static vec<oecount> cvec;
    1077                 :            : 
    1078                 :            : 
    1079                 :            : /* Oecount hashtable helpers.  */
    1080                 :            : 
    1081                 :            : struct oecount_hasher : int_hash <int, 0, 1>
    1082                 :            : {
    1083                 :            :   static inline hashval_t hash (int);
    1084                 :            :   static inline bool equal (int, int);
    1085                 :            : };
    1086                 :            : 
    1087                 :            : /* Hash function for oecount.  */
    1088                 :            : 
    1089                 :            : inline hashval_t
    1090                 :     129645 : oecount_hasher::hash (int p)
    1091                 :            : {
    1092                 :     129645 :   const oecount *c = &cvec[p - 42];
    1093                 :     129645 :   return htab_hash_pointer (c->op) ^ (hashval_t)c->oecode;
    1094                 :            : }
    1095                 :            : 
    1096                 :            : /* Comparison function for oecount.  */
    1097                 :            : 
    1098                 :            : inline bool
    1099                 :      72992 : oecount_hasher::equal (int p1, int p2)
    1100                 :            : {
    1101                 :      72992 :   const oecount *c1 = &cvec[p1 - 42];
    1102                 :      72992 :   const oecount *c2 = &cvec[p2 - 42];
    1103                 :      72992 :   return c1->oecode == c2->oecode && c1->op == c2->op;
    1104                 :            : }
    1105                 :            : 
    1106                 :            : /* Comparison function for qsort sorting oecount elements by count.  */
    1107                 :            : 
    1108                 :            : static int
    1109                 :     513451 : oecount_cmp (const void *p1, const void *p2)
    1110                 :            : {
    1111                 :     513451 :   const oecount *c1 = (const oecount *)p1;
    1112                 :     513451 :   const oecount *c2 = (const oecount *)p2;
    1113                 :     513451 :   if (c1->cnt != c2->cnt)
    1114                 :      12634 :     return c1->cnt > c2->cnt ? 1 : -1;
    1115                 :            :   else
    1116                 :            :     /* If counts are identical, use unique IDs to stabilize qsort.  */
    1117                 :     740193 :     return c1->id > c2->id ? 1 : -1;
    1118                 :            : }
    1119                 :            : 
    1120                 :            : /* Return TRUE iff STMT represents a builtin call that raises OP
    1121                 :            :    to some exponent.  */
    1122                 :            : 
    1123                 :            : static bool
    1124                 :        691 : stmt_is_power_of_op (gimple *stmt, tree op)
    1125                 :            : {
    1126                 :        691 :   if (!is_gimple_call (stmt))
    1127                 :            :     return false;
    1128                 :            : 
    1129                 :         12 :   switch (gimple_call_combined_fn (stmt))
    1130                 :            :     {
    1131                 :          7 :     CASE_CFN_POW:
    1132                 :          7 :     CASE_CFN_POWI:
    1133                 :          7 :       return (operand_equal_p (gimple_call_arg (stmt, 0), op, 0));
    1134                 :            :       
    1135                 :            :     default:
    1136                 :            :       return false;
    1137                 :            :     }
    1138                 :            : }
    1139                 :            : 
    1140                 :            : /* Given STMT which is a __builtin_pow* call, decrement its exponent
    1141                 :            :    in place and return the result.  Assumes that stmt_is_power_of_op
    1142                 :            :    was previously called for STMT and returned TRUE.  */
    1143                 :            : 
    1144                 :            : static HOST_WIDE_INT
    1145                 :          7 : decrement_power (gimple *stmt)
    1146                 :            : {
    1147                 :          7 :   REAL_VALUE_TYPE c, cint;
    1148                 :          7 :   HOST_WIDE_INT power;
    1149                 :          7 :   tree arg1;
    1150                 :            : 
    1151                 :          7 :   switch (gimple_call_combined_fn (stmt))
    1152                 :            :     {
    1153                 :          0 :     CASE_CFN_POW:
    1154                 :          0 :       arg1 = gimple_call_arg (stmt, 1);
    1155                 :          0 :       c = TREE_REAL_CST (arg1);
    1156                 :          0 :       power = real_to_integer (&c) - 1;
    1157                 :          0 :       real_from_integer (&cint, VOIDmode, power, SIGNED);
    1158                 :          0 :       gimple_call_set_arg (stmt, 1, build_real (TREE_TYPE (arg1), cint));
    1159                 :          0 :       return power;
    1160                 :            : 
    1161                 :          7 :     CASE_CFN_POWI:
    1162                 :          7 :       arg1 = gimple_call_arg (stmt, 1);
    1163                 :          7 :       power = TREE_INT_CST_LOW (arg1) - 1;
    1164                 :          7 :       gimple_call_set_arg (stmt, 1, build_int_cst (TREE_TYPE (arg1), power));
    1165                 :          7 :       return power;
    1166                 :            : 
    1167                 :          0 :     default:
    1168                 :          0 :       gcc_unreachable ();
    1169                 :            :     }
    1170                 :            : }
    1171                 :            : 
    1172                 :            : /* Replace SSA defined by STMT and replace all its uses with new
    1173                 :            :    SSA.  Also return the new SSA.  */
    1174                 :            : 
    1175                 :            : static tree
    1176                 :        204 : make_new_ssa_for_def (gimple *stmt, enum tree_code opcode, tree op)
    1177                 :            : {
    1178                 :        204 :   gimple *use_stmt;
    1179                 :        204 :   use_operand_p use;
    1180                 :        204 :   imm_use_iterator iter;
    1181                 :        204 :   tree new_lhs, new_debug_lhs = NULL_TREE;
    1182                 :        204 :   tree lhs = gimple_get_lhs (stmt);
    1183                 :            : 
    1184                 :        204 :   new_lhs = make_ssa_name (TREE_TYPE (lhs));
    1185                 :        204 :   gimple_set_lhs (stmt, new_lhs);
    1186                 :            : 
    1187                 :            :   /* Also need to update GIMPLE_DEBUGs.  */
    1188                 :        421 :   FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
    1189                 :            :     {
    1190                 :        217 :       tree repl = new_lhs;
    1191                 :        217 :       if (is_gimple_debug (use_stmt))
    1192                 :            :         {
    1193                 :         13 :           if (new_debug_lhs == NULL_TREE)
    1194                 :            :             {
    1195                 :          7 :               new_debug_lhs = make_node (DEBUG_EXPR_DECL);
    1196                 :          7 :               gdebug *def_temp
    1197                 :          7 :                 = gimple_build_debug_bind (new_debug_lhs,
    1198                 :          7 :                                            build2 (opcode, TREE_TYPE (lhs),
    1199                 :            :                                                    new_lhs, op),
    1200                 :            :                                            stmt);
    1201                 :          7 :               DECL_ARTIFICIAL (new_debug_lhs) = 1;
    1202                 :          7 :               TREE_TYPE (new_debug_lhs) = TREE_TYPE (lhs);
    1203                 :          7 :               SET_DECL_MODE (new_debug_lhs, TYPE_MODE (TREE_TYPE (lhs)));
    1204                 :          7 :               gimple_set_uid (def_temp, gimple_uid (stmt));
    1205                 :          7 :               gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    1206                 :          7 :               gsi_insert_after (&gsi, def_temp, GSI_SAME_STMT);
    1207                 :            :             }
    1208                 :            :           repl = new_debug_lhs;
    1209                 :            :         }
    1210                 :        868 :       FOR_EACH_IMM_USE_ON_STMT (use, iter)
    1211                 :        217 :         SET_USE (use, repl);
    1212                 :        434 :       update_stmt (use_stmt);
    1213                 :            :     }
    1214                 :        204 :   return new_lhs;
    1215                 :            : }
    1216                 :            : 
    1217                 :            : /* Replace all SSAs defined in STMTS_TO_FIX and replace its
    1218                 :            :    uses with new SSAs.  Also do this for the stmt that defines DEF
    1219                 :            :    if *DEF is not OP.  */
    1220                 :            : 
    1221                 :            : static void
    1222                 :        143 : make_new_ssa_for_all_defs (tree *def, enum tree_code opcode, tree op,
    1223                 :            :                            vec<gimple *> &stmts_to_fix)
    1224                 :            : {
    1225                 :        143 :   unsigned i;
    1226                 :        143 :   gimple *stmt;
    1227                 :            : 
    1228                 :        143 :   if (*def != op
    1229                 :        143 :       && TREE_CODE (*def) == SSA_NAME
    1230                 :        143 :       && (stmt = SSA_NAME_DEF_STMT (*def))
    1231                 :        286 :       && gimple_code (stmt) != GIMPLE_NOP)
    1232                 :        143 :     *def = make_new_ssa_for_def (stmt, opcode, op);
    1233                 :            : 
    1234                 :        204 :   FOR_EACH_VEC_ELT (stmts_to_fix, i, stmt)
    1235                 :         61 :     make_new_ssa_for_def (stmt, opcode, op);
    1236                 :        143 : }
    1237                 :            : 
    1238                 :            : /* Find the single immediate use of STMT's LHS, and replace it
    1239                 :            :    with OP.  Remove STMT.  If STMT's LHS is the same as *DEF,
    1240                 :            :    replace *DEF with OP as well.  */
    1241                 :            : 
    1242                 :            : static void
    1243                 :        477 : propagate_op_to_single_use (tree op, gimple *stmt, tree *def)
    1244                 :            : {
    1245                 :        477 :   tree lhs;
    1246                 :        477 :   gimple *use_stmt;
    1247                 :        477 :   use_operand_p use;
    1248                 :        477 :   gimple_stmt_iterator gsi;
    1249                 :            : 
    1250                 :        477 :   if (is_gimple_call (stmt))
    1251                 :          2 :     lhs = gimple_call_lhs (stmt);
    1252                 :            :   else
    1253                 :        475 :     lhs = gimple_assign_lhs (stmt);
    1254                 :            : 
    1255                 :        477 :   gcc_assert (has_single_use (lhs));
    1256                 :        477 :   single_imm_use (lhs, &use, &use_stmt);
    1257                 :        477 :   if (lhs == *def)
    1258                 :        343 :     *def = op;
    1259                 :        477 :   SET_USE (use, op);
    1260                 :        477 :   if (TREE_CODE (op) != SSA_NAME)
    1261                 :         34 :     update_stmt (use_stmt);
    1262                 :        477 :   gsi = gsi_for_stmt (stmt);
    1263                 :        477 :   unlink_stmt_vdef (stmt);
    1264                 :        477 :   reassoc_remove_stmt (&gsi);
    1265                 :        477 :   release_defs (stmt);
    1266                 :        477 : }
    1267                 :            : 
    1268                 :            : /* Walks the linear chain with result *DEF searching for an operation
    1269                 :            :    with operand OP and code OPCODE removing that from the chain.  *DEF
    1270                 :            :    is updated if there is only one operand but no operation left.  */
    1271                 :            : 
    1272                 :            : static void
    1273                 :        486 : zero_one_operation (tree *def, enum tree_code opcode, tree op)
    1274                 :            : {
    1275                 :        486 :   tree orig_def = *def;
    1276                 :        486 :   gimple *stmt = SSA_NAME_DEF_STMT (*def);
    1277                 :            :   /* PR72835 - Record the stmt chain that has to be updated such that
    1278                 :            :      we dont use the same LHS when the values computed are different.  */
    1279                 :        486 :   auto_vec<gimple *, 64> stmts_to_fix;
    1280                 :            : 
    1281                 :        846 :   do
    1282                 :            :     {
    1283                 :        666 :       tree name;
    1284                 :            : 
    1285                 :        666 :       if (opcode == MULT_EXPR)
    1286                 :            :         {
    1287                 :        664 :           if (stmt_is_power_of_op (stmt, op))
    1288                 :            :             {
    1289                 :          0 :               if (decrement_power (stmt) == 1)
    1290                 :            :                 {
    1291                 :          0 :                   if (stmts_to_fix.length () > 0)
    1292                 :          0 :                     stmts_to_fix.pop ();
    1293                 :          0 :                   propagate_op_to_single_use (op, stmt, def);
    1294                 :            :                 }
    1295                 :            :               break;
    1296                 :            :             }
    1297                 :        664 :           else if (gimple_assign_rhs_code (stmt) == NEGATE_EXPR)
    1298                 :            :             {
    1299                 :          7 :               if (gimple_assign_rhs1 (stmt) == op)
    1300                 :            :                 {
    1301                 :          5 :                   tree cst = build_minus_one_cst (TREE_TYPE (op));
    1302                 :          5 :                   if (stmts_to_fix.length () > 0)
    1303                 :          5 :                     stmts_to_fix.pop ();
    1304                 :          5 :                   propagate_op_to_single_use (cst, stmt, def);
    1305                 :          5 :                   break;
    1306                 :            :                 }
    1307                 :          2 :               else if (integer_minus_onep (op)
    1308                 :          2 :                        || real_minus_onep (op))
    1309                 :            :                 {
    1310                 :          2 :                   gimple_assign_set_rhs_code
    1311                 :          2 :                     (stmt, TREE_CODE (gimple_assign_rhs1 (stmt)));
    1312                 :            :                   break;
    1313                 :            :                 }
    1314                 :            :             }
    1315                 :            :         }
    1316                 :            : 
    1317                 :        659 :       name = gimple_assign_rhs1 (stmt);
    1318                 :            : 
    1319                 :            :       /* If this is the operation we look for and one of the operands
    1320                 :            :          is ours simply propagate the other operand into the stmts
    1321                 :            :          single use.  */
    1322                 :        659 :       if (gimple_assign_rhs_code (stmt) == opcode
    1323                 :        659 :           && (name == op
    1324                 :        574 :               || gimple_assign_rhs2 (stmt) == op))
    1325                 :            :         {
    1326                 :        464 :           if (name == op)
    1327                 :         85 :             name = gimple_assign_rhs2 (stmt);
    1328                 :        464 :           if (stmts_to_fix.length () > 0)
    1329                 :        121 :             stmts_to_fix.pop ();
    1330                 :        464 :           propagate_op_to_single_use (name, stmt, def);
    1331                 :        464 :           break;
    1332                 :            :         }
    1333                 :            : 
    1334                 :            :       /* We might have a multiply of two __builtin_pow* calls, and
    1335                 :            :          the operand might be hiding in the rightmost one.  Likewise
    1336                 :            :          this can happen for a negate.  */
    1337                 :        195 :       if (opcode == MULT_EXPR
    1338                 :        195 :           && gimple_assign_rhs_code (stmt) == opcode
    1339                 :        195 :           && TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME
    1340                 :        344 :           && has_single_use (gimple_assign_rhs2 (stmt)))
    1341                 :            :         {
    1342                 :         27 :           gimple *stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
    1343                 :         27 :           if (stmt_is_power_of_op (stmt2, op))
    1344                 :            :             {
    1345                 :          7 :               if (decrement_power (stmt2) == 1)
    1346                 :          2 :                 propagate_op_to_single_use (op, stmt2, def);
    1347                 :            :               else
    1348                 :          5 :                 stmts_to_fix.safe_push (stmt2);
    1349                 :         15 :               break;
    1350                 :            :             }
    1351                 :         20 :           else if (is_gimple_assign (stmt2)
    1352                 :         20 :                    && gimple_assign_rhs_code (stmt2) == NEGATE_EXPR)
    1353                 :            :             {
    1354                 :          8 :               if (gimple_assign_rhs1 (stmt2) == op)
    1355                 :            :                 {
    1356                 :          6 :                   tree cst = build_minus_one_cst (TREE_TYPE (op));
    1357                 :          6 :                   propagate_op_to_single_use (cst, stmt2, def);
    1358                 :          6 :                   break;
    1359                 :            :                 }
    1360                 :          2 :               else if (integer_minus_onep (op)
    1361                 :          2 :                        || real_minus_onep (op))
    1362                 :            :                 {
    1363                 :          2 :                   stmts_to_fix.safe_push (stmt2);
    1364                 :          2 :                   gimple_assign_set_rhs_code
    1365                 :         15 :                     (stmt2, TREE_CODE (gimple_assign_rhs1 (stmt2)));
    1366                 :            :                   break;
    1367                 :            :                 }
    1368                 :            :             }
    1369                 :            :         }
    1370                 :            : 
    1371                 :            :       /* Continue walking the chain.  */
    1372                 :        180 :       gcc_assert (name != op
    1373                 :            :                   && TREE_CODE (name) == SSA_NAME);
    1374                 :        180 :       stmt = SSA_NAME_DEF_STMT (name);
    1375                 :        180 :       stmts_to_fix.safe_push (stmt);
    1376                 :            :     }
    1377                 :            :   while (1);
    1378                 :            : 
    1379                 :        486 :   if (stmts_to_fix.length () > 0 || *def == orig_def)
    1380                 :        143 :     make_new_ssa_for_all_defs (def, opcode, op, stmts_to_fix);
    1381                 :        486 : }
    1382                 :            : 
    1383                 :            : /* Returns true if statement S1 dominates statement S2.  Like
    1384                 :            :    stmt_dominates_stmt_p, but uses stmt UIDs to optimize.  */
    1385                 :            : 
    1386                 :            : static bool
    1387                 :    4040190 : reassoc_stmt_dominates_stmt_p (gimple *s1, gimple *s2)
    1388                 :            : {
    1389                 :    4040190 :   basic_block bb1 = gimple_bb (s1), bb2 = gimple_bb (s2);
    1390                 :            : 
    1391                 :            :   /* If bb1 is NULL, it should be a GIMPLE_NOP def stmt of an (D)
    1392                 :            :      SSA_NAME.  Assume it lives at the beginning of function and
    1393                 :            :      thus dominates everything.  */
    1394                 :    4040190 :   if (!bb1 || s1 == s2)
    1395                 :            :     return true;
    1396                 :            : 
    1397                 :            :   /* If bb2 is NULL, it doesn't dominate any stmt with a bb.  */
    1398                 :    4038210 :   if (!bb2)
    1399                 :            :     return false;
    1400                 :            : 
    1401                 :    4024320 :   if (bb1 == bb2)
    1402                 :            :     {
    1403                 :            :       /* PHIs in the same basic block are assumed to be
    1404                 :            :          executed all in parallel, if only one stmt is a PHI,
    1405                 :            :          it dominates the other stmt in the same basic block.  */
    1406                 :    3870690 :       if (gimple_code (s1) == GIMPLE_PHI)
    1407                 :            :         return true;
    1408                 :            : 
    1409                 :    3807020 :       if (gimple_code (s2) == GIMPLE_PHI)
    1410                 :            :         return false;
    1411                 :            : 
    1412                 :    3753210 :       gcc_assert (gimple_uid (s1) && gimple_uid (s2));
    1413                 :            : 
    1414                 :    3753210 :       if (gimple_uid (s1) < gimple_uid (s2))
    1415                 :            :         return true;
    1416                 :            : 
    1417                 :    2309040 :       if (gimple_uid (s1) > gimple_uid (s2))
    1418                 :            :         return false;
    1419                 :            : 
    1420                 :      28552 :       gimple_stmt_iterator gsi = gsi_for_stmt (s1);
    1421                 :      28552 :       unsigned int uid = gimple_uid (s1);
    1422                 :      59048 :       for (gsi_next (&gsi); !gsi_end_p (gsi); gsi_next (&gsi))
    1423                 :            :         {
    1424                 :      55948 :           gimple *s = gsi_stmt (gsi);
    1425                 :      55948 :           if (gimple_uid (s) != uid)
    1426                 :            :             break;
    1427                 :      31809 :           if (s == s2)
    1428                 :            :             return true;
    1429                 :            :         }
    1430                 :            : 
    1431                 :            :       return false;
    1432                 :            :     }
    1433                 :            : 
    1434                 :     153625 :   return dominated_by_p (CDI_DOMINATORS, bb2, bb1);
    1435                 :            : }
    1436                 :            : 
    1437                 :            : /* Insert STMT after INSERT_POINT.  */
    1438                 :            : 
    1439                 :            : static void
    1440                 :      22133 : insert_stmt_after (gimple *stmt, gimple *insert_point)
    1441                 :            : {
    1442                 :      22133 :   gimple_stmt_iterator gsi;
    1443                 :      22133 :   basic_block bb;
    1444                 :            : 
    1445                 :      22133 :   if (gimple_code (insert_point) == GIMPLE_PHI)
    1446                 :         38 :     bb = gimple_bb (insert_point);
    1447                 :      22095 :   else if (!stmt_ends_bb_p (insert_point))
    1448                 :            :     {
    1449                 :      22093 :       gsi = gsi_for_stmt (insert_point);
    1450                 :      22093 :       gimple_set_uid (stmt, gimple_uid (insert_point));
    1451                 :      22093 :       gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
    1452                 :      22093 :       return;
    1453                 :            :     }
    1454                 :            :   else
    1455                 :            :     /* We assume INSERT_POINT is a SSA_NAME_DEF_STMT of some SSA_NAME,
    1456                 :            :        thus if it must end a basic block, it should be a call that can
    1457                 :            :        throw, or some assignment that can throw.  If it throws, the LHS
    1458                 :            :        of it will not be initialized though, so only valid places using
    1459                 :            :        the SSA_NAME should be dominated by the fallthru edge.  */
    1460                 :          2 :     bb = find_fallthru_edge (gimple_bb (insert_point)->succs)->dest;
    1461                 :         40 :   gsi = gsi_after_labels (bb);
    1462                 :         40 :   if (gsi_end_p (gsi))
    1463                 :            :     {
    1464                 :          0 :       gimple_stmt_iterator gsi2 = gsi_last_bb (bb);
    1465                 :          0 :       gimple_set_uid (stmt,
    1466                 :          0 :                       gsi_end_p (gsi2) ? 1 : gimple_uid (gsi_stmt (gsi2)));
    1467                 :            :     }
    1468                 :            :   else
    1469                 :         40 :     gimple_set_uid (stmt, gimple_uid (gsi_stmt (gsi)));
    1470                 :         40 :   gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
    1471                 :            : }
    1472                 :            : 
    1473                 :            : /* Builds one statement performing OP1 OPCODE OP2 using TMPVAR for
    1474                 :            :    the result.  Places the statement after the definition of either
    1475                 :            :    OP1 or OP2.  Returns the new statement.  */
    1476                 :            : 
    1477                 :            : static gimple *
    1478                 :       3459 : build_and_add_sum (tree type, tree op1, tree op2, enum tree_code opcode)
    1479                 :            : {
    1480                 :       3459 :   gimple *op1def = NULL, *op2def = NULL;
    1481                 :       3459 :   gimple_stmt_iterator gsi;
    1482                 :       3459 :   tree op;
    1483                 :       3459 :   gassign *sum;
    1484                 :            : 
    1485                 :            :   /* Create the addition statement.  */
    1486                 :       3459 :   op = make_ssa_name (type);
    1487                 :       3459 :   sum = gimple_build_assign (op, opcode, op1, op2);
    1488                 :            : 
    1489                 :            :   /* Find an insertion place and insert.  */
    1490                 :       3459 :   if (TREE_CODE (op1) == SSA_NAME)
    1491                 :       3459 :     op1def = SSA_NAME_DEF_STMT (op1);
    1492                 :       3459 :   if (TREE_CODE (op2) == SSA_NAME)
    1493                 :       3297 :     op2def = SSA_NAME_DEF_STMT (op2);
    1494                 :       3459 :   if ((!op1def || gimple_nop_p (op1def))
    1495                 :       3562 :       && (!op2def || gimple_nop_p (op2def)))
    1496                 :            :     {
    1497                 :         93 :       gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
    1498                 :         93 :       if (gsi_end_p (gsi))
    1499                 :            :         {
    1500                 :          0 :           gimple_stmt_iterator gsi2
    1501                 :          0 :             = gsi_last_bb (single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
    1502                 :          0 :           gimple_set_uid (sum,
    1503                 :          0 :                           gsi_end_p (gsi2) ? 1 : gimple_uid (gsi_stmt (gsi2)));
    1504                 :            :         }
    1505                 :            :       else
    1506                 :         93 :         gimple_set_uid (sum, gimple_uid (gsi_stmt (gsi)));
    1507                 :         93 :       gsi_insert_before (&gsi, sum, GSI_NEW_STMT);
    1508                 :            :     }
    1509                 :            :   else
    1510                 :            :     {
    1511                 :       3366 :       gimple *insert_point;
    1512                 :       3366 :       if ((!op1def || gimple_nop_p (op1def))
    1513                 :       6722 :            || (op2def && !gimple_nop_p (op2def)
    1514                 :       3137 :                && reassoc_stmt_dominates_stmt_p (op1def, op2def)))
    1515                 :            :         insert_point = op2def;
    1516                 :            :       else
    1517                 :            :         insert_point = op1def;
    1518                 :       3366 :       insert_stmt_after (sum, insert_point);
    1519                 :            :     }
    1520                 :       3459 :   update_stmt (sum);
    1521                 :            : 
    1522                 :       3459 :   return sum;
    1523                 :            : }
    1524                 :            : 
    1525                 :            : /* Perform un-distribution of divisions and multiplications.
    1526                 :            :    A * X + B * X is transformed into (A + B) * X and A / X + B / X
    1527                 :            :    to (A + B) / X for real X.
    1528                 :            : 
    1529                 :            :    The algorithm is organized as follows.
    1530                 :            : 
    1531                 :            :     - First we walk the addition chain *OPS looking for summands that
    1532                 :            :       are defined by a multiplication or a real division.  This results
    1533                 :            :       in the candidates bitmap with relevant indices into *OPS.
    1534                 :            : 
    1535                 :            :     - Second we build the chains of multiplications or divisions for
    1536                 :            :       these candidates, counting the number of occurrences of (operand, code)
    1537                 :            :       pairs in all of the candidates chains.
    1538                 :            : 
    1539                 :            :     - Third we sort the (operand, code) pairs by number of occurrence and
    1540                 :            :       process them starting with the pair with the most uses.
    1541                 :            : 
    1542                 :            :       * For each such pair we walk the candidates again to build a
    1543                 :            :         second candidate bitmap noting all multiplication/division chains
    1544                 :            :         that have at least one occurrence of (operand, code).
    1545                 :            : 
    1546                 :            :       * We build an alternate addition chain only covering these
    1547                 :            :         candidates with one (operand, code) operation removed from their
    1548                 :            :         multiplication/division chain.
    1549                 :            : 
    1550                 :            :       * The first candidate gets replaced by the alternate addition chain
    1551                 :            :         multiplied/divided by the operand.
    1552                 :            : 
    1553                 :            :       * All candidate chains get disabled for further processing and
    1554                 :            :         processing of (operand, code) pairs continues.
    1555                 :            : 
    1556                 :            :   The alternate addition chains built are re-processed by the main
    1557                 :            :   reassociation algorithm which allows optimizing a * x * y + b * y * x
    1558                 :            :   to (a + b ) * x * y in one invocation of the reassociation pass.  */
    1559                 :            : 
    1560                 :            : static bool
    1561                 :    2618820 : undistribute_ops_list (enum tree_code opcode,
    1562                 :            :                        vec<operand_entry *> *ops, class loop *loop)
    1563                 :            : {
    1564                 :    2618820 :   unsigned int length = ops->length ();
    1565                 :    2618820 :   operand_entry *oe1;
    1566                 :    2618820 :   unsigned i, j;
    1567                 :    2618820 :   unsigned nr_candidates, nr_candidates2;
    1568                 :    2618820 :   sbitmap_iterator sbi0;
    1569                 :    2618820 :   vec<operand_entry *> *subops;
    1570                 :    2618820 :   bool changed = false;
    1571                 :    2618820 :   unsigned int next_oecount_id = 0;
    1572                 :            : 
    1573                 :    2618820 :   if (length <= 1
    1574                 :    2618820 :       || opcode != PLUS_EXPR)
    1575                 :            :     return false;
    1576                 :            : 
    1577                 :            :   /* Build a list of candidates to process.  */
    1578                 :    1240240 :   auto_sbitmap candidates (length);
    1579                 :    1240240 :   bitmap_clear (candidates);
    1580                 :    1240240 :   nr_candidates = 0;
    1581                 :    3822820 :   FOR_EACH_VEC_ELT (*ops, i, oe1)
    1582                 :            :     {
    1583                 :    2582580 :       enum tree_code dcode;
    1584                 :    2582580 :       gimple *oe1def;
    1585                 :            : 
    1586                 :    2582580 :       if (TREE_CODE (oe1->op) != SSA_NAME)
    1587                 :     914562 :         continue;
    1588                 :    1668020 :       oe1def = SSA_NAME_DEF_STMT (oe1->op);
    1589                 :    1668020 :       if (!is_gimple_assign (oe1def))
    1590                 :     597708 :         continue;
    1591                 :    1070310 :       dcode = gimple_assign_rhs_code (oe1def);
    1592                 :    1996320 :       if ((dcode != MULT_EXPR
    1593                 :    1070310 :            && dcode != RDIV_EXPR)
    1594                 :    1070310 :           || !is_reassociable_op (oe1def, dcode, loop))
    1595                 :     926016 :         continue;
    1596                 :            : 
    1597                 :     144293 :       bitmap_set_bit (candidates, i);
    1598                 :     144293 :       nr_candidates++;
    1599                 :            :     }
    1600                 :            : 
    1601                 :    1240240 :   if (nr_candidates < 2)
    1602                 :            :     return false;
    1603                 :            : 
    1604                 :      12851 :   if (dump_file && (dump_flags & TDF_DETAILS))
    1605                 :            :     {
    1606                 :          0 :       fprintf (dump_file, "searching for un-distribute opportunities ");
    1607                 :          0 :       print_generic_expr (dump_file,
    1608                 :          0 :         (*ops)[bitmap_first_set_bit (candidates)]->op, TDF_NONE);
    1609                 :          0 :       fprintf (dump_file, " %d\n", nr_candidates);
    1610                 :            :     }
    1611                 :            : 
    1612                 :            :   /* Build linearized sub-operand lists and the counting table.  */
    1613                 :      12851 :   cvec.create (0);
    1614                 :            : 
    1615                 :      12851 :   hash_table<oecount_hasher> ctable (15);
    1616                 :            : 
    1617                 :            :   /* ??? Macro arguments cannot have multi-argument template types in
    1618                 :            :      them.  This typedef is needed to workaround that limitation.  */
    1619                 :      12851 :   typedef vec<operand_entry *> vec_operand_entry_t_heap;
    1620                 :      25702 :   subops = XCNEWVEC (vec_operand_entry_t_heap, ops->length ());
    1621                 :      57821 :   EXECUTE_IF_SET_IN_BITMAP (candidates, 0, i, sbi0)
    1622                 :            :     {
    1623                 :      32119 :       gimple *oedef;
    1624                 :      32119 :       enum tree_code oecode;
    1625                 :      32119 :       unsigned j;
    1626                 :            : 
    1627                 :      32119 :       oedef = SSA_NAME_DEF_STMT ((*ops)[i]->op);
    1628                 :      32119 :       oecode = gimple_assign_rhs_code (oedef);
    1629                 :      64238 :       linearize_expr_tree (&subops[i], oedef,
    1630                 :      32119 :                            associative_tree_code (oecode), false);
    1631                 :            : 
    1632                 :     128992 :       FOR_EACH_VEC_ELT (subops[i], j, oe1)
    1633                 :            :         {
    1634                 :      64754 :           oecount c;
    1635                 :      64754 :           int *slot;
    1636                 :      64754 :           int idx;
    1637                 :      64754 :           c.oecode = oecode;
    1638                 :      64754 :           c.cnt = 1;
    1639                 :      64754 :           c.id = next_oecount_id++;
    1640                 :      64754 :           c.op = oe1->op;
    1641                 :      64754 :           cvec.safe_push (c);
    1642                 :      64754 :           idx = cvec.length () + 41;
    1643                 :      64754 :           slot = ctable.find_slot (idx, INSERT);
    1644                 :      64754 :           if (!*slot)
    1645                 :            :             {
    1646                 :      63977 :               *slot = idx;
    1647                 :            :             }
    1648                 :            :           else
    1649                 :            :             {
    1650                 :        777 :               cvec.pop ();
    1651                 :        777 :               cvec[*slot - 42].cnt++;
    1652                 :            :             }
    1653                 :            :         }
    1654                 :            :     }
    1655                 :            : 
    1656                 :            :   /* Sort the counting table.  */
    1657                 :      12851 :   cvec.qsort (oecount_cmp);
    1658                 :            : 
    1659                 :      12851 :   if (dump_file && (dump_flags & TDF_DETAILS))
    1660                 :            :     {
    1661                 :          0 :       oecount *c;
    1662                 :          0 :       fprintf (dump_file, "Candidates:\n");
    1663                 :          0 :       FOR_EACH_VEC_ELT (cvec, j, c)
    1664                 :            :         {
    1665                 :          0 :           fprintf (dump_file, "  %u %s: ", c->cnt,
    1666                 :          0 :                    c->oecode == MULT_EXPR
    1667                 :            :                    ? "*" : c->oecode == RDIV_EXPR ? "/" : "?");
    1668                 :          0 :           print_generic_expr (dump_file, c->op);
    1669                 :          0 :           fprintf (dump_file, "\n");
    1670                 :            :         }
    1671                 :            :     }
    1672                 :            : 
    1673                 :            :   /* Process the (operand, code) pairs in order of most occurrence.  */
    1674                 :      25702 :   auto_sbitmap candidates2 (length);
    1675                 :      13320 :   while (!cvec.is_empty ())
    1676                 :            :     {
    1677                 :      13266 :       oecount *c = &cvec.last ();
    1678                 :      13266 :       if (c->cnt < 2)
    1679                 :            :         break;
    1680                 :            : 
    1681                 :            :       /* Now collect the operands in the outer chain that contain
    1682                 :            :          the common operand in their inner chain.  */
    1683                 :        469 :       bitmap_clear (candidates2);
    1684                 :        469 :       nr_candidates2 = 0;
    1685                 :       3862 :       EXECUTE_IF_SET_IN_BITMAP (candidates, 0, i, sbi0)
    1686                 :            :         {
    1687                 :       2924 :           gimple *oedef;
    1688                 :       2924 :           enum tree_code oecode;
    1689                 :       2924 :           unsigned j;
    1690                 :       2924 :           tree op = (*ops)[i]->op;
    1691                 :            : 
    1692                 :            :           /* If we undistributed in this chain already this may be
    1693                 :            :              a constant.  */
    1694                 :       2924 :           if (TREE_CODE (op) != SSA_NAME)
    1695                 :        760 :             continue;
    1696                 :            : 
    1697                 :       2164 :           oedef = SSA_NAME_DEF_STMT (op);
    1698                 :       2164 :           oecode = gimple_assign_rhs_code (oedef);
    1699                 :       2164 :           if (oecode != c->oecode)
    1700                 :          0 :             continue;
    1701                 :            : 
    1702                 :       8217 :           FOR_EACH_VEC_ELT (subops[i], j, oe1)
    1703                 :            :             {
    1704                 :       4169 :               if (oe1->op == c->op)
    1705                 :            :                 {
    1706                 :        781 :                   bitmap_set_bit (candidates2, i);
    1707                 :        781 :                   ++nr_candidates2;
    1708                 :        781 :                   break;
    1709                 :            :                 }
    1710                 :            :             }
    1711                 :            :         }
    1712                 :            : 
    1713                 :        469 :       if (nr_candidates2 >= 2)
    1714                 :            :         {
    1715                 :        129 :           operand_entry *oe1, *oe2;
    1716                 :        129 :           gimple *prod;
    1717                 :        129 :           int first = bitmap_first_set_bit (candidates2);
    1718                 :            : 
    1719                 :            :           /* Build the new addition chain.  */
    1720                 :        129 :           oe1 = (*ops)[first];
    1721                 :        129 :           if (dump_file && (dump_flags & TDF_DETAILS))
    1722                 :            :             {
    1723                 :          0 :               fprintf (dump_file, "Building (");
    1724                 :          0 :               print_generic_expr (dump_file, oe1->op);
    1725                 :            :             }
    1726                 :        129 :           zero_one_operation (&oe1->op, c->oecode, c->op);
    1727                 :        615 :           EXECUTE_IF_SET_IN_BITMAP (candidates2, first+1, i, sbi0)
    1728                 :            :             {
    1729                 :        357 :               gimple *sum;
    1730                 :        357 :               oe2 = (*ops)[i];
    1731                 :        357 :               if (dump_file && (dump_flags & TDF_DETAILS))
    1732                 :            :                 {
    1733                 :          0 :                   fprintf (dump_file, " + ");
    1734                 :          0 :                   print_generic_expr (dump_file, oe2->op);
    1735                 :            :                 }
    1736                 :        357 :               zero_one_operation (&oe2->op, c->oecode, c->op);
    1737                 :        357 :               sum = build_and_add_sum (TREE_TYPE (oe1->op),
    1738                 :            :                                        oe1->op, oe2->op, opcode);
    1739                 :        357 :               oe2->op = build_zero_cst (TREE_TYPE (oe2->op));
    1740                 :        357 :               oe2->rank = 0;
    1741                 :        357 :               oe1->op = gimple_get_lhs (sum);
    1742                 :            :             }
    1743                 :            : 
    1744                 :            :           /* Apply the multiplication/division.  */
    1745                 :        129 :           prod = build_and_add_sum (TREE_TYPE (oe1->op),
    1746                 :            :                                     oe1->op, c->op, c->oecode);
    1747                 :        129 :           if (dump_file && (dump_flags & TDF_DETAILS))
    1748                 :            :             {
    1749                 :          0 :               fprintf (dump_file, ") %s ", c->oecode == MULT_EXPR ? "*" : "/");
    1750                 :          0 :               print_generic_expr (dump_file, c->op);
    1751                 :          0 :               fprintf (dump_file, "\n");
    1752                 :            :             }
    1753                 :            : 
    1754                 :            :           /* Record it in the addition chain and disable further
    1755                 :            :              undistribution with this op.  */
    1756                 :        129 :           oe1->op = gimple_assign_lhs (prod);
    1757                 :        129 :           oe1->rank = get_rank (oe1->op);
    1758                 :        129 :           subops[first].release ();
    1759                 :            : 
    1760                 :            :           changed = true;
    1761                 :            :         }
    1762                 :            : 
    1763                 :        469 :       cvec.pop ();
    1764                 :            :     }
    1765                 :            : 
    1766                 :     107560 :   for (i = 0; i < ops->length (); ++i)
    1767                 :      72919 :     subops[i].release ();
    1768                 :      12851 :   free (subops);
    1769                 :      12851 :   cvec.release ();
    1770                 :            : 
    1771                 :      12851 :   return changed;
    1772                 :            : }
    1773                 :            : 
    1774                 :            : /* Pair to hold the information of one specific VECTOR_TYPE SSA_NAME:
    1775                 :            :    first: element index for each relevant BIT_FIELD_REF.
    1776                 :            :    second: the index of vec ops* for each relevant BIT_FIELD_REF.  */
    1777                 :            : typedef std::pair<unsigned, unsigned> v_info_elem;
    1778                 :       6476 : struct v_info {
    1779                 :            :   tree vec_type;
    1780                 :            :   auto_vec<v_info_elem, 32> vec;
    1781                 :            : };
    1782                 :            : typedef v_info *v_info_ptr;
    1783                 :            : 
    1784                 :            : /* Comparison function for qsort on VECTOR SSA_NAME trees by machine mode.  */
    1785                 :            : static int
    1786                 :      10485 : sort_by_mach_mode (const void *p_i, const void *p_j)
    1787                 :            : {
    1788                 :      10485 :   const tree tr1 = *((const tree *) p_i);
    1789                 :      10485 :   const tree tr2 = *((const tree *) p_j);
    1790                 :      10485 :   unsigned int mode1 = TYPE_MODE (TREE_TYPE (tr1));
    1791                 :      10485 :   unsigned int mode2 = TYPE_MODE (TREE_TYPE (tr2));
    1792                 :      10485 :   if (mode1 > mode2)
    1793                 :            :     return 1;
    1794                 :      10444 :   else if (mode1 < mode2)
    1795                 :            :     return -1;
    1796                 :      10397 :   if (SSA_NAME_VERSION (tr1) < SSA_NAME_VERSION (tr2))
    1797                 :            :     return -1;
    1798                 :       5084 :   else if (SSA_NAME_VERSION (tr1) > SSA_NAME_VERSION (tr2))
    1799                 :       5084 :     return 1;
    1800                 :            :   return 0;
    1801                 :            : }
    1802                 :            : 
    1803                 :            : /* Cleanup hash map for VECTOR information.  */
    1804                 :            : static void
    1805                 :    2516680 : cleanup_vinfo_map (hash_map<tree, v_info_ptr> &info_map)
    1806                 :            : {
    1807                 :    5046310 :   for (hash_map<tree, v_info_ptr>::iterator it = info_map.begin ();
    1808                 :    2523160 :        it != info_map.end (); ++it)
    1809                 :            :     {
    1810                 :       6476 :       v_info_ptr info = (*it).second;
    1811                 :      12952 :       delete info;
    1812                 :       6476 :       (*it).second = NULL;
    1813                 :            :     }
    1814                 :    2516680 : }
    1815                 :            : 
    1816                 :            : /* Perform un-distribution of BIT_FIELD_REF on VECTOR_TYPE.
    1817                 :            :      V1[0] + V1[1] + ... + V1[k] + V2[0] + V2[1] + ... + V2[k] + ... Vn[k]
    1818                 :            :    is transformed to
    1819                 :            :      Vs = (V1 + V2 + ... + Vn)
    1820                 :            :      Vs[0] + Vs[1] + ... + Vs[k]
    1821                 :            : 
    1822                 :            :    The basic steps are listed below:
    1823                 :            : 
    1824                 :            :     1) Check the addition chain *OPS by looking those summands coming from
    1825                 :            :        VECTOR bit_field_ref on VECTOR type.  Put the information into
    1826                 :            :        v_info_map for each satisfied summand, using VECTOR SSA_NAME as key.
    1827                 :            : 
    1828                 :            :     2) For each key (VECTOR SSA_NAME), validate all its BIT_FIELD_REFs are
    1829                 :            :        continuous, they can cover the whole VECTOR perfectly without any holes.
    1830                 :            :        Obtain one VECTOR list which contain candidates to be transformed.
    1831                 :            : 
    1832                 :            :     3) Sort the VECTOR list by machine mode of VECTOR type, for each group of
    1833                 :            :        candidates with same mode, build the addition statements for them and
    1834                 :            :        generate BIT_FIELD_REFs accordingly.
    1835                 :            : 
    1836                 :            :    TODO:
    1837                 :            :        The current implementation requires the whole VECTORs should be fully
    1838                 :            :        covered, but it can be extended to support partial, checking adjacent
    1839                 :            :        but not fill the whole, it may need some cost model to define the
    1840                 :            :        boundary to do or not.
    1841                 :            : */
    1842                 :            : static bool
    1843                 :    2618820 : undistribute_bitref_for_vector (enum tree_code opcode,
    1844                 :            :                                 vec<operand_entry *> *ops, struct loop *loop)
    1845                 :            : {
    1846                 :    2618820 :   if (ops->length () <= 1)
    1847                 :            :     return false;
    1848                 :            : 
    1849                 :    2616210 :   if (opcode != PLUS_EXPR
    1850                 :    2616210 :       && opcode != MULT_EXPR
    1851                 :            :       && opcode != BIT_XOR_EXPR
    1852                 :     704485 :       && opcode != BIT_IOR_EXPR
    1853                 :     486166 :       && opcode != BIT_AND_EXPR)
    1854                 :            :     return false;
    1855                 :            : 
    1856                 :    2516680 :   hash_map<tree, v_info_ptr> v_info_map;
    1857                 :    2516680 :   operand_entry *oe1;
    1858                 :    2516680 :   unsigned i;
    1859                 :            : 
    1860                 :            :   /* Find those summands from VECTOR BIT_FIELD_REF in addition chain, put the
    1861                 :            :      information into map.  */
    1862                 :    7691740 :   FOR_EACH_VEC_ELT (*ops, i, oe1)
    1863                 :            :     {
    1864                 :    5175060 :       enum tree_code dcode;
    1865                 :    5175060 :       gimple *oe1def;
    1866                 :            : 
    1867                 :    5175060 :       if (TREE_CODE (oe1->op) != SSA_NAME)
    1868                 :    1763260 :         continue;
    1869                 :    3411800 :       oe1def = SSA_NAME_DEF_STMT (oe1->op);
    1870                 :    3411800 :       if (!is_gimple_assign (oe1def))
    1871                 :     821207 :         continue;
    1872                 :    2590600 :       dcode = gimple_assign_rhs_code (oe1def);
    1873                 :    2590600 :       if (dcode != BIT_FIELD_REF || !is_reassociable_op (oe1def, dcode, loop))
    1874                 :    2563520 :         continue;
    1875                 :            : 
    1876                 :      27082 :       tree rhs = gimple_assign_rhs1 (oe1def);
    1877                 :      27082 :       tree vec = TREE_OPERAND (rhs, 0);
    1878                 :      27082 :       tree vec_type = TREE_TYPE (vec);
    1879                 :            : 
    1880                 :      27082 :       if (TREE_CODE (vec) != SSA_NAME || !VECTOR_TYPE_P (vec_type))
    1881                 :      12124 :         continue;
    1882                 :            : 
    1883                 :            :       /* Ignore it if target machine can't support this VECTOR type.  */
    1884                 :      14958 :       if (!VECTOR_MODE_P (TYPE_MODE (vec_type)))
    1885                 :       4621 :         continue;
    1886                 :            : 
    1887                 :            :       /* Check const vector type, constrain BIT_FIELD_REF offset and size.  */
    1888                 :      10337 :       if (!TYPE_VECTOR_SUBPARTS (vec_type).is_constant ())
    1889                 :            :         continue;
    1890                 :            : 
    1891                 :      10337 :       if (VECTOR_TYPE_P (TREE_TYPE (rhs))
    1892                 :      10337 :           || !is_a <scalar_mode> (TYPE_MODE (TREE_TYPE (rhs))))
    1893                 :        878 :         continue;
    1894                 :            : 
    1895                 :            :       /* The type of BIT_FIELD_REF might not be equal to the element type of
    1896                 :            :          the vector.  We want to use a vector type with element type the
    1897                 :            :          same as the BIT_FIELD_REF and size the same as TREE_TYPE (vec).  */
    1898                 :       9459 :       if (!useless_type_conversion_p (TREE_TYPE (rhs), TREE_TYPE (vec_type)))
    1899                 :            :         {
    1900                 :       2090 :           machine_mode simd_mode;
    1901                 :       2090 :           unsigned HOST_WIDE_INT size, nunits;
    1902                 :       2090 :           unsigned HOST_WIDE_INT elem_size
    1903                 :       2090 :             = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (rhs)));
    1904                 :       4180 :           if (!GET_MODE_BITSIZE (TYPE_MODE (vec_type)).is_constant (&size))
    1905                 :    5166060 :             continue;
    1906                 :       2090 :           if (size <= elem_size || (size % elem_size) != 0)
    1907                 :          0 :             continue;
    1908                 :       2090 :           nunits = size / elem_size;
    1909                 :       2090 :           if (!mode_for_vector (SCALAR_TYPE_MODE (TREE_TYPE (rhs)),
    1910                 :       6270 :                                 nunits).exists (&simd_mode))
    1911                 :          0 :             continue;
    1912                 :       2090 :           vec_type = build_vector_type_for_mode (TREE_TYPE (rhs), simd_mode);
    1913                 :            : 
    1914                 :            :           /* Ignore it if target machine can't support this VECTOR type.  */
    1915                 :       2090 :           if (!VECTOR_MODE_P (TYPE_MODE (vec_type)))
    1916                 :          0 :             continue;
    1917                 :            : 
    1918                 :            :           /* Check const vector type, constrain BIT_FIELD_REF offset and
    1919                 :            :              size.  */
    1920                 :       2090 :           if (!TYPE_VECTOR_SUBPARTS (vec_type).is_constant ())
    1921                 :            :             continue;
    1922                 :            : 
    1923                 :       4180 :           if (maybe_ne (GET_MODE_SIZE (TYPE_MODE (vec_type)),
    1924                 :       4180 :                         GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (vec)))))
    1925                 :          0 :             continue;
    1926                 :            :         }
    1927                 :            : 
    1928                 :       9459 :       tree elem_type = TREE_TYPE (vec_type);
    1929                 :       9459 :       unsigned HOST_WIDE_INT elem_size = tree_to_uhwi (TYPE_SIZE (elem_type));
    1930                 :       9459 :       if (maybe_ne (bit_field_size (rhs), elem_size))
    1931                 :          0 :         continue;
    1932                 :            : 
    1933                 :       9459 :       unsigned idx;
    1934                 :       9459 :       if (!constant_multiple_p (bit_field_offset (rhs), elem_size, &idx))
    1935                 :          0 :         continue;
    1936                 :            : 
    1937                 :            :       /* Ignore it if target machine can't support this type of VECTOR
    1938                 :            :          operation.  */
    1939                 :       9459 :       optab op_tab = optab_for_tree_code (opcode, vec_type, optab_vector);
    1940                 :       9459 :       if (optab_handler (op_tab, TYPE_MODE (vec_type)) == CODE_FOR_nothing)
    1941                 :        453 :         continue;
    1942                 :            : 
    1943                 :       9006 :       bool existed;
    1944                 :       9006 :       v_info_ptr &info = v_info_map.get_or_insert (vec, &existed);
    1945                 :       9006 :       if (!existed)
    1946                 :            :         {
    1947                 :       6476 :           info = new v_info;
    1948                 :       6476 :           info->vec_type = vec_type;
    1949                 :            :         }
    1950                 :       2530 :       else if (!types_compatible_p (vec_type, info->vec_type))
    1951                 :          0 :         continue;
    1952                 :       9006 :       info->vec.safe_push (std::make_pair (idx, i));
    1953                 :            :     }
    1954                 :            : 
    1955                 :            :   /* At least two VECTOR to combine.  */
    1956                 :    2516680 :   if (v_info_map.elements () <= 1)
    1957                 :            :     {
    1958                 :    2516530 :       cleanup_vinfo_map (v_info_map);
    1959                 :    2516530 :       return false;
    1960                 :            :     }
    1961                 :            : 
    1962                 :            :   /* Verify all VECTOR candidates by checking two conditions:
    1963                 :            :        1) sorted offsets are adjacent, no holes.
    1964                 :            :        2) can fill the whole VECTOR perfectly.
    1965                 :            :      And add the valid candidates to a vector for further handling.  */
    1966                 :        310 :   auto_vec<tree> valid_vecs (v_info_map.elements ());
    1967                 :        155 :   for (hash_map<tree, v_info_ptr>::iterator it = v_info_map.begin ();
    1968                 :       1481 :        it != v_info_map.end (); ++it)
    1969                 :            :     {
    1970                 :        663 :       tree cand_vec = (*it).first;
    1971                 :        663 :       v_info_ptr cand_info = (*it).second;
    1972                 :        663 :       unsigned int num_elems
    1973                 :        663 :         = TYPE_VECTOR_SUBPARTS (cand_info->vec_type).to_constant ();
    1974                 :        663 :       if (cand_info->vec.length () != num_elems)
    1975                 :        275 :         continue;
    1976                 :        388 :       sbitmap holes = sbitmap_alloc (num_elems);
    1977                 :        388 :       bitmap_ones (holes);
    1978                 :        388 :       bool valid = true;
    1979                 :        388 :       v_info_elem *curr;
    1980                 :       1872 :       FOR_EACH_VEC_ELT (cand_info->vec, i, curr)
    1981                 :            :         {
    1982                 :       1484 :           if (!bitmap_bit_p (holes, curr->first))
    1983                 :            :             {
    1984                 :            :               valid = false;
    1985                 :            :               break;
    1986                 :            :             }
    1987                 :            :           else
    1988                 :       1484 :             bitmap_clear_bit (holes, curr->first);
    1989                 :            :         }
    1990                 :        388 :       if (valid && bitmap_empty_p (holes))
    1991                 :        388 :         valid_vecs.quick_push (cand_vec);
    1992                 :        388 :       sbitmap_free (holes);
    1993                 :            :     }
    1994                 :            : 
    1995                 :            :   /* At least two VECTOR to combine.  */
    1996                 :        155 :   if (valid_vecs.length () <= 1)
    1997                 :            :     {
    1998                 :        125 :       cleanup_vinfo_map (v_info_map);
    1999                 :        125 :       return false;
    2000                 :            :     }
    2001                 :            : 
    2002                 :         30 :   valid_vecs.qsort (sort_by_mach_mode);
    2003                 :            :   /* Go through all candidates by machine mode order, query the mode_to_total
    2004                 :            :      to get the total number for each mode and skip the single one.  */
    2005                 :         66 :   for (unsigned i = 0; i < valid_vecs.length () - 1; ++i)
    2006                 :            :     {
    2007                 :         36 :       tree tvec = valid_vecs[i];
    2008                 :         36 :       enum machine_mode mode = TYPE_MODE (TREE_TYPE (tvec));
    2009                 :            : 
    2010                 :            :       /* Skip modes with only a single candidate.  */
    2011                 :         36 :       if (TYPE_MODE (TREE_TYPE (valid_vecs[i + 1])) != mode)
    2012                 :          4 :         continue;
    2013                 :            : 
    2014                 :         32 :       unsigned int idx, j;
    2015                 :         32 :       gimple *sum = NULL;
    2016                 :         32 :       tree sum_vec = tvec;
    2017                 :         32 :       v_info_ptr info_ptr = *(v_info_map.get (tvec));
    2018                 :         32 :       v_info_elem *elem;
    2019                 :         32 :       tree vec_type = info_ptr->vec_type;
    2020                 :            : 
    2021                 :            :       /* Build the sum for all candidates with same mode.  */
    2022                 :        307 :       do
    2023                 :            :         {
    2024                 :        307 :           sum = build_and_add_sum (vec_type, sum_vec,
    2025                 :        307 :                                    valid_vecs[i + 1], opcode);
    2026                 :        307 :           if (!useless_type_conversion_p (vec_type,
    2027                 :        307 :                                           TREE_TYPE (valid_vecs[i + 1])))
    2028                 :            :             {
    2029                 :            :               /* Update the operands only after build_and_add_sum,
    2030                 :            :                  so that we don't have to repeat the placement algorithm
    2031                 :            :                  of build_and_add_sum.  */
    2032                 :        266 :               gimple_stmt_iterator gsi = gsi_for_stmt (sum);
    2033                 :        266 :               tree vce = build1 (VIEW_CONVERT_EXPR, vec_type,
    2034                 :        266 :                                  valid_vecs[i + 1]);
    2035                 :        266 :               tree lhs = make_ssa_name (vec_type);
    2036                 :        266 :               gimple *g = gimple_build_assign (lhs, VIEW_CONVERT_EXPR, vce);
    2037                 :        266 :               gimple_set_uid (g, gimple_uid (sum));
    2038                 :        266 :               gsi_insert_before (&gsi, g, GSI_NEW_STMT);
    2039                 :        266 :               gimple_assign_set_rhs2 (sum, lhs);
    2040                 :        266 :               if (sum_vec == tvec)
    2041                 :            :                 {
    2042                 :         14 :                   vce = build1 (VIEW_CONVERT_EXPR, vec_type, sum_vec);
    2043                 :         14 :                   lhs = make_ssa_name (vec_type);
    2044                 :         14 :                   g = gimple_build_assign (lhs, VIEW_CONVERT_EXPR, vce);
    2045                 :         14 :                   gimple_set_uid (g, gimple_uid (sum));
    2046                 :         14 :                   gsi_insert_before (&gsi, g, GSI_NEW_STMT);
    2047                 :         14 :                   gimple_assign_set_rhs1 (sum, lhs);
    2048                 :            :                 }
    2049                 :        266 :               update_stmt (sum);
    2050                 :            :             }
    2051                 :        307 :           sum_vec = gimple_get_lhs (sum);
    2052                 :        307 :           info_ptr = *(v_info_map.get (valid_vecs[i + 1]));
    2053                 :        307 :           gcc_assert (types_compatible_p (vec_type, info_ptr->vec_type));
    2054                 :            :           /* Update those related ops of current candidate VECTOR.  */
    2055                 :       1521 :           FOR_EACH_VEC_ELT (info_ptr->vec, j, elem)
    2056                 :            :             {
    2057                 :       1214 :               idx = elem->second;
    2058                 :       1214 :               gimple *def = SSA_NAME_DEF_STMT ((*ops)[idx]->op);
    2059                 :            :               /* Set this then op definition will get DCEd later.  */
    2060                 :       1214 :               gimple_set_visited (def, true);
    2061                 :       1214 :               if (opcode == PLUS_EXPR
    2062                 :       1214 :                   || opcode == BIT_XOR_EXPR
    2063                 :         72 :                   || opcode == BIT_IOR_EXPR)
    2064                 :       1166 :                 (*ops)[idx]->op = build_zero_cst (TREE_TYPE ((*ops)[idx]->op));
    2065                 :         48 :               else if (opcode == MULT_EXPR)
    2066                 :         24 :                 (*ops)[idx]->op = build_one_cst (TREE_TYPE ((*ops)[idx]->op));
    2067                 :            :               else
    2068                 :            :                 {
    2069                 :         24 :                   gcc_assert (opcode == BIT_AND_EXPR);
    2070                 :         48 :                   (*ops)[idx]->op
    2071                 :         24 :                     = build_all_ones_cst (TREE_TYPE ((*ops)[idx]->op));
    2072                 :            :                 }
    2073                 :       1214 :               (*ops)[idx]->rank = 0;
    2074                 :            :             }
    2075                 :        307 :           if (dump_file && (dump_flags & TDF_DETAILS))
    2076                 :            :             {
    2077                 :          0 :               fprintf (dump_file, "Generating addition -> ");
    2078                 :          0 :               print_gimple_stmt (dump_file, sum, 0);
    2079                 :            :             }
    2080                 :        307 :           i++;
    2081                 :            :         }
    2082                 :        307 :       while ((i < valid_vecs.length () - 1)
    2083                 :        307 :              && TYPE_MODE (TREE_TYPE (valid_vecs[i + 1])) == mode);
    2084                 :            : 
    2085                 :            :       /* Referring to first valid VECTOR with this mode, generate the
    2086                 :            :          BIT_FIELD_REF statements accordingly.  */
    2087                 :         32 :       info_ptr = *(v_info_map.get (tvec));
    2088                 :         32 :       gcc_assert (sum);
    2089                 :         32 :       tree elem_type = TREE_TYPE (vec_type);
    2090                 :        160 :       FOR_EACH_VEC_ELT (info_ptr->vec, j, elem)
    2091                 :            :         {
    2092                 :        128 :           idx = elem->second;
    2093                 :        128 :           tree dst = make_ssa_name (elem_type);
    2094                 :        128 :           tree pos = bitsize_int (elem->first
    2095                 :            :                                   * tree_to_uhwi (TYPE_SIZE (elem_type)));
    2096                 :        128 :           tree bfr = build3 (BIT_FIELD_REF, elem_type, sum_vec,
    2097                 :        128 :                              TYPE_SIZE (elem_type), pos);
    2098                 :        128 :           gimple *gs = gimple_build_assign (dst, BIT_FIELD_REF, bfr);
    2099                 :        128 :           insert_stmt_after (gs, sum);
    2100                 :        128 :           gimple *def = SSA_NAME_DEF_STMT ((*ops)[idx]->op);
    2101                 :            :           /* Set this then op definition will get DCEd later.  */
    2102                 :        128 :           gimple_set_visited (def, true);
    2103                 :        128 :           (*ops)[idx]->op = gimple_assign_lhs (gs);
    2104                 :        128 :           (*ops)[idx]->rank = get_rank ((*ops)[idx]->op);
    2105                 :        128 :           if (dump_file && (dump_flags & TDF_DETAILS))
    2106                 :            :             {
    2107                 :          0 :               fprintf (dump_file, "Generating bit_field_ref -> ");
    2108                 :          0 :               print_gimple_stmt (dump_file, gs, 0);
    2109                 :            :             }
    2110                 :            :         }
    2111                 :            :     }
    2112                 :            : 
    2113                 :         30 :   if (dump_file && (dump_flags & TDF_DETAILS))
    2114                 :          0 :     fprintf (dump_file, "undistributiong bit_field_ref for vector done.\n");
    2115                 :            : 
    2116                 :         30 :   cleanup_vinfo_map (v_info_map);
    2117                 :            : 
    2118                 :         30 :   return true;
    2119                 :            : }
    2120                 :            : 
    2121                 :            : /* If OPCODE is BIT_IOR_EXPR or BIT_AND_EXPR and CURR is a comparison
    2122                 :            :    expression, examine the other OPS to see if any of them are comparisons
    2123                 :            :    of the same values, which we may be able to combine or eliminate.
    2124                 :            :    For example, we can rewrite (a < b) | (a == b) as (a <= b).  */
    2125                 :            : 
    2126                 :            : static bool
    2127                 :    5383770 : eliminate_redundant_comparison (enum tree_code opcode,
    2128                 :            :                                 vec<operand_entry *> *ops,
    2129                 :            :                                 unsigned int currindex,
    2130                 :            :                                 operand_entry *curr)
    2131                 :            : {
    2132                 :    5383770 :   tree op1, op2;
    2133                 :    5383770 :   enum tree_code lcode, rcode;
    2134                 :    5383770 :   gimple *def1, *def2;
    2135                 :    5383770 :   int i;
    2136                 :    5383770 :   operand_entry *oe;
    2137                 :            : 
    2138                 :    5383770 :   if (opcode != BIT_IOR_EXPR && opcode != BIT_AND_EXPR)
    2139                 :            :     return false;
    2140                 :            : 
    2141                 :            :   /* Check that CURR is a comparison.  */
    2142                 :    1163520 :   if (TREE_CODE (curr->op) != SSA_NAME)
    2143                 :            :     return false;
    2144                 :     869022 :   def1 = SSA_NAME_DEF_STMT (curr->op);
    2145                 :     869022 :   if (!is_gimple_assign (def1))
    2146                 :            :     return false;
    2147                 :     757833 :   lcode = gimple_assign_rhs_code (def1);
    2148                 :     757833 :   if (TREE_CODE_CLASS (lcode) != tcc_comparison)
    2149                 :            :     return false;
    2150                 :     357485 :   op1 = gimple_assign_rhs1 (def1);
    2151                 :     357485 :   op2 = gimple_assign_rhs2 (def1);
    2152                 :            : 
    2153                 :            :   /* Now look for a similar comparison in the remaining OPS.  */
    2154                 :     557067 :   for (i = currindex + 1; ops->iterate (i, &oe); i++)
    2155                 :            :     {
    2156                 :     199652 :       tree t;
    2157                 :            : 
    2158                 :     199652 :       if (TREE_CODE (oe->op) != SSA_NAME)
    2159                 :          0 :         continue;
    2160                 :     199652 :       def2 = SSA_NAME_DEF_STMT (oe->op);
    2161                 :     199652 :       if (!is_gimple_assign (def2))
    2162                 :       2650 :         continue;
    2163                 :     197002 :       rcode = gimple_assign_rhs_code (def2);
    2164                 :     197002 :       if (TREE_CODE_CLASS (rcode) != tcc_comparison)
    2165                 :       3977 :         continue;
    2166                 :            : 
    2167                 :            :       /* If we got here, we have a match.  See if we can combine the
    2168                 :            :          two comparisons.  */
    2169                 :     193025 :       tree type = TREE_TYPE (gimple_assign_lhs (def1));
    2170                 :     193025 :       if (opcode == BIT_IOR_EXPR)
    2171                 :     101358 :         t = maybe_fold_or_comparisons (type,
    2172                 :            :                                        lcode, op1, op2,
    2173                 :            :                                        rcode, gimple_assign_rhs1 (def2),
    2174                 :            :                                        gimple_assign_rhs2 (def2));
    2175                 :            :       else
    2176                 :      91667 :         t = maybe_fold_and_comparisons (type,
    2177                 :            :                                         lcode, op1, op2,
    2178                 :            :                                         rcode, gimple_assign_rhs1 (def2),
    2179                 :            :                                         gimple_assign_rhs2 (def2));
    2180                 :     193025 :       if (!t)
    2181                 :     192955 :         continue;
    2182                 :            : 
    2183                 :            :       /* maybe_fold_and_comparisons and maybe_fold_or_comparisons
    2184                 :            :          always give us a boolean_type_node value back.  If the original
    2185                 :            :          BIT_AND_EXPR or BIT_IOR_EXPR was of a wider integer type,
    2186                 :            :          we need to convert.  */
    2187                 :         70 :       if (!useless_type_conversion_p (TREE_TYPE (curr->op), TREE_TYPE (t)))
    2188                 :          1 :         t = fold_convert (TREE_TYPE (curr->op), t);
    2189                 :            : 
    2190                 :         70 :       if (TREE_CODE (t) != INTEGER_CST
    2191                 :         70 :           && !operand_equal_p (t, curr->op, 0))
    2192                 :            :         {
    2193                 :         66 :           enum tree_code subcode;
    2194                 :         66 :           tree newop1, newop2;
    2195                 :         66 :           if (!COMPARISON_CLASS_P (t))
    2196                 :          0 :             continue;
    2197                 :         66 :           extract_ops_from_tree (t, &subcode, &newop1, &newop2);
    2198                 :         66 :           STRIP_USELESS_TYPE_CONVERSION (newop1);
    2199                 :         66 :           STRIP_USELESS_TYPE_CONVERSION (newop2);
    2200                 :         66 :           if (!is_gimple_val (newop1) || !is_gimple_val (newop2))
    2201                 :          0 :             continue;
    2202                 :            :         }
    2203                 :            : 
    2204                 :         70 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2205                 :            :         {
    2206                 :          0 :           fprintf (dump_file, "Equivalence: ");
    2207                 :          0 :           print_generic_expr (dump_file, curr->op);
    2208                 :          0 :           fprintf (dump_file, " %s ", op_symbol_code (opcode));
    2209                 :          0 :           print_generic_expr (dump_file, oe->op);
    2210                 :          0 :           fprintf (dump_file, " -> ");
    2211                 :          0 :           print_generic_expr (dump_file, t);
    2212                 :          0 :           fprintf (dump_file, "\n");
    2213                 :            :         }
    2214                 :            : 
    2215                 :            :       /* Now we can delete oe, as it has been subsumed by the new combined
    2216                 :            :          expression t.  */
    2217                 :         70 :       ops->ordered_remove (i);
    2218                 :         70 :       reassociate_stats.ops_eliminated ++;
    2219                 :            : 
    2220                 :            :       /* If t is the same as curr->op, we're done.  Otherwise we must
    2221                 :            :          replace curr->op with t.  Special case is if we got a constant
    2222                 :            :          back, in which case we add it to the end instead of in place of
    2223                 :            :          the current entry.  */
    2224                 :         70 :       if (TREE_CODE (t) == INTEGER_CST)
    2225                 :            :         {
    2226                 :          4 :           ops->ordered_remove (currindex);
    2227                 :          4 :           add_to_ops_vec (ops, t);
    2228                 :            :         }
    2229                 :         66 :       else if (!operand_equal_p (t, curr->op, 0))
    2230                 :            :         {
    2231                 :         66 :           gimple *sum;
    2232                 :         66 :           enum tree_code subcode;
    2233                 :         66 :           tree newop1;
    2234                 :         66 :           tree newop2;
    2235                 :         66 :           gcc_assert (COMPARISON_CLASS_P (t));
    2236                 :         66 :           extract_ops_from_tree (t, &subcode, &newop1, &newop2);
    2237                 :         66 :           STRIP_USELESS_TYPE_CONVERSION (newop1);
    2238                 :         66 :           STRIP_USELESS_TYPE_CONVERSION (newop2);
    2239                 :         66 :           gcc_checking_assert (is_gimple_val (newop1)
    2240                 :            :                                && is_gimple_val (newop2));
    2241                 :         66 :           sum = build_and_add_sum (TREE_TYPE (t), newop1, newop2, subcode);
    2242                 :         66 :           curr->op = gimple_get_lhs (sum);
    2243                 :            :         }
    2244                 :            :       return true;
    2245                 :            :     }
    2246                 :            : 
    2247                 :            :   return false;
    2248                 :            : }
    2249                 :            : 
    2250                 :            : 
    2251                 :            : /* Transform repeated addition of same values into multiply with
    2252                 :            :    constant.  */
    2253                 :            : static bool
    2254                 :    1242740 : transform_add_to_multiply (vec<operand_entry *> *ops)
    2255                 :            : {
    2256                 :    1242740 :   operand_entry *oe;
    2257                 :    1242740 :   tree op = NULL_TREE;
    2258                 :    1242740 :   int j;
    2259                 :    1242740 :   int i, start = -1, end = 0, count = 0;
    2260                 :    1242740 :   auto_vec<std::pair <int, int> > indxs;
    2261                 :    1242740 :   bool changed = false;
    2262                 :            : 
    2263                 :    2483900 :   if (!INTEGRAL_TYPE_P (TREE_TYPE ((*ops)[0]->op))
    2264                 :    1289420 :       && (!SCALAR_FLOAT_TYPE_P (TREE_TYPE ((*ops)[0]->op))
    2265                 :      31711 :           || !flag_unsafe_math_optimizations))
    2266                 :            :     return false;
    2267                 :            : 
    2268                 :            :   /* Look for repeated operands.  */
    2269                 :    3776810 :   FOR_EACH_VEC_ELT (*ops, i, oe)
    2270                 :            :     {
    2271                 :    2549060 :       if (start == -1)
    2272                 :            :         {
    2273                 :    1227750 :           count = 1;
    2274                 :    1227750 :           op = oe->op;
    2275                 :    1227750 :           start = i;
    2276                 :            :         }
    2277                 :    1321310 :       else if (operand_equal_p (oe->op, op, 0))
    2278                 :            :         {
    2279                 :        151 :           count++;
    2280                 :        151 :           end = i;
    2281                 :            :         }
    2282                 :            :       else
    2283                 :            :         {
    2284                 :    1321160 :           if (count > 1)
    2285                 :         47 :             indxs.safe_push (std::make_pair (start, end));
    2286                 :    1321160 :           count = 1;
    2287                 :    1321160 :           op = oe->op;
    2288                 :    1321160 :           start = i;
    2289                 :            :         }
    2290                 :            :     }
    2291                 :            : 
    2292                 :    1227750 :   if (count > 1)
    2293                 :         32 :     indxs.safe_push (std::make_pair (start, end));
    2294                 :            : 
    2295                 :    1227890 :   for (j = indxs.length () - 1; j >= 0; --j)
    2296                 :            :     {
    2297                 :            :       /* Convert repeated operand addition to multiplication.  */
    2298                 :         79 :       start = indxs[j].first;
    2299                 :         79 :       end = indxs[j].second;
    2300                 :         79 :       op = (*ops)[start]->op;
    2301                 :         79 :       count = end - start + 1;
    2302                 :        309 :       for (i = end; i >= start; --i)
    2303                 :        230 :         ops->unordered_remove (i);
    2304                 :         79 :       tree tmp = make_ssa_name (TREE_TYPE (op));
    2305                 :         79 :       tree cst = build_int_cst (integer_type_node, count);
    2306                 :         79 :       gassign *mul_stmt
    2307                 :         79 :         = gimple_build_assign (tmp, MULT_EXPR,
    2308                 :         79 :                                op, fold_convert (TREE_TYPE (op), cst));
    2309                 :         79 :       gimple_set_visited (mul_stmt, true);
    2310                 :         79 :       add_to_ops_vec (ops, tmp, mul_stmt);
    2311                 :         79 :       changed = true;
    2312                 :            :     }
    2313                 :            : 
    2314                 :            :   return changed;
    2315                 :            : }
    2316                 :            : 
    2317                 :            : 
    2318                 :            : /* Perform various identities and other optimizations on the list of
    2319                 :            :    operand entries, stored in OPS.  The tree code for the binary
    2320                 :            :    operation between all the operands is OPCODE.  */
    2321                 :            : 
    2322                 :            : static void
    2323                 :    2659280 : optimize_ops_list (enum tree_code opcode,
    2324                 :            :                    vec<operand_entry *> *ops)
    2325                 :            : {
    2326                 :    2659280 :   unsigned int length = ops->length ();
    2327                 :    2659280 :   unsigned int i;
    2328                 :    2659280 :   operand_entry *oe;
    2329                 :    5317550 :   operand_entry *oelast = NULL;
    2330                 :    5317550 :   bool iterate = false;
    2331                 :            : 
    2332                 :    2659280 :   if (length == 1)
    2333                 :    2659280 :     return;
    2334                 :            : 
    2335                 :    2658270 :   oelast = ops->last ();
    2336                 :            : 
    2337                 :            :   /* If the last two are constants, pop the constants off, merge them
    2338                 :            :      and try the next two.  */
    2339                 :    2658270 :   if (oelast->rank == 0 && is_gimple_min_invariant (oelast->op))
    2340                 :            :     {
    2341                 :    1867830 :       operand_entry *oelm1 = (*ops)[length - 2];
    2342                 :            : 
    2343                 :    1867830 :       if (oelm1->rank == 0
    2344                 :      37495 :           && is_gimple_min_invariant (oelm1->op)
    2345                 :    1905320 :           && useless_type_conversion_p (TREE_TYPE (oelm1->op),
    2346                 :      37495 :                                        TREE_TYPE (oelast->op)))
    2347                 :            :         {
    2348                 :      37495 :           tree folded = fold_binary (opcode, TREE_TYPE (oelm1->op),
    2349                 :            :                                      oelm1->op, oelast->op);
    2350                 :            : 
    2351                 :      37495 :           if (folded && is_gimple_min_invariant (folded))
    2352                 :            :             {
    2353                 :      37477 :               if (dump_file && (dump_flags & TDF_DETAILS))
    2354                 :          0 :                 fprintf (dump_file, "Merging constants\n");
    2355                 :            : 
    2356                 :      37477 :               ops->pop ();
    2357                 :      37477 :               ops->pop ();
    2358                 :            : 
    2359                 :      37477 :               add_to_ops_vec (ops, folded);
    2360                 :      37477 :               reassociate_stats.constants_eliminated++;
    2361                 :            : 
    2362                 :      37477 :               optimize_ops_list (opcode, ops);
    2363                 :      37477 :               return;
    2364                 :            :             }
    2365                 :            :         }
    2366                 :            :     }
    2367                 :            : 
    2368                 :    2620790 :   eliminate_using_constants (opcode, ops);
    2369                 :    2620790 :   oelast = NULL;
    2370                 :            : 
    2371                 :    8007380 :   for (i = 0; ops->iterate (i, &oe);)
    2372                 :            :     {
    2373                 :    5386590 :       bool done = false;
    2374                 :            : 
    2375                 :    5386590 :       if (eliminate_not_pairs (opcode, ops, i, oe))
    2376                 :          2 :         return;
    2377                 :    5386590 :       if (eliminate_duplicate_pair (opcode, ops, &done, i, oe, oelast)
    2378                 :    5386530 :           || (!done && eliminate_plus_minus_pair (opcode, ops, i, oe))
    2379                 :   10770400 :           || (!done && eliminate_redundant_comparison (opcode, ops, i, oe)))
    2380                 :            :         {
    2381                 :       2885 :           if (done)
    2382                 :            :             return;
    2383                 :       2884 :           iterate = true;
    2384                 :       2884 :           oelast = NULL;
    2385                 :       2884 :           continue;
    2386                 :            :         }
    2387                 :    5383700 :       oelast = oe;
    2388                 :    5383700 :       i++;
    2389                 :            :     }
    2390                 :            : 
    2391                 :    2620790 :   if (iterate)
    2392                 :       2854 :     optimize_ops_list (opcode, ops);
    2393                 :            : }
    2394                 :            : 
    2395                 :            : /* The following functions are subroutines to optimize_range_tests and allow
    2396                 :            :    it to try to change a logical combination of comparisons into a range
    2397                 :            :    test.
    2398                 :            : 
    2399                 :            :    For example, both
    2400                 :            :         X == 2 || X == 5 || X == 3 || X == 4
    2401                 :            :    and
    2402                 :            :         X >= 2 && X <= 5
    2403                 :            :    are converted to
    2404                 :            :         (unsigned) (X - 2) <= 3
    2405                 :            : 
    2406                 :            :    For more information see comments above fold_test_range in fold-const.c,
    2407                 :            :    this implementation is for GIMPLE.  */
    2408                 :            : 
    2409                 :            : struct range_entry
    2410                 :            : {
    2411                 :            :   tree exp;
    2412                 :            :   tree low;
    2413                 :            :   tree high;
    2414                 :            :   bool in_p;
    2415                 :            :   bool strict_overflow_p;
    2416                 :            :   unsigned int idx, next;
    2417                 :            : };
    2418                 :            : 
    2419                 :            : /* This is similar to make_range in fold-const.c, but on top of
    2420                 :            :    GIMPLE instead of trees.  If EXP is non-NULL, it should be
    2421                 :            :    an SSA_NAME and STMT argument is ignored, otherwise STMT
    2422                 :            :    argument should be a GIMPLE_COND.  */
    2423                 :            : 
    2424                 :            : static void
    2425                 :    1373290 : init_range_entry (struct range_entry *r, tree exp, gimple *stmt)
    2426                 :            : {
    2427                 :    1373290 :   int in_p;
    2428                 :    1373290 :   tree low, high;
    2429                 :    1373290 :   bool is_bool, strict_overflow_p;
    2430                 :            : 
    2431                 :    1373290 :   r->exp = NULL_TREE;
    2432                 :    1373290 :   r->in_p = false;
    2433                 :    1373290 :   r->strict_overflow_p = false;
    2434                 :    1373290 :   r->low = NULL_TREE;
    2435                 :    1373290 :   r->high = NULL_TREE;
    2436                 :    1373290 :   if (exp != NULL_TREE
    2437                 :    2262670 :       && (TREE_CODE (exp) != SSA_NAME || !INTEGRAL_TYPE_P (TREE_TYPE (exp))))
    2438                 :     439364 :     return;
    2439                 :            : 
    2440                 :            :   /* Start with simply saying "EXP != 0" and then look at the code of EXP
    2441                 :            :      and see if we can refine the range.  Some of the cases below may not
    2442                 :            :      happen, but it doesn't seem worth worrying about this.  We "continue"
    2443                 :            :      the outer loop when we've changed something; otherwise we "break"
    2444                 :            :      the switch, which will "break" the while.  */
    2445                 :    1077430 :   low = exp ? build_int_cst (TREE_TYPE (exp), 0) : boolean_false_node;
    2446                 :    1077430 :   high = low;
    2447                 :    1077430 :   in_p = 0;
    2448                 :    1077430 :   strict_overflow_p = false;
    2449                 :    1077430 :   is_bool = false;
    2450                 :    1077430 :   if (exp == NULL_TREE)
    2451                 :            :     is_bool = true;
    2452                 :     887282 :   else if (TYPE_PRECISION (TREE_TYPE (exp)) == 1)
    2453                 :            :     {
    2454                 :     408308 :       if (TYPE_UNSIGNED (TREE_TYPE (exp)))
    2455                 :            :         is_bool = true;
    2456                 :            :       else
    2457                 :            :         return;
    2458                 :            :     }
    2459                 :     478974 :   else if (TREE_CODE (TREE_TYPE (exp)) == BOOLEAN_TYPE)
    2460                 :          0 :     is_bool = true;
    2461                 :            : 
    2462                 :    1540150 :   while (1)
    2463                 :            :     {
    2464                 :    1540150 :       enum tree_code code;
    2465                 :    1540150 :       tree arg0, arg1, exp_type;
    2466                 :    1540150 :       tree nexp;
    2467                 :    1540150 :       location_t loc;
    2468                 :            : 
    2469                 :    1540150 :       if (exp != NULL_TREE)
    2470                 :            :         {
    2471                 :    1350000 :           if (TREE_CODE (exp) != SSA_NAME
    2472                 :    1350000 :               || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (exp))
    2473                 :            :             break;
    2474                 :            : 
    2475                 :    1349980 :           stmt = SSA_NAME_DEF_STMT (exp);
    2476                 :    1349980 :           if (!is_gimple_assign (stmt))
    2477                 :            :             break;
    2478                 :            : 
    2479                 :    1111540 :           code = gimple_assign_rhs_code (stmt);
    2480                 :    1111540 :           arg0 = gimple_assign_rhs1 (stmt);
    2481                 :    1111540 :           arg1 = gimple_assign_rhs2 (stmt);
    2482                 :    1111540 :           exp_type = TREE_TYPE (exp);
    2483                 :            :         }
    2484                 :            :       else
    2485                 :            :         {
    2486                 :     190146 :           code = gimple_cond_code (stmt);
    2487                 :     190146 :           arg0 = gimple_cond_lhs (stmt);
    2488                 :     190146 :           arg1 = gimple_cond_rhs (stmt);
    2489                 :     190146 :           exp_type = boolean_type_node;
    2490                 :            :         }
    2491                 :            : 
    2492                 :    1301690 :       if (TREE_CODE (arg0) != SSA_NAME
    2493                 :    1301690 :           || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg0))
    2494                 :            :         break;
    2495                 :     979450 :       loc = gimple_location (stmt);
    2496                 :     979450 :       switch (code)
    2497                 :            :         {
    2498                 :      11647 :         case BIT_NOT_EXPR:
    2499                 :      11647 :           if (TREE_CODE (TREE_TYPE (exp)) == BOOLEAN_TYPE
    2500                 :            :               /* Ensure the range is either +[-,0], +[0,0],
    2501                 :            :                  -[-,0], -[0,0] or +[1,-], +[1,1], -[1,-] or
    2502                 :            :                  -[1,1].  If it is e.g. +[-,-] or -[-,-]
    2503                 :            :                  or similar expression of unconditional true or
    2504                 :            :                  false, it should not be negated.  */
    2505                 :      11647 :               && ((high && integer_zerop (high))
    2506                 :          0 :                   || (low && integer_onep (low))))
    2507                 :            :             {
    2508                 :       4283 :               in_p = !in_p;
    2509                 :       4283 :               exp = arg0;
    2510                 :       4283 :               continue;
    2511                 :            :             }
    2512                 :            :           break;
    2513                 :       2295 :         case SSA_NAME:
    2514                 :       2295 :           exp = arg0;
    2515                 :       2295 :           continue;
    2516                 :     124820 :         CASE_CONVERT:
    2517                 :     124820 :           if (is_bool)
    2518                 :            :             {
    2519                 :      41248 :               if ((TYPE_PRECISION (exp_type) == 1
    2520                 :      37575 :                    || TREE_CODE (exp_type) == BOOLEAN_TYPE)
    2521                 :      44921 :                   && TYPE_PRECISION (TREE_TYPE (arg0)) > 1)
    2522                 :            :                 return;
    2523                 :            :             }
    2524                 :      83572 :           else if (TYPE_PRECISION (TREE_TYPE (arg0)) == 1)
    2525                 :            :             {
    2526                 :       1972 :               if (TYPE_UNSIGNED (TREE_TYPE (arg0)))
    2527                 :            :                 is_bool = true;
    2528                 :            :               else
    2529                 :            :                 return;
    2530                 :            :             }
    2531                 :      81600 :           else if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE)
    2532                 :          0 :             is_bool = true;
    2533                 :     123470 :           goto do_default;
    2534                 :            :         case EQ_EXPR:
    2535                 :            :         case NE_EXPR:
    2536                 :            :         case LT_EXPR:
    2537                 :            :         case LE_EXPR:
    2538                 :            :         case GE_EXPR:
    2539                 :            :         case GT_EXPR:
    2540                 :            :           is_bool = true;
    2541                 :            :           /* FALLTHRU */
    2542                 :     275083 :         default:
    2543                 :     275083 :           if (!is_bool)
    2544                 :            :             return;
    2545                 :     132933 :         do_default:
    2546                 :     822008 :           nexp = make_range_step (loc, code, arg0, arg1, exp_type,
    2547                 :            :                                   &low, &high, &in_p,
    2548                 :            :                                   &strict_overflow_p);
    2549                 :     822008 :           if (nexp != NULL_TREE)
    2550                 :            :             {
    2551                 :     456145 :               exp = nexp;
    2552                 :     456145 :               gcc_assert (TREE_CODE (exp) == SSA_NAME);
    2553                 :     456145 :               continue;
    2554                 :            :             }
    2555                 :            :           break;
    2556                 :            :         }
    2557                 :            :       break;
    2558                 :            :     }
    2559                 :     933928 :   if (is_bool)
    2560                 :            :     {
    2561                 :     599076 :       r->exp = exp;
    2562                 :     599076 :       r->in_p = in_p;
    2563                 :     599076 :       r->low = low;
    2564                 :     599076 :       r->high = high;
    2565                 :     599076 :       r->strict_overflow_p = strict_overflow_p;
    2566                 :            :     }
    2567                 :            : }
    2568                 :            : 
    2569                 :            : /* Comparison function for qsort.  Sort entries
    2570                 :            :    without SSA_NAME exp first, then with SSA_NAMEs sorted
    2571                 :            :    by increasing SSA_NAME_VERSION, and for the same SSA_NAMEs
    2572                 :            :    by increasing ->low and if ->low is the same, by increasing
    2573                 :            :    ->high.  ->low == NULL_TREE means minimum, ->high == NULL_TREE
    2574                 :            :    maximum.  */
    2575                 :            : 
    2576                 :            : static int
    2577                 :    3544660 : range_entry_cmp (const void *a, const void *b)
    2578                 :            : {
    2579                 :    3544660 :   const struct range_entry *p = (const struct range_entry *) a;
    2580                 :    3544660 :   const struct range_entry *q = (const struct range_entry *) b;
    2581                 :            : 
    2582                 :    3544660 :   if (p->exp != NULL_TREE && TREE_CODE (p->exp) == SSA_NAME)
    2583                 :            :     {
    2584                 :    1554380 :       if (q->exp != NULL_TREE && TREE_CODE (q->exp) == SSA_NAME)
    2585                 :            :         {
    2586                 :            :           /* Group range_entries for the same SSA_NAME together.  */
    2587                 :    1507900 :           if (SSA_NAME_VERSION (p->exp) < SSA_NAME_VERSION (q->exp))
    2588                 :            :             return -1;
    2589                 :     661774 :           else if (SSA_NAME_VERSION (p->exp) > SSA_NAME_VERSION (q->exp))
    2590                 :            :             return 1;
    2591                 :            :           /* If ->low is different, NULL low goes first, then by
    2592                 :            :              ascending low.  */
    2593                 :     175079 :           if (p->low != NULL_TREE)
    2594                 :            :             {
    2595                 :     161267 :               if (q->low != NULL_TREE)
    2596                 :            :                 {
    2597                 :     155998 :                   tree tem = fold_binary (LT_EXPR, boolean_type_node,
    2598                 :            :                                           p->low, q->low);
    2599                 :     155998 :                   if (tem && integer_onep (tem))
    2600                 :            :                     return -1;
    2601                 :      69691 :                   tem = fold_binary (GT_EXPR, boolean_type_node,
    2602                 :            :                                      p->low, q->low);
    2603                 :      69691 :                   if (tem && integer_onep (tem))
    2604                 :            :                     return 1;
    2605                 :            :                 }
    2606                 :            :               else
    2607                 :            :                 return 1;
    2608                 :            :             }
    2609                 :      13812 :           else if (q->low != NULL_TREE)
    2610                 :            :             return -1;
    2611                 :            :           /* If ->high is different, NULL high goes last, before that by
    2612                 :            :              ascending high.  */
    2613                 :      17009 :           if (p->high != NULL_TREE)
    2614                 :            :             {
    2615                 :      16956 :               if (q->high != NULL_TREE)
    2616                 :            :                 {
    2617                 :      16865 :                   tree tem = fold_binary (LT_EXPR, boolean_type_node,
    2618                 :            :                                           p->high, q->high);
    2619                 :      16865 :                   if (tem && integer_onep (tem))
    2620                 :            :                     return -1;
    2621                 :       4539 :                   tem = fold_binary (GT_EXPR, boolean_type_node,
    2622                 :            :                                      p->high, q->high);
    2623                 :       4539 :                   if (tem && integer_onep (tem))
    2624                 :            :                     return 1;
    2625                 :            :                 }
    2626                 :            :               else
    2627                 :            :                 return -1;
    2628                 :            :             }
    2629                 :         53 :           else if (q->high != NULL_TREE)
    2630                 :            :             return 1;
    2631                 :            :           /* If both ranges are the same, sort below by ascending idx.  */
    2632                 :            :         }
    2633                 :            :       else
    2634                 :            :         return 1;
    2635                 :            :     }
    2636                 :    1990270 :   else if (q->exp != NULL_TREE && TREE_CODE (q->exp) == SSA_NAME)
    2637                 :            :     return -1;
    2638                 :            : 
    2639                 :    1928710 :   if (p->idx < q->idx)
    2640                 :            :     return -1;
    2641                 :            :   else
    2642                 :            :     {
    2643                 :     973053 :       gcc_checking_assert (p->idx > q->idx);
    2644                 :            :       return 1;
    2645                 :            :     }
    2646                 :            : }
    2647                 :            : 
    2648                 :            : /* Helper function for update_range_test.  Force EXPR into an SSA_NAME,
    2649                 :            :    insert needed statements BEFORE or after GSI.  */
    2650                 :            : 
    2651                 :            : static tree
    2652                 :      17294 : force_into_ssa_name (gimple_stmt_iterator *gsi, tree expr, bool before)
    2653                 :            : {
    2654                 :      17294 :   enum gsi_iterator_update m = before ? GSI_SAME_STMT : GSI_CONTINUE_LINKING;
    2655                 :      17294 :   tree ret = force_gimple_operand_gsi (gsi, expr, true, NULL_TREE, before, m);
    2656                 :      17294 :   if (TREE_CODE (ret) != SSA_NAME)
    2657                 :            :     {
    2658                 :         48 :       gimple *g = gimple_build_assign (make_ssa_name (TREE_TYPE (ret)), ret);
    2659                 :         48 :       if (before)
    2660                 :         48 :         gsi_insert_before (gsi, g, GSI_SAME_STMT);
    2661                 :            :       else
    2662                 :          0 :         gsi_insert_after (gsi, g, GSI_CONTINUE_LINKING);
    2663                 :         48 :       ret = gimple_assign_lhs (g);
    2664                 :            :     }
    2665                 :      17294 :   return ret;
    2666                 :            : }
    2667                 :            : 
    2668                 :            : /* Helper routine of optimize_range_test.
    2669                 :            :    [EXP, IN_P, LOW, HIGH, STRICT_OVERFLOW_P] is a merged range for
    2670                 :            :    RANGE and OTHERRANGE through OTHERRANGE + COUNT - 1 ranges,
    2671                 :            :    OPCODE and OPS are arguments of optimize_range_tests.  If OTHERRANGE
    2672                 :            :    is NULL, OTHERRANGEP should not be and then OTHERRANGEP points to
    2673                 :            :    an array of COUNT pointers to other ranges.  Return
    2674                 :            :    true if the range merge has been successful.
    2675                 :            :    If OPCODE is ERROR_MARK, this is called from within
    2676                 :            :    maybe_optimize_range_tests and is performing inter-bb range optimization.
    2677                 :            :    In that case, whether an op is BIT_AND_EXPR or BIT_IOR_EXPR is found in
    2678                 :            :    oe->rank.  */
    2679                 :            : 
    2680                 :            : static bool
    2681                 :      17294 : update_range_test (struct range_entry *range, struct range_entry *otherrange,
    2682                 :            :                    struct range_entry **otherrangep,
    2683                 :            :                    unsigned int count, enum tree_code opcode,
    2684                 :            :                    vec<operand_entry *> *ops, tree exp, gimple_seq seq,
    2685                 :            :                    bool in_p, tree low, tree high, bool strict_overflow_p)
    2686                 :            : {
    2687                 :      17294 :   operand_entry *oe = (*ops)[range->idx];
    2688                 :      17294 :   tree op = oe->op;
    2689                 :      26642 :   gimple *stmt = op ? SSA_NAME_DEF_STMT (op)
    2690                 :       7946 :                     : last_stmt (BASIC_BLOCK_FOR_FN (cfun, oe->id));
    2691                 :      17294 :   location_t loc = gimple_location (stmt);
    2692                 :      26642 :   tree optype = op ? TREE_TYPE (op) : boolean_type_node;
    2693                 :      17294 :   tree tem = build_range_check (loc, optype, unshare_expr (exp),
    2694                 :            :                                 in_p, low, high);
    2695                 :      17294 :   enum warn_strict_overflow_code wc = WARN_STRICT_OVERFLOW_COMPARISON;
    2696                 :      17294 :   gimple_stmt_iterator gsi;
    2697                 :      17294 :   unsigned int i, uid;
    2698                 :            : 
    2699                 :      17294 :   if (tem == NULL_TREE)
    2700                 :            :     return false;
    2701                 :            : 
    2702                 :            :   /* If op is default def SSA_NAME, there is no place to insert the
    2703                 :            :      new comparison.  Give up, unless we can use OP itself as the
    2704                 :            :      range test.  */
    2705                 :      26642 :   if (op && SSA_NAME_IS_DEFAULT_DEF (op))
    2706                 :            :     {
    2707                 :          0 :       if (op == range->exp
    2708                 :          0 :           && ((TYPE_PRECISION (optype) == 1 && TYPE_UNSIGNED (optype))
    2709                 :          0 :               || TREE_CODE (optype) == BOOLEAN_TYPE)
    2710                 :          0 :           && (op == tem
    2711                 :          0 :               || (TREE_CODE (tem) == EQ_EXPR
    2712                 :          0 :                   && TREE_OPERAND (tem, 0) == op
    2713                 :          0 :                   && integer_onep (TREE_OPERAND (tem, 1))))
    2714                 :          0 :           && opcode != BIT_IOR_EXPR
    2715                 :          0 :           && (opcode != ERROR_MARK || oe->rank != BIT_IOR_EXPR))
    2716                 :            :         {
    2717                 :            :           stmt = NULL;
    2718                 :            :           tem = op;
    2719                 :            :         }
    2720                 :            :       else
    2721                 :          0 :         return false;
    2722                 :            :     }
    2723                 :            : 
    2724                 :      17294 :   if (strict_overflow_p && issue_strict_overflow_warning (wc))
    2725                 :          0 :     warning_at (loc, OPT_Wstrict_overflow,
    2726                 :            :                 "assuming signed overflow does not occur "
    2727                 :            :                 "when simplifying range test");
    2728                 :            : 
    2729                 :      17294 :   if (dump_file && (dump_flags & TDF_DETAILS))
    2730                 :            :     {
    2731                 :         45 :       struct range_entry *r;
    2732                 :         45 :       fprintf (dump_file, "Optimizing range tests ");
    2733                 :         45 :       print_generic_expr (dump_file, range->exp);
    2734                 :         79 :       fprintf (dump_file, " %c[", range->in_p ? '+' : '-');
    2735                 :         45 :       print_generic_expr (dump_file, range->low);
    2736                 :         45 :       fprintf (dump_file, ", ");
    2737                 :         45 :       print_generic_expr (dump_file, range->high);
    2738                 :         45 :       fprintf (dump_file, "]");
    2739                 :        153 :       for (i = 0; i < count; i++)
    2740                 :            :         {
    2741                 :        108 :           if (otherrange)
    2742                 :         88 :             r = otherrange + i;
    2743                 :            :           else
    2744                 :         20 :             r = otherrangep[i];
    2745                 :        108 :           if (r->exp
    2746                 :        108 :               && r->exp != range->exp
    2747                 :         20 :               && TREE_CODE (r->exp) == SSA_NAME)
    2748                 :            :             {
    2749                 :         20 :               fprintf (dump_file, " and ");
    2750                 :         20 :               print_generic_expr (dump_file, r->exp);
    2751                 :            :             }
    2752                 :            :           else
    2753                 :         88 :             fprintf (dump_file, " and");
    2754                 :        196 :           fprintf (dump_file, " %c[", r->in_p ? '+' : '-');
    2755                 :        108 :           print_generic_expr (dump_file, r->low);
    2756                 :        108 :           fprintf (dump_file, ", ");
    2757                 :        108 :           print_generic_expr (dump_file, r->high);
    2758                 :        108 :           fprintf (dump_file, "]");
    2759                 :            :         }
    2760                 :         45 :       fprintf (dump_file, "\n into ");
    2761                 :         45 :       print_generic_expr (dump_file, tem);
    2762                 :         45 :       fprintf (dump_file, "\n");
    2763                 :            :     }
    2764                 :            : 
    2765                 :      17294 :   if (opcode == BIT_IOR_EXPR
    2766                 :      13175 :       || (opcode == ERROR_MARK && oe->rank == BIT_IOR_EXPR))
    2767                 :      10485 :     tem = invert_truthvalue_loc (loc, tem);
    2768                 :            : 
    2769                 :      17294 :   tem = fold_convert_loc (loc, optype, tem);
    2770                 :      17294 :   if (stmt)
    2771                 :            :     {
    2772                 :      17294 :       gsi = gsi_for_stmt (stmt);
    2773                 :      17294 :       uid = gimple_uid (stmt);
    2774                 :            :     }
    2775                 :            :   else
    2776                 :            :     {
    2777                 :          0 :       gsi = gsi_none ();
    2778                 :          0 :       uid = 0;
    2779                 :            :     }
    2780                 :      17294 :   if (stmt == NULL)
    2781                 :          0 :     gcc_checking_assert (tem == op);
    2782                 :            :   /* In rare cases range->exp can be equal to lhs of stmt.
    2783                 :            :      In that case we have to insert after the stmt rather then before
    2784                 :            :      it.  If stmt is a PHI, insert it at the start of the basic block.  */
    2785                 :      17294 :   else if (op != range->exp)
    2786                 :            :     {
    2787                 :      17294 :       gsi_insert_seq_before (&gsi, seq, GSI_SAME_STMT);
    2788                 :      17294 :       tem = force_into_ssa_name (&gsi, tem, true);
    2789                 :      17294 :       gsi_prev (&gsi);
    2790                 :            :     }
    2791                 :          0 :   else if (gimple_code (stmt) != GIMPLE_PHI)
    2792                 :            :     {
    2793                 :          0 :       gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
    2794                 :          0 :       tem = force_into_ssa_name (&gsi, tem, false);
    2795                 :            :     }
    2796                 :            :   else
    2797                 :            :     {
    2798                 :          0 :       gsi = gsi_after_labels (gimple_bb (stmt));
    2799                 :          0 :       if (!gsi_end_p (gsi))
    2800                 :          0 :         uid = gimple_uid (gsi_stmt (gsi));
    2801                 :            :       else
    2802                 :            :         {
    2803                 :          0 :           gsi = gsi_start_bb (gimple_bb (stmt));
    2804                 :          0 :           uid = 1;
    2805                 :          0 :           while (!gsi_end_p (gsi))
    2806                 :            :             {
    2807                 :          0 :               uid = gimple_uid (gsi_stmt (gsi));
    2808                 :          0 :               gsi_next (&gsi);
    2809                 :            :             }
    2810                 :            :         }
    2811                 :          0 :       gsi_insert_seq_before (&gsi, seq, GSI_SAME_STMT);
    2812                 :          0 :       tem = force_into_ssa_name (&gsi, tem, true);
    2813                 :          0 :       if (gsi_end_p (gsi))
    2814                 :          0 :         gsi = gsi_last_bb (gimple_bb (stmt));
    2815                 :            :       else
    2816                 :      17294 :         gsi_prev (&gsi);
    2817                 :            :     }
    2818                 :     113824 :   for (; !gsi_end_p (gsi); gsi_prev (&gsi))
    2819                 :      62192 :     if (gimple_uid (gsi_stmt (gsi)))
    2820                 :            :       break;
    2821                 :            :     else
    2822                 :      48265 :       gimple_set_uid (gsi_stmt (gsi), uid);
    2823                 :            : 
    2824                 :      17294 :   oe->op = tem;
    2825                 :      17294 :   range->exp = exp;
    2826                 :      17294 :   range->low = low;
    2827                 :      17294 :   range->high = high;
    2828                 :      17294 :   range->in_p = in_p;
    2829                 :      17294 :   range->strict_overflow_p = false;
    2830                 :            : 
    2831                 :      36845 :   for (i = 0; i < count; i++)
    2832                 :            :     {
    2833                 :      19551 :       if (otherrange)
    2834                 :      14808 :         range = otherrange + i;
    2835                 :            :       else
    2836                 :       4743 :         range = otherrangep[i];
    2837                 :      19551 :       oe = (*ops)[range->idx];
    2838                 :            :       /* Now change all the other range test immediate uses, so that
    2839                 :            :          those tests will be optimized away.  */
    2840                 :      19551 :       if (opcode == ERROR_MARK)
    2841                 :            :         {
    2842                 :      12957 :           if (oe->op)
    2843                 :       3942 :             oe->op = build_int_cst (TREE_TYPE (oe->op),
    2844                 :       3942 :                                     oe->rank == BIT_IOR_EXPR ? 0 : 1);
    2845                 :            :           else
    2846                 :       9015 :             oe->op = (oe->rank == BIT_IOR_EXPR
    2847                 :       9015 :                       ? boolean_false_node : boolean_true_node);
    2848                 :            :         }
    2849                 :            :       else
    2850                 :       6594 :         oe->op = error_mark_node;
    2851                 :      19551 :       range->exp = NULL_TREE;
    2852                 :      19551 :       range->low = NULL_TREE;
    2853                 :      19551 :       range->high = NULL_TREE;
    2854                 :            :     }
    2855                 :            :   return true;
    2856                 :            : }
    2857                 :            : 
    2858                 :            : /* Optimize X == CST1 || X == CST2
    2859                 :            :    if popcount (CST1 ^ CST2) == 1 into
    2860                 :            :    (X & ~(CST1 ^ CST2)) == (CST1 & ~(CST1 ^ CST2)).
    2861                 :            :    Similarly for ranges.  E.g.
    2862                 :            :    X != 2 && X != 3 && X != 10 && X != 11
    2863                 :            :    will be transformed by the previous optimization into
    2864                 :            :    !((X - 2U) <= 1U || (X - 10U) <= 1U)
    2865                 :            :    and this loop can transform that into
    2866                 :            :    !(((X & ~8) - 2U) <= 1U).  */
    2867                 :            : 
    2868                 :            : static bool
    2869                 :      28574 : optimize_range_tests_xor (enum tree_code opcode, tree type,
    2870                 :            :                           tree lowi, tree lowj, tree highi, tree highj,
    2871                 :            :                           vec<operand_entry *> *ops,
    2872                 :            :                           struct range_entry *rangei,
    2873                 :            :                           struct range_entry *rangej)
    2874                 :            : {
    2875                 :      28574 :   tree lowxor, highxor, tem, exp;
    2876                 :            :   /* Check lowi ^ lowj == highi ^ highj and
    2877                 :            :      popcount (lowi ^ lowj) == 1.  */
    2878                 :      28574 :   lowxor = fold_binary (BIT_XOR_EXPR, type, lowi, lowj);
    2879                 :      28574 :   if (lowxor == NULL_TREE || TREE_CODE (lowxor) != INTEGER_CST)
    2880                 :            :     return false;
    2881                 :      28574 :   if (!integer_pow2p (lowxor))
    2882                 :            :     return false;
    2883                 :       3183 :   highxor = fold_binary (BIT_XOR_EXPR, type, highi, highj);
    2884                 :       3183 :   if (!tree_int_cst_equal (lowxor, highxor))
    2885                 :            :     return false;
    2886                 :            : 
    2887                 :       2672 :   exp = rangei->exp;
    2888                 :       2672 :   scalar_int_mode mode = as_a <scalar_int_mode> (TYPE_MODE (type));
    2889                 :       2672 :   int prec = GET_MODE_PRECISION (mode);
    2890                 :       2672 :   if (TYPE_PRECISION (type) < prec
    2891                 :       2672 :       || (wi::to_wide (TYPE_MIN_VALUE (type))
    2892                 :       5344 :           != wi::min_value (prec, TYPE_SIGN (type)))
    2893                 :       5344 :       || (wi::to_wide (TYPE_MAX_VALUE (type))
    2894                 :       5344 :           != wi::max_value (prec, TYPE_SIGN (type))))
    2895                 :            :     {
    2896                 :          0 :       type = build_nonstandard_integer_type (prec, TYPE_UNSIGNED (type));
    2897                 :          0 :       exp = fold_convert (type, exp);
    2898                 :          0 :       lowxor = fold_convert (type, lowxor);
    2899                 :          0 :       lowi = fold_convert (type, lowi);
    2900                 :          0 :       highi = fold_convert (type, highi);
    2901                 :            :     }
    2902                 :       2672 :   tem = fold_build1 (BIT_NOT_EXPR, type, lowxor);
    2903                 :       2672 :   exp = fold_build2 (BIT_AND_EXPR, type, exp, tem);
    2904                 :       2672 :   lowj = fold_build2 (BIT_AND_EXPR, type, lowi, tem);
    2905                 :       2672 :   highj = fold_build2 (BIT_AND_EXPR, type, highi, tem);
    2906                 :       2672 :   if (update_range_test (rangei, rangej, NULL, 1, opcode, ops, exp,
    2907                 :       2672 :                          NULL, rangei->in_p, lowj, highj,
    2908                 :       2672 :                          rangei->strict_overflow_p
    2909                 :       2672 :                          || rangej->strict_overflow_p))
    2910                 :       2672 :     return true;
    2911                 :            :   return false;
    2912                 :            : }
    2913                 :            : 
    2914                 :            : /* Optimize X == CST1 || X == CST2
    2915                 :            :    if popcount (CST2 - CST1) == 1 into
    2916                 :            :    ((X - CST1) & ~(CST2 - CST1)) == 0.
    2917                 :            :    Similarly for ranges.  E.g.
    2918                 :            :    X == 43 || X == 76 || X == 44 || X == 78 || X == 77 || X == 46
    2919                 :            :    || X == 75 || X == 45
    2920                 :            :    will be transformed by the previous optimization into
    2921                 :            :    (X - 43U) <= 3U || (X - 75U) <= 3U
    2922                 :            :    and this loop can transform that into
    2923                 :            :    ((X - 43U) & ~(75U - 43U)) <= 3U.  */
    2924                 :            : static bool
    2925                 :      19641 : optimize_range_tests_diff (enum tree_code opcode, tree type,
    2926                 :            :                            tree lowi, tree lowj, tree highi, tree highj,
    2927                 :            :                            vec<operand_entry *> *ops,
    2928                 :            :                            struct range_entry *rangei,
    2929                 :            :                            struct range_entry *rangej)
    2930                 :            : {
    2931                 :      19641 :   tree tem1, tem2, mask;
    2932                 :            :   /* Check highi - lowi == highj - lowj.  */
    2933                 :      19641 :   tem1 = fold_binary (MINUS_EXPR, type, highi, lowi);
    2934                 :      19641 :   if (tem1 == NULL_TREE || TREE_CODE (tem1) != INTEGER_CST)
    2935                 :            :     return false;
    2936                 :      19641 :   tem2 = fold_binary (MINUS_EXPR, type, highj, lowj);
    2937                 :      19641 :   if (!tree_int_cst_equal (tem1, tem2))
    2938                 :            :     return false;
    2939                 :            :   /* Check popcount (lowj - lowi) == 1.  */
    2940                 :      12641 :   tem1 = fold_binary (MINUS_EXPR, type, lowj, lowi);
    2941                 :      12641 :   if (tem1 == NULL_TREE || TREE_CODE (tem1) != INTEGER_CST)
    2942                 :            :     return false;
    2943                 :      12641 :   if (!integer_pow2p (tem1))
    2944                 :            :     return false;
    2945                 :            : 
    2946                 :       2382 :   scalar_int_mode mode = as_a <scalar_int_mode> (TYPE_MODE (type));
    2947                 :       2382 :   int prec = GET_MODE_PRECISION (mode);
    2948                 :       2382 :   if (TYPE_PRECISION (type) < prec
    2949                 :       2378 :       || (wi::to_wide (TYPE_MIN_VALUE (type))
    2950                 :       4756 :           != wi::min_value (prec, TYPE_SIGN (type)))
    2951                 :       4760 :       || (wi::to_wide (TYPE_MAX_VALUE (type))
    2952                 :       4756 :           != wi::max_value (prec, TYPE_SIGN (type))))
    2953                 :          4 :     type = build_nonstandard_integer_type (prec, 1);
    2954                 :            :   else
    2955                 :       2378 :     type = unsigned_type_for (type);
    2956                 :       2382 :   tem1 = fold_convert (type, tem1);
    2957                 :       2382 :   tem2 = fold_convert (type, tem2);
    2958                 :       2382 :   lowi = fold_convert (type, lowi);
    2959                 :       2382 :   mask = fold_build1 (BIT_NOT_EXPR, type, tem1);
    2960                 :       2382 :   tem1 = fold_build2 (MINUS_EXPR, type,
    2961                 :            :                       fold_convert (type, rangei->exp), lowi);
    2962                 :       2382 :   tem1 = fold_build2 (BIT_AND_EXPR, type, tem1, mask);
    2963                 :       2382 :   lowj = build_int_cst (type, 0);
    2964                 :       2382 :   if (update_range_test (rangei, rangej, NULL, 1, opcode, ops, tem1,
    2965                 :       2382 :                          NULL, rangei->in_p, lowj, tem2,
    2966                 :       2382 :                          rangei->strict_overflow_p
    2967                 :       2382 :                          || rangej->strict_overflow_p))
    2968                 :       2382 :     return true;
    2969                 :            :   return false;
    2970                 :            : }
    2971                 :            : 
    2972                 :            : /* It does some common checks for function optimize_range_tests_xor and
    2973                 :            :    optimize_range_tests_diff.
    2974                 :            :    If OPTIMIZE_XOR is TRUE, it calls optimize_range_tests_xor.
    2975                 :            :    Else it calls optimize_range_tests_diff.  */
    2976                 :            : 
    2977                 :            : static bool
    2978                 :    1307100 : optimize_range_tests_1 (enum tree_code opcode, int first, int length,
    2979                 :            :                         bool optimize_xor, vec<operand_entry *> *ops,
    2980                 :            :                         struct range_entry *ranges)
    2981                 :            : {
    2982                 :    1307100 :   int i, j;
    2983                 :    1307100 :   bool any_changes = false;
    2984                 :    2434580 :   for (i = first; i < length; i++)
    2985                 :            :     {
    2986                 :    1127480 :       tree lowi, highi, lowj, highj, type, tem;
    2987                 :            : 
    2988                 :    1127480 :       if (ranges[i].exp == NULL_TREE || ranges[i].in_p)
    2989                 :     686742 :         continue;
    2990                 :     440734 :       type = TREE_TYPE (ranges[i].exp);
    2991                 :     440734 :       if (!INTEGRAL_TYPE_P (type))
    2992                 :      29416 :         continue;
    2993                 :     411318 :       lowi = ranges[i].low;
    2994                 :     411318 :       if (lowi == NULL_TREE)
    2995                 :      27944 :         lowi = TYPE_MIN_VALUE (type);
    2996                 :     411318 :       highi = ranges[i].high;
    2997                 :     411318 :       if (highi == NULL_TREE)
    2998                 :       4258 :         continue;
    2999                 :     725079 :       for (j = i + 1; j < length && j < i + 64; j++)
    3000                 :            :         {
    3001                 :     323073 :           bool changes;
    3002                 :     323073 :           if (ranges[i].exp != ranges[j].exp || ranges[j].in_p)
    3003                 :     274858 :             continue;
    3004                 :      48215 :           lowj = ranges[j].low;
    3005                 :      48215 :           if (lowj == NULL_TREE)
    3006                 :          0 :             continue;
    3007                 :      48215 :           highj = ranges[j].high;
    3008                 :      48215 :           if (highj == NULL_TREE)
    3009                 :         54 :             highj = TYPE_MAX_VALUE (type);
    3010                 :            :           /* Check lowj > highi.  */
    3011                 :      48215 :           tem = fold_binary (GT_EXPR, boolean_type_node,
    3012                 :            :                              lowj, highi);
    3013                 :      48215 :           if (tem == NULL_TREE || !integer_onep (tem))
    3014                 :          0 :             continue;
    3015                 :      48215 :           if (optimize_xor)
    3016                 :      28574 :             changes = optimize_range_tests_xor (opcode, type, lowi, lowj,
    3017                 :            :                                                 highi, highj, ops,
    3018                 :            :                                                 ranges + i, ranges + j);
    3019                 :            :           else
    3020                 :      19641 :             changes = optimize_range_tests_diff (opcode, type, lowi, lowj,
    3021                 :            :                                                  highi, highj, ops,
    3022                 :            :                                                  ranges + i, ranges + j);
    3023                 :      48215 :           if (changes)
    3024                 :            :             {
    3025                 :            :               any_changes = true;
    3026                 :            :               break;
    3027                 :            :             }
    3028                 :            :         }
    3029                 :            :     }
    3030                 :    1307100 :   return any_changes;
    3031                 :            : }
    3032                 :            : 
    3033                 :            : /* Helper function of optimize_range_tests_to_bit_test.  Handle a single
    3034                 :            :    range, EXP, LOW, HIGH, compute bit mask of bits to test and return
    3035                 :            :    EXP on success, NULL otherwise.  */
    3036                 :            : 
    3037                 :            : static tree
    3038                 :      27385 : extract_bit_test_mask (tree exp, int prec, tree totallow, tree low, tree high,
    3039                 :            :                        wide_int *mask, tree *totallowp)
    3040                 :            : {
    3041                 :      27385 :   tree tem = int_const_binop (MINUS_EXPR, high, low);
    3042                 :      27385 :   if (tem == NULL_TREE
    3043                 :      27385 :       || TREE_CODE (tem) != INTEGER_CST
    3044                 :      27385 :       || TREE_OVERFLOW (tem)
    3045                 :      24580 :       || tree_int_cst_sgn (tem) == -1
    3046                 :      51965 :       || compare_tree_int (tem, prec) != -1)
    3047                 :       3490 :     return NULL_TREE;
    3048                 :            : 
    3049                 :      23895 :   unsigned HOST_WIDE_INT max = tree_to_uhwi (tem) + 1;
    3050                 :      23895 :   *mask = wi::shifted_mask (0, max, false, prec);
    3051                 :      23895 :   if (TREE_CODE (exp) == BIT_AND_EXPR
    3052                 :      23895 :       && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
    3053                 :            :     {
    3054                 :       3529 :       widest_int msk = wi::to_widest (TREE_OPERAND (exp, 1));
    3055                 :       7058 :       msk = wi::zext (~msk, TYPE_PRECISION (TREE_TYPE (exp)));
    3056                 :       3529 :       if (wi::popcount (msk) == 1
    3057                 :       3529 :           && wi::ltu_p (msk, prec - max))
    3058                 :            :         {
    3059                 :       2506 :           *mask |= wi::shifted_mask (msk.to_uhwi (), max, false, prec);
    3060                 :       2506 :           max += msk.to_uhwi ();
    3061                 :       2506 :           exp = TREE_OPERAND (exp, 0);
    3062                 :       2506 :           if (integer_zerop (low)
    3063                 :       1275 :               && TREE_CODE (exp) == PLUS_EXPR
    3064                 :       3751 :               && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
    3065                 :            :             {
    3066                 :       1245 :               tree ret = TREE_OPERAND (exp, 0);
    3067                 :       1245 :               STRIP_NOPS (ret);
    3068                 :       1245 :               widest_int bias
    3069                 :       1245 :                 = wi::neg (wi::sext (wi::to_widest (TREE_OPERAND (exp, 1)),
    3070                 :       2490 :                                      TYPE_PRECISION (TREE_TYPE (low))));
    3071                 :       1245 :               tree tbias = wide_int_to_tree (TREE_TYPE (ret), bias);
    3072                 :       1245 :               if (totallowp)
    3073                 :            :                 {
    3074                 :        659 :                   *totallowp = tbias;
    3075                 :       1177 :                   return ret;
    3076                 :            :                 }
    3077                 :        586 :               else if (!tree_int_cst_lt (totallow, tbias))
    3078                 :            :                 return NULL_TREE;
    3079                 :        586 :               bias = wi::to_widest (tbias);
    3080                 :        586 :               bias -= wi::to_widest (totallow);
    3081                 :        586 :               if (bias >= 0 && bias < prec - max)
    3082                 :            :                 {
    3083                 :        518 :                   *mask = wi::lshift (*mask, bias);
    3084                 :        518 :                   return ret;
    3085                 :            :                 }
    3086                 :            :             }
    3087                 :            :         }
    3088                 :            :     }
    3089                 :      22718 :   if (totallowp)
    3090                 :            :     return exp;
    3091                 :      10406 :   if (!tree_int_cst_lt (totallow, low))
    3092                 :            :     return exp;
    3093                 :      10358 :   tem = int_const_binop (MINUS_EXPR, low, totallow);
    3094                 :      10358 :   if (tem == NULL_TREE
    3095                 :      10358 :       || TREE_CODE (tem) != INTEGER_CST
    3096                 :      10358 :       || TREE_OVERFLOW (tem)
    3097                 :      20080 :       || compare_tree_int (tem, prec - max) == 1)
    3098                 :       7172 :     return NULL_TREE;
    3099                 :            : 
    3100                 :       3186 :   *mask = wi::lshift (*mask, wi::to_widest (tem));
    3101                 :       3186 :   return exp;
    3102                 :            : }
    3103                 :            : 
    3104                 :            : /* Attempt to optimize small range tests using bit test.
    3105                 :            :    E.g.
    3106                 :            :    X != 43 && X != 76 && X != 44 && X != 78 && X != 49
    3107                 :            :    && X != 77 && X != 46 && X != 75 && X != 45 && X != 82
    3108                 :            :    has been by earlier optimizations optimized into:
    3109                 :            :    ((X - 43U) & ~32U) > 3U && X != 49 && X != 82
    3110                 :            :    As all the 43 through 82 range is less than 64 numbers,
    3111                 :            :    for 64-bit word targets optimize that into:
    3112                 :            :    (X - 43U) > 40U && ((1 << (X - 43U)) & 0x8F0000004FULL) == 0  */
    3113                 :            : 
    3114                 :            : static bool
    3115                 :     653563 : optimize_range_tests_to_bit_test (enum tree_code opcode, int first, int length,
    3116                 :            :                                   vec<operand_entry *> *ops,
    3117                 :            :                                   struct range_entry *ranges)
    3118                 :            : {
    3119                 :     653563 :   int i, j;
    3120                 :     653563 :   bool any_changes = false;
    3121                 :     653563 :   int prec = GET_MODE_BITSIZE (word_mode);
    3122                 :     653563 :   auto_vec<struct range_entry *, 64> candidates;
    3123                 :            : 
    3124                 :     696057 :   for (i = first; i < length - 2; i++)
    3125                 :            :     {
    3126                 :      42494 :       tree lowi, highi, lowj, highj, type;
    3127                 :            : 
    3128                 :      42494 :       if (ranges[i].exp == NULL_TREE || ranges[i].in_p)
    3129                 :      29523 :         continue;
    3130                 :      16705 :       type = TREE_TYPE (ranges[i].exp);
    3131                 :      16705 :       if (!INTEGRAL_TYPE_P (type))
    3132                 :        278 :         continue;
    3133                 :      16427 :       lowi = ranges[i].low;
    3134                 :      16427 :       if (lowi == NULL_TREE)
    3135                 :       2805 :         lowi = TYPE_MIN_VALUE (type);
    3136                 :      16427 :       highi = ranges[i].high;
    3137                 :      16427 :       if (highi == NULL_TREE)
    3138                 :         28 :         continue;
    3139                 :      16399 :       wide_int mask;
    3140                 :      16399 :       tree exp = extract_bit_test_mask (ranges[i].exp, prec, lowi, lowi,
    3141                 :            :                                         highi, &mask, &lowi);
    3142                 :      16399 :       if (exp == NULL_TREE)
    3143                 :       3428 :         continue;
    3144                 :      12971 :       bool strict_overflow_p = ranges[i].strict_overflow_p;
    3145                 :      12971 :       candidates.truncate (0);
    3146                 :      12971 :       int end = MIN (i + 64, length);
    3147                 :      62961 :       for (j = i + 1; j < end; j++)
    3148                 :            :         {
    3149                 :      49990 :           tree exp2;
    3150                 :      49990 :           if (ranges[j].exp == NULL_TREE || ranges[j].in_p)
    3151                 :      46307 :             continue;
    3152                 :      38188 :           if (ranges[j].exp == exp)
    3153                 :            :             ;
    3154                 :      29343 :           else if (TREE_CODE (ranges[j].exp) == BIT_AND_EXPR)
    3155                 :            :             {
    3156                 :       3386 :               exp2 = TREE_OPERAND (ranges[j].exp, 0);
    3157                 :       3386 :               if (exp2 == exp)
    3158                 :            :                 ;
    3159                 :       1913 :               else if (TREE_CODE (exp2) == PLUS_EXPR)
    3160                 :            :                 {
    3161                 :       1354 :                   exp2 = TREE_OPERAND (exp2, 0);
    3162                 :       1354 :                   STRIP_NOPS (exp2);
    3163                 :       1354 :                   if (exp2 != exp)
    3164                 :        686 :                     continue;
    3165                 :            :                 }
    3166                 :            :               else
    3167                 :        559 :                 continue;
    3168                 :            :             }
    3169                 :            :           else
    3170                 :      25957 :             continue;
    3171                 :      10986 :           lowj = ranges[j].low;
    3172                 :      10986 :           if (lowj == NULL_TREE)
    3173                 :          0 :             continue;
    3174                 :      10986 :           highj = ranges[j].high;
    3175                 :      10986 :           if (highj == NULL_TREE)
    3176                 :          8 :             highj = TYPE_MAX_VALUE (type);
    3177                 :      10986 :           wide_int mask2;
    3178                 :      10986 :           exp2 = extract_bit_test_mask (ranges[j].exp, prec, lowi, lowj,
    3179                 :            :                                         highj, &mask2, NULL);
    3180                 :      10986 :           if (exp2 != exp)
    3181                 :       7303 :             continue;
    3182                 :       3683 :           mask |= mask2;
    3183                 :       3683 :           strict_overflow_p |= ranges[j].strict_overflow_p;
    3184                 :       3683 :           candidates.safe_push (&ranges[j]);
    3185                 :            :         }
    3186                 :            : 
    3187                 :            :       /* If we need otherwise 3 or more comparisons, use a bit test.  */
    3188                 :      12971 :       if (candidates.length () >= 2)
    3189                 :            :         {
    3190                 :       1596 :           tree high = wide_int_to_tree (TREE_TYPE (lowi),
    3191                 :        798 :                                         wi::to_widest (lowi)
    3192                 :       1596 :                                         + prec - 1 - wi::clz (mask));
    3193                 :        798 :           operand_entry *oe = (*ops)[ranges[i].idx];
    3194                 :        798 :           tree op = oe->op;
    3195                 :       1486 :           gimple *stmt = op ? SSA_NAME_DEF_STMT (op)
    3196                 :        110 :                             : last_stmt (BASIC_BLOCK_FOR_FN (cfun, oe->id));
    3197                 :        798 :           location_t loc = gimple_location (stmt);
    3198                 :       1486 :           tree optype = op ? TREE_TYPE (op) : boolean_type_node;
    3199                 :            : 
    3200                 :            :           /* See if it isn't cheaper to pretend the minimum value of the
    3201                 :            :              range is 0, if maximum value is small enough.
    3202                 :            :              We can avoid then subtraction of the minimum value, but the
    3203                 :            :              mask constant could be perhaps more expensive.  */
    3204                 :        798 :           if (compare_tree_int (lowi, 0) > 0
    3205                 :        798 :               && compare_tree_int (high, prec) < 0)
    3206                 :            :             {
    3207                 :        222 :               int cost_diff;
    3208                 :        222 :               HOST_WIDE_INT m = tree_to_uhwi (lowi);
    3209                 :        222 :               rtx reg = gen_raw_REG (word_mode, 10000);
    3210                 :        222 :               bool speed_p = optimize_bb_for_speed_p (gimple_bb (stmt));
    3211                 :        222 :               cost_diff = set_src_cost (gen_rtx_PLUS (word_mode, reg,
    3212                 :            :                                                       GEN_INT (-m)),
    3213                 :            :                                         word_mode, speed_p);
    3214                 :        222 :               rtx r = immed_wide_int_const (mask, word_mode);
    3215                 :        222 :               cost_diff += set_src_cost (gen_rtx_AND (word_mode, reg, r),
    3216                 :            :                                          word_mode, speed_p);
    3217                 :        222 :               r = immed_wide_int_const (wi::lshift (mask, m), word_mode);
    3218                 :        222 :               cost_diff -= set_src_cost (gen_rtx_AND (word_mode, reg, r),
    3219                 :            :                                          word_mode, speed_p);
    3220                 :        222 :               if (cost_diff > 0)
    3221                 :            :                 {
    3222                 :        222 :                   mask = wi::lshift (mask, m);
    3223                 :        222 :                   lowi = build_zero_cst (TREE_TYPE (lowi));
    3224                 :            :                 }
    3225                 :            :             }
    3226                 :            : 
    3227                 :        798 :           tree tem = build_range_check (loc, optype, unshare_expr (exp),
    3228                 :        798 :                                         false, lowi, high);
    3229                 :        798 :           if (tem == NULL_TREE || is_gimple_val (tem))
    3230                 :          0 :             continue;
    3231                 :        798 :           tree etype = unsigned_type_for (TREE_TYPE (exp));
    3232                 :        798 :           exp = fold_build2_loc (loc, MINUS_EXPR, etype,
    3233                 :            :                                  fold_convert_loc (loc, etype, exp),
    3234                 :            :                                  fold_convert_loc (loc, etype, lowi));
    3235                 :        798 :           exp = fold_convert_loc (loc, integer_type_node, exp);
    3236                 :        798 :           tree word_type = lang_hooks.types.type_for_mode (word_mode, 1);
    3237                 :        798 :           exp = fold_build2_loc (loc, LSHIFT_EXPR, word_type,
    3238                 :        798 :                                  build_int_cst (word_type, 1), exp);
    3239                 :        798 :           exp = fold_build2_loc (loc, BIT_AND_EXPR, word_type, exp,
    3240                 :            :                                  wide_int_to_tree (word_type, mask));
    3241                 :        798 :           exp = fold_build2_loc (loc, EQ_EXPR, optype, exp,
    3242                 :            :                                  build_zero_cst (word_type));
    3243                 :        798 :           if (is_gimple_val (exp))
    3244                 :          0 :             continue;
    3245                 :            : 
    3246                 :            :           /* The shift might have undefined behavior if TEM is true,
    3247                 :            :              but reassociate_bb isn't prepared to have basic blocks
    3248                 :            :              split when it is running.  So, temporarily emit a code
    3249                 :            :              with BIT_IOR_EXPR instead of &&, and fix it up in
    3250                 :            :              branch_fixup.  */
    3251                 :        798 :           gimple_seq seq;
    3252                 :        798 :           tem = force_gimple_operand (tem, &seq, true, NULL_TREE);
    3253                 :        798 :           gcc_assert (TREE_CODE (tem) == SSA_NAME);
    3254                 :        798 :           gimple_set_visited (SSA_NAME_DEF_STMT (tem), true);
    3255                 :        798 :           gimple_seq seq2;
    3256                 :        798 :           exp = force_gimple_operand (exp, &seq2, true, NULL_TREE);
    3257                 :        798 :           gimple_seq_add_seq_without_update (&seq, seq2);
    3258                 :        798 :           gcc_assert (TREE_CODE (exp) == SSA_NAME);
    3259                 :        798 :           gimple_set_visited (SSA_NAME_DEF_STMT (exp), true);
    3260                 :        798 :           gimple *g = gimple_build_assign (make_ssa_name (optype),
    3261                 :            :                                            BIT_IOR_EXPR, tem, exp);
    3262                 :        798 :           gimple_set_location (g, loc);
    3263                 :        798 :           gimple_seq_add_stmt_without_update (&seq, g);
    3264                 :        798 :           exp = gimple_assign_lhs (g);
    3265                 :        798 :           tree val = build_zero_cst (optype);
    3266                 :       2394 :           if (update_range_test (&ranges[i], NULL, candidates.address (),
    3267                 :            :                                  candidates.length (), opcode, ops, exp,
    3268                 :            :                                  seq, false, val, val, strict_overflow_p))
    3269                 :            :             {
    3270                 :        798 :               any_changes = true;
    3271                 :        798 :               reassoc_branch_fixups.safe_push (tem);
    3272                 :            :             }
    3273                 :            :           else
    3274                 :          0 :             gimple_seq_discard (seq);
    3275                 :            :         }
    3276                 :            :     }
    3277                 :     653563 :   return any_changes;
    3278                 :            : }
    3279                 :            : 
    3280                 :            : /* Optimize x != 0 && y != 0 && z != 0 into (x | y | z) != 0
    3281                 :            :    and similarly x != -1 && y != -1 && y != -1 into (x & y & z) != -1.  */
    3282                 :            : 
    3283                 :            : static bool
    3284                 :     653563 : optimize_range_tests_cmp_bitwise (enum tree_code opcode, int first, int length,
    3285                 :            :                                   vec<operand_entry *> *ops,
    3286                 :            :                                   struct range_entry *ranges)
    3287                 :            : {
    3288                 :     653563 :   int i;
    3289                 :     653563 :   unsigned int b;
    3290                 :     653563 :   bool any_changes = false;
    3291                 :     653563 :   auto_vec<int, 128> buckets;
    3292                 :     653563 :   auto_vec<int, 32> chains;
    3293                 :     653563 :   auto_vec<struct range_entry *, 32> candidates;
    3294                 :            : 
    3295                 :    1217310 :   for (i = first; i < length; i++)
    3296                 :            :     {
    3297                 :    1024490 :       if (ranges[i].exp == NULL_TREE
    3298                 :     547082 :           || TREE_CODE (ranges[i].exp) != SSA_NAME
    3299                 :     542545 :           || !ranges[i].in_p
    3300                 :     329760 :           || TYPE_PRECISION (TREE_TYPE (ranges[i].exp)) <= 1
    3301                 :     179675 :           || TREE_CODE (TREE_TYPE (ranges[i].exp)) == BOOLEAN_TYPE
    3302                 :     179675 :           || ranges[i].low == NULL_TREE
    3303                 :     738008 :           || ranges[i].low != ranges[i].high)
    3304                 :     460745 :         continue;
    3305                 :            : 
    3306                 :     103003 :       bool zero_p = integer_zerop (ranges[i].low);
    3307                 :     103003 :       if (!zero_p && !integer_all_onesp (ranges[i].low))
    3308                 :      58928 :         continue;
    3309                 :            : 
    3310                 :      44075 :       b = TYPE_PRECISION (TREE_TYPE (ranges[i].exp)) * 2 + !zero_p;
    3311                 :      88150 :       if (buckets.length () <= b)
    3312                 :      37832 :         buckets.safe_grow_cleared (b + 1);
    3313                 :      88150 :       if (chains.length () <= (unsigned) i)
    3314                 :      44075 :         chains.safe_grow (i + 1);
    3315                 :      44075 :       chains[i] = buckets[b];
    3316                 :      44075 :       buckets[b] = i + 1;
    3317                 :            :     }
    3318                 :            : 
    3319                 :    3576810 :   FOR_EACH_VEC_ELT (buckets, b, i)
    3320                 :    2923250 :     if (i && chains[i - 1])
    3321                 :            :       {
    3322                 :            :         int j, k = i;
    3323                 :       5161 :         for (j = chains[i - 1]; j; j = chains[j - 1])
    3324                 :            :           {
    3325                 :       2885 :             gimple *gk = SSA_NAME_DEF_STMT (ranges[k - 1].exp);
    3326                 :       2885 :             gimple *gj = SSA_NAME_DEF_STMT (ranges[j - 1].exp);
    3327                 :       2885 :             if (reassoc_stmt_dominates_stmt_p (gk, gj))
    3328                 :        640 :               k = j;
    3329                 :            :           }
    3330                 :       2276 :         tree type1 = TREE_TYPE (ranges[k - 1].exp);
    3331                 :       2276 :         tree type2 = NULL_TREE;
    3332                 :       2276 :         bool strict_overflow_p = false;
    3333                 :       2276 :         candidates.truncate (0);
    3334                 :       7437 :         for (j = i; j; j = chains[j - 1])
    3335                 :            :           {
    3336                 :       5161 :             tree type = TREE_TYPE (ranges[j - 1].exp);
    3337                 :       5161 :             strict_overflow_p |= ranges[j - 1].strict_overflow_p;
    3338                 :       5161 :             if (j == k
    3339                 :       5161 :                 || useless_type_conversion_p (type1, type))
    3340                 :            :               ;
    3341                 :        248 :             else if (type2 == NULL_TREE
    3342                 :        248 :                      || useless_type_conversion_p (type2, type))
    3343                 :            :               {
    3344                 :        248 :                 if (type2 == NULL_TREE)
    3345                 :        246 :                   type2 = type;
    3346                 :        248 :                 candidates.safe_push (&ranges[j - 1]);
    3347                 :            :               }
    3348                 :            :           }
    3349                 :       2276 :         unsigned l = candidates.length ();
    3350                 :       7437 :         for (j = i; j; j = chains[j - 1])
    3351                 :            :           {
    3352                 :       5161 :             tree type = TREE_TYPE (ranges[j - 1].exp);
    3353                 :       5161 :             if (j == k)
    3354                 :       2276 :               continue;
    3355                 :       2885 :             if (useless_type_conversion_p (type1, type))
    3356                 :            :               ;
    3357                 :        496 :             else if (type2 == NULL_TREE
    3358                 :        248 :                      || useless_type_conversion_p (type2, type))
    3359                 :        248 :               continue;
    3360                 :       2637 :             candidates.safe_push (&ranges[j - 1]);
    3361                 :            :           }
    3362                 :       2276 :         gimple_seq seq = NULL;
    3363                 :       2276 :         tree op = NULL_TREE;
    3364                 :       2276 :         unsigned int id;
    3365                 :       2276 :         struct range_entry *r;
    3366                 :       2276 :         candidates.safe_push (&ranges[k - 1]);
    3367                 :       7437 :         FOR_EACH_VEC_ELT (candidates, id, r)
    3368                 :            :           {
    3369                 :       5161 :             gimple *g;
    3370                 :       5161 :             if (id == 0)
    3371                 :            :               {
    3372                 :       2276 :                 op = r->exp;
    3373                 :       2276 :                 continue;
    3374                 :            :               }
    3375                 :       2885 :             if (id == l)
    3376                 :            :               {
    3377                 :        246 :                 g = gimple_build_assign (make_ssa_name (type1), NOP_EXPR, op);
    3378                 :        246 :                 gimple_seq_add_stmt_without_update (&seq, g);
    3379                 :        246 :                 op = gimple_assign_lhs (g);
    3380                 :            :               }
    3381                 :       2885 :             tree type = TREE_TYPE (r->exp);
    3382                 :       2885 :             tree exp = r->exp;
    3383                 :       2885 :             if (id >= l && !useless_type_conversion_p (type1, type))
    3384                 :            :               {
    3385                 :          0 :                 g = gimple_build_assign (make_ssa_name (type1), NOP_EXPR, exp);
    3386                 :          0 :                 gimple_seq_add_stmt_without_update (&seq, g);
    3387                 :          0 :                 exp = gimple_assign_lhs (g);
    3388                 :            :               }
    3389                 :       5770 :             g = gimple_build_assign (make_ssa_name (id >= l ? type1 : type2),
    3390                 :       2885 :                                      (b & 1) ? BIT_AND_EXPR : BIT_IOR_EXPR,
    3391                 :            :                                      op, exp);
    3392                 :       2885 :             gimple_seq_add_stmt_without_update (&seq, g);
    3393                 :       2885 :             op = gimple_assign_lhs (g);
    3394                 :            :           }
    3395                 :       2276 :         candidates.pop ();
    3396                 :       2276 :         if (update_range_test (&ranges[k - 1], NULL, candidates.address (),
    3397                 :            :                                candidates.length (), opcode, ops, op,
    3398                 :            :                                seq, true, ranges[k - 1].low,
    3399                 :            :                                ranges[k - 1].low, strict_overflow_p))
    3400                 :            :           any_changes = true;
    3401                 :            :         else
    3402                 :          0 :           gimple_seq_discard (seq);
    3403                 :            :       }
    3404                 :            : 
    3405                 :     653563 :   return any_changes;
    3406                 :            : }
    3407                 :            : 
    3408                 :            : /* Attempt to optimize for signed a and b where b is known to be >= 0:
    3409                 :            :    a >= 0 && a < b into (unsigned) a < (unsigned) b
    3410                 :            :    a >= 0 && a <= b into (unsigned) a <= (unsigned) b  */
    3411                 :            : 
    3412                 :            : static bool
    3413                 :     653563 : optimize_range_tests_var_bound (enum tree_code opcode, int first, int length,
    3414                 :            :                                 vec<operand_entry *> *ops,
    3415                 :            :                                 struct range_entry *ranges,
    3416                 :            :                                 basic_block first_bb)
    3417                 :            : {
    3418                 :     653563 :   int i;
    3419                 :     653563 :   bool any_changes = false;
    3420                 :     653563 :   hash_map<tree, int> *map = NULL;
    3421                 :            : 
    3422                 :    1217310 :   for (i = first; i < length; i++)
    3423                 :            :     {
    3424                 :     563748 :       if (ranges[i].exp == NULL_TREE
    3425                 :     544197 :           || TREE_CODE (ranges[i].exp) != SSA_NAME
    3426                 :     539660 :           || !ranges[i].in_p)
    3427                 :     236873 :         continue;
    3428                 :            : 
    3429                 :     326875 :       tree type = TREE_TYPE (ranges[i].exp);
    3430                 :     604553 :       if (!INTEGRAL_TYPE_P (type)
    3431                 :     319911 :           || TYPE_UNSIGNED (type)
    3432                 :     131490 :           || ranges[i].low == NULL_TREE
    3433                 :     126075 :           || !integer_zerop (ranges[i].low)
    3434                 :     392000 :           || ranges[i].high != NULL_TREE)
    3435                 :     277678 :         continue;
    3436                 :            :       /* EXP >= 0 here.  */
    3437                 :      49197 :       if (map == NULL)
    3438                 :      48870 :         map = new hash_map <tree, int>;
    3439                 :      49197 :       map->put (ranges[i].exp, i);
    3440                 :            :     }
    3441                 :            : 
    3442                 :     653563 :   if (map == NULL)
    3443                 :            :     return false;
    3444                 :            : 
    3445                 :     148109 :   for (i = 0; i < length; i++)
    3446                 :            :     {
    3447                 :      99239 :       bool in_p = ranges[i].in_p;
    3448                 :      99239 :       if (ranges[i].low == NULL_TREE
    3449                 :      98202 :           || ranges[i].high == NULL_TREE)
    3450                 :      98728 :         continue;
    3451                 :      48984 :       if (!integer_zerop (ranges[i].low)
    3452                 :      48984 :           || !integer_zerop (ranges[i].high))
    3453                 :            :         {
    3454                 :        524 :           if (ranges[i].exp
    3455                 :        262 :               && TYPE_PRECISION (TREE_TYPE (ranges[i].exp)) == 1
    3456                 :          0 :               && TYPE_UNSIGNED (TREE_TYPE (ranges[i].exp))
    3457                 :          0 :               && integer_onep (ranges[i].low)
    3458                 :        262 :               && integer_onep (ranges[i].high))
    3459                 :          0 :             in_p = !in_p;
    3460                 :            :           else
    3461                 :        262 :             continue;
    3462                 :            :         }
    3463                 :            : 
    3464                 :      48722 :       gimple *stmt;
    3465                 :      48722 :       tree_code ccode;
    3466                 :      48722 :       tree rhs1, rhs2;
    3467                 :      48722 :       if (ranges[i].exp)
    3468                 :            :         {
    3469                 :      47983 :           if (TREE_CODE (ranges[i].exp) != SSA_NAME)
    3470                 :          5 :             continue;
    3471                 :      47978 :           stmt = SSA_NAME_DEF_STMT (ranges[i].exp);
    3472                 :      47978 :           if (!is_gimple_assign (stmt))
    3473                 :        637 :             continue;
    3474                 :      47341 :           ccode = gimple_assign_rhs_code (stmt);
    3475                 :      47341 :           rhs1 = gimple_assign_rhs1 (stmt);
    3476                 :      47341 :           rhs2 = gimple_assign_rhs2 (stmt);
    3477                 :            :         }
    3478                 :            :       else
    3479                 :            :         {
    3480                 :        739 :           operand_entry *oe = (*ops)[ranges[i].idx];
    3481                 :        739 :           stmt = last_stmt (BASIC_BLOCK_FOR_FN (cfun, oe->id));
    3482                 :        739 :           if (gimple_code (stmt) != GIMPLE_COND)
    3483                 :          0 :             continue;
    3484                 :        739 :           ccode = gimple_cond_code (stmt);
    3485                 :        739 :           rhs1 = gimple_cond_lhs (stmt);
    3486                 :        739 :           rhs2 = gimple_cond_rhs (stmt);
    3487                 :            :         }
    3488                 :            : 
    3489                 :      48080 :       if (TREE_CODE (rhs1) != SSA_NAME
    3490                 :      47854 :           || rhs2 == NULL_TREE
    3491                 :      47854 :           || TREE_CODE (rhs2) != SSA_NAME)
    3492                 :        267 :         continue;
    3493                 :            : 
    3494                 :      47813 :       switch (ccode)
    3495                 :            :         {
    3496                 :      43845 :         case GT_EXPR:
    3497                 :      43845 :         case GE_EXPR:
    3498                 :      43845 :         case LT_EXPR:
    3499                 :      43845 :         case LE_EXPR:
    3500                 :      43845 :           break;
    3501                 :       3968 :         default:
    3502                 :       3968 :           continue;
    3503                 :            :         }
    3504                 :      43845 :       if (in_p)
    3505                 :       1102 :         ccode = invert_tree_comparison (ccode, false);
    3506                 :      43845 :       switch (ccode)
    3507                 :            :         {
    3508                 :      21273 :         case GT_EXPR:
    3509                 :      21273 :         case GE_EXPR:
    3510                 :      21273 :           std::swap (rhs1, rhs2);
    3511                 :      21273 :           ccode = swap_tree_comparison (ccode);
    3512                 :      21273 :           break;
    3513                 :            :         case LT_EXPR:
    3514                 :            :         case LE_EXPR:
    3515                 :            :           break;
    3516                 :          0 :         default:
    3517                 :          0 :           gcc_unreachable ();
    3518                 :            :         }
    3519                 :            : 
    3520                 :      43845 :       int *idx = map->get (rhs1);
    3521                 :      41062 :       if (idx == NULL)
    3522                 :       2783 :         continue;
    3523                 :            : 
    3524                 :            :       /* maybe_optimize_range_tests allows statements without side-effects
    3525                 :            :          in the basic blocks as long as they are consumed in the same bb.
    3526                 :            :          Make sure rhs2's def stmt is not among them, otherwise we can't
    3527                 :            :          use safely get_nonzero_bits on it.  E.g. in:
    3528                 :            :           # RANGE [-83, 1] NONZERO 173
    3529                 :            :           # k_32 = PHI <k_47(13), k_12(9)>
    3530                 :            :          ...
    3531                 :            :           if (k_32 >= 0)
    3532                 :            :             goto <bb 5>; [26.46%]
    3533                 :            :           else
    3534                 :            :             goto <bb 9>; [73.54%]
    3535                 :            : 
    3536                 :            :           <bb 5> [local count: 140323371]:
    3537                 :            :           # RANGE [0, 1] NONZERO 1
    3538                 :            :           _5 = (int) k_32;
    3539                 :            :           # RANGE [0, 4] NONZERO 4
    3540                 :            :           _21 = _5 << 2;
    3541                 :            :           # RANGE [0, 4] NONZERO 4
    3542                 :            :           iftmp.0_44 = (char) _21;
    3543                 :            :           if (k_32 < iftmp.0_44)
    3544                 :            :             goto <bb 6>; [84.48%]
    3545                 :            :           else
    3546                 :            :             goto <bb 9>; [15.52%]
    3547                 :            :          the ranges on _5/_21/iftmp.0_44 are flow sensitive, assume that
    3548                 :            :          k_32 >= 0.  If we'd optimize k_32 >= 0 to true and k_32 < iftmp.0_44
    3549                 :            :          to (unsigned) k_32 < (unsigned) iftmp.0_44, then we would execute
    3550                 :            :          those stmts even for negative k_32 and the value ranges would be no
    3551                 :            :          longer guaranteed and so the optimization would be invalid.  */
    3552                 :      41063 :       while (opcode == ERROR_MARK)
    3553                 :            :         {
    3554                 :        539 :           gimple *g = SSA_NAME_DEF_STMT (rhs2);
    3555                 :        539 :           basic_block bb2 = gimple_bb (g);
    3556                 :        539 :           if (bb2
    3557                 :        539 :               && bb2 != first_bb
    3558                 :        539 :               && dominated_by_p (CDI_DOMINATORS, bb2, first_bb))
    3559                 :            :             {
    3560                 :            :               /* As an exception, handle a few common cases.  */
    3561                 :        116 :               if (gimple_assign_cast_p (g)
    3562                 :        144 :                   && INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (g))))
    3563                 :            :                 {
    3564                 :         28 :                   tree op0 = gimple_assign_rhs1 (g);
    3565                 :         28 :                   if (TYPE_UNSIGNED (TREE_TYPE (op0))
    3566                 :         14 :                       && (TYPE_PRECISION (TREE_TYPE (rhs2))
    3567                 :         42 :                           > TYPE_PRECISION (TREE_TYPE (op0))))
    3568                 :            :                     /* Zero-extension is always ok.  */
    3569                 :            :                     break;
    3570                 :         15 :                   else if (TYPE_PRECISION (TREE_TYPE (rhs2))
    3571                 :         15 :                            == TYPE_PRECISION (TREE_TYPE (op0))
    3572                 :         15 :                            && TREE_CODE (op0) == SSA_NAME)
    3573                 :            :                     {
    3574                 :            :                       /* Cast from signed to unsigned or vice versa.  Retry
    3575                 :            :                          with the op0 as new rhs2.  */
    3576                 :          1 :                       rhs2 = op0;
    3577                 :          1 :                       continue;
    3578                 :            :                     }
    3579                 :            :                 }
    3580                 :         88 :               else if (is_gimple_assign (g)
    3581                 :         88 :                        && gimple_assign_rhs_code (g) == BIT_AND_EXPR
    3582                 :          0 :                        && TREE_CODE (gimple_assign_rhs2 (g)) == INTEGER_CST
    3583                 :        176 :                        && !wi::neg_p (wi::to_wide (gimple_assign_rhs2 (g))))
    3584                 :            :                 /* Masking with INTEGER_CST with MSB clear is always ok
    3585                 :            :                    too.  */
    3586                 :            :                 break;
    3587                 :            :               rhs2 = NULL_TREE;
    3588                 :            :             }
    3589                 :            :           break;
    3590                 :            :         }
    3591                 :      40960 :       if (rhs2 == NULL_TREE)
    3592                 :        102 :         continue;
    3593                 :            : 
    3594                 :      40960 :       wide_int nz = get_nonzero_bits (rhs2);
    3595                 :      40960 :       if (wi::neg_p (nz))
    3596                 :      40449 :         continue;
    3597                 :            : 
    3598                 :            :       /* We have EXP < RHS2 or EXP <= RHS2 where EXP >= 0
    3599                 :            :          and RHS2 is known to be RHS2 >= 0.  */
    3600                 :        511 :       tree utype = unsigned_type_for (TREE_TYPE (rhs1));
    3601                 :            : 
    3602                 :        511 :       enum warn_strict_overflow_code wc = WARN_STRICT_OVERFLOW_COMPARISON;
    3603                 :        511 :       if ((ranges[*idx].strict_overflow_p
    3604                 :        511 :            || ranges[i].strict_overflow_p)
    3605                 :          0 :           && issue_strict_overflow_warning (wc))
    3606                 :          0 :         warning_at (gimple_location (stmt), OPT_Wstrict_overflow,
    3607                 :            :                     "assuming signed overflow does not occur "
    3608                 :            :                     "when simplifying range test");
    3609                 :            : 
    3610                 :        511 :       if (dump_file && (dump_flags & TDF_DETAILS))
    3611                 :            :         {
    3612                 :          7 :           struct range_entry *r = &ranges[*idx];
    3613                 :          7 :           fprintf (dump_file, "Optimizing range test ");
    3614                 :          7 :           print_generic_expr (dump_file, r->exp);
    3615                 :          7 :           fprintf (dump_file, " +[");
    3616                 :          7 :           print_generic_expr (dump_file, r->low);
    3617                 :          7 :           fprintf (dump_file, ", ");
    3618                 :          7 :           print_generic_expr (dump_file, r->high);
    3619                 :          7 :           fprintf (dump_file, "] and comparison ");
    3620                 :          7 :           print_generic_expr (dump_file, rhs1);
    3621                 :          7 :           fprintf (dump_file, " %s ", op_symbol_code (ccode));
    3622                 :          7 :           print_generic_expr (dump_file, rhs2);
    3623                 :          7 :           fprintf (dump_file, "\n into (");
    3624                 :          7 :           print_generic_expr (dump_file, utype);
    3625                 :          7 :           fprintf (dump_file, ") ");
    3626                 :          7 :           print_generic_expr (dump_file, rhs1);
    3627                 :          7 :           fprintf (dump_file, " %s (", op_symbol_code (ccode));
    3628                 :          7 :           print_generic_expr (dump_file, utype);
    3629                 :          7 :           fprintf (dump_file, ") ");
    3630                 :          7 :           print_generic_expr (dump_file, rhs2);
    3631                 :          7 :           fprintf (dump_file, "\n");
    3632                 :            :         }
    3633                 :            : 
    3634                 :        511 :       operand_entry *oe = (*ops)[ranges[i].idx];
    3635                 :        511 :       ranges[i].in_p = 0;
    3636                 :        511 :       if (opcode == BIT_IOR_EXPR
    3637                 :        504 :           || (opcode == ERROR_MARK && oe->rank == BIT_IOR_EXPR))
    3638                 :            :         {
    3639                 :         11 :           ranges[i].in_p = 1;
    3640                 :         11 :           ccode = invert_tree_comparison (ccode, false);
    3641                 :            :         }
    3642                 :            : 
    3643                 :        511 :       unsigned int uid = gimple_uid (stmt);
    3644                 :        511 :       gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    3645                 :        511 :       gimple *g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, rhs1);
    3646                 :        511 :       gimple_set_uid (g, uid);
    3647                 :        511 :       rhs1 = gimple_assign_lhs (g);
    3648                 :        511 :       gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    3649                 :        511 :       if (!useless_type_conversion_p (utype, TREE_TYPE (rhs2)))
    3650                 :            :         {
    3651                 :        510 :           g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, rhs2);
    3652                 :        510 :           gimple_set_uid (g, uid);
    3653                 :        510 :           rhs2 = gimple_assign_lhs (g);
    3654                 :        510 :           gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    3655                 :            :         }
    3656                 :        511 :       if (tree_swap_operands_p (rhs1, rhs2))
    3657                 :            :         {
    3658                 :        262 :           std::swap (rhs1, rhs2);
    3659                 :        262 :           ccode = swap_tree_comparison (ccode);
    3660                 :            :         }
    3661                 :        511 :       if (gimple_code (stmt) == GIMPLE_COND)
    3662                 :            :         {
    3663                 :         14 :           gcond *c = as_a <gcond *> (stmt);
    3664                 :         14 :           gimple_cond_set_code (c, ccode);
    3665                 :         14 :           gimple_cond_set_lhs (c, rhs1);
    3666                 :         14 :           gimple_cond_set_rhs (c, rhs2);
    3667                 :         14 :           update_stmt (stmt);
    3668                 :            :         }
    3669                 :            :       else
    3670                 :            :         {
    3671                 :        497 :           tree ctype = oe->op ? TREE_TYPE (oe->op) : boolean_type_node;
    3672                 :        497 :           if (!INTEGRAL_TYPE_P (ctype)
    3673                 :        497 :               || (TREE_CODE (ctype) != BOOLEAN_TYPE
    3674                 :          5 :                   && TYPE_PRECISION (ctype) != 1))
    3675                 :          5 :             ctype = boolean_type_node;
    3676                 :        497 :           g = gimple_build_assign (make_ssa_name (ctype), ccode, rhs1, rhs2);
    3677                 :        497 :           gimple_set_uid (g, uid);
    3678                 :        497 :           gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    3679                 :        497 :           if (oe->op && ctype != TREE_TYPE (oe->op))
    3680                 :            :             {
    3681                 :          5 :               g = gimple_build_assign (make_ssa_name (TREE_TYPE (oe->op)),
    3682                 :            :                                        NOP_EXPR, gimple_assign_lhs (g));
    3683                 :          5 :               gimple_set_uid (g, uid);
    3684                 :          5 :               gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    3685                 :            :             }
    3686                 :        497 :           ranges[i].exp = gimple_assign_lhs (g);
    3687                 :        497 :           oe->op = ranges[i].exp;
    3688                 :        497 :           ranges[i].low = build_zero_cst (TREE_TYPE (ranges[i].exp));
    3689                 :        497 :           ranges[i].high = ranges[i].low;
    3690                 :            :         }
    3691                 :        511 :       ranges[i].strict_overflow_p = false;
    3692                 :        511 :       oe = (*ops)[ranges[*idx].idx];
    3693                 :            :       /* Now change all the other range test immediate uses, so that
    3694                 :            :          those tests will be optimized away.  */
    3695                 :        511 :       if (opcode == ERROR_MARK)
    3696                 :            :         {
    3697                 :         20 :           if (oe->op)
    3698                 :          4 :             oe->op = build_int_cst (TREE_TYPE (oe->op),
    3699                 :          4 :                                     oe->rank == BIT_IOR_EXPR ? 0 : 1);
    3700                 :            :           else
    3701                 :         16 :             oe->op = (oe->rank == BIT_IOR_EXPR
    3702                 :         16 :                       ? boolean_false_node : boolean_true_node);
    3703                 :            :         }
    3704                 :            :       else
    3705                 :        491 :         oe->op = error_mark_node;
    3706                 :        511 :       ranges[*idx].exp = NULL_TREE;
    3707                 :        511 :       ranges[*idx].low = NULL_TREE;
    3708                 :        511 :       ranges[*idx].high = NULL_TREE;
    3709                 :        511 :       any_changes = true;
    3710                 :            :     }
    3711                 :            : 
    3712                 :      48870 :   delete map;
    3713                 :      48870 :   return any_changes;
    3714                 :            : }
    3715                 :            : 
    3716                 :            : /* Optimize range tests, similarly how fold_range_test optimizes
    3717                 :            :    it on trees.  The tree code for the binary
    3718                 :            :    operation between all the operands is OPCODE.
    3719                 :            :    If OPCODE is ERROR_MARK, optimize_range_tests is called from within
    3720                 :            :    maybe_optimize_range_tests for inter-bb range optimization.
    3721                 :            :    In that case if oe->op is NULL, oe->id is bb->index whose
    3722                 :            :    GIMPLE_COND is && or ||ed into the test, and oe->rank says
    3723                 :            :    the actual opcode.
    3724                 :            :    FIRST_BB is the first basic block if OPCODE is ERROR_MARK.  */
    3725                 :            : 
    3726                 :            : static bool
    3727                 :     653636 : optimize_range_tests (enum tree_code opcode,
    3728                 :            :                       vec<operand_entry *> *ops, basic_block first_bb)
    3729                 :            : {
    3730                 :     653636 :   unsigned int length = ops->length (), i, j, first;
    3731                 :     653636 :   operand_entry *oe;
    3732                 :     653636 :   struct range_entry *ranges;
    3733                 :    1307200 :   bool any_changes = false;
    3734                 :            : 
    3735                 :     653636 :   if (length == 1)
    3736                 :            :     return false;
    3737                 :            : 
    3738                 :     653563 :   ranges = XNEWVEC (struct range_entry, length);
    3739                 :    2026860 :   for (i = 0; i < length; i++)
    3740                 :            :     {
    3741                 :    1373290 :       oe = (*ops)[i];
    3742                 :    1373290 :       ranges[i].idx = i;
    3743                 :    1373290 :       init_range_entry (ranges + i, oe->op,
    3744                 :    1373290 :                         oe->op
    3745                 :            :                         ? NULL
    3746                 :     190146 :                         : last_stmt (BASIC_BLOCK_FOR_FN (cfun, oe->id)));
    3747                 :            :       /* For | invert it now, we will invert it again before emitting
    3748                 :            :          the optimized expression.  */
    3749                 :    1373290 :       if (opcode == BIT_IOR_EXPR
    3750                 :     990341 :           || (opcode == ERROR_MARK && oe->rank == BIT_IOR_EXPR))
    3751                 :     495574 :         ranges[i].in_p = !ranges[i].in_p;
    3752                 :            :     }
    3753                 :            : 
    3754                 :     653563 :   qsort (ranges, length, sizeof (*ranges), range_entry_cmp);
    3755                 :    1463110 :   for (i = 0; i < length; i++)
    3756                 :    1079750 :     if (ranges[i].exp != NULL_TREE && TREE_CODE (ranges[i].exp) == SSA_NAME)
    3757                 :            :       break;
    3758                 :            : 
    3759                 :            :   /* Try to merge ranges.  */
    3760                 :    1207560 :   for (first = i; i < length; i++)
    3761                 :            :     {
    3762                 :     553994 :       tree low = ranges[i].low;
    3763                 :     553994 :       tree high = ranges[i].high;
    3764                 :     553994 :       int in_p = ranges[i].in_p;
    3765                 :     553994 :       bool strict_overflow_p = ranges[i].strict_overflow_p;
    3766                 :     553994 :       int update_fail_count = 0;
    3767                 :            : 
    3768                 :     563748 :       for (j = i + 1; j < length; j++)
    3769                 :            :         {
    3770                 :     293538 :           if (ranges[i].exp != ranges[j].exp)
    3771                 :            :             break;
    3772                 :      27101 :           if (!merge_ranges (&in_p, &low, &high, in_p, low, high,
    3773                 :      27101 :                              ranges[j].in_p, ranges[j].low, ranges[j].high))
    3774                 :            :             break;
    3775                 :       9754 :           strict_overflow_p |= ranges[j].strict_overflow_p;
    3776                 :            :         }
    3777                 :            : 
    3778                 :     553994 :       if (j == i + 1)
    3779                 :     544828 :         continue;
    3780                 :            : 
    3781                 :       9166 :       if (update_range_test (ranges + i, ranges + i + 1, NULL, j - i - 1,
    3782                 :            :                              opcode, ops, ranges[i].exp, NULL, in_p,
    3783                 :            :                              low, high, strict_overflow_p))
    3784                 :            :         {
    3785                 :       9166 :           i = j - 1;
    3786                 :       9166 :           any_changes = true;
    3787                 :            :         }
    3788                 :            :       /* Avoid quadratic complexity if all merge_ranges calls would succeed,
    3789                 :            :          while update_range_test would fail.  */
    3790                 :            :       else if (update_fail_count == 64)
    3791                 :            :         i = j - 1;
    3792                 :            :       else
    3793                 :       9166 :         ++update_fail_count;
    3794                 :            :     }
    3795                 :            : 
    3796                 :     653563 :   any_changes |= optimize_range_tests_1 (opcode, first, length, true,
    3797                 :            :                                          ops, ranges);
    3798                 :            : 
    3799                 :     653563 :   if (BRANCH_COST (optimize_function_for_speed_p (cfun), false) >= 2)
    3800                 :     653536 :     any_changes |= optimize_range_tests_1 (opcode, first, length, false,
    3801                 :            :                                            ops, ranges);
    3802                 :     653563 :   if (lshift_cheap_p (optimize_function_for_speed_p (cfun)))
    3803                 :     653563 :     any_changes |= optimize_range_tests_to_bit_test (opcode, first, length,
    3804                 :            :                                                      ops, ranges);
    3805                 :     653563 :   any_changes |= optimize_range_tests_cmp_bitwise (opcode, first, length,
    3806                 :            :                                                    ops, ranges);
    3807                 :     653563 :   any_changes |= optimize_range_tests_var_bound (opcode, first, length, ops,
    3808                 :            :                                                  ranges, first_bb);
    3809                 :            : 
    3810                 :     653563 :   if (any_changes && opcode != ERROR_MARK)
    3811                 :            :     {
    3812                 :            :       j = 0;
    3813                 :      22126 :       FOR_EACH_VEC_ELT (*ops, i, oe)
    3814                 :            :         {
    3815                 :      15339 :           if (oe->op == error_mark_node)
    3816                 :       7085 :             continue;
    3817                 :       8254 :           else if (i != j)
    3818                 :       4377 :             (*ops)[j] = oe;
    3819                 :       8254 :           j++;
    3820                 :            :         }
    3821                 :       6787 :       ops->truncate (j);
    3822                 :            :     }
    3823                 :            : 
    3824                 :     653563 :   XDELETEVEC (ranges);
    3825                 :     653563 :   return any_changes;
    3826                 :            : }
    3827                 :            : 
    3828                 :            : /* A subroutine of optimize_vec_cond_expr to extract and canonicalize
    3829                 :            :    the operands of the VEC_COND_EXPR.  Returns ERROR_MARK on failure,
    3830                 :            :    otherwise the comparison code.  TYPE is a return value that is set
    3831                 :            :    to type of comparison.  */
    3832                 :            : 
    3833                 :            : static tree_code
    3834                 :       8354 : ovce_extract_ops (tree var, gassign **rets, bool *reti, tree *type)
    3835                 :            : {
    3836                 :       8354 :   if (TREE_CODE (var) != SSA_NAME)
    3837                 :            :     return ERROR_MARK;
    3838                 :            : 
    3839                 :       7619 :   gassign *stmt = dyn_cast <gassign *> (SSA_NAME_DEF_STMT (var));
    3840                 :       7117 :   if (stmt == NULL)
    3841                 :            :     return ERROR_MARK;
    3842                 :            : 
    3843                 :            :   /* ??? If we start creating more COND_EXPR, we could perform
    3844                 :            :      this same optimization with them.  For now, simplify.  */
    3845                 :      10962 :   if (gimple_assign_rhs_code (stmt) != VEC_COND_EXPR)
    3846                 :            :     return ERROR_MARK;
    3847                 :            : 
    3848                 :         74 :   tree cond = gimple_assign_rhs1 (stmt);
    3849                 :         74 :   tree_code cmp = TREE_CODE (cond);
    3850                 :         74 :   if (TREE_CODE_CLASS (cmp) != tcc_comparison)
    3851                 :            :     return ERROR_MARK;
    3852                 :            : 
    3853                 :            :   /* ??? For now, allow only canonical true and false result vectors.
    3854                 :            :      We could expand this to other constants should the need arise,
    3855                 :            :      but at the moment we don't create them.  */
    3856                 :         63 :   tree t = gimple_assign_rhs2 (stmt);
    3857                 :         63 :   tree f = gimple_assign_rhs3 (stmt);
    3858                 :         63 :   bool inv;
    3859                 :         63 :   if (integer_all_onesp (t))
    3860                 :            :     inv = false;
    3861                 :          8 :   else if (integer_all_onesp (f))
    3862                 :            :     {
    3863                 :          0 :       cmp = invert_tree_comparison (cmp, false);
    3864                 :          0 :       inv = true;
    3865                 :            :     }
    3866                 :            :   else
    3867                 :            :     return ERROR_MARK;
    3868                 :         55 :   if (!integer_zerop (f))
    3869                 :            :     return ERROR_MARK;
    3870                 :            : 
    3871                 :            :   /* Success!  */
    3872                 :         55 :   if (rets)
    3873                 :         55 :     *rets = stmt;
    3874                 :         55 :   if (reti)
    3875                 :         33 :     *reti = inv;
    3876                 :         55 :   if (type)
    3877                 :         33 :     *type = TREE_TYPE (cond);
    3878                 :            :   return cmp;
    3879                 :            : }
    3880                 :            : 
    3881                 :            : /* Optimize the condition of VEC_COND_EXPRs which have been combined
    3882                 :            :    with OPCODE (either BIT_AND_EXPR or BIT_IOR_EXPR).  */
    3883                 :            : 
    3884                 :            : static bool
    3885                 :       4025 : optimize_vec_cond_expr (tree_code opcode, vec<operand_entry *> *ops)
    3886                 :            : {
    3887                 :       4025 :   unsigned int length = ops->length (), i, j;
    3888                 :       4025 :   bool any_changes = false;
    3889                 :            : 
    3890                 :       4025 :   if (length == 1)
    3891                 :            :     return false;
    3892                 :            : 
    3893                 :      12354 :   for (i = 0; i < length; ++i)
    3894                 :            :     {
    3895                 :       8329 :       tree elt0 = (*ops)[i]->op;
    3896                 :            : 
    3897                 :       8329 :       gassign *stmt0;
    3898                 :       8329 :       bool invert;
    3899                 :       8329 :       tree type;
    3900                 :       8329 :       tree_code cmp0 = ovce_extract_ops (elt0, &stmt0, &invert, &type);
    3901                 :       8329 :       if (cmp0 == ERROR_MARK)
    3902                 :       8296 :         continue;
    3903                 :            : 
    3904                 :         58 :       for (j = i + 1; j < length; ++j)
    3905                 :            :         {
    3906                 :         25 :           tree &elt1 = (*ops)[j]->op;
    3907                 :            : 
    3908                 :         25 :           gassign *stmt1;
    3909                 :         25 :           tree_code cmp1 = ovce_extract_ops (elt1, &stmt1, NULL, NULL);
    3910                 :         25 :           if (cmp1 == ERROR_MARK)
    3911                 :         11 :             continue;
    3912                 :            : 
    3913                 :         22 :           tree cond0 = gimple_assign_rhs1 (stmt0);
    3914                 :         22 :           tree x0 = TREE_OPERAND (cond0, 0);
    3915                 :         22 :           tree y0 = TREE_OPERAND (cond0, 1);
    3916                 :            : 
    3917                 :         22 :           tree cond1 = gimple_assign_rhs1 (stmt1);
    3918                 :         22 :           tree x1 = TREE_OPERAND (cond1, 0);
    3919                 :         22 :           tree y1 = TREE_OPERAND (cond1, 1);
    3920                 :            : 
    3921                 :         22 :           tree comb;
    3922                 :         22 :           if (opcode == BIT_AND_EXPR)
    3923                 :         13 :             comb = maybe_fold_and_comparisons (type, cmp0, x0, y0, cmp1, x1,
    3924                 :            :                                                y1);
    3925                 :          9 :           else if (opcode == BIT_IOR_EXPR)
    3926                 :          9 :             comb = maybe_fold_or_comparisons (type, cmp0, x0, y0, cmp1, x1,
    3927                 :            :                                               y1);
    3928                 :            :           else
    3929                 :          0 :             gcc_unreachable ();
    3930                 :         22 :           if (comb == NULL)
    3931                 :          8 :             continue;
    3932                 :            : 
    3933                 :            :           /* Success! */
    3934                 :         14 :           if (dump_file && (dump_flags & TDF_DETAILS))
    3935                 :            :             {
    3936                 :          0 :               fprintf (dump_file, "Transforming ");
    3937                 :          0 :               print_generic_expr (dump_file, cond0);
    3938                 :          0 :               fprintf (dump_file, " %c ", opcode == BIT_AND_EXPR ? '&' : '|');
    3939                 :          0 :               print_generic_expr (dump_file, cond1);
    3940                 :          0 :               fprintf (dump_file, " into ");
    3941                 :          0 :               print_generic_expr (dump_file, comb);
    3942                 :          0 :               fputc ('\n', dump_file);
    3943                 :            :             }
    3944                 :            : 
    3945                 :         14 :           gimple_assign_set_rhs1 (stmt0, comb);
    3946                 :         14 :           if (invert)
    3947                 :          0 :             std::swap (*gimple_assign_rhs2_ptr (stmt0),
    3948                 :          0 :                        *gimple_assign_rhs3_ptr (stmt0));
    3949                 :         14 :           update_stmt (stmt0);
    3950                 :            : 
    3951                 :         14 :           elt1 = error_mark_node;
    3952                 :         14 :           any_changes = true;
    3953                 :            :         }
    3954                 :            :     }
    3955                 :            : 
    3956                 :       4025 :   if (any_changes)
    3957                 :            :     {
    3958                 :            :       operand_entry *oe;
    3959                 :            :       j = 0;
    3960                 :         42 :       FOR_EACH_VEC_ELT (*ops, i, oe)
    3961                 :            :         {
    3962                 :         28 :           if (oe->op == error_mark_node)
    3963                 :         14 :             continue;
    3964                 :         14 :           else if (i != j)
    3965                 :          0 :             (*ops)[j] = oe;
    3966                 :         14 :           j++;
    3967                 :            :         }
    3968                 :         14 :       ops->truncate (j);
    3969                 :            :     }
    3970                 :            : 
    3971                 :            :   return any_changes;
    3972                 :            : }
    3973                 :            : 
    3974                 :            : /* Return true if STMT is a cast like:
    3975                 :            :    <bb N>:
    3976                 :            :    ...
    3977                 :            :    _123 = (int) _234;
    3978                 :            : 
    3979                 :            :    <bb M>:
    3980                 :            :    # _345 = PHI <_123(N), 1(...), 1(...)>
    3981                 :            :    where _234 has bool type, _123 has single use and
    3982                 :            :    bb N has a single successor M.  This is commonly used in
    3983                 :            :    the last block of a range test.
    3984                 :            : 
    3985                 :            :    Also Return true if STMT is tcc_compare like:
    3986                 :            :    <bb N>:
    3987                 :            :    ...
    3988                 :            :    _234 = a_2(D) == 2;
    3989                 :            : 
    3990                 :            :    <bb M>:
    3991                 :            :    # _345 = PHI <_234(N), 1(...), 1(...)>
    3992                 :            :    _346 = (int) _345;
    3993                 :            :    where _234 has booltype, single use and
    3994                 :            :    bb N has a single successor M.  This is commonly used in
    3995                 :            :    the last block of a range test.  */
    3996                 :            : 
    3997                 :            : static bool
    3998                 :   10341400 : final_range_test_p (gimple *stmt)
    3999                 :            : {
    4000                 :   10341400 :   basic_block bb, rhs_bb, lhs_bb;
    4001                 :   10341400 :   edge e;
    4002                 :   10341400 :   tree lhs, rhs;
    4003                 :   10341400 :   use_operand_p use_p;
    4004                 :   10341400 :   gimple *use_stmt;
    4005                 :            : 
    4006                 :   10341400 :   if (!gimple_assign_cast_p (stmt)
    4007                 :   10341400 :       && (!is_gimple_assign (stmt)
    4008                 :    3265290 :           || (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
    4009                 :            :               != tcc_comparison)))
    4010                 :            :     return false;
    4011                 :     393317 :   bb = gimple_bb (stmt);
    4012                 :     393317 :   if (!single_succ_p (bb))
    4013                 :            :     return false;
    4014                 :     393097 :   e = single_succ_edge (bb);
    4015                 :     393097 :   if (e->flags & EDGE_COMPLEX)
    4016                 :            :     return false;
    4017                 :            : 
    4018                 :     393097 :   lhs = gimple_assign_lhs (stmt);
    4019                 :     393097 :   rhs = gimple_assign_rhs1 (stmt);
    4020                 :     393097 :   if (gimple_assign_cast_p (stmt)
    4021                 :     695705 :       && (!INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    4022                 :     288220 :           || TREE_CODE (rhs) != SSA_NAME
    4023                 :     279503 :           || TREE_CODE (TREE_TYPE (rhs)) != BOOLEAN_TYPE))
    4024                 :            :     return false;
    4025                 :            : 
    4026                 :     137875 :   if (!gimple_assign_cast_p (stmt)
    4027                 :     228364 :       && (TREE_CODE (TREE_TYPE (lhs)) != BOOLEAN_TYPE))
    4028                 :            :       return false;
    4029                 :            : 
    4030                 :            :   /* Test whether lhs is consumed only by a PHI in the only successor bb.  */
    4031                 :     137875 :   if (!single_imm_use (lhs, &use_p, &use_stmt))
    4032                 :            :     return false;
    4033                 :            : 
    4034                 :     133909 :   if (gimple_code (use_stmt) != GIMPLE_PHI
    4035                 :     133909 :       || gimple_bb (use_stmt) != e->dest)
    4036                 :            :     return false;
    4037                 :            : 
    4038                 :            :   /* And that the rhs is defined in the same loop.  */
    4039                 :     133514 :   if (gimple_assign_cast_p (stmt))
    4040                 :            :     {
    4041                 :      46943 :       if (TREE_CODE (rhs) != SSA_NAME
    4042                 :      46943 :           || !(rhs_bb = gimple_bb (SSA_NAME_DEF_STMT (rhs)))
    4043                 :      93878 :           || !flow_bb_inside_loop_p (loop_containing_stmt (stmt), rhs_bb))
    4044                 :         64 :         return false;
    4045                 :            :     }
    4046                 :            :   else
    4047                 :            :     {
    4048                 :      86571 :       if (TREE_CODE (lhs) != SSA_NAME
    4049                 :      86571 :           || !(lhs_bb = gimple_bb (SSA_NAME_DEF_STMT (lhs)))
    4050                 :     173142 :           || !flow_bb_inside_loop_p (loop_containing_stmt (stmt), lhs_bb))
    4051                 :          0 :         return false;
    4052                 :            :     }
    4053                 :            : 
    4054                 :            :   return true;
    4055                 :            : }
    4056                 :            : 
    4057                 :            : /* Return true if BB is suitable basic block for inter-bb range test
    4058                 :            :    optimization.  If BACKWARD is true, BB should be the only predecessor
    4059                 :            :    of TEST_BB, and *OTHER_BB is either NULL and filled by the routine,
    4060                 :            :    or compared with to find a common basic block to which all conditions
    4061                 :            :    branch to if true resp. false.  If BACKWARD is false, TEST_BB should
    4062                 :            :    be the only predecessor of BB.  */
    4063                 :            : 
    4064                 :            : static bool
    4065                 :    6724450 : suitable_cond_bb (basic_block bb, basic_block test_bb, basic_block *other_bb,
    4066                 :            :                   bool backward)
    4067                 :            : {
    4068                 :    6724450 :   edge_iterator ei, ei2;
    4069                 :    6724450 :   edge e, e2;
    4070                 :    6724450 :   gimple *stmt;
    4071                 :    6724450 :   gphi_iterator gsi;
    4072                 :    6724450 :   bool other_edge_seen = false;
    4073                 :    6724450 :   bool is_cond;
    4074                 :            : 
    4075                 :    6724450 :   if (test_bb == bb)
    4076                 :            :     return false;
    4077                 :            :   /* Check last stmt first.  */
    4078                 :    6724450 :   stmt = last_stmt (bb);
    4079                 :    6724450 :   if (stmt == NULL
    4080                 :    6080930 :       || (gimple_code (stmt) != GIMPLE_COND
    4081                 :     366173 :           && (backward || !final_range_test_p (stmt)))
    4082                 :    5739050 :       || gimple_visited_p (stmt)
    4083                 :    5719740 :       || stmt_could_throw_p (cfun, stmt)
    4084                 :   12444100 :       || *other_bb == bb)
    4085                 :    1004920 :     return false;
    4086                 :    5719520 :   is_cond = gimple_code (stmt) == GIMPLE_COND;
    4087                 :    5719520 :   if (is_cond)
    4088                 :            :     {
    4089                 :            :       /* If last stmt is GIMPLE_COND, verify that one of the succ edges
    4090                 :            :          goes to the next bb (if BACKWARD, it is TEST_BB), and the other
    4091                 :            :          to *OTHER_BB (if not set yet, try to find it out).  */
    4092                 :    5695320 :       if (EDGE_COUNT (bb->succs) != 2)
    4093                 :            :         return false;
    4094                 :   11609300 :       FOR_EACH_EDGE (e, ei, bb->succs)
    4095                 :            :         {
    4096                 :    9434660 :           if (!(e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
    4097                 :            :             return false;
    4098                 :    9434660 :           if (e->dest == test_bb)
    4099                 :            :             {
    4100                 :    3310710 :               if (backward)
    4101                 :    3309570 :                 continue;
    4102                 :            :               else
    4103                 :            :                 return false;
    4104                 :            :             }
    4105                 :    6123950 :           if (e->dest == bb)
    4106                 :            :             return false;
    4107                 :    6041530 :           if (*other_bb == NULL)
    4108                 :            :             {
    4109                 :   15122300 :               FOR_EACH_EDGE (e2, ei2, test_bb->succs)
    4110                 :   10081500 :                 if (!(e2->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
    4111                 :            :                   return false;
    4112                 :   10081500 :                 else if (e->dest == e2->dest)
    4113                 :    1671090 :                   *other_bb = e->dest;
    4114                 :    5040760 :               if (*other_bb == NULL)
    4115                 :            :                 return false;
    4116                 :            :             }
    4117                 :    2671860 :           if (e->dest == *other_bb)
    4118                 :            :             other_edge_seen = true;
    4119                 :     521156 :           else if (backward)
    4120                 :            :             return false;
    4121                 :            :         }
    4122                 :    2174650 :       if (*other_bb == NULL || !other_edge_seen)
    4123                 :            :         return false;
    4124                 :            :     }
    4125                 :      24204 :   else if (single_succ (bb) != *other_bb)
    4126                 :            :     return false;
    4127                 :            : 
    4128                 :            :   /* Now check all PHIs of *OTHER_BB.  */
    4129                 :    2174050 :   e = find_edge (bb, *other_bb);
    4130                 :    2174050 :   e2 = find_edge (test_bb, *other_bb);
    4131                 :    2959210 :   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
    4132                 :            :     {
    4133                 :    1578770 :       gphi *phi = gsi.phi ();
    4134                 :            :       /* If both BB and TEST_BB end with GIMPLE_COND, all PHI arguments
    4135                 :            :          corresponding to BB and TEST_BB predecessor must be the same.  */
    4136                 :    1578770 :       if (!operand_equal_p (gimple_phi_arg_def (phi, e->dest_idx),
    4137                 :    1578770 :                             gimple_phi_arg_def (phi, e2->dest_idx), 0))
    4138                 :            :         {
    4139                 :            :           /* Otherwise, if one of the blocks doesn't end with GIMPLE_COND,
    4140                 :            :              one of the PHIs should have the lhs of the last stmt in
    4141                 :            :              that block as PHI arg and that PHI should have 0 or 1
    4142                 :            :              corresponding to it in all other range test basic blocks
    4143                 :            :              considered.  */
    4144                 :     841654 :           if (!is_cond)
    4145                 :            :             {
    4146                 :      30312 :               if (gimple_phi_arg_def (phi, e->dest_idx)
    4147                 :      30312 :                   == gimple_assign_lhs (stmt)
    4148                 :      30312 :                   && (integer_zerop (gimple_phi_arg_def (phi, e2->dest_idx))
    4149                 :      11758 :                       || integer_onep (gimple_phi_arg_def (phi,
    4150                 :      11758 :                                                            e2->dest_idx))))
    4151                 :      21883 :                 continue;
    4152                 :            :             }
    4153                 :            :           else
    4154                 :            :             {
    4155                 :     811342 :               gimple *test_last = last_stmt (test_bb);
    4156                 :     811342 :               if (gimple_code (test_last) != GIMPLE_COND
    4157                 :      34591 :                   && gimple_phi_arg_def (phi, e2->dest_idx)
    4158                 :      34591 :                      == gimple_assign_lhs (test_last)
    4159                 :     839071 :                   && (integer_zerop (gimple_phi_arg_def (phi, e->dest_idx))
    4160                 :      14319 :                       || integer_onep (gimple_phi_arg_def (phi, e->dest_idx))))
    4161                 :      26164 :                 continue;
    4162                 :            :             }
    4163                 :            : 
    4164                 :     793607 :           return false;
    4165                 :            :         }
    4166                 :            :     }
    4167                 :            :   return true;
    4168                 :            : }
    4169                 :            : 
    4170                 :            : /* Return true if BB doesn't have side-effects that would disallow
    4171                 :            :    range test optimization, all SSA_NAMEs set in the bb are consumed
    4172                 :            :    in the bb and there are no PHIs.  */
    4173                 :            : 
    4174                 :            : static bool
    4175                 :     979088 : no_side_effect_bb (basic_block bb)
    4176                 :            : {
    4177                 :     979088 :   gimple_stmt_iterator gsi;
    4178                 :     979088 :   gimple *last;
    4179                 :            : 
    4180                 :     979088 :   if (!gimple_seq_empty_p (phi_nodes (bb)))
    4181                 :            :     return false;
    4182                 :     977254 :   last = last_stmt (bb);
    4183                 :    3445820 :   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    4184                 :            :     {
    4185                 :    2468570 :       gimple *stmt = gsi_stmt (gsi);
    4186                 :    2468570 :       tree lhs;
    4187                 :    2468570 :       imm_use_iterator imm_iter;
    4188                 :    2468570 :       use_operand_p use_p;
    4189                 :            : 
    4190                 :    2468570 :       if (is_gimple_debug (stmt))
    4191                 :    1158300 :         continue;
    4192                 :    1310270 :       if (gimple_has_side_effects (stmt))
    4193                 :     977254 :         return false;
    4194                 :     949366 :       if (stmt == last)
    4195                 :            :         return true;
    4196                 :     804717 :       if (!is_gimple_assign (stmt))
    4197                 :            :         return false;
    4198                 :     707609 :       lhs = gimple_assign_lhs (stmt);
    4199                 :     707609 :       if (TREE_CODE (lhs) != SSA_NAME)
    4200                 :            :         return false;
    4201                 :     707609 :       if (gimple_assign_rhs_could_trap_p (stmt))
    4202                 :            :         return false;
    4203                 :     814059 :       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, lhs)
    4204                 :            :         {
    4205                 :     481042 :           gimple *use_stmt = USE_STMT (use_p);
    4206                 :     481042 :           if (is_gimple_debug (use_stmt))
    4207                 :      21398 :             continue;
    4208                 :     459644 :           if (gimple_bb (use_stmt) != bb)
    4209                 :            :             return false;
    4210                 :            :         }
    4211                 :            :     }
    4212                 :            :   return false;
    4213                 :            : }
    4214                 :            : 
    4215                 :            : /* If VAR is set by CODE (BIT_{AND,IOR}_EXPR) which is reassociable,
    4216                 :            :    return true and fill in *OPS recursively.  */
    4217                 :            : 
    4218                 :            : static bool
    4219                 :      80223 : get_ops (tree var, enum tree_code code, vec<operand_entry *> *ops,
    4220                 :            :          class loop *loop)
    4221                 :            : {
    4222                 :      80223 :   gimple *stmt = SSA_NAME_DEF_STMT (var);
    4223                 :      80223 :   tree rhs[2];
    4224                 :      80223 :   int i;
    4225                 :            : 
    4226                 :      80223 :   if (!is_reassociable_op (stmt, code, loop))
    4227                 :            :     return false;
    4228                 :            : 
    4229                 :      13046 :   rhs[0] = gimple_assign_rhs1 (stmt);
    4230                 :      13046 :   rhs[1] = gimple_assign_rhs2 (stmt);
    4231                 :      13046 :   gimple_set_visited (stmt, true);
    4232                 :      39138 :   for (i = 0; i < 2; i++)
    4233                 :      26092 :     if (TREE_CODE (rhs[i]) == SSA_NAME
    4234                 :      26092 :         && !get_ops (rhs[i], code, ops, loop)
    4235                 :      51191 :         && has_single_use (rhs[i]))
    4236                 :            :       {
    4237                 :      24123 :         operand_entry *oe = operand_entry_pool.allocate ();
    4238                 :            : 
    4239                 :      24123 :         oe->op = rhs[i];
    4240                 :      24123 :         oe->rank = code;
    4241                 :      24123 :         oe->id = 0;
    4242                 :      24123 :         oe->count = 1;
    4243                 :      24123 :         oe->stmt_to_insert = NULL;
    4244                 :      24123 :         ops->safe_push (oe);
    4245                 :            :       }
    4246                 :            :   return true;
    4247                 :            : }
    4248                 :            : 
    4249                 :            : /* Find the ops that were added by get_ops starting from VAR, see if
    4250                 :            :    they were changed during update_range_test and if yes, create new
    4251                 :            :    stmts.  */
    4252                 :            : 
    4253                 :            : static tree
    4254                 :      12244 : update_ops (tree var, enum tree_code code, vec<operand_entry *> ops,
    4255                 :            :             unsigned int *pidx, class loop *loop)
    4256                 :            : {
    4257                 :      12244 :   gimple *stmt = SSA_NAME_DEF_STMT (var);
    4258                 :      12244 :   tree rhs[4];
    4259                 :      12244 :   int i;
    4260                 :            : 
    4261                 :      12244 :   if (!is_reassociable_op (stmt, code, loop))
    4262                 :            :     return NULL;
    4263                 :            : 
    4264                 :       3972 :   rhs[0] = gimple_assign_rhs1 (stmt);
    4265                 :       3972 :   rhs[1] = gimple_assign_rhs2 (stmt);
    4266                 :       3972 :   rhs[2] = rhs[0];
    4267                 :       3972 :   rhs[3] = rhs[1];
    4268                 :      11916 :   for (i = 0; i < 2; i++)
    4269                 :       7944 :     if (TREE_CODE (rhs[i]) == SSA_NAME)
    4270                 :            :       {
    4271                 :       7944 :         rhs[2 + i] = update_ops (rhs[i], code, ops, pidx, loop);
    4272                 :       7944 :         if (rhs[2 + i] == NULL_TREE)
    4273                 :            :           {
    4274                 :       7799 :             if (has_single_use (rhs[i]))
    4275                 :       7799 :               rhs[2 + i] = ops[(*pidx)++]->op;
    4276                 :            :             else
    4277                 :          0 :               rhs[2 + i] = rhs[i];
    4278                 :            :           }
    4279                 :            :       }
    4280                 :       3972 :   if ((rhs[2] != rhs[0] || rhs[3] != rhs[1])
    4281                 :       3764 :       && (rhs[2] != rhs[1] || rhs[3] != rhs[0]))
    4282                 :            :     {
    4283                 :       3764 :       gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    4284                 :       3764 :       var = make_ssa_name (TREE_TYPE (var));
    4285                 :       3764 :       gassign *g = gimple_build_assign (var, gimple_assign_rhs_code (stmt),
    4286                 :            :                                         rhs[2], rhs[3]);
    4287                 :       3764 :       gimple_set_uid (g, gimple_uid (stmt));
    4288                 :       3764 :       gimple_set_visited (g, true);
    4289                 :       3764 :       gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    4290                 :            :     }
    4291                 :            :   return var;
    4292                 :            : }
    4293                 :            : 
    4294                 :            : /* Structure to track the initial value passed to get_ops and
    4295                 :            :    the range in the ops vector for each basic block.  */
    4296                 :            : 
    4297                 :            : struct inter_bb_range_test_entry
    4298                 :            : {
    4299                 :            :   tree op;
    4300                 :            :   unsigned int first_idx, last_idx;
    4301                 :            : };
    4302                 :            : 
    4303                 :            : /* Inter-bb range test optimization.
    4304                 :            : 
    4305                 :            :    Returns TRUE if a gimple conditional is optimized to a true/false,
    4306                 :            :    otherwise return FALSE.
    4307                 :            : 
    4308                 :            :    This indicates to the caller that it should run a CFG cleanup pass
    4309                 :            :    once reassociation is completed.  */
    4310                 :            : 
    4311                 :            : static bool
    4312                 :   12132500 : maybe_optimize_range_tests (gimple *stmt)
    4313                 :            : {
    4314                 :   12132500 :   basic_block first_bb = gimple_bb (stmt);
    4315                 :   12132500 :   basic_block last_bb = first_bb;
    4316                 :   12132500 :   basic_block other_bb = NULL;
    4317                 :   12132500 :   basic_block bb;
    4318                 :   12132500 :   edge_iterator ei;
    4319                 :   12132500 :   edge e;
    4320                 :   12132500 :   auto_vec<operand_entry *> ops;
    4321                 :   12132500 :   auto_vec<inter_bb_range_test_entry> bbinfo;
    4322                 :   12132500 :   bool any_changes = false;
    4323                 :   12132500 :   bool cfg_cleanup_needed = false;
    4324                 :            : 
    4325                 :            :   /* Consider only basic blocks that end with GIMPLE_COND or
    4326                 :            :      a cast statement satisfying final_range_test_p.  All
    4327                 :            :      but the last bb in the first_bb .. last_bb range
    4328                 :            :      should end with GIMPLE_COND.  */
    4329                 :   12132500 :   if (gimple_code (stmt) == GIMPLE_COND)
    4330                 :            :     {
    4331                 :   17460200 :       if (EDGE_COUNT (first_bb->succs) != 2)
    4332                 :            :         return cfg_cleanup_needed;
    4333                 :            :     }
    4334                 :    6804800 :   else if (final_range_test_p (stmt))
    4335                 :      59996 :     other_bb = single_succ (first_bb);
    4336                 :            :   else
    4337                 :            :     return cfg_cleanup_needed;
    4338                 :            : 
    4339                 :    5387680 :   if (stmt_could_throw_p (cfun, stmt))
    4340                 :            :     return cfg_cleanup_needed;
    4341                 :            : 
    4342                 :            :   /* As relative ordering of post-dominator sons isn't fixed,
    4343                 :            :      maybe_optimize_range_tests can be called first on any
    4344                 :            :      bb in the range we want to optimize.  So, start searching
    4345                 :            :      backwards, if first_bb can be set to a predecessor.  */
    4346                 :    5528950 :   while (single_pred_p (first_bb))
    4347                 :            :     {
    4348                 :    3719370 :       basic_block pred_bb = single_pred (first_bb);
    4349                 :    3719370 :       if (!suitable_cond_bb (pred_bb, first_bb, &other_bb, true))
    4350                 :            :         break;
    4351                 :     562479 :       if (!no_side_effect_bb (first_bb))
    4352                 :            :         break;
    4353                 :            :       first_bb = pred_bb;
    4354                 :            :     }
    4355                 :            :   /* If first_bb is last_bb, other_bb hasn't been computed yet.
    4356                 :            :      Before starting forward search in last_bb successors, find
    4357                 :            :      out the other_bb.  */
    4358                 :    5387530 :   if (first_bb == last_bb)
    4359                 :            :     {
    4360                 :    5278860 :       other_bb = NULL;
    4361                 :            :       /* As non-GIMPLE_COND last stmt always terminates the range,
    4362                 :            :          if forward search didn't discover anything, just give up.  */
    4363                 :    5278860 :       if (gimple_code (stmt) != GIMPLE_COND)
    4364                 :            :         return cfg_cleanup_needed;
    4365                 :            :       /* Look at both successors.  Either it ends with a GIMPLE_COND
    4366                 :            :          and satisfies suitable_cond_bb, or ends with a cast and
    4367                 :            :          other_bb is that cast's successor.  */
    4368                 :   14838000 :       FOR_EACH_EDGE (e, ei, first_bb->succs)
    4369                 :   10238800 :         if (!(e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE))
    4370                 :   10238800 :             || e->dest == first_bb)
    4371                 :            :           return cfg_cleanup_needed;
    4372                 :   10015900 :         else if (single_pred_p (e->dest))
    4373                 :            :           {
    4374                 :    6136470 :             stmt = last_stmt (e->dest);
    4375                 :    6136470 :             if (stmt
    4376                 :    5984590 :                 && gimple_code (stmt) == GIMPLE_COND
    4377                 :    8638650 :                 && EDGE_COUNT (e->dest->succs) == 2)
    4378                 :            :               {
    4379                 :    2502180 :                 if (suitable_cond_bb (first_bb, e->dest, &other_bb, true))
    4380                 :            :                   break;
    4381                 :            :                 else
    4382                 :    2100820 :                   other_bb = NULL;
    4383                 :            :               }
    4384                 :    3634290 :             else if (stmt
    4385                 :    3482410 :                      && final_range_test_p (stmt)
    4386                 :    3683460 :                      && find_edge (first_bb, single_succ (e->dest)))
    4387                 :            :               {
    4388                 :      23282 :                 other_bb = single_succ (e->dest);
    4389                 :      23282 :                 if (other_bb == first_bb)
    4390                 :          0 :                   other_bb = NULL;
    4391                 :            :               }
    4392                 :            :           }
    4393                 :    5000560 :       if (other_bb == NULL)
    4394                 :            :         return cfg_cleanup_needed;
    4395                 :            :     }
    4396                 :            :   /* Now do the forward search, moving last_bb to successor bbs
    4397                 :            :      that aren't other_bb.  */
    4398                 :     536538 :   while (EDGE_COUNT (last_bb->succs) == 2)
    4399                 :            :     {
    4400                 :     941487 :       FOR_EACH_EDGE (e, ei, last_bb->succs)
    4401                 :     941487 :         if (e->dest != other_bb)
    4402                 :            :           break;
    4403                 :     531885 :       if (e == NULL)
    4404                 :            :         break;
    4405                 :     531885 :       if (!single_pred_p (e->dest))
    4406                 :            :         break;
    4407                 :     502897 :       if (!suitable_cond_bb (e->dest, last_bb, &other_bb, false))
    4408                 :            :         break;
    4409                 :     416609 :       if (!no_side_effect_bb (e->dest))
    4410                 :            :         break;
    4411                 :       3229 :       last_bb = e->dest;
    4412                 :            :     }
    4413                 :     533309 :   if (first_bb == last_bb)
    4414                 :            :     return cfg_cleanup_needed;
    4415                 :            :   /* Here basic blocks first_bb through last_bb's predecessor
    4416                 :            :      end with GIMPLE_COND, all of them have one of the edges to
    4417                 :            :      other_bb and another to another block in the range,
    4418                 :            :      all blocks except first_bb don't have side-effects and
    4419                 :            :      last_bb ends with either GIMPLE_COND, or cast satisfying
    4420                 :            :      final_range_test_p.  */
    4421                 :     144649 :   for (bb = last_bb; ; bb = single_pred (bb))
    4422                 :            :     {
    4423                 :     255122 :       enum tree_code code;
    4424                 :     255122 :       tree lhs, rhs;
    4425                 :     255122 :       inter_bb_range_test_entry bb_ent;
    4426                 :            : 
    4427                 :     255122 :       bb_ent.op = NULL_TREE;
    4428                 :     255122 :       bb_ent.first_idx = ops.length ();
    4429                 :     255122 :       bb_ent.last_idx = bb_ent.first_idx;
    4430                 :     255122 :       e = find_edge (bb, other_bb);
    4431                 :     255122 :       stmt = last_stmt (bb);
    4432                 :     255122 :       gimple_set_visited (stmt, true);
    4433                 :     255122 :       if (gimple_code (stmt) != GIMPLE_COND)
    4434                 :            :         {
    4435                 :       4653 :           use_operand_p use_p;
    4436                 :       4653 :           gimple *phi;
    4437                 :       4653 :           edge e2;
    4438                 :       4653 :           unsigned int d;
    4439                 :            : 
    4440                 :       4653 :           lhs = gimple_assign_lhs (stmt);
    4441                 :       4653 :           rhs = gimple_assign_rhs1 (stmt);
    4442                 :       4653 :           gcc_assert (bb == last_bb);
    4443                 :            : 
    4444                 :            :           /* stmt is
    4445                 :            :              _123 = (int) _234;
    4446                 :            :              OR
    4447                 :            :              _234 = a_2(D) == 2;
    4448                 :            : 
    4449                 :            :              followed by:
    4450                 :            :              <bb M>:
    4451                 :            :              # _345 = PHI <_123(N), 1(...), 1(...)>
    4452                 :            : 
    4453                 :            :              or 0 instead of 1.  If it is 0, the _234
    4454                 :            :              range test is anded together with all the
    4455                 :            :              other range tests, if it is 1, it is ored with
    4456                 :            :              them.  */
    4457                 :       4653 :           single_imm_use (lhs, &use_p, &phi);
    4458                 :       4653 :           gcc_assert (gimple_code (phi) == GIMPLE_PHI);
    4459                 :       4653 :           e2 = find_edge (first_bb, other_bb);
    4460                 :       4653 :           d = e2->dest_idx;
    4461                 :       4653 :           gcc_assert (gimple_phi_arg_def (phi, e->dest_idx) == lhs);
    4462                 :       4653 :           if (integer_zerop (gimple_phi_arg_def (phi, d)))
    4463                 :            :             code = BIT_AND_EXPR;
    4464                 :            :           else
    4465                 :            :             {
    4466                 :       2869 :               gcc_checking_assert (integer_onep (gimple_phi_arg_def (phi, d)));
    4467                 :            :               code = BIT_IOR_EXPR;
    4468                 :            :             }
    4469                 :            : 
    4470                 :            :           /* If _234 SSA_NAME_DEF_STMT is
    4471                 :            :              _234 = _567 | _789;
    4472                 :            :              (or &, corresponding to 1/0 in the phi arguments,
    4473                 :            :              push into ops the individual range test arguments
    4474                 :            :              of the bitwise or resp. and, recursively.  */
    4475                 :       4653 :           if (TREE_CODE (rhs) == SSA_NAME
    4476                 :       4649 :               && (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
    4477                 :            :                   != tcc_comparison)
    4478                 :       2558 :               && !get_ops (rhs, code, &ops,
    4479                 :            :                         loop_containing_stmt (stmt))
    4480                 :       7145 :               && has_single_use (rhs))
    4481                 :            :             {
    4482                 :            :               /* Otherwise, push the _234 range test itself.  */
    4483                 :       2458 :               operand_entry *oe = operand_entry_pool.allocate ();
    4484                 :            : 
    4485                 :       2458 :               oe->op = rhs;
    4486                 :       2458 :               oe->rank = code;
    4487                 :       2458 :               oe->id = 0;
    4488                 :       2458 :               oe->count = 1;
    4489                 :       2458 :               oe->stmt_to_insert = NULL;
    4490                 :       2458 :               ops.safe_push (oe);
    4491                 :       2458 :               bb_ent.last_idx++;
    4492                 :       2458 :               bb_ent.op = rhs;
    4493                 :            :             }
    4494                 :       2195 :           else if (is_gimple_assign (stmt)
    4495                 :       2195 :                    && (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
    4496                 :            :                        == tcc_comparison)
    4497                 :       2095 :                    && !get_ops (lhs, code, &ops,
    4498                 :            :                                 loop_containing_stmt (stmt))
    4499                 :       4290 :                    && has_single_use (lhs))
    4500                 :            :             {
    4501                 :       2095 :               operand_entry *oe = operand_entry_pool.allocate ();
    4502                 :       2095 :               oe->op = lhs;
    4503                 :       2095 :               oe->rank = code;
    4504                 :       2095 :               oe->id = 0;
    4505                 :       2095 :               oe->count = 1;
    4506                 :       2095 :               ops.safe_push (oe);
    4507                 :       2095 :               bb_ent.last_idx++;
    4508                 :       2095 :               bb_ent.op = lhs;
    4509                 :            :             }
    4510                 :            :           else
    4511                 :            :             {
    4512                 :        100 :               bb_ent.last_idx = ops.length ();
    4513                 :        100 :               bb_ent.op = rhs;
    4514                 :            :             }
    4515                 :       4653 :           bbinfo.safe_push (bb_ent);
    4516                 :       4653 :           continue;
    4517                 :            :         }
    4518                 :            :       /* Otherwise stmt is GIMPLE_COND.  */
    4519                 :     250469 :       code = gimple_cond_code (stmt);
    4520                 :     250469 :       lhs = gimple_cond_lhs (stmt);
    4521                 :     250469 :       rhs = gimple_cond_rhs (stmt);
    4522                 :     250469 :       if (TREE_CODE (lhs) == SSA_NAME
    4523                 :     249852 :           && INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    4524                 :     461274 :           && ((code != EQ_EXPR && code != NE_EXPR)
    4525                 :     173603 :               || rhs != boolean_false_node
    4526                 :            :                  /* Either push into ops the individual bitwise
    4527                 :            :                     or resp. and operands, depending on which
    4528                 :            :                     edge is other_bb.  */
    4529                 :      49478 :               || !get_ops (lhs, (((e->flags & EDGE_TRUE_VALUE) == 0)
    4530                 :      49478 :                                  ^ (code == EQ_EXPR))
    4531                 :            :                                 ? BIT_AND_EXPR : BIT_IOR_EXPR, &ops,
    4532                 :            :                            loop_containing_stmt (stmt))))
    4533                 :            :         {
    4534                 :            :           /* Or push the GIMPLE_COND stmt itself.  */
    4535                 :     198818 :           operand_entry *oe = operand_entry_pool.allocate ();
    4536                 :            : 
    4537                 :     198818 :           oe->op = NULL;
    4538                 :     397636 :           oe->rank = (e->flags & EDGE_TRUE_VALUE)
    4539                 :     198818 :                      ? BIT_IOR_EXPR : BIT_AND_EXPR;
    4540                 :            :           /* oe->op = NULL signs that there is no SSA_NAME
    4541                 :            :              for the range test, and oe->id instead is the
    4542                 :            :              basic block number, at which's end the GIMPLE_COND
    4543                 :            :              is.  */
    4544                 :     198818 :           oe->id = bb->index;
    4545                 :     198818 :           oe->count = 1;
    4546                 :     198818 :           oe->stmt_to_insert = NULL;
    4547                 :     198818 :           ops.safe_push (oe);
    4548                 :     198818 :           bb_ent.op = NULL;
    4549                 :     198818 :           bb_ent.last_idx++;
    4550                 :            :         }
    4551                 :      70026 :       else if (ops.length () > bb_ent.first_idx)
    4552                 :            :         {
    4553                 :      11951 :           bb_ent.op = lhs;
    4554                 :      11951 :           bb_ent.last_idx = ops.length ();
    4555                 :            :         }
    4556                 :     250469 :       bbinfo.safe_push (bb_ent);
    4557                 :     250469 :       if (bb == first_bb)
    4558                 :            :         break;
    4559                 :     144649 :     }
    4560                 :     110473 :   if (ops.length () > 1)
    4561                 :      89529 :     any_changes = optimize_range_tests (ERROR_MARK, &ops, first_bb);
    4562                 :      89529 :   if (any_changes)
    4563                 :            :     {
    4564                 :            :       unsigned int idx, max_idx = 0;
    4565                 :            :       /* update_ops relies on has_single_use predicates returning the
    4566                 :            :          same values as it did during get_ops earlier.  Additionally it
    4567                 :            :          never removes statements, only adds new ones and it should walk
    4568                 :            :          from the single imm use and check the predicate already before
    4569                 :            :          making those changes.
    4570                 :            :          On the other side, the handling of GIMPLE_COND directly can turn
    4571                 :            :          previously multiply used SSA_NAMEs into single use SSA_NAMEs, so
    4572                 :            :          it needs to be done in a separate loop afterwards.  */
    4573                 :      13791 :       for (bb = last_bb, idx = 0; ; bb = single_pred (bb), idx++)
    4574                 :            :         {
    4575                 :      23094 :           if (bbinfo[idx].first_idx < bbinfo[idx].last_idx
    4576                 :      23094 :               && bbinfo[idx].op != NULL_TREE)
    4577                 :            :             {
    4578                 :       4300 :               tree new_op;
    4579                 :            : 
    4580                 :       4300 :               max_idx = idx;
    4581                 :       4300 :               stmt = last_stmt (bb);
    4582                 :       4300 :               new_op = update_ops (bbinfo[idx].op,
    4583                 :            :                                    (enum tree_code)
    4584                 :       4300 :                                    ops[bbinfo[idx].first_idx]->rank,
    4585                 :       4300 :                                    ops, &bbinfo[idx].first_idx,
    4586                 :            :                                    loop_containing_stmt (stmt));
    4587                 :       4300 :               if (new_op == NULL_TREE)
    4588                 :            :                 {
    4589                 :        473 :                   gcc_assert (bb == last_bb);
    4590                 :        473 :                   new_op = ops[bbinfo[idx].first_idx++]->op;
    4591                 :            :                 }
    4592                 :       4300 :               if (bbinfo[idx].op != new_op)
    4593                 :            :                 {
    4594                 :       4078 :                   imm_use_iterator iter;
    4595                 :       4078 :                   use_operand_p use_p;
    4596                 :       4078 :                   gimple *use_stmt, *cast_or_tcc_cmp_stmt = NULL;
    4597                 :            : 
    4598                 :       8181 :                   FOR_EACH_IMM_USE_STMT (use_stmt, iter, bbinfo[idx].op)
    4599                 :       4103 :                     if (is_gimple_debug (use_stmt))
    4600                 :         25 :                       continue;
    4601                 :       4078 :                     else if (gimple_code (use_stmt) == GIMPLE_COND
    4602                 :       4078 :                              || gimple_code (use_stmt) == GIMPLE_PHI)
    4603                 :      11847 :                       FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
    4604                 :       3949 :                         SET_USE (use_p, new_op);
    4605                 :        129 :                     else if ((is_gimple_assign (use_stmt)
    4606                 :        129 :                               && (TREE_CODE_CLASS
    4607                 :            :                                   (gimple_assign_rhs_code (use_stmt))
    4608                 :            :                                   == tcc_comparison)))
    4609                 :            :                       cast_or_tcc_cmp_stmt = use_stmt;
    4610                 :        129 :                     else if (gimple_assign_cast_p (use_stmt))
    4611                 :            :                       cast_or_tcc_cmp_stmt = use_stmt;
    4612                 :            :                     else
    4613                 :          0 :                       gcc_unreachable ();
    4614                 :            : 
    4615                 :       4078 :                   if (cast_or_tcc_cmp_stmt)
    4616                 :            :                     {
    4617                 :        129 :                       gcc_assert (bb == last_bb);
    4618                 :        129 :                       tree lhs = gimple_assign_lhs (cast_or_tcc_cmp_stmt);
    4619                 :        129 :                       tree new_lhs = make_ssa_name (TREE_TYPE (lhs));
    4620                 :        129 :                       enum tree_code rhs_code
    4621                 :        129 :                         = gimple_assign_cast_p (cast_or_tcc_cmp_stmt)
    4622                 :        129 :                         ? gimple_assign_rhs_code (cast_or_tcc_cmp_stmt)
    4623                 :        129 :                         : CONVERT_EXPR;
    4624                 :        129 :                       gassign *g;
    4625                 :        129 :                       if (is_gimple_min_invariant (new_op))
    4626                 :            :                         {
    4627                 :         48 :                           new_op = fold_convert (TREE_TYPE (lhs), new_op);
    4628                 :         48 :                           g = gimple_build_assign (new_lhs, new_op);
    4629                 :            :                         }
    4630                 :            :                       else
    4631                 :         81 :                         g = gimple_build_assign (new_lhs, rhs_code, new_op);
    4632                 :        129 :                       gimple_stmt_iterator gsi
    4633                 :        129 :                         = gsi_for_stmt (cast_or_tcc_cmp_stmt);
    4634                 :        129 :                       gimple_set_uid (g, gimple_uid (cast_or_tcc_cmp_stmt));
    4635                 :        129 :                       gimple_set_visited (g, true);
    4636                 :        129 :                       gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    4637                 :        263 :                       FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
    4638                 :        134 :                         if (is_gimple_debug (use_stmt))
    4639                 :          5 :                           continue;
    4640                 :        129 :                         else if (gimple_code (use_stmt) == GIMPLE_COND
    4641                 :        129 :                                  || gimple_code (use_stmt) == GIMPLE_PHI)
    4642                 :        387 :                           FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
    4643                 :        129 :                             SET_USE (use_p, new_lhs);
    4644                 :            :                         else
    4645                 :          0 :                           gcc_unreachable ();
    4646                 :            :                     }
    4647                 :            :                 }
    4648                 :            :             }
    4649                 :      23094 :           if (bb == first_bb)
    4650                 :            :             break;
    4651                 :      13791 :         }
    4652                 :      13791 :       for (bb = last_bb, idx = 0; ; bb = single_pred (bb), idx++)
    4653                 :            :         {
    4654                 :      23094 :           if (bbinfo[idx].first_idx < bbinfo[idx].last_idx
    4655                 :      18666 :               && bbinfo[idx].op == NULL_TREE
    4656                 :      41760 :               && ops[bbinfo[idx].first_idx]->op != NULL_TREE)
    4657                 :            :             {
    4658                 :      16983 :               gcond *cond_stmt = as_a <gcond *> (last_stmt (bb));
    4659                 :            : 
    4660                 :      16983 :               if (idx > max_idx)
    4661                 :            :                 max_idx = idx;
    4662                 :            : 
    4663                 :            :               /* If we collapse the conditional to a true/false
    4664                 :            :                  condition, then bubble that knowledge up to our caller.  */
    4665                 :      16983 :               if (integer_zerop (ops[bbinfo[idx].first_idx]->op))
    4666                 :            :                 {
    4667                 :       5051 :                   gimple_cond_make_false (cond_stmt);
    4668                 :       5051 :                   cfg_cleanup_needed = true;
    4669                 :            :                 }
    4670                 :      11932 :               else if (integer_onep (ops[bbinfo[idx].first_idx]->op))
    4671                 :            :                 {
    4672                 :       4069 :                   gimple_cond_make_true (cond_stmt);
    4673                 :       4069 :                   cfg_cleanup_needed = true;
    4674                 :            :                 }
    4675                 :            :               else
    4676                 :            :                 {
    4677                 :       7863 :                   gimple_cond_set_code (cond_stmt, NE_EXPR);
    4678                 :      15726 :                   gimple_cond_set_lhs (cond_stmt,
    4679                 :       7863 :                                        ops[bbinfo[idx].first_idx]->op);
    4680                 :       7863 :                   gimple_cond_set_rhs (cond_stmt, boolean_false_node);
    4681                 :            :                 }
    4682                 :      16983 :               update_stmt (cond_stmt);
    4683                 :            :             }
    4684                 :      23094 :           if (bb == first_bb)
    4685                 :            :             break;
    4686                 :      13791 :         }
    4687                 :            : 
    4688                 :            :       /* The above changes could result in basic blocks after the first
    4689                 :            :          modified one, up to and including last_bb, to be executed even if
    4690                 :            :          they would not be in the original program.  If the value ranges of
    4691                 :            :          assignment lhs' in those bbs were dependent on the conditions
    4692                 :            :          guarding those basic blocks which now can change, the VRs might
    4693                 :            :          be incorrect.  As no_side_effect_bb should ensure those SSA_NAMEs
    4694                 :            :          are only used within the same bb, it should be not a big deal if
    4695                 :            :          we just reset all the VRs in those bbs.  See PR68671.  */
    4696                 :      22526 :       for (bb = last_bb, idx = 0; idx < max_idx; bb = single_pred (bb), idx++)
    4697                 :      13223 :         reset_flow_sensitive_info_in_bb (bb);
    4698                 :            :     }
    4699                 :            :   return cfg_cleanup_needed;
    4700                 :            : }
    4701                 :            : 
    4702                 :            : /* Return true if OPERAND is defined by a PHI node which uses the LHS
    4703                 :            :    of STMT in it's operands.  This is also known as a "destructive
    4704                 :            :    update" operation.  */
    4705                 :            : 
    4706                 :            : static bool
    4707                 :     168809 : is_phi_for_stmt (gimple *stmt, tree operand)
    4708                 :            : {
    4709                 :     168809 :   gimple *def_stmt;
    4710                 :     168809 :   gphi *def_phi;
    4711                 :     168809 :   tree lhs;
    4712                 :     168809 :   use_operand_p arg_p;
    4713                 :     168809 :   ssa_op_iter i;
    4714                 :            : 
    4715                 :     168809 :   if (TREE_CODE (operand) != SSA_NAME)
    4716                 :            :     return false;
    4717                 :            : 
    4718                 :     129310 :   lhs = gimple_assign_lhs (stmt);
    4719                 :            : 
    4720                 :     129310 :   def_stmt = SSA_NAME_DEF_STMT (operand);
    4721                 :     129310 :   def_phi = dyn_cast <gphi *> (def_stmt);
    4722                 :       5716 :   if (!def_phi)
    4723                 :            :     return false;
    4724                 :            : 
    4725                 :      17975 :   FOR_EACH_PHI_ARG (arg_p, def_phi, i, SSA_OP_USE)
    4726                 :      12566 :     if (lhs == USE_FROM_PTR (arg_p))
    4727                 :            :       return true;
    4728                 :            :   return false;
    4729                 :            : }
    4730                 :            : 
    4731                 :            : /* Remove def stmt of VAR if VAR has zero uses and recurse
    4732                 :            :    on rhs1 operand if so.  */
    4733                 :            : 
    4734                 :            : static void
    4735                 :      45975 : remove_visited_stmt_chain (tree var)
    4736                 :            : {
    4737                 :      87799 :   gimple *stmt;
    4738                 :      87799 :   gimple_stmt_iterator gsi;
    4739                 :            : 
    4740                 :     129623 :   while (1)
    4741                 :            :     {
    4742                 :      87799 :       if (TREE_CODE (var) != SSA_NAME || !has_zero_uses (var))
    4743                 :            :         return;
    4744                 :      48549 :       stmt = SSA_NAME_DEF_STMT (var);
    4745                 :      48549 :       if (is_gimple_assign (stmt) && gimple_visited_p (stmt))
    4746                 :            :         {
    4747                 :      41824 :           var = gimple_assign_rhs1 (stmt);
    4748                 :      41824 :           gsi = gsi_for_stmt (stmt);
    4749                 :      41824 :           reassoc_remove_stmt (&gsi);
    4750                 :      41824 :           release_defs (stmt);
    4751                 :            :         }
    4752                 :            :       else
    4753                 :            :         return;
    4754                 :            :     }
    4755                 :            : }
    4756                 :            : 
    4757                 :            : /* This function checks three consequtive operands in
    4758                 :            :    passed operands vector OPS starting from OPINDEX and
    4759                 :            :    swaps two operands if it is profitable for binary operation
    4760                 :            :    consuming OPINDEX + 1 abnd OPINDEX + 2 operands.
    4761                 :            : 
    4762                 :            :    We pair ops with the same rank if possible.
    4763                 :            : 
    4764                 :            :    The alternative we try is to see if STMT is a destructive
    4765                 :            :    update style statement, which is like:
    4766                 :            :    b = phi (a, ...)
    4767                 :            :    a = c + b;
    4768                 :            :    In that case, we want to use the destructive update form to
    4769                 :            :    expose the possible vectorizer sum reduction opportunity.
    4770                 :            :    In that case, the third operand will be the phi node. This
    4771                 :            :    check is not performed if STMT is null.
    4772                 :            : 
    4773                 :            :    We could, of course, try to be better as noted above, and do a
    4774                 :            :    lot of work to try to find these opportunities in >3 operand
    4775                 :            :    cases, but it is unlikely to be worth it.  */
    4776                 :            : 
    4777                 :            : static void
    4778                 :     104035 : swap_ops_for_binary_stmt (vec<operand_entry *> ops,
    4779                 :            :                           unsigned int opindex, gimple *stmt)
    4780                 :            : {
    4781                 :     104035 :   operand_entry *oe1, *oe2, *oe3;
    4782                 :            : 
    4783                 :     104035 :   oe1 = ops[opindex];
    4784                 :     104035 :   oe2 = ops[opindex + 1];
    4785                 :     104035 :   oe3 = ops[opindex + 2];
    4786                 :            : 
    4787                 :     104035 :   if ((oe1->rank == oe2->rank
    4788                 :      25401 :        && oe2->rank != oe3->rank)
    4789                 :     110685 :       || (stmt && is_phi_for_stmt (stmt, oe3->op)
    4790                 :        103 :           && !is_phi_for_stmt (stmt, oe1->op)
    4791                 :        103 :           && !is_phi_for_stmt (stmt, oe2->op)))
    4792                 :      18854 :     std::swap (*oe1, *oe3);
    4793                 :      85181 :   else if ((oe1->rank == oe3->rank
    4794                 :       6658 :             && oe2->rank != oe3->rank)
    4795                 :      91831 :            || (stmt && is_phi_for_stmt (stmt, oe2->op)
    4796                 :        204 :                && !is_phi_for_stmt (stmt, oe1->op)
    4797                 :        204 :                && !is_phi_for_stmt (stmt, oe3->op)))
    4798                 :        212 :     std::swap (*oe1, *oe2);
    4799                 :     104035 : }
    4800                 :            : 
    4801                 :            : /* If definition of RHS1 or RHS2 dominates STMT, return the later of those
    4802                 :            :    two definitions, otherwise return STMT.  */
    4803                 :            : 
    4804                 :            : static inline gimple *
    4805                 :     581719 : find_insert_point (gimple *stmt, tree rhs1, tree rhs2)
    4806                 :            : {
    4807                 :     581719 :   if (TREE_CODE (rhs1) == SSA_NAME
    4808                 :     581719 :       && reassoc_stmt_dominates_stmt_p (stmt, SSA_NAME_DEF_STMT (rhs1)))
    4809                 :       9064 :     stmt = SSA_NAME_DEF_STMT (rhs1);
    4810                 :     581719 :   if (TREE_CODE (rhs2) == SSA_NAME
    4811                 :     581719 :       && reassoc_stmt_dominates_stmt_p (stmt, SSA_NAME_DEF_STMT (rhs2)))
    4812                 :      10500 :     stmt = SSA_NAME_DEF_STMT (rhs2);
    4813                 :     581719 :   return stmt;
    4814                 :            : }
    4815                 :            : 
    4816                 :            : /* If the stmt that defines operand has to be inserted, insert it
    4817                 :            :    before the use.  */
    4818                 :            : static void
    4819                 :         79 : insert_stmt_before_use (gimple *stmt, gimple *stmt_to_insert)
    4820                 :            : {
    4821                 :         79 :   gcc_assert (is_gimple_assign (stmt_to_insert));
    4822                 :         79 :   tree rhs1 = gimple_assign_rhs1 (stmt_to_insert);
    4823                 :         79 :   tree rhs2 = gimple_assign_rhs2 (stmt_to_insert);
    4824                 :         79 :   gimple *insert_point = find_insert_point (stmt, rhs1, rhs2);
    4825                 :         79 :   gimple_stmt_iterator gsi = gsi_for_stmt (insert_point);
    4826                 :         79 :   gimple_set_uid (stmt_to_insert, gimple_uid (insert_point));
    4827                 :            : 
    4828                 :            :   /* If the insert point is not stmt, then insert_point would be
    4829                 :            :      the point where operand rhs1 or rhs2 is defined. In this case,
    4830                 :            :      stmt_to_insert has to be inserted afterwards. This would
    4831                 :            :      only happen when the stmt insertion point is flexible. */
    4832                 :         79 :   if (stmt == insert_point)
    4833                 :         78 :     gsi_insert_before (&gsi, stmt_to_insert, GSI_NEW_STMT);
    4834                 :            :   else
    4835                 :          1 :     insert_stmt_after (stmt_to_insert, insert_point);
    4836                 :         79 : }
    4837                 :            : 
    4838                 :            : 
    4839                 :            : /* Recursively rewrite our linearized statements so that the operators
    4840                 :            :    match those in OPS[OPINDEX], putting the computation in rank
    4841                 :            :    order.  Return new lhs.
    4842                 :            :    CHANGED is true if we shouldn't reuse the lhs SSA_NAME both in
    4843                 :            :    the current stmt and during recursive invocations.
    4844                 :            :    NEXT_CHANGED is true if we shouldn't reuse the lhs SSA_NAME in
    4845                 :            :    recursive invocations.  */
    4846                 :            : 
    4847                 :            : static tree
    4848                 :    2746660 : rewrite_expr_tree (gimple *stmt, unsigned int opindex,
    4849                 :            :                    vec<operand_entry *> ops, bool changed, bool next_changed)
    4850                 :            : {
    4851                 :    2746660 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    4852                 :    2746660 :   tree rhs2 = gimple_assign_rhs2 (stmt);
    4853                 :    2746660 :   tree lhs = gimple_assign_lhs (stmt);
    4854                 :    2746660 :   operand_entry *oe;
    4855                 :            : 
    4856                 :            :   /* The final recursion case for this function is that you have
    4857                 :            :      exactly two operations left.
    4858                 :            :      If we had exactly one op in the entire list to start with, we
    4859                 :            :      would have never called this function, and the tail recursion
    4860                 :            :      rewrites them one at a time.  */
    4861                 :    5493330 :   if (opindex + 2 == ops.length ())
    4862                 :            :     {
    4863                 :    2609420 :       operand_entry *oe1, *oe2;
    4864                 :            : 
    4865                 :    2609420 :       oe1 = ops[opindex];
    4866                 :    2609420 :       oe2 = ops[opindex + 1];
    4867                 :            : 
    4868                 :    2609420 :       if (rhs1 != oe1->op || rhs2 != oe2->op)
    4869                 :            :         {
    4870                 :     516378 :           gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    4871                 :     516378 :           unsigned int uid = gimple_uid (stmt);
    4872                 :            : 
    4873                 :     516378 :           if (dump_file && (dump_flags & TDF_DETAILS))
    4874                 :            :             {
    4875                 :         28 :               fprintf (dump_file, "Transforming ");
    4876                 :         28 :               print_gimple_stmt (dump_file, stmt, 0);
    4877                 :            :             }
    4878                 :            : 
    4879                 :            :           /* If the stmt that defines operand has to be inserted, insert it
    4880                 :            :              before the use.  */
    4881                 :     516378 :           if (oe1->stmt_to_insert)
    4882                 :         25 :             insert_stmt_before_use (stmt, oe1->stmt_to_insert);
    4883                 :     516378 :           if (oe2->stmt_to_insert)
    4884                 :         52 :             insert_stmt_before_use (stmt, oe2->stmt_to_insert);
    4885                 :            :           /* Even when changed is false, reassociation could have e.g. removed
    4886                 :            :              some redundant operations, so unless we are just swapping the
    4887                 :            :              arguments or unless there is no change at all (then we just
    4888                 :            :              return lhs), force creation of a new SSA_NAME.  */
    4889                 :     516378 :           if (changed || ((rhs1 != oe2->op || rhs2 != oe1->op) && opindex))
    4890                 :            :             {
    4891                 :      53052 :               gimple *insert_point
    4892                 :      53052 :                 = find_insert_point (stmt, oe1->op, oe2->op);
    4893                 :      53052 :               lhs = make_ssa_name (TREE_TYPE (lhs));
    4894                 :      53052 :               stmt
    4895                 :      53052 :                 = gimple_build_assign (lhs, gimple_assign_rhs_code (stmt),
    4896                 :            :                                        oe1->op, oe2->op);
    4897                 :      53052 :               gimple_set_uid (stmt, uid);
    4898                 :      53052 :               gimple_set_visited (stmt, true);
    4899                 :      53052 :               if (insert_point == gsi_stmt (gsi))
    4900                 :      39730 :                 gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
    4901                 :            :               else
    4902                 :      13322 :                 insert_stmt_after (stmt, insert_point);
    4903                 :            :             }
    4904                 :            :           else
    4905                 :            :             {
    4906                 :     463326 :               gcc_checking_assert (find_insert_point (stmt, oe1->op, oe2->op)
    4907                 :            :                                    == stmt);
    4908                 :     463326 :               gimple_assign_set_rhs1 (stmt, oe1->op);
    4909                 :     463326 :               gimple_assign_set_rhs2 (stmt, oe2->op);
    4910                 :     463326 :               update_stmt (stmt);
    4911                 :            :             }
    4912                 :            : 
    4913                 :     516378 :           if (rhs1 != oe1->op && rhs1 != oe2->op)
    4914                 :      36575 :             remove_visited_stmt_chain (rhs1);
    4915                 :            : 
    4916                 :     516378 :           if (dump_file && (dump_flags & TDF_DETAILS))
    4917                 :            :             {
    4918                 :         28 :               fprintf (dump_file, " into ");
    4919                 :         28 :               print_gimple_stmt (dump_file, stmt, 0);
    4920                 :            :             }
    4921                 :            :         }
    4922                 :    2609420 :       return lhs;
    4923                 :            :     }
    4924                 :            : 
    4925                 :            :   /* If we hit here, we should have 3 or more ops left.  */
    4926                 :     137247 :   gcc_assert (opindex + 2 < ops.length ());
    4927                 :            : 
    4928                 :            :   /* Rewrite the next operator.  */
    4929                 :     137247 :   oe = ops[opindex];
    4930                 :            : 
    4931                 :            :   /* If the stmt that defines operand has to be inserted, insert it
    4932                 :            :      before the use.  */
    4933                 :     137247 :   if (oe->stmt_to_insert)
    4934                 :          2 :     insert_stmt_before_use (stmt, oe->stmt_to_insert);
    4935                 :            : 
    4936                 :            :   /* Recurse on the LHS of the binary operator, which is guaranteed to
    4937                 :            :      be the non-leaf side.  */
    4938                 :     137247 :   tree new_rhs1
    4939                 :     137247 :     = rewrite_expr_tree (SSA_NAME_DEF_STMT (rhs1), opindex + 1, ops,
    4940                 :     137247 :                          changed || oe->op != rhs2 || next_changed,
    4941                 :            :                          false);
    4942                 :            : 
    4943                 :     137247 :   if (oe->op != rhs2 || new_rhs1 != rhs1)
    4944                 :            :     {
    4945                 :      65262 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4946                 :            :         {
    4947                 :          6 :           fprintf (dump_file, "Transforming ");
    4948                 :          6 :           print_gimple_stmt (dump_file, stmt, 0);
    4949                 :            :         }
    4950                 :            : 
    4951                 :            :       /* If changed is false, this is either opindex == 0
    4952                 :            :          or all outer rhs2's were equal to corresponding oe->op,
    4953                 :            :          and powi_result is NULL.
    4954                 :            :          That means lhs is equivalent before and after reassociation.
    4955                 :            :          Otherwise ensure the old lhs SSA_NAME is not reused and
    4956                 :            :          create a new stmt as well, so that any debug stmts will be
    4957                 :            :          properly adjusted.  */
    4958                 :      65262 :       if (changed)
    4959                 :            :         {
    4960                 :      11891 :           gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    4961                 :      11891 :           unsigned int uid = gimple_uid (stmt);
    4962                 :      11891 :           gimple *insert_point = find_insert_point (stmt, new_rhs1, oe->op);
    4963                 :            : 
    4964                 :      11891 :           lhs = make_ssa_name (TREE_TYPE (lhs));
    4965                 :      11891 :           stmt = gimple_build_assign (lhs, gimple_assign_rhs_code (stmt),
    4966                 :            :                                       new_rhs1, oe->op);
    4967                 :      11891 :           gimple_set_uid (stmt, uid);
    4968                 :      11891 :           gimple_set_visited (stmt, true);
    4969                 :      11891 :           if (insert_point == gsi_stmt (gsi))
    4970                 :       6598 :             gsi_insert_before (&gsi, stmt, GSI_SAME_STMT);
    4971                 :            :           else
    4972                 :       5293 :             insert_stmt_after (stmt, insert_point);
    4973                 :            :         }
    4974                 :            :       else
    4975                 :            :         {
    4976                 :      53371 :           gcc_checking_assert (find_insert_point (stmt, new_rhs1, oe->op)
    4977                 :            :                                == stmt);
    4978                 :      53371 :           gimple_assign_set_rhs1 (stmt, new_rhs1);
    4979                 :      53371 :           gimple_assign_set_rhs2 (stmt, oe->op);
    4980                 :      53371 :           update_stmt (stmt);
    4981                 :            :         }
    4982                 :            : 
    4983                 :      65262 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4984                 :            :         {
    4985                 :          6 :           fprintf (dump_file, " into ");
    4986                 :          6 :           print_gimple_stmt (dump_file, stmt, 0);
    4987                 :            :         }
    4988                 :            :     }
    4989                 :            :   return lhs;
    4990                 :            : }
    4991                 :            : 
    4992                 :            : /* Find out how many cycles we need to compute statements chain.
    4993                 :            :    OPS_NUM holds number os statements in a chain.  CPU_WIDTH is a
    4994                 :            :    maximum number of independent statements we may execute per cycle.  */
    4995                 :            : 
    4996                 :            : static int
    4997                 :       1994 : get_required_cycles (int ops_num, int cpu_width)
    4998                 :            : {
    4999                 :       1994 :   int res;
    5000                 :       1994 :   int elog;
    5001                 :       1994 :   unsigned int rest;
    5002                 :            : 
    5003                 :            :   /* While we have more than 2 * cpu_width operands
    5004                 :            :      we may reduce number of operands by cpu_width
    5005                 :            :      per cycle.  */
    5006                 :       1994 :   res = ops_num / (2 * cpu_width);
    5007                 :            : 
    5008                 :            :   /* Remained operands count may be reduced twice per cycle
    5009                 :            :      until we have only one operand.  */
    5010                 :       1994 :   rest = (unsigned)(ops_num - res * cpu_width);
    5011                 :          0 :   elog = exact_log2 (rest);
    5012                 :       1133 :   if (elog >= 0)
    5013                 :       1133 :     res += elog;
    5014                 :            :   else
    5015                 :       1722 :     res += floor_log2 (rest) + 1;
    5016                 :            : 
    5017                 :       1994 :   return res;
    5018                 :            : }
    5019                 :            : 
    5020                 :            : /* Returns an optimal number of registers to use for computation of
    5021                 :            :    given statements.  */
    5022                 :            : 
    5023                 :            : static int
    5024                 :       8075 : get_reassociation_width (int ops_num, enum tree_code opc,
    5025                 :            :                          machine_mode mode)
    5026                 :            : {
    5027                 :       8075 :   int param_width = param_tree_reassoc_width;
    5028                 :       8075 :   int width;
    5029                 :       8075 :   int width_min;
    5030                 :       8075 :   int cycles_best;
    5031                 :            : 
    5032                 :       8075 :   if (param_width > 0)
    5033                 :            :     width = param_width;
    5034                 :            :   else
    5035                 :       8039 :     width = targetm.sched.reassociation_width (opc, mode);
    5036                 :            : 
    5037                 :       8075 :   if (width == 1)
    5038                 :            :     return width;
    5039                 :            : 
    5040                 :            :   /* Get the minimal time required for sequence computation.  */
    5041                 :        658 :   cycles_best = get_required_cycles (ops_num, width);
    5042                 :            : 
    5043                 :            :   /* Check if we may use less width and still compute sequence for
    5044                 :            :      the same time.  It will allow us to reduce registers usage.
    5045                 :            :      get_required_cycles is monotonically increasing with lower width
    5046                 :            :      so we can perform a binary search for the minimal width that still
    5047                 :            :      results in the optimal cycle count.  */
    5048                 :        658 :   width_min = 1;
    5049                 :       1336 :   while (width > width_min)
    5050                 :            :     {
    5051                 :       1336 :       int width_mid = (width + width_min) / 2;
    5052                 :            : 
    5053                 :       2672 :       if (get_required_cycles (ops_num, width_mid) == cycles_best)
    5054                 :            :         width = width_mid;
    5055                 :        752 :       else if (width_min < width_mid)
    5056                 :            :         width_min = width_mid;
    5057                 :            :       else
    5058                 :            :         break;
    5059                 :            :     }
    5060                 :            : 
    5061                 :            :   return width;
    5062                 :            : }
    5063                 :            : 
    5064                 :            : /* Recursively rewrite our linearized statements so that the operators
    5065                 :            :    match those in OPS[OPINDEX], putting the computation in rank
    5066                 :            :    order and trying to allow operations to be executed in
    5067                 :            :    parallel.  */
    5068                 :            : 
    5069                 :            : static void
    5070                 :        658 : rewrite_expr_tree_parallel (gassign *stmt, int width,
    5071                 :            :                             vec<operand_entry *> ops)
    5072                 :            : {
    5073                 :        658 :   enum tree_code opcode = gimple_assign_rhs_code (stmt);
    5074                 :        658 :   int op_num = ops.length ();
    5075                 :        658 :   gcc_assert (op_num > 0);
    5076                 :        658 :   int stmt_num = op_num - 1;
    5077                 :        658 :   gimple **stmts = XALLOCAVEC (gimple *, stmt_num);
    5078                 :        658 :   int op_index = op_num - 1;
    5079                 :        658 :   int stmt_index = 0;
    5080                 :        658 :   int ready_stmts_end = 0;
    5081                 :        658 :   int i = 0;
    5082                 :        658 :   gimple *stmt1 = NULL, *stmt2 = NULL;
    5083                 :        658 :   tree last_rhs1 = gimple_assign_rhs1 (stmt);
    5084                 :            : 
    5085                 :            :   /* We start expression rewriting from the top statements.
    5086                 :            :      So, in this loop we create a full list of statements
    5087                 :            :      we will work with.  */
    5088                 :        658 :   stmts[stmt_num - 1] = stmt;
    5089                 :       3258 :   for (i = stmt_num - 2; i >= 0; i--)
    5090                 :       2600 :     stmts[i] = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmts[i+1]));
    5091                 :            : 
    5092                 :       3916 :   for (i = 0; i < stmt_num; i++)
    5093                 :            :     {
    5094                 :       3258 :       tree op1, op2;
    5095                 :            : 
    5096                 :            :       /* Determine whether we should use results of
    5097                 :            :          already handled statements or not.  */
    5098                 :       3258 :       if (ready_stmts_end == 0
    5099                 :       3019 :           && (i - stmt_index >= width || op_index < 1))
    5100                 :       1251 :         ready_stmts_end = i;
    5101                 :            : 
    5102                 :            :       /* Now we choose operands for the next statement.  Non zero
    5103                 :            :          value in ready_stmts_end means here that we should use
    5104                 :            :          the result of already generated statements as new operand.  */
    5105                 :       3258 :       if (ready_stmts_end > 0)
    5106                 :            :         {
    5107                 :       1490 :           op1 = gimple_assign_lhs (stmts[stmt_index++]);
    5108                 :       1490 :           if (ready_stmts_end > stmt_index)
    5109                 :       1109 :             op2 = gimple_assign_lhs (stmts[stmt_index++]);
    5110                 :        381 :           else if (op_index >= 0)
    5111                 :            :             {
    5112                 :        380 :               operand_entry *oe = ops[op_index--];
    5113                 :        380 :               stmt2 = oe->stmt_to_insert;
    5114                 :        380 :               op2 = oe->op;
    5115                 :            :             }
    5116                 :            :           else
    5117                 :            :             {
    5118                 :          1 :               gcc_assert (stmt_index < i);
    5119                 :          1 :               op2 = gimple_assign_lhs (stmts[stmt_index++]);
    5120                 :            :             }
    5121                 :            : 
    5122                 :       1490 :           if (stmt_index >= ready_stmts_end)
    5123                 :       1251 :             ready_stmts_end = 0;
    5124                 :            :         }
    5125                 :            :       else
    5126                 :            :         {
    5127                 :       1768 :           if (op_index > 1)
    5128                 :       1348 :             swap_ops_for_binary_stmt (ops, op_index - 2, NULL);
    5129                 :       1768 :           operand_entry *oe2 = ops[op_index--];
    5130                 :       1768 :           operand_entry *oe1 = ops[op_index--];
    5131                 :       1768 :           op2 = oe2->op;
    5132                 :       1768 :           stmt2 = oe2->stmt_to_insert;
    5133                 :       1768 :           op1 = oe1->op;
    5134                 :       1768 :           stmt1 = oe1->stmt_to_insert;
    5135                 :            :         }
    5136                 :            : 
    5137                 :            :       /* If we emit the last statement then we should put
    5138                 :            :          operands into the last statement.  It will also
    5139                 :            :          break the loop.  */
    5140                 :       3258 :       if (op_index < 0 && stmt_index == i)
    5141                 :        658 :         i = stmt_num - 1;
    5142                 :            : 
    5143                 :       3258 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5144                 :            :         {
    5145                 :          3 :           fprintf (dump_file, "Transforming ");
    5146                 :          3 :           print_gimple_stmt (dump_file, stmts[i], 0);
    5147                 :            :         }
    5148                 :            : 
    5149                 :            :       /* If the stmt that defines operand has to be inserted, insert it
    5150                 :            :          before the use.  */
    5151                 :       3258 :       if (stmt1)
    5152                 :          0 :         insert_stmt_before_use (stmts[i], stmt1);
    5153                 :       3258 :       if (stmt2)
    5154                 :          0 :         insert_stmt_before_use (stmts[i], stmt2);
    5155                 :       3258 :       stmt1 = stmt2 = NULL;
    5156                 :            : 
    5157                 :            :       /* We keep original statement only for the last one.  All
    5158                 :            :          others are recreated.  */
    5159                 :       3258 :       if (i == stmt_num - 1)
    5160                 :            :         {
    5161                 :        658 :           gimple_assign_set_rhs1 (stmts[i], op1);
    5162                 :        658 :           gimple_assign_set_rhs2 (stmts[i], op2);
    5163                 :        658 :           update_stmt (stmts[i]);
    5164                 :            :         }
    5165                 :            :       else
    5166                 :            :         {
    5167                 :       2600 :           stmts[i] = build_and_add_sum (TREE_TYPE (last_rhs1), op1, op2, opcode);
    5168                 :       2600 :           gimple_set_visited (stmts[i], true);
    5169                 :            :         }
    5170                 :       3258 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5171                 :            :         {
    5172                 :          3 :           fprintf (dump_file, " into ");
    5173                 :          3 :           print_gimple_stmt (dump_file, stmts[i], 0);
    5174                 :            :         }
    5175                 :            :     }
    5176                 :            : 
    5177                 :        658 :   remove_visited_stmt_chain (last_rhs1);
    5178                 :        658 : }
    5179                 :            : 
    5180                 :            : /* Transform STMT, which is really (A +B) + (C + D) into the left
    5181                 :            :    linear form, ((A+B)+C)+D.
    5182                 :            :    Recurse on D if necessary.  */
    5183                 :            : 
    5184                 :            : static void
    5185                 :       1909 : linearize_expr (gimple *stmt)
    5186                 :            : {
    5187                 :       1909 :   gimple_stmt_iterator gsi;
    5188                 :       1909 :   gimple *binlhs = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
    5189                 :       1909 :   gimple *binrhs = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
    5190                 :       1909 :   gimple *oldbinrhs = binrhs;
    5191                 :       1909 :   enum tree_code rhscode = gimple_assign_rhs_code (stmt);
    5192                 :       1909 :   gimple *newbinrhs = NULL;
    5193                 :       1909 :   class loop *loop = loop_containing_stmt (stmt);
    5194                 :       1909 :   tree lhs = gimple_assign_lhs (stmt);
    5195                 :            : 
    5196                 :       1909 :   gcc_assert (is_reassociable_op (binlhs, rhscode, loop)
    5197                 :            :               && is_reassociable_op (binrhs, rhscode, loop));
    5198                 :            : 
    5199                 :       1909 :   gsi = gsi_for_stmt (stmt);
    5200                 :            : 
    5201                 :       1909 :   gimple_assign_set_rhs2 (stmt, gimple_assign_rhs1 (binrhs));
    5202                 :       1909 :   binrhs = gimple_build_assign (make_ssa_name (TREE_TYPE (lhs)),
    5203                 :            :                                 gimple_assign_rhs_code (binrhs),
    5204                 :            :                                 gimple_assign_lhs (binlhs),
    5205                 :            :                                 gimple_assign_rhs2 (binrhs));
    5206                 :       1909 :   gimple_assign_set_rhs1 (stmt, gimple_assign_lhs (binrhs));
    5207                 :       1909 :   gsi_insert_before (&gsi, binrhs, GSI_SAME_STMT);
    5208                 :       1909 :   gimple_set_uid (binrhs, gimple_uid (stmt));
    5209                 :            : 
    5210                 :       1909 :   if (TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME)
    5211                 :       1908 :     newbinrhs = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt));
    5212                 :            : 
    5213                 :       1909 :   if (dump_file && (dump_flags & TDF_DETAILS))
    5214                 :            :     {
    5215                 :          0 :       fprintf (dump_file, "Linearized: ");
    5216                 :          0 :       print_gimple_stmt (dump_file, stmt, 0);
    5217                 :            :     }
    5218                 :            : 
    5219                 :       1909 :   reassociate_stats.linearized++;
    5220                 :       1909 :   update_stmt (stmt);
    5221                 :            : 
    5222                 :       1909 :   gsi = gsi_for_stmt (oldbinrhs);
    5223                 :       1909 :   reassoc_remove_stmt (&gsi);
    5224                 :       1909 :   release_defs (oldbinrhs);
    5225                 :            : 
    5226                 :       1909 :   gimple_set_visited (stmt, true);
    5227                 :       1909 :   gimple_set_visited (binlhs, true);
    5228                 :       1909 :   gimple_set_visited (binrhs, true);
    5229                 :            : 
    5230                 :            :   /* Tail recurse on the new rhs if it still needs reassociation.  */
    5231                 :       1909 :   if (newbinrhs && is_reassociable_op (newbinrhs, rhscode, loop))
    5232                 :            :     /* ??? This should probably be linearize_expr (newbinrhs) but I don't
    5233                 :            :            want to change the algorithm while converting to tuples.  */
    5234                 :        395 :     linearize_expr (stmt);
    5235                 :       1909 : }
    5236                 :            : 
    5237                 :            : /* If LHS has a single immediate use that is a GIMPLE_ASSIGN statement, return
    5238                 :            :    it.  Otherwise, return NULL.  */
    5239                 :            : 
    5240                 :            : static gimple *
    5241                 :     266155 : get_single_immediate_use (tree lhs)
    5242                 :            : {
    5243                 :     266155 :   use_operand_p immuse;
    5244                 :     266155 :   gimple *immusestmt;
    5245                 :            : 
    5246                 :     266155 :   if (TREE_CODE (lhs) == SSA_NAME
    5247                 :     266155 :       && single_imm_use (lhs, &immuse, &immusestmt)
    5248                 :     477843 :       && is_gimple_assign (immusestmt))
    5249                 :     171371 :     return immusestmt;
    5250                 :            : 
    5251                 :            :   return NULL;
    5252                 :            : }
    5253                 :            : 
    5254                 :            : /* Recursively negate the value of TONEGATE, and return the SSA_NAME
    5255                 :            :    representing the negated value.  Insertions of any necessary
    5256                 :            :    instructions go before GSI.
    5257                 :            :    This function is recursive in that, if you hand it "a_5" as the
    5258                 :            :    value to negate, and a_5 is defined by "a_5 = b_3 + b_4", it will
    5259                 :            :    transform b_3 + b_4 into a_5 = -b_3 + -b_4.  */
    5260                 :            : 
    5261                 :            : static tree
    5262                 :      51467 : negate_value (tree tonegate, gimple_stmt_iterator *gsip)
    5263                 :            : {
    5264                 :      51467 :   gimple *negatedefstmt = NULL;
    5265                 :      51467 :   tree resultofnegate;
    5266                 :      51467 :   gimple_stmt_iterator gsi;
    5267                 :      51467 :   unsigned int uid;
    5268                 :            : 
    5269                 :            :   /* If we are trying to negate a name, defined by an add, negate the
    5270                 :            :      add operands instead.  */
    5271                 :      51467 :   if (TREE_CODE (tonegate) == SSA_NAME)
    5272                 :      48881 :     negatedefstmt = SSA_NAME_DEF_STMT (tonegate);
    5273                 :      51467 :   if (TREE_CODE (tonegate) == SSA_NAME
    5274                 :      48881 :       && is_gimple_assign (negatedefstmt)
    5275                 :      41101 :       && TREE_CODE (gimple_assign_lhs (negatedefstmt)) == SSA_NAME
    5276                 :      41101 :       && has_single_use (gimple_assign_lhs (negatedefstmt))
    5277                 :      79739 :       && gimple_assign_rhs_code (negatedefstmt) == PLUS_EXPR)
    5278                 :            :     {
    5279                 :        540 :       tree rhs1 = gimple_assign_rhs1 (negatedefstmt);
    5280                 :        540 :       tree rhs2 = gimple_assign_rhs2 (negatedefstmt);
    5281                 :        540 :       tree lhs = gimple_assign_lhs (negatedefstmt);
    5282                 :        540 :       gimple *g;
    5283                 :            : 
    5284                 :        540 :       gsi = gsi_for_stmt (negatedefstmt);
    5285                 :        540 :       rhs1 = negate_value (rhs1, &gsi);
    5286                 :            : 
    5287                 :        540 :       gsi = gsi_for_stmt (negatedefstmt);
    5288                 :        540 :       rhs2 = negate_value (rhs2, &gsi);
    5289                 :            : 
    5290                 :        540 :       gsi = gsi_for_stmt (negatedefstmt);
    5291                 :        540 :       lhs = make_ssa_name (TREE_TYPE (lhs));
    5292                 :        540 :       gimple_set_visited (negatedefstmt, true);
    5293                 :        540 :       g = gimple_build_assign (lhs, PLUS_EXPR, rhs1, rhs2);
    5294                 :        540 :       gimple_set_uid (g, gimple_uid (negatedefstmt));
    5295                 :        540 :       gsi_insert_before (&gsi, g, GSI_SAME_STMT);
    5296                 :        540 :       return lhs;
    5297                 :            :     }
    5298                 :            : 
    5299                 :      50927 :   tonegate = fold_build1 (NEGATE_EXPR, TREE_TYPE (tonegate), tonegate);
    5300                 :      50927 :   resultofnegate = force_gimple_operand_gsi (gsip, tonegate, true,
    5301                 :            :                                              NULL_TREE, true, GSI_SAME_STMT);
    5302                 :      50927 :   gsi = *gsip;
    5303                 :      50927 :   uid = gimple_uid (gsi_stmt (gsi));
    5304                 :     198536 :   for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
    5305                 :            :     {
    5306                 :      96549 :       gimple *stmt = gsi_stmt (gsi);
    5307                 :      96549 :       if (gimple_uid (stmt) != 0)
    5308                 :            :         break;
    5309                 :      48341 :       gimple_set_uid (stmt, uid);
    5310                 :            :     }
    5311                 :            :   return resultofnegate;
    5312                 :            : }
    5313                 :            : 
    5314                 :            : /* Return true if we should break up the subtract in STMT into an add
    5315                 :            :    with negate.  This is true when we the subtract operands are really
    5316                 :            :    adds, or the subtract itself is used in an add expression.  In
    5317                 :            :    either case, breaking up the subtract into an add with negate
    5318                 :            :    exposes the adds to reassociation.  */
    5319                 :            : 
    5320                 :            : static bool
    5321                 :     184033 : should_break_up_subtract (gimple *stmt)
    5322                 :            : {
    5323                 :     184033 :   tree lhs = gimple_assign_lhs (stmt);
    5324                 :     184033 :   tree binlhs = gimple_assign_rhs1 (stmt);
    5325                 :     184033 :   tree binrhs = gimple_assign_rhs2 (stmt);
    5326                 :     184033 :   gimple *immusestmt;
    5327                 :     184033 :   class loop *loop = loop_containing_stmt (stmt);
    5328                 :            : 
    5329                 :     184033 :   if (TREE_CODE (binlhs) == SSA_NAME
    5330                 :     184033 :       && is_reassociable_op (SSA_NAME_DEF_STMT (binlhs), PLUS_EXPR, loop))
    5331                 :            :     return true;
    5332                 :            : 
    5333                 :     176637 :   if (TREE_CODE (binrhs) == SSA_NAME
    5334                 :     176637 :       && is_reassociable_op (SSA_NAME_DEF_STMT (binrhs), PLUS_EXPR, loop))
    5335                 :            :     return true;
    5336                 :            : 
    5337                 :     176190 :   if (TREE_CODE (lhs) == SSA_NAME
    5338                 :     176190 :       && (immusestmt = get_single_immediate_use (lhs))
    5339                 :      92238 :       && is_gimple_assign (immusestmt)
    5340                 :     268428 :       && (gimple_assign_rhs_code (immusestmt) == PLUS_EXPR
    5341                 :      61276 :           || (gimple_assign_rhs_code (immusestmt) == MINUS_EXPR
    5342                 :       2692 :               && gimple_assign_rhs1 (immusestmt) == lhs)
    5343                 :      58643 :           || gimple_assign_rhs_code (immusestmt) == MULT_EXPR))
    5344                 :      42544 :     return true;
    5345                 :            :   return false;
    5346                 :            : }
    5347                 :            : 
    5348                 :            : /* Transform STMT from A - B into A + -B.  */
    5349                 :            : 
    5350                 :            : static void
    5351                 :      50387 : break_up_subtract (gimple *stmt, gimple_stmt_iterator *gsip)
    5352                 :            : {
    5353                 :      50387 :   tree rhs1 = gimple_assign_rhs1 (stmt);
    5354                 :      50387 :   tree rhs2 = gimple_assign_rhs2 (stmt);
    5355                 :            : 
    5356                 :      50387 :   if (dump_file && (dump_flags & TDF_DETAILS))
    5357                 :            :     {
    5358                 :          0 :       fprintf (dump_file, "Breaking up subtract ");
    5359                 :          0 :       print_gimple_stmt (dump_file, stmt, 0);
    5360                 :            :     }
    5361                 :            : 
    5362                 :      50387 :   rhs2 = negate_value (rhs2, gsip);
    5363                 :      50387 :   gimple_assign_set_rhs_with_ops (gsip, PLUS_EXPR, rhs1, rhs2);
    5364                 :      50387 :   update_stmt (stmt);
    5365                 :      50387 : }
    5366                 :            : 
    5367                 :            : /* Determine whether STMT is a builtin call that raises an SSA name
    5368                 :            :    to an integer power and has only one use.  If so, and this is early
    5369                 :            :    reassociation and unsafe math optimizations are permitted, place
    5370                 :            :    the SSA name in *BASE and the exponent in *EXPONENT, and return TRUE.
    5371                 :            :    If any of these conditions does not hold, return FALSE.  */
    5372                 :            : 
    5373                 :            : static bool
    5374                 :        105 : acceptable_pow_call (gcall *stmt, tree *base, HOST_WIDE_INT *exponent)
    5375                 :            : {
    5376                 :        105 :   tree arg1;
    5377                 :        105 :   REAL_VALUE_TYPE c, cint;
    5378                 :            : 
    5379                 :        105 :   switch (gimple_call_combined_fn (stmt))
    5380                 :            :     {
    5381                 :         17 :     CASE_CFN_POW:
    5382                 :         17 :       if (flag_errno_math)
    5383                 :            :         return false;
    5384                 :            : 
    5385                 :         17 :       *base = gimple_call_arg (stmt, 0);
    5386                 :         17 :       arg1 = gimple_call_arg (stmt, 1);
    5387                 :            : 
    5388                 :         17 :       if (TREE_CODE (arg1) != REAL_CST)
    5389                 :            :         return false;
    5390                 :            : 
    5391                 :         15 :       c = TREE_REAL_CST (arg1);
    5392                 :            : 
    5393                 :         15 :       if (REAL_EXP (&c) > HOST_BITS_PER_WIDE_INT)
    5394                 :            :         return false;
    5395                 :            : 
    5396                 :         15 :       *exponent = real_to_integer (&c);
    5397                 :         15 :       real_from_integer (&cint, VOIDmode, *exponent, SIGNED);
    5398                 :         15 :       if (!real_identical (&c, &cint))
    5399                 :            :         return false;
    5400                 :            : 
    5401                 :            :       break;
    5402                 :            : 
    5403                 :         11 :     CASE_CFN_POWI:
    5404                 :         11 :       *base = gimple_call_arg (stmt, 0);
    5405                 :         11 :       arg1 = gimple_call_arg (stmt, 1);
    5406                 :            : 
    5407                 :         11 :       if (!tree_fits_shwi_p (arg1))
    5408                 :            :         return false;
    5409                 :            : 
    5410                 :         11 :       *exponent = tree_to_shwi (arg1);
    5411                 :         11 :       break;
    5412                 :            : 
    5413                 :            :     default:
    5414                 :            :       return false;
    5415                 :            :     }
    5416                 :            : 
    5417                 :            :   /* Expanding negative exponents is generally unproductive, so we don't
    5418                 :            :      complicate matters with those.  Exponents of zero and one should
    5419                 :            :      have been handled by expression folding.  */
    5420                 :         19 :   if (*exponent < 2 || TREE_CODE (*base) != SSA_NAME)
    5421                 :          0 :     return false;
    5422                 :            : 
    5423                 :            :   return true;
    5424                 :            : }
    5425                 :            : 
    5426                 :            : /* Try to derive and add operand entry for OP to *OPS.  Return false if
    5427                 :            :    unsuccessful.  */
    5428                 :            : 
    5429                 :            : static bool
    5430                 :    5483840 : try_special_add_to_ops (vec<operand_entry *> *ops,
    5431                 :            :                         enum tree_code code,
    5432                 :            :                         tree op, gimple* def_stmt)
    5433                 :            : {
    5434                 :    5483840 :   tree base = NULL_TREE;
    5435                 :    5483840 :   HOST_WIDE_INT exponent = 0;
    5436                 :            : 
    5437                 :    5483840 :   if (TREE_CODE (op) != SSA_NAME
    5438                 :    5483840 :       || ! has_single_use (op))
    5439                 :            :     return false;
    5440                 :            : 
    5441                 :    2166380 :   if (code == MULT_EXPR
    5442                 :     469085 :       && reassoc_insert_powi_p
    5443                 :     195401 :       && flag_unsafe_math_optimizations
    5444                 :      28609 :       && is_gimple_call (def_stmt)
    5445                 :    2166480 :       && acceptable_pow_call (as_a <gcall *> (def_stmt), &base, &exponent))
    5446                 :            :     {
    5447                 :         19 :       add_repeat_to_ops_vec (ops, base, exponent);
    5448                 :         19 :       gimple_set_visited (def_stmt, true);
    5449                 :         19 :       return true;
    5450                 :            :     }
    5451                 :    2166360 :   else if (code == MULT_EXPR
    5452                 :     469066 :            && is_gimple_assign (def_stmt)
    5453                 :     453815 :            && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
    5454                 :        124 :            && !HONOR_SNANS (TREE_TYPE (op))
    5455                 :    2166480 :            && (!HONOR_SIGNED_ZEROS (TREE_TYPE (op))
    5456                 :          0 :                || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (op))))
    5457                 :            :     {
    5458                 :        124 :       tree rhs1 = gimple_assign_rhs1 (def_stmt);
    5459                 :        124 :       tree cst = build_minus_one_cst (TREE_TYPE (op));
    5460                 :        124 :       add_to_ops_vec (ops, rhs1);
    5461                 :        124 :       add_to_ops_vec (ops, cst);
    5462                 :        124 :       gimple_set_visited (def_stmt, true);
    5463                 :        124 :       return true;
    5464                 :            :     }
    5465                 :            : 
    5466                 :            :   return false;
    5467                 :            : }
    5468                 :            : 
    5469                 :            : /* Recursively linearize a binary expression that is the RHS of STMT.
    5470                 :            :    Place the operands of the expression tree in the vector named OPS.  */
    5471                 :            : 
    5472                 :            : static void
    5473                 :    2832920 : linearize_expr_tree (vec<operand_entry *> *ops, gimple *stmt,
    5474                 :            :                      bool is_associative, bool set_visited)
    5475                 :            : {
    5476                 :    2832920 :   tree binlhs = gimple_assign_rhs1 (stmt);
    5477                 :    2832920 :   tree binrhs = gimple_assign_rhs2 (stmt);
    5478                 :    2832920 :   gimple *binlhsdef = NULL, *binrhsdef = NULL;
    5479                 :    2832920 :   bool binlhsisreassoc = false;
    5480                 :    2832920 :   bool binrhsisreassoc = false;
    5481                 :    2832920 :   enum tree_code rhscode = gimple_assign_rhs_code (stmt);
    5482                 :    2832920 :   class loop *loop = loop_containing_stmt (stmt);
    5483                 :            : 
    5484                 :    2832920 :   if (set_visited)
    5485                 :    2800290 :     gimple_set_visited (stmt, true);
    5486                 :            : 
    5487                 :    2832920 :   if (TREE_CODE (binlhs) == SSA_NAME)
    5488                 :            :     {
    5489                 :    2829600 :       binlhsdef = SSA_NAME_DEF_STMT (binlhs);
    5490                 :    2829600 :       binlhsisreassoc = (is_reassociable_op (binlhsdef, rhscode, loop)
    5491                 :    2829600 :                          && !stmt_could_throw_p (cfun, binlhsdef));
    5492                 :            :     }
    5493                 :            : 
    5494                 :    2832920 :   if (TREE_CODE (binrhs) == SSA_NAME)
    5495                 :            :     {
    5496                 :     966284 :       binrhsdef = SSA_NAME_DEF_STMT (binrhs);
    5497                 :     966284 :       binrhsisreassoc = (is_reassociable_op (binrhsdef, rhscode, loop)
    5498                 :     966284 :                          && !stmt_could_throw_p (cfun, binrhsdef));
    5499                 :            :     }
    5500                 :            : 
    5501                 :            :   /* If the LHS is not reassociable, but the RHS is, we need to swap
    5502                 :            :      them.  If neither is reassociable, there is nothing we can do, so
    5503                 :            :      just put them in the ops vector.  If the LHS is reassociable,
    5504                 :            :      linearize it.  If both are reassociable, then linearize the RHS
    5505                 :            :      and the LHS.  */
    5506                 :            : 
    5507                 :    2832920 :   if (!binlhsisreassoc)
    5508                 :            :     {
    5509                 :            :       /* If this is not a associative operation like division, give up.  */
    5510                 :    2696650 :       if (!is_associative)
    5511                 :            :         {
    5512                 :          9 :           add_to_ops_vec (ops, binrhs);
    5513                 :          9 :           return;
    5514                 :            :         }
    5515                 :            : 
    5516                 :    2696640 :       if (!binrhsisreassoc)
    5517                 :            :         {
    5518                 :    2650930 :           if (!try_special_add_to_ops (ops, rhscode, binrhs, binrhsdef))
    5519                 :    2650890 :             add_to_ops_vec (ops, binrhs);
    5520                 :            : 
    5521                 :    2650930 :           if (!try_special_add_to_ops (ops, rhscode, binlhs, binlhsdef))
    5522                 :    2650830 :             add_to_ops_vec (ops, binlhs);
    5523                 :            : 
    5524                 :    2650930 :           return;
    5525                 :            :         }
    5526                 :            : 
    5527                 :      45713 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5528                 :            :         {
    5529                 :          9 :           fprintf (dump_file, "swapping operands of ");
    5530                 :          9 :           print_gimple_stmt (dump_file, stmt, 0);
    5531                 :            :         }
    5532                 :            : 
    5533                 :      45713 :       swap_ssa_operands (stmt,
    5534                 :            :                          gimple_assign_rhs1_ptr (stmt),
    5535                 :            :                          gimple_assign_rhs2_ptr (stmt));
    5536                 :      45713 :       update_stmt (stmt);
    5537                 :            : 
    5538                 :      45713 :       if (dump_file && (dump_flags & TDF_DETAILS))
    5539                 :            :         {
    5540                 :          9 :           fprintf (dump_file, " is now ");
    5541                 :          9 :           print_gimple_stmt (dump_file, stmt, 0);
    5542                 :            :         }
    5543                 :            : 
    5544                 :            :       /* We want to make it so the lhs is always the reassociative op,
    5545                 :            :          so swap.  */
    5546                 :     181984 :       std::swap (binlhs, binrhs);
    5547                 :            :     }
    5548                 :     136271 :   else if (binrhsisreassoc)
    5549                 :            :     {
    5550                 :       1514 :       linearize_expr (stmt);
    5551                 :       1514 :       binlhs = gimple_assign_rhs1 (stmt);
    5552                 :       1514 :       binrhs = gimple_assign_rhs2 (stmt);
    5553                 :            :     }
    5554                 :            : 
    5555                 :     181984 :   gcc_assert (TREE_CODE (binrhs) != SSA_NAME
    5556                 :            :               || !is_reassociable_op (SSA_NAME_DEF_STMT (binrhs),
    5557                 :            :                                       rhscode, loop));
    5558                 :     181984 :   linearize_expr_tree (ops, SSA_NAME_DEF_STMT (binlhs),
    5559                 :            :                        is_associative, set_visited);
    5560                 :            : 
    5561                 :     181984 :   if (!try_special_add_to_ops (ops, rhscode, binrhs, binrhsdef))
    5562                 :     181980 :     add_to_ops_vec (ops, binrhs);
    5563                 :            : }
    5564                 :            : 
    5565                 :            : /* Repropagate the negates back into subtracts, since no other pass
    5566                 :            :    currently does it.  */
    5567                 :            : 
    5568                 :            : static void
    5569                 :    1372280 : repropagate_negates (void)
    5570                 :            : {
    5571                 :    1372280 :   unsigned int i = 0;
    5572                 :    1372280 :   tree negate;
    5573                 :            : 
    5574                 :    1462250 :   FOR_EACH_VEC_ELT (plus_negates, i, negate)
    5575                 :            :     {
    5576                 :      89965 :       gimple *user = get_single_immediate_use (negate);
    5577                 :            : 
    5578                 :      89965 :       if (!user || !is_gimple_assign (user))
    5579                 :      10832 :         continue;
    5580                 :            : 
    5581                 :            :       /* The negate operand can be either operand of a PLUS_EXPR
    5582                 :            :          (it can be the LHS if the RHS is a constant for example).
    5583                 :            : 
    5584                 :            :          Force the negate operand to the RHS of the PLUS_EXPR, then
    5585                 :            :          transform the PLUS_EXPR into a MINUS_EXPR.  */
    5586                 :      79133 :       if (gimple_assign_rhs_code (user) == PLUS_EXPR)
    5587                 :            :         {
    5588                 :            :           /* If the negated operand appears on the LHS of the
    5589                 :            :              PLUS_EXPR, exchange the operands of the PLUS_EXPR
    5590                 :            :              to force the negated operand to the RHS of the PLUS_EXPR.  */
    5591                 :      51170 :           if (gimple_assign_rhs1 (user) == negate)
    5592                 :            :             {
    5593                 :      24751 :               swap_ssa_operands (user,
    5594                 :            :                                  gimple_assign_rhs1_ptr (user),
    5595                 :            :                                  gimple_assign_rhs2_ptr (user));
    5596                 :            :             }
    5597                 :            : 
    5598                 :            :           /* Now transform the PLUS_EXPR into a MINUS_EXPR and replace
    5599                 :            :              the RHS of the PLUS_EXPR with the operand of the NEGATE_EXPR.  */
    5600                 :      51170 :           if (gimple_assign_rhs2 (user) == negate)
    5601                 :            :             {
    5602                 :      51170 :               tree rhs1 = gimple_assign_rhs1 (user);
    5603                 :      51170 :               tree rhs2 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (negate));
    5604                 :      51170 :               gimple_stmt_iterator gsi = gsi_for_stmt (user);
    5605                 :      51170 :               gimple_assign_set_rhs_with_ops (&gsi, MINUS_EXPR, rhs1, rhs2);
    5606                 :     102340 :               update_stmt (user);
    5607                 :            :             }
    5608                 :            :         }
    5609                 :      27963 :       else if (gimple_assign_rhs_code (user) == MINUS_EXPR)
    5610                 :            :         {
    5611                 :       1032 :           if (gimple_assign_rhs1 (user) == negate)
    5612                 :            :             {
    5613                 :            :               /* We have
    5614                 :            :                    x = -a
    5615                 :            :                    y = x - b
    5616                 :            :                  which we transform into
    5617                 :            :                    x = a + b
    5618                 :            :                    y = -x .
    5619                 :            :                  This pushes down the negate which we possibly can merge
    5620                 :            :                  into some other operation, hence insert it into the
    5621                 :            :                  plus_negates vector.  */
    5622                 :       1032 :               gimple *feed = SSA_NAME_DEF_STMT (negate);
    5623                 :       1032 :               tree a = gimple_assign_rhs1 (feed);
    5624                 :       1032 :               tree b = gimple_assign_rhs2 (user);
    5625                 :       1032 :               gimple_stmt_iterator gsi = gsi_for_stmt (feed);
    5626                 :       1032 :               gimple_stmt_iterator gsi2 = gsi_for_stmt (user);
    5627                 :       1032 :               tree x = make_ssa_name (TREE_TYPE (gimple_assign_lhs (feed)));
    5628                 :       1032 :               gimple *g = gimple_build_assign (x, PLUS_EXPR, a, b);
    5629                 :       1032 :               gsi_insert_before (&gsi2, g, GSI_SAME_STMT);
    5630                 :       1032 :               gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, x);
    5631                 :       1032 :               user = gsi_stmt (gsi2);
    5632                 :       1032 :               update_stmt (user);
    5633                 :       1032 :               reassoc_remove_stmt (&gsi);
    5634                 :       1032 :               release_defs (feed);
    5635                 :       1032 :               plus_negates.safe_push (gimple_assign_lhs (user));
    5636                 :            :             }
    5637                 :            :           else
    5638                 :            :             {
    5639                 :            :               /* Transform "x = -a; y = b - x" into "y = b + a", getting
    5640                 :            :                  rid of one operation.  */
    5641                 :          0 :               gimple *feed = SSA_NAME_DEF_STMT (negate);
    5642                 :          0 :               tree a = gimple_assign_rhs1 (feed);
    5643                 :          0 :               tree rhs1 = gimple_assign_rhs1 (user);
    5644                 :          0 :               gimple_stmt_iterator gsi = gsi_for_stmt (user);
    5645                 :          0 :               gimple_assign_set_rhs_with_ops (&gsi, PLUS_EXPR, rhs1, a);
    5646                 :          0 :               update_stmt (gsi_stmt (gsi));
    5647                 :            :             }
    5648                 :            :         }
    5649                 :            :     }
    5650                 :    1372280 : }
    5651                 :            : 
    5652                 :            : /* Returns true if OP is of a type for which we can do reassociation.
    5653                 :            :    That is for integral or non-saturating fixed-point types, and for
    5654                 :            :    floating point type when associative-math is enabled.  */
    5655                 :            : 
    5656                 :            : static bool
    5657                 :   43890600 : can_reassociate_p (tree op)
    5658                 :            : {
    5659                 :   43890600 :   tree type = TREE_TYPE (op);
    5660                 :   43890600 :   if (TREE_CODE (op) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op))
    5661                 :            :     return false;
    5662                 :   54376100 :   if ((ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
    5663                 :   24694600 :       || NON_SAT_FIXED_POINT_TYPE_P (type)
    5664                 :   68730100 :       || (flag_associative_math && FLOAT_TYPE_P (type)))
    5665                 :   19756900 :     return true;
    5666                 :            :   return false;
    5667                 :            : }
    5668                 :            : 
    5669                 :            : /* Break up subtract operations in block BB.
    5670                 :            : 
    5671                 :            :    We do this top down because we don't know whether the subtract is
    5672                 :            :    part of a possible chain of reassociation except at the top.
    5673                 :            : 
    5674                 :            :    IE given
    5675                 :            :    d = f + g
    5676                 :            :    c = a + e
    5677                 :            :    b = c - d
    5678                 :            :    q = b - r
    5679                 :            :    k = t - q
    5680                 :            : 
    5681                 :            :    we want to break up k = t - q, but we won't until we've transformed q
    5682                 :            :    = b - r, which won't be broken up until we transform b = c - d.
    5683                 :            : 
    5684                 :            :    En passant, clear the GIMPLE visited flag on every statement
    5685                 :            :    and set UIDs within each basic block.  */
    5686                 :            : 
    5687                 :            : static void
    5688                 :   14034700 : break_up_subtract_bb (basic_block bb)
    5689                 :            : {
    5690                 :   14034700 :   gimple_stmt_iterator gsi;
    5691                 :   14034700 :   basic_block son;
    5692                 :   14034700 :   unsigned int uid = 1;
    5693                 :            : 
    5694                 :  135704000 :   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    5695                 :            :     {
    5696                 :  107635000 :       gimple *stmt = gsi_stmt (gsi);
    5697                 :  107635000 :       gimple_set_visited (stmt, false);
    5698                 :  107635000 :       gimple_set_uid (stmt, uid++);
    5699                 :            : 
    5700                 :  107635000 :       if (!is_gimple_assign (stmt)
    5701                 :  107635000 :           || !can_reassociate_p (gimple_assign_lhs (stmt)))
    5702                 :   96516100 :         continue;
    5703                 :            : 
    5704                 :            :       /* Look for simple gimple subtract operations.  */
    5705                 :   11118700 :       if (gimple_assign_rhs_code (stmt) == MINUS_EXPR)
    5706                 :            :         {
    5707                 :     184033 :           if (!can_reassociate_p (gimple_assign_rhs1 (stmt))
    5708                 :     184033 :               || !can_reassociate_p (gimple_assign_rhs2 (stmt)))
    5709                 :          0 :             continue;
    5710                 :            : 
    5711                 :            :           /* Check for a subtract used only in an addition.  If this
    5712                 :            :              is the case, transform it into add of a negate for better
    5713                 :            :              reassociation.  IE transform C = A-B into C = A + -B if C
    5714                 :            :              is only used in an addition.  */
    5715                 :     184033 :           if (should_break_up_subtract (stmt))
    5716                 :      50387 :             break_up_subtract (stmt, &gsi);
    5717                 :            :         }
    5718                 :   10934700 :       else if (gimple_assign_rhs_code (stmt) == NEGATE_EXPR
    5719                 :   10934700 :                && can_reassociate_p (gimple_assign_rhs1 (stmt)))
    5720                 :      35956 :         plus_negates.safe_push (gimple_assign_lhs (stmt));
    5721                 :            :     }
    5722                 :   14034700 :   for (son = first_dom_son (CDI_DOMINATORS, bb);
    5723                 :   26697100 :        son;
    5724                 :   12662400 :        son = next_dom_son (CDI_DOMINATORS, son))
    5725                 :   12662400 :     break_up_subtract_bb (son);
    5726                 :   14034700 : }
    5727                 :            : 
    5728                 :            : /* Used for repeated factor analysis.  */
    5729                 :            : struct repeat_factor
    5730                 :            : {
    5731                 :            :   /* An SSA name that occurs in a multiply chain.  */
    5732                 :            :   tree factor;
    5733                 :            : 
    5734                 :            :   /* Cached rank of the factor.  */
    5735                 :            :   unsigned rank;
    5736                 :            : 
    5737                 :            :   /* Number of occurrences of the factor in the chain.  */
    5738                 :            :   HOST_WIDE_INT count;
    5739                 :            : 
    5740                 :            :   /* An SSA name representing the product of this factor and
    5741                 :            :      all factors appearing later in the repeated factor vector.  */
    5742                 :            :   tree repr;
    5743                 :            : };
    5744                 :            : 
    5745                 :            : 
    5746                 :            : static vec<repeat_factor> repeat_factor_vec;
    5747                 :            : 
    5748                 :            : /* Used for sorting the repeat factor vector.  Sort primarily by
    5749                 :            :    ascending occurrence count, secondarily by descending rank.  */
    5750                 :            : 
    5751                 :            : static int
    5752                 :      53202 : compare_repeat_factors (const void *x1, const void *x2)
    5753                 :            : {
    5754                 :      53202 :   const repeat_factor *rf1 = (const repeat_factor *) x1;
    5755                 :      53202 :   const repeat_factor *rf2 = (const repeat_factor *) x2;
    5756                 :            : 
    5757                 :      53202 :   if (rf1->count != rf2->count)
    5758                 :        566 :     return rf1->count - rf2->count;
    5759                 :            : 
    5760                 :      52636 :   return rf2->rank - rf1->rank;
    5761                 :            : }
    5762                 :            : 
    5763                 :            : /* Look for repeated operands in OPS in the multiply tree rooted at
    5764                 :            :    STMT.  Replace them with an optimal sequence of multiplies and powi
    5765                 :            :    builtin calls, and remove the used operands from OPS.  Return an
    5766                 :            :    SSA name representing the value of the replacement sequence.  */
    5767                 :            : 
    5768                 :            : static tree
    5769                 :      41218 : attempt_builtin_powi (gimple *stmt, vec<operand_entry *> *ops)
    5770                 :            : {
    5771                 :      41218 :   unsigned i, j, vec_len;
    5772                 :      41218 :   int ii;
    5773                 :      41218 :   operand_entry *oe;
    5774                 :      41218 :   repeat_factor *rf1, *rf2;
    5775                 :      41218 :   repeat_factor rfnew;
    5776                 :      41218 :   tree result = NULL_TREE;
    5777                 :      41218 :   tree target_ssa, iter_result;
    5778                 :      41218 :   tree type = TREE_TYPE (gimple_get_lhs (stmt));
    5779                 :      41218 :   tree powi_fndecl = mathfn_built_in (type, BUILT_IN_POWI);
    5780                 :      41218 :   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    5781                 :      41218 :   gimple *mul_stmt, *pow_stmt;
    5782                 :            : 
    5783                 :            :   /* Nothing to do if BUILT_IN_POWI doesn't exist for this type and
    5784                 :            :      target.  */
    5785                 :      41218 :   if (!powi_fndecl)
    5786                 :            :     return NULL_TREE;
    5787                 :            : 
    5788                 :            :   /* Allocate the repeated factor vector.  */
    5789                 :      13385 :   repeat_factor_vec.create (10);
    5790                 :            : 
    5791                 :            :   /* Scan the OPS vector for all SSA names in the product and build
    5792                 :            :      up a vector of occurrence counts for each factor.  */
    5793                 :      41450 :   FOR_EACH_VEC_ELT (*ops, i, oe)
    5794                 :            :     {
    5795                 :      28065 :       if (TREE_CODE (oe->op) == SSA_NAME)
    5796                 :            :         {
    5797                 :      41528 :           FOR_EACH_VEC_ELT (repeat_factor_vec, j, rf1)
    5798                 :            :             {
    5799                 :      14925 :               if (rf1->factor == oe->op)
    5800                 :            :                 {
    5801                 :        914 :                   rf1->count += oe->count;
    5802                 :        914 :                   break;
    5803                 :            :                 }
    5804                 :            :             }
    5805                 :            : 
    5806                 :      55034 :           if (j >= repeat_factor_vec.length ())
    5807                 :            :             {
    5808                 :      26603 :               rfnew.factor = oe->op;
    5809                 :      26603 :               rfnew.rank = oe->rank;
    5810                 :      26603 :               rfnew.count = oe->count;
    5811                 :      26603 :               rfnew.repr = NULL_TREE;
    5812                 :      26603 :               repeat_factor_vec.safe_push (rfnew);
    5813                 :            :             }
    5814                 :            :         }
    5815                 :            :     }
    5816                 :            : 
    5817                 :            :   /* Sort the repeated factor vector by (a) increasing occurrence count,
    5818                 :            :      and (b) decreasing rank.  */
    5819                 :      13385 :   repeat_factor_vec.qsort (compare_repeat_factors);
    5820                 :            : 
    5821                 :            :   /* It is generally best to combine as many base factors as possible
    5822                 :            :      into a product before applying __builtin_powi to the result.
    5823                 :            :      However, the sort order chosen for the repeated factor vector
    5824                 :            :      allows us to cache partial results for the product of the base
    5825                 :            :      factors for subsequent use.  When we already have a cached partial
    5826                 :            :      result from a previous iteration, it is best to make use of it
    5827                 :            :      before looking for another __builtin_pow opportunity.
    5828                 :            : 
    5829                 :            :      As an example, consider x * x * y * y * y * z * z * z * z.
    5830                 :            :      We want to first compose the product x * y * z, raise it to the
    5831                 :            :      second power, then multiply this by y * z, and finally multiply
    5832                 :            :      by z.  This can be done in 5 multiplies provided we cache y * z
    5833                 :            :      for use in both expressions:
    5834                 :            : 
    5835                 :            :         t1 = y * z
    5836                 :            :         t2 = t1 * x
    5837                 :            :         t3 = t2 * t2
    5838                 :            :         t4 = t1 * t3
    5839                 :            :         result = t4 * z
    5840                 :            : 
    5841                 :            :      If we instead ignored the cached y * z and first multiplied by
    5842                 :            :      the __builtin_pow opportunity z * z, we would get the inferior:
    5843                 :            : 
    5844                 :            :         t1 = y * z
    5845                 :            :         t2 = t1 * x
    5846                 :            :         t3 = t2 * t2
    5847                 :            :         t4 = z * z
    5848                 :            :         t5 = t3 * t4
    5849                 :            :         result = t5 * y  */
    5850                 :            : 
    5851                 :      26770 :   vec_len = repeat_factor_vec.length ();
    5852                 :            :   
    5853                 :            :   /* Repeatedly look for opportunities to create a builtin_powi call.  */
    5854                 :      13950 :   while (true)
    5855                 :            :     {
    5856                 :      13950 :       HOST_WIDE_INT power;
    5857                 :            : 
    5858                 :            :       /* First look for the largest cached product of factors from
    5859                 :            :          preceding iterations.  If found, create a builtin_powi for
    5860                 :            :          it if the minimum occurrence count for its factors is at
    5861                 :            :          least 2, or just use this cached product as our next 
    5862                 :            :          multiplicand if the minimum occurrence count is 1.  */
    5863                 :      41278 :       FOR_EACH_VEC_ELT (repeat_factor_vec, j, rf1)
    5864                 :            :         {
    5865                 :      27337 :           if (rf1->repr && rf1->count > 0)
    5866                 :            :             break;
    5867                 :            :         }
    5868                 :            : 
    5869                 :      13950 :       if (j < vec_len)
    5870                 :            :         {
    5871                 :          9 :           power = rf1->count;
    5872                 :            : 
    5873                 :          9 :           if (power == 1)
    5874                 :            :             {
    5875                 :          7 :               iter_result = rf1->repr;
    5876                 :            : 
    5877                 :          7 :               if (dump_file && (dump_flags & TDF_DETAILS))
    5878                 :            :                 {
    5879                 :          0 :                   unsigned elt;
    5880                 :          0 :                   repeat_factor *rf;
    5881                 :          0 :                   fputs ("Multiplying by cached product ", dump_file);
    5882                 :          0 :                   for (elt = j; elt < vec_len; elt++)
    5883                 :            :                     {
    5884                 :          0 :                       rf = &repeat_factor_vec[elt];
    5885                 :          0 :                       print_generic_expr (dump_file, rf->factor);
    5886                 :          0 :                       if (elt < vec_len - 1)
    5887                 :          0 :                         fputs (" * ", dump_file);
    5888                 :            :                     }
    5889                 :          0 :                   fputs ("\n", dump_file);
    5890                 :            :                 }
    5891                 :            :             }
    5892                 :            :           else
    5893                 :            :             {
    5894                 :          2 :               iter_result = make_temp_ssa_name (type, NULL, "reassocpow");
    5895                 :          2 :               pow_stmt = gimple_build_call (powi_fndecl, 2, rf1->repr, 
    5896                 :            :                                             build_int_cst (integer_type_node,
    5897                 :            :                                                            power));
    5898                 :          2 :               gimple_call_set_lhs (pow_stmt, iter_result);
    5899                 :          2 :               gimple_set_location (pow_stmt, gimple_location (stmt));
    5900                 :          2 :               gimple_set_uid (pow_stmt, gimple_uid (stmt));
    5901                 :          2 :               gsi_insert_before (&gsi, pow_stmt, GSI_SAME_STMT);
    5902                 :            : 
    5903                 :          2 :               if (dump_file && (dump_flags & TDF_DETAILS))
    5904                 :            :                 {
    5905                 :          0 :                   unsigned elt;
    5906                 :          0 :                   repeat_factor *rf;
    5907                 :          0 :                   fputs ("Building __builtin_pow call for cached product (",
    5908                 :            :                          dump_file);
    5909                 :          0 :                   for (elt = j; elt < vec_len; elt++)
    5910                 :            :                     {
    5911                 :          0 :                       rf = &repeat_factor_vec[elt];
    5912                 :          0 :                       print_generic_expr (dump_file, rf->factor);
    5913                 :          0 :                       if (elt < vec_len - 1)
    5914                 :          0 :                         fputs (" * ", dump_file);
    5915                 :            :                     }
    5916                 :          0 :                   fprintf (dump_file, ")^" HOST_WIDE_INT_PRINT_DEC"\n",
    5917                 :            :                            power);
    5918                 :            :                 }
    5919                 :            :             }
    5920                 :            :         }
    5921                 :            :       else
    5922                 :            :         {
    5923                 :            :           /* Otherwise, find the first factor in the repeated factor
    5924                 :            :              vector whose occurrence count is at least 2.  If no such
    5925                 :            :              factor exists, there are no builtin_powi opportunities
    5926                 :            :              remaining.  */
    5927                 :      40667 :           FOR_EACH_VEC_ELT (repeat_factor_vec, j, rf1)
    5928                 :            :             {
    5929                 :      27282 :               if (rf1->count >= 2)
    5930                 :            :                 break;
    5931                 :            :             }
    5932                 :            : 
    5933                 :      13941 :           if (j >= vec_len)
    5934                 :            :             break;
    5935                 :            : 
    5936                 :        556 :           power = rf1->count;
    5937                 :            : 
    5938                 :        556 :           if (dump_file && (dump_flags & TDF_DETAILS))
    5939                 :            :             {
    5940                 :          0 :               unsigned elt;
    5941                 :          0 :               repeat_factor *rf;
    5942                 :          0 :               fputs ("Building __builtin_pow call for (", dump_file);
    5943                 :          0 :               for (elt = j; elt < vec_len; elt++)
    5944                 :            :                 {
    5945                 :          0 :                   rf = &repeat_factor_vec[elt];
    5946                 :          0 :                   print_generic_expr (dump_file, rf->factor);
    5947                 :          0 :                   if (elt < vec_len - 1)
    5948                 :          0 :                     fputs (" * ", dump_file);
    5949                 :            :                 }
    5950                 :          0 :               fprintf (dump_file, ")^" HOST_WIDE_INT_PRINT_DEC"\n", power);
    5951                 :            :             }
    5952                 :            : 
    5953                 :        556 :           reassociate_stats.pows_created++;
    5954                 :            : 
    5955                 :            :           /* Visit each element of the vector in reverse order (so that
    5956                 :            :              high-occurrence elements are visited first, and within the
    5957                 :            :              same occurrence count, lower-ranked elements are visited
    5958                 :            :              first).  Form a linear product of all elements in this order
    5959                 :            :              whose occurrencce count is at least that of element J.
    5960                 :            :              Record the SSA name representing the product of each element
    5961                 :            :              with all subsequent elements in the vector.  */
    5962                 :        556 :           if (j == vec_len - 1)
    5963                 :        531 :             rf1->repr = rf1->factor;
    5964                 :            :           else
    5965                 :            :             {
    5966                 :         56 :               for (ii = vec_len - 2; ii >= (int)j; ii--)
    5967                 :            :                 {
    5968                 :         31 :                   tree op1, op2;
    5969                 :            : 
    5970                 :         31 :                   rf1 = &repeat_factor_vec[ii];
    5971                 :         31 :                   rf2 = &repeat_factor_vec[ii + 1];
    5972                 :            : 
    5973                 :            :                   /* Init the last factor's representative to be itself.  */
    5974                 :         31 :                   if (!rf2->repr)
    5975                 :         25 :                     rf2->repr = rf2->factor;
    5976                 :            : 
    5977                 :         31 :                   op1 = rf1->factor;
    5978                 :         31 :                   op2 = rf2->repr;
    5979                 :            : 
    5980                 :         31 :                   target_ssa = make_temp_ssa_name (type, NULL, "reassocpow");
    5981                 :         31 :                   mul_stmt = gimple_build_assign (target_ssa, MULT_EXPR,
    5982                 :            :                                                   op1, op2);
    5983                 :         31 :                   gimple_set_location (mul_stmt, gimple_location (stmt));
    5984                 :         31 :                   gimple_set_uid (mul_stmt, gimple_uid (stmt));
    5985                 :         31 :                   gsi_insert_before (&gsi, mul_stmt, GSI_SAME_STMT);
    5986                 :         31 :                   rf1->repr = target_ssa;
    5987                 :            : 
    5988                 :            :                   /* Don't reprocess the multiply we just introduced.  */
    5989                 :         31 :                   gimple_set_visited (mul_stmt, true);
    5990                 :            :                 }
    5991                 :            :             }
    5992                 :            : 
    5993                 :            :           /* Form a call to __builtin_powi for the maximum product
    5994                 :            :              just formed, raised to the power obtained earlier.  */
    5995                 :        556 :           rf1 = &repeat_factor_vec[j];
    5996                 :        556 :           iter_result = make_temp_ssa_name (type, NULL, "reassocpow");
    5997                 :        556 :           pow_stmt = gimple_build_call (powi_fndecl, 2, rf1->repr, 
    5998                 :            :                                         build_int_cst (integer_type_node,
    5999                 :            :                                                        power));
    6000                 :        556 :           gimple_call_set_lhs (pow_stmt, iter_result);
    6001                 :        556 :           gimple_set_location (pow_stmt, gimple_location (stmt));
    6002                 :        556 :           gimple_set_uid (pow_stmt, gimple_uid (stmt));
    6003                 :        556 :           gsi_insert_before (&gsi, pow_stmt, GSI_SAME_STMT);
    6004                 :            :         }
    6005                 :            : 
    6006                 :            :       /* If we previously formed at least one other builtin_powi call,
    6007                 :            :          form the product of this one and those others.  */
    6008                 :        565 :       if (result)
    6009                 :            :         {
    6010                 :          9 :           tree new_result = make_temp_ssa_name (type, NULL, "reassocpow");
    6011                 :          9 :           mul_stmt = gimple_build_assign (new_result, MULT_EXPR,
    6012                 :            :                                           result, iter_result);
    6013                 :          9 :           gimple_set_location (mul_stmt, gimple_location (stmt));
    6014                 :          9 :           gimple_set_uid (mul_stmt, gimple_uid (stmt));
    6015                 :          9 :           gsi_insert_before (&gsi, mul_stmt, GSI_SAME_STMT);
    6016                 :          9 :           gimple_set_visited (mul_stmt, true);
    6017                 :          9 :           result = new_result;
    6018                 :            :         }
    6019                 :            :       else
    6020                 :            :         result = iter_result;
    6021                 :            : 
    6022                 :            :       /* Decrement the occurrence count of each element in the product
    6023                 :            :          by the count found above, and remove this many copies of each
    6024                 :            :          factor from OPS.  */
    6025                 :       1166 :       for (i = j; i < vec_len; i++)
    6026                 :            :         {
    6027                 :        601 :           unsigned k = power;
    6028                 :        601 :           unsigned n;
    6029                 :            : 
    6030                 :        601 :           rf1 = &repeat_factor_vec[i];
    6031                 :        601 :           rf1->count -= power;
    6032                 :            :           
    6033                 :       2963 :           FOR_EACH_VEC_ELT_REVERSE (*ops, n, oe)
    6034                 :            :             {
    6035                 :       1761 :               if (oe->op == rf1->factor)
    6036                 :            :                 {
    6037                 :       1507 :                   if (oe->count <= k)
    6038                 :            :                     {
    6039                 :       1501 :                       ops->ordered_remove (n);
    6040                 :       1501 :                       k -= oe->count;
    6041                 :            : 
    6042                 :       1501 :                       if (k == 0)
    6043                 :            :                         break;
    6044                 :            :                     }
    6045                 :            :                   else
    6046                 :            :                     {
    6047                 :          6 :                       oe->count -= k;
    6048                 :          6 :                       break;
    6049                 :            :                     }
    6050                 :            :                 }
    6051                 :            :             }
    6052                 :            :         }
    6053                 :            :     }
    6054                 :            : 
    6055                 :            :   /* At this point all elements in the repeated factor vector have a
    6056                 :            :      remaining occurrence count of 0 or 1, and those with a count of 1
    6057                 :            :      don't have cached representatives.  Re-sort the ops vector and
    6058                 :            :      clean up.  */
    6059                 :      13385 :   ops->qsort (sort_by_operand_rank);
    6060                 :      13385 :   repeat_factor_vec.release ();
    6061                 :            : 
    6062                 :            :   /* Return the final product computed herein.  Note that there may
    6063                 :            :      still be some elements with single occurrence count left in OPS;
    6064                 :            :      those will be handled by the normal reassociation logic.  */
    6065                 :            :   return result;
    6066                 :            : }
    6067                 :            : 
    6068                 :            : /* Attempt to optimize
    6069                 :            :    CST1 * copysign (CST2, y) -> copysign (CST1 * CST2, y) if CST1 > 0, or
    6070                 :            :    CST1 * copysign (CST2, y) -> -copysign (CST1 * CST2, y) if CST1 < 0.  */
    6071                 :            : 
    6072                 :            : static void
    6073                 :     657312 : attempt_builtin_copysign (vec<operand_entry *> *ops)
    6074                 :            : {
    6075                 :     657312 :   operand_entry *oe;
    6076                 :     657312 :   unsigned int i;
    6077                 :     657312 :   unsigned int length = ops->length ();
    6078                 :     657312 :   tree cst = ops->last ()->op;
    6079                 :            : 
    6080                 :     657312 :   if (length == 1 || TREE_CODE (cst) != REAL_CST)
    6081                 :            :     return;
    6082                 :            : 
    6083                 :       3941 :   FOR_EACH_VEC_ELT (*ops, i, oe)
    6084                 :            :     {
    6085                 :       2850 :       if (TREE_CODE (oe->op) == SSA_NAME
    6086                 :       2850 :           && has_single_use (oe->op))
    6087                 :            :         {
    6088                 :        766 :           gimple *def_stmt = SSA_NAME_DEF_STMT (oe->op);
    6089                 :       2886 :           if (gcall *old_call = dyn_cast <gcall *> (def_stmt))
    6090                 :            :             {
    6091                 :         52 :               tree arg0, arg1;
    6092                 :         52 :               switch (gimple_call_combined_fn (old_call))
    6093                 :            :                 {
    6094                 :         20 :                 CASE_CFN_COPYSIGN:
    6095                 :         20 :                 CASE_CFN_COPYSIGN_FN:
    6096                 :         20 :                   arg0 = gimple_call_arg (old_call, 0);
    6097                 :         20 :                   arg1 = gimple_call_arg (old_call, 1);
    6098                 :            :                   /* The first argument of copysign must be a constant,
    6099                 :            :                      otherwise there's nothing to do.  */
    6100                 :         20 :                   if (TREE_CODE (arg0) == REAL_CST)
    6101                 :            :                     {
    6102                 :         20 :                       tree type = TREE_TYPE (arg0);
    6103                 :         20 :                       tree mul = const_binop (MULT_EXPR, type, cst, arg0);
    6104                 :            :                       /* If we couldn't fold to a single constant, skip it.
    6105                 :            :                          That happens e.g. for inexact multiplication when
    6106                 :            :                          -frounding-math.  */
    6107                 :         20 :                       if (mul == NULL_TREE)
    6108                 :            :                         break;
    6109                 :            :                       /* Instead of adjusting OLD_CALL, let's build a new
    6110                 :            :                          call to not leak the LHS and prevent keeping bogus
    6111                 :            :                          debug statements.  DCE will clean up the old call.  */
    6112                 :         16 :                       gcall *new_call;
    6113                 :         16 :                       if (gimple_call_internal_p (old_call))
    6114                 :          0 :                         new_call = gimple_build_call_internal
    6115                 :          0 :                           (IFN_COPYSIGN, 2, mul, arg1);
    6116                 :            :                       else
    6117                 :         16 :                         new_call = gimple_build_call
    6118                 :         16 :                           (gimple_call_fndecl (old_call), 2, mul, arg1);
    6119                 :         16 :                       tree lhs = make_ssa_name (type);
    6120                 :         16 :                       gimple_call_set_lhs (new_call, lhs);
    6121                 :         16 :                       gimple_set_location (new_call,
    6122                 :            :                                            gimple_location (old_call));
    6123                 :         16 :                       insert_stmt_after (new_call, old_call);
    6124                 :            :                       /* We've used the constant, get rid of it.  */
    6125                 :         16 :                       ops->pop ();
    6126                 :         16 :                       bool cst1_neg = real_isneg (TREE_REAL_CST_PTR (cst));
    6127                 :            :                       /* Handle the CST1 < 0 case by negating the result.  */
    6128                 :         16 :                       if (cst1_neg)
    6129                 :            :                         {
    6130                 :          7 :                           tree negrhs = make_ssa_name (TREE_TYPE (lhs));
    6131                 :          7 :                           gimple *negate_stmt
    6132                 :          7 :                             = gimple_build_assign (negrhs, NEGATE_EXPR, lhs);
    6133                 :          7 :                           insert_stmt_after (negate_stmt, new_call);
    6134                 :          7 :                           oe->op = negrhs;
    6135                 :            :                         }
    6136                 :            :                       else
    6137                 :          9 :                         oe->op = lhs;
    6138                 :         16 :                       if (dump_file && (dump_flags & TDF_DETAILS))
    6139                 :            :                         {
    6140                 :         14 :                           fprintf (dump_file, "Optimizing copysign: ");
    6141                 :         14 :                           print_generic_expr (dump_file, cst);
    6142                 :         14 :                           fprintf (dump_file, " * COPYSIGN (");
    6143                 :         14 :                           print_generic_expr (dump_file, arg0);
    6144                 :         14 :                           fprintf (dump_file, ", ");
    6145                 :         14 :                           print_generic_expr (dump_file, arg1);
    6146                 :         23 :                           fprintf (dump_file, ") into %sCOPYSIGN (",
    6147                 :            :                                    cst1_neg ? "-" : "");
    6148                 :         14 :                           print_generic_expr (dump_file, mul);
    6149                 :         14 :                           fprintf (dump_file, ", ");
    6150                 :         14 :                           print_generic_expr (dump_file, arg1);
    6151                 :         14 :                           fprintf (dump_file, "\n");
    6152                 :            :                         }
    6153                 :         16 :                       return;
    6154                 :            :                     }
    6155                 :            :                   break;
    6156                 :            :                 default:
    6157                 :            :                   break;
    6158                 :            :                 }
    6159                 :            :             }
    6160                 :            :         }
    6161                 :            :     }
    6162                 :            : }
    6163                 :            : 
    6164                 :            : /* Transform STMT at *GSI into a copy by replacing its rhs with NEW_RHS.  */
    6165                 :            : 
    6166                 :            : static void
    6167                 :       8712 : transform_stmt_to_copy (gimple_stmt_iterator *gsi, gimple *stmt, tree new_rhs)
    6168                 :            : {
    6169                 :       8712 :   tree rhs1;
    6170                 :            : 
    6171                 :       8712 :   if (dump_file && (dump_flags & TDF_DETAILS))
    6172                 :            :     {
    6173                 :         27 :       fprintf (dump_file, "Transforming ");
    6174                 :         27 :       print_gimple_stmt (dump_file, stmt, 0);
    6175                 :            :     }
    6176                 :            : 
    6177                 :       8712 :   rhs1 = gimple_assign_rhs1 (stmt);
    6178                 :       8712 :   gimple_assign_set_rhs_from_tree (gsi, new_rhs);
    6179                 :       8712 :   update_stmt (stmt);
    6180                 :       8712 :   remove_visited_stmt_chain (rhs1);
    6181                 :            : 
    6182                 :       8712 :   if (dump_file && (dump_flags & TDF_DETAILS))
    6183                 :            :     {
    6184                 :         27 :       fprintf (dump_file, " into ");
    6185                 :         27 :       print_gimple_stmt (dump_file, stmt, 0);
    6186                 :            :     }
    6187                 :       8712 : }
    6188                 :            : 
    6189                 :            : /* Transform STMT at *GSI into a multiply of RHS1 and RHS2.  */
    6190                 :            : 
    6191                 :            : static void
    6192                 :         30 : transform_stmt_to_multiply (gimple_stmt_iterator *gsi, gimple *stmt,
    6193                 :            :                             tree rhs1, tree rhs2)
    6194                 :            : {
    6195                 :         30 :   if (dump_file && (dump_flags & TDF_DETAILS))
    6196                 :            :     {
    6197                 :          0 :       fprintf (dump_file, "Transforming ");
    6198                 :          0 :       print_gimple_stmt (dump_file, stmt, 0);
    6199                 :            :     }
    6200                 :            : 
    6201                 :         30 :   gimple_assign_set_rhs_with_ops (gsi, MULT_EXPR, rhs1, rhs2);
    6202                 :         30 :   update_stmt (gsi_stmt (*gsi));
    6203                 :         30 :   remove_visited_stmt_chain (rhs1);
    6204                 :            : 
    6205                 :         30 :   if (dump_file && (dump_flags & TDF_DETAILS))
    6206                 :            :     {
    6207                 :          0 :       fprintf (dump_file, " into ");
    6208                 :          0 :       print_gimple_stmt (dump_file, stmt, 0);
    6209                 :            :     }
    6210                 :         30 : }
    6211                 :            : 
    6212                 :            : /* Reassociate expressions in basic block BB and its post-dominator as
    6213                 :            :    children.
    6214                 :            : 
    6215                 :            :    Bubble up return status from maybe_optimize_range_tests.  */
    6216                 :            : 
    6217                 :            : static bool
    6218                 :   14034700 : reassociate_bb (basic_block bb)
    6219                 :            : {
    6220                 :   14034700 :   gimple_stmt_iterator gsi;
    6221                 :   14034700 :   basic_block son;
    6222                 :   14034700 :   gimple *stmt = last_stmt (bb);
    6223                 :   14034700 :   bool cfg_cleanup_needed = false;
    6224                 :            : 
    6225                 :   14034700 :   if (stmt && !gimple_visited_p (stmt))
    6226                 :   12132500 :     cfg_cleanup_needed |= maybe_optimize_range_tests (stmt);
    6227                 :            : 
    6228                 :   14034700 :   bool do_prev = false;
    6229                 :   28069400 :   for (gsi = gsi_last_bb (bb);
    6230                 :  229568000 :        !gsi_end_p (gsi); do_prev ? gsi_prev (&gsi) : (void) 0)
    6231                 :            :     {
    6232                 :  107767000 :       do_prev = true;
    6233                 :  107767000 :       stmt = gsi_stmt (gsi);
    6234                 :            : 
    6235                 :  107767000 :       if (is_gimple_assign (stmt)
    6236                 :  107767000 :           && !stmt_could_throw_p (cfun, stmt))
    6237                 :            :         {
    6238                 :   30218400 :           tree lhs, rhs1, rhs2;
    6239                 :   30218400 :           enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
    6240                 :            : 
    6241                 :            :           /* If this was part of an already processed statement,
    6242                 :            :              we don't need to touch it again. */
    6243                 :   30218400 :           if (gimple_visited_p (stmt))
    6244                 :            :             {
    6245                 :            :               /* This statement might have become dead because of previous
    6246                 :            :                  reassociations.  */
    6247                 :     232659 :               if (has_zero_uses (gimple_get_lhs (stmt)))
    6248                 :            :                 {
    6249                 :      73574 :                   reassoc_remove_stmt (&gsi);
    6250                 :      73574 :                   release_defs (stmt);
    6251                 :            :                   /* We might end up removing the last stmt above which
    6252                 :            :                      places the iterator to the end of the sequence.
    6253                 :            :                      Reset it to the last stmt in this case and make sure
    6254                 :            :                      we don't do gsi_prev in that case.  */
    6255                 :      73574 :                   if (gsi_end_p (gsi))
    6256                 :            :                     {
    6257                 :        482 :                       gsi = gsi_last_bb (bb);
    6258                 :        482 :                       do_prev = false;
    6259                 :            :                     }
    6260                 :            :                 }
    6261                 :     232659 :               continue;
    6262                 :            :             }
    6263                 :            : 
    6264                 :            :           /* If this is not a gimple binary expression, there is
    6265                 :            :              nothing for us to do with it.  */
    6266                 :   29985700 :           if (get_gimple_rhs_class (rhs_code) != GIMPLE_BINARY_RHS)
    6267                 :   23032900 :             continue;
    6268                 :            : 
    6269                 :    6952760 :           lhs = gimple_assign_lhs (stmt);
    6270                 :    6952760 :           rhs1 = gimple_assign_rhs1 (stmt);
    6271                 :    6952760 :           rhs2 = gimple_assign_rhs2 (stmt);
    6272                 :            : 
    6273                 :            :           /* For non-bit or min/max operations we can't associate
    6274                 :            :              all types.  Verify that here.  */
    6275                 :   10617900 :           if (rhs_code != BIT_IOR_EXPR
    6276                 :    6952760 :               && rhs_code != BIT_AND_EXPR
    6277                 :    6378180 :               && rhs_code != BIT_XOR_EXPR
    6278                 :    6378180 :               && rhs_code != MIN_EXPR
    6279                 :    6297590 :               && rhs_code != MAX_EXPR
    6280                 :   13194200 :               && (!can_reassociate_p (lhs)
    6281                 :    2989130 :                   || !can_reassociate_p (rhs1)
    6282                 :    2668630 :                   || !can_reassociate_p (rhs2)))
    6283                 :    3665130 :             continue;
    6284                 :            : 
    6285                 :    3287620 :           if (associative_tree_code (rhs_code))
    6286                 :            :             {
    6287                 :    5269920 :               auto_vec<operand_entry *> ops;
    6288                 :    2651110 :               tree powi_result = NULL_TREE;
    6289                 :    2651110 :               bool is_vector = VECTOR_TYPE_P (TREE_TYPE (lhs));
    6290                 :            : 
    6291                 :            :               /* There may be no immediate uses left by the time we
    6292                 :            :                  get here because we may have eliminated them all.  */
    6293                 :    2651110 :               if (TREE_CODE (lhs) == SSA_NAME && has_zero_uses (lhs))
    6294                 :      32291 :                 continue;
    6295                 :            : 
    6296                 :    2618820 :               gimple_set_visited (stmt, true);
    6297                 :    2618820 :               linearize_expr_tree (&ops, stmt, true, true);
    6298                 :    2618820 :               ops.qsort (sort_by_operand_rank);
    6299                 :    2618820 :               int orig_len = ops.length ();
    6300                 :    2618820 :               optimize_ops_list (rhs_code, &ops);
    6301                 :    5237630 :               if (undistribute_ops_list (rhs_code, &ops,
    6302                 :            :                                          loop_containing_stmt (stmt)))
    6303                 :            :                 {
    6304                 :        106 :                   ops.qsort (sort_by_operand_rank);
    6305                 :        106 :                   optimize_ops_list (rhs_code, &ops);
    6306                 :            :                 }
    6307                 :    5237630 :               if (undistribute_bitref_for_vector (rhs_code, &ops,
    6308                 :            :                                                   loop_containing_stmt (stmt)))
    6309                 :            :                 {
    6310                 :         30 :                   ops.qsort (sort_by_operand_rank);
    6311                 :         30 :                   optimize_ops_list (rhs_code, &ops);
    6312                 :            :                 }
    6313                 :    2618820 :               if (rhs_code == PLUS_EXPR
    6314                 :    2618820 :                   && transform_add_to_multiply (&ops))
    6315                 :         67 :                 ops.qsort (sort_by_operand_rank);
    6316                 :            : 
    6317                 :    2618820 :               if (rhs_code == BIT_IOR_EXPR || rhs_code == BIT_AND_EXPR)
    6318                 :            :                 {
    6319                 :     568132 :                   if (is_vector)
    6320                 :       4025 :                     optimize_vec_cond_expr (rhs_code, &ops);
    6321                 :            :                   else
    6322                 :     564107 :                     optimize_range_tests (rhs_code, &ops, NULL);
    6323                 :            :                 }
    6324                 :            : 
    6325                 :    2618820 :               if (rhs_code == MULT_EXPR && !is_vector)
    6326                 :            :                 {
    6327                 :     657312 :                   attempt_builtin_copysign (&ops);
    6328                 :            : 
    6329                 :     657312 :                   if (reassoc_insert_powi_p
    6330                 :     270302 :                       && flag_unsafe_math_optimizations)
    6331                 :      41218 :                     powi_result = attempt_builtin_powi (stmt, &ops);
    6332                 :            :                 }
    6333                 :            : 
    6334                 :    2618820 :               operand_entry *last;
    6335                 :    2618820 :               bool negate_result = false;
    6336                 :    2618820 :               if (ops.length () > 1
    6337                 :    2618820 :                   && rhs_code == MULT_EXPR)
    6338                 :            :                 {
    6339                 :     671010 :                   last = ops.last ();
    6340                 :     671010 :                   if ((integer_minus_onep (last->op)
    6341                 :     670930 :                        || real_minus_onep (last->op))
    6342                 :        104 :                       && !HONOR_SNANS (TREE_TYPE (lhs))
    6343                 :     671114 :                       && (!HONOR_SIGNED_ZEROS (TREE_TYPE (lhs))
    6344                 :          0 :                           || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (lhs))))
    6345                 :            :                     {
    6346                 :        104 :                       ops.pop ();
    6347                 :        104 :                       negate_result = true;
    6348                 :            :                     }
    6349                 :            :                 }
    6350                 :            : 
    6351                 :    2618820 :               tree new_lhs = lhs;
    6352                 :            :               /* If the operand vector is now empty, all operands were 
    6353                 :            :                  consumed by the __builtin_powi optimization.  */
    6354                 :    2618820 :               if (ops.length () == 0)
    6355                 :        470 :                 transform_stmt_to_copy (&gsi, stmt, powi_result);
    6356                 :    2618350 :               else if (ops.length () == 1)
    6357                 :            :                 {
    6358                 :       8272 :                   tree last_op = ops.last ()->op;
    6359                 :            : 
    6360                 :            :                   /* If the stmt that defines operand has to be inserted, insert it
    6361                 :            :                      before the use.  */
    6362                 :       8272 :                   if (ops.last ()->stmt_to_insert)
    6363                 :          0 :                     insert_stmt_before_use (stmt, ops.last ()->stmt_to_insert);
    6364                 :       8272 :                   if (powi_result)
    6365                 :         30 :                     transform_stmt_to_multiply (&gsi, stmt, last_op,
    6366                 :            :                                                 powi_result);
    6367                 :            :                   else
    6368                 :       8242 :                     transform_stmt_to_copy (&gsi, stmt, last_op);
    6369                 :            :                 }
    6370                 :            :               else
    6371                 :            :                 {
    6372                 :    2610080 :                   machine_mode mode = TYPE_MODE (TREE_TYPE (lhs));
    6373                 :    2610080 :                   int ops_num = ops.length ();
    6374                 :    2610080 :                   int width;
    6375                 :            : 
    6376                 :            :                   /* For binary bit operations, if there are at least 3
    6377                 :            :                      operands and the last operand in OPS is a constant,
    6378                 :            :                      move it to the front.  This helps ensure that we generate
    6379                 :            :                      (X & Y) & C rather than (X & C) & Y.  The former will
    6380                 :            :                      often match a canonical bit test when we get to RTL.  */
    6381                 :    2610080 :                   if (ops.length () > 2
    6382                 :     103345 :                       && (rhs_code == BIT_AND_EXPR
    6383                 :            :                           || rhs_code == BIT_IOR_EXPR
    6384                 :      92415 :                           || rhs_code == BIT_XOR_EXPR)
    6385                 :    2623520 :                       && TREE_CODE (ops.last ()->op) == INTEGER_CST)
    6386                 :       1108 :                     std::swap (*ops[0], *ops[ops_num - 1]);
    6387                 :            : 
    6388                 :            :                   /* Only rewrite the expression tree to parallel in the
    6389                 :            :                      last reassoc pass to avoid useless work back-and-forth
    6390                 :            :                      with initial linearization.  */
    6391                 :    2610080 :                   if (!reassoc_insert_powi_p
    6392                 :    1601200 :                       && ops.length () > 3
    6393                 :    2618150 :                       && (width = get_reassociation_width (ops_num, rhs_code,
    6394                 :            :                                                            mode)) > 1)
    6395                 :            :                     {
    6396                 :        658 :                       if (dump_file && (dump_flags & TDF_DETAILS))
    6397                 :          1 :                         fprintf (dump_file,
    6398                 :            :                                  "Width = %d was chosen for reassociation\n",
    6399                 :            :                                  width);
    6400                 :        658 :                       rewrite_expr_tree_parallel (as_a <gassign *> (stmt),
    6401                 :            :                                                   width, ops);
    6402                 :            :                     }
    6403                 :            :                   else
    6404                 :            :                     {
    6405                 :            :                       /* When there are three operands left, we want
    6406                 :            :                          to make sure the ones that get the double
    6407                 :            :                          binary op are chosen wisely.  */
    6408                 :    2609420 :                       int len = ops.length ();
    6409                 :    2609420 :                       if (len >= 3)
    6410                 :     102687 :                         swap_ops_for_binary_stmt (ops, len - 3, stmt);
    6411                 :            : 
    6412                 :    2609420 :                       new_lhs = rewrite_expr_tree (stmt, 0, ops,
    6413                 :    2609420 :                                                    powi_result != NULL
    6414                 :    2609420 :                                                    || negate_result,
    6415                 :            :                                                    len != orig_len);
    6416                 :            :                     }
    6417                 :            : 
    6418                 :            :                   /* If we combined some repeated factors into a 
    6419                 :            :                      __builtin_powi call, multiply that result by the
    6420                 :            :                      reassociated operands.  */
    6421                 :    2610080 :                   if (powi_result)
    6422                 :            :                     {
    6423                 :         56 :                       gimple *mul_stmt, *lhs_stmt = SSA_NAME_DEF_STMT (lhs);
    6424                 :         56 :                       tree type = TREE_TYPE (lhs);
    6425                 :         56 :                       tree target_ssa = make_temp_ssa_name (type, NULL,
    6426                 :            :                                                             "reassocpow");
    6427                 :         56 :                       gimple_set_lhs (lhs_stmt, target_ssa);
    6428                 :         56 :                       update_stmt (lhs_stmt);
    6429                 :         56 :                       if (lhs != new_lhs)
    6430                 :            :                         {
    6431                 :         56 :                           target_ssa = new_lhs;
    6432                 :         56 :                           new_lhs = lhs;
    6433                 :            :                         }
    6434                 :         56 :                       mul_stmt = gimple_build_assign (lhs, MULT_EXPR,
    6435                 :            :                                                       powi_result, target_ssa);
    6436                 :         56 :                       gimple_set_location (mul_stmt, gimple_location (stmt));
    6437                 :         56 :                       gimple_set_uid (mul_stmt, gimple_uid (stmt));
    6438                 :         56 :                       gsi_insert_after (&gsi, mul_stmt, GSI_NEW_STMT);
    6439                 :            :                     }
    6440                 :            :                 }
    6441                 :            : 
    6442                 :    2618820 :               if (negate_result)
    6443                 :            :                 {
    6444                 :        104 :                   stmt = SSA_NAME_DEF_STMT (lhs);
    6445                 :        104 :                   tree tmp = make_ssa_name (TREE_TYPE (lhs));
    6446                 :        104 :                   gimple_set_lhs (stmt, tmp);
    6447                 :        104 :                   if (lhs != new_lhs)
    6448                 :         95 :                     tmp = new_lhs;
    6449                 :        104 :                   gassign *neg_stmt = gimple_build_assign (lhs, NEGATE_EXPR,
    6450                 :            :                                                            tmp);
    6451                 :        104 :                   gimple_set_uid (neg_stmt, gimple_uid (stmt));
    6452                 :        104 :                   gsi_insert_after (&gsi, neg_stmt, GSI_NEW_STMT);
    6453                 :    2618920 :                   update_stmt (stmt);
    6454                 :            :                 }
    6455                 :            :             }
    6456                 :            :         }
    6457                 :            :     }
    6458                 :   14034700 :   for (son = first_dom_son (CDI_POST_DOMINATORS, bb);
    6459                 :   26697100 :        son;
    6460                 :   12662400 :        son = next_dom_son (CDI_POST_DOMINATORS, son))
    6461                 :   12662400 :     cfg_cleanup_needed |= reassociate_bb (son);
    6462                 :            : 
    6463                 :   14034700 :   return cfg_cleanup_needed;
    6464                 :            : }
    6465                 :            : 
    6466                 :            : /* Add jumps around shifts for range tests turned into bit tests.
    6467                 :            :    For each SSA_NAME VAR we have code like:
    6468                 :            :    VAR = ...; // final stmt of range comparison
    6469                 :            :    // bit test here...;
    6470                 :            :    OTHERVAR = ...; // final stmt of the bit test sequence
    6471                 :            :    RES = VAR | OTHERVAR;
    6472                 :            :    Turn the above into:
    6473                 :            :    VAR = ...;
    6474                 :            :    if (VAR != 0)
    6475                 :            :      goto <l3>;
    6476                 :            :    else
    6477                 :            :      goto <l2>;
    6478                 :            :    <l2>:
    6479                 :            :    // bit test here...;
    6480                 :            :    OTHERVAR = ...;
    6481                 :            :    <l3>:
    6482                 :            :    # RES = PHI<1(l1), OTHERVAR(l2)>;  */
    6483                 :            : 
    6484                 :            : static void
    6485                 :    1372280 : branch_fixup (void)
    6486                 :            : {
    6487                 :    1372280 :   tree var;
    6488                 :    1372280 :   unsigned int i;
    6489                 :            : 
    6490                 :    1373080 :   FOR_EACH_VEC_ELT (reassoc_branch_fixups, i, var)
    6491                 :            :     {
    6492                 :        798 :       gimple *def_stmt = SSA_NAME_DEF_STMT (var);
    6493                 :        798 :       gimple *use_stmt;
    6494                 :        798 :       use_operand_p use;
    6495                 :        798 :       bool ok = single_imm_use (var, &use, &use_stmt);
    6496                 :        798 :       gcc_assert (ok
    6497                 :            :                   && is_gimple_assign (use_stmt)
    6498                 :            :                   && gimple_assign_rhs_code (use_stmt) == BIT_IOR_EXPR
    6499                 :            :                   && gimple_bb (def_stmt) == gimple_bb (use_stmt));
    6500                 :            : 
    6501                 :        798 :       basic_block cond_bb = gimple_bb (def_stmt);
    6502                 :        798 :       basic_block then_bb = split_block (cond_bb, def_stmt)->dest;
    6503                 :        798 :       basic_block merge_bb = split_block (then_bb, use_stmt)->dest;
    6504                 :            : 
    6505                 :        798 :       gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
    6506                 :        798 :       gimple *g = gimple_build_cond (NE_EXPR, var,
    6507                 :        798 :                                      build_zero_cst (TREE_TYPE (var)),
    6508                 :            :                                      NULL_TREE, NULL_TREE);
    6509                 :        798 :       location_t loc = gimple_location (use_stmt);
    6510                 :        798 :       gimple_set_location (g, loc);
    6511                 :        798 :       gsi_insert_after (&gsi, g, GSI_NEW_STMT);
    6512                 :            : 
    6513                 :        798 :       edge etrue = make_edge (cond_bb, merge_bb, EDGE_TRUE_VALUE);
    6514                 :        798 :       etrue->probability = profile_probability::even ();
    6515                 :        798 :       edge efalse = find_edge (cond_bb, then_bb);
    6516                 :        798 :       efalse->flags = EDGE_FALSE_VALUE;
    6517                 :        798 :       efalse->probability -= etrue->probability;
    6518                 :        798 :       then_bb->count -= etrue->count ();
    6519                 :            : 
    6520                 :        798 :       tree othervar = NULL_TREE;
    6521                 :        798 :       if (gimple_assign_rhs1 (use_stmt) == var)
    6522                 :          0 :         othervar = gimple_assign_rhs2 (use_stmt);
    6523                 :        798 :       else if (gimple_assign_rhs2 (use_stmt) == var)
    6524                 :        798 :         othervar = gimple_assign_rhs1 (use_stmt);
    6525                 :            :       else
    6526                 :          0 :         gcc_unreachable ();
    6527                 :        798 :       tree lhs = gimple_assign_lhs (use_stmt);
    6528                 :        798 :       gphi *phi = create_phi_node (lhs, merge_bb);
    6529                 :        798 :       add_phi_arg (phi, build_one_cst (TREE_TYPE (lhs)), etrue, loc);
    6530                 :        798 :       add_phi_arg (phi, othervar, single_succ_edge (then_bb), loc);
    6531                 :        798 :       gsi = gsi_for_stmt (use_stmt);
    6532                 :        798 :       gsi_remove (&gsi, true);
    6533                 :            : 
    6534                 :        798 :       set_immediate_dominator (CDI_DOMINATORS, merge_bb, cond_bb);
    6535                 :        798 :       set_immediate_dominator (CDI_POST_DOMINATORS, cond_bb, merge_bb);
    6536                 :            :     }
    6537                 :    1372280 :   reassoc_branch_fixups.release ();
    6538                 :    1372280 : }
    6539                 :            : 
    6540                 :            : void dump_ops_vector (FILE *file, vec<operand_entry *> ops);
    6541                 :            : void debug_ops_vector (vec<operand_entry *> ops);
    6542                 :            : 
    6543                 :            : /* Dump the operand entry vector OPS to FILE.  */
    6544                 :            : 
    6545                 :            : void
    6546                 :          0 : dump_ops_vector (FILE *file, vec<operand_entry *> ops)
    6547                 :            : {
    6548                 :          0 :   operand_entry *oe;
    6549                 :          0 :   unsigned int i;
    6550                 :            : 
    6551                 :          0 :   FOR_EACH_VEC_ELT (ops, i, oe)
    6552                 :            :     {
    6553                 :          0 :       fprintf (file, "Op %d -> rank: %d, tree: ", i, oe->rank);
    6554                 :          0 :       print_generic_expr (file, oe->op);
    6555                 :          0 :       fprintf (file, "\n");
    6556                 :            :     }
    6557                 :          0 : }
    6558                 :            : 
    6559                 :            : /* Dump the operand entry vector OPS to STDERR.  */
    6560                 :            : 
    6561                 :            : DEBUG_FUNCTION void
    6562                 :          0 : debug_ops_vector (vec<operand_entry *> ops)
    6563                 :            : {
    6564                 :          0 :   dump_ops_vector (stderr, ops);
    6565                 :          0 : }
    6566                 :            : 
    6567                 :            : /* Bubble up return status from reassociate_bb.  */
    6568                 :            : 
    6569                 :            : static bool
    6570                 :    1372280 : do_reassoc (void)
    6571                 :            : {
    6572                 :    1372280 :   break_up_subtract_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    6573                 :    1372280 :   return reassociate_bb (EXIT_BLOCK_PTR_FOR_FN (cfun));
    6574                 :            : }
    6575                 :            : 
    6576                 :            : /* Initialize the reassociation pass.  */
    6577                 :            : 
    6578                 :            : static void
    6579                 :    1372280 : init_reassoc (void)
    6580                 :            : {
    6581                 :    1372280 :   int i;
    6582                 :    1372280 :   long rank = 2;
    6583                 :    1372280 :   int *bbs = XNEWVEC (int, n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS);
    6584                 :            : 
    6585                 :            :   /* Find the loops, so that we can prevent moving calculations in
    6586                 :            :      them.  */
    6587                 :    1372280 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    6588                 :            : 
    6589                 :    1372280 :   memset (&reassociate_stats, 0, sizeof (reassociate_stats));
    6590                 :            : 
    6591                 :    1372280 :   next_operand_entry_id = 0;
    6592                 :            : 
    6593                 :            :   /* Reverse RPO (Reverse Post Order) will give us something where
    6594                 :            :      deeper loops come later.  */
    6595                 :    1372280 :   pre_and_rev_post_order_compute (NULL, bbs, false);
    6596                 :    1372280 :   bb_rank = XCNEWVEC (long, last_basic_block_for_fn (cfun));
    6597                 :    1372280 :   operand_rank = new hash_map<tree, long>;
    6598                 :            : 
    6599                 :            :   /* Give each default definition a distinct rank.  This includes
    6600                 :            :      parameters and the static chain.  Walk backwards over all
    6601                 :            :      SSA names so that we get proper rank ordering according
    6602                 :            :      to tree_swap_operands_p.  */
    6603                 :   68653900 :   for (i = num_ssa_names - 1; i > 0; --i)
    6604                 :            :     {
    6605                 :   65909400 :       tree name = ssa_name (i);
    6606                 :  115872000 :       if (name && SSA_NAME_IS_DEFAULT_DEF (name))
    6607                 :    3823710 :         insert_operand_rank (name, ++rank);
    6608                 :            :     }
    6609                 :            : 
    6610                 :            :   /* Set up rank for each BB  */
    6611                 :   14034700 :   for (i = 0; i < n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS; i++)
    6612                 :   12662400 :     bb_rank[bbs[i]] = ++rank << 16;
    6613                 :            : 
    6614                 :    1372280 :   free (bbs);
    6615                 :    1372280 :   calculate_dominance_info (CDI_POST_DOMINATORS);
    6616                 :    1372280 :   plus_negates = vNULL;
    6617                 :    1372280 : }
    6618                 :            : 
    6619                 :            : /* Cleanup after the reassociation pass, and print stats if
    6620                 :            :    requested.  */
    6621                 :            : 
    6622                 :            : static void
    6623                 :    1372280 : fini_reassoc (void)
    6624                 :            : {
    6625                 :    1372280 :   statistics_counter_event (cfun, "Linearized",
    6626                 :            :                             reassociate_stats.linearized);
    6627                 :    1372280 :   statistics_counter_event (cfun, "Constants eliminated",
    6628                 :            :                             reassociate_stats.constants_eliminated);
    6629                 :    1372280 :   statistics_counter_event (cfun, "Ops eliminated",
    6630                 :            :                             reassociate_stats.ops_eliminated);
    6631                 :    1372280 :   statistics_counter_event (cfun, "Statements rewritten",
    6632                 :            :                             reassociate_stats.rewritten);
    6633                 :    1372280 :   statistics_counter_event (cfun, "Built-in pow[i] calls encountered",
    6634                 :            :                             reassociate_stats.pows_encountered);
    6635                 :    1372280 :   statistics_counter_event (cfun, "Built-in powi calls created",
    6636                 :            :                             reassociate_stats.pows_created);
    6637                 :            : 
    6638                 :    2744560 :   delete operand_rank;
    6639                 :    1372280 :   operand_entry_pool.release ();
    6640                 :    1372280 :   free (bb_rank);
    6641                 :    1372280 :   plus_negates.release ();
    6642                 :    1372280 :   free_dominance_info (CDI_POST_DOMINATORS);
    6643                 :    1372280 :   loop_optimizer_finalize ();
    6644                 :    1372280 : }
    6645                 :            : 
    6646                 :            : /* Gate and execute functions for Reassociation.  If INSERT_POWI_P, enable
    6647                 :            :    insertion of __builtin_powi calls.
    6648                 :            : 
    6649                 :            :    Returns TODO_cfg_cleanup if a CFG cleanup pass is desired due to
    6650                 :            :    optimization of a gimple conditional.  Otherwise returns zero.  */
    6651                 :            : 
    6652                 :            : static unsigned int
    6653                 :    1372280 : execute_reassoc (bool insert_powi_p)
    6654                 :            : {
    6655                 :    1372280 :   reassoc_insert_powi_p = insert_powi_p;
    6656                 :            : 
    6657                 :    1372280 :   init_reassoc ();
    6658                 :            : 
    6659                 :    1372280 :   bool cfg_cleanup_needed;
    6660                 :    1372280 :   cfg_cleanup_needed = do_reassoc ();
    6661                 :    1372280 :   repropagate_negates ();
    6662                 :    1372280 :   branch_fixup ();
    6663                 :            : 
    6664                 :    1372280 :   fini_reassoc ();
    6665                 :    1372280 :   return cfg_cleanup_needed ? TODO_cleanup_cfg : 0;
    6666                 :            : }
    6667                 :            : 
    6668                 :            : namespace {
    6669                 :            : 
    6670                 :            : const pass_data pass_data_reassoc =
    6671                 :            : {
    6672                 :            :   GIMPLE_PASS, /* type */
    6673                 :            :   "reassoc", /* name */
    6674                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    6675                 :            :   TV_TREE_REASSOC, /* tv_id */
    6676                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
    6677                 :            :   0, /* properties_provided */
    6678                 :            :   0, /* properties_destroyed */
    6679                 :            :   0, /* todo_flags_start */
    6680                 :            :   TODO_update_ssa_only_virtuals, /* todo_flags_finish */
    6681                 :            : };
    6682                 :            : 
    6683                 :            : class pass_reassoc : public gimple_opt_pass
    6684                 :            : {
    6685                 :            : public:
    6686                 :     402880 :   pass_reassoc (gcc::context *ctxt)
    6687                 :     805760 :     : gimple_opt_pass (pass_data_reassoc, ctxt), insert_powi_p (false)
    6688                 :            :   {}
    6689                 :            : 
    6690                 :            :   /* opt_pass methods: */
    6691                 :     201440 :   opt_pass * clone () { return new pass_reassoc (m_ctxt); }
    6692                 :     402880 :   void set_pass_param (unsigned int n, bool param)
    6693                 :            :     {
    6694                 :     402880 :       gcc_assert (n == 0);
    6695                 :     402880 :       insert_powi_p = param;
    6696                 :     402880 :     }
    6697                 :    1372410 :   virtual bool gate (function *) { return flag_tree_reassoc != 0; }
    6698                 :    1372280 :   virtual unsigned int execute (function *)
    6699                 :    1372280 :     { return execute_reassoc (insert_powi_p); }
    6700                 :            : 
    6701                 :            :  private:
    6702                 :            :   /* Enable insertion of __builtin_powi calls during execute_reassoc.  See
    6703                 :            :      point 3a in the pass header comment.  */
    6704                 :            :   bool insert_powi_p;
    6705                 :            : }; // class pass_reassoc
    6706                 :            : 
    6707                 :            : } // anon namespace
    6708                 :            : 
    6709                 :            : gimple_opt_pass *
    6710                 :     201440 : make_pass_reassoc (gcc::context *ctxt)
    6711                 :            : {
    6712                 :     201440 :   return new pass_reassoc (ctxt);
    6713                 :            : }

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.