LCOV - code coverage report
Current view: top level - gcc - tree-ssa-phiopt.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1214 1260 96.3 %
Date: 2020-03-28 11:57:23 Functions: 35 36 97.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Optimization of PHI nodes by converting them into straightline code.
       2                 :            :    Copyright (C) 2004-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it
       7                 :            : under the terms of the GNU General Public License as published by the
       8                 :            : Free Software Foundation; either version 3, or (at your option) any
       9                 :            : later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT
      12                 :            : ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "insn-codes.h"
      25                 :            : #include "rtl.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "cfghooks.h"
      29                 :            : #include "tree-pass.h"
      30                 :            : #include "ssa.h"
      31                 :            : #include "optabs-tree.h"
      32                 :            : #include "insn-config.h"
      33                 :            : #include "gimple-pretty-print.h"
      34                 :            : #include "fold-const.h"
      35                 :            : #include "stor-layout.h"
      36                 :            : #include "cfganal.h"
      37                 :            : #include "gimplify.h"
      38                 :            : #include "gimple-iterator.h"
      39                 :            : #include "gimplify-me.h"
      40                 :            : #include "tree-cfg.h"
      41                 :            : #include "tree-dfa.h"
      42                 :            : #include "domwalk.h"
      43                 :            : #include "cfgloop.h"
      44                 :            : #include "tree-data-ref.h"
      45                 :            : #include "tree-scalar-evolution.h"
      46                 :            : #include "tree-inline.h"
      47                 :            : #include "case-cfn-macros.h"
      48                 :            : 
      49                 :            : static unsigned int tree_ssa_phiopt_worker (bool, bool, bool);
      50                 :            : static bool two_value_replacement (basic_block, basic_block, edge, gphi *,
      51                 :            :                                    tree, tree);
      52                 :            : static bool conditional_replacement (basic_block, basic_block,
      53                 :            :                                      edge, edge, gphi *, tree, tree);
      54                 :            : static gphi *factor_out_conditional_conversion (edge, edge, gphi *, tree, tree,
      55                 :            :                                                 gimple *);
      56                 :            : static int value_replacement (basic_block, basic_block,
      57                 :            :                               edge, edge, gimple *, tree, tree);
      58                 :            : static bool minmax_replacement (basic_block, basic_block,
      59                 :            :                                 edge, edge, gimple *, tree, tree);
      60                 :            : static bool abs_replacement (basic_block, basic_block,
      61                 :            :                              edge, edge, gimple *, tree, tree);
      62                 :            : static bool cond_removal_in_popcount_pattern (basic_block, basic_block,
      63                 :            :                                               edge, edge, gimple *, tree, tree);
      64                 :            : static bool cond_store_replacement (basic_block, basic_block, edge, edge,
      65                 :            :                                     hash_set<tree> *);
      66                 :            : static bool cond_if_else_store_replacement (basic_block, basic_block, basic_block);
      67                 :            : static hash_set<tree> * get_non_trapping ();
      68                 :            : static void replace_phi_edge_with_variable (basic_block, edge, gimple *, tree);
      69                 :            : static void hoist_adjacent_loads (basic_block, basic_block,
      70                 :            :                                   basic_block, basic_block);
      71                 :            : static bool gate_hoist_loads (void);
      72                 :            : 
      73                 :            : /* This pass tries to transform conditional stores into unconditional
      74                 :            :    ones, enabling further simplifications with the simpler then and else
      75                 :            :    blocks.  In particular it replaces this:
      76                 :            : 
      77                 :            :      bb0:
      78                 :            :        if (cond) goto bb2; else goto bb1;
      79                 :            :      bb1:
      80                 :            :        *p = RHS;
      81                 :            :      bb2:
      82                 :            : 
      83                 :            :    with
      84                 :            : 
      85                 :            :      bb0:
      86                 :            :        if (cond) goto bb1; else goto bb2;
      87                 :            :      bb1:
      88                 :            :        condtmp' = *p;
      89                 :            :      bb2:
      90                 :            :        condtmp = PHI <RHS, condtmp'>
      91                 :            :        *p = condtmp;
      92                 :            : 
      93                 :            :    This transformation can only be done under several constraints,
      94                 :            :    documented below.  It also replaces:
      95                 :            : 
      96                 :            :      bb0:
      97                 :            :        if (cond) goto bb2; else goto bb1;
      98                 :            :      bb1:
      99                 :            :        *p = RHS1;
     100                 :            :        goto bb3;
     101                 :            :      bb2:
     102                 :            :        *p = RHS2;
     103                 :            :      bb3:
     104                 :            : 
     105                 :            :    with
     106                 :            : 
     107                 :            :      bb0:
     108                 :            :        if (cond) goto bb3; else goto bb1;
     109                 :            :      bb1:
     110                 :            :      bb3:
     111                 :            :        condtmp = PHI <RHS1, RHS2>
     112                 :            :        *p = condtmp;  */
     113                 :            : 
     114                 :            : static unsigned int
     115                 :     685611 : tree_ssa_cs_elim (void)
     116                 :            : {
     117                 :     685611 :   unsigned todo;
     118                 :            :   /* ???  We are not interested in loop related info, but the following
     119                 :            :      will create it, ICEing as we didn't init loops with pre-headers.
     120                 :            :      An interfacing issue of find_data_references_in_bb.  */
     121                 :     685611 :   loop_optimizer_init (LOOPS_NORMAL);
     122                 :     685611 :   scev_initialize ();
     123                 :     685611 :   todo = tree_ssa_phiopt_worker (true, false, false);
     124                 :     685611 :   scev_finalize ();
     125                 :     685611 :   loop_optimizer_finalize ();
     126                 :     685611 :   return todo;
     127                 :            : }
     128                 :            : 
     129                 :            : /* Return the singleton PHI in the SEQ of PHIs for edges E0 and E1. */
     130                 :            : 
     131                 :            : static gphi *
     132                 :    1746440 : single_non_singleton_phi_for_edges (gimple_seq seq, edge e0, edge e1)
     133                 :            : {
     134                 :    1746440 :   gimple_stmt_iterator i;
     135                 :    1746440 :   gphi *phi = NULL;
     136                 :    1746440 :   if (gimple_seq_singleton_p (seq))
     137                 :    1412730 :     return as_a <gphi *> (gsi_stmt (gsi_start (seq)));
     138                 :     818657 :   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
     139                 :            :     {
     140                 :     721629 :       gphi *p = as_a <gphi *> (gsi_stmt (i));
     141                 :            :       /* If the PHI arguments are equal then we can skip this PHI. */
     142                 :     721629 :       if (operand_equal_for_phi_arg_p (gimple_phi_arg_def (p, e0->dest_idx),
     143                 :     721629 :                                        gimple_phi_arg_def (p, e1->dest_idx)))
     144                 :     157327 :         continue;
     145                 :            : 
     146                 :            :       /* If we already have a PHI that has the two edge arguments are
     147                 :            :          different, then return it is not a singleton for these PHIs. */
     148                 :     564302 :       if (phi)
     149                 :            :         return NULL;
     150                 :            : 
     151                 :            :       phi = p;
     152                 :            :     }
     153                 :            :   return phi;
     154                 :            : }
     155                 :            : 
     156                 :            : /* The core routine of conditional store replacement and normal
     157                 :            :    phi optimizations.  Both share much of the infrastructure in how
     158                 :            :    to match applicable basic block patterns.  DO_STORE_ELIM is true
     159                 :            :    when we want to do conditional store replacement, false otherwise.
     160                 :            :    DO_HOIST_LOADS is true when we want to hoist adjacent loads out
     161                 :            :    of diamond control flow patterns, false otherwise.  */
     162                 :            : static unsigned int
     163                 :    4324380 : tree_ssa_phiopt_worker (bool do_store_elim, bool do_hoist_loads, bool early_p)
     164                 :            : {
     165                 :    4324380 :   basic_block bb;
     166                 :    4324380 :   basic_block *bb_order;
     167                 :    4324380 :   unsigned n, i;
     168                 :    4324380 :   bool cfgchanged = false;
     169                 :    4324380 :   hash_set<tree> *nontrap = 0;
     170                 :            : 
     171                 :    4324380 :   if (do_store_elim)
     172                 :            :     /* Calculate the set of non-trapping memory accesses.  */
     173                 :     685611 :     nontrap = get_non_trapping ();
     174                 :            : 
     175                 :            :   /* Search every basic block for COND_EXPR we may be able to optimize.
     176                 :            : 
     177                 :            :      We walk the blocks in order that guarantees that a block with
     178                 :            :      a single predecessor is processed before the predecessor.
     179                 :            :      This ensures that we collapse inner ifs before visiting the
     180                 :            :      outer ones, and also that we do not try to visit a removed
     181                 :            :      block.  */
     182                 :    4324380 :   bb_order = single_pred_before_succ_order ();
     183                 :    4324380 :   n = n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS;
     184                 :            : 
     185                 :   38028700 :   for (i = 0; i < n; i++)
     186                 :            :     {
     187                 :   33704300 :       gimple *cond_stmt;
     188                 :   33704300 :       gphi *phi;
     189                 :   33704300 :       basic_block bb1, bb2;
     190                 :   33704300 :       edge e1, e2;
     191                 :   33704300 :       tree arg0, arg1;
     192                 :            : 
     193                 :   33704300 :       bb = bb_order[i];
     194                 :            : 
     195                 :   33704300 :       cond_stmt = last_stmt (bb);
     196                 :            :       /* Check to see if the last statement is a GIMPLE_COND.  */
     197                 :   54286300 :       if (!cond_stmt
     198                 :   33704300 :           || gimple_code (cond_stmt) != GIMPLE_COND)
     199                 :   33704300 :         continue;
     200                 :            : 
     201                 :   13122400 :       e1 = EDGE_SUCC (bb, 0);
     202                 :   13122400 :       bb1 = e1->dest;
     203                 :   13122400 :       e2 = EDGE_SUCC (bb, 1);
     204                 :   13122400 :       bb2 = e2->dest;
     205                 :            : 
     206                 :            :       /* We cannot do the optimization on abnormal edges.  */
     207                 :   13122400 :       if ((e1->flags & EDGE_ABNORMAL) != 0
     208                 :   13122400 :           || (e2->flags & EDGE_ABNORMAL) != 0)
     209                 :          0 :        continue;
     210                 :            : 
     211                 :            :       /* If either bb1's succ or bb2 or bb2's succ is non NULL.  */
     212                 :   13122400 :       if (EDGE_COUNT (bb1->succs) == 0
     213                 :   10584300 :           || bb2 == NULL
     214                 :   23025900 :           || EDGE_COUNT (bb2->succs) == 0)
     215                 :    3001860 :         continue;
     216                 :            : 
     217                 :            :       /* Find the bb which is the fall through to the other.  */
     218                 :   10120500 :       if (EDGE_SUCC (bb1, 0)->dest == bb2)
     219                 :            :         ;
     220                 :    8220980 :       else if (EDGE_SUCC (bb2, 0)->dest == bb1)
     221                 :            :         {
     222                 :    3032070 :           std::swap (bb1, bb2);
     223                 :    3032070 :           std::swap (e1, e2);
     224                 :            :         }
     225                 :    7088440 :       else if (do_store_elim
     226                 :    7088440 :                && EDGE_SUCC (bb1, 0)->dest == EDGE_SUCC (bb2, 0)->dest)
     227                 :            :         {
     228                 :     302511 :           basic_block bb3 = EDGE_SUCC (bb1, 0)->dest;
     229                 :            : 
     230                 :     302511 :           if (!single_succ_p (bb1)
     231                 :     245477 :               || (EDGE_SUCC (bb1, 0)->flags & EDGE_FALLTHRU) == 0
     232                 :     241058 :               || !single_succ_p (bb2)
     233                 :     220791 :               || (EDGE_SUCC (bb2, 0)->flags & EDGE_FALLTHRU) == 0
     234                 :     523302 :               || EDGE_COUNT (bb3->preds) != 2)
     235                 :     124033 :             continue;
     236                 :     178478 :           if (cond_if_else_store_replacement (bb1, bb2, bb3))
     237                 :       6403 :             cfgchanged = true;
     238                 :     178478 :           continue;
     239                 :            :         }
     240                 :   12712900 :       else if (do_hoist_loads
     241                 :    6785930 :                && EDGE_SUCC (bb1, 0)->dest == EDGE_SUCC (bb2, 0)->dest)
     242                 :            :         {
     243                 :     858992 :           basic_block bb3 = EDGE_SUCC (bb1, 0)->dest;
     244                 :            : 
     245                 :    1703270 :           if (!FLOAT_TYPE_P (TREE_TYPE (gimple_cond_lhs (cond_stmt)))
     246                 :     844212 :               && single_succ_p (bb1)
     247                 :     703927 :               && single_succ_p (bb2)
     248                 :     627554 :               && single_pred_p (bb1)
     249                 :     597115 :               && single_pred_p (bb2)
     250                 :     564317 :               && EDGE_COUNT (bb->succs) == 2
     251                 :    1322580 :               && EDGE_COUNT (bb3->preds) == 2
     252                 :            :               /* If one edge or the other is dominant, a conditional move
     253                 :            :                  is likely to perform worse than the well-predicted branch.  */
     254                 :     463592 :               && !predictable_edge_p (EDGE_SUCC (bb, 0))
     255                 :    1318370 :               && !predictable_edge_p (EDGE_SUCC (bb, 1)))
     256                 :     459378 :             hoist_adjacent_loads (bb, bb1, bb2, bb3);
     257                 :     858992 :           continue;
     258                 :            :         }
     259                 :            :       else
     260                 :    5926940 :         continue;
     261                 :            : 
     262                 :    3032070 :       e1 = EDGE_SUCC (bb1, 0);
     263                 :            : 
     264                 :            :       /* Make sure that bb1 is just a fall through.  */
     265                 :    3032070 :       if (!single_succ_p (bb1)
     266                 :    3032070 :           || (e1->flags & EDGE_FALLTHRU) == 0)
     267                 :     816302 :         continue;
     268                 :            : 
     269                 :            :       /* Also make sure that bb1 only have one predecessor and that it
     270                 :            :          is bb.  */
     271                 :    2215770 :       if (!single_pred_p (bb1)
     272                 :    2215770 :           || single_pred (bb1) != bb)
     273                 :      90229 :         continue;
     274                 :            : 
     275                 :    2125540 :       if (do_store_elim)
     276                 :            :         {
     277                 :            :           /* bb1 is the middle block, bb2 the join block, bb the split block,
     278                 :            :              e1 the fallthrough edge from bb1 to bb2.  We can't do the
     279                 :            :              optimization if the join block has more than two predecessors.  */
     280                 :     433865 :           if (EDGE_COUNT (bb2->preds) > 2)
     281                 :      89819 :             continue;
     282                 :     344046 :           if (cond_store_replacement (bb1, bb2, e1, e2, nontrap))
     283                 :       2254 :             cfgchanged = true;
     284                 :            :         }
     285                 :            :       else
     286                 :            :         {
     287                 :    1691670 :           gimple_seq phis = phi_nodes (bb2);
     288                 :    1691670 :           gimple_stmt_iterator gsi;
     289                 :    1691670 :           bool candorest = true;
     290                 :            : 
     291                 :            :           /* Value replacement can work with more than one PHI
     292                 :            :              so try that first. */
     293                 :    1691670 :           if (!early_p)
     294                 :    2849720 :             for (gsi = gsi_start (phis); !gsi_end_p (gsi); gsi_next (&gsi))
     295                 :            :               {
     296                 :    1608110 :                 phi = as_a <gphi *> (gsi_stmt (gsi));
     297                 :    1608110 :                 arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
     298                 :    1608110 :                 arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
     299                 :    1608110 :                 if (value_replacement (bb, bb1, e1, e2, phi, arg0, arg1) == 2)
     300                 :            :                   {
     301                 :            :                     candorest = false;
     302                 :            :                     cfgchanged = true;
     303                 :            :                     break;
     304                 :            :                   }
     305                 :            :               }
     306                 :            : 
     307                 :    1691670 :           if (!candorest)
     308                 :     232937 :             continue;
     309                 :            : 
     310                 :    1690520 :           phi = single_non_singleton_phi_for_edges (phis, e1, e2);
     311                 :    1690520 :           if (!phi)
     312                 :     231785 :             continue;
     313                 :            : 
     314                 :    1458740 :           arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
     315                 :    1458740 :           arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
     316                 :            : 
     317                 :            :           /* Something is wrong if we cannot find the arguments in the PHI
     318                 :            :              node.  */
     319                 :    1458740 :           gcc_assert (arg0 != NULL_TREE && arg1 != NULL_TREE);
     320                 :            : 
     321                 :    1458740 :           gphi *newphi = factor_out_conditional_conversion (e1, e2, phi,
     322                 :            :                                                             arg0, arg1,
     323                 :            :                                                             cond_stmt);
     324                 :    1458740 :           if (newphi != NULL)
     325                 :            :             {
     326                 :      10863 :               phi = newphi;
     327                 :            :               /* factor_out_conditional_conversion may create a new PHI in
     328                 :            :                  BB2 and eliminate an existing PHI in BB2.  Recompute values
     329                 :            :                  that may be affected by that change.  */
     330                 :      10863 :               arg0 = gimple_phi_arg_def (phi, e1->dest_idx);
     331                 :      10863 :               arg1 = gimple_phi_arg_def (phi, e2->dest_idx);
     332                 :      10863 :               gcc_assert (arg0 != NULL_TREE && arg1 != NULL_TREE);
     333                 :            :             }
     334                 :            : 
     335                 :            :           /* Do the replacement of conditional if it can be done.  */
     336                 :    1458740 :           if (two_value_replacement (bb, bb1, e2, phi, arg0, arg1))
     337                 :            :             cfgchanged = true;
     338                 :    1458180 :           else if (!early_p
     339                 :    1458180 :                    && conditional_replacement (bb, bb1, e1, e2, phi,
     340                 :            :                                                arg0, arg1))
     341                 :            :             cfgchanged = true;
     342                 :    1427800 :           else if (abs_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
     343                 :            :             cfgchanged = true;
     344                 :    1427680 :           else if (!early_p
     345                 :    1427680 :                    && cond_removal_in_popcount_pattern (bb, bb1, e1, e2,
     346                 :            :                                                         phi, arg0, arg1))
     347                 :            :             cfgchanged = true;
     348                 :    1427680 :           else if (minmax_replacement (bb, bb1, e1, e2, phi, arg0, arg1))
     349                 :      13268 :             cfgchanged = true;
     350                 :            :         }
     351                 :            :     }
     352                 :            : 
     353                 :    4324380 :   free (bb_order);
     354                 :            : 
     355                 :    4324380 :   if (do_store_elim)
     356                 :    1371220 :     delete nontrap;
     357                 :            :   /* If the CFG has changed, we should cleanup the CFG.  */
     358                 :    4324380 :   if (cfgchanged && do_store_elim)
     359                 :            :     {
     360                 :            :       /* In cond-store replacement we have added some loads on edges
     361                 :            :          and new VOPS (as we moved the store, and created a load).  */
     362                 :       3457 :       gsi_commit_edge_inserts ();
     363                 :       3457 :       return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals;
     364                 :            :     }
     365                 :    4320920 :   else if (cfgchanged)
     366                 :      34096 :     return TODO_cleanup_cfg;
     367                 :            :   return 0;
     368                 :            : }
     369                 :            : 
     370                 :            : /* Replace PHI node element whose edge is E in block BB with variable NEW.
     371                 :            :    Remove the edge from COND_BLOCK which does not lead to BB (COND_BLOCK
     372                 :            :    is known to have two edges, one of which must reach BB).  */
     373                 :            : 
     374                 :            : static void
     375                 :      45478 : replace_phi_edge_with_variable (basic_block cond_block,
     376                 :            :                                 edge e, gimple *phi, tree new_tree)
     377                 :            : {
     378                 :      45478 :   basic_block bb = gimple_bb (phi);
     379                 :      45478 :   basic_block block_to_remove;
     380                 :      45478 :   gimple_stmt_iterator gsi;
     381                 :            : 
     382                 :            :   /* Change the PHI argument to new.  */
     383                 :      45478 :   SET_USE (PHI_ARG_DEF_PTR (phi, e->dest_idx), new_tree);
     384                 :            : 
     385                 :            :   /* Remove the empty basic block.  */
     386                 :      45478 :   if (EDGE_SUCC (cond_block, 0)->dest == bb)
     387                 :            :     {
     388                 :      16542 :       EDGE_SUCC (cond_block, 0)->flags |= EDGE_FALLTHRU;
     389                 :      16542 :       EDGE_SUCC (cond_block, 0)->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
     390                 :      16542 :       EDGE_SUCC (cond_block, 0)->probability = profile_probability::always ();
     391                 :            : 
     392                 :      16542 :       block_to_remove = EDGE_SUCC (cond_block, 1)->dest;
     393                 :            :     }
     394                 :            :   else
     395                 :            :     {
     396                 :      28936 :       EDGE_SUCC (cond_block, 1)->flags |= EDGE_FALLTHRU;
     397                 :      28936 :       EDGE_SUCC (cond_block, 1)->flags
     398                 :      28936 :         &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
     399                 :      28936 :       EDGE_SUCC (cond_block, 1)->probability = profile_probability::always ();
     400                 :            : 
     401                 :      28936 :       block_to_remove = EDGE_SUCC (cond_block, 0)->dest;
     402                 :            :     }
     403                 :      45478 :   delete_basic_block (block_to_remove);
     404                 :            : 
     405                 :            :   /* Eliminate the COND_EXPR at the end of COND_BLOCK.  */
     406                 :      45478 :   gsi = gsi_last_bb (cond_block);
     407                 :      45478 :   gsi_remove (&gsi, true);
     408                 :            : 
     409                 :      45478 :   if (dump_file && (dump_flags & TDF_DETAILS))
     410                 :          4 :     fprintf (dump_file,
     411                 :            :               "COND_EXPR in block %d and PHI in block %d converted to straightline code.\n",
     412                 :            :               cond_block->index,
     413                 :            :               bb->index);
     414                 :      45478 : }
     415                 :            : 
     416                 :            : /* PR66726: Factor conversion out of COND_EXPR.  If the arguments of the PHI
     417                 :            :    stmt are CONVERT_STMT, factor out the conversion and perform the conversion
     418                 :            :    to the result of PHI stmt.  COND_STMT is the controlling predicate.
     419                 :            :    Return the newly-created PHI, if any.  */
     420                 :            : 
     421                 :            : static gphi *
     422                 :    1458740 : factor_out_conditional_conversion (edge e0, edge e1, gphi *phi,
     423                 :            :                                    tree arg0, tree arg1, gimple *cond_stmt)
     424                 :            : {
     425                 :    1458740 :   gimple *arg0_def_stmt = NULL, *arg1_def_stmt = NULL, *new_stmt;
     426                 :    1458740 :   tree new_arg0 = NULL_TREE, new_arg1 = NULL_TREE;
     427                 :    1458740 :   tree temp, result;
     428                 :    1458740 :   gphi *newphi;
     429                 :    1458740 :   gimple_stmt_iterator gsi, gsi_for_def;
     430                 :    1458740 :   location_t locus = gimple_location (phi);
     431                 :    1458740 :   enum tree_code convert_code;
     432                 :            : 
     433                 :            :   /* Handle only PHI statements with two arguments.  TODO: If all
     434                 :            :      other arguments to PHI are INTEGER_CST or if their defining
     435                 :            :      statement have the same unary operation, we can handle more
     436                 :            :      than two arguments too.  */
     437                 :    1458740 :   if (gimple_phi_num_args (phi) != 2)
     438                 :            :     return NULL;
     439                 :            : 
     440                 :            :   /* First canonicalize to simplify tests.  */
     441                 :    1174350 :   if (TREE_CODE (arg0) != SSA_NAME)
     442                 :            :     {
     443                 :     100158 :       std::swap (arg0, arg1);
     444                 :     100158 :       std::swap (e0, e1);
     445                 :            :     }
     446                 :            : 
     447                 :    1174350 :   if (TREE_CODE (arg0) != SSA_NAME
     448                 :    1116300 :       || (TREE_CODE (arg1) != SSA_NAME
     449                 :     205253 :           && TREE_CODE (arg1) != INTEGER_CST))
     450                 :            :     return NULL;
     451                 :            : 
     452                 :            :   /* Check if arg0 is an SSA_NAME and the stmt which defines arg0 is
     453                 :            :      a conversion.  */
     454                 :    1100370 :   arg0_def_stmt = SSA_NAME_DEF_STMT (arg0);
     455                 :    1100370 :   if (!gimple_assign_cast_p (arg0_def_stmt))
     456                 :            :     return NULL;
     457                 :            : 
     458                 :            :   /* Use the RHS as new_arg0.  */
     459                 :      41828 :   convert_code = gimple_assign_rhs_code (arg0_def_stmt);
     460                 :      41828 :   new_arg0 = gimple_assign_rhs1 (arg0_def_stmt);
     461                 :      41828 :   if (convert_code == VIEW_CONVERT_EXPR)
     462                 :            :     {
     463                 :        696 :       new_arg0 = TREE_OPERAND (new_arg0, 0);
     464                 :        696 :       if (!is_gimple_reg_type (TREE_TYPE (new_arg0)))
     465                 :            :         return NULL;
     466                 :            :     }
     467                 :            : 
     468                 :      41657 :   if (TREE_CODE (arg1) == SSA_NAME)
     469                 :            :     {
     470                 :            :       /* Check if arg1 is an SSA_NAME and the stmt which defines arg1
     471                 :            :          is a conversion.  */
     472                 :       4427 :       arg1_def_stmt = SSA_NAME_DEF_STMT (arg1);
     473                 :       4427 :       if (!is_gimple_assign (arg1_def_stmt)
     474                 :       4427 :           || gimple_assign_rhs_code (arg1_def_stmt) != convert_code)
     475                 :            :         return NULL;
     476                 :            : 
     477                 :            :       /* Use the RHS as new_arg1.  */
     478                 :       1173 :       new_arg1 = gimple_assign_rhs1 (arg1_def_stmt);
     479                 :       1173 :       if (convert_code == VIEW_CONVERT_EXPR)
     480                 :         68 :         new_arg1 = TREE_OPERAND (new_arg1, 0);
     481                 :            :     }
     482                 :            :   else
     483                 :            :     {
     484                 :            :       /* If arg1 is an INTEGER_CST, fold it to new type.  */
     485                 :      74270 :       if (INTEGRAL_TYPE_P (TREE_TYPE (new_arg0))
     486                 :      73605 :           && int_fits_type_p (arg1, TREE_TYPE (new_arg0)))
     487                 :            :         {
     488                 :      35329 :           if (gimple_assign_cast_p (arg0_def_stmt))
     489                 :            :             {
     490                 :            :               /* For the INTEGER_CST case, we are just moving the
     491                 :            :                  conversion from one place to another, which can often
     492                 :            :                  hurt as the conversion moves further away from the
     493                 :            :                  statement that computes the value.  So, perform this
     494                 :            :                  only if new_arg0 is an operand of COND_STMT, or
     495                 :            :                  if arg0_def_stmt is the only non-debug stmt in
     496                 :            :                  its basic block, because then it is possible this
     497                 :            :                  could enable further optimizations (minmax replacement
     498                 :            :                  etc.).  See PR71016.  */
     499                 :      35329 :               if (new_arg0 != gimple_cond_lhs (cond_stmt)
     500                 :      29111 :                   && new_arg0 != gimple_cond_rhs (cond_stmt)
     501                 :      60087 :                   && gimple_bb (arg0_def_stmt) == e0->src)
     502                 :            :                 {
     503                 :      22238 :                   gsi = gsi_for_stmt (arg0_def_stmt);
     504                 :      22238 :                   gsi_prev_nondebug (&gsi);
     505                 :      22238 :                   if (!gsi_end_p (gsi))
     506                 :            :                     {
     507                 :      20148 :                       if (gassign *assign
     508                 :      20148 :                             = dyn_cast <gassign *> (gsi_stmt (gsi)))
     509                 :            :                         {
     510                 :      19798 :                           tree lhs = gimple_assign_lhs (assign);
     511                 :      19798 :                           enum tree_code ass_code
     512                 :      19798 :                             = gimple_assign_rhs_code (assign);
     513                 :      19798 :                           if (ass_code != MAX_EXPR && ass_code != MIN_EXPR)
     514                 :            :                             return NULL;
     515                 :         90 :                           if (lhs != gimple_assign_rhs1 (arg0_def_stmt))
     516                 :            :                             return NULL;
     517                 :         90 :                           gsi_prev_nondebug (&gsi);
     518                 :         90 :                           if (!gsi_end_p (gsi))
     519                 :            :                             return NULL;
     520                 :            :                         }
     521                 :            :                       else
     522                 :            :                         return NULL;
     523                 :            :                     }
     524                 :       2126 :                   gsi = gsi_for_stmt (arg0_def_stmt);
     525                 :       2126 :                   gsi_next_nondebug (&gsi);
     526                 :       2126 :                   if (!gsi_end_p (gsi))
     527                 :            :                     return NULL;
     528                 :            :                 }
     529                 :      15175 :               new_arg1 = fold_convert (TREE_TYPE (new_arg0), arg1);
     530                 :            :             }
     531                 :            :           else
     532                 :            :             return NULL;
     533                 :            :         }
     534                 :            :       else
     535                 :            :         return NULL;
     536                 :            :     }
     537                 :            : 
     538                 :            :   /*  If arg0/arg1 have > 1 use, then this transformation actually increases
     539                 :            :       the number of expressions evaluated at runtime.  */
     540                 :      16348 :   if (!has_single_use (arg0)
     541                 :      16348 :       || (arg1_def_stmt && !has_single_use (arg1)))
     542                 :            :     return NULL;
     543                 :            : 
     544                 :            :   /* If types of new_arg0 and new_arg1 are different bailout.  */
     545                 :      10888 :   if (!types_compatible_p (TREE_TYPE (new_arg0), TREE_TYPE (new_arg1)))
     546                 :            :     return NULL;
     547                 :            : 
     548                 :            :   /* Create a new PHI stmt.  */
     549                 :      10863 :   result = PHI_RESULT (phi);
     550                 :      10863 :   temp = make_ssa_name (TREE_TYPE (new_arg0), NULL);
     551                 :      10863 :   newphi = create_phi_node (temp, gimple_bb (phi));
     552                 :            : 
     553                 :      10863 :   if (dump_file && (dump_flags & TDF_DETAILS))
     554                 :            :     {
     555                 :          1 :       fprintf (dump_file, "PHI ");
     556                 :          1 :       print_generic_expr (dump_file, gimple_phi_result (phi));
     557                 :          1 :       fprintf (dump_file,
     558                 :            :                " changed to factor conversion out from COND_EXPR.\n");
     559                 :          1 :       fprintf (dump_file, "New stmt with CAST that defines ");
     560                 :          1 :       print_generic_expr (dump_file, result);
     561                 :          1 :       fprintf (dump_file, ".\n");
     562                 :            :     }
     563                 :            : 
     564                 :            :   /* Remove the old cast(s) that has single use.  */
     565                 :      10863 :   gsi_for_def = gsi_for_stmt (arg0_def_stmt);
     566                 :      10863 :   gsi_remove (&gsi_for_def, true);
     567                 :      10863 :   release_defs (arg0_def_stmt);
     568                 :            : 
     569                 :      10863 :   if (arg1_def_stmt)
     570                 :            :     {
     571                 :        101 :       gsi_for_def = gsi_for_stmt (arg1_def_stmt);
     572                 :        101 :       gsi_remove (&gsi_for_def, true);
     573                 :        101 :       release_defs (arg1_def_stmt);
     574                 :            :     }
     575                 :            : 
     576                 :      10863 :   add_phi_arg (newphi, new_arg0, e0, locus);
     577                 :      10863 :   add_phi_arg (newphi, new_arg1, e1, locus);
     578                 :            : 
     579                 :            :   /* Create the conversion stmt and insert it.  */
     580                 :      10863 :   if (convert_code == VIEW_CONVERT_EXPR)
     581                 :            :     {
     582                 :         90 :       temp = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (result), temp);
     583                 :         90 :       new_stmt = gimple_build_assign (result, temp);
     584                 :            :     }
     585                 :            :   else
     586                 :      10773 :     new_stmt = gimple_build_assign (result, convert_code, temp);
     587                 :      10863 :   gsi = gsi_after_labels (gimple_bb (phi));
     588                 :      10863 :   gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
     589                 :            : 
     590                 :            :   /* Remove the original PHI stmt.  */
     591                 :      10863 :   gsi = gsi_for_stmt (phi);
     592                 :      10863 :   gsi_remove (&gsi, true);
     593                 :      10863 :   return newphi;
     594                 :            : }
     595                 :            : 
     596                 :            : /* Optimize
     597                 :            :    # x_5 in range [cst1, cst2] where cst2 = cst1 + 1
     598                 :            :    if (x_5 op cstN) # where op is == or != and N is 1 or 2
     599                 :            :      goto bb3;
     600                 :            :    else
     601                 :            :      goto bb4;
     602                 :            :    bb3:
     603                 :            :    bb4:
     604                 :            :    # r_6 = PHI<cst3(2), cst4(3)> # where cst3 == cst4 + 1 or cst4 == cst3 + 1
     605                 :            : 
     606                 :            :    to r_6 = x_5 + (min (cst3, cst4) - cst1) or
     607                 :            :    r_6 = (min (cst3, cst4) + cst1) - x_5 depending on op, N and which
     608                 :            :    of cst3 and cst4 is smaller.  */
     609                 :            : 
     610                 :            : static bool
     611                 :    1458740 : two_value_replacement (basic_block cond_bb, basic_block middle_bb,
     612                 :            :                        edge e1, gphi *phi, tree arg0, tree arg1)
     613                 :            : {
     614                 :            :   /* Only look for adjacent integer constants.  */
     615                 :    2913230 :   if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0))
     616                 :     412404 :       || !INTEGRAL_TYPE_P (TREE_TYPE (arg1))
     617                 :     412404 :       || TREE_CODE (arg0) != INTEGER_CST
     618                 :     136330 :       || TREE_CODE (arg1) != INTEGER_CST
     619                 :    1551750 :       || (tree_int_cst_lt (arg0, arg1)
     620                 :      62446 :           ? wi::to_widest (arg0) + 1 != wi::to_widest (arg1)
     621                 :      30570 :           : wi::to_widest (arg1) + 1 != wi::to_widest (arg0)))
     622                 :    1391480 :     return false;
     623                 :            : 
     624                 :      67260 :   if (!empty_block_p (middle_bb))
     625                 :            :     return false;
     626                 :            : 
     627                 :      67211 :   gimple *stmt = last_stmt (cond_bb);
     628                 :      67211 :   tree lhs = gimple_cond_lhs (stmt);
     629                 :      67211 :   tree rhs = gimple_cond_rhs (stmt);
     630                 :            : 
     631                 :      67211 :   if (TREE_CODE (lhs) != SSA_NAME
     632                 :      67179 :       || !INTEGRAL_TYPE_P (TREE_TYPE (lhs))
     633                 :      58590 :       || TREE_CODE (TREE_TYPE (lhs)) == BOOLEAN_TYPE
     634                 :     109598 :       || TREE_CODE (rhs) != INTEGER_CST)
     635                 :            :     return false;
     636                 :            : 
     637                 :      24625 :   switch (gimple_cond_code (stmt))
     638                 :            :     {
     639                 :      20358 :     case EQ_EXPR:
     640                 :      20358 :     case NE_EXPR:
     641                 :      20358 :       break;
     642                 :            :     default:
     643                 :            :       return false;
     644                 :            :     }
     645                 :            : 
     646                 :      20358 :   wide_int min, max;
     647                 :      20358 :   if (get_range_info (lhs, &min, &max) != VR_RANGE
     648                 :       3046 :       || min + 1 != max
     649                 :      20911 :       || (wi::to_wide (rhs) != min
     650                 :         16 :           && wi::to_wide (rhs) != max))
     651                 :      19805 :     return false;
     652                 :            : 
     653                 :            :   /* We need to know which is the true edge and which is the false
     654                 :            :      edge so that we know when to invert the condition below.  */
     655                 :        553 :   edge true_edge, false_edge;
     656                 :        553 :   extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
     657                 :        553 :   if ((gimple_cond_code (stmt) == EQ_EXPR)
     658                 :        553 :       ^ (wi::to_wide (rhs) == max)
     659                 :        553 :       ^ (e1 == false_edge))
     660                 :        242 :     std::swap (arg0, arg1);
     661                 :            : 
     662                 :        553 :   tree type;
     663                 :        553 :   if (TYPE_PRECISION (TREE_TYPE (lhs)) == TYPE_PRECISION (TREE_TYPE (arg0)))
     664                 :            :     {
     665                 :            :       /* Avoid performing the arithmetics in bool type which has different
     666                 :            :          semantics, otherwise prefer unsigned types from the two with
     667                 :            :          the same precision.  */
     668                 :        218 :       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE
     669                 :        218 :           || !TYPE_UNSIGNED (TREE_TYPE (arg0)))
     670                 :        553 :         type = TREE_TYPE (lhs);
     671                 :            :       else
     672                 :        553 :         type = TREE_TYPE (arg0);
     673                 :            :     }
     674                 :        335 :   else if (TYPE_PRECISION (TREE_TYPE (lhs)) > TYPE_PRECISION (TREE_TYPE (arg0)))
     675                 :        553 :     type = TREE_TYPE (lhs);
     676                 :            :   else
     677                 :         44 :     type = TREE_TYPE (arg0);
     678                 :            : 
     679                 :        553 :   min = wide_int::from (min, TYPE_PRECISION (type),
     680                 :        553 :                         TYPE_SIGN (TREE_TYPE (lhs)));
     681                 :        553 :   wide_int a = wide_int::from (wi::to_wide (arg0), TYPE_PRECISION (type),
     682                 :        553 :                                TYPE_SIGN (TREE_TYPE (arg0)));
     683                 :        553 :   enum tree_code code;
     684                 :        553 :   wi::overflow_type ovf;
     685                 :        553 :   if (tree_int_cst_lt (arg0, arg1))
     686                 :            :     {
     687                 :        422 :       code = PLUS_EXPR;
     688                 :        422 :       a -= min;
     689                 :        422 :       if (!TYPE_UNSIGNED (type))
     690                 :            :         {
     691                 :            :           /* lhs is known to be in range [min, min+1] and we want to add a
     692                 :            :              to it.  Check if that operation can overflow for those 2 values
     693                 :            :              and if yes, force unsigned type.  */
     694                 :        460 :           wi::add (min + (wi::neg_p (a) ? 0 : 1), a, SIGNED, &ovf);
     695                 :        232 :           if (ovf)
     696                 :          0 :             type = unsigned_type_for (type);
     697                 :            :         }
     698                 :            :     }
     699                 :            :   else
     700                 :            :     {
     701                 :        131 :       code = MINUS_EXPR;
     702                 :        131 :       a += min;
     703                 :        131 :       if (!TYPE_UNSIGNED (type))
     704                 :            :         {
     705                 :            :           /* lhs is known to be in range [min, min+1] and we want to subtract
     706                 :            :              it from a.  Check if that operation can overflow for those 2
     707                 :            :              values and if yes, force unsigned type.  */
     708                 :        194 :           wi::sub (a, min + (wi::neg_p (min) ? 0 : 1), SIGNED, &ovf);
     709                 :        100 :           if (ovf)
     710                 :          0 :             type = unsigned_type_for (type);
     711                 :            :         }
     712                 :            :     }
     713                 :            : 
     714                 :        553 :   tree arg = wide_int_to_tree (type, a);
     715                 :        553 :   gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
     716                 :        553 :   if (!useless_type_conversion_p (type, TREE_TYPE (lhs)))
     717                 :        110 :     lhs = gimplify_build1 (&gsi, NOP_EXPR, type, lhs);
     718                 :        553 :   tree new_rhs;
     719                 :        553 :   if (code == PLUS_EXPR)
     720                 :        422 :     new_rhs = gimplify_build2 (&gsi, PLUS_EXPR, type, lhs, arg);
     721                 :            :   else
     722                 :        131 :     new_rhs = gimplify_build2 (&gsi, MINUS_EXPR, type, arg, lhs);
     723                 :        553 :   if (!useless_type_conversion_p (TREE_TYPE (arg0), type))
     724                 :        306 :     new_rhs = gimplify_build1 (&gsi, NOP_EXPR, TREE_TYPE (arg0), new_rhs);
     725                 :            : 
     726                 :        553 :   replace_phi_edge_with_variable (cond_bb, e1, phi, new_rhs);
     727                 :            : 
     728                 :            :   /* Note that we optimized this PHI.  */
     729                 :        553 :   return true;
     730                 :            : }
     731                 :            : 
     732                 :            : /*  The function conditional_replacement does the main work of doing the
     733                 :            :     conditional replacement.  Return true if the replacement is done.
     734                 :            :     Otherwise return false.
     735                 :            :     BB is the basic block where the replacement is going to be done on.  ARG0
     736                 :            :     is argument 0 from PHI.  Likewise for ARG1.  */
     737                 :            : 
     738                 :            : static bool
     739                 :    1059630 : conditional_replacement (basic_block cond_bb, basic_block middle_bb,
     740                 :            :                          edge e0, edge e1, gphi *phi,
     741                 :            :                          tree arg0, tree arg1)
     742                 :            : {
     743                 :    1059630 :   tree result;
     744                 :    1059630 :   gimple *stmt;
     745                 :    1059630 :   gassign *new_stmt;
     746                 :    1059630 :   tree cond;
     747                 :    1059630 :   gimple_stmt_iterator gsi;
     748                 :    1059630 :   edge true_edge, false_edge;
     749                 :    1059630 :   tree new_var, new_var2;
     750                 :    1059630 :   bool neg;
     751                 :            : 
     752                 :            :   /* FIXME: Gimplification of complex type is too hard for now.  */
     753                 :            :   /* We aren't prepared to handle vectors either (and it is a question
     754                 :            :      if it would be worthwhile anyway).  */
     755                 :    2115990 :   if (!(INTEGRAL_TYPE_P (TREE_TYPE (arg0))
     756                 :     790974 :         || POINTER_TYPE_P (TREE_TYPE (arg0)))
     757                 :    1386590 :       || !(INTEGRAL_TYPE_P (TREE_TYPE (arg1))
     758                 :      58304 :            || POINTER_TYPE_P (TREE_TYPE (arg1))))
     759                 :            :     return false;
     760                 :            : 
     761                 :            :   /* The PHI arguments have the constants 0 and 1, or 0 and -1, then
     762                 :            :      convert it to the conditional.  */
     763                 :     380164 :   if ((integer_zerop (arg0) && integer_onep (arg1))
     764                 :     358204 :       || (integer_zerop (arg1) && integer_onep (arg0)))
     765                 :            :     neg = false;
     766                 :     329522 :   else if ((integer_zerop (arg0) && integer_all_onesp (arg1))
     767                 :     328598 :            || (integer_zerop (arg1) && integer_all_onesp (arg0)))
     768                 :            :     neg = true;
     769                 :            :   else
     770                 :     296538 :     return false;
     771                 :            : 
     772                 :      30420 :   if (!empty_block_p (middle_bb))
     773                 :            :     return false;
     774                 :            : 
     775                 :            :   /* At this point we know we have a GIMPLE_COND with two successors.
     776                 :            :      One successor is BB, the other successor is an empty block which
     777                 :            :      falls through into BB.
     778                 :            : 
     779                 :            :      There is a single PHI node at the join point (BB) and its arguments
     780                 :            :      are constants (0, 1) or (0, -1).
     781                 :            : 
     782                 :            :      So, given the condition COND, and the two PHI arguments, we can
     783                 :            :      rewrite this PHI into non-branching code:
     784                 :            : 
     785                 :            :        dest = (COND) or dest = COND'
     786                 :            : 
     787                 :            :      We use the condition as-is if the argument associated with the
     788                 :            :      true edge has the value one or the argument associated with the
     789                 :            :      false edge as the value zero.  Note that those conditions are not
     790                 :            :      the same since only one of the outgoing edges from the GIMPLE_COND
     791                 :            :      will directly reach BB and thus be associated with an argument.  */
     792                 :            : 
     793                 :      30385 :   stmt = last_stmt (cond_bb);
     794                 :      30385 :   result = PHI_RESULT (phi);
     795                 :            : 
     796                 :            :   /* To handle special cases like floating point comparison, it is easier and
     797                 :            :      less error-prone to build a tree and gimplify it on the fly though it is
     798                 :            :      less efficient.  */
     799                 :      30385 :   cond = fold_build2_loc (gimple_location (stmt),
     800                 :            :                           gimple_cond_code (stmt), boolean_type_node,
     801                 :            :                           gimple_cond_lhs (stmt), gimple_cond_rhs (stmt));
     802                 :            : 
     803                 :            :   /* We need to know which is the true edge and which is the false
     804                 :            :      edge so that we know when to invert the condition below.  */
     805                 :      30385 :   extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
     806                 :          0 :   if ((e0 == true_edge && integer_zerop (arg0))
     807                 :      30385 :       || (e0 == false_edge && !integer_zerop (arg0))
     808                 :      30385 :       || (e1 == true_edge && integer_zerop (arg1))
     809                 :      60012 :       || (e1 == false_edge && !integer_zerop (arg1)))
     810                 :       9324 :     cond = fold_build1_loc (gimple_location (stmt),
     811                 :       9324 :                             TRUTH_NOT_EXPR, TREE_TYPE (cond), cond);
     812                 :            : 
     813                 :      30385 :   if (neg)
     814                 :            :     {
     815                 :       1737 :       cond = fold_convert_loc (gimple_location (stmt),
     816                 :       1737 :                                TREE_TYPE (result), cond);
     817                 :       1737 :       cond = fold_build1_loc (gimple_location (stmt),
     818                 :       1737 :                               NEGATE_EXPR, TREE_TYPE (cond), cond);
     819                 :            :     }
     820                 :            : 
     821                 :            :   /* Insert our new statements at the end of conditional block before the
     822                 :            :      COND_STMT.  */
     823                 :      30385 :   gsi = gsi_for_stmt (stmt);
     824                 :      30385 :   new_var = force_gimple_operand_gsi (&gsi, cond, true, NULL, true,
     825                 :            :                                       GSI_SAME_STMT);
     826                 :            : 
     827                 :      30385 :   if (!useless_type_conversion_p (TREE_TYPE (result), TREE_TYPE (new_var)))
     828                 :            :     {
     829                 :      12929 :       location_t locus_0, locus_1;
     830                 :            : 
     831                 :      12929 :       new_var2 = make_ssa_name (TREE_TYPE (result));
     832                 :      12929 :       new_stmt = gimple_build_assign (new_var2, CONVERT_EXPR, new_var);
     833                 :      12929 :       gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
     834                 :      12929 :       new_var = new_var2;
     835                 :            : 
     836                 :            :       /* Set the locus to the first argument, unless is doesn't have one.  */
     837                 :      12929 :       locus_0 = gimple_phi_arg_location (phi, 0);
     838                 :      12929 :       locus_1 = gimple_phi_arg_location (phi, 1);
     839                 :      12929 :       if (locus_0 == UNKNOWN_LOCATION)
     840                 :        277 :         locus_0 = locus_1;
     841                 :      12929 :       gimple_set_location (new_stmt, locus_0);
     842                 :            :     }
     843                 :            : 
     844                 :      30385 :   replace_phi_edge_with_variable (cond_bb, e1, phi, new_var);
     845                 :            : 
     846                 :            :   /* Note that we optimized this PHI.  */
     847                 :      30385 :   return true;
     848                 :            : }
     849                 :            : 
     850                 :            : /* Update *ARG which is defined in STMT so that it contains the
     851                 :            :    computed value if that seems profitable.  Return true if the
     852                 :            :    statement is made dead by that rewriting.  */
     853                 :            : 
     854                 :            : static bool
     855                 :     369929 : jump_function_from_stmt (tree *arg, gimple *stmt)
     856                 :            : {
     857                 :     369929 :   enum tree_code code = gimple_assign_rhs_code (stmt);
     858                 :     369929 :   if (code == ADDR_EXPR)
     859                 :            :     {
     860                 :            :       /* For arg = &p->i transform it to p, if possible.  */
     861                 :       3058 :       tree rhs1 = gimple_assign_rhs1 (stmt);
     862                 :       3058 :       poly_int64 offset;
     863                 :       3058 :       tree tem = get_addr_base_and_unit_offset (TREE_OPERAND (rhs1, 0),
     864                 :            :                                                 &offset);
     865                 :       3058 :       if (tem
     866                 :       2999 :           && TREE_CODE (tem) == MEM_REF
     867                 :       7782 :           && known_eq (mem_ref_offset (tem) + offset, 0))
     868                 :            :         {
     869                 :       1274 :           *arg = TREE_OPERAND (tem, 0);
     870                 :       1274 :           return true;
     871                 :            :         }
     872                 :            :     }
     873                 :            :   /* TODO: Much like IPA-CP jump-functions we want to handle constant
     874                 :            :      additions symbolically here, and we'd need to update the comparison
     875                 :            :      code that compares the arg + cst tuples in our caller.  For now the
     876                 :            :      code above exactly handles the VEC_BASE pattern from vec.h.  */
     877                 :            :   return false;
     878                 :            : }
     879                 :            : 
     880                 :            : /* RHS is a source argument in a BIT_AND_EXPR which feeds a conditional
     881                 :            :    of the form SSA_NAME NE 0.
     882                 :            : 
     883                 :            :    If RHS is fed by a simple EQ_EXPR comparison of two values, see if
     884                 :            :    the two input values of the EQ_EXPR match arg0 and arg1.
     885                 :            : 
     886                 :            :    If so update *code and return TRUE.  Otherwise return FALSE.  */
     887                 :            : 
     888                 :            : static bool
     889                 :      80547 : rhs_is_fed_for_value_replacement (const_tree arg0, const_tree arg1,
     890                 :            :                                   enum tree_code *code, const_tree rhs)
     891                 :            : {
     892                 :            :   /* Obviously if RHS is not an SSA_NAME, we can't look at the defining
     893                 :            :      statement.  */
     894                 :      80547 :   if (TREE_CODE (rhs) == SSA_NAME)
     895                 :            :     {
     896                 :      52324 :       gimple *def1 = SSA_NAME_DEF_STMT (rhs);
     897                 :            : 
     898                 :            :       /* Verify the defining statement has an EQ_EXPR on the RHS.  */
     899                 :      52324 :       if (is_gimple_assign (def1) && gimple_assign_rhs_code (def1) == EQ_EXPR)
     900                 :            :         {
     901                 :            :           /* Finally verify the source operands of the EQ_EXPR are equal
     902                 :            :              to arg0 and arg1.  */
     903                 :       5149 :           tree op0 = gimple_assign_rhs1 (def1);
     904                 :       5149 :           tree op1 = gimple_assign_rhs2 (def1);
     905                 :       5149 :           if ((operand_equal_for_phi_arg_p (arg0, op0)
     906                 :         58 :                && operand_equal_for_phi_arg_p (arg1, op1))
     907                 :       5192 :               || (operand_equal_for_phi_arg_p (arg0, op1)
     908                 :        429 :                && operand_equal_for_phi_arg_p (arg1, op0)))
     909                 :            :             {
     910                 :            :               /* We will perform the optimization.  */
     911                 :        345 :               *code = gimple_assign_rhs_code (def1);
     912                 :        345 :               return true;
     913                 :            :             }
     914                 :            :         }
     915                 :            :     }
     916                 :            :   return false;
     917                 :            : }
     918                 :            : 
     919                 :            : /* Return TRUE if arg0/arg1 are equal to the rhs/lhs or lhs/rhs of COND. 
     920                 :            : 
     921                 :            :    Also return TRUE if arg0/arg1 are equal to the source arguments of a
     922                 :            :    an EQ comparison feeding a BIT_AND_EXPR which feeds COND. 
     923                 :            : 
     924                 :            :    Return FALSE otherwise.  */
     925                 :            : 
     926                 :            : static bool
     927                 :    1206900 : operand_equal_for_value_replacement (const_tree arg0, const_tree arg1,
     928                 :            :                                      enum tree_code *code, gimple *cond)
     929                 :            : {
     930                 :    1206900 :   gimple *def;
     931                 :    1206900 :   tree lhs = gimple_cond_lhs (cond);
     932                 :    1206900 :   tree rhs = gimple_cond_rhs (cond);
     933                 :            : 
     934                 :    1206900 :   if ((operand_equal_for_phi_arg_p (arg0, lhs)
     935                 :      18772 :        && operand_equal_for_phi_arg_p (arg1, rhs))
     936                 :    1221320 :       || (operand_equal_for_phi_arg_p (arg1, lhs)
     937                 :      31774 :           && operand_equal_for_phi_arg_p (arg0, rhs)))
     938                 :      11121 :     return true;
     939                 :            : 
     940                 :            :   /* Now handle more complex case where we have an EQ comparison
     941                 :            :      which feeds a BIT_AND_EXPR which feeds COND.
     942                 :            : 
     943                 :            :      First verify that COND is of the form SSA_NAME NE 0.  */
     944                 :     844054 :   if (*code != NE_EXPR || !integer_zerop (rhs)
     945                 :    1794120 :       || TREE_CODE (lhs) != SSA_NAME)
     946                 :     602970 :     return false;
     947                 :            : 
     948                 :            :   /* Now ensure that SSA_NAME is set by a BIT_AND_EXPR.  */
     949                 :     592812 :   def = SSA_NAME_DEF_STMT (lhs);
     950                 :     592812 :   if (!is_gimple_assign (def) || gimple_assign_rhs_code (def) != BIT_AND_EXPR)
     951                 :            :     return false;
     952                 :            : 
     953                 :            :   /* Now verify arg0/arg1 correspond to the source arguments of an 
     954                 :            :      EQ comparison feeding the BIT_AND_EXPR.  */
     955                 :            :      
     956                 :      40417 :   tree tmp = gimple_assign_rhs1 (def);
     957                 :      40417 :   if (rhs_is_fed_for_value_replacement (arg0, arg1, code, tmp))
     958                 :            :     return true;
     959                 :            : 
     960                 :      40130 :   tmp = gimple_assign_rhs2 (def);
     961                 :      40130 :   if (rhs_is_fed_for_value_replacement (arg0, arg1, code, tmp))
     962                 :         58 :     return true;
     963                 :            : 
     964                 :            :   return false;
     965                 :            : }
     966                 :            : 
     967                 :            : /* Returns true if ARG is a neutral element for operation CODE
     968                 :            :    on the RIGHT side.  */
     969                 :            : 
     970                 :            : static bool
     971                 :        748 : neutral_element_p (tree_code code, tree arg, bool right)
     972                 :            : {
     973                 :        748 :   switch (code)
     974                 :            :     {
     975                 :         23 :     case PLUS_EXPR:
     976                 :         23 :     case BIT_IOR_EXPR:
     977                 :         23 :     case BIT_XOR_EXPR:
     978                 :         23 :       return integer_zerop (arg);
     979                 :            : 
     980                 :        481 :     case LROTATE_EXPR:
     981                 :        481 :     case RROTATE_EXPR:
     982                 :        481 :     case LSHIFT_EXPR:
     983                 :        481 :     case RSHIFT_EXPR:
     984                 :        481 :     case MINUS_EXPR:
     985                 :        481 :     case POINTER_PLUS_EXPR:
     986                 :        481 :       return right && integer_zerop (arg);
     987                 :            : 
     988                 :         34 :     case MULT_EXPR:
     989                 :         34 :       return integer_onep (arg);
     990                 :            : 
     991                 :          6 :     case TRUNC_DIV_EXPR:
     992                 :          6 :     case CEIL_DIV_EXPR:
     993                 :          6 :     case FLOOR_DIV_EXPR:
     994                 :          6 :     case ROUND_DIV_EXPR:
     995                 :          6 :     case EXACT_DIV_EXPR:
     996                 :          6 :       return right && integer_onep (arg);
     997                 :            : 
     998                 :          0 :     case BIT_AND_EXPR:
     999                 :          0 :       return integer_all_onesp (arg);
    1000                 :            : 
    1001                 :            :     default:
    1002                 :            :       return false;
    1003                 :            :     }
    1004                 :            : }
    1005                 :            : 
    1006                 :            : /* Returns true if ARG is an absorbing element for operation CODE.  */
    1007                 :            : 
    1008                 :            : static bool
    1009                 :        401 : absorbing_element_p (tree_code code, tree arg, bool right, tree rval)
    1010                 :            : {
    1011                 :        401 :   switch (code)
    1012                 :            :     {
    1013                 :          0 :     case BIT_IOR_EXPR:
    1014                 :          0 :       return integer_all_onesp (arg);
    1015                 :            : 
    1016                 :         26 :     case MULT_EXPR:
    1017                 :         26 :     case BIT_AND_EXPR:
    1018                 :         26 :       return integer_zerop (arg);
    1019                 :            : 
    1020                 :          2 :     case LSHIFT_EXPR:
    1021                 :          2 :     case RSHIFT_EXPR:
    1022                 :          2 :     case LROTATE_EXPR:
    1023                 :          2 :     case RROTATE_EXPR:
    1024                 :          2 :       return !right && integer_zerop (arg);
    1025                 :            : 
    1026                 :         69 :     case TRUNC_DIV_EXPR:
    1027                 :         69 :     case CEIL_DIV_EXPR:
    1028                 :         69 :     case FLOOR_DIV_EXPR:
    1029                 :         69 :     case ROUND_DIV_EXPR:
    1030                 :         69 :     case EXACT_DIV_EXPR:
    1031                 :         69 :     case TRUNC_MOD_EXPR:
    1032                 :         69 :     case CEIL_MOD_EXPR:
    1033                 :         69 :     case FLOOR_MOD_EXPR:
    1034                 :         69 :     case ROUND_MOD_EXPR:
    1035                 :         69 :       return (!right
    1036                 :         12 :               && integer_zerop (arg)
    1037                 :         80 :               && tree_single_nonzero_warnv_p (rval, NULL));
    1038                 :            : 
    1039                 :            :     default:
    1040                 :            :       return false;
    1041                 :            :     }
    1042                 :            : }
    1043                 :            : 
    1044                 :            : /*  The function value_replacement does the main work of doing the value
    1045                 :            :     replacement.  Return non-zero if the replacement is done.  Otherwise return
    1046                 :            :     0.  If we remove the middle basic block, return 2.
    1047                 :            :     BB is the basic block where the replacement is going to be done on.  ARG0
    1048                 :            :     is argument 0 from the PHI.  Likewise for ARG1.  */
    1049                 :            : 
    1050                 :            : static int
    1051                 :    1608110 : value_replacement (basic_block cond_bb, basic_block middle_bb,
    1052                 :            :                    edge e0, edge e1, gimple *phi,
    1053                 :            :                    tree arg0, tree arg1)
    1054                 :            : {
    1055                 :    1608110 :   gimple_stmt_iterator gsi;
    1056                 :    1608110 :   gimple *cond;
    1057                 :    1608110 :   edge true_edge, false_edge;
    1058                 :    1608110 :   enum tree_code code;
    1059                 :    1608110 :   bool empty_or_with_defined_p = true;
    1060                 :            : 
    1061                 :            :   /* If the type says honor signed zeros we cannot do this
    1062                 :            :      optimization.  */
    1063                 :    1608110 :   if (HONOR_SIGNED_ZEROS (arg1))
    1064                 :            :     return 0;
    1065                 :            : 
    1066                 :            :   /* If there is a statement in MIDDLE_BB that defines one of the PHI
    1067                 :            :      arguments, then adjust arg0 or arg1.  */
    1068                 :    1568730 :   gsi = gsi_start_nondebug_after_labels_bb (middle_bb);
    1069                 :    5770460 :   while (!gsi_end_p (gsi))
    1070                 :            :     {
    1071                 :    8806320 :       gimple *stmt = gsi_stmt (gsi);
    1072                 :            :       tree lhs;
    1073                 :    8806320 :       gsi_next_nondebug (&gsi);
    1074                 :    4201730 :       if (!is_gimple_assign (stmt))
    1075                 :            :         {
    1076                 :    1055030 :           if (gimple_code (stmt) != GIMPLE_PREDICT
    1077                 :    1055030 :               && gimple_code (stmt) != GIMPLE_NOP)
    1078                 :            :             empty_or_with_defined_p = false;
    1079                 :    1055030 :           continue;
    1080                 :            :         }
    1081                 :            :       /* Now try to adjust arg0 or arg1 according to the computation
    1082                 :            :          in the statement.  */
    1083                 :    3146700 :       lhs = gimple_assign_lhs (stmt);
    1084                 :     369929 :       if (!(lhs == arg0
    1085                 :     369929 :              && jump_function_from_stmt (&arg0, stmt))
    1086                 :    3147970 :             || (lhs == arg1
    1087                 :          0 :                 && jump_function_from_stmt (&arg1, stmt)))
    1088                 :            :         empty_or_with_defined_p = false;
    1089                 :            :     }
    1090                 :            : 
    1091                 :    1568730 :   cond = last_stmt (cond_bb);
    1092                 :    1568730 :   code = gimple_cond_code (cond);
    1093                 :            : 
    1094                 :            :   /* This transformation is only valid for equality comparisons.  */
    1095                 :    1568730 :   if (code != NE_EXPR && code != EQ_EXPR)
    1096                 :            :     return 0;
    1097                 :            : 
    1098                 :            :   /* We need to know which is the true edge and which is the false
    1099                 :            :       edge so that we know if have abs or negative abs.  */
    1100                 :    1206900 :   extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
    1101                 :            : 
    1102                 :            :   /* At this point we know we have a COND_EXPR with two successors.
    1103                 :            :      One successor is BB, the other successor is an empty block which
    1104                 :            :      falls through into BB.
    1105                 :            : 
    1106                 :            :      The condition for the COND_EXPR is known to be NE_EXPR or EQ_EXPR.
    1107                 :            : 
    1108                 :            :      There is a single PHI node at the join point (BB) with two arguments.
    1109                 :            : 
    1110                 :            :      We now need to verify that the two arguments in the PHI node match
    1111                 :            :      the two arguments to the equality comparison.  */
    1112                 :            : 
    1113                 :    1206900 :   if (operand_equal_for_value_replacement (arg0, arg1, &code, cond))
    1114                 :            :     {
    1115                 :      11466 :       edge e;
    1116                 :      11466 :       tree arg;
    1117                 :            : 
    1118                 :            :       /* For NE_EXPR, we want to build an assignment result = arg where
    1119                 :            :          arg is the PHI argument associated with the true edge.  For
    1120                 :            :          EQ_EXPR we want the PHI argument associated with the false edge.  */
    1121                 :      11466 :       e = (code == NE_EXPR ? true_edge : false_edge);
    1122                 :            : 
    1123                 :            :       /* Unfortunately, E may not reach BB (it may instead have gone to
    1124                 :            :          OTHER_BLOCK).  If that is the case, then we want the single outgoing
    1125                 :            :          edge from OTHER_BLOCK which reaches BB and represents the desired
    1126                 :            :          path from COND_BLOCK.  */
    1127                 :      11466 :       if (e->dest == middle_bb)
    1128                 :       4648 :         e = single_succ_edge (e->dest);
    1129                 :            : 
    1130                 :            :       /* Now we know the incoming edge to BB that has the argument for the
    1131                 :            :          RHS of our new assignment statement.  */
    1132                 :      11466 :       if (e0 == e)
    1133                 :       4648 :         arg = arg0;
    1134                 :            :       else
    1135                 :       6818 :         arg = arg1;
    1136                 :            : 
    1137                 :            :       /* If the middle basic block was empty or is defining the
    1138                 :            :          PHI arguments and this is a single phi where the args are different
    1139                 :            :          for the edges e0 and e1 then we can remove the middle basic block. */
    1140                 :      11466 :       if (empty_or_with_defined_p
    1141                 :      11466 :           && single_non_singleton_phi_for_edges (phi_nodes (gimple_bb (phi)),
    1142                 :            :                                                  e0, e1) == phi)
    1143                 :            :         {
    1144                 :       1029 :           replace_phi_edge_with_variable (cond_bb, e1, phi, arg);
    1145                 :            :           /* Note that we optimized this PHI.  */
    1146                 :       1029 :           return 2;
    1147                 :            :         }
    1148                 :            :       else
    1149                 :            :         {
    1150                 :            :           /* Replace the PHI arguments with arg. */
    1151                 :      10437 :           SET_PHI_ARG_DEF (phi, e0->dest_idx, arg);
    1152                 :      10437 :           SET_PHI_ARG_DEF (phi, e1->dest_idx, arg);
    1153                 :      10437 :           if (dump_file && (dump_flags & TDF_DETAILS))
    1154                 :            :             {
    1155                 :          0 :               fprintf (dump_file, "PHI ");
    1156                 :          0 :               print_generic_expr (dump_file, gimple_phi_result (phi));
    1157                 :          0 :               fprintf (dump_file, " reduced for COND_EXPR in block %d to ",
    1158                 :            :                        cond_bb->index);
    1159                 :          0 :               print_generic_expr (dump_file, arg);
    1160                 :          0 :               fprintf (dump_file, ".\n");
    1161                 :            :             }
    1162                 :      10437 :           return 1;
    1163                 :            :         }
    1164                 :            : 
    1165                 :            :     }
    1166                 :            : 
    1167                 :            :   /* Now optimize (x != 0) ? x + y : y to just x + y.  */
    1168                 :    1195440 :   gsi = gsi_last_nondebug_bb (middle_bb);
    1169                 :    1195440 :   if (gsi_end_p (gsi))
    1170                 :            :     return 0;
    1171                 :            : 
    1172                 :    1043530 :   gimple *assign = gsi_stmt (gsi);
    1173                 :    1043530 :   if (!is_gimple_assign (assign)
    1174                 :     446479 :       || gimple_assign_rhs_class (assign) != GIMPLE_BINARY_RHS
    1175                 :    1201020 :       || (!INTEGRAL_TYPE_P (TREE_TYPE (arg0))
    1176                 :      51580 :           && !POINTER_TYPE_P (TREE_TYPE (arg0))))
    1177                 :            :     return 0;
    1178                 :            : 
    1179                 :            :   /* Punt if there are (degenerate) PHIs in middle_bb, there should not be.  */
    1180                 :     127253 :   if (!gimple_seq_empty_p (phi_nodes (middle_bb)))
    1181                 :            :     return 0;
    1182                 :            : 
    1183                 :            :   /* Allow up to 2 cheap preparation statements that prepare argument
    1184                 :            :      for assign, e.g.:
    1185                 :            :       if (y_4 != 0)
    1186                 :            :         goto <bb 3>;
    1187                 :            :       else
    1188                 :            :         goto <bb 4>;
    1189                 :            :      <bb 3>:
    1190                 :            :       _1 = (int) y_4;
    1191                 :            :       iftmp.0_6 = x_5(D) r<< _1;
    1192                 :            :      <bb 4>:
    1193                 :            :       # iftmp.0_2 = PHI <iftmp.0_6(3), x_5(D)(2)>
    1194                 :            :      or:
    1195                 :            :       if (y_3(D) == 0)
    1196                 :            :         goto <bb 4>;
    1197                 :            :       else
    1198                 :            :         goto <bb 3>;
    1199                 :            :      <bb 3>:
    1200                 :            :       y_4 = y_3(D) & 31;
    1201                 :            :       _1 = (int) y_4;
    1202                 :            :       _6 = x_5(D) r<< _1;
    1203                 :            :      <bb 4>:
    1204                 :            :       # _2 = PHI <x_5(D)(2), _6(3)>  */
    1205                 :     127235 :   gimple *prep_stmt[2] = { NULL, NULL };
    1206                 :     127235 :   int prep_cnt;
    1207                 :     127235 :   for (prep_cnt = 0; ; prep_cnt++)
    1208                 :            :     {
    1209                 :     144472 :       gsi_prev_nondebug (&gsi);
    1210                 :     144472 :       if (gsi_end_p (gsi))
    1211                 :            :         break;
    1212                 :            : 
    1213                 :      92348 :       gimple *g = gsi_stmt (gsi);
    1214                 :      92348 :       if (gimple_code (g) == GIMPLE_LABEL)
    1215                 :            :         break;
    1216                 :            : 
    1217                 :      92200 :       if (prep_cnt == 2 || !is_gimple_assign (g))
    1218                 :      74963 :         return 0;
    1219                 :            : 
    1220                 :      71331 :       tree lhs = gimple_assign_lhs (g);
    1221                 :      71331 :       tree rhs1 = gimple_assign_rhs1 (g);
    1222                 :      71331 :       use_operand_p use_p;
    1223                 :      71331 :       gimple *use_stmt;
    1224                 :      71331 :       if (TREE_CODE (lhs) != SSA_NAME
    1225                 :      69805 :           || TREE_CODE (rhs1) != SSA_NAME
    1226                 :      32277 :           || !INTEGRAL_TYPE_P (TREE_TYPE (lhs))
    1227                 :      31212 :           || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
    1228                 :      29498 :           || !single_imm_use (lhs, &use_p, &use_stmt)
    1229                 :     100335 :           || use_stmt != (prep_cnt ? prep_stmt[prep_cnt - 1] : assign))
    1230                 :      45342 :         return 0;
    1231                 :      25989 :       switch (gimple_assign_rhs_code (g))
    1232                 :            :         {
    1233                 :            :         CASE_CONVERT:
    1234                 :            :           break;
    1235                 :       3140 :         case PLUS_EXPR:
    1236                 :       3140 :         case BIT_AND_EXPR:
    1237                 :       3140 :         case BIT_IOR_EXPR:
    1238                 :       3140 :         case BIT_XOR_EXPR:
    1239                 :       3140 :           if (TREE_CODE (gimple_assign_rhs2 (g)) != INTEGER_CST)
    1240                 :            :             return 0;
    1241                 :            :           break;
    1242                 :            :         default:
    1243                 :            :           return 0;
    1244                 :            :         }
    1245                 :      17237 :       prep_stmt[prep_cnt] = g;
    1246                 :      17237 :     }
    1247                 :            : 
    1248                 :            :   /* Only transform if it removes the condition.  */
    1249                 :      52272 :   if (!single_non_singleton_phi_for_edges (phi_nodes (gimple_bb (phi)), e0, e1))
    1250                 :            :     return 0;
    1251                 :            : 
    1252                 :            :   /* Size-wise, this is always profitable.  */
    1253                 :      43888 :   if (optimize_bb_for_speed_p (cond_bb)
    1254                 :            :       /* The special case is useless if it has a low probability.  */
    1255                 :      42651 :       && profile_status_for_fn (cfun) != PROFILE_ABSENT
    1256                 :      42637 :       && EDGE_PRED (middle_bb, 0)->probability < profile_probability::even ()
    1257                 :            :       /* If assign is cheap, there is no point avoiding it.  */
    1258                 :      53742 :       && estimate_num_insns_seq (bb_seq (middle_bb), &eni_time_weights)
    1259                 :       4927 :          >= 3 * estimate_num_insns (cond, &eni_time_weights))
    1260                 :         13 :     return 0;
    1261                 :            : 
    1262                 :      43875 :   tree lhs = gimple_assign_lhs (assign);
    1263                 :      43875 :   tree rhs1 = gimple_assign_rhs1 (assign);
    1264                 :      43875 :   tree rhs2 = gimple_assign_rhs2 (assign);
    1265                 :      43875 :   enum tree_code code_def = gimple_assign_rhs_code (assign);
    1266                 :      43875 :   tree cond_lhs = gimple_cond_lhs (cond);
    1267                 :      43875 :   tree cond_rhs = gimple_cond_rhs (cond);
    1268                 :            : 
    1269                 :            :   /* Propagate the cond_rhs constant through preparation stmts,
    1270                 :            :      make sure UB isn't invoked while doing that.  */
    1271                 :      44811 :   for (int i = prep_cnt - 1; i >= 0; --i)
    1272                 :            :     {
    1273                 :      12117 :       gimple *g = prep_stmt[i];
    1274                 :      12117 :       tree grhs1 = gimple_assign_rhs1 (g);
    1275                 :      12117 :       if (!operand_equal_for_phi_arg_p (cond_lhs, grhs1))
    1276                 :            :         return 0;
    1277                 :       6299 :       cond_lhs = gimple_assign_lhs (g);
    1278                 :       6299 :       cond_rhs = fold_convert (TREE_TYPE (grhs1), cond_rhs);
    1279                 :       6299 :       if (TREE_CODE (cond_rhs) != INTEGER_CST
    1280                 :       7235 :           || TREE_OVERFLOW (cond_rhs))
    1281                 :            :         return 0;
    1282                 :        936 :       if (gimple_assign_rhs_class (g) == GIMPLE_BINARY_RHS)
    1283                 :            :         {
    1284                 :        310 :           cond_rhs = int_const_binop (gimple_assign_rhs_code (g), cond_rhs,
    1285                 :        310 :                                       gimple_assign_rhs2 (g));
    1286                 :        310 :           if (TREE_OVERFLOW (cond_rhs))
    1287                 :            :             return 0;
    1288                 :            :         }
    1289                 :        936 :       cond_rhs = fold_convert (TREE_TYPE (cond_lhs), cond_rhs);
    1290                 :        936 :       if (TREE_CODE (cond_rhs) != INTEGER_CST
    1291                 :       1872 :           || TREE_OVERFLOW (cond_rhs))
    1292                 :            :         return 0;
    1293                 :            :     }
    1294                 :            : 
    1295                 :      23797 :   if (((code == NE_EXPR && e1 == false_edge)
    1296                 :      10232 :         || (code == EQ_EXPR && e1 == true_edge))
    1297                 :      24114 :       && arg0 == lhs
    1298                 :      55820 :       && ((arg1 == rhs1
    1299                 :      18358 :            && operand_equal_for_phi_arg_p (rhs2, cond_lhs)
    1300                 :        670 :            && neutral_element_p (code_def, cond_rhs, true))
    1301                 :      23044 :           || (arg1 == rhs2
    1302                 :        346 :               && operand_equal_for_phi_arg_p (rhs1, cond_lhs)
    1303                 :         78 :               && neutral_element_p (code_def, cond_rhs, false))
    1304                 :      23041 :           || (operand_equal_for_phi_arg_p (arg1, cond_rhs)
    1305                 :       1484 :               && ((operand_equal_for_phi_arg_p (rhs2, cond_lhs)
    1306                 :         76 :                    && absorbing_element_p (code_def, cond_rhs, true, rhs2))
    1307                 :       1479 :                   || (operand_equal_for_phi_arg_p (rhs1, cond_lhs)
    1308                 :        325 :                       && absorbing_element_p (code_def,
    1309                 :            :                                               cond_rhs, false, rhs2))))))
    1310                 :            :     {
    1311                 :        123 :       gsi = gsi_for_stmt (cond);
    1312                 :            :       /* Moving ASSIGN might change VR of lhs, e.g. when moving u_6
    1313                 :            :          def-stmt in:
    1314                 :            :            if (n_5 != 0)
    1315                 :            :              goto <bb 3>;
    1316                 :            :            else
    1317                 :            :              goto <bb 4>;
    1318                 :            : 
    1319                 :            :            <bb 3>:
    1320                 :            :            # RANGE [0, 4294967294]
    1321                 :            :            u_6 = n_5 + 4294967295;
    1322                 :            : 
    1323                 :            :            <bb 4>:
    1324                 :            :            # u_3 = PHI <u_6(3), 4294967295(2)>  */
    1325                 :        123 :       reset_flow_sensitive_info (lhs);
    1326                 :        123 :       if (INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
    1327                 :            :         {
    1328                 :            :           /* If available, we can use VR of phi result at least.  */
    1329                 :        106 :           tree phires = gimple_phi_result (phi);
    1330                 :        106 :           struct range_info_def *phires_range_info
    1331                 :        106 :             = SSA_NAME_RANGE_INFO (phires);
    1332                 :        106 :           if (phires_range_info)
    1333                 :         62 :             duplicate_ssa_name_range_info (lhs, SSA_NAME_RANGE_TYPE (phires),
    1334                 :            :                                            phires_range_info);
    1335                 :            :         }
    1336                 :            :       gimple_stmt_iterator gsi_from;
    1337                 :        183 :       for (int i = prep_cnt - 1; i >= 0; --i)
    1338                 :            :         {
    1339                 :         60 :           tree plhs = gimple_assign_lhs (prep_stmt[i]);
    1340                 :         60 :           reset_flow_sensitive_info (plhs);
    1341                 :         60 :           gsi_from = gsi_for_stmt (prep_stmt[i]);
    1342                 :         60 :           gsi_move_before (&gsi_from, &gsi);
    1343                 :            :         }
    1344                 :        123 :       gsi_from = gsi_for_stmt (assign);
    1345                 :        123 :       gsi_move_before (&gsi_from, &gsi);
    1346                 :        123 :       replace_phi_edge_with_variable (cond_bb, e1, phi, lhs);
    1347                 :        123 :       return 2;
    1348                 :            :     }
    1349                 :            : 
    1350                 :            :   return 0;
    1351                 :            : }
    1352                 :            : 
    1353                 :            : /*  The function minmax_replacement does the main work of doing the minmax
    1354                 :            :     replacement.  Return true if the replacement is done.  Otherwise return
    1355                 :            :     false.
    1356                 :            :     BB is the basic block where the replacement is going to be done on.  ARG0
    1357                 :            :     is argument 0 from the PHI.  Likewise for ARG1.  */
    1358                 :            : 
    1359                 :            : static bool
    1360                 :    1427680 : minmax_replacement (basic_block cond_bb, basic_block middle_bb,
    1361                 :            :                     edge e0, edge e1, gimple *phi,
    1362                 :            :                     tree arg0, tree arg1)
    1363                 :            : {
    1364                 :    1427680 :   tree result, type, rhs;
    1365                 :    1427680 :   gcond *cond;
    1366                 :    1427680 :   gassign *new_stmt;
    1367                 :    1427680 :   edge true_edge, false_edge;
    1368                 :    1427680 :   enum tree_code cmp, minmax, ass_code;
    1369                 :    1427680 :   tree smaller, alt_smaller, larger, alt_larger, arg_true, arg_false;
    1370                 :    1427680 :   gimple_stmt_iterator gsi, gsi_from;
    1371                 :            : 
    1372                 :    1427680 :   type = TREE_TYPE (PHI_RESULT (phi));
    1373                 :            : 
    1374                 :            :   /* The optimization may be unsafe due to NaNs.  */
    1375                 :    1427680 :   if (HONOR_NANS (type) || HONOR_SIGNED_ZEROS (type))
    1376                 :      27242 :     return false;
    1377                 :            : 
    1378                 :    1400440 :   cond = as_a <gcond *> (last_stmt (cond_bb));
    1379                 :    1400440 :   cmp = gimple_cond_code (cond);
    1380                 :    1400440 :   rhs = gimple_cond_rhs (cond);
    1381                 :            : 
    1382                 :            :   /* Turn EQ/NE of extreme values to order comparisons.  */
    1383                 :    1400440 :   if ((cmp == NE_EXPR || cmp == EQ_EXPR)
    1384                 :    1203200 :       && TREE_CODE (rhs) == INTEGER_CST
    1385                 :    2349330 :       && INTEGRAL_TYPE_P (TREE_TYPE (rhs)))
    1386                 :            :     {
    1387                 :     723142 :       if (wi::eq_p (wi::to_wide (rhs), wi::min_value (TREE_TYPE (rhs))))
    1388                 :            :         {
    1389                 :     394505 :           cmp = (cmp == EQ_EXPR) ? LT_EXPR : GE_EXPR;
    1390                 :     394505 :           rhs = wide_int_to_tree (TREE_TYPE (rhs),
    1391                 :     789010 :                                   wi::min_value (TREE_TYPE (rhs)) + 1);
    1392                 :            :         }
    1393                 :     328637 :       else if (wi::eq_p (wi::to_wide (rhs), wi::max_value (TREE_TYPE (rhs))))
    1394                 :            :         {
    1395                 :       5529 :           cmp = (cmp == EQ_EXPR) ? GT_EXPR : LE_EXPR;
    1396                 :       5529 :           rhs = wide_int_to_tree (TREE_TYPE (rhs),
    1397                 :      11058 :                                   wi::max_value (TREE_TYPE (rhs)) - 1);
    1398                 :            :         }
    1399                 :            :     }
    1400                 :            : 
    1401                 :            :   /* This transformation is only valid for order comparisons.  Record which
    1402                 :            :      operand is smaller/larger if the result of the comparison is true.  */
    1403                 :    1400440 :   alt_smaller = NULL_TREE;
    1404                 :    1400440 :   alt_larger = NULL_TREE;
    1405                 :    1400440 :   if (cmp == LT_EXPR || cmp == LE_EXPR)
    1406                 :            :     {
    1407                 :     132641 :       smaller = gimple_cond_lhs (cond);
    1408                 :     132641 :       larger = rhs;
    1409                 :            :       /* If we have smaller < CST it is equivalent to smaller <= CST-1.
    1410                 :            :          Likewise smaller <= CST is equivalent to smaller < CST+1.  */
    1411                 :     132641 :       if (TREE_CODE (larger) == INTEGER_CST
    1412                 :     230610 :           && INTEGRAL_TYPE_P (TREE_TYPE (larger)))
    1413                 :            :         {
    1414                 :      97969 :           if (cmp == LT_EXPR)
    1415                 :            :             {
    1416                 :      62598 :               wi::overflow_type overflow;
    1417                 :      62598 :               wide_int alt = wi::sub (wi::to_wide (larger), 1,
    1418                 :      62598 :                                       TYPE_SIGN (TREE_TYPE (larger)),
    1419                 :      62598 :                                       &overflow);
    1420                 :      62598 :               if (! overflow)
    1421                 :      62598 :                 alt_larger = wide_int_to_tree (TREE_TYPE (larger), alt);
    1422                 :            :             }
    1423                 :            :           else
    1424                 :            :             {
    1425                 :      35371 :               wi::overflow_type overflow;
    1426                 :      35371 :               wide_int alt = wi::add (wi::to_wide (larger), 1,
    1427                 :      35371 :                                       TYPE_SIGN (TREE_TYPE (larger)),
    1428                 :      35371 :                                       &overflow);
    1429                 :      35371 :               if (! overflow)
    1430                 :      35123 :                 alt_larger = wide_int_to_tree (TREE_TYPE (larger), alt);
    1431                 :            :             }
    1432                 :            :         }
    1433                 :            :     }
    1434                 :    1267790 :   else if (cmp == GT_EXPR || cmp == GE_EXPR)
    1435                 :            :     {
    1436                 :     462994 :       smaller = rhs;
    1437                 :     462994 :       larger = gimple_cond_lhs (cond);
    1438                 :            :       /* If we have larger > CST it is equivalent to larger >= CST+1.
    1439                 :            :          Likewise larger >= CST is equivalent to larger > CST-1.  */
    1440                 :     462994 :       if (TREE_CODE (smaller) == INTEGER_CST
    1441                 :     875427 :           && INTEGRAL_TYPE_P (TREE_TYPE (smaller)))
    1442                 :            :         {
    1443                 :     412361 :           wi::overflow_type overflow;
    1444                 :     412361 :           if (cmp == GT_EXPR)
    1445                 :            :             {
    1446                 :      49854 :               wide_int alt = wi::add (wi::to_wide (smaller), 1,
    1447                 :      49854 :                                       TYPE_SIGN (TREE_TYPE (smaller)),
    1448                 :      49854 :                                       &overflow);
    1449                 :      49854 :               if (! overflow)
    1450                 :      49854 :                 alt_smaller = wide_int_to_tree (TREE_TYPE (smaller), alt);
    1451                 :            :             }
    1452                 :            :           else
    1453                 :            :             {
    1454                 :     362507 :               wide_int alt = wi::sub (wi::to_wide (smaller), 1,
    1455                 :     362507 :                                       TYPE_SIGN (TREE_TYPE (smaller)),
    1456                 :     362507 :                                       &overflow);
    1457                 :     362507 :               if (! overflow)
    1458                 :     362507 :                 alt_smaller = wide_int_to_tree (TREE_TYPE (smaller), alt);
    1459                 :            :             }
    1460                 :            :         }
    1461                 :            :     }
    1462                 :            :   else
    1463                 :            :     return false;
    1464                 :            : 
    1465                 :            :   /* We need to know which is the true edge and which is the false
    1466                 :            :       edge so that we know if have abs or negative abs.  */
    1467                 :     595635 :   extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
    1468                 :            : 
    1469                 :            :   /* Forward the edges over the middle basic block.  */
    1470                 :     595635 :   if (true_edge->dest == middle_bb)
    1471                 :     450968 :     true_edge = EDGE_SUCC (true_edge->dest, 0);
    1472                 :     595635 :   if (false_edge->dest == middle_bb)
    1473                 :     144667 :     false_edge = EDGE_SUCC (false_edge->dest, 0);
    1474                 :            : 
    1475                 :     595635 :   if (true_edge == e0)
    1476                 :            :     {
    1477                 :     450968 :       gcc_assert (false_edge == e1);
    1478                 :            :       arg_true = arg0;
    1479                 :            :       arg_false = arg1;
    1480                 :            :     }
    1481                 :            :   else
    1482                 :            :     {
    1483                 :     144667 :       gcc_assert (false_edge == e0);
    1484                 :     144667 :       gcc_assert (true_edge == e1);
    1485                 :            :       arg_true = arg1;
    1486                 :            :       arg_false = arg0;
    1487                 :            :     }
    1488                 :            : 
    1489                 :     595635 :   if (empty_block_p (middle_bb))
    1490                 :            :     {
    1491                 :      95209 :       if ((operand_equal_for_phi_arg_p (arg_true, smaller)
    1492                 :      72984 :            || (alt_smaller
    1493                 :      38544 :                && operand_equal_for_phi_arg_p (arg_true, alt_smaller)))
    1494                 :      98919 :           && (operand_equal_for_phi_arg_p (arg_false, larger)
    1495                 :      19011 :               || (alt_larger
    1496                 :       1990 :                   && operand_equal_for_phi_arg_p (arg_true, alt_larger))))
    1497                 :            :         {
    1498                 :            :           /* Case
    1499                 :            : 
    1500                 :            :              if (smaller < larger)
    1501                 :            :              rslt = smaller;
    1502                 :            :              else
    1503                 :            :              rslt = larger;  */
    1504                 :            :           minmax = MIN_EXPR;
    1505                 :            :         }
    1506                 :      88285 :       else if ((operand_equal_for_phi_arg_p (arg_false, smaller)
    1507                 :      77239 :                 || (alt_smaller
    1508                 :      46773 :                     && operand_equal_for_phi_arg_p (arg_false, alt_smaller)))
    1509                 :     102527 :                && (operand_equal_for_phi_arg_p (arg_true, larger)
    1510                 :      19661 :                    || (alt_larger
    1511                 :       1801 :                        && operand_equal_for_phi_arg_p (arg_true, alt_larger))))
    1512                 :            :         minmax = MAX_EXPR;
    1513                 :            :       else
    1514                 :      82143 :         return false;
    1515                 :            :     }
    1516                 :            :   else
    1517                 :            :     {
    1518                 :            :       /* Recognize the following case, assuming d <= u:
    1519                 :            : 
    1520                 :            :          if (a <= u)
    1521                 :            :            b = MAX (a, d);
    1522                 :            :          x = PHI <b, u>
    1523                 :            : 
    1524                 :            :          This is equivalent to
    1525                 :            : 
    1526                 :            :          b = MAX (a, d);
    1527                 :            :          x = MIN (b, u);  */
    1528                 :            : 
    1529                 :     500426 :       gimple *assign = last_and_only_stmt (middle_bb);
    1530                 :     500426 :       tree lhs, op0, op1, bound;
    1531                 :            : 
    1532                 :     500426 :       if (!assign
    1533                 :     500426 :           || gimple_code (assign) != GIMPLE_ASSIGN)
    1534                 :            :         return false;
    1535                 :            : 
    1536                 :      93705 :       lhs = gimple_assign_lhs (assign);
    1537                 :      93705 :       ass_code = gimple_assign_rhs_code (assign);
    1538                 :      93705 :       if (ass_code != MAX_EXPR && ass_code != MIN_EXPR)
    1539                 :            :         return false;
    1540                 :       3426 :       op0 = gimple_assign_rhs1 (assign);
    1541                 :       3426 :       op1 = gimple_assign_rhs2 (assign);
    1542                 :            : 
    1543                 :       3426 :       if (true_edge->src == middle_bb)
    1544                 :            :         {
    1545                 :            :           /* We got here if the condition is true, i.e., SMALLER < LARGER.  */
    1546                 :       1942 :           if (!operand_equal_for_phi_arg_p (lhs, arg_true))
    1547                 :            :             return false;
    1548                 :            : 
    1549                 :       1942 :           if (operand_equal_for_phi_arg_p (arg_false, larger)
    1550                 :       1942 :               || (alt_larger
    1551                 :         59 :                   && operand_equal_for_phi_arg_p (arg_false, alt_larger)))
    1552                 :            :             {
    1553                 :            :               /* Case
    1554                 :            : 
    1555                 :            :                  if (smaller < larger)
    1556                 :            :                    {
    1557                 :            :                      r' = MAX_EXPR (smaller, bound)
    1558                 :            :                    }
    1559                 :            :                  r = PHI <r', larger>  --> to be turned to MIN_EXPR.  */
    1560                 :       1287 :               if (ass_code != MAX_EXPR)
    1561                 :            :                 return false;
    1562                 :            : 
    1563                 :       1270 :               minmax = MIN_EXPR;
    1564                 :       1270 :               if (operand_equal_for_phi_arg_p (op0, smaller)
    1565                 :       1270 :                   || (alt_smaller
    1566                 :          0 :                       && operand_equal_for_phi_arg_p (op0, alt_smaller)))
    1567                 :            :                 bound = op1;
    1568                 :        793 :               else if (operand_equal_for_phi_arg_p (op1, smaller)
    1569                 :        793 :                        || (alt_smaller
    1570                 :          0 :                            && operand_equal_for_phi_arg_p (op1, alt_smaller)))
    1571                 :            :                 bound = op0;
    1572                 :            :               else
    1573                 :          0 :                 return false;
    1574                 :            : 
    1575                 :            :               /* We need BOUND <= LARGER.  */
    1576                 :       1270 :               if (!integer_nonzerop (fold_build2 (LE_EXPR, boolean_type_node,
    1577                 :            :                                                   bound, larger)))
    1578                 :            :                 return false;
    1579                 :            :             }
    1580                 :        655 :           else if (operand_equal_for_phi_arg_p (arg_false, smaller)
    1581                 :        655 :                    || (alt_smaller
    1582                 :        212 :                        && operand_equal_for_phi_arg_p (arg_false, alt_smaller)))
    1583                 :            :             {
    1584                 :            :               /* Case
    1585                 :            : 
    1586                 :            :                  if (smaller < larger)
    1587                 :            :                    {
    1588                 :            :                      r' = MIN_EXPR (larger, bound)
    1589                 :            :                    }
    1590                 :            :                  r = PHI <r', smaller>  --> to be turned to MAX_EXPR.  */
    1591                 :        179 :               if (ass_code != MIN_EXPR)
    1592                 :            :                 return false;
    1593                 :            : 
    1594                 :        162 :               minmax = MAX_EXPR;
    1595                 :        162 :               if (operand_equal_for_phi_arg_p (op0, larger)
    1596                 :        162 :                   || (alt_larger
    1597                 :          0 :                       && operand_equal_for_phi_arg_p (op0, alt_larger)))
    1598                 :            :                 bound = op1;
    1599                 :         13 :               else if (operand_equal_for_phi_arg_p (op1, larger)
    1600                 :         13 :                        || (alt_larger
    1601                 :          0 :                            && operand_equal_for_phi_arg_p (op1, alt_larger)))
    1602                 :            :                 bound = op0;
    1603                 :            :               else
    1604                 :          0 :                 return false;
    1605                 :            : 
    1606                 :            :               /* We need BOUND >= SMALLER.  */
    1607                 :        162 :               if (!integer_nonzerop (fold_build2 (GE_EXPR, boolean_type_node,
    1608                 :            :                                                   bound, smaller)))
    1609                 :            :                 return false;
    1610                 :            :             }
    1611                 :            :           else
    1612                 :        476 :             return false;
    1613                 :            :         }
    1614                 :            :       else
    1615                 :            :         {
    1616                 :            :           /* We got here if the condition is false, i.e., SMALLER > LARGER.  */
    1617                 :       1484 :           if (!operand_equal_for_phi_arg_p (lhs, arg_false))
    1618                 :            :             return false;
    1619                 :            : 
    1620                 :       1484 :           if (operand_equal_for_phi_arg_p (arg_true, larger)
    1621                 :       1484 :               || (alt_larger
    1622                 :         40 :                   && operand_equal_for_phi_arg_p (arg_true, alt_larger)))
    1623                 :            :             {
    1624                 :            :               /* Case
    1625                 :            : 
    1626                 :            :                  if (smaller > larger)
    1627                 :            :                    {
    1628                 :            :                      r' = MIN_EXPR (smaller, bound)
    1629                 :            :                    }
    1630                 :            :                  r = PHI <r', larger>  --> to be turned to MAX_EXPR.  */
    1631                 :         88 :               if (ass_code != MIN_EXPR)
    1632                 :            :                 return false;
    1633                 :            : 
    1634                 :         85 :               minmax = MAX_EXPR;
    1635                 :         85 :               if (operand_equal_for_phi_arg_p (op0, smaller)
    1636                 :         85 :                   || (alt_smaller
    1637                 :          0 :                       && operand_equal_for_phi_arg_p (op0, alt_smaller)))
    1638                 :            :                 bound = op1;
    1639                 :         44 :               else if (operand_equal_for_phi_arg_p (op1, smaller)
    1640                 :         44 :                        || (alt_smaller
    1641                 :          0 :                            && operand_equal_for_phi_arg_p (op1, alt_smaller)))
    1642                 :            :                 bound = op0;
    1643                 :            :               else
    1644                 :          0 :                 return false;
    1645                 :            : 
    1646                 :            :               /* We need BOUND >= LARGER.  */
    1647                 :         85 :               if (!integer_nonzerop (fold_build2 (GE_EXPR, boolean_type_node,
    1648                 :            :                                                   bound, larger)))
    1649                 :            :                 return false;
    1650                 :            :             }
    1651                 :       1396 :           else if (operand_equal_for_phi_arg_p (arg_true, smaller)
    1652                 :       1396 :                    || (alt_smaller
    1653                 :         28 :                        && operand_equal_for_phi_arg_p (arg_true, alt_smaller)))
    1654                 :            :             {
    1655                 :            :               /* Case
    1656                 :            : 
    1657                 :            :                  if (smaller > larger)
    1658                 :            :                    {
    1659                 :            :                      r' = MAX_EXPR (larger, bound)
    1660                 :            :                    }
    1661                 :            :                  r = PHI <r', smaller>  --> to be turned to MIN_EXPR.  */
    1662                 :         91 :               if (ass_code != MAX_EXPR)
    1663                 :            :                 return false;
    1664                 :            : 
    1665                 :         91 :               minmax = MIN_EXPR;
    1666                 :         91 :               if (operand_equal_for_phi_arg_p (op0, larger))
    1667                 :            :                 bound = op1;
    1668                 :         69 :               else if (operand_equal_for_phi_arg_p (op1, larger))
    1669                 :            :                 bound = op0;
    1670                 :            :               else
    1671                 :            :                 return false;
    1672                 :            : 
    1673                 :            :               /* We need BOUND <= SMALLER.  */
    1674                 :         71 :               if (!integer_nonzerop (fold_build2 (LE_EXPR, boolean_type_node,
    1675                 :            :                                                   bound, smaller)))
    1676                 :            :                 return false;
    1677                 :            :             }
    1678                 :            :           else
    1679                 :       1305 :             return false;
    1680                 :            :         }
    1681                 :            : 
    1682                 :            :       /* Move the statement from the middle block.  */
    1683                 :        202 :       gsi = gsi_last_bb (cond_bb);
    1684                 :        202 :       gsi_from = gsi_last_nondebug_bb (middle_bb);
    1685                 :        202 :       reset_flow_sensitive_info (SINGLE_SSA_TREE_OPERAND (gsi_stmt (gsi_from),
    1686                 :            :                                                           SSA_OP_DEF));
    1687                 :        202 :       gsi_move_before (&gsi_from, &gsi);
    1688                 :            :     }
    1689                 :            : 
    1690                 :            :   /* Create an SSA var to hold the min/max result.  If we're the only
    1691                 :            :      things setting the target PHI, then we  can clone the PHI
    1692                 :            :      variable.  Otherwise we must create a new one.  */
    1693                 :      13268 :   result = PHI_RESULT (phi);
    1694                 :      13268 :   if (EDGE_COUNT (gimple_bb (phi)->preds) == 2)
    1695                 :      10833 :     result = duplicate_ssa_name (result, NULL);
    1696                 :            :   else
    1697                 :       2435 :     result = make_ssa_name (TREE_TYPE (result));
    1698                 :            : 
    1699                 :            :   /* Emit the statement to compute min/max.  */
    1700                 :      13268 :   new_stmt = gimple_build_assign (result, minmax, arg0, arg1);
    1701                 :      13268 :   gsi = gsi_last_bb (cond_bb);
    1702                 :      13268 :   gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
    1703                 :            : 
    1704                 :      13268 :   replace_phi_edge_with_variable (cond_bb, e1, phi, result);
    1705                 :            : 
    1706                 :      13268 :   return true;
    1707                 :            : }
    1708                 :            : 
    1709                 :            : /* Convert
    1710                 :            : 
    1711                 :            :    <bb 2>
    1712                 :            :    if (b_4(D) != 0)
    1713                 :            :    goto <bb 3>
    1714                 :            :    else
    1715                 :            :    goto <bb 4>
    1716                 :            : 
    1717                 :            :    <bb 3>
    1718                 :            :    _2 = (unsigned long) b_4(D);
    1719                 :            :    _9 = __builtin_popcountl (_2);
    1720                 :            :    OR
    1721                 :            :    _9 = __builtin_popcountl (b_4(D));
    1722                 :            : 
    1723                 :            :    <bb 4>
    1724                 :            :    c_12 = PHI <0(2), _9(3)>
    1725                 :            : 
    1726                 :            :    Into
    1727                 :            :    <bb 2>
    1728                 :            :    _2 = (unsigned long) b_4(D);
    1729                 :            :    _9 = __builtin_popcountl (_2);
    1730                 :            :    OR
    1731                 :            :    _9 = __builtin_popcountl (b_4(D));
    1732                 :            : 
    1733                 :            :    <bb 4>
    1734                 :            :    c_12 = PHI <_9(2)>
    1735                 :            : */
    1736                 :            : 
    1737                 :            : static bool
    1738                 :    1029240 : cond_removal_in_popcount_pattern (basic_block cond_bb, basic_block middle_bb,
    1739                 :            :                                   edge e1, edge e2,
    1740                 :            :                                   gimple *phi, tree arg0, tree arg1)
    1741                 :            : {
    1742                 :    1029240 :   gimple *cond;
    1743                 :    1029240 :   gimple_stmt_iterator gsi, gsi_from;
    1744                 :    1029240 :   gimple *popcount;
    1745                 :    1029240 :   gimple *cast = NULL;
    1746                 :    1029240 :   tree lhs, arg;
    1747                 :            : 
    1748                 :            :   /* Check that
    1749                 :            :    _2 = (unsigned long) b_4(D);
    1750                 :            :    _9 = __builtin_popcountl (_2);
    1751                 :            :    OR
    1752                 :            :    _9 = __builtin_popcountl (b_4(D));
    1753                 :            :    are the only stmts in the middle_bb.  */
    1754                 :            : 
    1755                 :    1029240 :   gsi = gsi_start_nondebug_after_labels_bb (middle_bb);
    1756                 :    1029240 :   if (gsi_end_p (gsi))
    1757                 :            :     return false;
    1758                 :    1667580 :   cast = gsi_stmt (gsi);
    1759                 :    1667580 :   gsi_next_nondebug (&gsi);
    1760                 :     903536 :   if (!gsi_end_p (gsi))
    1761                 :            :     {
    1762                 :    2025030 :       popcount = gsi_stmt (gsi);
    1763                 :    2025030 :       gsi_next_nondebug (&gsi);
    1764                 :     477779 :       if (!gsi_end_p (gsi))
    1765                 :            :         return false;
    1766                 :            :     }
    1767                 :            :   else
    1768                 :            :     {
    1769                 :            :       popcount = cast;
    1770                 :            :       cast = NULL;
    1771                 :            :     }
    1772                 :            : 
    1773                 :            :   /* Check that we have a popcount builtin.  */
    1774                 :     599506 :   if (!is_gimple_call (popcount))
    1775                 :            :     return false;
    1776                 :     385709 :   combined_fn cfn = gimple_call_combined_fn (popcount);
    1777                 :     385709 :   switch (cfn)
    1778                 :            :     {
    1779                 :         25 :     CASE_CFN_POPCOUNT:
    1780                 :         25 :       break;
    1781                 :            :     default:
    1782                 :            :       return false;
    1783                 :            :     }
    1784                 :            : 
    1785                 :         25 :   arg = gimple_call_arg (popcount, 0);
    1786                 :         25 :   lhs = gimple_get_lhs (popcount);
    1787                 :            : 
    1788                 :         25 :   if (cast)
    1789                 :            :     {
    1790                 :            :       /* We have a cast stmt feeding popcount builtin.  */
    1791                 :            :       /* Check that we have a cast prior to that.  */
    1792                 :         24 :       if (gimple_code (cast) != GIMPLE_ASSIGN
    1793                 :         24 :           || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (cast)))
    1794                 :            :         return false;
    1795                 :            :       /* Result of the cast stmt is the argument to the builtin.  */
    1796                 :          7 :       if (arg != gimple_assign_lhs (cast))
    1797                 :            :         return false;
    1798                 :          7 :       arg = gimple_assign_rhs1 (cast);
    1799                 :            :     }
    1800                 :            : 
    1801                 :          8 :   cond = last_stmt (cond_bb);
    1802                 :            : 
    1803                 :            :   /* Cond_bb has a check for b_4 [!=|==] 0 before calling the popcount
    1804                 :            :      builtin.  */
    1805                 :          8 :   if (gimple_code (cond) != GIMPLE_COND
    1806                 :          8 :       || (gimple_cond_code (cond) != NE_EXPR
    1807                 :          0 :           && gimple_cond_code (cond) != EQ_EXPR)
    1808                 :          8 :       || !integer_zerop (gimple_cond_rhs (cond))
    1809                 :         16 :       || arg != gimple_cond_lhs (cond))
    1810                 :          0 :     return false;
    1811                 :            : 
    1812                 :            :   /* Canonicalize.  */
    1813                 :          8 :   if ((e2->flags & EDGE_TRUE_VALUE
    1814                 :          0 :        && gimple_cond_code (cond) == NE_EXPR)
    1815                 :          8 :       || (e1->flags & EDGE_TRUE_VALUE
    1816                 :          0 :           && gimple_cond_code (cond) == EQ_EXPR))
    1817                 :            :     {
    1818                 :          8 :       std::swap (arg0, arg1);
    1819                 :          8 :       std::swap (e1, e2);
    1820                 :            :     }
    1821                 :            : 
    1822                 :            :   /* Check PHI arguments.  */
    1823                 :          8 :   if (lhs != arg0 || !integer_zerop (arg1))
    1824                 :          6 :     return false;
    1825                 :            : 
    1826                 :            :   /* And insert the popcount builtin and cast stmt before the cond_bb.  */
    1827                 :          2 :   gsi = gsi_last_bb (cond_bb);
    1828                 :          2 :   if (cast)
    1829                 :            :     {
    1830                 :          1 :       gsi_from = gsi_for_stmt (cast);
    1831                 :          1 :       gsi_move_before (&gsi_from, &gsi);
    1832                 :          1 :       reset_flow_sensitive_info (gimple_get_lhs (cast));
    1833                 :            :     }
    1834                 :          2 :   gsi_from = gsi_for_stmt (popcount);
    1835                 :          2 :   gsi_move_before (&gsi_from, &gsi);
    1836                 :          2 :   reset_flow_sensitive_info (gimple_get_lhs (popcount));
    1837                 :            : 
    1838                 :            :   /* Now update the PHI and remove unneeded bbs.  */
    1839                 :          2 :   replace_phi_edge_with_variable (cond_bb, e2, phi, lhs);
    1840                 :          2 :   return true;
    1841                 :            : }
    1842                 :            : 
    1843                 :            : /*  The function absolute_replacement does the main work of doing the absolute
    1844                 :            :     replacement.  Return true if the replacement is done.  Otherwise return
    1845                 :            :     false.
    1846                 :            :     bb is the basic block where the replacement is going to be done on.  arg0
    1847                 :            :     is argument 0 from the phi.  Likewise for arg1.  */
    1848                 :            : 
    1849                 :            : static bool
    1850                 :    1427800 : abs_replacement (basic_block cond_bb, basic_block middle_bb,
    1851                 :            :                  edge e0 ATTRIBUTE_UNUSED, edge e1,
    1852                 :            :                  gimple *phi, tree arg0, tree arg1)
    1853                 :            : {
    1854                 :    1427800 :   tree result;
    1855                 :    1427800 :   gassign *new_stmt;
    1856                 :    1427800 :   gimple *cond;
    1857                 :    1427800 :   gimple_stmt_iterator gsi;
    1858                 :    1427800 :   edge true_edge, false_edge;
    1859                 :    1427800 :   gimple *assign;
    1860                 :    1427800 :   edge e;
    1861                 :    1427800 :   tree rhs, lhs;
    1862                 :    1427800 :   bool negate;
    1863                 :    1427800 :   enum tree_code cond_code;
    1864                 :            : 
    1865                 :            :   /* If the type says honor signed zeros we cannot do this
    1866                 :            :      optimization.  */
    1867                 :    1427800 :   if (HONOR_SIGNED_ZEROS (arg1))
    1868                 :            :     return false;
    1869                 :            : 
    1870                 :            :   /* OTHER_BLOCK must have only one executable statement which must have the
    1871                 :            :      form arg0 = -arg1 or arg1 = -arg0.  */
    1872                 :            : 
    1873                 :    1400580 :   assign = last_and_only_stmt (middle_bb);
    1874                 :            :   /* If we did not find the proper negation assignment, then we cannot
    1875                 :            :      optimize.  */
    1876                 :    1400580 :   if (assign == NULL)
    1877                 :            :     return false;
    1878                 :            : 
    1879                 :            :   /* If we got here, then we have found the only executable statement
    1880                 :            :      in OTHER_BLOCK.  If it is anything other than arg = -arg1 or
    1881                 :            :      arg1 = -arg0, then we cannot optimize.  */
    1882                 :     597152 :   if (gimple_code (assign) != GIMPLE_ASSIGN)
    1883                 :            :     return false;
    1884                 :            : 
    1885                 :     215699 :   lhs = gimple_assign_lhs (assign);
    1886                 :            : 
    1887                 :     215699 :   if (gimple_assign_rhs_code (assign) != NEGATE_EXPR)
    1888                 :            :     return false;
    1889                 :            : 
    1890                 :       1985 :   rhs = gimple_assign_rhs1 (assign);
    1891                 :            : 
    1892                 :            :   /* The assignment has to be arg0 = -arg1 or arg1 = -arg0.  */
    1893                 :       1985 :   if (!(lhs == arg0 && rhs == arg1)
    1894                 :        154 :       && !(lhs == arg1 && rhs == arg0))
    1895                 :            :     return false;
    1896                 :            : 
    1897                 :       1831 :   cond = last_stmt (cond_bb);
    1898                 :       1831 :   result = PHI_RESULT (phi);
    1899                 :            : 
    1900                 :            :   /* Only relationals comparing arg[01] against zero are interesting.  */
    1901                 :       1831 :   cond_code = gimple_cond_code (cond);
    1902                 :       1831 :   if (cond_code != GT_EXPR && cond_code != GE_EXPR
    1903                 :       1831 :       && cond_code != LT_EXPR && cond_code != LE_EXPR)
    1904                 :            :     return false;
    1905                 :            : 
    1906                 :            :   /* Make sure the conditional is arg[01] OP y.  */
    1907                 :        788 :   if (gimple_cond_lhs (cond) != rhs)
    1908                 :            :     return false;
    1909                 :            : 
    1910                 :        462 :   if (FLOAT_TYPE_P (TREE_TYPE (gimple_cond_rhs (cond)))
    1911                 :        154 :                ? real_zerop (gimple_cond_rhs (cond))
    1912                 :        154 :                : integer_zerop (gimple_cond_rhs (cond)))
    1913                 :            :     ;
    1914                 :            :   else
    1915                 :            :     return false;
    1916                 :            : 
    1917                 :            :   /* We need to know which is the true edge and which is the false
    1918                 :            :      edge so that we know if have abs or negative abs.  */
    1919                 :        150 :   extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
    1920                 :            : 
    1921                 :            :   /* For GT_EXPR/GE_EXPR, if the true edge goes to OTHER_BLOCK, then we
    1922                 :            :      will need to negate the result.  Similarly for LT_EXPR/LE_EXPR if
    1923                 :            :      the false edge goes to OTHER_BLOCK.  */
    1924                 :        150 :   if (cond_code == GT_EXPR || cond_code == GE_EXPR)
    1925                 :         33 :     e = true_edge;
    1926                 :            :   else
    1927                 :        117 :     e = false_edge;
    1928                 :            : 
    1929                 :        150 :   if (e->dest == middle_bb)
    1930                 :            :     negate = true;
    1931                 :            :   else
    1932                 :            :     negate = false;
    1933                 :            : 
    1934                 :            :   /* If the code negates only iff positive then make sure to not
    1935                 :            :      introduce undefined behavior when negating or computing the absolute.
    1936                 :            :      ???  We could use range info if present to check for arg1 == INT_MIN.  */
    1937                 :         32 :   if (negate
    1938                 :         32 :       && (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg1))
    1939                 :         64 :           && ! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1))))
    1940                 :            :     return false;
    1941                 :            : 
    1942                 :        118 :   result = duplicate_ssa_name (result, NULL);
    1943                 :            : 
    1944                 :        118 :   if (negate)
    1945                 :          0 :     lhs = make_ssa_name (TREE_TYPE (result));
    1946                 :            :   else
    1947                 :            :     lhs = result;
    1948                 :            : 
    1949                 :            :   /* Build the modify expression with abs expression.  */
    1950                 :        118 :   new_stmt = gimple_build_assign (lhs, ABS_EXPR, rhs);
    1951                 :            : 
    1952                 :        118 :   gsi = gsi_last_bb (cond_bb);
    1953                 :        118 :   gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
    1954                 :            : 
    1955                 :        118 :   if (negate)
    1956                 :            :     {
    1957                 :            :       /* Get the right GSI.  We want to insert after the recently
    1958                 :            :          added ABS_EXPR statement (which we know is the first statement
    1959                 :            :          in the block.  */
    1960                 :          0 :       new_stmt = gimple_build_assign (result, NEGATE_EXPR, lhs);
    1961                 :            : 
    1962                 :          0 :       gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
    1963                 :            :     }
    1964                 :            : 
    1965                 :        118 :   replace_phi_edge_with_variable (cond_bb, e1, phi, result);
    1966                 :            : 
    1967                 :            :   /* Note that we optimized this PHI.  */
    1968                 :        118 :   return true;
    1969                 :            : }
    1970                 :            : 
    1971                 :            : /* Auxiliary functions to determine the set of memory accesses which
    1972                 :            :    can't trap because they are preceded by accesses to the same memory
    1973                 :            :    portion.  We do that for MEM_REFs, so we only need to track
    1974                 :            :    the SSA_NAME of the pointer indirectly referenced.  The algorithm
    1975                 :            :    simply is a walk over all instructions in dominator order.  When
    1976                 :            :    we see an MEM_REF we determine if we've already seen a same
    1977                 :            :    ref anywhere up to the root of the dominator tree.  If we do the
    1978                 :            :    current access can't trap.  If we don't see any dominating access
    1979                 :            :    the current access might trap, but might also make later accesses
    1980                 :            :    non-trapping, so we remember it.  We need to be careful with loads
    1981                 :            :    or stores, for instance a load might not trap, while a store would,
    1982                 :            :    so if we see a dominating read access this doesn't mean that a later
    1983                 :            :    write access would not trap.  Hence we also need to differentiate the
    1984                 :            :    type of access(es) seen.
    1985                 :            : 
    1986                 :            :    ??? We currently are very conservative and assume that a load might
    1987                 :            :    trap even if a store doesn't (write-only memory).  This probably is
    1988                 :            :    overly conservative.  */
    1989                 :            : 
    1990                 :            : /* A hash-table of SSA_NAMEs, and in which basic block an MEM_REF
    1991                 :            :    through it was seen, which would constitute a no-trap region for
    1992                 :            :    same accesses.  */
    1993                 :            : struct name_to_bb
    1994                 :            : {
    1995                 :            :   unsigned int ssa_name_ver;
    1996                 :            :   unsigned int phase;
    1997                 :            :   bool store;
    1998                 :            :   HOST_WIDE_INT offset, size;
    1999                 :            :   basic_block bb;
    2000                 :            : };
    2001                 :            : 
    2002                 :            : /* Hashtable helpers.  */
    2003                 :            : 
    2004                 :            : struct ssa_names_hasher : free_ptr_hash <name_to_bb>
    2005                 :            : {
    2006                 :            :   static inline hashval_t hash (const name_to_bb *);
    2007                 :            :   static inline bool equal (const name_to_bb *, const name_to_bb *);
    2008                 :            : };
    2009                 :            : 
    2010                 :            : /* Used for quick clearing of the hash-table when we see calls.
    2011                 :            :    Hash entries with phase < nt_call_phase are invalid.  */
    2012                 :            : static unsigned int nt_call_phase;
    2013                 :            : 
    2014                 :            : /* The hash function.  */
    2015                 :            : 
    2016                 :            : inline hashval_t
    2017                 :    1347840 : ssa_names_hasher::hash (const name_to_bb *n)
    2018                 :            : {
    2019                 :    1347840 :   return n->ssa_name_ver ^ (((hashval_t) n->store) << 31)
    2020                 :    1347840 :          ^ (n->offset << 6) ^ (n->size << 3);
    2021                 :            : }
    2022                 :            : 
    2023                 :            : /* The equality function of *P1 and *P2.  */
    2024                 :            : 
    2025                 :            : inline bool
    2026                 :     532561 : ssa_names_hasher::equal (const name_to_bb *n1, const name_to_bb *n2)
    2027                 :            : {
    2028                 :     532561 :   return n1->ssa_name_ver == n2->ssa_name_ver
    2029                 :     113972 :          && n1->store == n2->store
    2030                 :     107555 :          && n1->offset == n2->offset
    2031                 :     593264 :          && n1->size == n2->size;
    2032                 :            : }
    2033                 :            : 
    2034                 :     685611 : class nontrapping_dom_walker : public dom_walker
    2035                 :            : {
    2036                 :            : public:
    2037                 :     685611 :   nontrapping_dom_walker (cdi_direction direction, hash_set<tree> *ps)
    2038                 :     685611 :     : dom_walker (direction), m_nontrapping (ps), m_seen_ssa_names (128) {}
    2039                 :            : 
    2040                 :            :   virtual edge before_dom_children (basic_block);
    2041                 :            :   virtual void after_dom_children (basic_block);
    2042                 :            : 
    2043                 :            : private:
    2044                 :            : 
    2045                 :            :   /* We see the expression EXP in basic block BB.  If it's an interesting
    2046                 :            :      expression (an MEM_REF through an SSA_NAME) possibly insert the
    2047                 :            :      expression into the set NONTRAP or the hash table of seen expressions.
    2048                 :            :      STORE is true if this expression is on the LHS, otherwise it's on
    2049                 :            :      the RHS.  */
    2050                 :            :   void add_or_mark_expr (basic_block, tree, bool);
    2051                 :            : 
    2052                 :            :   hash_set<tree> *m_nontrapping;
    2053                 :            : 
    2054                 :            :   /* The hash table for remembering what we've seen.  */
    2055                 :            :   hash_table<ssa_names_hasher> m_seen_ssa_names;
    2056                 :            : };
    2057                 :            : 
    2058                 :            : /* Called by walk_dominator_tree, when entering the block BB.  */
    2059                 :            : edge
    2060                 :    7218640 : nontrapping_dom_walker::before_dom_children (basic_block bb)
    2061                 :            : {
    2062                 :    7218640 :   edge e;
    2063                 :    7218640 :   edge_iterator ei;
    2064                 :    7218640 :   gimple_stmt_iterator gsi;
    2065                 :            : 
    2066                 :            :   /* If we haven't seen all our predecessors, clear the hash-table.  */
    2067                 :   15908400 :   FOR_EACH_EDGE (e, ei, bb->preds)
    2068                 :    9072540 :     if ((((size_t)e->src->aux) & 2) == 0)
    2069                 :            :       {
    2070                 :     382727 :         nt_call_phase++;
    2071                 :     382727 :         break;
    2072                 :            :       }
    2073                 :            : 
    2074                 :            :   /* Mark this BB as being on the path to dominator root and as visited.  */
    2075                 :    7218640 :   bb->aux = (void*)(1 | 2);
    2076                 :            : 
    2077                 :            :   /* And walk the statements in order.  */
    2078                 :   65773600 :   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    2079                 :            :     {
    2080                 :   51336300 :       gimple *stmt = gsi_stmt (gsi);
    2081                 :            : 
    2082                 :   51336300 :       if ((gimple_code (stmt) == GIMPLE_ASM && gimple_vdef (stmt))
    2083                 :   51379900 :           || (is_gimple_call (stmt)
    2084                 :    3589530 :               && (!nonfreeing_call_p (stmt) || !nonbarrier_call_p (stmt))))
    2085                 :    3408600 :         nt_call_phase++;
    2086                 :   74853200 :       else if (gimple_assign_single_p (stmt) && !gimple_has_volatile_ops (stmt))
    2087                 :            :         {
    2088                 :    8811460 :           add_or_mark_expr (bb, gimple_assign_lhs (stmt), true);
    2089                 :    8811460 :           add_or_mark_expr (bb, gimple_assign_rhs1 (stmt), false);
    2090                 :            :         }
    2091                 :            :     }
    2092                 :    7218640 :   return NULL;
    2093                 :            : }
    2094                 :            : 
    2095                 :            : /* Called by walk_dominator_tree, when basic block BB is exited.  */
    2096                 :            : void
    2097                 :    7218640 : nontrapping_dom_walker::after_dom_children (basic_block bb)
    2098                 :            : {
    2099                 :            :   /* This BB isn't on the path to dominator root anymore.  */
    2100                 :    7218640 :   bb->aux = (void*)2;
    2101                 :    7218640 : }
    2102                 :            : 
    2103                 :            : /* We see the expression EXP in basic block BB.  If it's an interesting
    2104                 :            :    expression (an MEM_REF through an SSA_NAME) possibly insert the
    2105                 :            :    expression into the set NONTRAP or the hash table of seen expressions.
    2106                 :            :    STORE is true if this expression is on the LHS, otherwise it's on
    2107                 :            :    the RHS.  */
    2108                 :            : void
    2109                 :   17622900 : nontrapping_dom_walker::add_or_mark_expr (basic_block bb, tree exp, bool store)
    2110                 :            : {
    2111                 :   17622900 :   HOST_WIDE_INT size;
    2112                 :            : 
    2113                 :   17622900 :   if (TREE_CODE (exp) == MEM_REF
    2114                 :    1738150 :       && TREE_CODE (TREE_OPERAND (exp, 0)) == SSA_NAME
    2115                 :     917893 :       && tree_fits_shwi_p (TREE_OPERAND (exp, 1))
    2116                 :   18509300 :       && (size = int_size_in_bytes (TREE_TYPE (exp))) > 0)
    2117                 :            :     {
    2118                 :     886348 :       tree name = TREE_OPERAND (exp, 0);
    2119                 :     886348 :       struct name_to_bb map;
    2120                 :     886348 :       name_to_bb **slot;
    2121                 :     886348 :       struct name_to_bb *n2bb;
    2122                 :     886348 :       basic_block found_bb = 0;
    2123                 :            : 
    2124                 :            :       /* Try to find the last seen MEM_REF through the same
    2125                 :            :          SSA_NAME, which can trap.  */
    2126                 :     886348 :       map.ssa_name_ver = SSA_NAME_VERSION (name);
    2127                 :     886348 :       map.phase = 0;
    2128                 :     886348 :       map.bb = 0;
    2129                 :     886348 :       map.store = store;
    2130                 :     886348 :       map.offset = tree_to_shwi (TREE_OPERAND (exp, 1));
    2131                 :     886348 :       map.size = size;
    2132                 :            : 
    2133                 :     886348 :       slot = m_seen_ssa_names.find_slot (&map, INSERT);
    2134                 :     886348 :       n2bb = *slot;
    2135                 :     886348 :       if (n2bb && n2bb->phase >= nt_call_phase)
    2136                 :      21604 :         found_bb = n2bb->bb;
    2137                 :            : 
    2138                 :            :       /* If we've found a trapping MEM_REF, _and_ it dominates EXP
    2139                 :            :          (it's in a basic block on the path from us to the dominator root)
    2140                 :            :          then we can't trap.  */
    2141                 :      21604 :       if (found_bb && (((size_t)found_bb->aux) & 1) == 1)
    2142                 :            :         {
    2143                 :       4952 :           m_nontrapping->add (exp);
    2144                 :            :         }
    2145                 :            :       else
    2146                 :            :         {
    2147                 :            :           /* EXP might trap, so insert it into the hash table.  */
    2148                 :     881396 :           if (n2bb)
    2149                 :            :             {
    2150                 :      54662 :               n2bb->phase = nt_call_phase;
    2151                 :      54662 :               n2bb->bb = bb;
    2152                 :            :             }
    2153                 :            :           else
    2154                 :            :             {
    2155                 :     826734 :               n2bb = XNEW (struct name_to_bb);
    2156                 :     826734 :               n2bb->ssa_name_ver = SSA_NAME_VERSION (name);
    2157                 :     826734 :               n2bb->phase = nt_call_phase;
    2158                 :     826734 :               n2bb->bb = bb;
    2159                 :     826734 :               n2bb->store = store;
    2160                 :     826734 :               n2bb->offset = map.offset;
    2161                 :     826734 :               n2bb->size = size;
    2162                 :     826734 :               *slot = n2bb;
    2163                 :            :             }
    2164                 :            :         }
    2165                 :            :     }
    2166                 :   17622900 : }
    2167                 :            : 
    2168                 :            : /* This is the entry point of gathering non trapping memory accesses.
    2169                 :            :    It will do a dominator walk over the whole function, and it will
    2170                 :            :    make use of the bb->aux pointers.  It returns a set of trees
    2171                 :            :    (the MEM_REFs itself) which can't trap.  */
    2172                 :            : static hash_set<tree> *
    2173                 :     685611 : get_non_trapping (void)
    2174                 :            : {
    2175                 :     685611 :   nt_call_phase = 0;
    2176                 :     685611 :   hash_set<tree> *nontrap = new hash_set<tree>;
    2177                 :            :   /* We're going to do a dominator walk, so ensure that we have
    2178                 :            :      dominance information.  */
    2179                 :     685611 :   calculate_dominance_info (CDI_DOMINATORS);
    2180                 :            : 
    2181                 :     685611 :   nontrapping_dom_walker (CDI_DOMINATORS, nontrap)
    2182                 :     685611 :     .walk (cfun->cfg->x_entry_block_ptr);
    2183                 :            : 
    2184                 :     685611 :   clear_aux_for_blocks ();
    2185                 :     685611 :   return nontrap;
    2186                 :            : }
    2187                 :            : 
    2188                 :            : /* Do the main work of conditional store replacement.  We already know
    2189                 :            :    that the recognized pattern looks like so:
    2190                 :            : 
    2191                 :            :    split:
    2192                 :            :      if (cond) goto MIDDLE_BB; else goto JOIN_BB (edge E1)
    2193                 :            :    MIDDLE_BB:
    2194                 :            :      something
    2195                 :            :      fallthrough (edge E0)
    2196                 :            :    JOIN_BB:
    2197                 :            :      some more
    2198                 :            : 
    2199                 :            :    We check that MIDDLE_BB contains only one store, that that store
    2200                 :            :    doesn't trap (not via NOTRAP, but via checking if an access to the same
    2201                 :            :    memory location dominates us, or the store is to a local addressable
    2202                 :            :    object) and that the store has a "simple" RHS.  */
    2203                 :            : 
    2204                 :            : static bool
    2205                 :     344046 : cond_store_replacement (basic_block middle_bb, basic_block join_bb,
    2206                 :            :                         edge e0, edge e1, hash_set<tree> *nontrap)
    2207                 :            : {
    2208                 :     344046 :   gimple *assign = last_and_only_stmt (middle_bb);
    2209                 :     344046 :   tree lhs, rhs, name, name2;
    2210                 :     344046 :   gphi *newphi;
    2211                 :     344046 :   gassign *new_stmt;
    2212                 :     344046 :   gimple_stmt_iterator gsi;
    2213                 :     344046 :   location_t locus;
    2214                 :            : 
    2215                 :            :   /* Check if middle_bb contains of only one store.  */
    2216                 :     344046 :   if (!assign
    2217                 :      26592 :       || !gimple_assign_single_p (assign)
    2218                 :     370638 :       || gimple_has_volatile_ops (assign))
    2219                 :            :     return false;
    2220                 :            : 
    2221                 :            :   /* And no PHI nodes so all uses in the single stmt are also
    2222                 :            :      available where we insert to.  */
    2223                 :      26520 :   if (!gimple_seq_empty_p (phi_nodes (middle_bb)))
    2224                 :            :     return false;
    2225                 :            : 
    2226                 :      26519 :   locus = gimple_location (assign);
    2227                 :      26519 :   lhs = gimple_assign_lhs (assign);
    2228                 :      26519 :   rhs = gimple_assign_rhs1 (assign);
    2229                 :      26519 :   if ((TREE_CODE (lhs) != MEM_REF
    2230                 :      25167 :        && TREE_CODE (lhs) != ARRAY_REF
    2231                 :      19952 :        && TREE_CODE (lhs) != COMPONENT_REF)
    2232                 :      37651 :       || !is_gimple_reg_type (TREE_TYPE (lhs)))
    2233                 :            :     return false;
    2234                 :            : 
    2235                 :            :   /* Prove that we can move the store down.  We could also check
    2236                 :            :      TREE_THIS_NOTRAP here, but in that case we also could move stores,
    2237                 :            :      whose value is not available readily, which we want to avoid.  */
    2238                 :      12370 :   if (!nontrap->contains (lhs))
    2239                 :            :     {
    2240                 :            :       /* If LHS is a local variable without address-taken, we could
    2241                 :            :          always safely move down the store.  */
    2242                 :      12345 :       tree base = get_base_address (lhs);
    2243                 :      12345 :       if (!auto_var_p (base) || TREE_ADDRESSABLE (base))
    2244                 :            :         return false;
    2245                 :            :     }
    2246                 :            : 
    2247                 :            :   /* Now we've checked the constraints, so do the transformation:
    2248                 :            :      1) Remove the single store.  */
    2249                 :       2254 :   gsi = gsi_for_stmt (assign);
    2250                 :       2254 :   unlink_stmt_vdef (assign);
    2251                 :       2254 :   gsi_remove (&gsi, true);
    2252                 :       2254 :   release_defs (assign);
    2253                 :            : 
    2254                 :            :   /* Make both store and load use alias-set zero as we have to
    2255                 :            :      deal with the case of the store being a conditional change
    2256                 :            :      of the dynamic type.  */
    2257                 :       2254 :   lhs = unshare_expr (lhs);
    2258                 :       2254 :   tree *basep = &lhs;
    2259                 :       4541 :   while (handled_component_p (*basep))
    2260                 :       2287 :     basep = &TREE_OPERAND (*basep, 0);
    2261                 :       2254 :   if (TREE_CODE (*basep) == MEM_REF
    2262                 :       2254 :       || TREE_CODE (*basep) == TARGET_MEM_REF)
    2263                 :         66 :     TREE_OPERAND (*basep, 1)
    2264                 :         33 :       = fold_convert (ptr_type_node, TREE_OPERAND (*basep, 1));
    2265                 :            :   else
    2266                 :       2221 :     *basep = build2 (MEM_REF, TREE_TYPE (*basep),
    2267                 :            :                      build_fold_addr_expr (*basep),
    2268                 :            :                      build_zero_cst (ptr_type_node));
    2269                 :            : 
    2270                 :            :   /* 2) Insert a load from the memory of the store to the temporary
    2271                 :            :         on the edge which did not contain the store.  */
    2272                 :       2254 :   name = make_temp_ssa_name (TREE_TYPE (lhs), NULL, "cstore");
    2273                 :       2254 :   new_stmt = gimple_build_assign (name, lhs);
    2274                 :       2254 :   gimple_set_location (new_stmt, locus);
    2275                 :       2254 :   lhs = unshare_expr (lhs);
    2276                 :            :   /* Set TREE_NO_WARNING on the rhs of the load to avoid uninit
    2277                 :            :      warnings.  */
    2278                 :       2254 :   TREE_NO_WARNING (gimple_assign_rhs1 (new_stmt)) = 1;
    2279                 :       2254 :   gsi_insert_on_edge (e1, new_stmt);
    2280                 :            : 
    2281                 :            :   /* 3) Create a PHI node at the join block, with one argument
    2282                 :            :         holding the old RHS, and the other holding the temporary
    2283                 :            :         where we stored the old memory contents.  */
    2284                 :       2254 :   name2 = make_temp_ssa_name (TREE_TYPE (lhs), NULL, "cstore");
    2285                 :       2254 :   newphi = create_phi_node (name2, join_bb);
    2286                 :       2254 :   add_phi_arg (newphi, rhs, e0, locus);
    2287                 :       2254 :   add_phi_arg (newphi, name, e1, locus);
    2288                 :            : 
    2289                 :       2254 :   new_stmt = gimple_build_assign (lhs, PHI_RESULT (newphi));
    2290                 :            : 
    2291                 :            :   /* 4) Insert that PHI node.  */
    2292                 :       2254 :   gsi = gsi_after_labels (join_bb);
    2293                 :       2254 :   if (gsi_end_p (gsi))
    2294                 :            :     {
    2295                 :        505 :       gsi = gsi_last_bb (join_bb);
    2296                 :        505 :       gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
    2297                 :            :     }
    2298                 :            :   else
    2299                 :       1749 :     gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
    2300                 :            : 
    2301                 :       2254 :   if (dump_file && (dump_flags & TDF_DETAILS))
    2302                 :            :     {
    2303                 :          4 :       fprintf (dump_file, "\nConditional store replacement happened!");
    2304                 :          4 :       fprintf (dump_file, "\nReplaced the store with a load.");
    2305                 :          4 :       fprintf (dump_file, "\nInserted a new PHI statement in joint block:\n");
    2306                 :          4 :       print_gimple_stmt (dump_file, new_stmt, 0, TDF_VOPS|TDF_MEMSYMS);
    2307                 :            :     }
    2308                 :            : 
    2309                 :            :   return true;
    2310                 :            : }
    2311                 :            : 
    2312                 :            : /* Do the main work of conditional store replacement.  */
    2313                 :            : 
    2314                 :            : static bool
    2315                 :     139156 : cond_if_else_store_replacement_1 (basic_block then_bb, basic_block else_bb,
    2316                 :            :                                   basic_block join_bb, gimple *then_assign,
    2317                 :            :                                   gimple *else_assign)
    2318                 :            : {
    2319                 :     139156 :   tree lhs_base, lhs, then_rhs, else_rhs, name;
    2320                 :     139156 :   location_t then_locus, else_locus;
    2321                 :     139156 :   gimple_stmt_iterator gsi;
    2322                 :     139156 :   gphi *newphi;
    2323                 :     139156 :   gassign *new_stmt;
    2324                 :            : 
    2325                 :     139156 :   if (then_assign == NULL
    2326                 :     269502 :       || !gimple_assign_single_p (then_assign)
    2327                 :     130346 :       || gimple_clobber_p (then_assign)
    2328                 :     129265 :       || gimple_has_volatile_ops (then_assign)
    2329                 :     129253 :       || else_assign == NULL
    2330                 :     150695 :       || !gimple_assign_single_p (else_assign)
    2331                 :      11539 :       || gimple_clobber_p (else_assign)
    2332                 :     150695 :       || gimple_has_volatile_ops (else_assign))
    2333                 :            :     return false;
    2334                 :            : 
    2335                 :      11539 :   lhs = gimple_assign_lhs (then_assign);
    2336                 :      11539 :   if (!is_gimple_reg_type (TREE_TYPE (lhs))
    2337                 :      11539 :       || !operand_equal_p (lhs, gimple_assign_lhs (else_assign), 0))
    2338                 :       5100 :     return false;
    2339                 :            : 
    2340                 :       6439 :   lhs_base = get_base_address (lhs);
    2341                 :       6439 :   if (lhs_base == NULL_TREE
    2342                 :       6439 :       || (!DECL_P (lhs_base) && TREE_CODE (lhs_base) != MEM_REF))
    2343                 :            :     return false;
    2344                 :            : 
    2345                 :       6439 :   then_rhs = gimple_assign_rhs1 (then_assign);
    2346                 :       6439 :   else_rhs = gimple_assign_rhs1 (else_assign);
    2347                 :       6439 :   then_locus = gimple_location (then_assign);
    2348                 :       6439 :   else_locus = gimple_location (else_assign);
    2349                 :            : 
    2350                 :            :   /* Now we've checked the constraints, so do the transformation:
    2351                 :            :      1) Remove the stores.  */
    2352                 :       6439 :   gsi = gsi_for_stmt (then_assign);
    2353                 :       6439 :   unlink_stmt_vdef (then_assign);
    2354                 :       6439 :   gsi_remove (&gsi, true);
    2355                 :       6439 :   release_defs (then_assign);
    2356                 :            : 
    2357                 :       6439 :   gsi = gsi_for_stmt (else_assign);
    2358                 :       6439 :   unlink_stmt_vdef (else_assign);
    2359                 :       6439 :   gsi_remove (&gsi, true);
    2360                 :       6439 :   release_defs (else_assign);
    2361                 :            : 
    2362                 :            :   /* 2) Create a PHI node at the join block, with one argument
    2363                 :            :         holding the old RHS, and the other holding the temporary
    2364                 :            :         where we stored the old memory contents.  */
    2365                 :       6439 :   name = make_temp_ssa_name (TREE_TYPE (lhs), NULL, "cstore");
    2366                 :       6439 :   newphi = create_phi_node (name, join_bb);
    2367                 :       6439 :   add_phi_arg (newphi, then_rhs, EDGE_SUCC (then_bb, 0), then_locus);
    2368                 :       6439 :   add_phi_arg (newphi, else_rhs, EDGE_SUCC (else_bb, 0), else_locus);
    2369                 :            : 
    2370                 :       6439 :   new_stmt = gimple_build_assign (lhs, PHI_RESULT (newphi));
    2371                 :            : 
    2372                 :            :   /* 3) Insert that PHI node.  */
    2373                 :       6439 :   gsi = gsi_after_labels (join_bb);
    2374                 :       6439 :   if (gsi_end_p (gsi))
    2375                 :            :     {
    2376                 :        158 :       gsi = gsi_last_bb (join_bb);
    2377                 :        158 :       gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
    2378                 :            :     }
    2379                 :            :   else
    2380                 :       6281 :     gsi_insert_before (&gsi, new_stmt, GSI_NEW_STMT);
    2381                 :            : 
    2382                 :            :   return true;
    2383                 :            : }
    2384                 :            : 
    2385                 :            : /* Return the single store in BB with VDEF or NULL if there are
    2386                 :            :    other stores in the BB or loads following the store.  */
    2387                 :            : 
    2388                 :            : static gimple *
    2389                 :     312025 : single_trailing_store_in_bb (basic_block bb, tree vdef)
    2390                 :            : {
    2391                 :     312025 :   if (SSA_NAME_IS_DEFAULT_DEF (vdef))
    2392                 :            :     return NULL;
    2393                 :     311606 :   gimple *store = SSA_NAME_DEF_STMT (vdef);
    2394                 :     311606 :   if (gimple_bb (store) != bb
    2395                 :     311606 :       || gimple_code (store) == GIMPLE_PHI)
    2396                 :            :     return NULL;
    2397                 :            : 
    2398                 :            :   /* Verify there is no other store in this BB.  */
    2399                 :     615792 :   if (!SSA_NAME_IS_DEFAULT_DEF (gimple_vuse (store))
    2400                 :     300622 :       && gimple_bb (SSA_NAME_DEF_STMT (gimple_vuse (store))) == bb
    2401                 :     331589 :       && gimple_code (SSA_NAME_DEF_STMT (gimple_vuse (store))) != GIMPLE_PHI)
    2402                 :            :     return NULL;
    2403                 :            : 
    2404                 :            :   /* Verify there is no load or store after the store.  */
    2405                 :     284861 :   use_operand_p use_p;
    2406                 :     284861 :   imm_use_iterator imm_iter;
    2407                 :     854488 :   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_vdef (store))
    2408                 :     284956 :     if (USE_STMT (use_p) != store
    2409                 :     284956 :         && gimple_bb (USE_STMT (use_p)) == bb)
    2410                 :            :       return NULL;
    2411                 :            : 
    2412                 :            :   return store;
    2413                 :            : }
    2414                 :            : 
    2415                 :            : /* Conditional store replacement.  We already know
    2416                 :            :    that the recognized pattern looks like so:
    2417                 :            : 
    2418                 :            :    split:
    2419                 :            :      if (cond) goto THEN_BB; else goto ELSE_BB (edge E1)
    2420                 :            :    THEN_BB:
    2421                 :            :      ...
    2422                 :            :      X = Y;
    2423                 :            :      ...
    2424                 :            :      goto JOIN_BB;
    2425                 :            :    ELSE_BB:
    2426                 :            :      ...
    2427                 :            :      X = Z;
    2428                 :            :      ...
    2429                 :            :      fallthrough (edge E0)
    2430                 :            :    JOIN_BB:
    2431                 :            :      some more
    2432                 :            : 
    2433                 :            :    We check that it is safe to sink the store to JOIN_BB by verifying that
    2434                 :            :    there are no read-after-write or write-after-write dependencies in
    2435                 :            :    THEN_BB and ELSE_BB.  */
    2436                 :            : 
    2437                 :            : static bool
    2438                 :     178478 : cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb,
    2439                 :            :                                 basic_block join_bb)
    2440                 :            : {
    2441                 :     178478 :   vec<data_reference_p> then_datarefs, else_datarefs;
    2442                 :     178478 :   vec<ddr_p> then_ddrs, else_ddrs;
    2443                 :     178478 :   gimple *then_store, *else_store;
    2444                 :     178478 :   bool found, ok = false, res;
    2445                 :     178478 :   struct data_dependence_relation *ddr;
    2446                 :     178478 :   data_reference_p then_dr, else_dr;
    2447                 :     178478 :   int i, j;
    2448                 :     178478 :   tree then_lhs, else_lhs;
    2449                 :     178478 :   basic_block blocks[3];
    2450                 :            : 
    2451                 :            :   /* Handle the case with single store in THEN_BB and ELSE_BB.  That is
    2452                 :            :      cheap enough to always handle as it allows us to elide dependence
    2453                 :            :      checking.  */
    2454                 :     178478 :   gphi *vphi = NULL;
    2455                 :     214495 :   for (gphi_iterator si = gsi_start_phis (join_bb); !gsi_end_p (si);
    2456                 :      36017 :        gsi_next (&si))
    2457                 :     404870 :     if (virtual_operand_p (gimple_phi_result (si.phi ())))
    2458                 :            :       {
    2459                 :            :         vphi = si.phi ();
    2460                 :            :         break;
    2461                 :            :       }
    2462                 :     178478 :   if (!vphi)
    2463                 :            :     return false;
    2464                 :     166418 :   tree then_vdef = PHI_ARG_DEF_FROM_EDGE (vphi, single_succ_edge (then_bb));
    2465                 :     166418 :   tree else_vdef = PHI_ARG_DEF_FROM_EDGE (vphi, single_succ_edge (else_bb));
    2466                 :     166418 :   gimple *then_assign = single_trailing_store_in_bb (then_bb, then_vdef);
    2467                 :     166418 :   if (then_assign)
    2468                 :            :     {
    2469                 :     145607 :       gimple *else_assign = single_trailing_store_in_bb (else_bb, else_vdef);
    2470                 :     145607 :       if (else_assign)
    2471                 :     139064 :         return cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb,
    2472                 :     139064 :                                                  then_assign, else_assign);
    2473                 :            :     }
    2474                 :            : 
    2475                 :            :   /* If either vectorization or if-conversion is disabled then do
    2476                 :            :      not sink any stores.  */
    2477                 :      27354 :   if (param_max_stores_to_sink == 0
    2478                 :      27354 :       || (!flag_tree_loop_vectorize && !flag_tree_slp_vectorize)
    2479                 :        917 :       || !flag_tree_loop_if_convert)
    2480                 :            :     return false;
    2481                 :            : 
    2482                 :            :   /* Find data references.  */
    2483                 :        914 :   then_datarefs.create (1);
    2484                 :        914 :   else_datarefs.create (1);
    2485                 :        914 :   if ((find_data_references_in_bb (NULL, then_bb, &then_datarefs)
    2486                 :        914 :         == chrec_dont_know)
    2487                 :        252 :       || !then_datarefs.length ()
    2488                 :        210 :       || (find_data_references_in_bb (NULL, else_bb, &else_datarefs)
    2489                 :        210 :           == chrec_dont_know)
    2490                 :       1091 :       || !else_datarefs.length ())
    2491                 :            :     {
    2492                 :        772 :       free_data_refs (then_datarefs);
    2493                 :        772 :       free_data_refs (else_datarefs);
    2494                 :        772 :       return false;
    2495                 :            :     }
    2496                 :            : 
    2497                 :            :   /* Find pairs of stores with equal LHS.  */
    2498                 :        284 :   auto_vec<gimple *, 1> then_stores, else_stores;
    2499                 :        527 :   FOR_EACH_VEC_ELT (then_datarefs, i, then_dr)
    2500                 :            :     {
    2501                 :        385 :       if (DR_IS_READ (then_dr))
    2502                 :        105 :         continue;
    2503                 :            : 
    2504                 :        280 :       then_store = DR_STMT (then_dr);
    2505                 :        280 :       then_lhs = gimple_get_lhs (then_store);
    2506                 :        280 :       if (then_lhs == NULL_TREE)
    2507                 :          0 :         continue;
    2508                 :       1105 :       found = false;
    2509                 :            : 
    2510                 :       1105 :       FOR_EACH_VEC_ELT (else_datarefs, j, else_dr)
    2511                 :            :         {
    2512                 :        982 :           if (DR_IS_READ (else_dr))
    2513                 :        345 :             continue;
    2514                 :            : 
    2515                 :        637 :           else_store = DR_STMT (else_dr);
    2516                 :        637 :           else_lhs = gimple_get_lhs (else_store);
    2517                 :        637 :           if (else_lhs == NULL_TREE)
    2518                 :          0 :             continue;
    2519                 :            : 
    2520                 :        637 :           if (operand_equal_p (then_lhs, else_lhs, 0))
    2521                 :            :             {
    2522                 :            :               found = true;
    2523                 :            :               break;
    2524                 :            :             }
    2525                 :            :         }
    2526                 :            : 
    2527                 :        280 :       if (!found)
    2528                 :        123 :         continue;
    2529                 :            : 
    2530                 :        157 :       then_stores.safe_push (then_store);
    2531                 :        157 :       else_stores.safe_push (else_store);
    2532                 :            :     }
    2533                 :            : 
    2534                 :            :   /* No pairs of stores found.  */
    2535                 :        142 :   if (!then_stores.length ()
    2536                 :        142 :       || then_stores.length () > (unsigned) param_max_stores_to_sink)
    2537                 :            :     {
    2538                 :         66 :       free_data_refs (then_datarefs);
    2539                 :         66 :       free_data_refs (else_datarefs);
    2540                 :         66 :       return false;
    2541                 :            :     }
    2542                 :            : 
    2543                 :            :   /* Compute and check data dependencies in both basic blocks.  */
    2544                 :         76 :   then_ddrs.create (1);
    2545                 :         76 :   else_ddrs.create (1);
    2546                 :         76 :   if (!compute_all_dependences (then_datarefs, &then_ddrs,
    2547                 :            :                                 vNULL, false)
    2548                 :         76 :       || !compute_all_dependences (else_datarefs, &else_ddrs,
    2549                 :            :                                    vNULL, false))
    2550                 :            :     {
    2551                 :          0 :       free_dependence_relations (then_ddrs);
    2552                 :          0 :       free_dependence_relations (else_ddrs);
    2553                 :          0 :       free_data_refs (then_datarefs);
    2554                 :          0 :       free_data_refs (else_datarefs);
    2555                 :          0 :       return false;
    2556                 :            :     }
    2557                 :         76 :   blocks[0] = then_bb;
    2558                 :         76 :   blocks[1] = else_bb;
    2559                 :         76 :   blocks[2] = join_bb;
    2560                 :         76 :   renumber_gimple_stmt_uids_in_blocks (blocks, 3);
    2561                 :            : 
    2562                 :            :   /* Check that there are no read-after-write or write-after-write dependencies
    2563                 :            :      in THEN_BB.  */
    2564                 :        206 :   FOR_EACH_VEC_ELT (then_ddrs, i, ddr)
    2565                 :            :     {
    2566                 :        148 :       struct data_reference *dra = DDR_A (ddr);
    2567                 :        148 :       struct data_reference *drb = DDR_B (ddr);
    2568                 :            : 
    2569                 :        148 :       if (DDR_ARE_DEPENDENT (ddr) != chrec_known
    2570                 :        148 :           && ((DR_IS_READ (dra) && DR_IS_WRITE (drb)
    2571                 :          8 :                && gimple_uid (DR_STMT (dra)) > gimple_uid (DR_STMT (drb)))
    2572                 :         26 :               || (DR_IS_READ (drb) && DR_IS_WRITE (dra)
    2573                 :         14 :                   && gimple_uid (DR_STMT (drb)) > gimple_uid (DR_STMT (dra)))
    2574                 :         12 :               || (DR_IS_WRITE (dra) && DR_IS_WRITE (drb))))
    2575                 :            :         {
    2576                 :         18 :           free_dependence_relations (then_ddrs);
    2577                 :         18 :           free_dependence_relations (else_ddrs);
    2578                 :         18 :           free_data_refs (then_datarefs);
    2579                 :         18 :           free_data_refs (else_datarefs);
    2580                 :         18 :           return false;
    2581                 :            :         }
    2582                 :            :     }
    2583                 :            : 
    2584                 :            :   /* Check that there are no read-after-write or write-after-write dependencies
    2585                 :            :      in ELSE_BB.  */
    2586                 :        262 :   FOR_EACH_VEC_ELT (else_ddrs, i, ddr)
    2587                 :            :     {
    2588                 :        206 :       struct data_reference *dra = DDR_A (ddr);
    2589                 :        206 :       struct data_reference *drb = DDR_B (ddr);
    2590                 :            : 
    2591                 :        206 :       if (DDR_ARE_DEPENDENT (ddr) != chrec_known
    2592                 :        206 :           && ((DR_IS_READ (dra) && DR_IS_WRITE (drb)
    2593                 :          2 :                && gimple_uid (DR_STMT (dra)) > gimple_uid (DR_STMT (drb)))
    2594                 :          4 :               || (DR_IS_READ (drb) && DR_IS_WRITE (dra)
    2595                 :          0 :                   && gimple_uid (DR_STMT (drb)) > gimple_uid (DR_STMT (dra)))
    2596                 :          4 :               || (DR_IS_WRITE (dra) && DR_IS_WRITE (drb))))
    2597                 :            :         {
    2598                 :          2 :           free_dependence_relations (then_ddrs);
    2599                 :          2 :           free_dependence_relations (else_ddrs);
    2600                 :          2 :           free_data_refs (then_datarefs);
    2601                 :          2 :           free_data_refs (else_datarefs);
    2602                 :          2 :           return false;
    2603                 :            :         }
    2604                 :            :     }
    2605                 :            : 
    2606                 :            :   /* Sink stores with same LHS.  */
    2607                 :        204 :   FOR_EACH_VEC_ELT (then_stores, i, then_store)
    2608                 :            :     {
    2609                 :         92 :       else_store = else_stores[i];
    2610                 :         92 :       res = cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb,
    2611                 :            :                                               then_store, else_store);
    2612                 :         92 :       ok = ok || res;
    2613                 :            :     }
    2614                 :            : 
    2615                 :         56 :   free_dependence_relations (then_ddrs);
    2616                 :         56 :   free_dependence_relations (else_ddrs);
    2617                 :         56 :   free_data_refs (then_datarefs);
    2618                 :         56 :   free_data_refs (else_datarefs);
    2619                 :            : 
    2620                 :         56 :   return ok;
    2621                 :            : }
    2622                 :            : 
    2623                 :            : /* Return TRUE if STMT has a VUSE whose corresponding VDEF is in BB.  */
    2624                 :            : 
    2625                 :            : static bool
    2626                 :       4754 : local_mem_dependence (gimple *stmt, basic_block bb)
    2627                 :            : {
    2628                 :       4754 :   tree vuse = gimple_vuse (stmt);
    2629                 :       4754 :   gimple *def;
    2630                 :            : 
    2631                 :       4754 :   if (!vuse)
    2632                 :            :     return false;
    2633                 :            : 
    2634                 :       4754 :   def = SSA_NAME_DEF_STMT (vuse);
    2635                 :       4754 :   return (def && gimple_bb (def) == bb);
    2636                 :            : }
    2637                 :            : 
    2638                 :            : /* Given a "diamond" control-flow pattern where BB0 tests a condition,
    2639                 :            :    BB1 and BB2 are "then" and "else" blocks dependent on this test,
    2640                 :            :    and BB3 rejoins control flow following BB1 and BB2, look for
    2641                 :            :    opportunities to hoist loads as follows.  If BB3 contains a PHI of
    2642                 :            :    two loads, one each occurring in BB1 and BB2, and the loads are
    2643                 :            :    provably of adjacent fields in the same structure, then move both
    2644                 :            :    loads into BB0.  Of course this can only be done if there are no
    2645                 :            :    dependencies preventing such motion.
    2646                 :            : 
    2647                 :            :    One of the hoisted loads will always be speculative, so the
    2648                 :            :    transformation is currently conservative:
    2649                 :            : 
    2650                 :            :     - The fields must be strictly adjacent.
    2651                 :            :     - The two fields must occupy a single memory block that is
    2652                 :            :       guaranteed to not cross a page boundary.
    2653                 :            : 
    2654                 :            :     The last is difficult to prove, as such memory blocks should be
    2655                 :            :     aligned on the minimum of the stack alignment boundary and the
    2656                 :            :     alignment guaranteed by heap allocation interfaces.  Thus we rely
    2657                 :            :     on a parameter for the alignment value.
    2658                 :            : 
    2659                 :            :     Provided a good value is used for the last case, the first
    2660                 :            :     restriction could possibly be relaxed.  */
    2661                 :            : 
    2662                 :            : static void
    2663                 :     459378 : hoist_adjacent_loads (basic_block bb0, basic_block bb1,
    2664                 :            :                       basic_block bb2, basic_block bb3)
    2665                 :            : {
    2666                 :     459378 :   int param_align = param_l1_cache_line_size;
    2667                 :     459378 :   unsigned param_align_bits = (unsigned) (param_align * BITS_PER_UNIT);
    2668                 :     459378 :   gphi_iterator gsi;
    2669                 :            : 
    2670                 :            :   /* Walk the phis in bb3 looking for an opportunity.  We are looking
    2671                 :            :      for phis of two SSA names, one each of which is defined in bb1 and
    2672                 :            :      bb2.  */
    2673                 :     993003 :   for (gsi = gsi_start_phis (bb3); !gsi_end_p (gsi); gsi_next (&gsi))
    2674                 :            :     {
    2675                 :     533625 :       gphi *phi_stmt = gsi.phi ();
    2676                 :     533625 :       gimple *def1, *def2;
    2677                 :     533625 :       tree arg1, arg2, ref1, ref2, field1, field2;
    2678                 :     533625 :       tree tree_offset1, tree_offset2, tree_size2, next;
    2679                 :     533625 :       int offset1, offset2, size2;
    2680                 :     533625 :       unsigned align1;
    2681                 :     533625 :       gimple_stmt_iterator gsi2;
    2682                 :     533625 :       basic_block bb_for_def1, bb_for_def2;
    2683                 :            : 
    2684                 :     533625 :       if (gimple_phi_num_args (phi_stmt) != 2
    2685                 :    1067250 :           || virtual_operand_p (gimple_phi_result (phi_stmt)))
    2686                 :     531248 :         continue;
    2687                 :            : 
    2688                 :     100821 :       arg1 = gimple_phi_arg_def (phi_stmt, 0);
    2689                 :     100821 :       arg2 = gimple_phi_arg_def (phi_stmt, 1);
    2690                 :            : 
    2691                 :     118135 :       if (TREE_CODE (arg1) != SSA_NAME
    2692                 :      86954 :           || TREE_CODE (arg2) != SSA_NAME
    2693                 :      83871 :           || SSA_NAME_IS_DEFAULT_DEF (arg1)
    2694                 :     184404 :           || SSA_NAME_IS_DEFAULT_DEF (arg2))
    2695                 :      17314 :         continue;
    2696                 :            : 
    2697                 :      83507 :       def1 = SSA_NAME_DEF_STMT (arg1);
    2698                 :      83507 :       def2 = SSA_NAME_DEF_STMT (arg2);
    2699                 :            : 
    2700                 :      83507 :       if ((gimple_bb (def1) != bb1 || gimple_bb (def2) != bb2)
    2701                 :      90328 :           && (gimple_bb (def2) != bb1 || gimple_bb (def1) != bb2))
    2702                 :      19676 :         continue;
    2703                 :            : 
    2704                 :            :       /* Check the mode of the arguments to be sure a conditional move
    2705                 :            :          can be generated for it.  */
    2706                 :     127662 :       if (optab_handler (movcc_optab, TYPE_MODE (TREE_TYPE (arg1)))
    2707                 :            :           == CODE_FOR_nothing)
    2708                 :       1536 :         continue;
    2709                 :            : 
    2710                 :            :       /* Both statements must be assignments whose RHS is a COMPONENT_REF.  */
    2711                 :      62295 :       if (!gimple_assign_single_p (def1)
    2712                 :      14165 :           || !gimple_assign_single_p (def2)
    2713                 :      13096 :           || gimple_has_volatile_ops (def1)
    2714                 :      13093 :           || gimple_has_volatile_ops (def2))
    2715                 :      49202 :         continue;
    2716                 :            : 
    2717                 :      13093 :       ref1 = gimple_assign_rhs1 (def1);
    2718                 :      13093 :       ref2 = gimple_assign_rhs1 (def2);
    2719                 :            : 
    2720                 :      13093 :       if (TREE_CODE (ref1) != COMPONENT_REF
    2721                 :      10169 :           || TREE_CODE (ref2) != COMPONENT_REF)
    2722                 :       3052 :         continue;
    2723                 :            : 
    2724                 :            :       /* The zeroth operand of the two component references must be
    2725                 :            :          identical.  It is not sufficient to compare get_base_address of
    2726                 :            :          the two references, because this could allow for different
    2727                 :            :          elements of the same array in the two trees.  It is not safe to
    2728                 :            :          assume that the existence of one array element implies the
    2729                 :            :          existence of a different one.  */
    2730                 :      10041 :       if (!operand_equal_p (TREE_OPERAND (ref1, 0), TREE_OPERAND (ref2, 0), 0))
    2731                 :       5269 :         continue;
    2732                 :            : 
    2733                 :       4772 :       field1 = TREE_OPERAND (ref1, 1);
    2734                 :       4772 :       field2 = TREE_OPERAND (ref2, 1);
    2735                 :            : 
    2736                 :            :       /* Check for field adjacency, and ensure field1 comes first.  */
    2737                 :      16597 :       for (next = DECL_CHAIN (field1);
    2738                 :      16597 :            next && TREE_CODE (next) != FIELD_DECL;
    2739                 :      11825 :            next = DECL_CHAIN (next))
    2740                 :            :         ;
    2741                 :            : 
    2742                 :       4772 :       if (next != field2)
    2743                 :            :         {
    2744                 :       4184 :           for (next = DECL_CHAIN (field2);
    2745                 :       4184 :                next && TREE_CODE (next) != FIELD_DECL;
    2746                 :        100 :                next = DECL_CHAIN (next))
    2747                 :            :             ;
    2748                 :            : 
    2749                 :       4084 :           if (next != field1)
    2750                 :       2395 :             continue;
    2751                 :            : 
    2752                 :       2377 :           std::swap (field1, field2);
    2753                 :       2377 :           std::swap (def1, def2);
    2754                 :            :         }
    2755                 :            : 
    2756                 :       2377 :       bb_for_def1 = gimple_bb (def1);
    2757                 :       2377 :       bb_for_def2 = gimple_bb (def2);
    2758                 :            : 
    2759                 :            :       /* Check for proper alignment of the first field.  */
    2760                 :       2377 :       tree_offset1 = bit_position (field1);
    2761                 :       2377 :       tree_offset2 = bit_position (field2);
    2762                 :       2377 :       tree_size2 = DECL_SIZE (field2);
    2763                 :            : 
    2764                 :       2377 :       if (!tree_fits_uhwi_p (tree_offset1)
    2765                 :       2377 :           || !tree_fits_uhwi_p (tree_offset2)
    2766                 :       2377 :           || !tree_fits_uhwi_p (tree_size2))
    2767                 :          0 :         continue;
    2768                 :            : 
    2769                 :       2377 :       offset1 = tree_to_uhwi (tree_offset1);
    2770                 :       2377 :       offset2 = tree_to_uhwi (tree_offset2);
    2771                 :       2377 :       size2 = tree_to_uhwi (tree_size2);
    2772                 :       2377 :       align1 = DECL_ALIGN (field1) % param_align_bits;
    2773                 :            : 
    2774                 :       2377 :       if (offset1 % BITS_PER_UNIT != 0)
    2775                 :          0 :         continue;
    2776                 :            : 
    2777                 :            :       /* For profitability, the two field references should fit within
    2778                 :            :          a single cache line.  */
    2779                 :       2377 :       if (align1 + offset2 - offset1 + size2 > param_align_bits)
    2780                 :          0 :         continue;
    2781                 :            : 
    2782                 :            :       /* The two expressions cannot be dependent upon vdefs defined
    2783                 :            :          in bb1/bb2.  */
    2784                 :       2377 :       if (local_mem_dependence (def1, bb_for_def1)
    2785                 :       2377 :           || local_mem_dependence (def2, bb_for_def2))
    2786                 :          0 :         continue;
    2787                 :            : 
    2788                 :            :       /* The conditions are satisfied; hoist the loads from bb1 and bb2 into
    2789                 :            :          bb0.  We hoist the first one first so that a cache miss is handled
    2790                 :            :          efficiently regardless of hardware cache-fill policy.  */
    2791                 :       2377 :       gsi2 = gsi_for_stmt (def1);
    2792                 :       2377 :       gsi_move_to_bb_end (&gsi2, bb0);
    2793                 :       2377 :       gsi2 = gsi_for_stmt (def2);
    2794                 :       2377 :       gsi_move_to_bb_end (&gsi2, bb0);
    2795                 :            : 
    2796                 :       2377 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2797                 :            :         {
    2798                 :          0 :           fprintf (dump_file,
    2799                 :            :                    "\nHoisting adjacent loads from %d and %d into %d: \n",
    2800                 :            :                    bb_for_def1->index, bb_for_def2->index, bb0->index);
    2801                 :          0 :           print_gimple_stmt (dump_file, def1, 0, TDF_VOPS|TDF_MEMSYMS);
    2802                 :          0 :           print_gimple_stmt (dump_file, def2, 0, TDF_VOPS|TDF_MEMSYMS);
    2803                 :            :         }
    2804                 :            :     }
    2805                 :     459378 : }
    2806                 :            : 
    2807                 :            : /* Determine whether we should attempt to hoist adjacent loads out of
    2808                 :            :    diamond patterns in pass_phiopt.  Always hoist loads if
    2809                 :            :    -fhoist-adjacent-loads is specified and the target machine has
    2810                 :            :    both a conditional move instruction and a defined cache line size.  */
    2811                 :            : 
    2812                 :            : static bool
    2813                 :    2056790 : gate_hoist_loads (void)
    2814                 :            : {
    2815                 :    2056790 :   return (flag_hoist_adjacent_loads == 1
    2816                 :    2056790 :           && param_l1_cache_line_size
    2817                 :          0 :           && HAVE_conditional_move);
    2818                 :            : }
    2819                 :            : 
    2820                 :            : /* This pass tries to replaces an if-then-else block with an
    2821                 :            :    assignment.  We have four kinds of transformations.  Some of these
    2822                 :            :    transformations are also performed by the ifcvt RTL optimizer.
    2823                 :            : 
    2824                 :            :    Conditional Replacement
    2825                 :            :    -----------------------
    2826                 :            : 
    2827                 :            :    This transformation, implemented in conditional_replacement,
    2828                 :            :    replaces
    2829                 :            : 
    2830                 :            :      bb0:
    2831                 :            :       if (cond) goto bb2; else goto bb1;
    2832                 :            :      bb1:
    2833                 :            :      bb2:
    2834                 :            :       x = PHI <0 (bb1), 1 (bb0), ...>;
    2835                 :            : 
    2836                 :            :    with
    2837                 :            : 
    2838                 :            :      bb0:
    2839                 :            :       x' = cond;
    2840                 :            :       goto bb2;
    2841                 :            :      bb2:
    2842                 :            :       x = PHI <x' (bb0), ...>;
    2843                 :            : 
    2844                 :            :    We remove bb1 as it becomes unreachable.  This occurs often due to
    2845                 :            :    gimplification of conditionals.
    2846                 :            : 
    2847                 :            :    Value Replacement
    2848                 :            :    -----------------
    2849                 :            : 
    2850                 :            :    This transformation, implemented in value_replacement, replaces
    2851                 :            : 
    2852                 :            :      bb0:
    2853                 :            :        if (a != b) goto bb2; else goto bb1;
    2854                 :            :      bb1:
    2855                 :            :      bb2:
    2856                 :            :        x = PHI <a (bb1), b (bb0), ...>;
    2857                 :            : 
    2858                 :            :    with
    2859                 :            : 
    2860                 :            :      bb0:
    2861                 :            :      bb2:
    2862                 :            :        x = PHI <b (bb0), ...>;
    2863                 :            : 
    2864                 :            :    This opportunity can sometimes occur as a result of other
    2865                 :            :    optimizations.
    2866                 :            : 
    2867                 :            : 
    2868                 :            :    Another case caught by value replacement looks like this:
    2869                 :            : 
    2870                 :            :      bb0:
    2871                 :            :        t1 = a == CONST;
    2872                 :            :        t2 = b > c;
    2873                 :            :        t3 = t1 & t2;
    2874                 :            :        if (t3 != 0) goto bb1; else goto bb2;
    2875                 :            :      bb1:
    2876                 :            :      bb2:
    2877                 :            :        x = PHI (CONST, a)
    2878                 :            : 
    2879                 :            :    Gets replaced with:
    2880                 :            :      bb0:
    2881                 :            :      bb2:
    2882                 :            :        t1 = a == CONST;
    2883                 :            :        t2 = b > c;
    2884                 :            :        t3 = t1 & t2;
    2885                 :            :        x = a;
    2886                 :            : 
    2887                 :            :    ABS Replacement
    2888                 :            :    ---------------
    2889                 :            : 
    2890                 :            :    This transformation, implemented in abs_replacement, replaces
    2891                 :            : 
    2892                 :            :      bb0:
    2893                 :            :        if (a >= 0) goto bb2; else goto bb1;
    2894                 :            :      bb1:
    2895                 :            :        x = -a;
    2896                 :            :      bb2:
    2897                 :            :        x = PHI <x (bb1), a (bb0), ...>;
    2898                 :            : 
    2899                 :            :    with
    2900                 :            : 
    2901                 :            :      bb0:
    2902                 :            :        x' = ABS_EXPR< a >;
    2903                 :            :      bb2:
    2904                 :            :        x = PHI <x' (bb0), ...>;
    2905                 :            : 
    2906                 :            :    MIN/MAX Replacement
    2907                 :            :    -------------------
    2908                 :            : 
    2909                 :            :    This transformation, minmax_replacement replaces
    2910                 :            : 
    2911                 :            :      bb0:
    2912                 :            :        if (a <= b) goto bb2; else goto bb1;
    2913                 :            :      bb1:
    2914                 :            :      bb2:
    2915                 :            :        x = PHI <b (bb1), a (bb0), ...>;
    2916                 :            : 
    2917                 :            :    with
    2918                 :            : 
    2919                 :            :      bb0:
    2920                 :            :        x' = MIN_EXPR (a, b)
    2921                 :            :      bb2:
    2922                 :            :        x = PHI <x' (bb0), ...>;
    2923                 :            : 
    2924                 :            :    A similar transformation is done for MAX_EXPR.
    2925                 :            : 
    2926                 :            : 
    2927                 :            :    This pass also performs a fifth transformation of a slightly different
    2928                 :            :    flavor.
    2929                 :            : 
    2930                 :            :    Factor conversion in COND_EXPR
    2931                 :            :    ------------------------------
    2932                 :            : 
    2933                 :            :    This transformation factors the conversion out of COND_EXPR with
    2934                 :            :    factor_out_conditional_conversion.
    2935                 :            : 
    2936                 :            :    For example:
    2937                 :            :    if (a <= CST) goto <bb 3>; else goto <bb 4>;
    2938                 :            :    <bb 3>:
    2939                 :            :    tmp = (int) a;
    2940                 :            :    <bb 4>:
    2941                 :            :    tmp = PHI <tmp, CST>
    2942                 :            : 
    2943                 :            :    Into:
    2944                 :            :    if (a <= CST) goto <bb 3>; else goto <bb 4>;
    2945                 :            :    <bb 3>:
    2946                 :            :    <bb 4>:
    2947                 :            :    a = PHI <a, CST>
    2948                 :            :    tmp = (int) a;
    2949                 :            : 
    2950                 :            :    Adjacent Load Hoisting
    2951                 :            :    ----------------------
    2952                 :            : 
    2953                 :            :    This transformation replaces
    2954                 :            : 
    2955                 :            :      bb0:
    2956                 :            :        if (...) goto bb2; else goto bb1;
    2957                 :            :      bb1:
    2958                 :            :        x1 = (<expr>).field1;
    2959                 :            :        goto bb3;
    2960                 :            :      bb2:
    2961                 :            :        x2 = (<expr>).field2;
    2962                 :            :      bb3:
    2963                 :            :        # x = PHI <x1, x2>;
    2964                 :            : 
    2965                 :            :    with
    2966                 :            : 
    2967                 :            :      bb0:
    2968                 :            :        x1 = (<expr>).field1;
    2969                 :            :        x2 = (<expr>).field2;
    2970                 :            :        if (...) goto bb2; else goto bb1;
    2971                 :            :      bb1:
    2972                 :            :        goto bb3;
    2973                 :            :      bb2:
    2974                 :            :      bb3:
    2975                 :            :        # x = PHI <x1, x2>;
    2976                 :            : 
    2977                 :            :    The purpose of this transformation is to enable generation of conditional
    2978                 :            :    move instructions such as Intel CMOVE or PowerPC ISEL.  Because one of
    2979                 :            :    the loads is speculative, the transformation is restricted to very
    2980                 :            :    specific cases to avoid introducing a page fault.  We are looking for
    2981                 :            :    the common idiom:
    2982                 :            : 
    2983                 :            :      if (...)
    2984                 :            :        x = y->left;
    2985                 :            :      else
    2986                 :            :        x = y->right;
    2987                 :            : 
    2988                 :            :    where left and right are typically adjacent pointers in a tree structure.  */
    2989                 :            : 
    2990                 :            : namespace {
    2991                 :            : 
    2992                 :            : const pass_data pass_data_phiopt =
    2993                 :            : {
    2994                 :            :   GIMPLE_PASS, /* type */
    2995                 :            :   "phiopt", /* name */
    2996                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    2997                 :            :   TV_TREE_PHIOPT, /* tv_id */
    2998                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
    2999                 :            :   0, /* properties_provided */
    3000                 :            :   0, /* properties_destroyed */
    3001                 :            :   0, /* todo_flags_start */
    3002                 :            :   0, /* todo_flags_finish */
    3003                 :            : };
    3004                 :            : 
    3005                 :            : class pass_phiopt : public gimple_opt_pass
    3006                 :            : {
    3007                 :            : public:
    3008                 :     802160 :   pass_phiopt (gcc::context *ctxt)
    3009                 :    1604320 :     : gimple_opt_pass (pass_data_phiopt, ctxt), early_p (false)
    3010                 :            :   {}
    3011                 :            : 
    3012                 :            :   /* opt_pass methods: */
    3013                 :     601620 :   opt_pass * clone () { return new pass_phiopt (m_ctxt); }
    3014                 :     802160 :   void set_pass_param (unsigned n, bool param)
    3015                 :            :     {
    3016                 :     802160 :       gcc_assert (n == 0);
    3017                 :     802160 :       early_p = param;
    3018                 :     802160 :     }
    3019                 :    3641120 :   virtual bool gate (function *) { return flag_ssa_phiopt; }
    3020                 :    3638770 :   virtual unsigned int execute (function *)
    3021                 :            :     {
    3022                 :    3638770 :       return tree_ssa_phiopt_worker (false,
    3023                 :    3638770 :                                      !early_p ? gate_hoist_loads () : false,
    3024                 :    3638770 :                                      early_p);
    3025                 :            :     }
    3026                 :            : 
    3027                 :            : private:
    3028                 :            :   bool early_p;
    3029                 :            : }; // class pass_phiopt
    3030                 :            : 
    3031                 :            : } // anon namespace
    3032                 :            : 
    3033                 :            : gimple_opt_pass *
    3034                 :     200540 : make_pass_phiopt (gcc::context *ctxt)
    3035                 :            : {
    3036                 :     200540 :   return new pass_phiopt (ctxt);
    3037                 :            : }
    3038                 :            : 
    3039                 :            : namespace {
    3040                 :            : 
    3041                 :            : const pass_data pass_data_cselim =
    3042                 :            : {
    3043                 :            :   GIMPLE_PASS, /* type */
    3044                 :            :   "cselim", /* name */
    3045                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    3046                 :            :   TV_TREE_PHIOPT, /* tv_id */
    3047                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
    3048                 :            :   0, /* properties_provided */
    3049                 :            :   0, /* properties_destroyed */
    3050                 :            :   0, /* todo_flags_start */
    3051                 :            :   0, /* todo_flags_finish */
    3052                 :            : };
    3053                 :            : 
    3054                 :            : class pass_cselim : public gimple_opt_pass
    3055                 :            : {
    3056                 :            : public:
    3057                 :     200540 :   pass_cselim (gcc::context *ctxt)
    3058                 :     401080 :     : gimple_opt_pass (pass_data_cselim, ctxt)
    3059                 :            :   {}
    3060                 :            : 
    3061                 :            :   /* opt_pass methods: */
    3062                 :     685664 :   virtual bool gate (function *) { return flag_tree_cselim; }
    3063                 :     685611 :   virtual unsigned int execute (function *) { return tree_ssa_cs_elim (); }
    3064                 :            : 
    3065                 :            : }; // class pass_cselim
    3066                 :            : 
    3067                 :            : } // anon namespace
    3068                 :            : 
    3069                 :            : gimple_opt_pass *
    3070                 :     200540 : make_pass_cselim (gcc::context *ctxt)
    3071                 :            : {
    3072                 :     200540 :   return new pass_cselim (ctxt);
    3073                 :            : }

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.