LCOV - code coverage report
Current view: top level - gcc - tree-ssa-loop-niter.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2071 2140 96.8 %
Date: 2020-04-04 11:58:09 Functions: 76 78 97.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Functions to determine/estimate number of iterations of a loop.
       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 "rtl.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "gimple.h"
      27                 :            : #include "tree-pass.h"
      28                 :            : #include "ssa.h"
      29                 :            : #include "gimple-pretty-print.h"
      30                 :            : #include "diagnostic-core.h"
      31                 :            : #include "stor-layout.h"
      32                 :            : #include "fold-const.h"
      33                 :            : #include "calls.h"
      34                 :            : #include "intl.h"
      35                 :            : #include "gimplify.h"
      36                 :            : #include "gimple-iterator.h"
      37                 :            : #include "tree-cfg.h"
      38                 :            : #include "tree-ssa-loop-ivopts.h"
      39                 :            : #include "tree-ssa-loop-niter.h"
      40                 :            : #include "tree-ssa-loop.h"
      41                 :            : #include "cfgloop.h"
      42                 :            : #include "tree-chrec.h"
      43                 :            : #include "tree-scalar-evolution.h"
      44                 :            : #include "tree-dfa.h"
      45                 :            : 
      46                 :            : 
      47                 :            : /* The maximum number of dominator BBs we search for conditions
      48                 :            :    of loop header copies we use for simplifying a conditional
      49                 :            :    expression.  */
      50                 :            : #define MAX_DOMINATORS_TO_WALK 8
      51                 :            : 
      52                 :            : /*
      53                 :            : 
      54                 :            :    Analysis of number of iterations of an affine exit test.
      55                 :            : 
      56                 :            : */
      57                 :            : 
      58                 :            : /* Bounds on some value, BELOW <= X <= UP.  */
      59                 :            : 
      60                 :            : struct bounds
      61                 :            : {
      62                 :            :   mpz_t below, up;
      63                 :            : };
      64                 :            : 
      65                 :            : static bool number_of_iterations_popcount (loop_p loop, edge exit,
      66                 :            :                                            enum tree_code code,
      67                 :            :                                            class tree_niter_desc *niter);
      68                 :            : 
      69                 :            : 
      70                 :            : /* Splits expression EXPR to a variable part VAR and constant OFFSET.  */
      71                 :            : 
      72                 :            : static void
      73                 :   30602300 : split_to_var_and_offset (tree expr, tree *var, mpz_t offset)
      74                 :            : {
      75                 :   30602300 :   tree type = TREE_TYPE (expr);
      76                 :   30602300 :   tree op0, op1;
      77                 :   30602300 :   bool negate = false;
      78                 :            : 
      79                 :   30602300 :   *var = expr;
      80                 :   30602300 :   mpz_set_ui (offset, 0);
      81                 :            : 
      82                 :   30602300 :   switch (TREE_CODE (expr))
      83                 :            :     {
      84                 :       6235 :     case MINUS_EXPR:
      85                 :       6235 :       negate = true;
      86                 :            :       /* Fallthru.  */
      87                 :            : 
      88                 :    3341710 :     case PLUS_EXPR:
      89                 :    3341710 :     case POINTER_PLUS_EXPR:
      90                 :    3341710 :       op0 = TREE_OPERAND (expr, 0);
      91                 :    3341710 :       op1 = TREE_OPERAND (expr, 1);
      92                 :            : 
      93                 :    3341710 :       if (TREE_CODE (op1) != INTEGER_CST)
      94                 :            :         break;
      95                 :            : 
      96                 :    3333710 :       *var = op0;
      97                 :            :       /* Always sign extend the offset.  */
      98                 :    3333710 :       wi::to_mpz (wi::to_wide (op1), offset, SIGNED);
      99                 :    3333710 :       if (negate)
     100                 :        186 :         mpz_neg (offset, offset);
     101                 :            :       break;
     102                 :            : 
     103                 :   11779300 :     case INTEGER_CST:
     104                 :   11779300 :       *var = build_int_cst_type (type, 0);
     105                 :   11779300 :       wi::to_mpz (wi::to_wide (expr), offset, TYPE_SIGN (type));
     106                 :   11779300 :       break;
     107                 :            : 
     108                 :            :     default:
     109                 :            :       break;
     110                 :            :     }
     111                 :   30602300 : }
     112                 :            : 
     113                 :            : /* From condition C0 CMP C1 derives information regarding the value range
     114                 :            :    of VAR, which is of TYPE.  Results are stored in to BELOW and UP.  */
     115                 :            : 
     116                 :            : static void
     117                 :   10110700 : refine_value_range_using_guard (tree type, tree var,
     118                 :            :                                 tree c0, enum tree_code cmp, tree c1,
     119                 :            :                                 mpz_t below, mpz_t up)
     120                 :            : {
     121                 :   10110700 :   tree varc0, varc1, ctype;
     122                 :   10110700 :   mpz_t offc0, offc1;
     123                 :   10110700 :   mpz_t mint, maxt, minc1, maxc1;
     124                 :   10110700 :   wide_int minv, maxv;
     125                 :   10110700 :   bool no_wrap = nowrap_type_p (type);
     126                 :   10110700 :   bool c0_ok, c1_ok;
     127                 :   10110700 :   signop sgn = TYPE_SIGN (type);
     128                 :            : 
     129                 :   10110700 :   switch (cmp)
     130                 :            :     {
     131                 :    5376640 :     case LT_EXPR:
     132                 :    5376640 :     case LE_EXPR:
     133                 :    5376640 :     case GT_EXPR:
     134                 :    5376640 :     case GE_EXPR:
     135                 :    5376640 :       STRIP_SIGN_NOPS (c0);
     136                 :    5376640 :       STRIP_SIGN_NOPS (c1);
     137                 :    5376640 :       ctype = TREE_TYPE (c0);
     138                 :    5376640 :       if (!useless_type_conversion_p (ctype, type))
     139                 :    8769550 :         return;
     140                 :            : 
     141                 :            :       break;
     142                 :            : 
     143                 :            :     case EQ_EXPR:
     144                 :            :       /* We could derive quite precise information from EQ_EXPR, however,
     145                 :            :          such a guard is unlikely to appear, so we do not bother with
     146                 :            :          handling it.  */
     147                 :            :       return;
     148                 :            : 
     149                 :    1956750 :     case NE_EXPR:
     150                 :            :       /* NE_EXPR comparisons do not contain much of useful information,
     151                 :            :          except for cases of comparing with bounds.  */
     152                 :    1956750 :       if (TREE_CODE (c1) != INTEGER_CST
     153                 :    1799140 :           || !INTEGRAL_TYPE_P (type))
     154                 :            :         return;
     155                 :            : 
     156                 :            :       /* Ensure that the condition speaks about an expression in the same
     157                 :            :          type as X and Y.  */
     158                 :    1799140 :       ctype = TREE_TYPE (c0);
     159                 :    1799140 :       if (TYPE_PRECISION (ctype) != TYPE_PRECISION (type))
     160                 :            :         return;
     161                 :    1083200 :       c0 = fold_convert (type, c0);
     162                 :    1083200 :       c1 = fold_convert (type, c1);
     163                 :            : 
     164                 :    1083200 :       if (operand_equal_p (var, c0, 0))
     165                 :            :         {
     166                 :     116654 :           mpz_t valc1;
     167                 :            : 
     168                 :            :           /* Case of comparing VAR with its below/up bounds.  */
     169                 :     116654 :           mpz_init (valc1);
     170                 :     116654 :           wi::to_mpz (wi::to_wide (c1), valc1, TYPE_SIGN (type));
     171                 :     116654 :           if (mpz_cmp (valc1, below) == 0)
     172                 :      66003 :             cmp = GT_EXPR;
     173                 :     116654 :           if (mpz_cmp (valc1, up) == 0)
     174                 :       3835 :             cmp = LT_EXPR;
     175                 :            : 
     176                 :     116654 :           mpz_clear (valc1);
     177                 :            :         }
     178                 :            :       else
     179                 :            :         {
     180                 :            :           /* Case of comparing with the bounds of the type.  */
     181                 :     966544 :           wide_int min = wi::min_value (type);
     182                 :     966544 :           wide_int max = wi::max_value (type);
     183                 :            : 
     184                 :     966544 :           if (wi::to_wide (c1) == min)
     185                 :     106269 :             cmp = GT_EXPR;
     186                 :     966544 :           if (wi::to_wide (c1) == max)
     187                 :       3975 :             cmp = LT_EXPR;
     188                 :            :         }
     189                 :            : 
     190                 :            :       /* Quick return if no useful information.  */
     191                 :    1083200 :       if (cmp == NE_EXPR)
     192                 :            :         return;
     193                 :            : 
     194                 :            :       break;
     195                 :            : 
     196                 :            :     default:
     197                 :            :       return;
     198                 :            :     }
     199                 :            : 
     200                 :    4819090 :   mpz_init (offc0);
     201                 :    4819090 :   mpz_init (offc1);
     202                 :    4819090 :   split_to_var_and_offset (expand_simple_operations (c0), &varc0, offc0);
     203                 :    4819090 :   split_to_var_and_offset (expand_simple_operations (c1), &varc1, offc1);
     204                 :            : 
     205                 :            :   /* We are only interested in comparisons of expressions based on VAR.  */
     206                 :    4819090 :   if (operand_equal_p (var, varc1, 0))
     207                 :            :     {
     208                 :     374126 :       std::swap (varc0, varc1);
     209                 :     374126 :       mpz_swap (offc0, offc1);
     210                 :     374126 :       cmp = swap_tree_comparison (cmp);
     211                 :            :     }
     212                 :    4444960 :   else if (!operand_equal_p (var, varc0, 0))
     213                 :            :     {
     214                 :    3477920 :       mpz_clear (offc0);
     215                 :    3477920 :       mpz_clear (offc1);
     216                 :    3477920 :       return;
     217                 :            :     }
     218                 :            : 
     219                 :    1341170 :   mpz_init (mint);
     220                 :    1341170 :   mpz_init (maxt);
     221                 :    1341170 :   get_type_static_bounds (type, mint, maxt);
     222                 :    1341170 :   mpz_init (minc1);
     223                 :    1341170 :   mpz_init (maxc1);
     224                 :            :   /* Setup range information for varc1.  */
     225                 :    1341170 :   if (integer_zerop (varc1))
     226                 :            :     {
     227                 :     673960 :       wi::to_mpz (0, minc1, TYPE_SIGN (type));
     228                 :     673960 :       wi::to_mpz (0, maxc1, TYPE_SIGN (type));
     229                 :            :     }
     230                 :     667211 :   else if (TREE_CODE (varc1) == SSA_NAME
     231                 :     637763 :            && INTEGRAL_TYPE_P (type)
     232                 :    1304970 :            && get_range_info (varc1, &minv, &maxv) == VR_RANGE)
     233                 :            :     {
     234                 :     198479 :       gcc_assert (wi::le_p (minv, maxv, sgn));
     235                 :     198479 :       wi::to_mpz (minv, minc1, sgn);
     236                 :     198479 :       wi::to_mpz (maxv, maxc1, sgn);
     237                 :            :     }
     238                 :            :   else
     239                 :            :     {
     240                 :     468732 :       mpz_set (minc1, mint);
     241                 :     468732 :       mpz_set (maxc1, maxt);
     242                 :            :     }
     243                 :            : 
     244                 :            :   /* Compute valid range information for varc1 + offc1.  Note nothing
     245                 :            :      useful can be derived if it overflows or underflows.  Overflow or
     246                 :            :      underflow could happen when:
     247                 :            : 
     248                 :            :        offc1 > 0 && varc1 + offc1 > MAX_VAL (type)
     249                 :            :        offc1 < 0 && varc1 + offc1 < MIN_VAL (type).  */
     250                 :    1341170 :   mpz_add (minc1, minc1, offc1);
     251                 :    1341170 :   mpz_add (maxc1, maxc1, offc1);
     252                 :    2682340 :   c1_ok = (no_wrap
     253                 :     472914 :            || mpz_sgn (offc1) == 0
     254                 :      57306 :            || (mpz_sgn (offc1) < 0 && mpz_cmp (minc1, mint) >= 0)
     255                 :    1398060 :            || (mpz_sgn (offc1) > 0 && mpz_cmp (maxc1, maxt) <= 0));
     256                 :      22389 :   if (!c1_ok)
     257                 :      22389 :     goto end;
     258                 :            : 
     259                 :    1318780 :   if (mpz_cmp (minc1, mint) < 0)
     260                 :      40490 :     mpz_set (minc1, mint);
     261                 :    1318780 :   if (mpz_cmp (maxc1, maxt) > 0)
     262                 :      24498 :     mpz_set (maxc1, maxt);
     263                 :            : 
     264                 :    1318780 :   if (cmp == LT_EXPR)
     265                 :            :     {
     266                 :     189467 :       cmp = LE_EXPR;
     267                 :     189467 :       mpz_sub_ui (maxc1, maxc1, 1);
     268                 :            :     }
     269                 :    1318780 :   if (cmp == GT_EXPR)
     270                 :            :     {
     271                 :     716183 :       cmp = GE_EXPR;
     272                 :     716183 :       mpz_add_ui (minc1, minc1, 1);
     273                 :            :     }
     274                 :            : 
     275                 :            :   /* Compute range information for varc0.  If there is no overflow,
     276                 :            :      the condition implied that
     277                 :            : 
     278                 :            :        (varc0) cmp (varc1 + offc1 - offc0)
     279                 :            : 
     280                 :            :      We can possibly improve the upper bound of varc0 if cmp is LE_EXPR,
     281                 :            :      or the below bound if cmp is GE_EXPR.
     282                 :            : 
     283                 :            :      To prove there is no overflow/underflow, we need to check below
     284                 :            :      four cases:
     285                 :            :        1) cmp == LE_EXPR && offc0 > 0
     286                 :            : 
     287                 :            :             (varc0 + offc0) doesn't overflow
     288                 :            :             && (varc1 + offc1 - offc0) doesn't underflow
     289                 :            : 
     290                 :            :        2) cmp == LE_EXPR && offc0 < 0
     291                 :            : 
     292                 :            :             (varc0 + offc0) doesn't underflow
     293                 :            :             && (varc1 + offc1 - offc0) doesn't overfloe
     294                 :            : 
     295                 :            :           In this case, (varc0 + offc0) will never underflow if we can
     296                 :            :           prove (varc1 + offc1 - offc0) doesn't overflow.
     297                 :            : 
     298                 :            :        3) cmp == GE_EXPR && offc0 < 0
     299                 :            : 
     300                 :            :             (varc0 + offc0) doesn't underflow
     301                 :            :             && (varc1 + offc1 - offc0) doesn't overflow
     302                 :            : 
     303                 :            :        4) cmp == GE_EXPR && offc0 > 0
     304                 :            : 
     305                 :            :             (varc0 + offc0) doesn't overflow
     306                 :            :             && (varc1 + offc1 - offc0) doesn't underflow
     307                 :            : 
     308                 :            :           In this case, (varc0 + offc0) will never overflow if we can
     309                 :            :           prove (varc1 + offc1 - offc0) doesn't underflow.
     310                 :            : 
     311                 :            :      Note we only handle case 2 and 4 in below code.  */
     312                 :            : 
     313                 :    1318780 :   mpz_sub (minc1, minc1, offc0);
     314                 :    1318780 :   mpz_sub (maxc1, maxc1, offc0);
     315                 :    2637560 :   c0_ok = (no_wrap
     316                 :     450525 :            || mpz_sgn (offc0) == 0
     317                 :      33299 :            || (cmp == LE_EXPR
     318                 :      19051 :                && mpz_sgn (offc0) < 0 && mpz_cmp (maxc1, maxt) <= 0)
     319                 :    1348360 :            || (cmp == GE_EXPR
     320                 :      14248 :                && mpz_sgn (offc0) > 0 && mpz_cmp (minc1, mint) >= 0));
     321                 :      26226 :   if (!c0_ok)
     322                 :      26226 :     goto end;
     323                 :            : 
     324                 :    1292560 :   if (cmp == LE_EXPR)
     325                 :            :     {
     326                 :     424213 :       if (mpz_cmp (up, maxc1) > 0)
     327                 :     194349 :         mpz_set (up, maxc1);
     328                 :            :     }
     329                 :            :   else
     330                 :            :     {
     331                 :     868343 :       if (mpz_cmp (below, minc1) < 0)
     332                 :     773574 :         mpz_set (below, minc1);
     333                 :            :     }
     334                 :            : 
     335                 :      94769 : end:
     336                 :    1341170 :   mpz_clear (mint);
     337                 :    1341170 :   mpz_clear (maxt);
     338                 :    1341170 :   mpz_clear (minc1);
     339                 :    1341170 :   mpz_clear (maxc1);
     340                 :    1341170 :   mpz_clear (offc0);
     341                 :    1341170 :   mpz_clear (offc1);
     342                 :            : }
     343                 :            : 
     344                 :            : /* Stores estimate on the minimum/maximum value of the expression VAR + OFF
     345                 :            :    in TYPE to MIN and MAX.  */
     346                 :            : 
     347                 :            : static void
     348                 :   12060900 : determine_value_range (class loop *loop, tree type, tree var, mpz_t off,
     349                 :            :                        mpz_t min, mpz_t max)
     350                 :            : {
     351                 :   12060900 :   int cnt = 0;
     352                 :   12060900 :   mpz_t minm, maxm;
     353                 :   12060900 :   basic_block bb;
     354                 :   12060900 :   wide_int minv, maxv;
     355                 :   12060900 :   enum value_range_kind rtype = VR_VARYING;
     356                 :            : 
     357                 :            :   /* If the expression is a constant, we know its value exactly.  */
     358                 :   12060900 :   if (integer_zerop (var))
     359                 :            :     {
     360                 :    7707530 :       mpz_set (min, off);
     361                 :    7707530 :       mpz_set (max, off);
     362                 :   18383900 :       return;
     363                 :            :     }
     364                 :            : 
     365                 :    4353330 :   get_type_static_bounds (type, min, max);
     366                 :            : 
     367                 :            :   /* See if we have some range info from VRP.  */
     368                 :    4353330 :   if (TREE_CODE (var) == SSA_NAME && INTEGRAL_TYPE_P (type))
     369                 :            :     {
     370                 :    2777960 :       edge e = loop_preheader_edge (loop);
     371                 :    2777960 :       signop sgn = TYPE_SIGN (type);
     372                 :    2777960 :       gphi_iterator gsi;
     373                 :            : 
     374                 :            :       /* Either for VAR itself...  */
     375                 :    2777960 :       rtype = get_range_info (var, &minv, &maxv);
     376                 :            :       /* Or for PHI results in loop->header where VAR is used as
     377                 :            :          PHI argument from the loop preheader edge.  */
     378                 :   10799200 :       for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi))
     379                 :            :         {
     380                 :    8021270 :           gphi *phi = gsi.phi ();
     381                 :    8021270 :           wide_int minc, maxc;
     382                 :    8021270 :           if (PHI_ARG_DEF_FROM_EDGE (phi, e) == var
     383                 :    8021270 :               && (get_range_info (gimple_phi_result (phi), &minc, &maxc)
     384                 :            :                   == VR_RANGE))
     385                 :            :             {
     386                 :     139984 :               if (rtype != VR_RANGE)
     387                 :            :                 {
     388                 :      34993 :                   rtype = VR_RANGE;
     389                 :      34993 :                   minv = minc;
     390                 :      34993 :                   maxv = maxc;
     391                 :            :                 }
     392                 :            :               else
     393                 :            :                 {
     394                 :     104991 :                   minv = wi::max (minv, minc, sgn);
     395                 :     104991 :                   maxv = wi::min (maxv, maxc, sgn);
     396                 :            :                   /* If the PHI result range are inconsistent with
     397                 :            :                      the VAR range, give up on looking at the PHI
     398                 :            :                      results.  This can happen if VR_UNDEFINED is
     399                 :            :                      involved.  */
     400                 :     104991 :                   if (wi::gt_p (minv, maxv, sgn))
     401                 :            :                     {
     402                 :          0 :                       rtype = get_range_info (var, &minv, &maxv);
     403                 :          0 :                       break;
     404                 :            :                     }
     405                 :            :                 }
     406                 :            :             }
     407                 :            :         }
     408                 :    2777960 :       mpz_init (minm);
     409                 :    2777960 :       mpz_init (maxm);
     410                 :    2777960 :       if (rtype != VR_RANGE)
     411                 :            :         {
     412                 :    2136420 :           mpz_set (minm, min);
     413                 :    2136420 :           mpz_set (maxm, max);
     414                 :            :         }
     415                 :            :       else
     416                 :            :         {
     417                 :     641538 :           gcc_assert (wi::le_p (minv, maxv, sgn));
     418                 :     641538 :           wi::to_mpz (minv, minm, sgn);
     419                 :     641538 :           wi::to_mpz (maxv, maxm, sgn);
     420                 :            :         }
     421                 :            :       /* Now walk the dominators of the loop header and use the entry
     422                 :            :          guards to refine the estimates.  */
     423                 :    2777960 :       for (bb = loop->header;
     424                 :   29405300 :            bb != ENTRY_BLOCK_PTR_FOR_FN (cfun) && cnt < MAX_DOMINATORS_TO_WALK;
     425                 :   26627400 :            bb = get_immediate_dominator (CDI_DOMINATORS, bb))
     426                 :            :         {
     427                 :   26627400 :           edge e;
     428                 :   26627400 :           tree c0, c1;
     429                 :   26627400 :           gimple *cond;
     430                 :   26627400 :           enum tree_code cmp;
     431                 :            : 
     432                 :   26627400 :           if (!single_pred_p (bb))
     433                 :   13477100 :             continue;
     434                 :   13150300 :           e = single_pred_edge (bb);
     435                 :            : 
     436                 :   13150300 :           if (!(e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
     437                 :    3039560 :             continue;
     438                 :            : 
     439                 :   10110700 :           cond = last_stmt (e->src);
     440                 :   10110700 :           c0 = gimple_cond_lhs (cond);
     441                 :   10110700 :           cmp = gimple_cond_code (cond);
     442                 :   10110700 :           c1 = gimple_cond_rhs (cond);
     443                 :            : 
     444                 :   10110700 :           if (e->flags & EDGE_FALSE_VALUE)
     445                 :    5045860 :             cmp = invert_tree_comparison (cmp, false);
     446                 :            : 
     447                 :   10110700 :           refine_value_range_using_guard (type, var, c0, cmp, c1, minm, maxm);
     448                 :   10110700 :           ++cnt;
     449                 :            :         }
     450                 :            : 
     451                 :    2777960 :       mpz_add (minm, minm, off);
     452                 :    2777960 :       mpz_add (maxm, maxm, off);
     453                 :            :       /* If the computation may not wrap or off is zero, then this
     454                 :            :          is always fine.  If off is negative and minv + off isn't
     455                 :            :          smaller than type's minimum, or off is positive and
     456                 :            :          maxv + off isn't bigger than type's maximum, use the more
     457                 :            :          precise range too.  */
     458                 :    2777960 :       if (nowrap_type_p (type)
     459                 :    1067730 :           || mpz_sgn (off) == 0
     460                 :     171175 :           || (mpz_sgn (off) < 0 && mpz_cmp (minm, min) >= 0)
     461                 :    2915060 :           || (mpz_sgn (off) > 0 && mpz_cmp (maxm, max) <= 0))
     462                 :            :         {
     463                 :    2677060 :           mpz_set (min, minm);
     464                 :    2677060 :           mpz_set (max, maxm);
     465                 :    2677060 :           mpz_clear (minm);
     466                 :    2677060 :           mpz_clear (maxm);
     467                 :    2677060 :           return;
     468                 :            :         }
     469                 :     100904 :       mpz_clear (minm);
     470                 :     100904 :       mpz_clear (maxm);
     471                 :            :     }
     472                 :            : 
     473                 :            :   /* If the computation may wrap, we know nothing about the value, except for
     474                 :            :      the range of the type.  */
     475                 :    1676270 :   if (!nowrap_type_p (type))
     476                 :            :     return;
     477                 :            : 
     478                 :            :   /* Since the addition of OFF does not wrap, if OFF is positive, then we may
     479                 :            :      add it to MIN, otherwise to MAX.  */
     480                 :    1384460 :   if (mpz_sgn (off) < 0)
     481                 :     103954 :     mpz_add (max, max, off);
     482                 :            :   else
     483                 :    1280510 :     mpz_add (min, min, off);
     484                 :            : }
     485                 :            : 
     486                 :            : /* Stores the bounds on the difference of the values of the expressions
     487                 :            :    (var + X) and (var + Y), computed in TYPE, to BNDS.  */
     488                 :            : 
     489                 :            : static void
     490                 :      51131 : bound_difference_of_offsetted_base (tree type, mpz_t x, mpz_t y,
     491                 :            :                                     bounds *bnds)
     492                 :            : {
     493                 :      51131 :   int rel = mpz_cmp (x, y);
     494                 :      51131 :   bool may_wrap = !nowrap_type_p (type);
     495                 :      51131 :   mpz_t m;
     496                 :            : 
     497                 :            :   /* If X == Y, then the expressions are always equal.
     498                 :            :      If X > Y, there are the following possibilities:
     499                 :            :        a) neither of var + X and var + Y overflow or underflow, or both of
     500                 :            :           them do.  Then their difference is X - Y.
     501                 :            :        b) var + X overflows, and var + Y does not.  Then the values of the
     502                 :            :           expressions are var + X - M and var + Y, where M is the range of
     503                 :            :           the type, and their difference is X - Y - M.
     504                 :            :        c) var + Y underflows and var + X does not.  Their difference again
     505                 :            :           is M - X + Y.
     506                 :            :        Therefore, if the arithmetics in type does not overflow, then the
     507                 :            :        bounds are (X - Y, X - Y), otherwise they are (X - Y - M, X - Y)
     508                 :            :      Similarly, if X < Y, the bounds are either (X - Y, X - Y) or
     509                 :            :      (X - Y, X - Y + M).  */
     510                 :            : 
     511                 :      51131 :   if (rel == 0)
     512                 :            :     {
     513                 :        131 :       mpz_set_ui (bnds->below, 0);
     514                 :        131 :       mpz_set_ui (bnds->up, 0);
     515                 :        131 :       return;
     516                 :            :     }
     517                 :            : 
     518                 :      51000 :   mpz_init (m);
     519                 :      55312 :   wi::to_mpz (wi::minus_one (TYPE_PRECISION (type)), m, UNSIGNED);
     520                 :      51000 :   mpz_add_ui (m, m, 1);
     521                 :      51000 :   mpz_sub (bnds->up, x, y);
     522                 :      51000 :   mpz_set (bnds->below, bnds->up);
     523                 :            : 
     524                 :      51000 :   if (may_wrap)
     525                 :            :     {
     526                 :      41525 :       if (rel > 0)
     527                 :      40962 :         mpz_sub (bnds->below, bnds->below, m);
     528                 :            :       else
     529                 :        563 :         mpz_add (bnds->up, bnds->up, m);
     530                 :            :     }
     531                 :            : 
     532                 :      51000 :   mpz_clear (m);
     533                 :            : }
     534                 :            : 
     535                 :            : /* From condition C0 CMP C1 derives information regarding the
     536                 :            :    difference of values of VARX + OFFX and VARY + OFFY, computed in TYPE,
     537                 :            :    and stores it to BNDS.  */
     538                 :            : 
     539                 :            : static void
     540                 :   10858800 : refine_bounds_using_guard (tree type, tree varx, mpz_t offx,
     541                 :            :                            tree vary, mpz_t offy,
     542                 :            :                            tree c0, enum tree_code cmp, tree c1,
     543                 :            :                            bounds *bnds)
     544                 :            : {
     545                 :   10858800 :   tree varc0, varc1, ctype;
     546                 :   10858800 :   mpz_t offc0, offc1, loffx, loffy, bnd;
     547                 :   10858800 :   bool lbound = false;
     548                 :   10858800 :   bool no_wrap = nowrap_type_p (type);
     549                 :   10858800 :   bool x_ok, y_ok;
     550                 :            : 
     551                 :   10858800 :   switch (cmp)
     552                 :            :     {
     553                 :    5113610 :     case LT_EXPR:
     554                 :    5113610 :     case LE_EXPR:
     555                 :    5113610 :     case GT_EXPR:
     556                 :    5113610 :     case GE_EXPR:
     557                 :    5113610 :       STRIP_SIGN_NOPS (c0);
     558                 :    5113610 :       STRIP_SIGN_NOPS (c1);
     559                 :    5113610 :       ctype = TREE_TYPE (c0);
     560                 :    5113610 :       if (!useless_type_conversion_p (ctype, type))
     561                 :    6458270 :         return;
     562                 :            : 
     563                 :            :       break;
     564                 :            : 
     565                 :            :     case EQ_EXPR:
     566                 :            :       /* We could derive quite precise information from EQ_EXPR, however, such
     567                 :            :          a guard is unlikely to appear, so we do not bother with handling
     568                 :            :          it.  */
     569                 :            :       return;
     570                 :            : 
     571                 :    2516570 :     case NE_EXPR:
     572                 :            :       /* NE_EXPR comparisons do not contain much of useful information, except for
     573                 :            :          special case of comparing with the bounds of the type.  */
     574                 :    2516570 :       if (TREE_CODE (c1) != INTEGER_CST
     575                 :    2112650 :           || !INTEGRAL_TYPE_P (type))
     576                 :            :         return;
     577                 :            : 
     578                 :            :       /* Ensure that the condition speaks about an expression in the same type
     579                 :            :          as X and Y.  */
     580                 :    1970000 :       ctype = TREE_TYPE (c0);
     581                 :    1970000 :       if (TYPE_PRECISION (ctype) != TYPE_PRECISION (type))
     582                 :            :         return;
     583                 :    1201270 :       c0 = fold_convert (type, c0);
     584                 :    1201270 :       c1 = fold_convert (type, c1);
     585                 :            : 
     586                 :    1201270 :       if (TYPE_MIN_VALUE (type)
     587                 :    1201270 :           && operand_equal_p (c1, TYPE_MIN_VALUE (type), 0))
     588                 :            :         {
     589                 :            :           cmp = GT_EXPR;
     590                 :            :           break;
     591                 :            :         }
     592                 :     984394 :       if (TYPE_MAX_VALUE (type)
     593                 :     984394 :           && operand_equal_p (c1, TYPE_MAX_VALUE (type), 0))
     594                 :            :         {
     595                 :            :           cmp = LT_EXPR;
     596                 :            :           break;
     597                 :            :         }
     598                 :            : 
     599                 :            :       return;
     600                 :            :     default:
     601                 :            :       return;
     602                 :            :     }
     603                 :            : 
     604                 :    4400500 :   mpz_init (offc0);
     605                 :    4400500 :   mpz_init (offc1);
     606                 :    4400500 :   split_to_var_and_offset (expand_simple_operations (c0), &varc0, offc0);
     607                 :    4400500 :   split_to_var_and_offset (expand_simple_operations (c1), &varc1, offc1);
     608                 :            : 
     609                 :            :   /* We are only interested in comparisons of expressions based on VARX and
     610                 :            :      VARY.  TODO -- we might also be able to derive some bounds from
     611                 :            :      expressions containing just one of the variables.  */
     612                 :            : 
     613                 :    4400500 :   if (operand_equal_p (varx, varc1, 0))
     614                 :            :     {
     615                 :     553061 :       std::swap (varc0, varc1);
     616                 :     553061 :       mpz_swap (offc0, offc1);
     617                 :     553061 :       cmp = swap_tree_comparison (cmp);
     618                 :            :     }
     619                 :            : 
     620                 :    4400500 :   if (!operand_equal_p (varx, varc0, 0)
     621                 :    4400500 :       || !operand_equal_p (vary, varc1, 0))
     622                 :    3289490 :     goto end;
     623                 :            : 
     624                 :    1111010 :   mpz_init_set (loffx, offx);
     625                 :    1111010 :   mpz_init_set (loffy, offy);
     626                 :            : 
     627                 :    1111010 :   if (cmp == GT_EXPR || cmp == GE_EXPR)
     628                 :            :     {
     629                 :    1070690 :       std::swap (varx, vary);
     630                 :    1070690 :       mpz_swap (offc0, offc1);
     631                 :    1070690 :       mpz_swap (loffx, loffy);
     632                 :    1070690 :       cmp = swap_tree_comparison (cmp);
     633                 :    1070690 :       lbound = true;
     634                 :            :     }
     635                 :            : 
     636                 :            :   /* If there is no overflow, the condition implies that
     637                 :            : 
     638                 :            :      (VARX + OFFX) cmp (VARY + OFFY) + (OFFX - OFFY + OFFC1 - OFFC0).
     639                 :            : 
     640                 :            :      The overflows and underflows may complicate things a bit; each
     641                 :            :      overflow decreases the appropriate offset by M, and underflow
     642                 :            :      increases it by M.  The above inequality would not necessarily be
     643                 :            :      true if
     644                 :            : 
     645                 :            :      -- VARX + OFFX underflows and VARX + OFFC0 does not, or
     646                 :            :         VARX + OFFC0 overflows, but VARX + OFFX does not.
     647                 :            :         This may only happen if OFFX < OFFC0.
     648                 :            :      -- VARY + OFFY overflows and VARY + OFFC1 does not, or
     649                 :            :         VARY + OFFC1 underflows and VARY + OFFY does not.
     650                 :            :         This may only happen if OFFY > OFFC1.  */
     651                 :            : 
     652                 :    1111010 :   if (no_wrap)
     653                 :            :     {
     654                 :            :       x_ok = true;
     655                 :            :       y_ok = true;
     656                 :            :     }
     657                 :            :   else
     658                 :            :     {
     659                 :     383097 :       x_ok = (integer_zerop (varx)
     660                 :     383097 :               || mpz_cmp (loffx, offc0) >= 0);
     661                 :     383097 :       y_ok = (integer_zerop (vary)
     662                 :     383097 :               || mpz_cmp (loffy, offc1) <= 0);
     663                 :            :     }
     664                 :            : 
     665                 :    1111010 :   if (x_ok && y_ok)
     666                 :            :     {
     667                 :    1106210 :       mpz_init (bnd);
     668                 :    1106210 :       mpz_sub (bnd, loffx, loffy);
     669                 :    1106210 :       mpz_add (bnd, bnd, offc1);
     670                 :    1106210 :       mpz_sub (bnd, bnd, offc0);
     671                 :            : 
     672                 :    1106210 :       if (cmp == LT_EXPR)
     673                 :     913012 :         mpz_sub_ui (bnd, bnd, 1);
     674                 :            : 
     675                 :    1106210 :       if (lbound)
     676                 :            :         {
     677                 :    1066430 :           mpz_neg (bnd, bnd);
     678                 :    1066430 :           if (mpz_cmp (bnds->below, bnd) < 0)
     679                 :     457394 :             mpz_set (bnds->below, bnd);
     680                 :            :         }
     681                 :            :       else
     682                 :            :         {
     683                 :      39778 :           if (mpz_cmp (bnd, bnds->up) < 0)
     684                 :       6321 :             mpz_set (bnds->up, bnd);
     685                 :            :         }
     686                 :    1106210 :       mpz_clear (bnd);
     687                 :            :     }
     688                 :            : 
     689                 :    1111010 :   mpz_clear (loffx);
     690                 :    1111010 :   mpz_clear (loffy);
     691                 :    4400500 : end:
     692                 :    4400500 :   mpz_clear (offc0);
     693                 :    4400500 :   mpz_clear (offc1);
     694                 :            : }
     695                 :            : 
     696                 :            : /* Stores the bounds on the value of the expression X - Y in LOOP to BNDS.
     697                 :            :    The subtraction is considered to be performed in arbitrary precision,
     698                 :            :    without overflows.
     699                 :            : 
     700                 :            :    We do not attempt to be too clever regarding the value ranges of X and
     701                 :            :    Y; most of the time, they are just integers or ssa names offsetted by
     702                 :            :    integer.  However, we try to use the information contained in the
     703                 :            :    comparisons before the loop (usually created by loop header copying).  */
     704                 :            : 
     705                 :            : static void
     706                 :    6081560 : bound_difference (class loop *loop, tree x, tree y, bounds *bnds)
     707                 :            : {
     708                 :    6081560 :   tree type = TREE_TYPE (x);
     709                 :    6081560 :   tree varx, vary;
     710                 :    6081560 :   mpz_t offx, offy;
     711                 :    6081560 :   mpz_t minx, maxx, miny, maxy;
     712                 :    6081560 :   int cnt = 0;
     713                 :    6081560 :   edge e;
     714                 :    6081560 :   basic_block bb;
     715                 :    6081560 :   tree c0, c1;
     716                 :    6081560 :   gimple *cond;
     717                 :    6081560 :   enum tree_code cmp;
     718                 :            : 
     719                 :            :   /* Get rid of unnecessary casts, but preserve the value of
     720                 :            :      the expressions.  */
     721                 :    6081560 :   STRIP_SIGN_NOPS (x);
     722                 :    6081560 :   STRIP_SIGN_NOPS (y);
     723                 :            : 
     724                 :    6081560 :   mpz_init (bnds->below);
     725                 :    6081560 :   mpz_init (bnds->up);
     726                 :    6081560 :   mpz_init (offx);
     727                 :    6081560 :   mpz_init (offy);
     728                 :    6081560 :   split_to_var_and_offset (x, &varx, offx);
     729                 :    6081560 :   split_to_var_and_offset (y, &vary, offy);
     730                 :            : 
     731                 :    6081560 :   if (!integer_zerop (varx)
     732                 :    6081560 :       && operand_equal_p (varx, vary, 0))
     733                 :            :     {
     734                 :            :       /* Special case VARX == VARY -- we just need to compare the
     735                 :            :          offsets.  The matters are a bit more complicated in the
     736                 :            :          case addition of offsets may wrap.  */
     737                 :      51131 :       bound_difference_of_offsetted_base (type, offx, offy, bnds);
     738                 :            :     }
     739                 :            :   else
     740                 :            :     {
     741                 :            :       /* Otherwise, use the value ranges to determine the initial
     742                 :            :          estimates on below and up.  */
     743                 :    6030430 :       mpz_init (minx);
     744                 :    6030430 :       mpz_init (maxx);
     745                 :    6030430 :       mpz_init (miny);
     746                 :    6030430 :       mpz_init (maxy);
     747                 :    6030430 :       determine_value_range (loop, type, varx, offx, minx, maxx);
     748                 :    6030430 :       determine_value_range (loop, type, vary, offy, miny, maxy);
     749                 :            : 
     750                 :    6030430 :       mpz_sub (bnds->below, minx, maxy);
     751                 :    6030430 :       mpz_sub (bnds->up, maxx, miny);
     752                 :    6030430 :       mpz_clear (minx);
     753                 :    6030430 :       mpz_clear (maxx);
     754                 :    6030430 :       mpz_clear (miny);
     755                 :    6030430 :       mpz_clear (maxy);
     756                 :            :     }
     757                 :            : 
     758                 :            :   /* If both X and Y are constants, we cannot get any more precise.  */
     759                 :    6081560 :   if (integer_zerop (varx) && integer_zerop (vary))
     760                 :    2755950 :     goto end;
     761                 :            : 
     762                 :            :   /* Now walk the dominators of the loop header and use the entry
     763                 :            :      guards to refine the estimates.  */
     764                 :    3325610 :   for (bb = loop->header;
     765                 :   33441400 :        bb != ENTRY_BLOCK_PTR_FOR_FN (cfun) && cnt < MAX_DOMINATORS_TO_WALK;
     766                 :   30115800 :        bb = get_immediate_dominator (CDI_DOMINATORS, bb))
     767                 :            :     {
     768                 :   30115800 :       if (!single_pred_p (bb))
     769                 :   15027400 :         continue;
     770                 :   15088300 :       e = single_pred_edge (bb);
     771                 :            : 
     772                 :   15088300 :       if (!(e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
     773                 :    4229570 :         continue;
     774                 :            : 
     775                 :   10858800 :       cond = last_stmt (e->src);
     776                 :   10858800 :       c0 = gimple_cond_lhs (cond);
     777                 :   10858800 :       cmp = gimple_cond_code (cond);
     778                 :   10858800 :       c1 = gimple_cond_rhs (cond);
     779                 :            : 
     780                 :   10858800 :       if (e->flags & EDGE_FALSE_VALUE)
     781                 :    5944740 :         cmp = invert_tree_comparison (cmp, false);
     782                 :            : 
     783                 :   10858800 :       refine_bounds_using_guard (type, varx, offx, vary, offy,
     784                 :            :                                  c0, cmp, c1, bnds);
     785                 :   10858800 :       ++cnt;
     786                 :            :     }
     787                 :            : 
     788                 :    3325610 : end:
     789                 :    6081560 :   mpz_clear (offx);
     790                 :    6081560 :   mpz_clear (offy);
     791                 :    6081560 : }
     792                 :            : 
     793                 :            : /* Update the bounds in BNDS that restrict the value of X to the bounds
     794                 :            :    that restrict the value of X + DELTA.  X can be obtained as a
     795                 :            :    difference of two values in TYPE.  */
     796                 :            : 
     797                 :            : static void
     798                 :    1102500 : bounds_add (bounds *bnds, const widest_int &delta, tree type)
     799                 :            : {
     800                 :    1102500 :   mpz_t mdelta, max;
     801                 :            : 
     802                 :    1102500 :   mpz_init (mdelta);
     803                 :    1102500 :   wi::to_mpz (delta, mdelta, SIGNED);
     804                 :            : 
     805                 :    1102500 :   mpz_init (max);
     806                 :    1530340 :   wi::to_mpz (wi::minus_one (TYPE_PRECISION (type)), max, UNSIGNED);
     807                 :            : 
     808                 :    1102500 :   mpz_add (bnds->up, bnds->up, mdelta);
     809                 :    1102500 :   mpz_add (bnds->below, bnds->below, mdelta);
     810                 :            : 
     811                 :    1102500 :   if (mpz_cmp (bnds->up, max) > 0)
     812                 :      68426 :     mpz_set (bnds->up, max);
     813                 :            : 
     814                 :    1102500 :   mpz_neg (max, max);
     815                 :    1102500 :   if (mpz_cmp (bnds->below, max) < 0)
     816                 :       5218 :     mpz_set (bnds->below, max);
     817                 :            : 
     818                 :    1102500 :   mpz_clear (mdelta);
     819                 :    1102500 :   mpz_clear (max);
     820                 :    1102500 : }
     821                 :            : 
     822                 :            : /* Update the bounds in BNDS that restrict the value of X to the bounds
     823                 :            :    that restrict the value of -X.  */
     824                 :            : 
     825                 :            : static void
     826                 :    1020370 : bounds_negate (bounds *bnds)
     827                 :            : {
     828                 :    1020370 :   mpz_t tmp;
     829                 :            : 
     830                 :    1020370 :   mpz_init_set (tmp, bnds->up);
     831                 :    1020370 :   mpz_neg (bnds->up, bnds->below);
     832                 :    1020370 :   mpz_neg (bnds->below, tmp);
     833                 :    1020370 :   mpz_clear (tmp);
     834                 :    1020370 : }
     835                 :            : 
     836                 :            : /* Returns inverse of X modulo 2^s, where MASK = 2^s-1.  */
     837                 :            : 
     838                 :            : static tree
     839                 :      89045 : inverse (tree x, tree mask)
     840                 :            : {
     841                 :      89045 :   tree type = TREE_TYPE (x);
     842                 :      89045 :   tree rslt;
     843                 :      89045 :   unsigned ctr = tree_floor_log2 (mask);
     844                 :            : 
     845                 :      89045 :   if (TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT)
     846                 :            :     {
     847                 :      89045 :       unsigned HOST_WIDE_INT ix;
     848                 :      89045 :       unsigned HOST_WIDE_INT imask;
     849                 :      89045 :       unsigned HOST_WIDE_INT irslt = 1;
     850                 :            : 
     851                 :      89045 :       gcc_assert (cst_and_fits_in_hwi (x));
     852                 :      89045 :       gcc_assert (cst_and_fits_in_hwi (mask));
     853                 :            : 
     854                 :      89045 :       ix = int_cst_value (x);
     855                 :      89045 :       imask = int_cst_value (mask);
     856                 :            : 
     857                 :    5097560 :       for (; ctr; ctr--)
     858                 :            :         {
     859                 :    5008510 :           irslt *= ix;
     860                 :    5008510 :           ix *= ix;
     861                 :            :         }
     862                 :      89045 :       irslt &= imask;
     863                 :            : 
     864                 :      89045 :       rslt = build_int_cst_type (type, irslt);
     865                 :            :     }
     866                 :            :   else
     867                 :            :     {
     868                 :          0 :       rslt = build_int_cst (type, 1);
     869                 :          0 :       for (; ctr; ctr--)
     870                 :            :         {
     871                 :          0 :           rslt = int_const_binop (MULT_EXPR, rslt, x);
     872                 :          0 :           x = int_const_binop (MULT_EXPR, x, x);
     873                 :            :         }
     874                 :          0 :       rslt = int_const_binop (BIT_AND_EXPR, rslt, mask);
     875                 :            :     }
     876                 :            : 
     877                 :      89045 :   return rslt;
     878                 :            : }
     879                 :            : 
     880                 :            : /* Derives the upper bound BND on the number of executions of loop with exit
     881                 :            :    condition S * i <> C.  If NO_OVERFLOW is true, then the control variable of
     882                 :            :    the loop does not overflow.  EXIT_MUST_BE_TAKEN is true if we are guaranteed
     883                 :            :    that the loop ends through this exit, i.e., the induction variable ever
     884                 :            :    reaches the value of C.  
     885                 :            :    
     886                 :            :    The value C is equal to final - base, where final and base are the final and
     887                 :            :    initial value of the actual induction variable in the analysed loop.  BNDS
     888                 :            :    bounds the value of this difference when computed in signed type with
     889                 :            :    unbounded range, while the computation of C is performed in an unsigned
     890                 :            :    type with the range matching the range of the type of the induction variable.
     891                 :            :    In particular, BNDS.up contains an upper bound on C in the following cases:
     892                 :            :    -- if the iv must reach its final value without overflow, i.e., if
     893                 :            :       NO_OVERFLOW && EXIT_MUST_BE_TAKEN is true, or
     894                 :            :    -- if final >= base, which we know to hold when BNDS.below >= 0.  */
     895                 :            : 
     896                 :            : static void
     897                 :    3135180 : number_of_iterations_ne_max (mpz_t bnd, bool no_overflow, tree c, tree s,
     898                 :            :                              bounds *bnds, bool exit_must_be_taken)
     899                 :            : {
     900                 :    3135180 :   widest_int max;
     901                 :    3135180 :   mpz_t d;
     902                 :    3135180 :   tree type = TREE_TYPE (c);
     903                 :    6270360 :   bool bnds_u_valid = ((no_overflow && exit_must_be_taken)
     904                 :    3135180 :                        || mpz_sgn (bnds->below) >= 0);
     905                 :            : 
     906                 :    3135180 :   if (integer_onep (s)
     907                 :     518903 :       || (TREE_CODE (c) == INTEGER_CST
     908                 :     149320 :           && TREE_CODE (s) == INTEGER_CST
     909                 :     519262 :           && wi::mod_trunc (wi::to_wide (c), wi::to_wide (s),
     910                 :    3063880 :                             TYPE_SIGN (type)) == 0)
     911                 :    3505120 :       || (TYPE_OVERFLOW_UNDEFINED (type)
     912                 :          0 :           && multiple_of_p (type, c, s)))
     913                 :            :     {
     914                 :            :       /* If C is an exact multiple of S, then its value will be reached before
     915                 :            :          the induction variable overflows (unless the loop is exited in some
     916                 :            :          other way before).  Note that the actual induction variable in the
     917                 :            :          loop (which ranges from base to final instead of from 0 to C) may
     918                 :            :          overflow, in which case BNDS.up will not be giving a correct upper
     919                 :            :          bound on C; thus, BNDS_U_VALID had to be computed in advance.  */
     920                 :            :       no_overflow = true;
     921                 :            :       exit_must_be_taken = true;
     922                 :            :     }
     923                 :            : 
     924                 :            :   /* If the induction variable can overflow, the number of iterations is at
     925                 :            :      most the period of the control variable (or infinite, but in that case
     926                 :            :      the whole # of iterations analysis will fail).  */
     927                 :    3135180 :   if (!no_overflow)
     928                 :            :     {
     929                 :      51876 :       max = wi::mask <widest_int> (TYPE_PRECISION (type)
     930                 :      51876 :                                    - wi::ctz (wi::to_wide (s)), false);
     931                 :      51876 :       wi::to_mpz (max, bnd, UNSIGNED);
     932                 :      51876 :       return;
     933                 :            :     }
     934                 :            : 
     935                 :            :   /* Now we know that the induction variable does not overflow, so the loop
     936                 :            :      iterates at most (range of type / S) times.  */
     937                 :    4601430 :   wi::to_mpz (wi::minus_one (TYPE_PRECISION (type)), bnd, UNSIGNED);
     938                 :            : 
     939                 :            :   /* If the induction variable is guaranteed to reach the value of C before
     940                 :            :      overflow, ... */
     941                 :    3083300 :   if (exit_must_be_taken)
     942                 :            :     {
     943                 :            :       /* ... then we can strengthen this to C / S, and possibly we can use
     944                 :            :          the upper bound on C given by BNDS.  */
     945                 :    2857250 :       if (TREE_CODE (c) == INTEGER_CST)
     946                 :    2419980 :         wi::to_mpz (wi::to_wide (c), bnd, UNSIGNED);
     947                 :     437268 :       else if (bnds_u_valid)
     948                 :     294031 :         mpz_set (bnd, bnds->up);
     949                 :            :     }
     950                 :            : 
     951                 :    3083300 :   mpz_init (d);
     952                 :    3083300 :   wi::to_mpz (wi::to_wide (s), d, UNSIGNED);
     953                 :    3083300 :   mpz_fdiv_q (bnd, bnd, d);
     954                 :    3083300 :   mpz_clear (d);
     955                 :            : }
     956                 :            : 
     957                 :            : /* Determines number of iterations of loop whose ending condition
     958                 :            :    is IV <> FINAL.  TYPE is the type of the iv.  The number of
     959                 :            :    iterations is stored to NITER.  EXIT_MUST_BE_TAKEN is true if
     960                 :            :    we know that the exit must be taken eventually, i.e., that the IV
     961                 :            :    ever reaches the value FINAL (we derived this earlier, and possibly set
     962                 :            :    NITER->assumptions to make sure this is the case).  BNDS contains the
     963                 :            :    bounds on the difference FINAL - IV->base.  */
     964                 :            : 
     965                 :            : static bool
     966                 :    3135180 : number_of_iterations_ne (class loop *loop, tree type, affine_iv *iv,
     967                 :            :                          tree final, class tree_niter_desc *niter,
     968                 :            :                          bool exit_must_be_taken, bounds *bnds)
     969                 :            : {
     970                 :    3135180 :   tree niter_type = unsigned_type_for (type);
     971                 :    3135180 :   tree s, c, d, bits, assumption, tmp, bound;
     972                 :    3135180 :   mpz_t max;
     973                 :            : 
     974                 :    3135180 :   niter->control = *iv;
     975                 :    3135180 :   niter->bound = final;
     976                 :    3135180 :   niter->cmp = NE_EXPR;
     977                 :            : 
     978                 :            :   /* Rearrange the terms so that we get inequality S * i <> C, with S
     979                 :            :      positive.  Also cast everything to the unsigned type.  If IV does
     980                 :            :      not overflow, BNDS bounds the value of C.  Also, this is the
     981                 :            :      case if the computation |FINAL - IV->base| does not overflow, i.e.,
     982                 :            :      if BNDS->below in the result is nonnegative.  */
     983                 :    3135180 :   if (tree_int_cst_sign_bit (iv->step))
     984                 :            :     {
     985                 :    1020370 :       s = fold_convert (niter_type,
     986                 :            :                         fold_build1 (NEGATE_EXPR, type, iv->step));
     987                 :    1020370 :       c = fold_build2 (MINUS_EXPR, niter_type,
     988                 :            :                        fold_convert (niter_type, iv->base),
     989                 :            :                        fold_convert (niter_type, final));
     990                 :    1020370 :       bounds_negate (bnds);
     991                 :            :     }
     992                 :            :   else
     993                 :            :     {
     994                 :    2114810 :       s = fold_convert (niter_type, iv->step);
     995                 :    2114810 :       c = fold_build2 (MINUS_EXPR, niter_type,
     996                 :            :                        fold_convert (niter_type, final),
     997                 :            :                        fold_convert (niter_type, iv->base));
     998                 :            :     }
     999                 :            : 
    1000                 :    3135180 :   mpz_init (max);
    1001                 :    3135180 :   number_of_iterations_ne_max (max, iv->no_overflow, c, s, bnds,
    1002                 :            :                                exit_must_be_taken);
    1003                 :    6270360 :   niter->max = widest_int::from (wi::from_mpz (niter_type, max, false),
    1004                 :    3135180 :                                  TYPE_SIGN (niter_type));
    1005                 :    3135180 :   mpz_clear (max);
    1006                 :            : 
    1007                 :            :   /* Compute no-overflow information for the control iv.  This can be
    1008                 :            :      proven when below two conditions are satisfied:
    1009                 :            : 
    1010                 :            :        1) IV evaluates toward FINAL at beginning, i.e:
    1011                 :            :             base <= FINAL ; step > 0
    1012                 :            :             base >= FINAL ; step < 0
    1013                 :            : 
    1014                 :            :        2) |FINAL - base| is an exact multiple of step.
    1015                 :            : 
    1016                 :            :      Unfortunately, it's hard to prove above conditions after pass loop-ch
    1017                 :            :      because loop with exit condition (IV != FINAL) usually will be guarded
    1018                 :            :      by initial-condition (IV.base - IV.step != FINAL).  In this case, we
    1019                 :            :      can alternatively try to prove below conditions:
    1020                 :            : 
    1021                 :            :        1') IV evaluates toward FINAL at beginning, i.e:
    1022                 :            :             new_base = base - step < FINAL ; step > 0
    1023                 :            :                                              && base - step doesn't underflow
    1024                 :            :             new_base = base - step > FINAL ; step < 0
    1025                 :            :                                              && base - step doesn't overflow
    1026                 :            : 
    1027                 :            :        2') |FINAL - new_base| is an exact multiple of step.
    1028                 :            : 
    1029                 :            :      Please refer to PR34114 as an example of loop-ch's impact, also refer
    1030                 :            :      to PR72817 as an example why condition 2') is necessary.
    1031                 :            : 
    1032                 :            :      Note, for NE_EXPR, base equals to FINAL is a special case, in
    1033                 :            :      which the loop exits immediately, and the iv does not overflow.  */
    1034                 :    3135180 :   if (!niter->control.no_overflow
    1035                 :    3135180 :       && (integer_onep (s) || multiple_of_p (type, c, s)))
    1036                 :            :     {
    1037                 :     952734 :       tree t, cond, new_c, relaxed_cond = boolean_false_node;
    1038                 :            : 
    1039                 :     952734 :       if (tree_int_cst_sign_bit (iv->step))
    1040                 :            :         {
    1041                 :     861467 :           cond = fold_build2 (GE_EXPR, boolean_type_node, iv->base, final);
    1042                 :     861467 :           if (TREE_CODE (type) == INTEGER_TYPE)
    1043                 :            :             {
    1044                 :            :               /* Only when base - step doesn't overflow.  */
    1045                 :     861467 :               t = TYPE_MAX_VALUE (type);
    1046                 :     861467 :               t = fold_build2 (PLUS_EXPR, type, t, iv->step);
    1047                 :     861467 :               t = fold_build2 (GE_EXPR, boolean_type_node, t, iv->base);
    1048                 :     861467 :               if (integer_nonzerop (t))
    1049                 :            :                 {
    1050                 :     778962 :                   t = fold_build2 (MINUS_EXPR, type, iv->base, iv->step);
    1051                 :     778962 :                   new_c = fold_build2 (MINUS_EXPR, niter_type,
    1052                 :            :                                        fold_convert (niter_type, t),
    1053                 :            :                                        fold_convert (niter_type, final));
    1054                 :     778962 :                   if (multiple_of_p (type, new_c, s))
    1055                 :     774711 :                     relaxed_cond = fold_build2 (GT_EXPR, boolean_type_node,
    1056                 :            :                                                 t, final);
    1057                 :            :                 }
    1058                 :            :             }
    1059                 :            :         }
    1060                 :            :       else
    1061                 :            :         {
    1062                 :      91267 :           cond = fold_build2 (LE_EXPR, boolean_type_node, iv->base, final);
    1063                 :      91267 :           if (TREE_CODE (type) == INTEGER_TYPE)
    1064                 :            :             {
    1065                 :            :               /* Only when base - step doesn't underflow.  */
    1066                 :      91267 :               t = TYPE_MIN_VALUE (type);
    1067                 :      91267 :               t = fold_build2 (PLUS_EXPR, type, t, iv->step);
    1068                 :      91267 :               t = fold_build2 (LE_EXPR, boolean_type_node, t, iv->base);
    1069                 :      91267 :               if (integer_nonzerop (t))
    1070                 :            :                 {
    1071                 :      31415 :                   t = fold_build2 (MINUS_EXPR, type, iv->base, iv->step);
    1072                 :      31415 :                   new_c = fold_build2 (MINUS_EXPR, niter_type,
    1073                 :            :                                        fold_convert (niter_type, final),
    1074                 :            :                                        fold_convert (niter_type, t));
    1075                 :      31415 :                   if (multiple_of_p (type, new_c, s))
    1076                 :       3865 :                     relaxed_cond = fold_build2 (LT_EXPR, boolean_type_node,
    1077                 :            :                                                 t, final);
    1078                 :            :                 }
    1079                 :            :             }
    1080                 :            :         }
    1081                 :            : 
    1082                 :     952734 :       t = simplify_using_initial_conditions (loop, cond);
    1083                 :     952734 :       if (!t || !integer_onep (t))
    1084                 :      92309 :         t = simplify_using_initial_conditions (loop, relaxed_cond);
    1085                 :            : 
    1086                 :     952734 :       if (t && integer_onep (t))
    1087                 :     860457 :         niter->control.no_overflow = true;
    1088                 :            :     }
    1089                 :            : 
    1090                 :            :   /* First the trivial cases -- when the step is 1.  */
    1091                 :    3135180 :   if (integer_onep (s))
    1092                 :            :     {
    1093                 :    2616280 :       niter->niter = c;
    1094                 :    2616280 :       return true;
    1095                 :            :     }
    1096                 :     518903 :   if (niter->control.no_overflow && multiple_of_p (type, c, s))
    1097                 :            :     {
    1098                 :      84364 :       niter->niter = fold_build2 (FLOOR_DIV_EXPR, niter_type, c, s);
    1099                 :      84364 :       return true;
    1100                 :            :     }
    1101                 :            : 
    1102                 :            :   /* Let nsd (step, size of mode) = d.  If d does not divide c, the loop
    1103                 :            :      is infinite.  Otherwise, the number of iterations is
    1104                 :            :      (inverse(s/d) * (c/d)) mod (size of mode/d).  */
    1105                 :     434539 :   bits = num_ending_zeros (s);
    1106                 :     434539 :   bound = build_low_bits_mask (niter_type,
    1107                 :     434539 :                                (TYPE_PRECISION (niter_type)
    1108                 :     434539 :                                 - tree_to_uhwi (bits)));
    1109                 :            : 
    1110                 :     434539 :   d = fold_binary_to_constant (LSHIFT_EXPR, niter_type,
    1111                 :     434539 :                                build_int_cst (niter_type, 1), bits);
    1112                 :     434539 :   s = fold_binary_to_constant (RSHIFT_EXPR, niter_type, s, bits);
    1113                 :            : 
    1114                 :     434539 :   if (!exit_must_be_taken)
    1115                 :            :     {
    1116                 :            :       /* If we cannot assume that the exit is taken eventually, record the
    1117                 :            :          assumptions for divisibility of c.  */
    1118                 :     333737 :       assumption = fold_build2 (FLOOR_MOD_EXPR, niter_type, c, d);
    1119                 :     333737 :       assumption = fold_build2 (EQ_EXPR, boolean_type_node,
    1120                 :            :                                 assumption, build_int_cst (niter_type, 0));
    1121                 :     333737 :       if (!integer_nonzerop (assumption))
    1122                 :     275440 :         niter->assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
    1123                 :            :                                           niter->assumptions, assumption);
    1124                 :            :     }
    1125                 :            : 
    1126                 :     434539 :   c = fold_build2 (EXACT_DIV_EXPR, niter_type, c, d);
    1127                 :     434539 :   if (integer_onep (s))
    1128                 :            :     {
    1129                 :     345494 :       niter->niter = c;
    1130                 :            :     }
    1131                 :            :   else
    1132                 :            :     {
    1133                 :      89045 :       tmp = fold_build2 (MULT_EXPR, niter_type, c, inverse (s, bound));
    1134                 :      89045 :       niter->niter = fold_build2 (BIT_AND_EXPR, niter_type, tmp, bound);
    1135                 :            :     }
    1136                 :            :   return true;
    1137                 :            : }
    1138                 :            : 
    1139                 :            : /* Checks whether we can determine the final value of the control variable
    1140                 :            :    of the loop with ending condition IV0 < IV1 (computed in TYPE).
    1141                 :            :    DELTA is the difference IV1->base - IV0->base, STEP is the absolute value
    1142                 :            :    of the step.  The assumptions necessary to ensure that the computation
    1143                 :            :    of the final value does not overflow are recorded in NITER.  If we
    1144                 :            :    find the final value, we adjust DELTA and return TRUE.  Otherwise
    1145                 :            :    we return false.  BNDS bounds the value of IV1->base - IV0->base,
    1146                 :            :    and will be updated by the same amount as DELTA.  EXIT_MUST_BE_TAKEN is
    1147                 :            :    true if we know that the exit must be taken eventually.  */
    1148                 :            : 
    1149                 :            : static bool
    1150                 :     211132 : number_of_iterations_lt_to_ne (tree type, affine_iv *iv0, affine_iv *iv1,
    1151                 :            :                                class tree_niter_desc *niter,
    1152                 :            :                                tree *delta, tree step,
    1153                 :            :                                bool exit_must_be_taken, bounds *bnds)
    1154                 :            : {
    1155                 :     211132 :   tree niter_type = TREE_TYPE (step);
    1156                 :     211132 :   tree mod = fold_build2 (FLOOR_MOD_EXPR, niter_type, *delta, step);
    1157                 :     211132 :   tree tmod;
    1158                 :     211132 :   mpz_t mmod;
    1159                 :     211132 :   tree assumption = boolean_true_node, bound, noloop;
    1160                 :     211132 :   bool ret = false, fv_comp_no_overflow;
    1161                 :     211132 :   tree type1 = type;
    1162                 :     211132 :   if (POINTER_TYPE_P (type))
    1163                 :      52680 :     type1 = sizetype;
    1164                 :            : 
    1165                 :     211132 :   if (TREE_CODE (mod) != INTEGER_CST)
    1166                 :            :     return false;
    1167                 :       9463 :   if (integer_nonzerop (mod))
    1168                 :       4758 :     mod = fold_build2 (MINUS_EXPR, niter_type, step, mod);
    1169                 :       9463 :   tmod = fold_convert (type1, mod);
    1170                 :            : 
    1171                 :       9463 :   mpz_init (mmod);
    1172                 :       9463 :   wi::to_mpz (wi::to_wide (mod), mmod, UNSIGNED);
    1173                 :       9463 :   mpz_neg (mmod, mmod);
    1174                 :            : 
    1175                 :            :   /* If the induction variable does not overflow and the exit is taken,
    1176                 :            :      then the computation of the final value does not overflow.  This is
    1177                 :            :      also obviously the case if the new final value is equal to the
    1178                 :            :      current one.  Finally, we postulate this for pointer type variables,
    1179                 :            :      as the code cannot rely on the object to that the pointer points being
    1180                 :            :      placed at the end of the address space (and more pragmatically,
    1181                 :            :      TYPE_{MIN,MAX}_VALUE is not defined for pointers).  */
    1182                 :       9463 :   if (integer_zerop (mod) || POINTER_TYPE_P (type))
    1183                 :            :     fv_comp_no_overflow = true;
    1184                 :       4601 :   else if (!exit_must_be_taken)
    1185                 :            :     fv_comp_no_overflow = false;
    1186                 :            :   else
    1187                 :       2535 :     fv_comp_no_overflow =
    1188                 :       2535 :             (iv0->no_overflow && integer_nonzerop (iv0->step))
    1189                 :       2861 :             || (iv1->no_overflow && integer_nonzerop (iv1->step));
    1190                 :            : 
    1191                 :       9463 :   if (integer_nonzerop (iv0->step))
    1192                 :            :     {
    1193                 :            :       /* The final value of the iv is iv1->base + MOD, assuming that this
    1194                 :            :          computation does not overflow, and that
    1195                 :            :          iv0->base <= iv1->base + MOD.  */
    1196                 :       8011 :       if (!fv_comp_no_overflow)
    1197                 :            :         {
    1198                 :       1710 :           bound = fold_build2 (MINUS_EXPR, type1,
    1199                 :            :                                TYPE_MAX_VALUE (type1), tmod);
    1200                 :       1710 :           assumption = fold_build2 (LE_EXPR, boolean_type_node,
    1201                 :            :                                     iv1->base, bound);
    1202                 :       1710 :           if (integer_zerop (assumption))
    1203                 :          0 :             goto end;
    1204                 :            :         }
    1205                 :       8011 :       if (mpz_cmp (mmod, bnds->below) < 0)
    1206                 :       6939 :         noloop = boolean_false_node;
    1207                 :       1072 :       else if (POINTER_TYPE_P (type))
    1208                 :       1025 :         noloop = fold_build2 (GT_EXPR, boolean_type_node,
    1209                 :            :                               iv0->base,
    1210                 :            :                               fold_build_pointer_plus (iv1->base, tmod));
    1211                 :            :       else
    1212                 :         47 :         noloop = fold_build2 (GT_EXPR, boolean_type_node,
    1213                 :            :                               iv0->base,
    1214                 :            :                               fold_build2 (PLUS_EXPR, type1,
    1215                 :            :                                            iv1->base, tmod));
    1216                 :            :     }
    1217                 :            :   else
    1218                 :            :     {
    1219                 :            :       /* The final value of the iv is iv0->base - MOD, assuming that this
    1220                 :            :          computation does not overflow, and that
    1221                 :            :          iv0->base - MOD <= iv1->base. */
    1222                 :       1452 :       if (!fv_comp_no_overflow)
    1223                 :            :         {
    1224                 :        356 :           bound = fold_build2 (PLUS_EXPR, type1,
    1225                 :            :                                TYPE_MIN_VALUE (type1), tmod);
    1226                 :        356 :           assumption = fold_build2 (GE_EXPR, boolean_type_node,
    1227                 :            :                                     iv0->base, bound);
    1228                 :        356 :           if (integer_zerop (assumption))
    1229                 :         43 :             goto end;
    1230                 :            :         }
    1231                 :       1409 :       if (mpz_cmp (mmod, bnds->below) < 0)
    1232                 :       1201 :         noloop = boolean_false_node;
    1233                 :        208 :       else if (POINTER_TYPE_P (type))
    1234                 :        208 :         noloop = fold_build2 (GT_EXPR, boolean_type_node,
    1235                 :            :                               fold_build_pointer_plus (iv0->base,
    1236                 :            :                                                        fold_build1 (NEGATE_EXPR,
    1237                 :            :                                                                     type1, tmod)),
    1238                 :            :                               iv1->base);
    1239                 :            :       else
    1240                 :          0 :         noloop = fold_build2 (GT_EXPR, boolean_type_node,
    1241                 :            :                               fold_build2 (MINUS_EXPR, type1,
    1242                 :            :                                            iv0->base, tmod),
    1243                 :            :                               iv1->base);
    1244                 :            :     }
    1245                 :            : 
    1246                 :       9420 :   if (!integer_nonzerop (assumption))
    1247                 :         33 :     niter->assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
    1248                 :            :                                       niter->assumptions,
    1249                 :            :                                       assumption);
    1250                 :       9420 :   if (!integer_zerop (noloop))
    1251                 :        380 :     niter->may_be_zero = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
    1252                 :            :                                       niter->may_be_zero,
    1253                 :            :                                       noloop);
    1254                 :       9420 :   bounds_add (bnds, wi::to_widest (mod), type);
    1255                 :       9420 :   *delta = fold_build2 (PLUS_EXPR, niter_type, *delta, mod);
    1256                 :            : 
    1257                 :       9420 :   ret = true;
    1258                 :       9463 : end:
    1259                 :       9463 :   mpz_clear (mmod);
    1260                 :       9463 :   return ret;
    1261                 :            : }
    1262                 :            : 
    1263                 :            : /* Add assertions to NITER that ensure that the control variable of the loop
    1264                 :            :    with ending condition IV0 < IV1 does not overflow.  Types of IV0 and IV1
    1265                 :            :    are TYPE.  Returns false if we can prove that there is an overflow, true
    1266                 :            :    otherwise.  STEP is the absolute value of the step.  */
    1267                 :            : 
    1268                 :            : static bool
    1269                 :     201712 : assert_no_overflow_lt (tree type, affine_iv *iv0, affine_iv *iv1,
    1270                 :            :                        class tree_niter_desc *niter, tree step)
    1271                 :            : {
    1272                 :     201712 :   tree bound, d, assumption, diff;
    1273                 :     201712 :   tree niter_type = TREE_TYPE (step);
    1274                 :            : 
    1275                 :     201712 :   if (integer_nonzerop (iv0->step))
    1276                 :            :     {
    1277                 :            :       /* for (i = iv0->base; i < iv1->base; i += iv0->step) */
    1278                 :     169203 :       if (iv0->no_overflow)
    1279                 :            :         return true;
    1280                 :            : 
    1281                 :            :       /* If iv0->base is a constant, we can determine the last value before
    1282                 :            :          overflow precisely; otherwise we conservatively assume
    1283                 :            :          MAX - STEP + 1.  */
    1284                 :            : 
    1285                 :      23862 :       if (TREE_CODE (iv0->base) == INTEGER_CST)
    1286                 :            :         {
    1287                 :       7007 :           d = fold_build2 (MINUS_EXPR, niter_type,
    1288                 :            :                            fold_convert (niter_type, TYPE_MAX_VALUE (type)),
    1289                 :            :                            fold_convert (niter_type, iv0->base));
    1290                 :       7007 :           diff = fold_build2 (FLOOR_MOD_EXPR, niter_type, d, step);
    1291                 :            :         }
    1292                 :            :       else
    1293                 :      16855 :         diff = fold_build2 (MINUS_EXPR, niter_type, step,
    1294                 :            :                             build_int_cst (niter_type, 1));
    1295                 :      23862 :       bound = fold_build2 (MINUS_EXPR, type,
    1296                 :            :                            TYPE_MAX_VALUE (type), fold_convert (type, diff));
    1297                 :      23862 :       assumption = fold_build2 (LE_EXPR, boolean_type_node,
    1298                 :            :                                 iv1->base, bound);
    1299                 :            :     }
    1300                 :            :   else
    1301                 :            :     {
    1302                 :            :       /* for (i = iv1->base; i > iv0->base; i += iv1->step) */
    1303                 :      32509 :       if (iv1->no_overflow)
    1304                 :            :         return true;
    1305                 :            : 
    1306                 :      16935 :       if (TREE_CODE (iv1->base) == INTEGER_CST)
    1307                 :            :         {
    1308                 :         43 :           d = fold_build2 (MINUS_EXPR, niter_type,
    1309                 :            :                            fold_convert (niter_type, iv1->base),
    1310                 :            :                            fold_convert (niter_type, TYPE_MIN_VALUE (type)));
    1311                 :         43 :           diff = fold_build2 (FLOOR_MOD_EXPR, niter_type, d, step);
    1312                 :            :         }
    1313                 :            :       else
    1314                 :      16892 :         diff = fold_build2 (MINUS_EXPR, niter_type, step,
    1315                 :            :                             build_int_cst (niter_type, 1));
    1316                 :      16935 :       bound = fold_build2 (PLUS_EXPR, type,
    1317                 :            :                            TYPE_MIN_VALUE (type), fold_convert (type, diff));
    1318                 :      16935 :       assumption = fold_build2 (GE_EXPR, boolean_type_node,
    1319                 :            :                                 iv0->base, bound);
    1320                 :            :     }
    1321                 :            : 
    1322                 :      40797 :   if (integer_zerop (assumption))
    1323                 :            :     return false;
    1324                 :      40754 :   if (!integer_nonzerop (assumption))
    1325                 :      31356 :     niter->assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
    1326                 :            :                                       niter->assumptions, assumption);
    1327                 :            : 
    1328                 :      40754 :   iv0->no_overflow = true;
    1329                 :      40754 :   iv1->no_overflow = true;
    1330                 :      40754 :   return true;
    1331                 :            : }
    1332                 :            : 
    1333                 :            : /* Add an assumption to NITER that a loop whose ending condition
    1334                 :            :    is IV0 < IV1 rolls.  TYPE is the type of the control iv.  BNDS
    1335                 :            :    bounds the value of IV1->base - IV0->base.  */
    1336                 :            : 
    1337                 :            : static void
    1338                 :     201669 : assert_loop_rolls_lt (tree type, affine_iv *iv0, affine_iv *iv1,
    1339                 :            :                       class tree_niter_desc *niter, bounds *bnds)
    1340                 :            : {
    1341                 :     201669 :   tree assumption = boolean_true_node, bound, diff;
    1342                 :     201669 :   tree mbz, mbzl, mbzr, type1;
    1343                 :     201669 :   bool rolls_p, no_overflow_p;
    1344                 :     201669 :   widest_int dstep;
    1345                 :     201669 :   mpz_t mstep, max;
    1346                 :            : 
    1347                 :            :   /* We are going to compute the number of iterations as
    1348                 :            :      (iv1->base - iv0->base + step - 1) / step, computed in the unsigned
    1349                 :            :      variant of TYPE.  This formula only works if
    1350                 :            : 
    1351                 :            :      -step + 1 <= (iv1->base - iv0->base) <= MAX - step + 1
    1352                 :            : 
    1353                 :            :      (where MAX is the maximum value of the unsigned variant of TYPE, and
    1354                 :            :      the computations in this formula are performed in full precision,
    1355                 :            :      i.e., without overflows).
    1356                 :            : 
    1357                 :            :      Usually, for loops with exit condition iv0->base + step * i < iv1->base,
    1358                 :            :      we have a condition of the form iv0->base - step < iv1->base before the loop,
    1359                 :            :      and for loops iv0->base < iv1->base - step * i the condition
    1360                 :            :      iv0->base < iv1->base + step, due to loop header copying, which enable us
    1361                 :            :      to prove the lower bound.
    1362                 :            : 
    1363                 :            :      The upper bound is more complicated.  Unless the expressions for initial
    1364                 :            :      and final value themselves contain enough information, we usually cannot
    1365                 :            :      derive it from the context.  */
    1366                 :            : 
    1367                 :            :   /* First check whether the answer does not follow from the bounds we gathered
    1368                 :            :      before.  */
    1369                 :     201669 :   if (integer_nonzerop (iv0->step))
    1370                 :     169203 :     dstep = wi::to_widest (iv0->step);
    1371                 :            :   else
    1372                 :            :     {
    1373                 :      32466 :       dstep = wi::sext (wi::to_widest (iv1->step), TYPE_PRECISION (type));
    1374                 :      32466 :       dstep = -dstep;
    1375                 :            :     }
    1376                 :            : 
    1377                 :     201669 :   mpz_init (mstep);
    1378                 :     201669 :   wi::to_mpz (dstep, mstep, UNSIGNED);
    1379                 :     201669 :   mpz_neg (mstep, mstep);
    1380                 :     201669 :   mpz_add_ui (mstep, mstep, 1);
    1381                 :            : 
    1382                 :     201669 :   rolls_p = mpz_cmp (mstep, bnds->below) <= 0;
    1383                 :            : 
    1384                 :     201669 :   mpz_init (max);
    1385                 :     282172 :   wi::to_mpz (wi::minus_one (TYPE_PRECISION (type)), max, UNSIGNED);
    1386                 :     201669 :   mpz_add (max, max, mstep);
    1387                 :     403338 :   no_overflow_p = (mpz_cmp (bnds->up, max) <= 0
    1388                 :            :                    /* For pointers, only values lying inside a single object
    1389                 :            :                       can be compared or manipulated by pointer arithmetics.
    1390                 :            :                       Gcc in general does not allow or handle objects larger
    1391                 :            :                       than half of the address space, hence the upper bound
    1392                 :            :                       is satisfied for pointers.  */
    1393                 :     201669 :                    || POINTER_TYPE_P (type));
    1394                 :     201669 :   mpz_clear (mstep);
    1395                 :     201669 :   mpz_clear (max);
    1396                 :            : 
    1397                 :     201669 :   if (rolls_p && no_overflow_p)
    1398                 :      66186 :     return;
    1399                 :            : 
    1400                 :     135483 :   type1 = type;
    1401                 :     135483 :   if (POINTER_TYPE_P (type))
    1402                 :      38210 :     type1 = sizetype;
    1403                 :            : 
    1404                 :            :   /* Now the hard part; we must formulate the assumption(s) as expressions, and
    1405                 :            :      we must be careful not to introduce overflow.  */
    1406                 :            : 
    1407                 :     135483 :   if (integer_nonzerop (iv0->step))
    1408                 :            :     {
    1409                 :     112034 :       diff = fold_build2 (MINUS_EXPR, type1,
    1410                 :            :                           iv0->step, build_int_cst (type1, 1));
    1411                 :            : 
    1412                 :            :       /* We need to know that iv0->base >= MIN + iv0->step - 1.  Since
    1413                 :            :          0 address never belongs to any object, we can assume this for
    1414                 :            :          pointers.  */
    1415                 :     112034 :       if (!POINTER_TYPE_P (type))
    1416                 :            :         {
    1417                 :      77265 :           bound = fold_build2 (PLUS_EXPR, type1,
    1418                 :            :                                TYPE_MIN_VALUE (type), diff);
    1419                 :      77265 :           assumption = fold_build2 (GE_EXPR, boolean_type_node,
    1420                 :            :                                     iv0->base, bound);
    1421                 :            :         }
    1422                 :            : 
    1423                 :            :       /* And then we can compute iv0->base - diff, and compare it with
    1424                 :            :          iv1->base.  */
    1425                 :     112034 :       mbzl = fold_build2 (MINUS_EXPR, type1,
    1426                 :            :                           fold_convert (type1, iv0->base), diff);
    1427                 :     112034 :       mbzr = fold_convert (type1, iv1->base);
    1428                 :            :     }
    1429                 :            :   else
    1430                 :            :     {
    1431                 :      23449 :       diff = fold_build2 (PLUS_EXPR, type1,
    1432                 :            :                           iv1->step, build_int_cst (type1, 1));
    1433                 :            : 
    1434                 :      23449 :       if (!POINTER_TYPE_P (type))
    1435                 :            :         {
    1436                 :      20008 :           bound = fold_build2 (PLUS_EXPR, type1,
    1437                 :            :                                TYPE_MAX_VALUE (type), diff);
    1438                 :      20008 :           assumption = fold_build2 (LE_EXPR, boolean_type_node,
    1439                 :            :                                     iv1->base, bound);
    1440                 :            :         }
    1441                 :            : 
    1442                 :      23449 :       mbzl = fold_convert (type1, iv0->base);
    1443                 :      23449 :       mbzr = fold_build2 (MINUS_EXPR, type1,
    1444                 :            :                           fold_convert (type1, iv1->base), diff);
    1445                 :            :     }
    1446                 :            : 
    1447                 :     135483 :   if (!integer_nonzerop (assumption))
    1448                 :      50024 :     niter->assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
    1449                 :            :                                       niter->assumptions, assumption);
    1450                 :     135483 :   if (!rolls_p)
    1451                 :            :     {
    1452                 :     128022 :       mbz = fold_build2 (GT_EXPR, boolean_type_node, mbzl, mbzr);
    1453                 :     128022 :       niter->may_be_zero = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
    1454                 :            :                                         niter->may_be_zero, mbz);
    1455                 :            :     }
    1456                 :            : }
    1457                 :            : 
    1458                 :            : /* Determines number of iterations of loop whose ending condition
    1459                 :            :    is IV0 < IV1.  TYPE is the type of the iv.  The number of
    1460                 :            :    iterations is stored to NITER.  BNDS bounds the difference
    1461                 :            :    IV1->base - IV0->base.  EXIT_MUST_BE_TAKEN is true if we know
    1462                 :            :    that the exit must be taken eventually.  */
    1463                 :            : 
    1464                 :            : static bool
    1465                 :    2955800 : number_of_iterations_lt (class loop *loop, tree type, affine_iv *iv0,
    1466                 :            :                          affine_iv *iv1, class tree_niter_desc *niter,
    1467                 :            :                          bool exit_must_be_taken, bounds *bnds)
    1468                 :            : {
    1469                 :    2955800 :   tree niter_type = unsigned_type_for (type);
    1470                 :    2955800 :   tree delta, step, s;
    1471                 :    2955800 :   mpz_t mstep, tmp;
    1472                 :            : 
    1473                 :    2955800 :   if (integer_nonzerop (iv0->step))
    1474                 :            :     {
    1475                 :    2763770 :       niter->control = *iv0;
    1476                 :    2763770 :       niter->cmp = LT_EXPR;
    1477                 :    2763770 :       niter->bound = iv1->base;
    1478                 :            :     }
    1479                 :            :   else
    1480                 :            :     {
    1481                 :     192036 :       niter->control = *iv1;
    1482                 :     192036 :       niter->cmp = GT_EXPR;
    1483                 :     192036 :       niter->bound = iv0->base;
    1484                 :            :     }
    1485                 :            : 
    1486                 :    2955800 :   delta = fold_build2 (MINUS_EXPR, niter_type,
    1487                 :            :                        fold_convert (niter_type, iv1->base),
    1488                 :            :                        fold_convert (niter_type, iv0->base));
    1489                 :            : 
    1490                 :            :   /* First handle the special case that the step is +-1.  */
    1491                 :    5542350 :   if ((integer_onep (iv0->step) && integer_zerop (iv1->step))
    1492                 :    2955800 :       || (integer_all_onesp (iv1->step) && integer_zerop (iv0->step)))
    1493                 :            :     {
    1494                 :            :       /* for (i = iv0->base; i < iv1->base; i++)
    1495                 :            : 
    1496                 :            :          or
    1497                 :            : 
    1498                 :            :          for (i = iv1->base; i > iv0->base; i--).
    1499                 :            : 
    1500                 :            :          In both cases # of iterations is iv1->base - iv0->base, assuming that
    1501                 :            :          iv1->base >= iv0->base.
    1502                 :            : 
    1503                 :            :          First try to derive a lower bound on the value of
    1504                 :            :          iv1->base - iv0->base, computed in full precision.  If the difference
    1505                 :            :          is nonnegative, we are done, otherwise we must record the
    1506                 :            :          condition.  */
    1507                 :            : 
    1508                 :    2744670 :       if (mpz_sgn (bnds->below) < 0)
    1509                 :    1143190 :         niter->may_be_zero = fold_build2 (LT_EXPR, boolean_type_node,
    1510                 :            :                                           iv1->base, iv0->base);
    1511                 :    2744670 :       niter->niter = delta;
    1512                 :    5489340 :       niter->max = widest_int::from (wi::from_mpz (niter_type, bnds->up, false),
    1513                 :    2744670 :                                      TYPE_SIGN (niter_type));
    1514                 :    2744670 :       niter->control.no_overflow = true;
    1515                 :    2744670 :       return true;
    1516                 :            :     }
    1517                 :            : 
    1518                 :     211132 :   if (integer_nonzerop (iv0->step))
    1519                 :     177214 :     step = fold_convert (niter_type, iv0->step);
    1520                 :            :   else
    1521                 :      33918 :     step = fold_convert (niter_type,
    1522                 :            :                          fold_build1 (NEGATE_EXPR, type, iv1->step));
    1523                 :            : 
    1524                 :            :   /* If we can determine the final value of the control iv exactly, we can
    1525                 :            :      transform the condition to != comparison.  In particular, this will be
    1526                 :            :      the case if DELTA is constant.  */
    1527                 :     211132 :   if (number_of_iterations_lt_to_ne (type, iv0, iv1, niter, &delta, step,
    1528                 :            :                                      exit_must_be_taken, bnds))
    1529                 :            :     {
    1530                 :       9420 :       affine_iv zps;
    1531                 :            : 
    1532                 :       9420 :       zps.base = build_int_cst (niter_type, 0);
    1533                 :       9420 :       zps.step = step;
    1534                 :            :       /* number_of_iterations_lt_to_ne will add assumptions that ensure that
    1535                 :            :          zps does not overflow.  */
    1536                 :       9420 :       zps.no_overflow = true;
    1537                 :            : 
    1538                 :       9420 :       return number_of_iterations_ne (loop, type, &zps,
    1539                 :            :                                       delta, niter, true, bnds);
    1540                 :            :     }
    1541                 :            : 
    1542                 :            :   /* Make sure that the control iv does not overflow.  */
    1543                 :     201712 :   if (!assert_no_overflow_lt (type, iv0, iv1, niter, step))
    1544                 :            :     return false;
    1545                 :            : 
    1546                 :            :   /* We determine the number of iterations as (delta + step - 1) / step.  For
    1547                 :            :      this to work, we must know that iv1->base >= iv0->base - step + 1,
    1548                 :            :      otherwise the loop does not roll.  */
    1549                 :     201669 :   assert_loop_rolls_lt (type, iv0, iv1, niter, bnds);
    1550                 :            : 
    1551                 :     201669 :   s = fold_build2 (MINUS_EXPR, niter_type,
    1552                 :            :                    step, build_int_cst (niter_type, 1));
    1553                 :     201669 :   delta = fold_build2 (PLUS_EXPR, niter_type, delta, s);
    1554                 :     201669 :   niter->niter = fold_build2 (FLOOR_DIV_EXPR, niter_type, delta, step);
    1555                 :            : 
    1556                 :     201669 :   mpz_init (mstep);
    1557                 :     201669 :   mpz_init (tmp);
    1558                 :     201669 :   wi::to_mpz (wi::to_wide (step), mstep, UNSIGNED);
    1559                 :     201669 :   mpz_add (tmp, bnds->up, mstep);
    1560                 :     201669 :   mpz_sub_ui (tmp, tmp, 1);
    1561                 :     201669 :   mpz_fdiv_q (tmp, tmp, mstep);
    1562                 :     403338 :   niter->max = widest_int::from (wi::from_mpz (niter_type, tmp, false),
    1563                 :     201669 :                                  TYPE_SIGN (niter_type));
    1564                 :     201669 :   mpz_clear (mstep);
    1565                 :     201669 :   mpz_clear (tmp);
    1566                 :            : 
    1567                 :     201669 :   return true;
    1568                 :            : }
    1569                 :            : 
    1570                 :            : /* Determines number of iterations of loop whose ending condition
    1571                 :            :    is IV0 <= IV1.  TYPE is the type of the iv.  The number of
    1572                 :            :    iterations is stored to NITER.  EXIT_MUST_BE_TAKEN is true if
    1573                 :            :    we know that this condition must eventually become false (we derived this
    1574                 :            :    earlier, and possibly set NITER->assumptions to make sure this
    1575                 :            :    is the case).  BNDS bounds the difference IV1->base - IV0->base.  */
    1576                 :            : 
    1577                 :            : static bool
    1578                 :    1093080 : number_of_iterations_le (class loop *loop, tree type, affine_iv *iv0,
    1579                 :            :                          affine_iv *iv1, class tree_niter_desc *niter,
    1580                 :            :                          bool exit_must_be_taken, bounds *bnds)
    1581                 :            : {
    1582                 :    1093080 :   tree assumption;
    1583                 :    1093080 :   tree type1 = type;
    1584                 :    1093080 :   if (POINTER_TYPE_P (type))
    1585                 :       1242 :     type1 = sizetype;
    1586                 :            : 
    1587                 :            :   /* Say that IV0 is the control variable.  Then IV0 <= IV1 iff
    1588                 :            :      IV0 < IV1 + 1, assuming that IV1 is not equal to the greatest
    1589                 :            :      value of the type.  This we must know anyway, since if it is
    1590                 :            :      equal to this value, the loop rolls forever.  We do not check
    1591                 :            :      this condition for pointer type ivs, as the code cannot rely on
    1592                 :            :      the object to that the pointer points being placed at the end of
    1593                 :            :      the address space (and more pragmatically, TYPE_{MIN,MAX}_VALUE is
    1594                 :            :      not defined for pointers).  */
    1595                 :            : 
    1596                 :    1093080 :   if (!exit_must_be_taken && !POINTER_TYPE_P (type))
    1597                 :            :     {
    1598                 :     330355 :       if (integer_nonzerop (iv0->step))
    1599                 :     304821 :         assumption = fold_build2 (NE_EXPR, boolean_type_node,
    1600                 :            :                                   iv1->base, TYPE_MAX_VALUE (type));
    1601                 :            :       else
    1602                 :      25534 :         assumption = fold_build2 (NE_EXPR, boolean_type_node,
    1603                 :            :                                   iv0->base, TYPE_MIN_VALUE (type));
    1604                 :            : 
    1605                 :     330355 :       if (integer_zerop (assumption))
    1606                 :            :         return false;
    1607                 :     330355 :       if (!integer_nonzerop (assumption))
    1608                 :     135594 :         niter->assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
    1609                 :            :                                           niter->assumptions, assumption);
    1610                 :            :     }
    1611                 :            : 
    1612                 :    1093080 :   if (integer_nonzerop (iv0->step))
    1613                 :            :     {
    1614                 :    1047350 :       if (POINTER_TYPE_P (type))
    1615                 :        630 :         iv1->base = fold_build_pointer_plus_hwi (iv1->base, 1);
    1616                 :            :       else
    1617                 :    1046720 :         iv1->base = fold_build2 (PLUS_EXPR, type1, iv1->base,
    1618                 :            :                                  build_int_cst (type1, 1));
    1619                 :            :     }
    1620                 :      45728 :   else if (POINTER_TYPE_P (type))
    1621                 :        612 :     iv0->base = fold_build_pointer_plus_hwi (iv0->base, -1);
    1622                 :            :   else
    1623                 :      45116 :     iv0->base = fold_build2 (MINUS_EXPR, type1,
    1624                 :            :                              iv0->base, build_int_cst (type1, 1));
    1625                 :            : 
    1626                 :    1093080 :   bounds_add (bnds, 1, type1);
    1627                 :            : 
    1628                 :    1093080 :   return number_of_iterations_lt (loop, type, iv0, iv1, niter, exit_must_be_taken,
    1629                 :    1093080 :                                   bnds);
    1630                 :            : }
    1631                 :            : 
    1632                 :            : /* Dumps description of affine induction variable IV to FILE.  */
    1633                 :            : 
    1634                 :            : static void
    1635                 :      57548 : dump_affine_iv (FILE *file, affine_iv *iv)
    1636                 :            : {
    1637                 :      57548 :   if (!integer_zerop (iv->step))
    1638                 :      28774 :     fprintf (file, "[");
    1639                 :            : 
    1640                 :      57548 :   print_generic_expr (dump_file, iv->base, TDF_SLIM);
    1641                 :            : 
    1642                 :      57548 :   if (!integer_zerop (iv->step))
    1643                 :            :     {
    1644                 :      28774 :       fprintf (file, ", + , ");
    1645                 :      28774 :       print_generic_expr (dump_file, iv->step, TDF_SLIM);
    1646                 :      50983 :       fprintf (file, "]%s", iv->no_overflow ? "(no_overflow)" : "");
    1647                 :            :     }
    1648                 :      57548 : }
    1649                 :            : 
    1650                 :            : /* Given exit condition IV0 CODE IV1 in TYPE, this function adjusts
    1651                 :            :    the condition for loop-until-wrap cases.  For example:
    1652                 :            :      (unsigned){8, -1}_loop < 10        => {0, 1} != 9
    1653                 :            :      10 < (unsigned){0, max - 7}_loop   => {0, 1} != 8
    1654                 :            :    Return true if condition is successfully adjusted.  */
    1655                 :            : 
    1656                 :            : static bool
    1657                 :      26348 : adjust_cond_for_loop_until_wrap (tree type, affine_iv *iv0, tree_code *code,
    1658                 :            :                                  affine_iv *iv1)
    1659                 :            : {
    1660                 :            :   /* Only support simple cases for the moment.  */
    1661                 :      26348 :   if (TREE_CODE (iv0->base) != INTEGER_CST
    1662                 :      12977 :       || TREE_CODE (iv1->base) != INTEGER_CST)
    1663                 :            :     return false;
    1664                 :            : 
    1665                 :       8296 :   tree niter_type = unsigned_type_for (type), high, low;
    1666                 :            :   /* Case: i-- < 10.  */
    1667                 :       8296 :   if (integer_zerop (iv1->step))
    1668                 :            :     {
    1669                 :            :       /* TODO: Should handle case in which abs(step) != 1.  */
    1670                 :       1106 :       if (!integer_minus_onep (iv0->step))
    1671                 :            :         return false;
    1672                 :            :       /* Give up on infinite loop.  */
    1673                 :        865 :       if (*code == LE_EXPR
    1674                 :        865 :           && tree_int_cst_equal (iv1->base, TYPE_MAX_VALUE (type)))
    1675                 :            :         return false;
    1676                 :        865 :       high = fold_build2 (PLUS_EXPR, niter_type,
    1677                 :            :                           fold_convert (niter_type, iv0->base),
    1678                 :            :                           build_int_cst (niter_type, 1));
    1679                 :        865 :       low = fold_convert (niter_type, TYPE_MIN_VALUE (type));
    1680                 :            :     }
    1681                 :       7190 :   else if (integer_zerop (iv0->step))
    1682                 :            :     {
    1683                 :            :       /* TODO: Should handle case in which abs(step) != 1.  */
    1684                 :       7190 :       if (!integer_onep (iv1->step))
    1685                 :            :         return false;
    1686                 :            :       /* Give up on infinite loop.  */
    1687                 :       6629 :       if (*code == LE_EXPR
    1688                 :       6629 :           && tree_int_cst_equal (iv0->base, TYPE_MIN_VALUE (type)))
    1689                 :            :         return false;
    1690                 :       6629 :       high = fold_convert (niter_type, TYPE_MAX_VALUE (type));
    1691                 :       6629 :       low = fold_build2 (MINUS_EXPR, niter_type,
    1692                 :            :                          fold_convert (niter_type, iv1->base),
    1693                 :            :                          build_int_cst (niter_type, 1));
    1694                 :            :     }
    1695                 :            :   else
    1696                 :          0 :     gcc_unreachable ();
    1697                 :            : 
    1698                 :       7494 :   iv0->base = low;
    1699                 :       7494 :   iv0->step = fold_convert (niter_type, integer_one_node);
    1700                 :       7494 :   iv1->base = high;
    1701                 :       7494 :   iv1->step = build_int_cst (niter_type, 0);
    1702                 :       7494 :   *code = NE_EXPR;
    1703                 :       7494 :   return true;
    1704                 :            : }
    1705                 :            : 
    1706                 :            : /* Determine the number of iterations according to condition (for staying
    1707                 :            :    inside loop) which compares two induction variables using comparison
    1708                 :            :    operator CODE.  The induction variable on left side of the comparison
    1709                 :            :    is IV0, the right-hand side is IV1.  Both induction variables must have
    1710                 :            :    type TYPE, which must be an integer or pointer type.  The steps of the
    1711                 :            :    ivs must be constants (or NULL_TREE, which is interpreted as constant zero).
    1712                 :            : 
    1713                 :            :    LOOP is the loop whose number of iterations we are determining.
    1714                 :            : 
    1715                 :            :    ONLY_EXIT is true if we are sure this is the only way the loop could be
    1716                 :            :    exited (including possibly non-returning function calls, exceptions, etc.)
    1717                 :            :    -- in this case we can use the information whether the control induction
    1718                 :            :    variables can overflow or not in a more efficient way.
    1719                 :            : 
    1720                 :            :    if EVERY_ITERATION is true, we know the test is executed on every iteration.
    1721                 :            : 
    1722                 :            :    The results (number of iterations and assumptions as described in
    1723                 :            :    comments at class tree_niter_desc in tree-ssa-loop.h) are stored to NITER.
    1724                 :            :    Returns false if it fails to determine number of iterations, true if it
    1725                 :            :    was determined (possibly with some assumptions).  */
    1726                 :            : 
    1727                 :            : static bool
    1728                 :    6238160 : number_of_iterations_cond (class loop *loop,
    1729                 :            :                            tree type, affine_iv *iv0, enum tree_code code,
    1730                 :            :                            affine_iv *iv1, class tree_niter_desc *niter,
    1731                 :            :                            bool only_exit, bool every_iteration)
    1732                 :            : {
    1733                 :    6238160 :   bool exit_must_be_taken = false, ret;
    1734                 :    6238160 :   bounds bnds;
    1735                 :            : 
    1736                 :            :   /* If the test is not executed every iteration, wrapping may make the test
    1737                 :            :      to pass again. 
    1738                 :            :      TODO: the overflow case can be still used as unreliable estimate of upper
    1739                 :            :      bound.  But we have no API to pass it down to number of iterations code
    1740                 :            :      and, at present, it will not use it anyway.  */
    1741                 :    6238160 :   if (!every_iteration
    1742                 :      70434 :       && (!iv0->no_overflow || !iv1->no_overflow
    1743                 :      59804 :           || code == NE_EXPR || code == EQ_EXPR))
    1744                 :            :     return false;
    1745                 :            : 
    1746                 :            :   /* The meaning of these assumptions is this:
    1747                 :            :      if !assumptions
    1748                 :            :        then the rest of information does not have to be valid
    1749                 :            :      if may_be_zero then the loop does not roll, even if
    1750                 :            :        niter != 0.  */
    1751                 :    6200120 :   niter->assumptions = boolean_true_node;
    1752                 :    6200120 :   niter->may_be_zero = boolean_false_node;
    1753                 :    6200120 :   niter->niter = NULL_TREE;
    1754                 :    6200120 :   niter->max = 0;
    1755                 :    6200120 :   niter->bound = NULL_TREE;
    1756                 :    6200120 :   niter->cmp = ERROR_MARK;
    1757                 :            : 
    1758                 :            :   /* Make < comparison from > ones, and for NE_EXPR comparisons, ensure that
    1759                 :            :      the control variable is on lhs.  */
    1760                 :    6200120 :   if (code == GE_EXPR || code == GT_EXPR
    1761                 :    6200120 :       || (code == NE_EXPR && integer_zerop (iv0->step)))
    1762                 :            :     {
    1763                 :    1745600 :       std::swap (iv0, iv1);
    1764                 :    1745600 :       code = swap_tree_comparison (code);
    1765                 :            :     }
    1766                 :            : 
    1767                 :    6200120 :   if (POINTER_TYPE_P (type))
    1768                 :            :     {
    1769                 :            :       /* Comparison of pointers is undefined unless both iv0 and iv1 point
    1770                 :            :          to the same object.  If they do, the control variable cannot wrap
    1771                 :            :          (as wrap around the bounds of memory will never return a pointer
    1772                 :            :          that would be guaranteed to point to the same object, even if we
    1773                 :            :          avoid undefined behavior by casting to size_t and back).  */
    1774                 :     453836 :       iv0->no_overflow = true;
    1775                 :     453836 :       iv1->no_overflow = true;
    1776                 :            :     }
    1777                 :            : 
    1778                 :            :   /* If the control induction variable does not overflow and the only exit
    1779                 :            :      from the loop is the one that we analyze, we know it must be taken
    1780                 :            :      eventually.  */
    1781                 :    6200120 :   if (only_exit)
    1782                 :            :     {
    1783                 :    3490170 :       if (!integer_zerop (iv0->step) && iv0->no_overflow)
    1784                 :            :         exit_must_be_taken = true;
    1785                 :     815689 :       else if (!integer_zerop (iv1->step) && iv1->no_overflow)
    1786                 :            :         exit_must_be_taken = true;
    1787                 :            :     }
    1788                 :            : 
    1789                 :            :   /* We can handle cases which neither of the sides of the comparison is
    1790                 :            :      invariant:
    1791                 :            : 
    1792                 :            :        {iv0.base, iv0.step} cmp_code {iv1.base, iv1.step}
    1793                 :            :      as if:
    1794                 :            :        {iv0.base, iv0.step - iv1.step} cmp_code {iv1.base, 0}
    1795                 :            : 
    1796                 :            :      provided that either below condition is satisfied:
    1797                 :            : 
    1798                 :            :        a) the test is NE_EXPR;
    1799                 :            :        b) iv0.step - iv1.step is integer and iv0/iv1 don't overflow.
    1800                 :            : 
    1801                 :            :      This rarely occurs in practice, but it is simple enough to manage.  */
    1802                 :    6200120 :   if (!integer_zerop (iv0->step) && !integer_zerop (iv1->step))
    1803                 :            :     {
    1804                 :       4233 :       tree step_type = POINTER_TYPE_P (type) ? sizetype : type;
    1805                 :       4233 :       tree step = fold_binary_to_constant (MINUS_EXPR, step_type,
    1806                 :            :                                            iv0->step, iv1->step);
    1807                 :            : 
    1808                 :            :       /* No need to check sign of the new step since below code takes care
    1809                 :            :          of this well.  */
    1810                 :       4233 :       if (code != NE_EXPR
    1811                 :       3306 :           && (TREE_CODE (step) != INTEGER_CST
    1812                 :       3306 :               || !iv0->no_overflow || !iv1->no_overflow))
    1813                 :            :         return false;
    1814                 :            : 
    1815                 :       2543 :       iv0->step = step;
    1816                 :       2543 :       if (!POINTER_TYPE_P (type))
    1817                 :        543 :         iv0->no_overflow = false;
    1818                 :            : 
    1819                 :       2543 :       iv1->step = build_int_cst (step_type, 0);
    1820                 :       2543 :       iv1->no_overflow = true;
    1821                 :            :     }
    1822                 :            : 
    1823                 :            :   /* If the result of the comparison is a constant,  the loop is weird.  More
    1824                 :            :      precise handling would be possible, but the situation is not common enough
    1825                 :            :      to waste time on it.  */
    1826                 :    6198430 :   if (integer_zerop (iv0->step) && integer_zerop (iv1->step))
    1827                 :            :     return false;
    1828                 :            : 
    1829                 :            :   /* If the loop exits immediately, there is nothing to do.  */
    1830                 :    6120730 :   tree tem = fold_binary (code, boolean_type_node, iv0->base, iv1->base);
    1831                 :    6120730 :   if (tem && integer_zerop (tem))
    1832                 :            :     {
    1833                 :      20313 :       if (!every_iteration)
    1834                 :            :         return false;
    1835                 :      20293 :       niter->niter = build_int_cst (unsigned_type_for (type), 0);
    1836                 :      20293 :       niter->max = 0;
    1837                 :      20293 :       return true;
    1838                 :            :     }
    1839                 :            : 
    1840                 :            :   /* Handle special case loops: while (i-- < 10) and while (10 < i++) by
    1841                 :            :      adjusting iv0, iv1 and code.  */
    1842                 :    6100420 :   if (code != NE_EXPR
    1843                 :    2982150 :       && (tree_int_cst_sign_bit (iv0->step)
    1844                 :    2969030 :           || (!integer_zerop (iv1->step)
    1845                 :     205264 :               && !tree_int_cst_sign_bit (iv1->step)))
    1846                 :    6126760 :       && !adjust_cond_for_loop_until_wrap (type, iv0, &code, iv1))
    1847                 :            :     return false;
    1848                 :            : 
    1849                 :            :   /* OK, now we know we have a senseful loop.  Handle several cases, depending
    1850                 :            :      on what comparison operator is used.  */
    1851                 :    6081560 :   bound_difference (loop, iv1->base, iv0->base, &bnds);
    1852                 :            : 
    1853                 :    6081560 :   if (dump_file && (dump_flags & TDF_DETAILS))
    1854                 :            :     {
    1855                 :      28774 :       fprintf (dump_file,
    1856                 :            :                "Analyzing # of iterations of loop %d\n", loop->num);
    1857                 :            : 
    1858                 :      28774 :       fprintf (dump_file, "  exit condition ");
    1859                 :      28774 :       dump_affine_iv (dump_file, iv0);
    1860                 :      28774 :       fprintf (dump_file, " %s ",
    1861                 :      28774 :                code == NE_EXPR ? "!="
    1862                 :       5875 :                : code == LT_EXPR ? "<"
    1863                 :            :                : "<=");
    1864                 :      28774 :       dump_affine_iv (dump_file, iv1);
    1865                 :      28774 :       fprintf (dump_file, "\n");
    1866                 :            : 
    1867                 :      28774 :       fprintf (dump_file, "  bounds on difference of bases: ");
    1868                 :      28774 :       mpz_out_str (dump_file, 10, bnds.below);
    1869                 :      28774 :       fprintf (dump_file, " ... ");
    1870                 :      28774 :       mpz_out_str (dump_file, 10, bnds.up);
    1871                 :      28774 :       fprintf (dump_file, "\n");
    1872                 :            :     }
    1873                 :            : 
    1874                 :    6081560 :   switch (code)
    1875                 :            :     {
    1876                 :    3125760 :     case NE_EXPR:
    1877                 :    3125760 :       gcc_assert (integer_zerop (iv1->step));
    1878                 :    3125760 :       ret = number_of_iterations_ne (loop, type, iv0, iv1->base, niter,
    1879                 :            :                                      exit_must_be_taken, &bnds);
    1880                 :    3125760 :       break;
    1881                 :            : 
    1882                 :    1862720 :     case LT_EXPR:
    1883                 :    1862720 :       ret = number_of_iterations_lt (loop, type, iv0, iv1, niter,
    1884                 :            :                                      exit_must_be_taken, &bnds);
    1885                 :    1862720 :       break;
    1886                 :            : 
    1887                 :    1093080 :     case LE_EXPR:
    1888                 :    1093080 :       ret = number_of_iterations_le (loop, type, iv0, iv1, niter,
    1889                 :            :                                      exit_must_be_taken, &bnds);
    1890                 :    1093080 :       break;
    1891                 :            : 
    1892                 :          0 :     default:
    1893                 :          0 :       gcc_unreachable ();
    1894                 :            :     }
    1895                 :            : 
    1896                 :    6081560 :   mpz_clear (bnds.up);
    1897                 :    6081560 :   mpz_clear (bnds.below);
    1898                 :            : 
    1899                 :    6081560 :   if (dump_file && (dump_flags & TDF_DETAILS))
    1900                 :            :     {
    1901                 :      28774 :       if (ret)
    1902                 :            :         {
    1903                 :      28774 :           fprintf (dump_file, "  result:\n");
    1904                 :      28774 :           if (!integer_nonzerop (niter->assumptions))
    1905                 :            :             {
    1906                 :         24 :               fprintf (dump_file, "    under assumptions ");
    1907                 :         24 :               print_generic_expr (dump_file, niter->assumptions, TDF_SLIM);
    1908                 :         24 :               fprintf (dump_file, "\n");
    1909                 :            :             }
    1910                 :            : 
    1911                 :      28774 :           if (!integer_zerop (niter->may_be_zero))
    1912                 :            :             {
    1913                 :        544 :               fprintf (dump_file, "    zero if ");
    1914                 :        544 :               print_generic_expr (dump_file, niter->may_be_zero, TDF_SLIM);
    1915                 :        544 :               fprintf (dump_file, "\n");
    1916                 :            :             }
    1917                 :            : 
    1918                 :      28774 :           fprintf (dump_file, "    # of iterations ");
    1919                 :      28774 :           print_generic_expr (dump_file, niter->niter, TDF_SLIM);
    1920                 :      28774 :           fprintf (dump_file, ", bounded by ");
    1921                 :      28774 :           print_decu (niter->max, dump_file);
    1922                 :      28774 :           fprintf (dump_file, "\n");
    1923                 :            :         }
    1924                 :            :       else
    1925                 :          0 :         fprintf (dump_file, "  failed\n\n");
    1926                 :            :     }
    1927                 :            :   return ret;
    1928                 :            : }
    1929                 :            : 
    1930                 :            : /* Substitute NEW_TREE for OLD in EXPR and fold the result.
    1931                 :            :    If VALUEIZE is non-NULL then OLD and NEW_TREE are ignored and instead
    1932                 :            :    all SSA names are replaced with the result of calling the VALUEIZE
    1933                 :            :    function with the SSA name as argument.  */
    1934                 :            : 
    1935                 :            : tree
    1936                 :   40040700 : simplify_replace_tree (tree expr, tree old, tree new_tree,
    1937                 :            :                        tree (*valueize) (tree, void*), void *context,
    1938                 :            :                        bool do_fold)
    1939                 :            : {
    1940                 :   40040700 :   unsigned i, n;
    1941                 :   40040700 :   tree ret = NULL_TREE, e, se;
    1942                 :            : 
    1943                 :   40040700 :   if (!expr)
    1944                 :            :     return NULL_TREE;
    1945                 :            : 
    1946                 :            :   /* Do not bother to replace constants.  */
    1947                 :   22508300 :   if (CONSTANT_CLASS_P (expr))
    1948                 :            :     return expr;
    1949                 :            : 
    1950                 :   17336300 :   if (valueize)
    1951                 :            :     {
    1952                 :      10699 :       if (TREE_CODE (expr) == SSA_NAME)
    1953                 :            :         {
    1954                 :       3918 :           new_tree = valueize (expr, context);
    1955                 :       3918 :           if (new_tree != expr)
    1956                 :            :             return new_tree;
    1957                 :            :         }
    1958                 :            :     }
    1959                 :   17325600 :   else if (expr == old
    1960                 :   17325600 :            || operand_equal_p (expr, old, 0))
    1961                 :     120063 :     return unshare_expr (new_tree);
    1962                 :            : 
    1963                 :   17216200 :   if (!EXPR_P (expr))
    1964                 :            :     return expr;
    1965                 :            : 
    1966                 :    9489730 :   n = TREE_OPERAND_LENGTH (expr);
    1967                 :   26230900 :   for (i = 0; i < n; i++)
    1968                 :            :     {
    1969                 :   16741100 :       e = TREE_OPERAND (expr, i);
    1970                 :   16741100 :       se = simplify_replace_tree (e, old, new_tree, valueize, context, do_fold);
    1971                 :   16741100 :       if (e == se)
    1972                 :   16586800 :         continue;
    1973                 :            : 
    1974                 :     154344 :       if (!ret)
    1975                 :     154195 :         ret = copy_node (expr);
    1976                 :            : 
    1977                 :     154344 :       TREE_OPERAND (ret, i) = se;
    1978                 :            :     }
    1979                 :            : 
    1980                 :    9489730 :   return (ret ? (do_fold ? fold (ret) : ret) : expr);
    1981                 :            : }
    1982                 :            : 
    1983                 :            : /* Expand definitions of ssa names in EXPR as long as they are simple
    1984                 :            :    enough, and return the new expression.  If STOP is specified, stop
    1985                 :            :    expanding if EXPR equals to it.  */
    1986                 :            : 
    1987                 :            : static tree
    1988                 :   72735000 : expand_simple_operations (tree expr, tree stop, hash_map<tree, tree> &cache)
    1989                 :            : {
    1990                 :   72735000 :   unsigned i, n;
    1991                 :   72735000 :   tree ret = NULL_TREE, e, ee, e1;
    1992                 :   72735000 :   enum tree_code code;
    1993                 :   72735000 :   gimple *stmt;
    1994                 :            : 
    1995                 :   72735000 :   if (expr == NULL_TREE)
    1996                 :            :     return expr;
    1997                 :            : 
    1998                 :   72735000 :   if (is_gimple_min_invariant (expr))
    1999                 :            :     return expr;
    2000                 :            : 
    2001                 :   52645400 :   code = TREE_CODE (expr);
    2002                 :   52645400 :   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
    2003                 :            :     {
    2004                 :   13742400 :       n = TREE_OPERAND_LENGTH (expr);
    2005                 :   37883100 :       for (i = 0; i < n; i++)
    2006                 :            :         {
    2007                 :   24140700 :           e = TREE_OPERAND (expr, i);
    2008                 :            :           /* SCEV analysis feeds us with a proper expression
    2009                 :            :              graph matching the SSA graph.  Avoid turning it
    2010                 :            :              into a tree here, thus handle tree sharing
    2011                 :            :              properly.
    2012                 :            :              ???  The SSA walk below still turns the SSA graph
    2013                 :            :              into a tree but until we find a testcase do not
    2014                 :            :              introduce additional tree sharing here.  */
    2015                 :   24140700 :           bool existed_p;
    2016                 :   24140700 :           tree &cee = cache.get_or_insert (e, &existed_p);
    2017                 :   24140700 :           if (existed_p)
    2018                 :     109547 :             ee = cee;
    2019                 :            :           else
    2020                 :            :             {
    2021                 :   24031200 :               cee = e;
    2022                 :   24031200 :               ee = expand_simple_operations (e, stop, cache);
    2023                 :   24031200 :               if (ee != e)
    2024                 :    4442930 :                 *cache.get (e) = ee;
    2025                 :            :             }
    2026                 :   24140700 :           if (e == ee)
    2027                 :   21919100 :             continue;
    2028                 :            : 
    2029                 :    2221650 :           if (!ret)
    2030                 :    2078280 :             ret = copy_node (expr);
    2031                 :            : 
    2032                 :    2221650 :           TREE_OPERAND (ret, i) = ee;
    2033                 :            :         }
    2034                 :            : 
    2035                 :   13742400 :       if (!ret)
    2036                 :            :         return expr;
    2037                 :            : 
    2038                 :    2078280 :       fold_defer_overflow_warnings ();
    2039                 :    2078280 :       ret = fold (ret);
    2040                 :    2078280 :       fold_undefer_and_ignore_overflow_warnings ();
    2041                 :    2078280 :       return ret;
    2042                 :            :     }
    2043                 :            : 
    2044                 :            :   /* Stop if it's not ssa name or the one we don't want to expand.  */
    2045                 :   38903000 :   if (TREE_CODE (expr) != SSA_NAME || expr == stop)
    2046                 :            :     return expr;
    2047                 :            : 
    2048                 :   38756500 :   stmt = SSA_NAME_DEF_STMT (expr);
    2049                 :   38756500 :   if (gimple_code (stmt) == GIMPLE_PHI)
    2050                 :            :     {
    2051                 :   11600800 :       basic_block src, dest;
    2052                 :            : 
    2053                 :   11600800 :       if (gimple_phi_num_args (stmt) != 1)
    2054                 :            :         return expr;
    2055                 :     613746 :       e = PHI_ARG_DEF (stmt, 0);
    2056                 :            : 
    2057                 :            :       /* Avoid propagating through loop exit phi nodes, which
    2058                 :            :          could break loop-closed SSA form restrictions.  */
    2059                 :     613746 :       dest = gimple_bb (stmt);
    2060                 :     613746 :       src = single_pred (dest);
    2061                 :     613746 :       if (TREE_CODE (e) == SSA_NAME
    2062                 :     596812 :           && src->loop_father != dest->loop_father)
    2063                 :            :         return expr;
    2064                 :            : 
    2065                 :     247350 :       return expand_simple_operations (e, stop, cache);
    2066                 :            :     }
    2067                 :   27155700 :   if (gimple_code (stmt) != GIMPLE_ASSIGN)
    2068                 :            :     return expr;
    2069                 :            : 
    2070                 :            :   /* Avoid expanding to expressions that contain SSA names that need
    2071                 :            :      to take part in abnormal coalescing.  */
    2072                 :   24197100 :   ssa_op_iter iter;
    2073                 :   75324200 :   FOR_EACH_SSA_TREE_OPERAND (e, stmt, iter, SSA_OP_USE)
    2074                 :   26930300 :     if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (e))
    2075                 :            :       return expr;
    2076                 :            : 
    2077                 :   24196800 :   e = gimple_assign_rhs1 (stmt);
    2078                 :   24196800 :   code = gimple_assign_rhs_code (stmt);
    2079                 :   24196800 :   if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
    2080                 :            :     {
    2081                 :    9923500 :       if (is_gimple_min_invariant (e))
    2082                 :       3037 :         return e;
    2083                 :            : 
    2084                 :    9920470 :       if (code == SSA_NAME)
    2085                 :     126765 :         return expand_simple_operations (e, stop, cache);
    2086                 :    9793700 :       else if (code == ADDR_EXPR)
    2087                 :            :         {
    2088                 :      15795 :           poly_int64 offset;
    2089                 :      15795 :           tree base = get_addr_base_and_unit_offset (TREE_OPERAND (e, 0),
    2090                 :            :                                                      &offset);
    2091                 :      15795 :           if (base
    2092                 :      14008 :               && TREE_CODE (base) == MEM_REF)
    2093                 :            :             {
    2094                 :      14008 :               ee = expand_simple_operations (TREE_OPERAND (base, 0), stop,
    2095                 :            :                                              cache);
    2096                 :      14008 :               return fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (expr), ee,
    2097                 :            :                                   wide_int_to_tree (sizetype,
    2098                 :            :                                                     mem_ref_offset (base)
    2099                 :            :                                                     + offset));
    2100                 :            :             }
    2101                 :            :         }
    2102                 :            : 
    2103                 :    9779700 :       return expr;
    2104                 :            :     }
    2105                 :            : 
    2106                 :   14273300 :   switch (code)
    2107                 :            :     {
    2108                 :    3137550 :     CASE_CONVERT:
    2109                 :            :       /* Casts are simple.  */
    2110                 :    3137550 :       ee = expand_simple_operations (e, stop, cache);
    2111                 :    3137550 :       return fold_build1 (code, TREE_TYPE (expr), ee);
    2112                 :            : 
    2113                 :    8528410 :     case PLUS_EXPR:
    2114                 :    8528410 :     case MINUS_EXPR:
    2115                 :   17056800 :       if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (expr))
    2116                 :   17054500 :           && TYPE_OVERFLOW_TRAPS (TREE_TYPE (expr)))
    2117                 :            :         return expr;
    2118                 :            :       /* Fallthru.  */
    2119                 :    8871680 :     case POINTER_PLUS_EXPR:
    2120                 :            :       /* And increments and decrements by a constant are simple.  */
    2121                 :    8871680 :       e1 = gimple_assign_rhs2 (stmt);
    2122                 :    8871680 :       if (!is_gimple_min_invariant (e1))
    2123                 :            :         return expr;
    2124                 :            : 
    2125                 :    4333810 :       ee = expand_simple_operations (e, stop, cache);
    2126                 :    4333810 :       return fold_build2 (code, TREE_TYPE (expr), ee, e1);
    2127                 :            : 
    2128                 :            :     default:
    2129                 :            :       return expr;
    2130                 :            :     }
    2131                 :            : }
    2132                 :            : 
    2133                 :            : tree
    2134                 :   40844300 : expand_simple_operations (tree expr, tree stop)
    2135                 :            : {
    2136                 :   40844300 :   hash_map<tree, tree> cache;
    2137                 :   40844300 :   return expand_simple_operations (expr, stop, cache);
    2138                 :            : }
    2139                 :            : 
    2140                 :            : /* Tries to simplify EXPR using the condition COND.  Returns the simplified
    2141                 :            :    expression (or EXPR unchanged, if no simplification was possible).  */
    2142                 :            : 
    2143                 :            : static tree
    2144                 :    5807340 : tree_simplify_using_condition_1 (tree cond, tree expr)
    2145                 :            : {
    2146                 :    5807340 :   bool changed;
    2147                 :    5807340 :   tree e, e0, e1, e2, notcond;
    2148                 :    5807340 :   enum tree_code code = TREE_CODE (expr);
    2149                 :            : 
    2150                 :    5807340 :   if (code == INTEGER_CST)
    2151                 :            :     return expr;
    2152                 :            : 
    2153                 :    5806640 :   if (code == TRUTH_OR_EXPR
    2154                 :    5806640 :       || code == TRUTH_AND_EXPR
    2155                 :    5806640 :       || code == COND_EXPR)
    2156                 :            :     {
    2157                 :      49368 :       changed = false;
    2158                 :            : 
    2159                 :      49368 :       e0 = tree_simplify_using_condition_1 (cond, TREE_OPERAND (expr, 0));
    2160                 :      49368 :       if (TREE_OPERAND (expr, 0) != e0)
    2161                 :        105 :         changed = true;
    2162                 :            : 
    2163                 :      49368 :       e1 = tree_simplify_using_condition_1 (cond, TREE_OPERAND (expr, 1));
    2164                 :      49368 :       if (TREE_OPERAND (expr, 1) != e1)
    2165                 :          0 :         changed = true;
    2166                 :            : 
    2167                 :      49368 :       if (code == COND_EXPR)
    2168                 :            :         {
    2169                 :          0 :           e2 = tree_simplify_using_condition_1 (cond, TREE_OPERAND (expr, 2));
    2170                 :          0 :           if (TREE_OPERAND (expr, 2) != e2)
    2171                 :            :             changed = true;
    2172                 :            :         }
    2173                 :            :       else
    2174                 :            :         e2 = NULL_TREE;
    2175                 :            : 
    2176                 :      49368 :       if (changed)
    2177                 :            :         {
    2178                 :        105 :           if (code == COND_EXPR)
    2179                 :          0 :             expr = fold_build3 (code, boolean_type_node, e0, e1, e2);
    2180                 :            :           else
    2181                 :        105 :             expr = fold_build2 (code, boolean_type_node, e0, e1);
    2182                 :            :         }
    2183                 :            : 
    2184                 :      49368 :       return expr;
    2185                 :            :     }
    2186                 :            : 
    2187                 :            :   /* In case COND is equality, we may be able to simplify EXPR by copy/constant
    2188                 :            :      propagation, and vice versa.  Fold does not handle this, since it is
    2189                 :            :      considered too expensive.  */
    2190                 :    5757270 :   if (TREE_CODE (cond) == EQ_EXPR)
    2191                 :            :     {
    2192                 :    1456900 :       e0 = TREE_OPERAND (cond, 0);
    2193                 :    1456900 :       e1 = TREE_OPERAND (cond, 1);
    2194                 :            : 
    2195                 :            :       /* We know that e0 == e1.  Check whether we cannot simplify expr
    2196                 :            :          using this fact.  */
    2197                 :    1456900 :       e = simplify_replace_tree (expr, e0, e1);
    2198                 :    1456900 :       if (integer_zerop (e) || integer_nonzerop (e))
    2199                 :        369 :         return e;
    2200                 :            : 
    2201                 :    1456530 :       e = simplify_replace_tree (expr, e1, e0);
    2202                 :    1456530 :       if (integer_zerop (e) || integer_nonzerop (e))
    2203                 :        266 :         return e;
    2204                 :            :     }
    2205                 :    5756630 :   if (TREE_CODE (expr) == EQ_EXPR)
    2206                 :            :     {
    2207                 :     742140 :       e0 = TREE_OPERAND (expr, 0);
    2208                 :     742140 :       e1 = TREE_OPERAND (expr, 1);
    2209                 :            : 
    2210                 :            :       /* If e0 == e1 (EXPR) implies !COND, then EXPR cannot be true.  */
    2211                 :     742140 :       e = simplify_replace_tree (cond, e0, e1);
    2212                 :     742140 :       if (integer_zerop (e))
    2213                 :            :         return e;
    2214                 :     736272 :       e = simplify_replace_tree (cond, e1, e0);
    2215                 :     736272 :       if (integer_zerop (e))
    2216                 :            :         return e;
    2217                 :            :     }
    2218                 :    5750770 :   if (TREE_CODE (expr) == NE_EXPR)
    2219                 :            :     {
    2220                 :     642580 :       e0 = TREE_OPERAND (expr, 0);
    2221                 :     642580 :       e1 = TREE_OPERAND (expr, 1);
    2222                 :            : 
    2223                 :            :       /* If e0 == e1 (!EXPR) implies !COND, then EXPR must be true.  */
    2224                 :     642580 :       e = simplify_replace_tree (cond, e0, e1);
    2225                 :     642580 :       if (integer_zerop (e))
    2226                 :      10422 :         return boolean_true_node;
    2227                 :     632158 :       e = simplify_replace_tree (cond, e1, e0);
    2228                 :     632158 :       if (integer_zerop (e))
    2229                 :          0 :         return boolean_true_node;
    2230                 :            :     }
    2231                 :            : 
    2232                 :            :   /* Check whether COND ==> EXPR.  */
    2233                 :    5740340 :   notcond = invert_truthvalue (cond);
    2234                 :    5740340 :   e = fold_binary (TRUTH_OR_EXPR, boolean_type_node, notcond, expr);
    2235                 :    5740340 :   if (e && integer_nonzerop (e))
    2236                 :            :     return e;
    2237                 :            : 
    2238                 :            :   /* Check whether COND ==> not EXPR.  */
    2239                 :    5737110 :   e = fold_binary (TRUTH_AND_EXPR, boolean_type_node, cond, expr);
    2240                 :    5737110 :   if (e && integer_zerop (e))
    2241                 :      14773 :     return e;
    2242                 :            : 
    2243                 :            :   return expr;
    2244                 :            : }
    2245                 :            : 
    2246                 :            : /* Tries to simplify EXPR using the condition COND.  Returns the simplified
    2247                 :            :    expression (or EXPR unchanged, if no simplification was possible).
    2248                 :            :    Wrapper around tree_simplify_using_condition_1 that ensures that chains
    2249                 :            :    of simple operations in definitions of ssa names in COND are expanded,
    2250                 :            :    so that things like casts or incrementing the value of the bound before
    2251                 :            :    the loop do not cause us to fail.  */
    2252                 :            : 
    2253                 :            : static tree
    2254                 :    5708600 : tree_simplify_using_condition (tree cond, tree expr)
    2255                 :            : {
    2256                 :          0 :   cond = expand_simple_operations (cond);
    2257                 :            : 
    2258                 :    5708600 :   return tree_simplify_using_condition_1 (cond, expr);
    2259                 :            : }
    2260                 :            : 
    2261                 :            : /* Tries to simplify EXPR using the conditions on entry to LOOP.
    2262                 :            :    Returns the simplified expression (or EXPR unchanged, if no
    2263                 :            :    simplification was possible).  */
    2264                 :            : 
    2265                 :            : tree
    2266                 :   13272500 : simplify_using_initial_conditions (class loop *loop, tree expr)
    2267                 :            : {
    2268                 :   13272500 :   edge e;
    2269                 :   13272500 :   basic_block bb;
    2270                 :   13272500 :   gimple *stmt;
    2271                 :   13272500 :   tree cond, expanded, backup;
    2272                 :   13272500 :   int cnt = 0;
    2273                 :            : 
    2274                 :   13272500 :   if (TREE_CODE (expr) == INTEGER_CST)
    2275                 :            :     return expr;
    2276                 :            : 
    2277                 :    1834340 :   backup = expanded = expand_simple_operations (expr);
    2278                 :            : 
    2279                 :            :   /* Limit walking the dominators to avoid quadraticness in
    2280                 :            :      the number of BBs times the number of loops in degenerate
    2281                 :            :      cases.  */
    2282                 :    1834340 :   for (bb = loop->header;
    2283                 :   18667500 :        bb != ENTRY_BLOCK_PTR_FOR_FN (cfun) && cnt < MAX_DOMINATORS_TO_WALK;
    2284                 :   16833200 :        bb = get_immediate_dominator (CDI_DOMINATORS, bb))
    2285                 :            :     {
    2286                 :   16868700 :       if (!single_pred_p (bb))
    2287                 :    8731670 :         continue;
    2288                 :    8137030 :       e = single_pred_edge (bb);
    2289                 :            : 
    2290                 :    8137030 :       if (!(e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
    2291                 :    2428420 :         continue;
    2292                 :            : 
    2293                 :    5708600 :       stmt = last_stmt (e->src);
    2294                 :    5708600 :       cond = fold_build2 (gimple_cond_code (stmt),
    2295                 :            :                           boolean_type_node,
    2296                 :            :                           gimple_cond_lhs (stmt),
    2297                 :            :                           gimple_cond_rhs (stmt));
    2298                 :    5708600 :       if (e->flags & EDGE_FALSE_VALUE)
    2299                 :    3308240 :         cond = invert_truthvalue (cond);
    2300                 :    5708600 :       expanded = tree_simplify_using_condition (cond, expanded);
    2301                 :            :       /* Break if EXPR is simplified to const values.  */
    2302                 :    5708600 :       if (expanded
    2303                 :    5708600 :           && (integer_zerop (expanded) || integer_nonzerop (expanded)))
    2304                 :      35529 :         return expanded;
    2305                 :            : 
    2306                 :    5673080 :       ++cnt;
    2307                 :            :     }
    2308                 :            : 
    2309                 :            :   /* Return the original expression if no simplification is done.  */
    2310                 :    1798810 :   return operand_equal_p (backup, expanded, 0) ? expr : expanded;
    2311                 :            : }
    2312                 :            : 
    2313                 :            : /* Tries to simplify EXPR using the evolutions of the loop invariants
    2314                 :            :    in the superloops of LOOP.  Returns the simplified expression
    2315                 :            :    (or EXPR unchanged, if no simplification was possible).  */
    2316                 :            : 
    2317                 :            : static tree
    2318                 :    3227910 : simplify_using_outer_evolutions (class loop *loop, tree expr)
    2319                 :            : {
    2320                 :    3227910 :   enum tree_code code = TREE_CODE (expr);
    2321                 :    3227910 :   bool changed;
    2322                 :    3227910 :   tree e, e0, e1, e2;
    2323                 :            : 
    2324                 :    3227910 :   if (is_gimple_min_invariant (expr))
    2325                 :            :     return expr;
    2326                 :            : 
    2327                 :     788202 :   if (code == TRUTH_OR_EXPR
    2328                 :     788202 :       || code == TRUTH_AND_EXPR
    2329                 :     788202 :       || code == COND_EXPR)
    2330                 :            :     {
    2331                 :       5580 :       changed = false;
    2332                 :            : 
    2333                 :       5580 :       e0 = simplify_using_outer_evolutions (loop, TREE_OPERAND (expr, 0));
    2334                 :       5580 :       if (TREE_OPERAND (expr, 0) != e0)
    2335                 :          0 :         changed = true;
    2336                 :            : 
    2337                 :       5580 :       e1 = simplify_using_outer_evolutions (loop, TREE_OPERAND (expr, 1));
    2338                 :       5580 :       if (TREE_OPERAND (expr, 1) != e1)
    2339                 :          0 :         changed = true;
    2340                 :            : 
    2341                 :       5580 :       if (code == COND_EXPR)
    2342                 :            :         {
    2343                 :          0 :           e2 = simplify_using_outer_evolutions (loop, TREE_OPERAND (expr, 2));
    2344                 :          0 :           if (TREE_OPERAND (expr, 2) != e2)
    2345                 :            :             changed = true;
    2346                 :            :         }
    2347                 :            :       else
    2348                 :            :         e2 = NULL_TREE;
    2349                 :            : 
    2350                 :       5580 :       if (changed)
    2351                 :            :         {
    2352                 :          0 :           if (code == COND_EXPR)
    2353                 :          0 :             expr = fold_build3 (code, boolean_type_node, e0, e1, e2);
    2354                 :            :           else
    2355                 :          0 :             expr = fold_build2 (code, boolean_type_node, e0, e1);
    2356                 :            :         }
    2357                 :            : 
    2358                 :       5580 :       return expr;
    2359                 :            :     }
    2360                 :            : 
    2361                 :     782622 :   e = instantiate_parameters (loop, expr);
    2362                 :     782622 :   if (is_gimple_min_invariant (e))
    2363                 :          0 :     return e;
    2364                 :            : 
    2365                 :            :   return expr;
    2366                 :            : }
    2367                 :            : 
    2368                 :            : /* Returns true if EXIT is the only possible exit from LOOP.  */
    2369                 :            : 
    2370                 :            : bool
    2371                 :    6454780 : loop_only_exit_p (const class loop *loop, basic_block *body, const_edge exit)
    2372                 :            : {
    2373                 :    6454780 :   gimple_stmt_iterator bsi;
    2374                 :    6454780 :   unsigned i;
    2375                 :            : 
    2376                 :    6454780 :   if (exit != single_exit (loop))
    2377                 :            :     return false;
    2378                 :            : 
    2379                 :   21944800 :   for (i = 0; i < loop->num_nodes; i++)
    2380                 :  191011000 :     for (bsi = gsi_start_bb (body[i]); !gsi_end_p (bsi); gsi_next (&bsi))
    2381                 :  155333000 :       if (stmt_can_terminate_bb_p (gsi_stmt (bsi)))
    2382                 :            :         return false;
    2383                 :            : 
    2384                 :            :   return true;
    2385                 :            : }
    2386                 :            : 
    2387                 :            : /* Stores description of number of iterations of LOOP derived from
    2388                 :            :    EXIT (an exit edge of the LOOP) in NITER.  Returns true if some useful
    2389                 :            :    information could be derived (and fields of NITER have meaning described
    2390                 :            :    in comments at class tree_niter_desc declaration), false otherwise.
    2391                 :            :    When EVERY_ITERATION is true, only tests that are known to be executed
    2392                 :            :    every iteration are considered (i.e. only test that alone bounds the loop).
    2393                 :            :    If AT_STMT is not NULL, this function stores LOOP's condition statement in
    2394                 :            :    it when returning true.  */
    2395                 :            : 
    2396                 :            : bool
    2397                 :   13483400 : number_of_iterations_exit_assumptions (class loop *loop, edge exit,
    2398                 :            :                                        class tree_niter_desc *niter,
    2399                 :            :                                        gcond **at_stmt, bool every_iteration,
    2400                 :            :                                        basic_block *body)
    2401                 :            : {
    2402                 :   13483400 :   gimple *last;
    2403                 :   13483400 :   gcond *stmt;
    2404                 :   13483400 :   tree type;
    2405                 :   13483400 :   tree op0, op1;
    2406                 :   13483400 :   enum tree_code code;
    2407                 :   13483400 :   affine_iv iv0, iv1;
    2408                 :   13483400 :   bool safe;
    2409                 :            : 
    2410                 :            :   /* Nothing to analyze if the loop is known to be infinite.  */
    2411                 :   13483400 :   if (loop_constraint_set_p (loop, LOOP_C_INFINITE))
    2412                 :            :     return false;
    2413                 :            : 
    2414                 :   13483000 :   safe = dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src);
    2415                 :            : 
    2416                 :   13483000 :   if (every_iteration && !safe)
    2417                 :            :     return false;
    2418                 :            : 
    2419                 :   12712500 :   niter->assumptions = boolean_false_node;
    2420                 :   12712500 :   niter->control.base = NULL_TREE;
    2421                 :   12712500 :   niter->control.step = NULL_TREE;
    2422                 :   12712500 :   niter->control.no_overflow = false;
    2423                 :   12712500 :   last = last_stmt (exit->src);
    2424                 :   12712500 :   if (!last)
    2425                 :            :     return false;
    2426                 :   12712400 :   stmt = dyn_cast <gcond *> (last);
    2427                 :   10817900 :   if (!stmt)
    2428                 :            :     return false;
    2429                 :            : 
    2430                 :            :   /* We want the condition for staying inside loop.  */
    2431                 :   10817900 :   code = gimple_cond_code (stmt);
    2432                 :   10817900 :   if (exit->flags & EDGE_TRUE_VALUE)
    2433                 :    5488390 :     code = invert_tree_comparison (code, false);
    2434                 :            : 
    2435                 :   10817900 :   switch (code)
    2436                 :            :     {
    2437                 :    8961370 :     case GT_EXPR:
    2438                 :    8961370 :     case GE_EXPR:
    2439                 :    8961370 :     case LT_EXPR:
    2440                 :    8961370 :     case LE_EXPR:
    2441                 :    8961370 :     case NE_EXPR:
    2442                 :    8961370 :       break;
    2443                 :            : 
    2444                 :            :     default:
    2445                 :            :       return false;
    2446                 :            :     }
    2447                 :            : 
    2448                 :    8961370 :   op0 = gimple_cond_lhs (stmt);
    2449                 :    8961370 :   op1 = gimple_cond_rhs (stmt);
    2450                 :    8961370 :   type = TREE_TYPE (op0);
    2451                 :            : 
    2452                 :    8961370 :   if (TREE_CODE (type) != INTEGER_TYPE
    2453                 :    1708640 :       && !POINTER_TYPE_P (type))
    2454                 :            :     return false;
    2455                 :            : 
    2456                 :    8411880 :   tree iv0_niters = NULL_TREE;
    2457                 :   16823800 :   if (!simple_iv_with_niters (loop, loop_containing_stmt (stmt),
    2458                 :            :                               op0, &iv0, safe ? &iv0_niters : NULL, false))
    2459                 :    1809670 :     return number_of_iterations_popcount (loop, exit, code, niter);
    2460                 :    6602210 :   tree iv1_niters = NULL_TREE;
    2461                 :   13204400 :   if (!simple_iv_with_niters (loop, loop_containing_stmt (stmt),
    2462                 :            :                               op1, &iv1, safe ? &iv1_niters : NULL, false))
    2463                 :            :     return false;
    2464                 :            :   /* Give up on complicated case.  */
    2465                 :    6238160 :   if (iv0_niters && iv1_niters)
    2466                 :            :     return false;
    2467                 :            : 
    2468                 :            :   /* We don't want to see undefined signed overflow warnings while
    2469                 :            :      computing the number of iterations.  */
    2470                 :    6238160 :   fold_defer_overflow_warnings ();
    2471                 :            : 
    2472                 :    6238160 :   iv0.base = expand_simple_operations (iv0.base);
    2473                 :    6238160 :   iv1.base = expand_simple_operations (iv1.base);
    2474                 :    6238160 :   bool body_from_caller = true;
    2475                 :    6238160 :   if (!body)
    2476                 :            :     {
    2477                 :    3586100 :       body = get_loop_body (loop);
    2478                 :    3586100 :       body_from_caller = false;
    2479                 :            :     }
    2480                 :    6238160 :   bool only_exit_p = loop_only_exit_p (loop, body, exit);
    2481                 :    6238160 :   if (!body_from_caller)
    2482                 :    3586100 :     free (body);
    2483                 :    6238160 :   if (!number_of_iterations_cond (loop, type, &iv0, code, &iv1, niter,
    2484                 :            :                                   only_exit_p, safe))
    2485                 :            :     {
    2486                 :     136351 :       fold_undefer_and_ignore_overflow_warnings ();
    2487                 :     136351 :       return false;
    2488                 :            :     }
    2489                 :            : 
    2490                 :            :   /* Incorporate additional assumption implied by control iv.  */
    2491                 :    6101810 :   tree iv_niters = iv0_niters ? iv0_niters : iv1_niters;
    2492                 :    6101810 :   if (iv_niters)
    2493                 :            :     {
    2494                 :       2040 :       tree assumption = fold_build2 (LE_EXPR, boolean_type_node, niter->niter,
    2495                 :            :                                      fold_convert (TREE_TYPE (niter->niter),
    2496                 :            :                                                    iv_niters));
    2497                 :            : 
    2498                 :       2040 :       if (!integer_nonzerop (assumption))
    2499                 :       2036 :         niter->assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
    2500                 :            :                                           niter->assumptions, assumption);
    2501                 :            : 
    2502                 :            :       /* Refine upper bound if possible.  */
    2503                 :       2040 :       if (TREE_CODE (iv_niters) == INTEGER_CST
    2504                 :       4080 :           && niter->max > wi::to_widest (iv_niters))
    2505                 :       1358 :         niter->max = wi::to_widest (iv_niters);
    2506                 :            :     }
    2507                 :            : 
    2508                 :            :   /* There is no assumptions if the loop is known to be finite.  */
    2509                 :    6101810 :   if (!integer_zerop (niter->assumptions)
    2510                 :    6101810 :       && loop_constraint_set_p (loop, LOOP_C_FINITE))
    2511                 :        807 :     niter->assumptions = boolean_true_node;
    2512                 :            : 
    2513                 :    6101810 :   if (optimize >= 3)
    2514                 :            :     {
    2515                 :    1072250 :       niter->assumptions = simplify_using_outer_evolutions (loop,
    2516                 :            :                                                             niter->assumptions);
    2517                 :    1072250 :       niter->may_be_zero = simplify_using_outer_evolutions (loop,
    2518                 :            :                                                             niter->may_be_zero);
    2519                 :    1072250 :       niter->niter = simplify_using_outer_evolutions (loop, niter->niter);
    2520                 :            :     }
    2521                 :            : 
    2522                 :    6101810 :   niter->assumptions
    2523                 :    6101810 :           = simplify_using_initial_conditions (loop,
    2524                 :            :                                                niter->assumptions);
    2525                 :    6101810 :   niter->may_be_zero
    2526                 :    6101810 :           = simplify_using_initial_conditions (loop,
    2527                 :            :                                                niter->may_be_zero);
    2528                 :            : 
    2529                 :    6101810 :   fold_undefer_and_ignore_overflow_warnings ();
    2530                 :            : 
    2531                 :            :   /* If NITER has simplified into a constant, update MAX.  */
    2532                 :    6101810 :   if (TREE_CODE (niter->niter) == INTEGER_CST)
    2533                 :    2868830 :     niter->max = wi::to_widest (niter->niter);
    2534                 :            : 
    2535                 :    6101810 :   if (at_stmt)
    2536                 :    6044960 :     *at_stmt = stmt;
    2537                 :            : 
    2538                 :    6101810 :   return (!integer_zerop (niter->assumptions));
    2539                 :            : }
    2540                 :            : 
    2541                 :            : 
    2542                 :            : /* Utility function to check if OP is defined by a stmt
    2543                 :            :    that is a val - 1.  */
    2544                 :            : 
    2545                 :            : static bool
    2546                 :      77252 : ssa_defined_by_minus_one_stmt_p (tree op, tree val)
    2547                 :            : {
    2548                 :      77252 :   gimple *stmt;
    2549                 :      77252 :   return (TREE_CODE (op) == SSA_NAME
    2550                 :      47254 :           && (stmt = SSA_NAME_DEF_STMT (op))
    2551                 :      47254 :           && is_gimple_assign (stmt)
    2552                 :      41713 :           && (gimple_assign_rhs_code (stmt) == PLUS_EXPR)
    2553                 :       2710 :           && val == gimple_assign_rhs1 (stmt)
    2554                 :      77353 :           && integer_minus_onep (gimple_assign_rhs2 (stmt)));
    2555                 :            : }
    2556                 :            : 
    2557                 :            : 
    2558                 :            : /* See if LOOP is a popcout implementation, determine NITER for the loop
    2559                 :            : 
    2560                 :            :    We match:
    2561                 :            :    <bb 2>
    2562                 :            :    goto <bb 4>
    2563                 :            : 
    2564                 :            :    <bb 3>
    2565                 :            :    _1 = b_11 + -1
    2566                 :            :    b_6 = _1 & b_11
    2567                 :            : 
    2568                 :            :    <bb 4>
    2569                 :            :    b_11 = PHI <b_5(D)(2), b_6(3)>
    2570                 :            : 
    2571                 :            :    exit block
    2572                 :            :    if (b_11 != 0)
    2573                 :            :         goto <bb 3>
    2574                 :            :    else
    2575                 :            :         goto <bb 5>
    2576                 :            : 
    2577                 :            :    OR we match copy-header version:
    2578                 :            :    if (b_5 != 0)
    2579                 :            :         goto <bb 3>
    2580                 :            :    else
    2581                 :            :         goto <bb 4>
    2582                 :            : 
    2583                 :            :    <bb 3>
    2584                 :            :    b_11 = PHI <b_5(2), b_6(3)>
    2585                 :            :    _1 = b_11 + -1
    2586                 :            :    b_6 = _1 & b_11
    2587                 :            : 
    2588                 :            :    exit block
    2589                 :            :    if (b_6 != 0)
    2590                 :            :         goto <bb 3>
    2591                 :            :    else
    2592                 :            :         goto <bb 4>
    2593                 :            : 
    2594                 :            :    If popcount pattern, update NITER accordingly.
    2595                 :            :    i.e., set NITER to  __builtin_popcount (b)
    2596                 :            :    return true if we did, false otherwise.
    2597                 :            : 
    2598                 :            :  */
    2599                 :            : 
    2600                 :            : static bool
    2601                 :    1809670 : number_of_iterations_popcount (loop_p loop, edge exit,
    2602                 :            :                                enum tree_code code,
    2603                 :            :                                class tree_niter_desc *niter)
    2604                 :            : {
    2605                 :    1809670 :   bool adjust = true;
    2606                 :    1809670 :   tree iter;
    2607                 :    1809670 :   HOST_WIDE_INT max;
    2608                 :    1809670 :   adjust = true;
    2609                 :    1809670 :   tree fn = NULL_TREE;
    2610                 :            : 
    2611                 :            :   /* Check loop terminating branch is like
    2612                 :            :      if (b != 0).  */
    2613                 :    1809670 :   gimple *stmt = last_stmt (exit->src);
    2614                 :    1809670 :   if (!stmt
    2615                 :    1809670 :       || gimple_code (stmt) != GIMPLE_COND
    2616                 :    1809670 :       || code != NE_EXPR
    2617                 :    1012650 :       || !integer_zerop (gimple_cond_rhs (stmt))
    2618                 :    2564660 :       || TREE_CODE (gimple_cond_lhs (stmt)) != SSA_NAME)
    2619                 :    1054680 :     return false;
    2620                 :            : 
    2621                 :     754987 :   gimple *and_stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (stmt));
    2622                 :            : 
    2623                 :            :   /* Depending on copy-header is performed, feeding PHI stmts might be in
    2624                 :            :      the loop header or loop latch, handle this.  */
    2625                 :     754987 :   if (gimple_code (and_stmt) == GIMPLE_PHI
    2626                 :     214352 :       && gimple_bb (and_stmt) == loop->header
    2627                 :     151489 :       && gimple_phi_num_args (and_stmt) == 2
    2628                 :     906476 :       && (TREE_CODE (gimple_phi_arg_def (and_stmt,
    2629                 :            :                                          loop_latch_edge (loop)->dest_idx))
    2630                 :            :           == SSA_NAME))
    2631                 :            :     {
    2632                 :            :       /* SSA used in exit condition is defined by PHI stmt
    2633                 :            :         b_11 = PHI <b_5(D)(2), b_6(3)>
    2634                 :            :         from the PHI stmt, get the and_stmt
    2635                 :            :         b_6 = _1 & b_11.  */
    2636                 :     149070 :       tree t = gimple_phi_arg_def (and_stmt, loop_latch_edge (loop)->dest_idx);
    2637                 :     149070 :       and_stmt = SSA_NAME_DEF_STMT (t);
    2638                 :     149070 :       adjust = false;
    2639                 :            :     }
    2640                 :            : 
    2641                 :            :   /* Make sure it is indeed an and stmt (b_6 = _1 & b_11).  */
    2642                 :     754987 :   if (!is_gimple_assign (and_stmt)
    2643                 :     754987 :       || gimple_assign_rhs_code (and_stmt) != BIT_AND_EXPR)
    2644                 :            :     return false;
    2645                 :            : 
    2646                 :      38656 :   tree b_11 = gimple_assign_rhs1 (and_stmt);
    2647                 :      38656 :   tree _1 = gimple_assign_rhs2 (and_stmt);
    2648                 :            : 
    2649                 :            :   /* Check that _1 is defined by _b11 + -1 (_1 = b_11 + -1).
    2650                 :            :      Also make sure that b_11 is the same in and_stmt and _1 defining stmt.
    2651                 :            :      Also canonicalize if _1 and _b11 are revrsed.  */
    2652                 :      38656 :   if (ssa_defined_by_minus_one_stmt_p (b_11, _1))
    2653                 :        101 :     std::swap (b_11, _1);
    2654                 :      38596 :   else if (ssa_defined_by_minus_one_stmt_p (_1, b_11))
    2655                 :            :     ;
    2656                 :            :   else
    2657                 :            :     return false;
    2658                 :            :   /* Check the recurrence:
    2659                 :            :    ... = PHI <b_5(2), b_6(3)>.  */
    2660                 :        101 :   gimple *phi = SSA_NAME_DEF_STMT (b_11);
    2661                 :        101 :   if (gimple_code (phi) != GIMPLE_PHI
    2662                 :         99 :       || (gimple_bb (phi) != loop_latch_edge (loop)->dest)
    2663                 :        101 :       || (gimple_assign_lhs (and_stmt)
    2664                 :         86 :           != gimple_phi_arg_def (phi, loop_latch_edge (loop)->dest_idx)))
    2665                 :         17 :     return false;
    2666                 :            : 
    2667                 :            :   /* We found a match. Get the corresponding popcount builtin.  */
    2668                 :         84 :   tree src = gimple_phi_arg_def (phi, loop_preheader_edge (loop)->dest_idx);
    2669                 :         84 :   if (TYPE_PRECISION (TREE_TYPE (src)) == TYPE_PRECISION (integer_type_node))
    2670                 :         36 :     fn = builtin_decl_implicit (BUILT_IN_POPCOUNT);
    2671                 :         48 :   else if (TYPE_PRECISION (TREE_TYPE (src)) == TYPE_PRECISION
    2672                 :            :            (long_integer_type_node))
    2673                 :         48 :     fn = builtin_decl_implicit (BUILT_IN_POPCOUNTL);
    2674                 :          0 :   else if (TYPE_PRECISION (TREE_TYPE (src)) == TYPE_PRECISION
    2675                 :            :            (long_long_integer_type_node))
    2676                 :          0 :     fn = builtin_decl_implicit (BUILT_IN_POPCOUNTLL);
    2677                 :            : 
    2678                 :            :   /* ??? Support promoting char/short to int.  */
    2679                 :         84 :   if (!fn)
    2680                 :            :     return false;
    2681                 :            : 
    2682                 :            :   /* Update NITER params accordingly  */
    2683                 :         84 :   tree utype = unsigned_type_for (TREE_TYPE (src));
    2684                 :         84 :   src = fold_convert (utype, src);
    2685                 :         84 :   tree call = fold_convert (utype, build_call_expr (fn, 1, src));
    2686                 :         84 :   if (adjust)
    2687                 :         57 :     iter = fold_build2 (MINUS_EXPR, utype,
    2688                 :            :                         call,
    2689                 :            :                         build_int_cst (utype, 1));
    2690                 :            :   else
    2691                 :            :     iter = call;
    2692                 :            : 
    2693                 :         84 :   if (TREE_CODE (call) == INTEGER_CST)
    2694                 :         44 :     max = tree_to_uhwi (call);
    2695                 :            :   else
    2696                 :         40 :     max = TYPE_PRECISION (TREE_TYPE (src));
    2697                 :         84 :   if (adjust)
    2698                 :         57 :     max = max - 1;
    2699                 :            : 
    2700                 :         84 :   niter->niter = iter;
    2701                 :         84 :   niter->assumptions = boolean_true_node;
    2702                 :            : 
    2703                 :         84 :   if (adjust)
    2704                 :            :     {
    2705                 :         57 :       tree may_be_zero = fold_build2 (EQ_EXPR, boolean_type_node, src,
    2706                 :            :                                       build_zero_cst
    2707                 :            :                                       (TREE_TYPE (src)));
    2708                 :         57 :       niter->may_be_zero =
    2709                 :         57 :         simplify_using_initial_conditions (loop, may_be_zero);
    2710                 :            :     }
    2711                 :            :   else
    2712                 :         27 :     niter->may_be_zero = boolean_false_node;
    2713                 :            : 
    2714                 :         84 :   niter->max = max;
    2715                 :         84 :   niter->bound = NULL_TREE;
    2716                 :         84 :   niter->cmp = ERROR_MARK;
    2717                 :         84 :   return true;
    2718                 :            : }
    2719                 :            : 
    2720                 :            : 
    2721                 :            : /* Like number_of_iterations_exit_assumptions, but return TRUE only if
    2722                 :            :    the niter information holds unconditionally.  */
    2723                 :            : 
    2724                 :            : bool
    2725                 :   13422200 : number_of_iterations_exit (class loop *loop, edge exit,
    2726                 :            :                            class tree_niter_desc *niter,
    2727                 :            :                            bool warn, bool every_iteration,
    2728                 :            :                            basic_block *body)
    2729                 :            : {
    2730                 :   13422200 :   gcond *stmt;
    2731                 :   13422200 :   if (!number_of_iterations_exit_assumptions (loop, exit, niter,
    2732                 :            :                                               &stmt, every_iteration, body))
    2733                 :            :     return false;
    2734                 :            : 
    2735                 :    6043040 :   if (integer_nonzerop (niter->assumptions))
    2736                 :            :     return true;
    2737                 :            : 
    2738                 :     450723 :   if (warn && dump_enabled_p ())
    2739                 :          5 :     dump_printf_loc (MSG_MISSED_OPTIMIZATION, stmt,
    2740                 :            :                      "missed loop optimization: niters analysis ends up "
    2741                 :            :                      "with assumptions.\n");
    2742                 :            : 
    2743                 :            :   return false;
    2744                 :            : }
    2745                 :            : 
    2746                 :            : /* Try to determine the number of iterations of LOOP.  If we succeed,
    2747                 :            :    expression giving number of iterations is returned and *EXIT is
    2748                 :            :    set to the edge from that the information is obtained.  Otherwise
    2749                 :            :    chrec_dont_know is returned.  */
    2750                 :            : 
    2751                 :            : tree
    2752                 :     441281 : find_loop_niter (class loop *loop, edge *exit)
    2753                 :            : {
    2754                 :     441281 :   unsigned i;
    2755                 :     441281 :   vec<edge> exits = get_loop_exit_edges (loop);
    2756                 :     441281 :   edge ex;
    2757                 :     441281 :   tree niter = NULL_TREE, aniter;
    2758                 :     441281 :   class tree_niter_desc desc;
    2759                 :            : 
    2760                 :     441281 :   *exit = NULL;
    2761                 :    2075050 :   FOR_EACH_VEC_ELT (exits, i, ex)
    2762                 :            :     {
    2763                 :    1633770 :       if (!number_of_iterations_exit (loop, ex, &desc, false))
    2764                 :    1333530 :         continue;
    2765                 :            : 
    2766                 :     300241 :       if (integer_nonzerop (desc.may_be_zero))
    2767                 :            :         {
    2768                 :            :           /* We exit in the first iteration through this exit.
    2769                 :            :              We won't find anything better.  */
    2770                 :          1 :           niter = build_int_cst (unsigned_type_node, 0);
    2771                 :          1 :           *exit = ex;
    2772                 :          1 :           break;
    2773                 :            :         }
    2774                 :            : 
    2775                 :     300240 :       if (!integer_zerop (desc.may_be_zero))
    2776                 :      34457 :         continue;
    2777                 :            : 
    2778                 :     265783 :       aniter = desc.niter;
    2779                 :            : 
    2780                 :     265783 :       if (!niter)
    2781                 :            :         {
    2782                 :            :           /* Nothing recorded yet.  */
    2783                 :     259299 :           niter = aniter;
    2784                 :     259299 :           *exit = ex;
    2785                 :     259299 :           continue;
    2786                 :            :         }
    2787                 :            : 
    2788                 :            :       /* Prefer constants, the lower the better.  */
    2789                 :       6484 :       if (TREE_CODE (aniter) != INTEGER_CST)
    2790                 :       4595 :         continue;
    2791                 :            : 
    2792                 :       1889 :       if (TREE_CODE (niter) != INTEGER_CST)
    2793                 :            :         {
    2794                 :       1368 :           niter = aniter;
    2795                 :       1368 :           *exit = ex;
    2796                 :       1368 :           continue;
    2797                 :            :         }
    2798                 :            : 
    2799                 :        521 :       if (tree_int_cst_lt (aniter, niter))
    2800                 :            :         {
    2801                 :        154 :           niter = aniter;
    2802                 :        154 :           *exit = ex;
    2803                 :        154 :           continue;
    2804                 :            :         }
    2805                 :            :     }
    2806                 :     441281 :   exits.release ();
    2807                 :            : 
    2808                 :     441281 :   return niter ? niter : chrec_dont_know;
    2809                 :            : }
    2810                 :            : 
    2811                 :            : /* Return true if loop is known to have bounded number of iterations.  */
    2812                 :            : 
    2813                 :            : bool
    2814                 :    1298520 : finite_loop_p (class loop *loop)
    2815                 :            : {
    2816                 :    1298520 :   widest_int nit;
    2817                 :    1298520 :   int flags;
    2818                 :            : 
    2819                 :    1298520 :   flags = flags_from_decl_or_type (current_function_decl);
    2820                 :    1298520 :   if ((flags & (ECF_CONST|ECF_PURE)) && !(flags & ECF_LOOPING_CONST_OR_PURE))
    2821                 :            :     {
    2822                 :      14632 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2823                 :          0 :         fprintf (dump_file, "Found loop %i to be finite: it is within pure or const function.\n",
    2824                 :            :                  loop->num);
    2825                 :      14632 :       return true;
    2826                 :            :     }
    2827                 :            : 
    2828                 :    1283890 :   if (loop->any_upper_bound
    2829                 :    1283890 :       || max_loop_iterations (loop, &nit))
    2830                 :            :     {
    2831                 :     889252 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2832                 :         13 :         fprintf (dump_file, "Found loop %i to be finite: upper bound found.\n",
    2833                 :            :                  loop->num);
    2834                 :     889252 :       return true;
    2835                 :            :     }
    2836                 :            : 
    2837                 :     394639 :   if (loop->finite_p)
    2838                 :            :     {
    2839                 :     140277 :       unsigned i;
    2840                 :     140277 :       vec<edge> exits = get_loop_exit_edges (loop);
    2841                 :     140277 :       edge ex;
    2842                 :            : 
    2843                 :            :       /* If the loop has a normal exit, we can assume it will terminate.  */
    2844                 :     155209 :       FOR_EACH_VEC_ELT (exits, i, ex)
    2845                 :     151301 :         if (!(ex->flags & (EDGE_EH | EDGE_ABNORMAL | EDGE_FAKE)))
    2846                 :            :           {
    2847                 :     136369 :             exits.release ();
    2848                 :     136369 :             if (dump_file)
    2849                 :          5 :               fprintf (dump_file, "Assume loop %i to be finite: it has an exit "
    2850                 :            :                        "and -ffinite-loops is on.\n", loop->num);
    2851                 :     136369 :             return true;
    2852                 :            :           }
    2853                 :            : 
    2854                 :       3908 :       exits.release ();
    2855                 :            :     }
    2856                 :            : 
    2857                 :            :   return false;
    2858                 :            : }
    2859                 :            : 
    2860                 :            : /*
    2861                 :            : 
    2862                 :            :    Analysis of a number of iterations of a loop by a brute-force evaluation.
    2863                 :            : 
    2864                 :            : */
    2865                 :            : 
    2866                 :            : /* Bound on the number of iterations we try to evaluate.  */
    2867                 :            : 
    2868                 :            : #define MAX_ITERATIONS_TO_TRACK \
    2869                 :            :   ((unsigned) param_max_iterations_to_track)
    2870                 :            : 
    2871                 :            : /* Returns the loop phi node of LOOP such that ssa name X is derived from its
    2872                 :            :    result by a chain of operations such that all but exactly one of their
    2873                 :            :    operands are constants.  */
    2874                 :            : 
    2875                 :            : static gphi *
    2876                 :     805415 : chain_of_csts_start (class loop *loop, tree x)
    2877                 :            : {
    2878                 :     990608 :   gimple *stmt = SSA_NAME_DEF_STMT (x);
    2879                 :     990608 :   tree use;
    2880                 :     990608 :   basic_block bb = gimple_bb (stmt);
    2881                 :     990608 :   enum tree_code code;
    2882                 :            : 
    2883                 :     990608 :   if (!bb
    2884                 :     990608 :       || !flow_bb_inside_loop_p (loop, bb))
    2885                 :     226467 :     return NULL;
    2886                 :            : 
    2887                 :     764141 :   if (gimple_code (stmt) == GIMPLE_PHI)
    2888                 :            :     {
    2889                 :     290347 :       if (bb == loop->header)
    2890                 :     805415 :         return as_a <gphi *> (stmt);
    2891                 :            : 
    2892                 :      26160 :       return NULL;
    2893                 :            :     }
    2894                 :            : 
    2895                 :     473794 :   if (gimple_code (stmt) != GIMPLE_ASSIGN
    2896                 :     894710 :       || gimple_assign_rhs_class (stmt) == GIMPLE_TERNARY_RHS)
    2897                 :            :     return NULL;
    2898                 :            : 
    2899                 :     420888 :   code = gimple_assign_rhs_code (stmt);
    2900                 :     420888 :   if (gimple_references_memory_p (stmt)
    2901                 :     251726 :       || TREE_CODE_CLASS (code) == tcc_reference
    2902                 :     237794 :       || (code == ADDR_EXPR
    2903                 :        435 :           && !is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
    2904                 :     183529 :     return NULL;
    2905                 :            : 
    2906                 :     237359 :   use = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_USE);
    2907                 :     237359 :   if (use == NULL_TREE)
    2908                 :            :     return NULL;
    2909                 :            : 
    2910                 :            :   return chain_of_csts_start (loop, use);
    2911                 :            : }
    2912                 :            : 
    2913                 :            : /* Determines whether the expression X is derived from a result of a phi node
    2914                 :            :    in header of LOOP such that
    2915                 :            : 
    2916                 :            :    * the derivation of X consists only from operations with constants
    2917                 :            :    * the initial value of the phi node is constant
    2918                 :            :    * the value of the phi node in the next iteration can be derived from the
    2919                 :            :      value in the current iteration by a chain of operations with constants,
    2920                 :            :      or is also a constant
    2921                 :            : 
    2922                 :            :    If such phi node exists, it is returned, otherwise NULL is returned.  */
    2923                 :            : 
    2924                 :            : static gphi *
    2925                 :     726778 : get_base_for (class loop *loop, tree x)
    2926                 :            : {
    2927                 :     726778 :   gphi *phi;
    2928                 :     726778 :   tree init, next;
    2929                 :            : 
    2930                 :     726778 :   if (is_gimple_min_invariant (x))
    2931                 :            :     return NULL;
    2932                 :            : 
    2933                 :     726778 :   phi = chain_of_csts_start (loop, x);
    2934                 :     726778 :   if (!phi)
    2935                 :            :     return NULL;
    2936                 :            : 
    2937                 :     191363 :   init = PHI_ARG_DEF_FROM_EDGE (phi, loop_preheader_edge (loop));
    2938                 :     191363 :   next = PHI_ARG_DEF_FROM_EDGE (phi, loop_latch_edge (loop));
    2939                 :            : 
    2940                 :     191363 :   if (!is_gimple_min_invariant (init))
    2941                 :            :     return NULL;
    2942                 :            : 
    2943                 :      84558 :   if (TREE_CODE (next) == SSA_NAME
    2944                 :      84558 :       && chain_of_csts_start (loop, next) != phi)
    2945                 :       5836 :     return NULL;
    2946                 :            : 
    2947                 :            :   return phi;
    2948                 :            : }
    2949                 :            : 
    2950                 :            : /* Given an expression X, then
    2951                 :            : 
    2952                 :            :    * if X is NULL_TREE, we return the constant BASE.
    2953                 :            :    * if X is a constant, we return the constant X.
    2954                 :            :    * otherwise X is a SSA name, whose value in the considered loop is derived
    2955                 :            :      by a chain of operations with constant from a result of a phi node in
    2956                 :            :      the header of the loop.  Then we return value of X when the value of the
    2957                 :            :      result of this phi node is given by the constant BASE.  */
    2958                 :            : 
    2959                 :            : static tree
    2960                 :    9711570 : get_val_for (tree x, tree base)
    2961                 :            : {
    2962                 :    9741050 :   gimple *stmt;
    2963                 :            : 
    2964                 :    9741050 :   gcc_checking_assert (is_gimple_min_invariant (base));
    2965                 :            : 
    2966                 :    9741050 :   if (!x)
    2967                 :            :     return base;
    2968                 :    6757710 :   else if (is_gimple_min_invariant (x))
    2969                 :            :     return x;
    2970                 :            : 
    2971                 :    6751840 :   stmt = SSA_NAME_DEF_STMT (x);
    2972                 :    6751840 :   if (gimple_code (stmt) == GIMPLE_PHI)
    2973                 :            :     return base;
    2974                 :            : 
    2975                 :    3415180 :   gcc_checking_assert (is_gimple_assign (stmt));
    2976                 :            : 
    2977                 :            :   /* STMT must be either an assignment of a single SSA name or an
    2978                 :            :      expression involving an SSA name and a constant.  Try to fold that
    2979                 :            :      expression using the value for the SSA name.  */
    2980                 :    3415180 :   if (gimple_assign_ssa_name_copy_p (stmt))
    2981                 :      29485 :     return get_val_for (gimple_assign_rhs1 (stmt), base);
    2982                 :    3385700 :   else if (gimple_assign_rhs_class (stmt) == GIMPLE_UNARY_RHS
    2983                 :    3480940 :            && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
    2984                 :      95244 :     return fold_build1 (gimple_assign_rhs_code (stmt),
    2985                 :            :                         gimple_expr_type (stmt),
    2986                 :            :                         get_val_for (gimple_assign_rhs1 (stmt), base));
    2987                 :    3290450 :   else if (gimple_assign_rhs_class (stmt) == GIMPLE_BINARY_RHS)
    2988                 :            :     {
    2989                 :    3290450 :       tree rhs1 = gimple_assign_rhs1 (stmt);
    2990                 :    3290450 :       tree rhs2 = gimple_assign_rhs2 (stmt);
    2991                 :    3290450 :       if (TREE_CODE (rhs1) == SSA_NAME)
    2992                 :    3266530 :         rhs1 = get_val_for (rhs1, base);
    2993                 :      23925 :       else if (TREE_CODE (rhs2) == SSA_NAME)
    2994                 :      23925 :         rhs2 = get_val_for (rhs2, base);
    2995                 :            :       else
    2996                 :          0 :         gcc_unreachable ();
    2997                 :    3290450 :       return fold_build2 (gimple_assign_rhs_code (stmt),
    2998                 :            :                           gimple_expr_type (stmt), rhs1, rhs2);
    2999                 :            :     }
    3000                 :            :   else
    3001                 :          0 :     gcc_unreachable ();
    3002                 :            : }
    3003                 :            : 
    3004                 :            : 
    3005                 :            : /* Tries to count the number of iterations of LOOP till it exits by EXIT
    3006                 :            :    by brute force -- i.e. by determining the value of the operands of the
    3007                 :            :    condition at EXIT in first few iterations of the loop (assuming that
    3008                 :            :    these values are constant) and determining the first one in that the
    3009                 :            :    condition is not satisfied.  Returns the constant giving the number
    3010                 :            :    of the iterations of LOOP if successful, chrec_dont_know otherwise.  */
    3011                 :            : 
    3012                 :            : tree
    3013                 :     714602 : loop_niter_by_eval (class loop *loop, edge exit)
    3014                 :            : {
    3015                 :     714602 :   tree acnd;
    3016                 :     714602 :   tree op[2], val[2], next[2], aval[2];
    3017                 :     714602 :   gphi *phi;
    3018                 :     714602 :   gimple *cond;
    3019                 :     714602 :   unsigned i, j;
    3020                 :     714602 :   enum tree_code cmp;
    3021                 :            : 
    3022                 :     714602 :   cond = last_stmt (exit->src);
    3023                 :     714602 :   if (!cond || gimple_code (cond) != GIMPLE_COND)
    3024                 :      56577 :     return chrec_dont_know;
    3025                 :            : 
    3026                 :     658025 :   cmp = gimple_cond_code (cond);
    3027                 :     658025 :   if (exit->flags & EDGE_TRUE_VALUE)
    3028                 :     315131 :     cmp = invert_tree_comparison (cmp, false);
    3029                 :            : 
    3030                 :     658025 :   switch (cmp)
    3031                 :            :     {
    3032                 :     658014 :     case EQ_EXPR:
    3033                 :     658014 :     case NE_EXPR:
    3034                 :     658014 :     case GT_EXPR:
    3035                 :     658014 :     case GE_EXPR:
    3036                 :     658014 :     case LT_EXPR:
    3037                 :     658014 :     case LE_EXPR:
    3038                 :     658014 :       op[0] = gimple_cond_lhs (cond);
    3039                 :     658014 :       op[1] = gimple_cond_rhs (cond);
    3040                 :     658014 :       break;
    3041                 :            : 
    3042                 :         11 :     default:
    3043                 :         11 :       return chrec_dont_know;
    3044                 :            :     }
    3045                 :            : 
    3046                 :     747662 :   for (j = 0; j < 2; j++)
    3047                 :            :     {
    3048                 :     737704 :       if (is_gimple_min_invariant (op[j]))
    3049                 :            :         {
    3050                 :      10926 :           val[j] = op[j];
    3051                 :      10926 :           next[j] = NULL_TREE;
    3052                 :      10926 :           op[j] = NULL_TREE;
    3053                 :            :         }
    3054                 :            :       else
    3055                 :            :         {
    3056                 :     726778 :           phi = get_base_for (loop, op[j]);
    3057                 :     726778 :           if (!phi)
    3058                 :     648056 :             return chrec_dont_know;
    3059                 :      78722 :           val[j] = PHI_ARG_DEF_FROM_EDGE (phi, loop_preheader_edge (loop));
    3060                 :      78722 :           next[j] = PHI_ARG_DEF_FROM_EDGE (phi, loop_latch_edge (loop));
    3061                 :            :         }
    3062                 :            :     }
    3063                 :            : 
    3064                 :            :   /* Don't issue signed overflow warnings.  */
    3065                 :       9958 :   fold_defer_overflow_warnings ();
    3066                 :            : 
    3067                 :    1586940 :   for (i = 0; i < MAX_ITERATIONS_TO_TRACK; i++)
    3068                 :            :     {
    3069                 :    4756730 :       for (j = 0; j < 2; j++)
    3070                 :    3171150 :         aval[j] = get_val_for (op[j], val[j]);
    3071                 :            : 
    3072                 :    1585580 :       acnd = fold_binary (cmp, boolean_type_node, aval[0], aval[1]);
    3073                 :    1585580 :       if (acnd && integer_zerop (acnd))
    3074                 :            :         {
    3075                 :       8012 :           fold_undefer_and_ignore_overflow_warnings ();
    3076                 :       8012 :           if (dump_file && (dump_flags & TDF_DETAILS))
    3077                 :          3 :             fprintf (dump_file,
    3078                 :            :                      "Proved that loop %d iterates %d times using brute force.\n",
    3079                 :            :                      loop->num, i);
    3080                 :       8012 :           return build_int_cst (unsigned_type_node, i);
    3081                 :            :         }
    3082                 :            : 
    3083                 :    4731790 :       for (j = 0; j < 2; j++)
    3084                 :            :         {
    3085                 :    3154710 :           aval[j] = val[j];
    3086                 :    3154710 :           val[j] = get_val_for (next[j], val[j]);
    3087                 :    3154710 :           if (!is_gimple_min_invariant (val[j]))
    3088                 :            :             {
    3089                 :        490 :               fold_undefer_and_ignore_overflow_warnings ();
    3090                 :        490 :               return chrec_dont_know;
    3091                 :            :             }
    3092                 :            :         }
    3093                 :            : 
    3094                 :            :       /* If the next iteration would use the same base values
    3095                 :            :          as the current one, there is no point looping further,
    3096                 :            :          all following iterations will be the same as this one.  */
    3097                 :    1577080 :       if (val[0] == aval[0] && val[1] == aval[1])
    3098                 :            :         break;
    3099                 :            :     }
    3100                 :            : 
    3101                 :       1456 :   fold_undefer_and_ignore_overflow_warnings ();
    3102                 :            : 
    3103                 :       1456 :   return chrec_dont_know;
    3104                 :            : }
    3105                 :            : 
    3106                 :            : /* Finds the exit of the LOOP by that the loop exits after a constant
    3107                 :            :    number of iterations and stores the exit edge to *EXIT.  The constant
    3108                 :            :    giving the number of iterations of LOOP is returned.  The number of
    3109                 :            :    iterations is determined using loop_niter_by_eval (i.e. by brute force
    3110                 :            :    evaluation).  If we are unable to find the exit for that loop_niter_by_eval
    3111                 :            :    determines the number of iterations, chrec_dont_know is returned.  */
    3112                 :            : 
    3113                 :            : tree
    3114                 :     240795 : find_loop_niter_by_eval (class loop *loop, edge *exit)
    3115                 :            : {
    3116                 :     240795 :   unsigned i;
    3117                 :     240795 :   vec<edge> exits = get_loop_exit_edges (loop);
    3118                 :     240795 :   edge ex;
    3119                 :     240795 :   tree niter = NULL_TREE, aniter;
    3120                 :            : 
    3121                 :     240795 :   *exit = NULL;
    3122                 :            : 
    3123                 :            :   /* Loops with multiple exits are expensive to handle and less important.  */
    3124                 :     240795 :   if (!flag_expensive_optimizations
    3125                 :     240795 :       && exits.length () > 1)
    3126                 :            :     {
    3127                 :       1810 :       exits.release ();
    3128                 :       1810 :       return chrec_dont_know;
    3129                 :            :     }
    3130                 :            : 
    3131                 :     725605 :   FOR_EACH_VEC_ELT (exits, i, ex)
    3132                 :            :     {
    3133                 :     486620 :       if (!just_once_each_iteration_p (loop, ex->src))
    3134                 :     155103 :         continue;
    3135                 :            : 
    3136                 :     331517 :       aniter = loop_niter_by_eval (loop, ex);
    3137                 :     331517 :       if (chrec_contains_undetermined (aniter))
    3138                 :     329781 :         continue;
    3139                 :            : 
    3140                 :       1787 :       if (niter
    3141                 :       1736 :           && !tree_int_cst_lt (aniter, niter))
    3142                 :         51 :         continue;
    3143                 :            : 
    3144                 :       1685 :       niter = aniter;
    3145                 :       1685 :       *exit = ex;
    3146                 :            :     }
    3147                 :     238985 :   exits.release ();
    3148                 :            : 
    3149                 :     238985 :   return niter ? niter : chrec_dont_know;
    3150                 :            : }
    3151                 :            : 
    3152                 :            : /*
    3153                 :            : 
    3154                 :            :    Analysis of upper bounds on number of iterations of a loop.
    3155                 :            : 
    3156                 :            : */
    3157                 :            : 
    3158                 :            : static widest_int derive_constant_upper_bound_ops (tree, tree,
    3159                 :            :                                                    enum tree_code, tree);
    3160                 :            : 
    3161                 :            : /* Returns a constant upper bound on the value of the right-hand side of
    3162                 :            :    an assignment statement STMT.  */
    3163                 :            : 
    3164                 :            : static widest_int
    3165                 :        391 : derive_constant_upper_bound_assign (gimple *stmt)
    3166                 :            : {
    3167                 :        391 :   enum tree_code code = gimple_assign_rhs_code (stmt);
    3168                 :        391 :   tree op0 = gimple_assign_rhs1 (stmt);
    3169                 :        391 :   tree op1 = gimple_assign_rhs2 (stmt);
    3170                 :            : 
    3171                 :        391 :   return derive_constant_upper_bound_ops (TREE_TYPE (gimple_assign_lhs (stmt)),
    3172                 :        391 :                                           op0, code, op1);
    3173                 :            : }
    3174                 :            : 
    3175                 :            : /* Returns a constant upper bound on the value of expression VAL.  VAL
    3176                 :            :    is considered to be unsigned.  If its type is signed, its value must
    3177                 :            :    be nonnegative.  */
    3178                 :            : 
    3179                 :            : static widest_int
    3180                 :    5750340 : derive_constant_upper_bound (tree val)
    3181                 :            : {
    3182                 :    5750340 :   enum tree_code code;
    3183                 :    5750340 :   tree op0, op1, op2;
    3184                 :            : 
    3185                 :    5750340 :   extract_ops_from_tree (val, &code, &op0, &op1, &op2);
    3186                 :    5750340 :   return derive_constant_upper_bound_ops (TREE_TYPE (val), op0, code, op1);
    3187                 :            : }
    3188                 :            : 
    3189                 :            : /* Returns a constant upper bound on the value of expression OP0 CODE OP1,
    3190                 :            :    whose type is TYPE.  The expression is considered to be unsigned.  If
    3191                 :            :    its type is signed, its value must be nonnegative.  */
    3192                 :            : 
    3193                 :            : static widest_int
    3194                 :    5750730 : derive_constant_upper_bound_ops (tree type, tree op0,
    3195                 :            :                                  enum tree_code code, tree op1)
    3196                 :            : {
    3197                 :    5750730 :   tree subtype, maxt;
    3198                 :    5750730 :   widest_int bnd, max, cst;
    3199                 :    5750730 :   gimple *stmt;
    3200                 :            : 
    3201                 :    5750730 :   if (INTEGRAL_TYPE_P (type))
    3202                 :    5750730 :     maxt = TYPE_MAX_VALUE (type);
    3203                 :            :   else
    3204                 :          0 :     maxt = upper_bound_in_type (type, type);
    3205                 :            : 
    3206                 :    5750730 :   max = wi::to_widest (maxt);
    3207                 :            : 
    3208                 :    5750730 :   switch (code)
    3209                 :            :     {
    3210                 :    5709530 :     case INTEGER_CST:
    3211                 :    5709530 :       return wi::to_widest (op0);
    3212                 :            : 
    3213                 :        995 :     CASE_CONVERT:
    3214                 :        995 :       subtype = TREE_TYPE (op0);
    3215                 :        995 :       if (!TYPE_UNSIGNED (subtype)
    3216                 :            :           /* If TYPE is also signed, the fact that VAL is nonnegative implies
    3217                 :            :              that OP0 is nonnegative.  */
    3218                 :        764 :           && TYPE_UNSIGNED (type)
    3219                 :       1759 :           && !tree_expr_nonnegative_p (op0))
    3220                 :            :         {
    3221                 :            :           /* If we cannot prove that the casted expression is nonnegative,
    3222                 :            :              we cannot establish more useful upper bound than the precision
    3223                 :            :              of the type gives us.  */
    3224                 :        747 :           return max;
    3225                 :            :         }
    3226                 :            : 
    3227                 :            :       /* We now know that op0 is an nonnegative value.  Try deriving an upper
    3228                 :            :          bound for it.  */
    3229                 :        248 :       bnd = derive_constant_upper_bound (op0);
    3230                 :            : 
    3231                 :            :       /* If the bound does not fit in TYPE, max. value of TYPE could be
    3232                 :            :          attained.  */
    3233                 :        248 :       if (wi::ltu_p (max, bnd))
    3234                 :          0 :         return max;
    3235                 :            : 
    3236                 :        248 :       return bnd;
    3237                 :            : 
    3238                 :      30175 :     case PLUS_EXPR:
    3239                 :      30175 :     case POINTER_PLUS_EXPR:
    3240                 :      30175 :     case MINUS_EXPR:
    3241                 :      30175 :       if (TREE_CODE (op1) != INTEGER_CST
    3242                 :      30175 :           || !tree_expr_nonnegative_p (op0))
    3243                 :      29872 :         return max;
    3244                 :            : 
    3245                 :            :       /* Canonicalize to OP0 - CST.  Consider CST to be signed, in order to
    3246                 :            :          choose the most logical way how to treat this constant regardless
    3247                 :            :          of the signedness of the type.  */
    3248                 :        303 :       cst = wi::sext (wi::to_widest (op1), TYPE_PRECISION (type));
    3249                 :        303 :       if (code != MINUS_EXPR)
    3250                 :        303 :         cst = -cst;
    3251                 :            : 
    3252                 :        303 :       bnd = derive_constant_upper_bound (op0);
    3253                 :            : 
    3254                 :        303 :       if (wi::neg_p (cst))
    3255                 :            :         {
    3256                 :          0 :           cst = -cst;
    3257                 :            :           /* Avoid CST == 0x80000...  */
    3258                 :          0 :           if (wi::neg_p (cst))
    3259                 :          0 :             return max;
    3260                 :            : 
    3261                 :            :           /* OP0 + CST.  We need to check that
    3262                 :            :              BND <= MAX (type) - CST.  */
    3263                 :            : 
    3264                 :          0 :           widest_int mmax = max - cst;
    3265                 :          0 :           if (wi::leu_p (bnd, mmax))
    3266                 :          0 :             return max;
    3267                 :            : 
    3268                 :          0 :           return bnd + cst;
    3269                 :            :         }
    3270                 :            :       else
    3271                 :            :         {
    3272                 :            :           /* OP0 - CST, where CST >= 0.
    3273                 :            : 
    3274                 :            :              If TYPE is signed, we have already verified that OP0 >= 0, and we
    3275                 :            :              know that the result is nonnegative.  This implies that
    3276                 :            :              VAL <= BND - CST.
    3277                 :            : 
    3278                 :            :              If TYPE is unsigned, we must additionally know that OP0 >= CST,
    3279                 :            :              otherwise the operation underflows.
    3280                 :            :            */
    3281                 :            : 
    3282                 :            :           /* This should only happen if the type is unsigned; however, for
    3283                 :            :              buggy programs that use overflowing signed arithmetics even with
    3284                 :            :              -fno-wrapv, this condition may also be true for signed values.  */
    3285                 :        303 :           if (wi::ltu_p (bnd, cst))
    3286                 :          0 :             return max;
    3287                 :            : 
    3288                 :        303 :           if (TYPE_UNSIGNED (type))
    3289                 :            :             {
    3290                 :        303 :               tree tem = fold_binary (GE_EXPR, boolean_type_node, op0,
    3291                 :            :                                       wide_int_to_tree (type, cst));
    3292                 :        303 :               if (!tem || integer_nonzerop (tem))
    3293                 :          0 :                 return max;
    3294                 :            :             }
    3295                 :            : 
    3296                 :        303 :           bnd -= cst;
    3297                 :            :         }
    3298                 :            : 
    3299                 :        303 :       return bnd;
    3300                 :            : 
    3301                 :          0 :     case FLOOR_DIV_EXPR:
    3302                 :          0 :     case EXACT_DIV_EXPR:
    3303                 :          0 :       if (TREE_CODE (op1) != INTEGER_CST
    3304                 :          0 :           || tree_int_cst_sign_bit (op1))
    3305                 :          0 :         return max;
    3306                 :            : 
    3307                 :          0 :       bnd = derive_constant_upper_bound (op0);
    3308                 :          0 :       return wi::udiv_floor (bnd, wi::to_widest (op1));
    3309                 :            : 
    3310                 :          0 :     case BIT_AND_EXPR:
    3311                 :          0 :       if (TREE_CODE (op1) != INTEGER_CST
    3312                 :          0 :           || tree_int_cst_sign_bit (op1))
    3313                 :          0 :         return max;
    3314                 :          0 :       return wi::to_widest (op1);
    3315                 :            : 
    3316                 :        463 :     case SSA_NAME:
    3317                 :        463 :       stmt = SSA_NAME_DEF_STMT (op0);
    3318                 :        463 :       if (gimple_code (stmt) != GIMPLE_ASSIGN
    3319                 :        463 :           || gimple_assign_lhs (stmt) != op0)
    3320                 :         72 :         return max;
    3321                 :        391 :       return derive_constant_upper_bound_assign (stmt);
    3322                 :            : 
    3323                 :       9569 :     default:
    3324                 :       9569 :       return max;
    3325                 :            :     }
    3326                 :            : }
    3327                 :            : 
    3328                 :            : /* Emit a -Waggressive-loop-optimizations warning if needed.  */
    3329                 :            : 
    3330                 :            : static void
    3331                 :    5259890 : do_warn_aggressive_loop_optimizations (class loop *loop,
    3332                 :            :                                        widest_int i_bound, gimple *stmt)
    3333                 :            : {
    3334                 :            :   /* Don't warn if the loop doesn't have known constant bound.  */
    3335                 :    5259890 :   if (!loop->nb_iterations
    3336                 :    5259890 :       || TREE_CODE (loop->nb_iterations) != INTEGER_CST
    3337                 :    1908450 :       || !warn_aggressive_loop_optimizations
    3338                 :            :       /* To avoid warning multiple times for the same loop,
    3339                 :            :          only start warning when we preserve loops.  */
    3340                 :    1908370 :       || (cfun->curr_properties & PROP_loops) == 0
    3341                 :            :       /* Only warn once per loop.  */
    3342                 :    1908370 :       || loop->warned_aggressive_loop_optimizations
    3343                 :            :       /* Only warn if undefined behavior gives us lower estimate than the
    3344                 :            :          known constant bound.  */
    3345                 :    1907910 :       || wi::cmpu (i_bound, wi::to_widest (loop->nb_iterations)) >= 0
    3346                 :            :       /* And undefined behavior happens unconditionally.  */
    3347                 :    5259920 :       || !dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (stmt)))
    3348                 :    5259860 :     return;
    3349                 :            : 
    3350                 :         31 :   edge e = single_exit (loop);
    3351                 :         31 :   if (e == NULL)
    3352                 :            :     return;
    3353                 :            : 
    3354                 :         31 :   gimple *estmt = last_stmt (e->src);
    3355                 :         31 :   char buf[WIDE_INT_PRINT_BUFFER_SIZE];
    3356                 :         31 :   print_dec (i_bound, buf, TYPE_UNSIGNED (TREE_TYPE (loop->nb_iterations))
    3357                 :         31 :              ? UNSIGNED : SIGNED);
    3358                 :         31 :   auto_diagnostic_group d;
    3359                 :         31 :   if (warning_at (gimple_location (stmt), OPT_Waggressive_loop_optimizations,
    3360                 :            :                   "iteration %s invokes undefined behavior", buf))
    3361                 :          9 :     inform (gimple_location (estmt), "within this loop");
    3362                 :         31 :   loop->warned_aggressive_loop_optimizations = true;
    3363                 :            : }
    3364                 :            : 
    3365                 :            : /* Records that AT_STMT is executed at most BOUND + 1 times in LOOP.  IS_EXIT
    3366                 :            :    is true if the loop is exited immediately after STMT, and this exit
    3367                 :            :    is taken at last when the STMT is executed BOUND + 1 times.
    3368                 :            :    REALISTIC is true if BOUND is expected to be close to the real number
    3369                 :            :    of iterations.  UPPER is true if we are sure the loop iterates at most
    3370                 :            :    BOUND times.  I_BOUND is a widest_int upper estimate on BOUND.  */
    3371                 :            : 
    3372                 :            : static void
    3373                 :    8073970 : record_estimate (class loop *loop, tree bound, const widest_int &i_bound,
    3374                 :            :                  gimple *at_stmt, bool is_exit, bool realistic, bool upper)
    3375                 :            : {
    3376                 :    8073970 :   widest_int delta;
    3377                 :            : 
    3378                 :    8073970 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3379                 :            :     {
    3380                 :      71990 :       fprintf (dump_file, "Statement %s", is_exit ? "(exit)" : "");
    3381                 :      39776 :       print_gimple_stmt (dump_file, at_stmt, 0, TDF_SLIM);
    3382                 :      40277 :       fprintf (dump_file, " is %sexecuted at most ",
    3383                 :            :                upper ? "" : "probably ");
    3384                 :      39776 :       print_generic_expr (dump_file, bound, TDF_SLIM);
    3385                 :      39776 :       fprintf (dump_file, " (bounded by ");
    3386                 :      39776 :       print_decu (i_bound, dump_file);
    3387                 :      39776 :       fprintf (dump_file, ") + 1 times in loop %d.\n", loop->num);
    3388                 :            :     }
    3389                 :            : 
    3390                 :            :   /* If the I_BOUND is just an estimate of BOUND, it rarely is close to the
    3391                 :            :      real number of iterations.  */
    3392                 :    8073970 :   if (TREE_CODE (bound) != INTEGER_CST)
    3393                 :            :     realistic = false;
    3394                 :            :   else
    3395                 :    6963450 :     gcc_checking_assert (i_bound == wi::to_widest (bound));
    3396                 :            : 
    3397                 :            :   /* If we have a guaranteed upper bound, record it in the appropriate
    3398                 :            :      list, unless this is an !is_exit bound (i.e. undefined behavior in
    3399                 :            :      at_stmt) in a loop with known constant number of iterations.  */
    3400                 :    8073970 :   if (upper
    3401                 :    7844140 :       && (is_exit
    3402                 :    5519970 :           || loop->nb_iterations == NULL_TREE
    3403                 :    5519970 :           || TREE_CODE (loop->nb_iterations) != INTEGER_CST))
    3404                 :            :     {
    3405                 :    5806810 :       class nb_iter_bound *elt = ggc_alloc<nb_iter_bound> ();
    3406                 :            : 
    3407                 :    5806810 :       elt->bound = i_bound;
    3408                 :    5806810 :       elt->stmt = at_stmt;
    3409                 :    5806810 :       elt->is_exit = is_exit;
    3410                 :    5806810 :       elt->next = loop->bounds;
    3411                 :    5806810 :       loop->bounds = elt;
    3412                 :            :     }
    3413                 :            : 
    3414                 :            :   /* If statement is executed on every path to the loop latch, we can directly
    3415                 :            :      infer the upper bound on the # of iterations of the loop.  */
    3416                 :    8073970 :   if (!dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (at_stmt)))
    3417                 :     293914 :     upper = false;
    3418                 :            : 
    3419                 :            :   /* Update the number of iteration estimates according to the bound.
    3420                 :            :      If at_stmt is an exit then the loop latch is executed at most BOUND times,
    3421                 :            :      otherwise it can be executed BOUND + 1 times.  We will lower the estimate
    3422                 :            :      later if such statement must be executed on last iteration  */
    3423                 :    8073970 :   if (is_exit)
    3424                 :    2324180 :     delta = 0;
    3425                 :            :   else
    3426                 :    5749790 :     delta = 1;
    3427                 :    8073970 :   widest_int new_i_bound = i_bound + delta;
    3428                 :            : 
    3429                 :            :   /* If an overflow occurred, ignore the result.  */
    3430                 :    8073970 :   if (wi::ltu_p (new_i_bound, delta))
    3431                 :          0 :     return;
    3432                 :            : 
    3433                 :    8073970 :   if (upper && !is_exit)
    3434                 :    5259890 :     do_warn_aggressive_loop_optimizations (loop, new_i_bound, at_stmt);
    3435                 :    8073970 :   record_niter_bound (loop, new_i_bound, realistic, upper);
    3436                 :            : }
    3437                 :            : 
    3438                 :            : /* Records the control iv analyzed in NITER for LOOP if the iv is valid
    3439                 :            :    and doesn't overflow.  */
    3440                 :            : 
    3441                 :            : static void
    3442                 :    2324170 : record_control_iv (class loop *loop, class tree_niter_desc *niter)
    3443                 :            : {
    3444                 :    2324170 :   struct control_iv *iv;
    3445                 :            : 
    3446                 :    2324170 :   if (!niter->control.base || !niter->control.step)
    3447                 :            :     return;
    3448                 :            : 
    3449                 :    2316110 :   if (!integer_onep (niter->assumptions) || !niter->control.no_overflow)
    3450                 :            :     return;
    3451                 :            : 
    3452                 :    2247760 :   iv = ggc_alloc<control_iv> ();
    3453                 :    2247760 :   iv->base = niter->control.base;
    3454                 :    2247760 :   iv->step = niter->control.step;
    3455                 :    2247760 :   iv->next = loop->control_ivs;
    3456                 :    2247760 :   loop->control_ivs = iv;
    3457                 :            : 
    3458                 :    2247760 :   return;
    3459                 :            : }
    3460                 :            : 
    3461                 :            : /* This function returns TRUE if below conditions are satisfied:
    3462                 :            :      1) VAR is SSA variable.
    3463                 :            :      2) VAR is an IV:{base, step} in its defining loop.
    3464                 :            :      3) IV doesn't overflow.
    3465                 :            :      4) Both base and step are integer constants.
    3466                 :            :      5) Base is the MIN/MAX value depends on IS_MIN.
    3467                 :            :    Store value of base to INIT correspondingly.  */
    3468                 :            : 
    3469                 :            : static bool
    3470                 :      63702 : get_cst_init_from_scev (tree var, wide_int *init, bool is_min)
    3471                 :            : {
    3472                 :      63702 :   if (TREE_CODE (var) != SSA_NAME)
    3473                 :            :     return false;
    3474                 :            : 
    3475                 :      63702 :   gimple *def_stmt = SSA_NAME_DEF_STMT (var);
    3476                 :      63702 :   class loop *loop = loop_containing_stmt (def_stmt);
    3477                 :            : 
    3478                 :      56567 :   if (loop == NULL)
    3479                 :            :     return false;
    3480                 :            : 
    3481                 :      56567 :   affine_iv iv;
    3482                 :      56567 :   if (!simple_iv (loop, loop, var, &iv, false))
    3483                 :            :     return false;
    3484                 :            : 
    3485                 :       9140 :   if (!iv.no_overflow)
    3486                 :            :     return false;
    3487                 :            : 
    3488                 :       9058 :   if (TREE_CODE (iv.base) != INTEGER_CST || TREE_CODE (iv.step) != INTEGER_CST)
    3489                 :            :     return false;
    3490                 :            : 
    3491                 :       7008 :   if (is_min == tree_int_cst_sign_bit (iv.step))
    3492                 :            :     return false;
    3493                 :            : 
    3494                 :       6679 :   *init = wi::to_wide (iv.base);
    3495                 :       6679 :   return true;
    3496                 :            : }
    3497                 :            : 
    3498                 :            : /* Record the estimate on number of iterations of LOOP based on the fact that
    3499                 :            :    the induction variable BASE + STEP * i evaluated in STMT does not wrap and
    3500                 :            :    its values belong to the range <LOW, HIGH>.  REALISTIC is true if the
    3501                 :            :    estimated number of iterations is expected to be close to the real one.
    3502                 :            :    UPPER is true if we are sure the induction variable does not wrap.  */
    3503                 :            : 
    3504                 :            : static void
    3505                 :    5749790 : record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt,
    3506                 :            :                        tree low, tree high, bool realistic, bool upper)
    3507                 :            : {
    3508                 :    5749790 :   tree niter_bound, extreme, delta;
    3509                 :    5749790 :   tree type = TREE_TYPE (base), unsigned_type;
    3510                 :    5749790 :   tree orig_base = base;
    3511                 :            : 
    3512                 :    5749790 :   if (TREE_CODE (step) != INTEGER_CST || integer_zerop (step))
    3513                 :          0 :     return;
    3514                 :            : 
    3515                 :    5749790 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3516                 :            :     {
    3517                 :      32214 :       fprintf (dump_file, "Induction variable (");
    3518                 :      32214 :       print_generic_expr (dump_file, TREE_TYPE (base), TDF_SLIM);
    3519                 :      32214 :       fprintf (dump_file, ") ");
    3520                 :      32214 :       print_generic_expr (dump_file, base, TDF_SLIM);
    3521                 :      32214 :       fprintf (dump_file, " + ");
    3522                 :      32214 :       print_generic_expr (dump_file, step, TDF_SLIM);
    3523                 :      32214 :       fprintf (dump_file, " * iteration does not wrap in statement ");
    3524                 :      32214 :       print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
    3525                 :      32214 :       fprintf (dump_file, " in loop %d.\n", loop->num);
    3526                 :            :     }
    3527                 :            : 
    3528                 :    5749790 :   unsigned_type = unsigned_type_for (type);
    3529                 :    5749790 :   base = fold_convert (unsigned_type, base);
    3530                 :    5749790 :   step = fold_convert (unsigned_type, step);
    3531                 :            : 
    3532                 :    5749790 :   if (tree_int_cst_sign_bit (step))
    3533                 :            :     {
    3534                 :     223243 :       wide_int min, max;
    3535                 :     223243 :       extreme = fold_convert (unsigned_type, low);
    3536                 :     223243 :       if (TREE_CODE (orig_base) == SSA_NAME
    3537                 :      15018 :           && TREE_CODE (high) == INTEGER_CST
    3538                 :      15018 :           && INTEGRAL_TYPE_P (TREE_TYPE (orig_base))
    3539                 :      14952 :           && (get_range_info (orig_base, &min, &max) == VR_RANGE
    3540                 :      11606 :               || get_cst_init_from_scev (orig_base, &max, false))
    3541                 :     226589 :           && wi::gts_p (wi::to_wide (high), max))
    3542                 :       1175 :         base = wide_int_to_tree (unsigned_type, max);
    3543                 :     222068 :       else if (TREE_CODE (base) != INTEGER_CST
    3544                 :     222068 :                && dominated_by_p (CDI_DOMINATORS,
    3545                 :     133235 :                                   loop->latch, gimple_bb (stmt)))
    3546                 :     132146 :         base = fold_convert (unsigned_type, high);
    3547                 :     223243 :       delta = fold_build2 (MINUS_EXPR, unsigned_type, base, extreme);
    3548                 :     223243 :       step = fold_build1 (NEGATE_EXPR, unsigned_type, step);
    3549                 :            :     }
    3550                 :            :   else
    3551                 :            :     {
    3552                 :    5526550 :       wide_int min, max;
    3553                 :    5526550 :       extreme = fold_convert (unsigned_type, high);
    3554                 :    5526550 :       if (TREE_CODE (orig_base) == SSA_NAME
    3555                 :     483958 :           && TREE_CODE (low) == INTEGER_CST
    3556                 :     483958 :           && INTEGRAL_TYPE_P (TREE_TYPE (orig_base))
    3557                 :     170132 :           && (get_range_info (orig_base, &min, &max) == VR_RANGE
    3558                 :      52096 :               || get_cst_init_from_scev (orig_base, &min, true))
    3559                 :    5651260 :           && wi::gts_p (min, wi::to_wide (low)))
    3560                 :      13840 :         base = wide_int_to_tree (unsigned_type, min);
    3561                 :    5512710 :       else if (TREE_CODE (base) != INTEGER_CST
    3562                 :    5512710 :                && dominated_by_p (CDI_DOMINATORS,
    3563                 :    1620830 :                                   loop->latch, gimple_bb (stmt)))
    3564                 :    1581660 :         base = fold_convert (unsigned_type, low);
    3565                 :    5526550 :       delta = fold_build2 (MINUS_EXPR, unsigned_type, extreme, base);
    3566                 :            :     }
    3567                 :            : 
    3568                 :            :   /* STMT is executed at most NITER_BOUND + 1 times, since otherwise the value
    3569                 :            :      would get out of the range.  */
    3570                 :    5749790 :   niter_bound = fold_build2 (FLOOR_DIV_EXPR, unsigned_type, delta, step);
    3571                 :    5749790 :   widest_int max = derive_constant_upper_bound (niter_bound);
    3572                 :    5749790 :   record_estimate (loop, niter_bound, max, stmt, false, realistic, upper);
    3573                 :            : }
    3574                 :            : 
    3575                 :            : /* Determine information about number of iterations a LOOP from the index
    3576                 :            :    IDX of a data reference accessed in STMT.  RELIABLE is true if STMT is
    3577                 :            :    guaranteed to be executed in every iteration of LOOP.  Callback for
    3578                 :            :    for_each_index.  */
    3579                 :            : 
    3580                 :            : struct ilb_data
    3581                 :            : {
    3582                 :            :   class loop *loop;
    3583                 :            :   gimple *stmt;
    3584                 :            : };
    3585                 :            : 
    3586                 :            : static bool
    3587                 :   21855900 : idx_infer_loop_bounds (tree base, tree *idx, void *dta)
    3588                 :            : {
    3589                 :   21855900 :   struct ilb_data *data = (struct ilb_data *) dta;
    3590                 :   21855900 :   tree ev, init, step;
    3591                 :   21855900 :   tree low, high, type, next;
    3592                 :   21855900 :   bool sign, upper = true, at_end = false;
    3593                 :   21855900 :   class loop *loop = data->loop;
    3594                 :            : 
    3595                 :   21855900 :   if (TREE_CODE (base) != ARRAY_REF)
    3596                 :            :     return true;
    3597                 :            : 
    3598                 :            :   /* For arrays at the end of the structure, we are not guaranteed that they
    3599                 :            :      do not really extend over their declared size.  However, for arrays of
    3600                 :            :      size greater than one, this is unlikely to be intended.  */
    3601                 :    5797680 :   if (array_at_struct_end_p (base))
    3602                 :            :     {
    3603                 :    1341730 :       at_end = true;
    3604                 :    1341730 :       upper = false;
    3605                 :            :     }
    3606                 :            : 
    3607                 :    5797680 :   class loop *dloop = loop_containing_stmt (data->stmt);
    3608                 :    5797680 :   if (!dloop)
    3609                 :            :     return true;
    3610                 :            : 
    3611                 :    5797680 :   ev = analyze_scalar_evolution (dloop, *idx);
    3612                 :    5797680 :   ev = instantiate_parameters (loop, ev);
    3613                 :    5797680 :   init = initial_condition (ev);
    3614                 :    5797680 :   step = evolution_part_in_loop_num (ev, loop->num);
    3615                 :            : 
    3616                 :    5797680 :   if (!init
    3617                 :    5797680 :       || !step
    3618                 :    3282030 :       || TREE_CODE (step) != INTEGER_CST
    3619                 :    2413510 :       || integer_zerop (step)
    3620                 :    2413510 :       || tree_contains_chrecs (init, NULL)
    3621                 :    8211190 :       || chrec_contains_symbols_defined_in_loop (init, loop->num))
    3622                 :    3384170 :     return true;
    3623                 :            : 
    3624                 :    2413510 :   low = array_ref_low_bound (base);
    3625                 :    2413510 :   high = array_ref_up_bound (base);
    3626                 :            : 
    3627                 :            :   /* The case of nonconstant bounds could be handled, but it would be
    3628                 :            :      complicated.  */
    3629                 :    2413510 :   if (TREE_CODE (low) != INTEGER_CST
    3630                 :    2413510 :       || !high
    3631                 :    1995720 :       || TREE_CODE (high) != INTEGER_CST)
    3632                 :            :     return true;
    3633                 :    1861730 :   sign = tree_int_cst_sign_bit (step);
    3634                 :    1861730 :   type = TREE_TYPE (step);
    3635                 :            : 
    3636                 :            :   /* The array of length 1 at the end of a structure most likely extends
    3637                 :            :      beyond its bounds.  */
    3638                 :    1861730 :   if (at_end
    3639                 :    1861730 :       && operand_equal_p (low, high, 0))
    3640                 :            :     return true;
    3641                 :            : 
    3642                 :            :   /* In case the relevant bound of the array does not fit in type, or
    3643                 :            :      it does, but bound + step (in type) still belongs into the range of the
    3644                 :            :      array, the index may wrap and still stay within the range of the array
    3645                 :            :      (consider e.g. if the array is indexed by the full range of
    3646                 :            :      unsigned char).
    3647                 :            : 
    3648                 :            :      To make things simpler, we require both bounds to fit into type, although
    3649                 :            :      there are cases where this would not be strictly necessary.  */
    3650                 :    1858600 :   if (!int_fits_type_p (high, type)
    3651                 :    1858600 :       || !int_fits_type_p (low, type))
    3652                 :            :     return true;
    3653                 :    1858600 :   low = fold_convert (type, low);
    3654                 :    1858600 :   high = fold_convert (type, high);
    3655                 :            : 
    3656                 :    1858600 :   if (sign)
    3657                 :      27644 :     next = fold_binary (PLUS_EXPR, type, low, step);
    3658                 :            :   else
    3659                 :    1830960 :     next = fold_binary (PLUS_EXPR, type, high, step);
    3660                 :            : 
    3661                 :    1858600 :   if (tree_int_cst_compare (low, next) <= 0
    3662                 :    1858600 :       && tree_int_cst_compare (next, high) <= 0)
    3663                 :            :     return true;
    3664                 :            : 
    3665                 :            :   /* If access is not executed on every iteration, we must ensure that overlow
    3666                 :            :      may not make the access valid later.  */
    3667                 :    1858600 :   if (!dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (data->stmt))
    3668                 :    2146810 :       && scev_probably_wraps_p (NULL_TREE,
    3669                 :     288207 :                                 initial_condition_in_loop_num (ev, loop->num),
    3670                 :            :                                 step, data->stmt, loop, true))
    3671                 :            :     upper = false;
    3672                 :            : 
    3673                 :    1858600 :   record_nonwrapping_iv (loop, init, step, data->stmt, low, high, false, upper);
    3674                 :    1858600 :   return true;
    3675                 :            : }
    3676                 :            : 
    3677                 :            : /* Determine information about number of iterations a LOOP from the bounds
    3678                 :            :    of arrays in the data reference REF accessed in STMT.  RELIABLE is true if
    3679                 :            :    STMT is guaranteed to be executed in every iteration of LOOP.*/
    3680                 :            : 
    3681                 :            : static void
    3682                 :   22816400 : infer_loop_bounds_from_ref (class loop *loop, gimple *stmt, tree ref)
    3683                 :            : {
    3684                 :   22816400 :   struct ilb_data data;
    3685                 :            : 
    3686                 :   22816400 :   data.loop = loop;
    3687                 :   22816400 :   data.stmt = stmt;
    3688                 :          0 :   for_each_index (&ref, idx_infer_loop_bounds, &data);
    3689                 :          0 : }
    3690                 :            : 
    3691                 :            : /* Determine information about number of iterations of a LOOP from the way
    3692                 :            :    arrays are used in STMT.  RELIABLE is true if STMT is guaranteed to be
    3693                 :            :    executed in every iteration of LOOP.  */
    3694                 :            : 
    3695                 :            : static void
    3696                 :  163493000 : infer_loop_bounds_from_array (class loop *loop, gimple *stmt)
    3697                 :            : {
    3698                 :  163493000 :   if (is_gimple_assign (stmt))
    3699                 :            :     {
    3700                 :   66007900 :       tree op0 = gimple_assign_lhs (stmt);
    3701                 :   66007900 :       tree op1 = gimple_assign_rhs1 (stmt);
    3702                 :            : 
    3703                 :            :       /* For each memory access, analyze its access function
    3704                 :            :          and record a bound on the loop iteration domain.  */
    3705                 :   66007900 :       if (REFERENCE_CLASS_P (op0))
    3706                 :    9206010 :         infer_loop_bounds_from_ref (loop, stmt, op0);
    3707                 :            : 
    3708                 :   66007900 :       if (REFERENCE_CLASS_P (op1))
    3709                 :   13481800 :         infer_loop_bounds_from_ref (loop, stmt, op1);
    3710                 :            :     }
    3711                 :   97484800 :   else if (is_gimple_call (stmt))
    3712                 :            :     {
    3713                 :    4994160 :       tree arg, lhs;
    3714                 :    4994160 :       unsigned i, n = gimple_call_num_args (stmt);
    3715                 :            : 
    3716                 :    4994160 :       lhs = gimple_call_lhs (stmt);
    3717                 :    4994160 :       if (lhs && REFERENCE_CLASS_P (lhs))
    3718                 :       1851 :         infer_loop_bounds_from_ref (loop, stmt, lhs);
    3719                 :            : 
    3720                 :   15843300 :       for (i = 0; i < n; i++)
    3721                 :            :         {
    3722                 :   10849200 :           arg = gimple_call_arg (stmt, i);
    3723                 :   10849200 :           if (REFERENCE_CLASS_P (arg))
    3724                 :     126760 :             infer_loop_bounds_from_ref (loop, stmt, arg);
    3725                 :            :         }
    3726                 :            :     }
    3727                 :  163493000 : }
    3728                 :            : 
    3729                 :            : /* Determine information about number of iterations of a LOOP from the fact
    3730                 :            :    that pointer arithmetics in STMT does not overflow.  */
    3731                 :            : 
    3732                 :            : static void
    3733                 :   80225400 : infer_loop_bounds_from_pointer_arith (class loop *loop, gimple *stmt)
    3734                 :            : {
    3735                 :   80225400 :   tree def, base, step, scev, type, low, high;
    3736                 :   80225400 :   tree var, ptr;
    3737                 :            : 
    3738                 :   80225400 :   if (!is_gimple_assign (stmt)
    3739                 :   80225400 :       || gimple_assign_rhs_code (stmt) != POINTER_PLUS_EXPR)
    3740                 :            :     return;
    3741                 :            : 
    3742                 :    2936670 :   def = gimple_assign_lhs (stmt);
    3743                 :    2936670 :   if (TREE_CODE (def) != SSA_NAME)
    3744                 :            :     return;
    3745                 :            : 
    3746                 :    2936670 :   type = TREE_TYPE (def);
    3747                 :    2936670 :   if (!nowrap_type_p (type))
    3748                 :            :     return;
    3749                 :            : 
    3750                 :    2936670 :   ptr = gimple_assign_rhs1 (stmt);
    3751                 :    2936670 :   if (!expr_invariant_in_loop_p (loop, ptr))
    3752                 :            :     return;
    3753                 :            : 
    3754                 :     990691 :   var = gimple_assign_rhs2 (stmt);
    3755                 :     990691 :   if (TYPE_PRECISION (type) != TYPE_PRECISION (TREE_TYPE (var)))
    3756                 :            :     return;
    3757                 :            : 
    3758                 :     990691 :   class loop *uloop = loop_containing_stmt (stmt);
    3759                 :     990691 :   scev = instantiate_parameters (loop, analyze_scalar_evolution (uloop, def));
    3760                 :     990691 :   if (chrec_contains_undetermined (scev))
    3761                 :            :     return;
    3762                 :            : 
    3763                 :     798715 :   base = initial_condition_in_loop_num (scev, loop->num);
    3764                 :     798715 :   step = evolution_part_in_loop_num (scev, loop->num);
    3765                 :            : 
    3766                 :     798715 :   if (!base || !step
    3767                 :     782536 :       || TREE_CODE (step) != INTEGER_CST
    3768                 :     700445 :       || tree_contains_chrecs (base, NULL)
    3769                 :    1499160 :       || chrec_contains_symbols_defined_in_loop (base, loop->num))
    3770                 :      98270 :     return;
    3771                 :            : 
    3772                 :     700445 :   low = lower_bound_in_type (type, type);
    3773                 :     700445 :   high = upper_bound_in_type (type, type);
    3774                 :            : 
    3775                 :            :   /* In C, pointer arithmetic p + 1 cannot use a NULL pointer, and p - 1 cannot
    3776                 :            :      produce a NULL pointer.  The contrary would mean NULL points to an object,
    3777                 :            :      while NULL is supposed to compare unequal with the address of all objects.
    3778                 :            :      Furthermore, p + 1 cannot produce a NULL pointer and p - 1 cannot use a
    3779                 :            :      NULL pointer since that would mean wrapping, which we assume here not to
    3780                 :            :      happen.  So, we can exclude NULL from the valid range of pointer
    3781                 :            :      arithmetic.  */
    3782                 :     700445 :   if (flag_delete_null_pointer_checks && int_cst_value (low) == 0)
    3783                 :     700445 :     low = build_int_cstu (TREE_TYPE (low), TYPE_ALIGN_UNIT (TREE_TYPE (type)));
    3784                 :            : 
    3785                 :     700445 :   record_nonwrapping_iv (loop, base, step, stmt, low, high, false, true);
    3786                 :            : }
    3787                 :            : 
    3788                 :            : /* Determine information about number of iterations of a LOOP from the fact
    3789                 :            :    that signed arithmetics in STMT does not overflow.  */
    3790                 :            : 
    3791                 :            : static void
    3792                 :   80225400 : infer_loop_bounds_from_signedness (class loop *loop, gimple *stmt)
    3793                 :            : {
    3794                 :   80225400 :   tree def, base, step, scev, type, low, high;
    3795                 :            : 
    3796                 :   80225400 :   if (gimple_code (stmt) != GIMPLE_ASSIGN)
    3797                 :   77034700 :     return;
    3798                 :            : 
    3799                 :   30764000 :   def = gimple_assign_lhs (stmt);
    3800                 :            : 
    3801                 :   30764000 :   if (TREE_CODE (def) != SSA_NAME)
    3802                 :            :     return;
    3803                 :            : 
    3804                 :   26045600 :   type = TREE_TYPE (def);
    3805                 :   26045600 :   if (!INTEGRAL_TYPE_P (type)
    3806                 :   26045600 :       || !TYPE_OVERFLOW_UNDEFINED (type))
    3807                 :            :     return;
    3808                 :            : 
    3809                 :    8512910 :   scev = instantiate_parameters (loop, analyze_scalar_evolution (loop, def));
    3810                 :    8512910 :   if (chrec_contains_undetermined (scev))
    3811                 :            :     return;
    3812                 :            : 
    3813                 :    4060580 :   base = initial_condition_in_loop_num (scev, loop->num);
    3814                 :    4060580 :   step = evolution_part_in_loop_num (scev, loop->num);
    3815                 :            : 
    3816                 :    4060580 :   if (!base || !step
    3817                 :    3552420 :       || TREE_CODE (step) != INTEGER_CST
    3818                 :    3190740 :       || tree_contains_chrecs (base, NULL)
    3819                 :    7251330 :       || chrec_contains_symbols_defined_in_loop (base, loop->num))
    3820                 :     869841 :     return;
    3821                 :            : 
    3822                 :    3190740 :   low = lower_bound_in_type (type, type);
    3823                 :    3190740 :   high = upper_bound_in_type (type, type);
    3824                 :    3190740 :   wide_int minv, maxv;
    3825                 :    3190740 :   if (get_range_info (def, &minv, &maxv) == VR_RANGE)
    3826                 :            :     {
    3827                 :    2442460 :       low = wide_int_to_tree (type, minv);
    3828                 :    2442460 :       high = wide_int_to_tree (type, maxv);
    3829                 :            :     }
    3830                 :            : 
    3831                 :    3190740 :   record_nonwrapping_iv (loop, base, step, stmt, low, high, false, true);
    3832                 :            : }
    3833                 :            : 
    3834                 :            : /* The following analyzers are extracting informations on the bounds
    3835                 :            :    of LOOP from the following undefined behaviors:
    3836                 :            : 
    3837                 :            :    - data references should not access elements over the statically
    3838                 :            :      allocated size,
    3839                 :            : 
    3840                 :            :    - signed variables should not overflow when flag_wrapv is not set.
    3841                 :            : */
    3842                 :            : 
    3843                 :            : static void
    3844                 :    3467500 : infer_loop_bounds_from_undefined (class loop *loop, basic_block *bbs)
    3845                 :            : {
    3846                 :    3467500 :   unsigned i;
    3847                 :    3467500 :   gimple_stmt_iterator bsi;
    3848                 :    3467500 :   basic_block bb;
    3849                 :    3467500 :   bool reliable;
    3850                 :            : 
    3851                 :   26311300 :   for (i = 0; i < loop->num_nodes; i++)
    3852                 :            :     {
    3853                 :   22843800 :       bb = bbs[i];
    3854                 :            : 
    3855                 :            :       /* If BB is not executed in each iteration of the loop, we cannot
    3856                 :            :          use the operations in it to infer reliable upper bound on the
    3857                 :            :          # of iterations of the loop.  However, we can use it as a guess. 
    3858                 :            :          Reliable guesses come only from array bounds.  */
    3859                 :   22843800 :       reliable = dominated_by_p (CDI_DOMINATORS, loop->latch, bb);
    3860                 :            : 
    3861                 :  209180000 :       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
    3862                 :            :         {
    3863                 :  163493000 :           gimple *stmt = gsi_stmt (bsi);
    3864                 :            : 
    3865                 :  163493000 :           infer_loop_bounds_from_array (loop, stmt);
    3866                 :            : 
    3867                 :  163493000 :           if (reliable)
    3868                 :            :             {
    3869                 :   80225400 :               infer_loop_bounds_from_signedness (loop, stmt);
    3870                 :   80225400 :               infer_loop_bounds_from_pointer_arith (loop, stmt);
    3871                 :            :             }
    3872                 :            :         }
    3873                 :            : 
    3874                 :            :     }
    3875                 :    3467500 : }
    3876                 :            : 
    3877                 :            : /* Compare wide ints, callback for qsort.  */
    3878                 :            : 
    3879                 :            : static int
    3880                 :      18547 : wide_int_cmp (const void *p1, const void *p2)
    3881                 :            : {
    3882                 :      18547 :   const widest_int *d1 = (const widest_int *) p1;
    3883                 :      18547 :   const widest_int *d2 = (const widest_int *) p2;
    3884                 :      18547 :   return wi::cmpu (*d1, *d2);
    3885                 :            : }
    3886                 :            : 
    3887                 :            : /* Return index of BOUND in BOUNDS array sorted in increasing order.
    3888                 :            :    Lookup by binary search.  */
    3889                 :            : 
    3890                 :            : static int
    3891                 :       4110 : bound_index (vec<widest_int> bounds, const widest_int &bound)
    3892                 :            : {
    3893                 :       4110 :   unsigned int end = bounds.length ();
    3894                 :            :   unsigned int begin = 0;
    3895                 :            : 
    3896                 :            :   /* Find a matching index by means of a binary search.  */
    3897                 :       4835 :   while (begin != end)
    3898                 :            :     {
    3899                 :       4835 :       unsigned int middle = (begin + end) / 2;
    3900                 :       4835 :       widest_int index = bounds[middle];
    3901                 :            : 
    3902                 :       9670 :       if (index == bound)
    3903                 :       4110 :         return middle;
    3904                 :        725 :       else if (wi::ltu_p (index, bound))
    3905                 :        213 :         begin = middle + 1;
    3906                 :            :       else
    3907                 :            :         end = middle;
    3908                 :            :     }
    3909                 :          0 :   gcc_unreachable ();
    3910                 :            : }
    3911                 :            : 
    3912                 :            : /* We recorded loop bounds only for statements dominating loop latch (and thus
    3913                 :            :    executed each loop iteration).  If there are any bounds on statements not
    3914                 :            :    dominating the loop latch we can improve the estimate by walking the loop
    3915                 :            :    body and seeing if every path from loop header to loop latch contains
    3916                 :            :    some bounded statement.  */
    3917                 :            : 
    3918                 :            : static void
    3919                 :    3503050 : discover_iteration_bound_by_body_walk (class loop *loop)
    3920                 :            : {
    3921                 :    3503050 :   class nb_iter_bound *elt;
    3922                 :    3505250 :   auto_vec<widest_int> bounds;
    3923                 :    3503050 :   vec<vec<basic_block> > queues = vNULL;
    3924                 :    3503050 :   vec<basic_block> queue = vNULL;
    3925                 :    3503050 :   ptrdiff_t queue_index;
    3926                 :    3503050 :   ptrdiff_t latch_index = 0;
    3927                 :            : 
    3928                 :            :   /* Discover what bounds may interest us.  */
    3929                 :    9309860 :   for (elt = loop->bounds; elt; elt = elt->next)
    3930                 :            :     {
    3931                 :    5806810 :       widest_int bound = elt->bound;
    3932                 :            : 
    3933                 :            :       /* Exit terminates loop at given iteration, while non-exits produce undefined
    3934                 :            :          effect on the next iteration.  */
    3935                 :    5806810 :       if (!elt->is_exit)
    3936                 :            :         {
    3937                 :    3482640 :           bound += 1;
    3938                 :            :           /* If an overflow occurred, ignore the result.  */
    3939                 :    3482640 :           if (bound == 0)
    3940                 :          0 :             continue;
    3941                 :            :         }
    3942                 :            : 
    3943                 :    5806810 :       if (!loop->any_upper_bound
    3944                 :    5806810 :           || wi::ltu_p (bound, loop->nb_iterations_upper_bound))
    3945                 :       4110 :         bounds.safe_push (bound);
    3946                 :            :     }
    3947                 :            : 
    3948                 :            :   /* Exit early if there is nothing to do.  */
    3949                 :    3503050 :   if (!bounds.exists ())
    3950                 :    3500860 :     return;
    3951                 :            : 
    3952                 :       2195 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3953                 :         13 :     fprintf (dump_file, " Trying to walk loop body to reduce the bound.\n");
    3954                 :            : 
    3955                 :            :   /* Sort the bounds in decreasing order.  */
    3956                 :       2195 :   bounds.qsort (wide_int_cmp);
    3957                 :            : 
    3958                 :            :   /* For every basic block record the lowest bound that is guaranteed to
    3959                 :            :      terminate the loop.  */
    3960                 :            : 
    3961                 :       4390 :   hash_map<basic_block, ptrdiff_t> bb_bounds;
    3962                 :      11094 :   for (elt = loop->bounds; elt; elt = elt->next)
    3963                 :            :     {
    3964                 :       8899 :       widest_int bound = elt->bound;
    3965                 :       8899 :       if (!elt->is_exit)
    3966                 :            :         {
    3967                 :       6776 :           bound += 1;
    3968                 :            :           /* If an overflow occurred, ignore the result.  */
    3969                 :       6776 :           if (bound == 0)
    3970                 :          0 :             continue;
    3971                 :            :         }
    3972                 :            : 
    3973                 :       8899 :       if (!loop->any_upper_bound
    3974                 :       8899 :           || wi::ltu_p (bound, loop->nb_iterations_upper_bound))
    3975                 :            :         {
    3976                 :       4110 :           ptrdiff_t index = bound_index (bounds, bound);
    3977                 :       4110 :           ptrdiff_t *entry = bb_bounds.get (gimple_bb (elt->stmt));
    3978                 :       4110 :           if (!entry)
    3979                 :       2804 :             bb_bounds.put (gimple_bb (elt->stmt), index);
    3980                 :       1306 :           else if ((ptrdiff_t)*entry > index)
    3981                 :         95 :             *entry = index;
    3982                 :            :         }
    3983                 :            :     }
    3984                 :            : 
    3985                 :       4390 :   hash_map<basic_block, ptrdiff_t> block_priority;
    3986                 :            : 
    3987                 :            :   /* Perform shortest path discovery loop->header ... loop->latch.
    3988                 :            : 
    3989                 :            :      The "distance" is given by the smallest loop bound of basic block
    3990                 :            :      present in the path and we look for path with largest smallest bound
    3991                 :            :      on it.
    3992                 :            : 
    3993                 :            :      To avoid the need for fibonacci heap on double ints we simply compress
    3994                 :            :      double ints into indexes to BOUNDS array and then represent the queue
    3995                 :            :      as arrays of queues for every index.
    3996                 :            :      Index of BOUNDS.length() means that the execution of given BB has
    3997                 :            :      no bounds determined.
    3998                 :            : 
    3999                 :            :      VISITED is a pointer map translating basic block into smallest index
    4000                 :            :      it was inserted into the priority queue with.  */
    4001                 :       2195 :   latch_index = -1;
    4002                 :            : 
    4003                 :            :   /* Start walk in loop header with index set to infinite bound.  */
    4004                 :       2195 :   queue_index = bounds.length ();
    4005                 :       2195 :   queues.safe_grow_cleared (queue_index + 1);
    4006                 :       2195 :   queue.safe_push (loop->header);
    4007                 :       2195 :   queues[queue_index] = queue;
    4008                 :       2195 :   block_priority.put (loop->header, queue_index);
    4009                 :            : 
    4010                 :       8500 :   for (; queue_index >= 0; queue_index--)
    4011                 :            :     {
    4012                 :       6305 :       if (latch_index < queue_index)
    4013                 :            :         {
    4014                 :      22669 :           while (queues[queue_index].length ())
    4015                 :            :             {
    4016                 :      20390 :               basic_block bb;
    4017                 :      20390 :               ptrdiff_t bound_index = queue_index;
    4018                 :      20390 :               edge e;
    4019                 :      20390 :               edge_iterator ei;
    4020                 :            : 
    4021                 :      20390 :               queue = queues[queue_index];
    4022                 :      20390 :               bb = queue.pop ();
    4023                 :            : 
    4024                 :            :               /* OK, we later inserted the BB with lower priority, skip it.  */
    4025                 :      40780 :               if (*block_priority.get (bb) > queue_index)
    4026                 :          0 :                 continue;
    4027                 :            : 
    4028                 :            :               /* See if we can improve the bound.  */
    4029                 :      20390 :               ptrdiff_t *entry = bb_bounds.get (bb);
    4030                 :       2382 :               if (entry && *entry < bound_index)
    4031                 :       2371 :                 bound_index = *entry;
    4032                 :            : 
    4033                 :            :               /* Insert succesors into the queue, watch for latch edge
    4034                 :            :                  and record greatest index we saw.  */
    4035                 :      51531 :               FOR_EACH_EDGE (e, ei, bb->succs)
    4036                 :            :                 {
    4037                 :      31141 :                   bool insert = false;
    4038                 :            : 
    4039                 :      31141 :                   if (loop_exit_edge_p (loop, e))
    4040                 :       4607 :                     continue;
    4041                 :            : 
    4042                 :      26534 :                   if (e == loop_latch_edge (loop)
    4043                 :      26534 :                       && latch_index < bound_index)
    4044                 :            :                     latch_index = bound_index;
    4045                 :      24339 :                   else if (!(entry = block_priority.get (e->dest)))
    4046                 :            :                     {
    4047                 :      19388 :                       insert = true;
    4048                 :      19388 :                       block_priority.put (e->dest, bound_index);
    4049                 :            :                     }
    4050                 :       4951 :                   else if (*entry < bound_index)
    4051                 :            :                     {
    4052                 :         87 :                       insert = true;
    4053                 :         87 :                       *entry = bound_index;
    4054                 :            :                     }
    4055                 :            :                     
    4056                 :      19475 :                   if (insert)
    4057                 :      19475 :                     queues[bound_index].safe_push (e->dest);
    4058                 :            :                 }
    4059                 :            :             }
    4060                 :            :         }
    4061                 :       9545 :       queues[queue_index].release ();
    4062                 :            :     }
    4063                 :            : 
    4064                 :       2195 :   gcc_assert (latch_index >= 0);
    4065                 :       4390 :   if ((unsigned)latch_index < bounds.length ())
    4066                 :            :     {
    4067                 :         44 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4068                 :            :         {
    4069                 :          0 :           fprintf (dump_file, "Found better loop bound ");
    4070                 :          0 :           print_decu (bounds[latch_index], dump_file);
    4071                 :          0 :           fprintf (dump_file, "\n");
    4072                 :            :         }
    4073                 :         44 :       record_niter_bound (loop, bounds[latch_index], false, true);
    4074                 :            :     }
    4075                 :            : 
    4076                 :       4390 :   queues.release ();
    4077                 :            : }
    4078                 :            : 
    4079                 :            : /* See if every path cross the loop goes through a statement that is known
    4080                 :            :    to not execute at the last iteration. In that case we can decrese iteration
    4081                 :            :    count by 1.  */
    4082                 :            : 
    4083                 :            : static void
    4084                 :    3503050 : maybe_lower_iteration_bound (class loop *loop)
    4085                 :            : {
    4086                 :    3503050 :   hash_set<gimple *> *not_executed_last_iteration = NULL;
    4087                 :    3503050 :   class nb_iter_bound *elt;
    4088                 :    3503050 :   bool found_exit = false;
    4089                 :    4198290 :   auto_vec<basic_block> queue;
    4090                 :    3503050 :   bitmap visited;
    4091                 :            : 
    4092                 :            :   /* Collect all statements with interesting (i.e. lower than
    4093                 :            :      nb_iterations_upper_bound) bound on them. 
    4094                 :            : 
    4095                 :            :      TODO: Due to the way record_estimate choose estimates to store, the bounds
    4096                 :            :      will be always nb_iterations_upper_bound-1.  We can change this to record
    4097                 :            :      also statements not dominating the loop latch and update the walk bellow
    4098                 :            :      to the shortest path algorithm.  */
    4099                 :    9309860 :   for (elt = loop->bounds; elt; elt = elt->next)
    4100                 :            :     {
    4101                 :    5806810 :       if (!elt->is_exit
    4102                 :    5806810 :           && wi::ltu_p (elt->bound, loop->nb_iterations_upper_bound))
    4103                 :            :         {
    4104                 :    1225370 :           if (!not_executed_last_iteration)
    4105                 :     695240 :             not_executed_last_iteration = new hash_set<gimple *>;
    4106                 :    1225370 :           not_executed_last_iteration->add (elt->stmt);
    4107                 :            :         }
    4108                 :            :     }
    4109                 :    3503050 :   if (!not_executed_last_iteration)
    4110                 :    2807810 :     return;
    4111                 :            : 
    4112                 :            :   /* Start DFS walk in the loop header and see if we can reach the
    4113                 :            :      loop latch or any of the exits (including statements with side
    4114                 :            :      effects that may terminate the loop otherwise) without visiting
    4115                 :            :      any of the statements known to have undefined effect on the last
    4116                 :            :      iteration.  */
    4117                 :     695240 :   queue.safe_push (loop->header);
    4118                 :     695240 :   visited = BITMAP_ALLOC (NULL);
    4119                 :     695240 :   bitmap_set_bit (visited, loop->header->index);
    4120                 :     695240 :   found_exit = false;
    4121                 :            : 
    4122                 :     835784 :   do
    4123                 :            :     {
    4124                 :     835784 :       basic_block bb = queue.pop ();
    4125                 :     835784 :       gimple_stmt_iterator gsi;
    4126                 :     835784 :       bool stmt_found = false;
    4127                 :            : 
    4128                 :            :       /* Loop for possible exits and statements bounding the execution.  */
    4129                 :    5241260 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    4130                 :            :         {
    4131                 :    3656590 :           gimple *stmt = gsi_stmt (gsi);
    4132                 :    3656590 :           if (not_executed_last_iteration->contains (stmt))
    4133                 :            :             {
    4134                 :            :               stmt_found = true;
    4135                 :      86902 :               break;
    4136                 :            :             }
    4137                 :    3592520 :           if (gimple_has_side_effects (stmt))
    4138                 :            :             {
    4139                 :            :               found_exit = true;
    4140                 :            :               break;
    4141                 :            :             }
    4142                 :            :         }
    4143                 :     835784 :       if (found_exit)
    4144                 :            :         break;
    4145                 :            : 
    4146                 :            :       /* If no bounding statement is found, continue the walk.  */
    4147                 :     812953 :       if (!stmt_found)
    4148                 :            :         {
    4149                 :     748882 :           edge e;
    4150                 :     748882 :           edge_iterator ei;
    4151                 :            : 
    4152                 :    1317960 :           FOR_EACH_EDGE (e, ei, bb->succs)
    4153                 :            :             {
    4154                 :    1182640 :               if (loop_exit_edge_p (loop, e)
    4155                 :    1182640 :                   || e == loop_latch_edge (loop))
    4156                 :            :                 {
    4157                 :            :                   found_exit = true;
    4158                 :            :                   break;
    4159                 :            :                 }
    4160                 :     569083 :               if (bitmap_set_bit (visited, e->dest->index))
    4161                 :     522567 :                 queue.safe_push (e->dest);
    4162                 :            :             }
    4163                 :            :         }
    4164                 :            :     }
    4165                 :     812953 :   while (queue.length () && !found_exit);
    4166                 :            : 
    4167                 :            :   /* If every path through the loop reach bounding statement before exit,
    4168                 :            :      then we know the last iteration of the loop will have undefined effect
    4169                 :            :      and we can decrease number of iterations.  */
    4170                 :            :     
    4171                 :     695240 :   if (!found_exit)
    4172                 :            :     {
    4173                 :      58855 :       if (dump_file && (dump_flags & TDF_DETAILS))
    4174                 :          9 :         fprintf (dump_file, "Reducing loop iteration estimate by 1; "
    4175                 :            :                  "undefined statement must be executed at the last iteration.\n");
    4176                 :      58855 :       record_niter_bound (loop, loop->nb_iterations_upper_bound - 1,
    4177                 :            :                           false, true);
    4178                 :            :     }
    4179                 :            : 
    4180                 :     695240 :   BITMAP_FREE (visited);
    4181                 :     695240 :   delete not_executed_last_iteration;
    4182                 :            : }
    4183                 :            : 
    4184                 :            : /* Get expected upper bound for number of loop iterations for
    4185                 :            :    BUILT_IN_EXPECT_WITH_PROBABILITY for a condition COND.  */
    4186                 :            : 
    4187                 :            : static tree
    4188                 :    2684290 : get_upper_bound_based_on_builtin_expr_with_prob (gcond *cond)
    4189                 :            : {
    4190                 :    2684290 :   if (cond == NULL)
    4191                 :            :     return NULL_TREE;
    4192                 :            : 
    4193                 :    2566250 :   tree lhs = gimple_cond_lhs (cond);
    4194                 :    2566250 :   if (TREE_CODE (lhs) != SSA_NAME)
    4195                 :            :     return NULL_TREE;
    4196                 :            : 
    4197                 :    2555930 :   gimple *stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (cond));
    4198                 :    2555930 :   gcall *def = dyn_cast<gcall *> (stmt);
    4199                 :     108107 :   if (def == NULL)
    4200                 :            :     return NULL_TREE;
    4201                 :            : 
    4202                 :     108107 :   tree decl = gimple_call_fndecl (def);
    4203                 :     108107 :   if (!decl
    4204                 :      87456 :       || !fndecl_built_in_p (decl, BUILT_IN_EXPECT_WITH_PROBABILITY)
    4205                 :     108111 :       || gimple_call_num_args (stmt) != 3)
    4206                 :            :     return NULL_TREE;
    4207                 :            : 
    4208                 :          4 :   tree c = gimple_call_arg (def, 1);
    4209                 :          4 :   tree condt = TREE_TYPE (lhs);
    4210                 :          4 :   tree res = fold_build2 (gimple_cond_code (cond),
    4211                 :            :                           condt, c,
    4212                 :            :                           gimple_cond_rhs (cond));
    4213                 :          4 :   if (TREE_CODE (res) != INTEGER_CST)
    4214                 :            :     return NULL_TREE;
    4215                 :            : 
    4216                 :            : 
    4217                 :          4 :   tree prob = gimple_call_arg (def, 2);
    4218                 :          4 :   tree t = TREE_TYPE (prob);
    4219                 :          4 :   tree one
    4220                 :          8 :     = build_real_from_int_cst (t,
    4221                 :          4 :                                integer_one_node);
    4222                 :          4 :   if (integer_zerop (res))
    4223                 :          0 :     prob = fold_build2 (MINUS_EXPR, t, one, prob);
    4224                 :          4 :   tree r = fold_build2 (RDIV_EXPR, t, one, prob);
    4225                 :          4 :   if (TREE_CODE (r) != REAL_CST)
    4226                 :            :     return NULL_TREE;
    4227                 :            : 
    4228                 :          2 :   HOST_WIDE_INT probi
    4229                 :          2 :     = real_to_integer (TREE_REAL_CST_PTR (r));
    4230                 :          2 :   return build_int_cst (condt, probi);
    4231                 :            : }
    4232                 :            : 
    4233                 :            : /* Records estimates on numbers of iterations of LOOP.  If USE_UNDEFINED_P
    4234                 :            :    is true also use estimates derived from undefined behavior.  */
    4235                 :            : 
    4236                 :            : void
    4237                 :   14495700 : estimate_numbers_of_iterations (class loop *loop)
    4238                 :            : {
    4239                 :   14495700 :   vec<edge> exits;
    4240                 :   14495700 :   tree niter, type;
    4241                 :   14495700 :   unsigned i;
    4242                 :   14495700 :   class tree_niter_desc niter_desc;
    4243                 :   14495700 :   edge ex;
    4244                 :   14495700 :   widest_int bound;
    4245                 :   14495700 :   edge likely_exit;
    4246                 :            : 
    4247                 :            :   /* Give up if we already have tried to compute an estimation.  */
    4248                 :   14495700 :   if (loop->estimate_state != EST_NOT_COMPUTED)
    4249                 :   10992600 :     return;
    4250                 :            : 
    4251                 :    3503050 :   loop->estimate_state = EST_AVAILABLE;
    4252                 :            : 
    4253                 :            :   /* If we have a measured profile, use it to estimate the number of
    4254                 :            :      iterations.  Normally this is recorded by branch_prob right after
    4255                 :            :      reading the profile.  In case we however found a new loop, record the
    4256                 :            :      information here.
    4257                 :            : 
    4258                 :            :      Explicitly check for profile status so we do not report
    4259                 :            :      wrong prediction hitrates for guessed loop iterations heuristics.
    4260                 :            :      Do not recompute already recorded bounds - we ought to be better on
    4261                 :            :      updating iteration bounds than updating profile in general and thus
    4262                 :            :      recomputing iteration bounds later in the compilation process will just
    4263                 :            :      introduce random roundoff errors.  */
    4264                 :    3503050 :   if (!loop->any_estimate
    4265                 :    3503050 :       && loop->header->count.reliable_p ())
    4266                 :            :     {
    4267                 :       9239 :       gcov_type nit = expected_loop_iterations_unbounded (loop);
    4268                 :       9239 :       bound = gcov_type_to_wide_int (nit);
    4269                 :       9239 :       record_niter_bound (loop, bound, true, false);
    4270                 :            :     }
    4271                 :            : 
    4272                 :            :   /* Ensure that loop->nb_iterations is computed if possible.  If it turns out
    4273                 :            :      to be constant, we avoid undefined behavior implied bounds and instead
    4274                 :            :      diagnose those loops with -Waggressive-loop-optimizations.  */
    4275                 :    3503050 :   number_of_latch_executions (loop);
    4276                 :            : 
    4277                 :    3503050 :   basic_block *body = get_loop_body (loop);
    4278                 :    3503050 :   exits = get_loop_exit_edges (loop, body);
    4279                 :    3503050 :   likely_exit = single_likely_exit (loop, exits);
    4280                 :   10535600 :   FOR_EACH_VEC_ELT (exits, i, ex)
    4281                 :            :     {
    4282                 :    7032510 :       if (ex == likely_exit)
    4283                 :            :         {
    4284                 :    2684340 :           gimple *stmt = last_stmt (ex->src);
    4285                 :    2684340 :           if (stmt != NULL)
    4286                 :            :             {
    4287                 :    2684290 :               gcond *cond = dyn_cast<gcond *> (stmt);
    4288                 :    2684290 :               tree niter_bound
    4289                 :    2684290 :                 = get_upper_bound_based_on_builtin_expr_with_prob (cond);
    4290                 :    2684290 :               if (niter_bound != NULL_TREE)
    4291                 :            :                 {
    4292                 :          2 :                   widest_int max = derive_constant_upper_bound (niter_bound);
    4293                 :          2 :                   record_estimate (loop, niter_bound, max, cond,
    4294                 :            :                                    true, true, false);
    4295                 :            :                 }
    4296                 :            :             }
    4297                 :            :         }
    4298                 :            : 
    4299                 :    7032510 :       if (!number_of_iterations_exit (loop, ex, &niter_desc,
    4300                 :            :                                       false, false, body))
    4301                 :    4708340 :         continue;
    4302                 :            : 
    4303                 :    2324170 :       niter = niter_desc.niter;
    4304                 :    2324170 :       type = TREE_TYPE (niter);
    4305                 :    2324170 :       if (TREE_CODE (niter_desc.may_be_zero) != INTEGER_CST)
    4306                 :     451867 :         niter = build3 (COND_EXPR, type, niter_desc.may_be_zero,
    4307                 :     451867 :                         build_int_cst (type, 0),
    4308                 :            :                         niter);
    4309                 :    2324170 :       record_estimate (loop, niter, niter_desc.max,
    4310                 :            :                        last_stmt (ex->src),
    4311                 :            :                        true, ex == likely_exit, true);
    4312                 :    2324170 :       record_control_iv (loop, &niter_desc);
    4313                 :            :     }
    4314                 :    3503050 :   exits.release ();
    4315                 :            : 
    4316                 :    3503050 :   if (flag_aggressive_loop_optimizations)
    4317                 :    3467500 :     infer_loop_bounds_from_undefined (loop, body);
    4318                 :            : 
    4319                 :    3503050 :   discover_iteration_bound_by_body_walk (loop);
    4320                 :            : 
    4321                 :    3503050 :   maybe_lower_iteration_bound (loop);
    4322                 :            : 
    4323                 :            :   /* If we know the exact number of iterations of this loop, try to
    4324                 :            :      not break code with undefined behavior by not recording smaller
    4325                 :            :      maximum number of iterations.  */
    4326                 :    3503050 :   if (loop->nb_iterations
    4327                 :    3503050 :       && TREE_CODE (loop->nb_iterations) == INTEGER_CST)
    4328                 :            :     {
    4329                 :     673400 :       loop->any_upper_bound = true;
    4330                 :     673400 :       loop->nb_iterations_upper_bound = wi::to_widest (loop->nb_iterations);
    4331                 :            :     }
    4332                 :            : }
    4333                 :            : 
    4334                 :            : /* Sets NIT to the estimated number of executions of the latch of the
    4335                 :            :    LOOP.  If CONSERVATIVE is true, we must be sure that NIT is at least as
    4336                 :            :    large as the number of iterations.  If we have no reliable estimate,
    4337                 :            :    the function returns false, otherwise returns true.  */
    4338                 :            : 
    4339                 :            : bool
    4340                 :    5633140 : estimated_loop_iterations (class loop *loop, widest_int *nit)
    4341                 :            : {
    4342                 :            :   /* When SCEV information is available, try to update loop iterations
    4343                 :            :      estimate.  Otherwise just return whatever we recorded earlier.  */
    4344                 :    5633140 :   if (scev_initialized_p ())
    4345                 :    5633140 :     estimate_numbers_of_iterations (loop);
    4346                 :            : 
    4347                 :    5633140 :   return (get_estimated_loop_iterations (loop, nit));
    4348                 :            : }
    4349                 :            : 
    4350                 :            : /* Similar to estimated_loop_iterations, but returns the estimate only
    4351                 :            :    if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
    4352                 :            :    on the number of iterations of LOOP could not be derived, returns -1.  */
    4353                 :            : 
    4354                 :            : HOST_WIDE_INT
    4355                 :    5457410 : estimated_loop_iterations_int (class loop *loop)
    4356                 :            : {
    4357                 :    5457410 :   widest_int nit;
    4358                 :    5457410 :   HOST_WIDE_INT hwi_nit;
    4359                 :            : 
    4360                 :    5457410 :   if (!estimated_loop_iterations (loop, &nit))
    4361                 :            :     return -1;
    4362                 :            : 
    4363                 :    2118240 :   if (!wi::fits_shwi_p (nit))
    4364                 :            :     return -1;
    4365                 :    2118230 :   hwi_nit = nit.to_shwi ();
    4366                 :            : 
    4367                 :    2118230 :   return hwi_nit < 0 ? -1 : hwi_nit;
    4368                 :            : }
    4369                 :            : 
    4370                 :            : 
    4371                 :            : /* Sets NIT to an upper bound for the maximum number of executions of the
    4372                 :            :    latch of the LOOP.  If we have no reliable estimate, the function returns
    4373                 :            :    false, otherwise returns true.  */
    4374                 :            : 
    4375                 :            : bool
    4376                 :    4705500 : max_loop_iterations (class loop *loop, widest_int *nit)
    4377                 :            : {
    4378                 :            :   /* When SCEV information is available, try to update loop iterations
    4379                 :            :      estimate.  Otherwise just return whatever we recorded earlier.  */
    4380                 :    4705500 :   if (scev_initialized_p ())
    4381                 :    4686150 :     estimate_numbers_of_iterations (loop);
    4382                 :            : 
    4383                 :    4705500 :   return get_max_loop_iterations (loop, nit);
    4384                 :            : }
    4385                 :            : 
    4386                 :            : /* Similar to max_loop_iterations, but returns the estimate only
    4387                 :            :    if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
    4388                 :            :    on the number of iterations of LOOP could not be derived, returns -1.  */
    4389                 :            : 
    4390                 :            : HOST_WIDE_INT
    4391                 :    1230070 : max_loop_iterations_int (class loop *loop)
    4392                 :            : {
    4393                 :    1230070 :   widest_int nit;
    4394                 :    1230070 :   HOST_WIDE_INT hwi_nit;
    4395                 :            : 
    4396                 :    1230070 :   if (!max_loop_iterations (loop, &nit))
    4397                 :            :     return -1;
    4398                 :            : 
    4399                 :     874677 :   if (!wi::fits_shwi_p (nit))
    4400                 :            :     return -1;
    4401                 :     832036 :   hwi_nit = nit.to_shwi ();
    4402                 :            : 
    4403                 :     832036 :   return hwi_nit < 0 ? -1 : hwi_nit;
    4404                 :            : }
    4405                 :            : 
    4406                 :            : /* Sets NIT to an likely upper bound for the maximum number of executions of the
    4407                 :            :    latch of the LOOP.  If we have no reliable estimate, the function returns
    4408                 :            :    false, otherwise returns true.  */
    4409                 :            : 
    4410                 :            : bool
    4411                 :     232512 : likely_max_loop_iterations (class loop *loop, widest_int *nit)
    4412                 :            : {
    4413                 :            :   /* When SCEV information is available, try to update loop iterations
    4414                 :            :      estimate.  Otherwise just return whatever we recorded earlier.  */
    4415                 :     232512 :   if (scev_initialized_p ())
    4416                 :     232512 :     estimate_numbers_of_iterations (loop);
    4417                 :            : 
    4418                 :     232512 :   return get_likely_max_loop_iterations (loop, nit);
    4419                 :            : }
    4420                 :            : 
    4421                 :            : /* Similar to max_loop_iterations, but returns the estimate only
    4422                 :            :    if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
    4423                 :            :    on the number of iterations of LOOP could not be derived, returns -1.  */
    4424                 :            : 
    4425                 :            : HOST_WIDE_INT
    4426                 :      56881 : likely_max_loop_iterations_int (class loop *loop)
    4427                 :            : {
    4428                 :      56881 :   widest_int nit;
    4429                 :      56881 :   HOST_WIDE_INT hwi_nit;
    4430                 :            : 
    4431                 :      56881 :   if (!likely_max_loop_iterations (loop, &nit))
    4432                 :            :     return -1;
    4433                 :            : 
    4434                 :      42968 :   if (!wi::fits_shwi_p (nit))
    4435                 :            :     return -1;
    4436                 :      38710 :   hwi_nit = nit.to_shwi ();
    4437                 :            : 
    4438                 :      38710 :   return hwi_nit < 0 ? -1 : hwi_nit;
    4439                 :            : }
    4440                 :            : 
    4441                 :            : /* Returns an estimate for the number of executions of statements
    4442                 :            :    in the LOOP.  For statements before the loop exit, this exceeds
    4443                 :            :    the number of execution of the latch by one.  */
    4444                 :            : 
    4445                 :            : HOST_WIDE_INT
    4446                 :    5375430 : estimated_stmt_executions_int (class loop *loop)
    4447                 :            : {
    4448                 :    5375430 :   HOST_WIDE_INT nit = estimated_loop_iterations_int (loop);
    4449                 :    5375430 :   HOST_WIDE_INT snit;
    4450                 :            : 
    4451                 :    5375430 :   if (nit == -1)
    4452                 :            :     return -1;
    4453                 :            : 
    4454                 :    2093340 :   snit = (HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) nit + 1);
    4455                 :            : 
    4456                 :            :   /* If the computation overflows, return -1.  */
    4457                 :    2093340 :   return snit < 0 ? -1 : snit;
    4458                 :            : }
    4459                 :            : 
    4460                 :            : /* Sets NIT to the maximum number of executions of the latch of the
    4461                 :            :    LOOP, plus one.  If we have no reliable estimate, the function returns
    4462                 :            :    false, otherwise returns true.  */
    4463                 :            : 
    4464                 :            : bool
    4465                 :        118 : max_stmt_executions (class loop *loop, widest_int *nit)
    4466                 :            : {
    4467                 :        118 :   widest_int nit_minus_one;
    4468                 :            : 
    4469                 :        118 :   if (!max_loop_iterations (loop, nit))
    4470                 :            :     return false;
    4471                 :            : 
    4472                 :        118 :   nit_minus_one = *nit;
    4473                 :            : 
    4474                 :        118 :   *nit += 1;
    4475                 :            : 
    4476                 :        118 :   return wi::gtu_p (*nit, nit_minus_one);
    4477                 :            : }
    4478                 :            : 
    4479                 :            : /* Sets NIT to the estimated maximum number of executions of the latch of the
    4480                 :            :    LOOP, plus one.  If we have no likely estimate, the function returns
    4481                 :            :    false, otherwise returns true.  */
    4482                 :            : 
    4483                 :            : bool
    4484                 :     175631 : likely_max_stmt_executions (class loop *loop, widest_int *nit)
    4485                 :            : {
    4486                 :     175631 :   widest_int nit_minus_one;
    4487                 :            : 
    4488                 :     175631 :   if (!likely_max_loop_iterations (loop, nit))
    4489                 :            :     return false;
    4490                 :            : 
    4491                 :      99882 :   nit_minus_one = *nit;
    4492                 :            : 
    4493                 :      99882 :   *nit += 1;
    4494                 :            : 
    4495                 :      99882 :   return wi::gtu_p (*nit, nit_minus_one);
    4496                 :            : }
    4497                 :            : 
    4498                 :            : /* Sets NIT to the estimated number of executions of the latch of the
    4499                 :            :    LOOP, plus one.  If we have no reliable estimate, the function returns
    4500                 :            :    false, otherwise returns true.  */
    4501                 :            : 
    4502                 :            : bool
    4503                 :     175728 : estimated_stmt_executions (class loop *loop, widest_int *nit)
    4504                 :            : {
    4505                 :     175728 :   widest_int nit_minus_one;
    4506                 :            : 
    4507                 :     175728 :   if (!estimated_loop_iterations (loop, nit))
    4508                 :            :     return false;
    4509                 :            : 
    4510                 :         97 :   nit_minus_one = *nit;
    4511                 :            : 
    4512                 :         97 :   *nit += 1;
    4513                 :            : 
    4514                 :         97 :   return wi::gtu_p (*nit, nit_minus_one);
    4515                 :            : }
    4516                 :            : 
    4517                 :            : /* Records estimates on numbers of iterations of loops.  */
    4518                 :            : 
    4519                 :            : void
    4520                 :     796933 : estimate_numbers_of_iterations (function *fn)
    4521                 :            : {
    4522                 :     796933 :   class loop *loop;
    4523                 :            : 
    4524                 :            :   /* We don't want to issue signed overflow warnings while getting
    4525                 :            :      loop iteration estimates.  */
    4526                 :     796933 :   fold_defer_overflow_warnings ();
    4527                 :            : 
    4528                 :    2830640 :   FOR_EACH_LOOP_FN (fn, loop, 0)
    4529                 :    2033710 :     estimate_numbers_of_iterations (loop);
    4530                 :            : 
    4531                 :     796933 :   fold_undefer_and_ignore_overflow_warnings ();
    4532                 :     796933 : }
    4533                 :            : 
    4534                 :            : /* Returns true if statement S1 dominates statement S2.  */
    4535                 :            : 
    4536                 :            : bool
    4537                 :    1722380 : stmt_dominates_stmt_p (gimple *s1, gimple *s2)
    4538                 :            : {
    4539                 :    1722380 :   basic_block bb1 = gimple_bb (s1), bb2 = gimple_bb (s2);
    4540                 :            : 
    4541                 :    1722380 :   if (!bb1
    4542                 :    1722380 :       || s1 == s2)
    4543                 :            :     return true;
    4544                 :            : 
    4545                 :    1719630 :   if (bb1 == bb2)
    4546                 :            :     {
    4547                 :     627655 :       gimple_stmt_iterator bsi;
    4548                 :            : 
    4549                 :     627655 :       if (gimple_code (s2) == GIMPLE_PHI)
    4550                 :            :         return false;
    4551                 :            : 
    4552                 :     508720 :       if (gimple_code (s1) == GIMPLE_PHI)
    4553                 :            :         return true;
    4554                 :            : 
    4555                 :   20449600 :       for (bsi = gsi_start_bb (bb1); gsi_stmt (bsi) != s2; gsi_next (&bsi))
    4556                 :   19693400 :         if (gsi_stmt (bsi) == s1)
    4557                 :            :           return true;
    4558                 :            : 
    4559                 :            :       return false;
    4560                 :            :     }
    4561                 :            : 
    4562                 :    1091980 :   return dominated_by_p (CDI_DOMINATORS, bb2, bb1);
    4563                 :            : }
    4564                 :            : 
    4565                 :            : /* Returns true when we can prove that the number of executions of
    4566                 :            :    STMT in the loop is at most NITER, according to the bound on
    4567                 :            :    the number of executions of the statement NITER_BOUND->stmt recorded in
    4568                 :            :    NITER_BOUND and fact that NITER_BOUND->stmt dominate STMT.
    4569                 :            : 
    4570                 :            :    ??? This code can become quite a CPU hog - we can have many bounds,
    4571                 :            :    and large basic block forcing stmt_dominates_stmt_p to be queried
    4572                 :            :    many times on a large basic blocks, so the whole thing is O(n^2)
    4573                 :            :    for scev_probably_wraps_p invocation (that can be done n times).
    4574                 :            : 
    4575                 :            :    It would make more sense (and give better answers) to remember BB
    4576                 :            :    bounds computed by discover_iteration_bound_by_body_walk.  */
    4577                 :            : 
    4578                 :            : static bool
    4579                 :    1847900 : n_of_executions_at_most (gimple *stmt,
    4580                 :            :                          class nb_iter_bound *niter_bound,
    4581                 :            :                          tree niter)
    4582                 :            : {
    4583                 :    1847900 :   widest_int bound = niter_bound->bound;
    4584                 :    1847900 :   tree nit_type = TREE_TYPE (niter), e;
    4585                 :    1847900 :   enum tree_code cmp;
    4586                 :            : 
    4587                 :    1847900 :   gcc_assert (TYPE_UNSIGNED (nit_type));
    4588                 :            : 
    4589                 :            :   /* If the bound does not even fit into NIT_TYPE, it cannot tell us that
    4590                 :            :      the number of iterations is small.  */
    4591                 :    1847900 :   if (!wi::fits_to_tree_p (bound, nit_type))
    4592                 :            :     return false;
    4593                 :            : 
    4594                 :            :   /* We know that NITER_BOUND->stmt is executed at most NITER_BOUND->bound + 1
    4595                 :            :      times.  This means that:
    4596                 :            : 
    4597                 :            :      -- if NITER_BOUND->is_exit is true, then everything after
    4598                 :            :         it at most NITER_BOUND->bound times.
    4599                 :            : 
    4600                 :            :      -- If NITER_BOUND->is_exit is false, then if we can prove that when STMT
    4601                 :            :         is executed, then NITER_BOUND->stmt is executed as well in the same
    4602                 :            :         iteration then STMT is executed at most NITER_BOUND->bound + 1 times. 
    4603                 :            : 
    4604                 :            :         If we can determine that NITER_BOUND->stmt is always executed
    4605                 :            :         after STMT, then STMT is executed at most NITER_BOUND->bound + 2 times.
    4606                 :            :         We conclude that if both statements belong to the same
    4607                 :            :         basic block and STMT is before NITER_BOUND->stmt and there are no
    4608                 :            :         statements with side effects in between.  */
    4609                 :            : 
    4610                 :    1722380 :   if (niter_bound->is_exit)
    4611                 :            :     {
    4612                 :     405388 :       if (stmt == niter_bound->stmt
    4613                 :     405388 :           || !stmt_dominates_stmt_p (niter_bound->stmt, stmt))
    4614                 :     352546 :         return false;
    4615                 :            :       cmp = GE_EXPR;
    4616                 :            :     }
    4617                 :            :   else
    4618                 :            :     {
    4619                 :    1317000 :       if (!stmt_dominates_stmt_p (niter_bound->stmt, stmt))
    4620                 :            :         {
    4621                 :     461585 :           gimple_stmt_iterator bsi;
    4622                 :     461585 :           if (gimple_bb (stmt) != gimple_bb (niter_bound->stmt)
    4623                 :     227421 :               || gimple_code (stmt) == GIMPLE_PHI
    4624                 :     651125 :               || gimple_code (niter_bound->stmt) == GIMPLE_PHI)
    4625                 :     275891 :             return false;
    4626                 :            : 
    4627                 :            :           /* By stmt_dominates_stmt_p we already know that STMT appears
    4628                 :            :              before NITER_BOUND->STMT.  Still need to test that the loop
    4629                 :            :              cannot be terinated by a side effect in between.  */
    4630                 :    7960620 :           for (bsi = gsi_for_stmt (stmt); gsi_stmt (bsi) != niter_bound->stmt;
    4631                 :    7771080 :                gsi_next (&bsi))
    4632                 :    7771590 :             if (gimple_has_side_effects (gsi_stmt (bsi)))
    4633                 :            :                return false;
    4634                 :     189034 :           bound += 1;
    4635                 :     189034 :           if (bound == 0
    4636                 :     189034 :               || !wi::fits_to_tree_p (bound, nit_type))
    4637                 :       3340 :             return false;
    4638                 :            :         }
    4639                 :            :       cmp = GT_EXPR;
    4640                 :            :     }
    4641                 :            : 
    4642                 :    1093950 :   e = fold_binary (cmp, boolean_type_node,
    4643                 :            :                    niter, wide_int_to_tree (nit_type, bound));
    4644                 :    1093950 :   return e && integer_nonzerop (e);
    4645                 :            : }
    4646                 :            : 
    4647                 :            : /* Returns true if the arithmetics in TYPE can be assumed not to wrap.  */
    4648                 :            : 
    4649                 :            : bool
    4650                 :   44666700 : nowrap_type_p (tree type)
    4651                 :            : {
    4652                 :    6447690 :   if (ANY_INTEGRAL_TYPE_P (type)
    4653                 :   44666700 :       && TYPE_OVERFLOW_UNDEFINED (type))
    4654                 :            :     return true;
    4655                 :            : 
    4656                 :   21128900 :   if (POINTER_TYPE_P (type))
    4657                 :    6447680 :     return true;
    4658                 :            : 
    4659                 :            :   return false;
    4660                 :            : }
    4661                 :            : 
    4662                 :            : /* Return true if we can prove LOOP is exited before evolution of induction
    4663                 :            :    variable {BASE, STEP} overflows with respect to its type bound.  */
    4664                 :            : 
    4665                 :            : static bool
    4666                 :    1910140 : loop_exits_before_overflow (tree base, tree step,
    4667                 :            :                             gimple *at_stmt, class loop *loop)
    4668                 :            : {
    4669                 :    1910140 :   widest_int niter;
    4670                 :    1910140 :   struct control_iv *civ;
    4671                 :    1910140 :   class nb_iter_bound *bound;
    4672                 :    1910140 :   tree e, delta, step_abs, unsigned_base;
    4673                 :    1910140 :   tree type = TREE_TYPE (step);
    4674                 :    1910140 :   tree unsigned_type, valid_niter;
    4675                 :            : 
    4676                 :            :   /* Don't issue signed overflow warnings.  */
    4677                 :    1910140 :   fold_defer_overflow_warnings ();
    4678                 :            : 
    4679                 :            :   /* Compute the number of iterations before we reach the bound of the
    4680                 :            :      type, and verify that the loop is exited before this occurs.  */
    4681                 :    1910140 :   unsigned_type = unsigned_type_for (type);
    4682                 :    1910140 :   unsigned_base = fold_convert (unsigned_type, base);
    4683                 :            : 
    4684                 :    1910140 :   if (tree_int_cst_sign_bit (step))
    4685                 :            :     {
    4686                 :     154190 :       tree extreme = fold_convert (unsigned_type,
    4687                 :            :                                    lower_bound_in_type (type, type));
    4688                 :     154190 :       delta = fold_build2 (MINUS_EXPR, unsigned_type, unsigned_base, extreme);
    4689                 :     154190 :       step_abs = fold_build1 (NEGATE_EXPR, unsigned_type,
    4690                 :            :                               fold_convert (unsigned_type, step));
    4691                 :            :     }
    4692                 :            :   else
    4693                 :            :     {
    4694                 :    1755950 :       tree extreme = fold_convert (unsigned_type,
    4695                 :            :                                    upper_bound_in_type (type, type));
    4696                 :    1755950 :       delta = fold_build2 (MINUS_EXPR, unsigned_type, extreme, unsigned_base);
    4697                 :    1755950 :       step_abs = fold_convert (unsigned_type, step);
    4698                 :            :     }
    4699                 :            : 
    4700                 :    1910140 :   valid_niter = fold_build2 (FLOOR_DIV_EXPR, unsigned_type, delta, step_abs);
    4701                 :            : 
    4702                 :    1910140 :   estimate_numbers_of_iterations (loop);
    4703                 :            : 
    4704                 :    1910140 :   if (max_loop_iterations (loop, &niter)
    4705                 :    1778920 :       && wi::fits_to_tree_p (niter, TREE_TYPE (valid_niter))
    4706                 :    1663030 :       && (e = fold_binary (GT_EXPR, boolean_type_node, valid_niter,
    4707                 :            :                            wide_int_to_tree (TREE_TYPE (valid_niter),
    4708                 :            :                                              niter))) != NULL
    4709                 :    3399180 :       && integer_nonzerop (e))
    4710                 :            :     {
    4711                 :     640267 :       fold_undefer_and_ignore_overflow_warnings ();
    4712                 :     640267 :       return true;
    4713                 :            :     }
    4714                 :    1269870 :   if (at_stmt)
    4715                 :    2503800 :     for (bound = loop->bounds; bound; bound = bound->next)
    4716                 :            :       {
    4717                 :    1847900 :         if (n_of_executions_at_most (at_stmt, bound, valid_niter))
    4718                 :            :           {
    4719                 :       3065 :             fold_undefer_and_ignore_overflow_warnings ();
    4720                 :       3065 :             return true;
    4721                 :            :           }
    4722                 :            :       }
    4723                 :    1266810 :   fold_undefer_and_ignore_overflow_warnings ();
    4724                 :            : 
    4725                 :            :   /* Try to prove loop is exited before {base, step} overflows with the
    4726                 :            :      help of analyzed loop control IV.  This is done only for IVs with
    4727                 :            :      constant step because otherwise we don't have the information.  */
    4728                 :    1266810 :   if (TREE_CODE (step) == INTEGER_CST)
    4729                 :            :     {
    4730                 :    2041560 :       for (civ = loop->control_ivs; civ; civ = civ->next)
    4731                 :            :         {
    4732                 :     824767 :           enum tree_code code;
    4733                 :     824767 :           tree civ_type = TREE_TYPE (civ->step);
    4734                 :            : 
    4735                 :            :           /* Have to consider type difference because operand_equal_p ignores
    4736                 :            :              that for constants.  */
    4737                 :     824767 :           if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (civ_type)
    4738                 :     824767 :               || element_precision (type) != element_precision (civ_type))
    4739                 :     475168 :             continue;
    4740                 :            : 
    4741                 :            :           /* Only consider control IV with same step.  */
    4742                 :     349599 :           if (!operand_equal_p (step, civ->step, 0))
    4743                 :     159249 :             continue;
    4744                 :            : 
    4745                 :            :           /* Done proving if this is a no-overflow control IV.  */
    4746                 :     190350 :           if (operand_equal_p (base, civ->base, 0))
    4747                 :            :             return true;
    4748                 :            : 
    4749                 :            :           /* Control IV is recorded after expanding simple operations,
    4750                 :            :              Here we expand base and compare it too.  */
    4751                 :     155434 :           tree expanded_base = expand_simple_operations (base);
    4752                 :     155434 :           if (operand_equal_p (expanded_base, civ->base, 0))
    4753                 :            :             return true;
    4754                 :            : 
    4755                 :            :           /* If this is a before stepping control IV, in other words, we have
    4756                 :            : 
    4757                 :            :                {civ_base, step} = {base + step, step}
    4758                 :            : 
    4759                 :            :              Because civ {base + step, step} doesn't overflow during loop
    4760                 :            :              iterations, {base, step} will not overflow if we can prove the
    4761                 :            :              operation "base + step" does not overflow.  Specifically, we try
    4762                 :            :              to prove below conditions are satisfied:
    4763                 :            : 
    4764                 :            :                base <= UPPER_BOUND (type) - step  ;;step > 0
    4765                 :            :                base >= LOWER_BOUND (type) - step  ;;step < 0
    4766                 :            : 
    4767                 :            :              by proving the reverse conditions are false using loop's initial
    4768                 :            :              condition.  */
    4769                 :     144671 :           if (POINTER_TYPE_P (TREE_TYPE (base)))
    4770                 :            :             code = POINTER_PLUS_EXPR;
    4771                 :            :           else
    4772                 :            :             code = PLUS_EXPR;
    4773                 :            : 
    4774                 :     144671 :           tree stepped = fold_build2 (code, TREE_TYPE (base), base, step);
    4775                 :     144671 :           tree expanded_stepped = fold_build2 (code, TREE_TYPE (base),
    4776                 :            :                                                expanded_base, step);
    4777                 :     144671 :           if (operand_equal_p (stepped, civ->base, 0)
    4778                 :     144671 :               || operand_equal_p (expanded_stepped, civ->base, 0))
    4779                 :            :             {
    4780                 :      11286 :               tree extreme;
    4781                 :            : 
    4782                 :      11286 :               if (tree_int_cst_sign_bit (step))
    4783                 :            :                 {
    4784                 :       3054 :                   code = LT_EXPR;
    4785                 :       3054 :                   extreme = lower_bound_in_type (type, type);
    4786                 :            :                 }
    4787                 :            :               else
    4788                 :            :                 {
    4789                 :       8232 :                   code = GT_EXPR;
    4790                 :       8232 :                   extreme = upper_bound_in_type (type, type);
    4791                 :            :                 }
    4792                 :      11286 :               extreme = fold_build2 (MINUS_EXPR, type, extreme, step);
    4793                 :      11286 :               e = fold_build2 (code, boolean_type_node, base, extreme);
    4794                 :      11286 :               e = simplify_using_initial_conditions (loop, e);
    4795                 :      11286 :               if (integer_zerop (e))
    4796                 :            :                 return true;
    4797                 :            :             }
    4798                 :            :         }
    4799                 :            :     }
    4800                 :            : 
    4801                 :            :   return false;
    4802                 :            : }
    4803                 :            : 
    4804                 :            : /* VAR is scev variable whose evolution part is constant STEP, this function
    4805                 :            :    proves that VAR can't overflow by using value range info.  If VAR's value
    4806                 :            :    range is [MIN, MAX], it can be proven by:
    4807                 :            :      MAX + step doesn't overflow    ; if step > 0
    4808                 :            :    or
    4809                 :            :      MIN + step doesn't underflow   ; if step < 0.
    4810                 :            : 
    4811                 :            :    We can only do this if var is computed in every loop iteration, i.e, var's
    4812                 :            :    definition has to dominate loop latch.  Consider below example:
    4813                 :            : 
    4814                 :            :      {
    4815                 :            :        unsigned int i;
    4816                 :            : 
    4817                 :            :        <bb 3>:
    4818                 :            : 
    4819                 :            :        <bb 4>:
    4820                 :            :        # RANGE [0, 4294967294] NONZERO 65535
    4821                 :            :        # i_21 = PHI <0(3), i_18(9)>
    4822                 :            :        if (i_21 != 0)
    4823                 :            :          goto <bb 6>;
    4824                 :            :        else
    4825                 :            :          goto <bb 8>;
    4826                 :            : 
    4827                 :            :        <bb 6>:
    4828                 :            :        # RANGE [0, 65533] NONZERO 65535
    4829                 :            :        _6 = i_21 + 4294967295;
    4830                 :            :        # RANGE [0, 65533] NONZERO 65535
    4831                 :            :        _7 = (long unsigned int) _6;
    4832                 :            :        # RANGE [0, 524264] NONZERO 524280
    4833                 :            :        _8 = _7 * 8;
    4834                 :            :        # PT = nonlocal escaped
    4835                 :            :        _9 = a_14 + _8;
    4836                 :            :        *_9 = 0;
    4837                 :            : 
    4838                 :            :        <bb 8>:
    4839                 :            :        # RANGE [1, 65535] NONZERO 65535
    4840                 :            :        i_18 = i_21 + 1;
    4841                 :            :        if (i_18 >= 65535)
    4842                 :            :          goto <bb 10>;
    4843                 :            :        else
    4844                 :            :          goto <bb 9>;
    4845                 :            : 
    4846                 :            :        <bb 9>:
    4847                 :            :        goto <bb 4>;
    4848                 :            : 
    4849                 :            :        <bb 10>:
    4850                 :            :        return;
    4851                 :            :      }
    4852                 :            : 
    4853                 :            :    VAR _6 doesn't overflow only with pre-condition (i_21 != 0), here we
    4854                 :            :    can't use _6 to prove no-overlfow for _7.  In fact, var _7 takes value
    4855                 :            :    sequence (4294967295, 0, 1, ..., 65533) in loop life time, rather than
    4856                 :            :    (4294967295, 4294967296, ...).  */
    4857                 :            : 
    4858                 :            : static bool
    4859                 :     119304 : scev_var_range_cant_overflow (tree var, tree step, class loop *loop)
    4860                 :            : {
    4861                 :     119304 :   tree type;
    4862                 :     119304 :   wide_int minv, maxv, diff, step_wi;
    4863                 :     119304 :   enum value_range_kind rtype;
    4864                 :            : 
    4865                 :     238608 :   if (TREE_CODE (step) != INTEGER_CST || !INTEGRAL_TYPE_P (TREE_TYPE (var)))
    4866                 :            :     return false;
    4867                 :            : 
    4868                 :            :   /* Check if VAR evaluates in every loop iteration.  It's not the case
    4869                 :            :      if VAR is default definition or does not dominate loop's latch.  */
    4870                 :     119304 :   basic_block def_bb = gimple_bb (SSA_NAME_DEF_STMT (var));
    4871                 :     119304 :   if (!def_bb || !dominated_by_p (CDI_DOMINATORS, loop->latch, def_bb))
    4872                 :       3033 :     return false;
    4873                 :            : 
    4874                 :     116271 :   rtype = get_range_info (var, &minv, &maxv);
    4875                 :     116271 :   if (rtype != VR_RANGE)
    4876                 :            :     return false;
    4877                 :            : 
    4878                 :            :   /* VAR is a scev whose evolution part is STEP and value range info
    4879                 :            :      is [MIN, MAX], we can prove its no-overflowness by conditions:
    4880                 :            : 
    4881                 :            :        type_MAX - MAX >= step   ; if step > 0
    4882                 :            :        MIN - type_MIN >= |step| ; if step < 0.
    4883                 :            : 
    4884                 :            :      Or VAR must take value outside of value range, which is not true.  */
    4885                 :      22472 :   step_wi = wi::to_wide (step);
    4886                 :      22472 :   type = TREE_TYPE (var);
    4887                 :      22472 :   if (tree_int_cst_sign_bit (step))
    4888                 :            :     {
    4889                 :       1092 :       diff = minv - wi::to_wide (lower_bound_in_type (type, type));
    4890                 :       1092 :       step_wi = - step_wi;
    4891                 :            :     }
    4892                 :            :   else
    4893                 :      21380 :     diff = wi::to_wide (upper_bound_in_type (type, type)) - maxv;
    4894                 :            : 
    4895                 :      22472 :   return (wi::geu_p (diff, step_wi));
    4896                 :            : }
    4897                 :            : 
    4898                 :            : /* Return false only when the induction variable BASE + STEP * I is
    4899                 :            :    known to not overflow: i.e. when the number of iterations is small
    4900                 :            :    enough with respect to the step and initial condition in order to
    4901                 :            :    keep the evolution confined in TYPEs bounds.  Return true when the
    4902                 :            :    iv is known to overflow or when the property is not computable.
    4903                 :            : 
    4904                 :            :    USE_OVERFLOW_SEMANTICS is true if this function should assume that
    4905                 :            :    the rules for overflow of the given language apply (e.g., that signed
    4906                 :            :    arithmetics in C does not overflow).
    4907                 :            : 
    4908                 :            :    If VAR is a ssa variable, this function also returns false if VAR can
    4909                 :            :    be proven not overflow with value range info.  */
    4910                 :            : 
    4911                 :            : bool
    4912                 :    3693160 : scev_probably_wraps_p (tree var, tree base, tree step,
    4913                 :            :                        gimple *at_stmt, class loop *loop,
    4914                 :            :                        bool use_overflow_semantics)
    4915                 :            : {
    4916                 :            :   /* FIXME: We really need something like
    4917                 :            :      http://gcc.gnu.org/ml/gcc-patches/2005-06/msg02025.html.
    4918                 :            : 
    4919                 :            :      We used to test for the following situation that frequently appears
    4920                 :            :      during address arithmetics:
    4921                 :            : 
    4922                 :            :        D.1621_13 = (long unsigned intD.4) D.1620_12;
    4923                 :            :        D.1622_14 = D.1621_13 * 8;
    4924                 :            :        D.1623_15 = (doubleD.29 *) D.1622_14;
    4925                 :            : 
    4926                 :            :      And derived that the sequence corresponding to D_14
    4927                 :            :      can be proved to not wrap because it is used for computing a
    4928                 :            :      memory access; however, this is not really the case -- for example,
    4929                 :            :      if D_12 = (unsigned char) [254,+,1], then D_14 has values
    4930                 :            :      2032, 2040, 0, 8, ..., but the code is still legal.  */
    4931                 :            : 
    4932                 :    3693160 :   if (chrec_contains_undetermined (base)
    4933                 :    3693160 :       || chrec_contains_undetermined (step))
    4934                 :          0 :     return true;
    4935                 :            : 
    4936                 :    3693160 :   if (integer_zerop (step))
    4937                 :            :     return false;
    4938                 :            : 
    4939                 :            :   /* If we can use the fact that signed and pointer arithmetics does not
    4940                 :            :      wrap, we are done.  */
    4941                 :    6338150 :   if (use_overflow_semantics && nowrap_type_p (TREE_TYPE (base)))
    4942                 :            :     return false;
    4943                 :            : 
    4944                 :            :   /* To be able to use estimates on number of iterations of the loop,
    4945                 :            :      we must have an upper bound on the absolute value of the step.  */
    4946                 :    2206160 :   if (TREE_CODE (step) != INTEGER_CST)
    4947                 :            :     return true;
    4948                 :            : 
    4949                 :            :   /* Check if var can be proven not overflow with value range info.  */
    4950                 :     120194 :   if (var && TREE_CODE (var) == SSA_NAME
    4951                 :    2049170 :       && scev_var_range_cant_overflow (var, step, loop))
    4952                 :            :     return false;
    4953                 :            : 
    4954                 :    1910140 :   if (loop_exits_before_overflow (base, step, at_stmt, loop))
    4955                 :     693346 :     return false;
    4956                 :            : 
    4957                 :            :   /* At this point we still don't have a proof that the iv does not
    4958                 :            :      overflow: give up.  */
    4959                 :            :   return true;
    4960                 :            : }
    4961                 :            : 
    4962                 :            : /* Frees the information on upper bounds on numbers of iterations of LOOP.  */
    4963                 :            : 
    4964                 :            : void
    4965                 :   28590700 : free_numbers_of_iterations_estimates (class loop *loop)
    4966                 :            : {
    4967                 :   28590700 :   struct control_iv *civ;
    4968                 :   28590700 :   class nb_iter_bound *bound;
    4969                 :            : 
    4970                 :   28590700 :   loop->nb_iterations = NULL;
    4971                 :   28590700 :   loop->estimate_state = EST_NOT_COMPUTED;
    4972                 :   34239400 :   for (bound = loop->bounds; bound;)
    4973                 :            :     {
    4974                 :    5648720 :       class nb_iter_bound *next = bound->next;
    4975                 :    5648720 :       ggc_free (bound);
    4976                 :    5648720 :       bound = next;
    4977                 :            :     }
    4978                 :   28590700 :   loop->bounds = NULL;
    4979                 :            : 
    4980                 :   30774500 :   for (civ = loop->control_ivs; civ;)
    4981                 :            :     {
    4982                 :    2183860 :       struct control_iv *next = civ->next;
    4983                 :    2183860 :       ggc_free (civ);
    4984                 :    2183860 :       civ = next;
    4985                 :            :     }
    4986                 :   28590700 :   loop->control_ivs = NULL;
    4987                 :   28590700 : }
    4988                 :            : 
    4989                 :            : /* Frees the information on upper bounds on numbers of iterations of loops.  */
    4990                 :            : 
    4991                 :            : void
    4992                 :   44856000 : free_numbers_of_iterations_estimates (function *fn)
    4993                 :            : {
    4994                 :   44856000 :   class loop *loop;
    4995                 :            : 
    4996                 :   73282600 :   FOR_EACH_LOOP_FN (fn, loop, 0)
    4997                 :   28426500 :     free_numbers_of_iterations_estimates (loop);
    4998                 :   44856000 : }
    4999                 :            : 
    5000                 :            : /* Substitute value VAL for ssa name NAME inside expressions held
    5001                 :            :    at LOOP.  */
    5002                 :            : 
    5003                 :            : void
    5004                 :   17624600 : substitute_in_loop_info (class loop *loop, tree name, tree val)
    5005                 :            : {
    5006                 :   17624600 :   loop->nb_iterations = simplify_replace_tree (loop->nb_iterations, name, val);
    5007                 :   17624600 : }

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.